text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Микрофронтенды: микросервисы для фронтенда
*Можно ли использовать принципы микросервисной архитектуры применительно к фронтенду?*
Популярность микросервисной архитектуры во многом связана с тем, что она позволяет распределять проект между небольшими автономными командами, которые могут действовать независимо друг от друга. К сожалению, по своей природе микросервисы работают только в среде бэкенда. Даже при оптимальной микросервисной архитектуре разработка элементов фронтенд по-прежнему остается в большой степени взаимозависимой, что может замедлить достижение общего результата.
А можно ли взять шаблоны микросервисной архитектуры и применить их к фронтенду? Оказывается, можно. Успешно использовали эту концепцию такие компании, как [Netflix](https://netflixtechblog.com/how-we-build-micro-frontends-with-lattice-22b8635f77ea), Zalando и [Capital One](https://www.capitalone.com/tech/software-engineering/loosely-coupled-micro-frontends-with-nodejs/). Давайте рассмотрим преимущества и недостатки микрофронтендов, а также их отличия от традиционных микросервисов.
Микросервисы во фронтенде
-------------------------
Микросервисный подход применительно к разработке фронтенд дает в результате микрофронтенд. Другими словами, микрофронтенд состоит состоит из компонентов, которые принадлежат разным командам и могут развертываться независимо. Собранные воедино компоненты обеспечивают согласованный пользовательский интерфейс.
Есть разные способы деления монолита. Можно разделить его фронтенд и бэкенд или использовать микросервисы в бэкенде. Еще один вариант — это создание фронтенда в виде набора изолированных компонентов, управляемых разными командами разработчиков.При использовании принципа микрофронтенда нет владельца с исключительными правами на пользовательский интерфейс. Каждая группа разработчиков занимается собственной частью экрана, страницы, контента. Например, в приложении музыкального сервиса одна команда может отвечать за окно поиска, в то время как другая будет кодировать предложения, основанные на вкусах пользователей. Другие команды могут кодировать музыкальный проигрыватель, управлять списками воспроизведения или отображать страницу оплаты. Конечно, все несколько усложняется, но взамен команды получают независимость.
Функции фронтенда контролируются разными командами, развертываются независимо и прозрачно для конечного пользователя внедряются на домашнюю страницу.Преимущества и проблемы микрофронтендов
---------------------------------------
Преимущества у микрофронтендов такие же, как и у микросервисов. А именно, разработку можно масштабировать, разбивая код пользовательского интерфейса на изолированные части для разных команд. Как и в случае с микросервисами, каждая функция может быть выпущена самостоятельно, в любое время, без какой-либо координации. Обновления будут происходить чаще.
### Вертикальные команды
Микрофронтенды позволяют создавать т. н. вертикальные команды. Это означает, что разработчики занимаются созданием как клиентской, так серверной части кода (фронтенд+ бэкенд или фулл стек).
Вертикальные “фуллстековые” команды отвечают за функции или компоненты как фронтенда, так и бэкенда.### Постоянно развертываемые компоненты
Каждая составляющая микрофронтенда представляет собой развертываемый модуль. Это позволяет командам независимо вносить свои изменения на сайте, не дожидаясь общего релиза. В результате интерфейс может меняться несколько раз в день.
Каждая команда может иметь отдельные репозитории, конвейеры непрерывной интеграции и сборки (CI/CD). В качестве альтернативы можно разместить все в монорепозитории и иметь единый общий конвейер CI/CD.Проблемы проектирования микрофронтендов
---------------------------------------
Основной задачей проектирования является создание быстрого и отзывчивого клиента. Всегда следует помнить, что интерфейс фронтенд работает с ограниченными ресурсами (памятью, процессором и сетью), иначе мы рискуем получить медленный пользовательский интерфейс.
Быстрый интерфейс крайне важен для успеха продукта. По результатам некоторых последних опросов: загружающийся за 1 секунду сайт посещают в 3 раза чаще, чем сайт, который загружается за 5 секунд. Как говорится, время — деньги.
В дополнение ко всем проблемам микросервисов микрофронтенды имеют и несколько собственных.
* **Изоляция**. Код каждой команды в конечном итоге должен быть написан в одном браузере. Нужно тщательно изолировать отдельные модули, чтобы избежать конфликтов кода или стиля.
* **Общие ресурсы**. Чтобы избежать дублирования и обеспечить компактность интерфейса, компоненты должны по возможности совместно использовать ресурсы и библиотеки. А это может создать нежелательные связи.
* **Доступность**. Сильная зависимость от JavaScript для рендеринга страницы негативно влияет на доступность.
* **Стиль**. В созданном из компонентов разных команд пользовательском интерфейсе сложнее выдерживать единый стиль. Небольшие стилистические несоответствия могут портить внешний вид.
**Координация**: При таком количестве изменяющихся компонентов API должны быть очень четко реализованными и стабильными. Команды должны согласовывать взаимодействие компонентов друг с другом и с серверными микросервисами.
Принципы построения микрофронтендов
-----------------------------------
Есть два взаимодополняющих метода рендеринга унифицированного пользовательского интерфейса из отдельных компонентов микрофронтенда: рендеринг на стороне сервера и на стороне клиента.
### Server-Side Rendering (SSR)
Рендеринг на стороне сервера обеспечивает более высокую производительность и доступность контента. Это хороший метод быстрой раздачи контента, особенно для таких ограниченных в ресурсах устройств, как недорогие смартфоны. Кроме того, это подходящий резервный режим, когда JavaScript отключен.
Веб-сервер собирает полную страницу из содержимого, предоставляемого различными микросервисами.
Это может быть страница с основным контентом. На нее можно добавить динамический контент.Есть несколько способов формирования SSR:
* [Server Side Includes](https://httpd.apache.org/docs/current/howto/ssi.html) (SSI) — это простой язык сценариев, выполняемый веб-сервером. SSI использует директивы для выстраивания фрагментов HTML в полноценную страницу. Эти фрагменты могут браться из других файлов или откликов программ. SSI поддерживается всеми основными веб-серверами, включая Apache, Nginx и IIS.
* [iframes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) — широкоизвестная функция iframe позволяет встраивать на страницу произвольный HTML-контент.
* [Edge Side Includes](https://www.w3.org/TR/esi-lang/) (ESI) — более современная альтернатива SSI. ESI позволяет обрабатывать переменные, иметь условные обозначения, лучше работает с ошибками. ESI поддерживается такими кэш-серверами HTTP, как [Varnish](http://varnish-cache.org/).
Пример использования SSI для рендеринга страницы из HTML:
```
1
2
3
```
Ключевое слово `virtual` заставляет веб-сервер запрашивать содержимое из URL-адреса или CGI-программы. В нашем случае нужно настроить веб-сервер для ответа на запросы на основе path `/hello-world` с подходящим фрагментом:
```
1 Hello World!
============
```
SSR используется во многих веб-фреймворках для рендеринга главного экрана. Кроме того, есть несколько специфичных для SSR полезных утилит, таких как [compoxure](https://github.com/tes/compoxure), [nodesi](https://www.npmjs.com/package/nodesi) и [tailor](https://github.com/zalando/tailor).
### Client-side Rendering (CSR)
Рендеринг на стороне клиента создает страницу в браузере пользователя, извлекая данные из микросервисов и манипулируя DOM. Для лучшего взаимодействия с пользователем большинство веб-фреймворков используют ту или иную форму CSR.
CSR динамически отображает страницу в браузере пользователя, используя данные из конечных точек.Нашими основными инструментами для написания слабосвязанных компонентов являются пользовательские элементы (Custom Elements). Они являются частью стандарта HTML, позволяют создавать новые HTML-теги, привязывать к ним логику и поведение.
Пользовательские элементы динамически монтируются и демонтируются со страницы с помощью JavaScript:
```
1 // hello-world-component.js
2
3 class HelloWorld extends HTMLElement {
4 connectedCallback() {
5 this.innerHTML = `Hello world
===========
`;
6 }
7 }
8
9 customElements.define('hello-world', HelloWorld);
```
После определения мы можем использовать новый элемент, как и любой другой HTML-тег:
```
1
```
В этом примере полная страница будет содержать тег скрипта для извлечения компонентов JavaScript:
```
1
2
3
4 Microservice Example
5
6
7
8
9
```
Большинство фронтенд-фреймворков можно использовать и для микрофронтендов, а некоторые были разработаны специально для них:
* [Piral](https://piral.io/): реализует изолированные компоненты, называемые *pilets*. Это модули, которые объединяют контент и поведение.
* [Ragu](https://ragu-framework.github.io/#!) — фреймворк фреймворков. Он позволяет встраивать написанный в любом фреймворке код в виде виджетов.
* [Single SPA](https://single-spa.js.org/) — мета-фреймворк для объединения пользовательского интерфейса с использованием любой комбинации интерфейсных фреймворков, включая среди прочих React, Angular и Ember.
* [Frint](https://frint.js.org/) — еще одна модульная платформа для создания приложений на основе компонентов. Интегрируется с React, Vue и Preact.
* [Module Federation](https://webpack.js.org/concepts/module-federation/) — плагин WebPack для создания одностраничных приложений (SPA) путем объединения отдельных сборок. Эти сборки могут разрабатываться независимо друг от друга.
Заключение
----------
Переход на архитектуру микрофронтенда может дать командам разработчиков больше автономии, тем самым ускоряя работу над проектами. Однако микрофронтендам присущи те же самые изъяны, что и микросервисам. Нужен апробированный дизайн, поэтому для новых проектов микрофронтенды не подходят.
Для новых проектов лучше подходят традиционные решения, такие как одностраничные приложения (SPA), которыми управляет одна команда. Только после того, как фронтенд выдержит испытание временем, можно рассматривать микрофронтенды для усовершенствования проекта.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/697994/ | null | ru | null |
# Кеширование в Yii с помощью тегов
Yii позволяет кешировать данные в виде массива возвращаемые прямиком из базы данных.
А у системы кеширования есть разные зависимости. Вот только ни одна из этих зависимостей не позволяет автоматически отслеживать изменения в таблице без обращения к ней же (имею ввиду CDbCacheDependency), что в нагруженных системах бессмысленно.
Для подобных вещей придумали так называемое тегирование. Т.е. создается какой-то тег, который сохраняется со всеми кешами связанными с данной таблицей. И как только он меняется, все связанные кеши должны перезагрузиться. Как оказалось в Yii это делается очень просто.
Стоит упомянуть, что для большего комфорта используется Active Record.
Делается это так. Создаем новую зависимость и сохраняем ее, к примеру в components:
```
/**
* CTagCacheDependency class.
*
* CTagCacheDependency represents a dependency based on a autoincrement(timestamp) of tags
*
* @author Roman
\* @since 1.0
\*/
class CTagCacheDependency extends CCacheDependency
{
/\*\*
\* @var autoincrement(timestamp) param is used to
\* check if the dependency has been changed.
\*/
public $tag;
/\*\*
\* Cache component, by default used - cache
\* @var CCache
\*/
public $cache;
/\*\*
\* Name of cache component, by default used - cache
\* @var string
\*/
public $cacheName;
/\*\*
\* Constructor.
\* @param string $tag value of the tag for module
\*/
public function \_\_construct($tag=null, $cacheName='cache')
{
$this->tag=$tag;
$this->cacheName = $cacheName;
}
/\*\*
\* Generates the data needed to determine if dependency has been changed.
\* This method returns the integer(timestamp).
\* @return mixed the data needed to determine if dependency has been changed.
\*/
protected function generateDependentData()
{
if($this->tag!==null)
{
$this->cache = Yii::app()->getComponent($this->cacheName);
$t = $this->cache->get($this->tag);
if ($t === false) {
$t = microtime(true);
$this->cache->set($this->tag, $t);
}
return $t;
}
}
}
```
В модели указываем, когда мы будем использовать новую зависимость. Поскольку мы хотим это сделать для всей модели добавляем код в функцию **beforeFind**:
```
protected function beforeFind() {
$this->cache(30, new CTagCacheDependency(get_class($this)));
parent::beforeFind();
}
```
Ну или где хотим, главное тут — "$this->cache(30, new CTagCacheDependency(get\_class($this)));"
* 30 — время хранения кеша, но лучше вынести это значение в переменную
* CTagCacheDependency — класс нашей новой зависимости
* get\_class($this) — имя тега — имя модели
В качестве тега у нас выступает просто название класса, модели, связанной с определенной таблицей.
Ну и когда мы удаляем или сохраняем что-то, пишем в нужных местах(в функциях afterDelete, afterSave):
```
Yii::app()->cache->set(get_class($this), microtime(true), 0);
```
* 0 — бесконечное хранение
* get\_class($this) — имя тега — имя модели
* microtime(true) — новое значение тега
Этим самым мы обновляем тег связанный с данной моделью, а соответственно и с таблицей. Теперь, когда тег обновится в следствии обновления таблицы, все кеши с зависимостью от этого тега должны будут обновиться.
Используется кеш по-умолчанию — компонент: cache. Но можно указать другой свой.
Используемая литература:
* <http://www.opennet.ru/base/dev/memcached_tips.txt.html>
**UPD Важный!**
Обновил код класса **CTagCacheDependency**
Теперь конструктор принимает имя Компонента как строку. Например:
```
$this->cache($duration, new CTagCacheDependency(get_class($this), 'cache'));
```
**Сделано из-за некорректной работы с memcache.** | https://habr.com/ru/post/140414/ | null | ru | null |
# Программирование в PHP для командной строки
##### Предисловие
Ubuntu предоставляет в комплекте с пакетом apache2 утилиты для включения\выключения виртуальных хостов и модулей. Однако, создание конфигов для виртуальных хостов отнимают дополнительное время. Поэтому, мне захотелось исправить этот недостаток. Можно было, конечно, сделать автоматические поддомены для апача, но я решил написать скрипт, который создает файлы конфигурации виртуальных хостов для апача, а так же, при необходимости, добавляет имя хоста в файл /etc/hosts. Я не очень хорошо пишу скрипты в bash'e, поэтому решил использовать PHP для моей довольно простой задачи, который я, к тому же, знаю довольно неплохо.
Итак, в этой статье мы сделаем сразу две полезных вещи: ознакомимся с операциями ввода\вывода командной строки в PHP и напишем скрипт, который совсем немного упростит нам жизнь.
##### Проверка прав доступа
Наверное, ни для кого не секрет, что достаточно просто в первой строке PHP скрипта написать
`#!/usr/bin/env php`
и такой скрипт можно будет выполнить как обычную программу в Linux.
Прежде всего, нам нужно проверить, есть ли у нас право на запись в ту самую папку, которая содержит в себе конфиги виртуальных хостов, а обычно для этого нужны root права. Проверить это довольно просто:
> 1. $virtual\_hosts\_dir = "/etc/apache2/sites-available/";
> 2. if (!is\_dir($virtual\_hosts\_dir) || !is\_writable($virtual\_hosts\_dir))
> 3. {
> 4. echo "You must run this script as root!\n";
> 5. exit;
> 6. }
>
##### Получение информации из параметров
Далее, нам необходимо узнать у пользователя некоторую информацию, которая нам нужна для создания конфига. Кроме последовательного ввода из консоли, можно передать эту информацию в качестве параметров, которые мы передаем при вызове скрипта. В PHP есть глобальные переменные $argc и $argv. Первая содержит количество входящих параметров, а вторая — массив со входящими параметрами. По-умолчанию входящий параметр всего один — полный путь к вызываемому скрипту. Таким образом, обработка входящих переменных сводится просто к обработке массива:
> 1. if ($argc>1)
> 2. {
> 3. for ($i=1; $i<$argc; $i++)
> 4. {
> 5. $option = explode("=", $argv[$i]);
> 6. switch ($option[0])
> 7. {
> 8. case "-h":
> 9. case "--add-to-hosts":
> 10. $add\_to\_hosts = true;
> 11. break;
> 12.
> 13. case "-n":
> 14. case "--no-add-to-hosts":
> 15. $add\_to\_hosts = false;
> 16. break;
> 17.
> 18. case "-a":
> 19. case "--server-alias":
> 20. if (isset($option[1]))
> 21. {
> 22. $server\_alias = $option[1];
> 23. }
> 24. else
> 25. {
> 26. echo "Wrong option: {$argv[$i]}\n";
> 27. }
> 28. break;
> 29.
> 30. case "-d":
> 31. case "--document-root":
> 32. if (isset($option[1]))
> 33. {
> 34. if ($option[1] == "default")
> 35. {
> 36. $document\_root = $default\_doc\_root
> 37. }
> 38. else if (is\_dir(dirname($option[1])))
> 39. {
> 40. $document\_root = $option[1];
> 41. }
> 42. }
> 43. else
> 44. {
> 45. echo "Wrong option: {$argv[$i]}\n";
> 46. }
> 47. break;
> 48.
> 49. default:
> 50. if (substr($argv[$i], 1, 1) == '-')
> 51. {
> 52. echo "Unknown option: {$argv[$i]}\n";
> 53. }
> 54. break;
> 55. }
> 56. }
> 57. }
> 58.
>
##### Потоки ввода\вывода
Но не всегда ведь удобно вбивать кучу параметров в консоль. Поэтому теперь мы просим пользователя ввести с клавиатуры то, что нам до сих пор неизвестно. Для этого нам понадобятся потоки ввода\вывода, а в данном случае только ввода. В PHP для работы с потоками ввода\вывода используются константы STDIN, STDOUT, STDERR. По сути, эти потоки ничем не отличаются от файловых потоков и работать с ними так же просто. Например, строка:
> 1. $line = fgets(STDIN);
>
просто считает строку из консоли и запишет её в переменную $line. В данном случае, мы не открывали и не закрывали поток, т.к. PHP делает это автоматически. Но, мы можем открыть поток вручную и держать его открытым столько, сколько нам нужно. Это будет работать быстрее, если Вам нужно считать\записать более одной строки:
> 1. $stdin = fopen("php://stdin", "r");
> 2. $line1 = gets($stdin);
> 3. $line2 = gets($stdin);
> 4. fclose($stdin);
>
В данном случае мы сначала открываем поток, считываем из него две строки и закрываем его.
С записью аналогично, хотя я предпочитаю для вывода на экран просто использовать echo.
Продолжаем писать наш скрипт. Пока у нас нет хоть какой-то строки в качестве имени хоста, продолжаем просить пользователя, чтобы он что-то ввел:
> 1. while (!$server\_alias)
> 2. {
> 3. echo "Enter your hostname: ";
> 4. $server\_alias = trim(fgets(STDIN));
> 5. }
>
Теперь, спросим у пользователя, нужно ли добавлять информацию о этом хосте в /etc/hosts, но спрашиваем только в том случае, если эта информация не была передана в качестве параметра. Так как скрипт я писал себе для повседневной работы, то никаких реальных сайтов у меня не будет и чаще всего нужно будет добавлять хост в /etc/hosts, поэтому если мы ничего не вводим, а просто нажимаем Enter то это принимается как согласие:
> 1. if ($add\_to\_hosts === null)
> 2. {
> 3. echo "Add $server\_alias to your /etc/hosts ? (Y/N) [Y]: ";
> 4. $line = trim(fgets(STDIN));
> 5. if ($line == 'n' || $line == 'N')
> 6. {
> 7. $add\_to\_hosts = false;
> 8. }
> 9. else
> 10. {
> 11. $add\_to\_hosts = true;
> 12. }
> 13. }
>
То же самое и с корневой директорией сайта:
> 1. if (!$document\_root)
> 2. {
> 3. $default\_doc\_root = $default\_doc\_root.'/'.$server\_alias;
> 4. echo "Enter your document root [$default\_doc\_root]: ";
> 5. $line = trim(fgets(STDIN));
> 6. if ($line && is\_dir(dirname($line)))
> 7. {
> 8. $document\_root = $line;
> 9. }
> 10. else
> 11. {
> 12. $document\_root = $default\_doc\_root;
> 13. }
> 14. }
> 15.
>
##### Генерация конфиг-файла
На этом этапе весь сбор информации закончен и у нас есть все, что нужно, для того, чтобы создать конфиг. Надо убедится, что корневая директория сайта существует, а если её нет — создадим её:
> 1. if (!is\_dir($document\_root))
> 2. {
> 3. mkdir($document\_root);
> 4. }
>
Мы спрашивали у пользователя по поводу добавления хоста в /etc/hosts. Сделаем это, если он согласился:
> 1. if ($add\_to\_hosts)
> 2. {
> 3. $hosts = file\_get\_contents("/etc/hosts");
> 4. $hosts .= "127.0.0.1\t$server\_alias\n";
> 5. file\_put\_contents("/etc/hosts", $hosts);
> 6. }
>
Собственно так выглядит шаблон нашего конфига:
> 1. $host\_template = <<
> 2.
> 3. ServerAdmin i@bogus.in
> 4. ServerAlias $server\_alias
> 5.
> 6. DocumentRoot $document\_root
> 7.
> 8. Options Indexes FollowSymLinks MultiViews
> 9. AllowOverride All
> 10. Order allow,deny
> 11. allow from all
> 12.
> 13.
> 14. ErrorLog \${APACHE\_LOG\_DIR}/$server\_alias-error.log;
> 15. LogLevel warn
> 16. CustomLog \${APACHE\_LOG\_DIR}/$server\_alias-access.log combined
> 17.
> 18. HOST;
> 19.
>
Ну и теперь просто запишем конфиг в файл и напомним пользователю о том, что конфиг теперь нужно еще и активировать с помощью a2ensite:
> 1. file\_put\_contents("/etc/apache2/sites-available/$server\_alias", $host\_template);
> 2. echo "Apache config for this hostname created successfully! Don't forget to run a2ensite $server\_alias\n";
> 3.
>
Скрипт написан. Нужно сохранить его в файл и не забыть установить флаг +x, чтобы его можно было запускать как программу:
`chmod +x a2addsite`
##### Использование
Теперь скрипт можно использовать. Можно как вводить всю информацию в консоли:
*% sudo ./a2addsite
Add test.local to your /etc/hosts? (Y/N) [Y]:
Enter your document root [/home/www/test.local]:
Apache config for this hostname created successfully! Don't forget to run a2ensite test.local*
так передавать всю или часть информации скрипту в качестве параметров при вызове:
*% sudo ./a2addsite --server-alias=test2.local --add-to-hosts --document-root=default
Apache config for this hostname created successfully! Don't forget to run a2ensite test2.local*
##### Выводы
PHP можно использовать не только для разработки сайтов, но и для решения мелких локальных задач на компьютере. Скрипт я писал под себя и, наверняка, кто-то из Вас переделает его под свои нужды.
[Исходный код скрипта](http://pastie.org/1477029)
##### Литература
Больше информации о потоках ввода вывода, а также о остальных особенностях работы с консолью в PHP можно получить на официальном сайте PHP (англ.):
[Command line usage](http://www.php.net/manual/en/features.commandline.php)
[PHP input/output](http://php.net/manual/en/wrappers.php.php) | https://habr.com/ru/post/112146/ | null | ru | null |
# Tor Browser без Tor
Tor Browser — сборка из Tor, Firefox и других полезных утилит, заточенная под анонимный серфинг. Трафик пользователя проходит через анонимную сеть Tor, а браузер настроен так, чтобы оставлять на сайтах как можно меньше следов (куки, время, разрешение экрана и ещё [длинный список](https://www.torproject.org/projects/torbrowser/design/#fingerprinting-linkability)).
Так уж получилось, что не всегда есть возможность и необходимость пропускать трафик браузера через Tor, но хочется сохранить защиту от слежки, которую не предоставляет обычный браузер. Такая ситуация может возникать по разным причинам: сайты, блокирующие подключения из Tor (редиски!), плохое подключение к сети, из-за которого жизнь за Tor становится совсем медленной.
Как бы то ни было, была поставлена задача: получить Tor Browser, который бы пускал трафик напрямую. Оказалось, что для этого надо некоторое время покопаться в настройках. Кроме того, время от времени выходят новые версии Tor Browser и весь процесс приходится начинать сначала. Чтобы облегчить жизнь остальным людям, которые столкнулись с той же проблемой, я решил написать эту статью. В конце будет [скрипт](https://github.com/starius/config/blob/master/bin/torless-tbb) командной строки, который делает всё автоматически. Сразу оговорюсь, что тестировал всё только под Linux, однако есть вероятность, что эти инструкции применимы и к другим платформам.
1. [Качаем последний Tor Browser](https://www.torproject.org/download/download-easy.html.en) и распаковываем архив в отдельную папку.
2. Запускаем со стандартными настройками, ждём, пока полностью загрузится.
3. Заходим в Add-ons, отключаем TorLauncher.
4. Нажимаем по «луковице» слева от адресной строки, заходим в Preferences, выбираем Transparent Torification.
Программа будет ругаться, так как трафик идёт не через Tor.
5. Перезапускаем Tor Browser. Программа будет ругаться, так как трафик идёт не через Tor:
Теперь браузером можно пользоваться. Не работает кнопка New Identity, но это не беда — достаточно перезапустить браузер, чтобы он «забыл» всю историю, куки и т. п.
С таким браузером я и жил некоторое время, но сегодня вышла очередная версия 4.0.5 и я было приготовился опять «ковыряться» в настройках и выкорчёвывать Tor. Кроме того, надо дождаться, пока он запустится в первый раз, что может занять немалое время в наших условиях, так как при этом происходит загрузка описаний всех серверов сети Tor. К счастью, мне пришла идея получше — изучить конфиги Tor Browser и решить эту проблему раз и навсегда. Было решено использовать git и сравнивать состояния файлов в папке tor-browser\_en-US до и после «кастрации».
Опытным путём было выявлено, что для достижения вышеописанного эффекта достаточно сделать следующее до первого запуска Tor Browser:
1) удалить файл **Browser/TorBrowser/Data/Browser/profile.default/extensions/tor-launcher@torproject.org.xpi**
2) в файл **Browser/TorBrowser/Data/Browser/profile.default/preferences/extension-overrides.js** дописать следующее:
```
pref("extensions.torbutton.settings_method", "transparent");
pref("extensions.torbutton.use_privoxy", false);
pref("network.proxy.socks_remote_dns", false);
pref("network.proxy.type", 0);
```
Был составлен [скрипт](https://github.com/starius/config/blob/master/bin/torless-tbb), который выполняет эти действия.
Всем анонимного серфинга! | https://habr.com/ru/post/356698/ | null | ru | null |
# Производительность 40G Ethernet с коммутатором на основе Intel ONS
Сегодня доступно приличное количество интерфейсов, каждый из которых претендует на полезность и необходимость. Традиционный Ethernet с 1G, 10G, 40G; InfiniBand FDR 56G и QDR 40G; FibreChannel 8G, 16G, обещанный 32G.
Все обещают счастье и рассказывают про свою крайнюю необходимость и полезность в быту. Как с этим быть, что выбрать и где подводные камни?
**Как тестировали:**
Принимали участие традиционный для всех гигабит, который есть в каждом сервере, 40G Ethernet, QDR и FDR InfiniBand, 10G не стали брать. Сразу надо отметить, что мы считаем FC уходящим интерфейсом, сейчас в тренде конвергенция. 32G пока что недоступен, а 16G вне лиги высокоскоростных решений.
Для выяснения пределов испытания провели на достижение минимальных задержек и максимальной пропускной способности, что удобно сделать с помощью HPC методик, заодно проверили пригодность 40G Ethernet для HPC приложений.
Неоценимую помощь оказали и провели натурные испытания коллеги из [ЦКО](http://compcenter.org/), которым один коммутатор на базе Intel ONS был передан на тестирование.
Кстати, [раздача коммутатора](http://habrahabr.ru/company/etegro/blog/212639/) в самый интересный проект продолжается.
**Аппаратное обеспечение:**
* [Коммутатор с поддержкой 40G Ethernet](http://www.etegro.ru/configurator/network/eos410i)
* Коммуникационный адаптер Mellanox ConnectX-3 VPI adapter card; single-port QSFP; FDR IB (56Gb/s) and 40GigE; PCIe3.0 x8 8GT/s
* Двухпроцессорная система с Intel® Xeon® E5-2680 v2
* OFED-3.5 ([драйвера и низкоуровневые библиотеки](https://www.openfabrics.org) для Mellanox)
* [ConnectX® EN 10 and 40 Gigabit Linux Driver](http://www.mellanox.com)
**Программное обеспечение:**
* Замер производительности проводили с помощью синтетического теста pingpong из набора тестов [Intel MPI Benchmark v3.2.3](http://www.intel.com)
* Версия используемой MPI библиотеки [S-MPI v1.1.1](http://compcenter.org/) – клон Open MPI.
В процессе подготовки выяснился нюанс адаптеров Mellanox — они требуют принудительного перевода в режим Ethernet. Заявленный функционал автоматического определения типа подключенной сети почему-то не работает, может поправят.
Для оценки производительности «традиционно» смотрим на значения времени задержки (latency) при передаче сообщений длиной 4 байта и полосы пропускания при передаче сообщения длиной 4 МБ.
**Начало опытов:**
Используется обычный для Ethernet режим. В нашей терминологии, использовалась tcp фабрика. То есть MPI библиотека использует socket интерфейс для передачи сообщений. Конфигурация драйверов, коммутатора, и MPI по-умолчанию.
В таблице слева результаты для 1G ethernet, справа для 40G (с нашим коммутатором). Видим «провалы» в полосе для сообщений длиной 256К-1М и максимальный результат, подходящий для 10G Ethernet. Очевидно, что нужно настраивать ПО. Задержка, понятное дело, очень велика, но при прохождении через стандартный TCP стек много ожидать и не стоит. Надо отдать должное, в три раза лучше 1G Ethernet.
| | |
| --- | --- |
| `Mpirun –n 2 –debug-mpi 4 –host host01,host02 –nets tcp --mca btl_tcp_if_include eth0 IMB-MPI1 PingPong` | `mpirun -n 2 -debug-mpi 4 -host host01,host02 -nets tcp --mca btl_tcp_if_include eth4 IMB-MPI1 PingPong` |
Кликабельно:
[](https://habrastorage.org/getpro/habr/post_images/6da/1d9/13d/6da1d913d480cd41fbb9c04feb7e5dd7.jpg)
**Продолжаем:**
Обновляем драйвера. Берем [драйвер с сайта Mellanox](http://www.mellanox.com/page/products_dyn?product_family=27).
Для уменьшения «просадки» в диапазоне 256К-1М увеличиваем размер буферов через настройки MPI:
`export S_MPI_BTL_TCP_SNDBUF=2097152
export S_MPI_BTL_TCP_RCVBUF=2097152
mpirun -n 2 -debug-mpi 4 -host host1,host2 -nets tcp --mca btl_tcp_if_include eth4 IMB-MPI1 PingPong`
Кликабельно:
[](https://habrastorage.org/getpro/habr/post_images/2a4/df1/214/2a4df1214beb44107d6ba653fddaf8f5.jpg)
В результате улучшение в полтора раза и уменьшение провалов, но всё равно мало, да еще подросли задержки на малых пакетах.
Конечно же, для улучшения полосы пропускания при применении высокоскоростных Ethernet интерфейсов имеет смысл использовать сверхдлинные Ethernet-кадры (Jumbo frames). Конфигурируем коммутатор и адаптеры на использование MTU 9000, и получаем заметно более высокую полосу пропускания, которая всё равно остается на уровне 20 Гбит/с.
Кликабельно:
[](https://habrastorage.org/getpro/habr/post_images/7fb/4ed/3e5/7fb4ed3e574c9445bf82d650827d588e.jpg)
Опять растет латентность на малых пакетах.
Пробовали другие параметры «покрутить», но принципиальных улучшений не получили. В общем, решили, что «не умеем их готовить».
В какую сторону смотреть?
Безусловно, если искать производительность, то нужно это делать в обход TCP стека. Очевидное решение — попробовать RDMA технологии.
**Суть технологии:**
* Доставка данных непосредственно в окружение пользователя, без переключения контекста приложения между режимами ядра и пользователя.
* Данные от адаптера помещаются сразу в память приложения, без промежуточных буферов.
* Сетевые контроллеры обрабатывают транспортный уровень без привлечения процессора.
Одно из следствий – значительное снижение латентности доступа.
Есть два конкурирующих стандарта, Internet Wide Area RDMA Protocol (iWARP) и RDMA over Converged Ethernet (RoCE), их соревнование и попытки сторонников утопить друг друга достойны отдельного холивара и объемного материала. Картинки приведены для iWARP, но суть общая.
Адаптерами Mellanox поддерживается RDMA over Converged Ethernet (RoCE), используем OFED-3.5.2.
В результате, получили отличные цифры. Задержку 1.9 мкс и полосу 4613.88 Мбайт/с (это 92.2% от пика!) при использовании Jumbo frames. Если размер MTU оставить по умолчанию, то полоса будет ниже, примерно 4300 Мбайт/с.
`mpirun -n 2 -debug-mpi 4 -host host1,host2 --mca btl openib,self --mca btl_openib_cpc_include rdmacm IMB-MPI1`
Кликабельно:
[](https://habrastorage.org/getpro/habr/post_images/137/64b/3ba/13764b3baddadeffef58bb2edcbdff2b.jpg)
Для Pingpong теста время задержки можно улучшить до 1.4 мкс, для этого процессы нужно разместить на CPU «близких» к сетевому адаптеру. Какое практическое значение это имеет в реальной жизни? Ниже небольшая сравнительная табличка Ethernet vs InfiniBand. В принципе, такой «трюк» возможно применить к любому интерконнекту, поэтому в таблице ниже приведен диапазон значений для некоторых сетевых фабрик.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | 1G Ethernet (TCP) | 40G Ethernet (TCP) | 40G Ethernet (RDMA) | InfiniBand QDR | InfiniBand FDR |
| Latency, usec | 24.5 | 7.8 | 1.4-1.9 | 1.5 | 0.86-1.4 |
| Bandwidth, Mbytes/s | 112 | 1126 | 4300-4613 | 3400 | 5300-6000 |
Данные для 40G и FDR плавают в зависимости от близости ядер, на которых исполняются процессы, к ядрам, ответственным за сетевой адаптер, почему-то на QDR этот эффект был почти не виден.
40G Ethernet значительно обогнал IB QDR, но до IB FDR не догнал по абсолютным цифрам, что не удивительно. Однако по эффективности 40G Ethernet лидирует.
Что из этого следует?
Торжество конвергентных Ethernet технологий!
Недаром Microsoft усиленно продвигает возможности SMB Direct, который полагается на RDMA, в NFS поддержка RDMA также встроена.
Для работы с блочным доступом есть технологии iSCSI offload на сетевых контроллерах и протокол iSCSI Extensions for RDMA (iSER), эстеты могут попробовать FCoE :-)
При использовании таких коммутаторов:
Можно построить кучу интересных высокопроизводительных решений.
Например, программно-конфигурируемая СХД наподобие [FS200 G3](http://habrahabr.ru/company/etegro/blog/189520/) с 40G интерфейсом и ферма серверов с 10G адаптерами.
При таком подходе отпадает необходимость строить выделенную сеть для данных, значительно экономя как средства на второй набор коммутаторов, так и время на развертывание решения, ведь кабелей тоже требуется вдвое меньше подключить и проложить.
**Итого:**
1. На Ethernet можно построить высокопроизводительную сеть со сверхмалыми задержками.
2. Активное использование современных контроллеров с поддержкой RDMA значительно повышает производительность решения.
3. Матрица Intel с уровнем задержки в 400 ns cut-through помогает получить отличный результат :-) | https://habr.com/ru/post/213911/ | null | ru | null |
# Ещё один способ получить нестандартные данные в iOS
Привет!
Я хочу показать, как, не используя приватных API ( = не используя приватных фреймворков/классов/функций) можно собирать разнообразные данные о использовании устройства. 
Вот описание информации, которую можно получить:
* Мощность сигнала сотовой сети: RSSI в дБм и относительную мощность в «палках»
* Качество сигнала WiFi (0 — плохо, 4 — хорошо)
* Состояние регистрации в сотовой сети: наличие SIM, поиск сети
* Тип сети передачи данных: 2G, 3G, WiFi
* Заряд аккумулятора с точностью до процента (стандартные средства дают точность в 5%)
* Включен ли «режим самолёта» («airplane mode»)
* Включены ли различные сервисы: будильник, Airplay, VPN, перенаправление звонков, Nike+
Собственно, суть метода:
```
typedef struct {
BOOL itemIsEnabled[24];
char timeString[64];
int gsmSignalStrengthRaw;
int gsmSignalStrengthBars;
char serviceString[100];
char serviceCrossfadeString[100];
char serviceImages[2][100];
char operatorDirectory[1024];
unsigned serviceContentType;
int wifiSignalStrengthRaw;
int wifiSignalStrengthBars;
unsigned dataNetworkType;
int batteryCapacity;
unsigned batteryState;
char batteryDetailString[150];
int bluetoothBatteryCapacity;
int thermalColor;
unsigned thermalSunlightMode : 1;
unsigned slowActivity : 1;
unsigned syncActivity : 1;
char activityDisplayId[256];
unsigned bluetoothConnected : 1;
unsigned displayRawGSMSignal : 1;
unsigned displayRawWifiSignal : 1;
unsigned locationIconType : 1;
} iOS6Data;
// retrieve data
char *app = (__bridge void *)([UIApplication sharedApplication]);
ptrdiff_t providerOffset = 52;
char *provider = *(char**)(app + providerOffset);
ptrdiff_t iOS6DataOffset = 116;
iOS6Data *data = (iOS6Data*)(provider + iOS6DataOffset);
```
**Минимальная программа, демонстрирующая возможности подхода**
```
enum {
kTimeItem = 0,
kLockItem,
kAirplaneItem,
kSignalStrengthItem,
kServiceItem,
kDataNetworkItem,
kBatteryItem,
kBatteryPercentItem,
kNotChargingItem,
kBluetoothBatteryItem,
kBluetoothItem,
kTTYItem,
kAlarmItem,
kPlusItem,
kPlayItem,
kLocationItem,
kRotationLockItem,
kDoubleHeightItem,
kAirPlayItem,
kVPNItem,
kCallForwardItem,
kActivityItem,
kThermalColorItem
};
typedef struct {
BOOL itemIsEnabled[24];
char timeString[64];
int gsmSignalStrengthRaw;
int gsmSignalStrengthBars;
char serviceString[100];
char serviceCrossfadeString[100];
char serviceImages[2][100];
char operatorDirectory[1024];
unsigned serviceContentType;
int wifiSignalStrengthRaw;
int wifiSignalStrengthBars;
unsigned dataNetworkType;
int batteryCapacity;
unsigned batteryState;
char batteryDetailString[150];
int bluetoothBatteryCapacity;
int thermalColor;
unsigned thermalSunlightMode : 1;
unsigned slowActivity : 1;
unsigned syncActivity : 1;
char activityDisplayId[256];
unsigned bluetoothConnected : 1;
unsigned displayRawGSMSignal : 1;
unsigned displayRawWifiSignal : 1;
unsigned locationIconType : 1;
} iOS6Data;
void proof_of_concept()
{
// we need to check runtime before start
NSString *systemVersion = [[UIDevice currentDevice] systemVersion] ;
NSScanner *scanner = [NSScanner scannerWithString:systemVersion];
int runtime;
[scanner scanInt:&runtime];
if (runtime != 6) {
NSLog(@"К сожалению, программа работает только на iOS 6");
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Не удалось получить данные"
message:@"Для работы программы необходима iOS 6."
delegate:nil
cancelButtonTitle:@"Закрыть"
otherButtonTitles:nil];
[alertView show];
return;
}
// retrieve data
char *app = (__bridge void *)([UIApplication sharedApplication]);
ptrdiff_t providerOffset = 52;
char *provider = *(char**)(app + providerOffset);
ptrdiff_t iOS6DataOffset = 116;
iOS6Data *data = (iOS6Data*)(provider + iOS6DataOffset);
// usage example
NSMutableString *example = [NSMutableString stringWithCapacity:1000];
[example appendFormat: @"Сигнал сотовой сети: %d дБм\n", data->gsmSignalStrengthRaw ];
[example appendFormat: @"Заряд батареи: %@\n", @(data->batteryDetailString)];
switch (data->dataNetworkType) {
case 2:
[example appendString: @"Тип сети передачи данных: 2G\n"];
break;
case 3:
[example appendString: @"Тип сети передачи данных: 3G\n"];
break;
case 5:
[example appendString: @"Тип сети передачи данных: WiFi\n"];
default:
break;
}
if (data->itemIsEnabled[kAlarmItem]) {
[example appendString:@"Будильник включен"];
}
if (data->itemIsEnabled[kCallForwardItem]) {
[example appendString:@"Влючено перенаправление звонков"];
}
if (data->itemIsEnabled[kAirplaneItem]) {
[example appendString:@"Влючен \"Режим самолёта\""];
}
NSLog(@"%@", example);
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Info"
message:example
delegate:nil
cancelButtonTitle:@"Закрыть"
otherButtonTitles: nil];
[alertView show];
}
```
**Плюсы:**
* Данные постоянно остаются актуальными, их обновлением занимается само приложение (UIApplication)
* Решение не использует приватные API
**Минусы:**
* Решение построено на рантайме iOS, поэтому структуры и константы отличаются для iOS 5, 6 и 7
* Полученная информация довольна поверхностна, нельзя например получить другие статистики сотовой сети
Если интересно, как это работает, откуда берутся константы и описания структур данных, пишите в комментариях, дополню статью. | https://habr.com/ru/post/183650/ | null | ru | null |
# Вывод информации об исключениях перед аварийным выходом
Зачем и для чего
----------------
Во время разработки не всегда всё бывает гладко. Бывают проблемы, которые не всплывают на тестах, а уже после релиза. Для таких случаев мы сделали небольшую систему отлова исключений и внутренних ошибок.
Перехват исключений
-------------------
Для того, чтобы программа перед падением могла сообщить нам (вне отладчика) в чём проблема, можно воспользоваться [функцией обработки сигналов](http://cppstudio.com/post/1204/).
**Несколько примеров таких сигналов:**
```
signal(SIGABRT, abort_handler); // Аварийное завершение, стандартные исключения с nullptr и прочим
signal(SIGFPE, floating_point_handler); // Ошибки арифметики с плавающей запятой
signal(SIGILL, illegal_instruction_handler); // Ошибки при работе с intrinsics (SSE/AVX/Other)
```
**Обработчики сигналов**
```
inline void abort_handler(int signal)
{
handler_base("Application is aborting");
}
inline void floating_point_handler(int signal)
{
handler_base("Floating point error");
}
inline void illegal_instruction_handler(int signal)
{
if (!CPU::Info.hasFeature(CPUFeature::SSE42))
handler_base("SSE4.2 and AVX instructions isn't legal on your CPU");
else if (!CPU::Info.hasFeature(CPUFeature::AVX))
handler_base("AVX instructions isn't legal on your CPU");
else
handler_base("Illegal instruction");
}
```
Так же есть обработчик недопустимых параметров (\_set\_invalid\_parameter\_handler), некорректного выделения памяти (\_set\_new\_handler) и подобные им.
Проблемное место: Получение callstack'a
---------------------------------------
Помимо самого исключения, нужно узнать, где именно проблема. К примеру, CallStack. Для этого можно воспользоваться готовым решением: [StackWalker](https://github.com/JochenKalmbach/StackWalker)
Проблемное место: Получения dump-файла
--------------------------------------
Если вам нужно получить более детальную информацию о проблеме, то следует сгенерировать Dump файл.
```
using MINIDUMPWRITEDUMP = BOOL(WINAPI*)(HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType,
CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
LONG WriteMinidump(struct _EXCEPTION_POINTERS* pExceptionInfo)
{
long retval = EXCEPTION_CONTINUE_SEARCH;
// firstly see if dbghelp.dll is around and has the function we need
// look next to the EXE first, as the one in System32 might be old
// (e.g. Windows 2000)
HMODULE hDll = nullptr;
string_path szDbgHelpPath;
if (GetModuleFileName(nullptr, szDbgHelpPath, _MAX_PATH))
{
char* pSlash = strchr(szDbgHelpPath, '\\');
if (pSlash)
{
const char dbgHelpStr[] = "DBGHELP.DLL";
xr_strcpy(pSlash + 1, sizeof(dbgHelpStr), dbgHelpStr);
hDll = LoadLibraryA(szDbgHelpPath);
}
}
if (!hDll)
{
// Загружаем dbgHelp
hDll = LoadLibraryA("DBGHELP.DLL");
}
LPCSTR szResult = nullptr;
if (hDll)
{
MINIDUMPWRITEDUMP pDump = (MINIDUMPWRITEDUMP)::GetProcAddress(hDll, "MiniDumpWriteDump");
if (pDump)
{
string512 ErrorString = { NULL };
DWORD ErrorSysCode = NULL;
DWORD ErrorStringSize = NULL;
string_path szDumpPath = { 0 };
string_path szFilename = { 0 };
string_path szScratch = { 0 };
string64 t_stemp = { 0 };
timestamp(t_stemp);
xr_strcat(szDumpPath, DumpFilePath);
// Генерируем название файла : App Name, User Name, Time, Ext
xr_strcat(szFilename, Core.ApplicationName);
xr_strcat(szFilename, "_");
xr_strcat(szFilename, Core.UserName);
xr_strcat(szFilename, "_");
xr_strcat(szFilename, t_stemp);
xr_strcat(szFilename, ".mdmp");
xr_strcat(szDumpPath, szFilename);
// Создаём файл
HANDLE hFile = CreateFileA(szDumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if (INVALID_HANDLE_VALUE == hFile)
{
// Попробуем записать в директорию, из которой запущено приложение
ZeroMemory(szDumpPath, sizeof(szDumpPath));
xr_strcat(szDumpPath, szFilename);
hFile = CreateFileA(szDumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
}
if (hFile != INVALID_HANDLE_VALUE)
{
_MINIDUMP_EXCEPTION_INFORMATION ExInfo;
ExInfo.ThreadId = GetCurrentThreadId();
ExInfo.ExceptionPointers = pExceptionInfo;
ExInfo.ClientPointers = NULL;
// Записываем Dump
MINIDUMP_TYPE dump_flags = MINIDUMP_TYPE(MiniDumpNormal | MiniDumpFilterMemory | MiniDumpScanMemory);
// Сообщение ошибки
char* logFileContent = nullptr;
DWORD logFileContentSize = 0;
/////////////////////////////////////
// Вставьте ваш код генерации сообщения об ошибке (logFileContent)
/////////////////////////////////////
MINIDUMP_USER_STREAM_INFORMATION UserStreamsInfo = { 0 };
MINIDUMP_USER_STREAM LogFileUserStream = { 0 };
if (logFileContent)
{
UserStreamsInfo.UserStreamCount = 1;
LogFileUserStream.Buffer = logFileContent; // Передаём ваше сообщение
LogFileUserStream.BufferSize = logFileContentSize; // Размер сообщения
LogFileUserStream.Type = MINIDUMP_STREAM_TYPE::CommentStreamA; // Тип
UserStreamsInfo.UserStreamArray = &LogFileUserStream
}
BOOL bOK = pDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, dump_flags, &ExInfo, &UserStreamsInfo, nullptr);
if (bOK)
{
xr_sprintf(szScratch, "Saved dump file to '%s'", szDumpPath);
szResult = szScratch;
retval = EXCEPTION_EXECUTE_HANDLER;
}
else
{
ErrorSysCode = GetLastError();
ErrorStringSize = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, ErrorSysCode, 0, ErrorString, sizeof(ErrorString) - 1, nullptr);
if (!!ErrorString && ErrorSysCode && ErrorStringSize)
xr_sprintf(szScratch, "Failed to save dump file to '%s' (error %d '%s')", szDumpPath, ErrorSysCode, ErrorString);
else
xr_sprintf(szScratch, "Failed to save dump file to '%s' (No system error)", szDumpPath);
szResult = szScratch;
}
CloseHandle(hFile);
}
else
{
ErrorSysCode = GetLastError();
ErrorStringSize = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, ErrorSysCode, 0, ErrorString, sizeof(ErrorString) - 1, nullptr);
if (!!ErrorString && ErrorSysCode && ErrorStringSize)
xr_sprintf(szScratch, "Failed to create dump file '%s' (error %d '%s')", szDumpPath, ErrorSysCode, ErrorString);
else
xr_sprintf(szScratch, "Failed to create dump file '%s' (No system error)", szDumpPath);
szResult = szScratch;
}
}
else
szResult = "DBGHELP.DLL too old";
}
else
szResult = "DBGHELP.DLL not found";
return retval;
}
```
Сообщим пользователю о проблеме
-------------------------------
Для вывода сообщений о проблемах, как исключений, так и внутренних (скриптов, конфигов, неправильного поведения программы), мы написали небольшую утилиту, которая выглядит следующим образом:
Написана она на C# + WPF, исходный код [доступен](https://github.com/xrOxygen/xray-oxygen/tree/master/code/engine.vc2008/CrashStack)
Функционал достаточно примитивен:
* Продолжить выполнение программы (если это внутренняя ошибка)
* Сообщить о проблеме (стек улетает в буфер обмена, пользователь переходит на сервер дискорда в нужный топик)
* Прервать выполнение программы | https://habr.com/ru/post/486510/ | null | ru | null |
# Операторы ?., ?? и |>: будущие возможности JavaScript, которые вам понравятся
Джастин Фуллер, автор материала, перевод которого мы сегодня публикуем, предлагает рассмотреть три новых возможности, появление которых ожидается в JavaScript в обозримом будущем. Сначала он расскажет о процессе развития JS, а после этого представит обзор этих возможностей и покажет примеры их использования. Речь пойдёт об операторах `?.`, `??` и `|>`.
О стандарте ECMAScript и развитии JavaScript
--------------------------------------------
[](https://habrahabr.ru/company/ruvds/blog/353446/) Если вы уже знакомы с особенностями деятельности рабочей группы [ECMA TC39](http://www.ecma-international.org/memento/TC39.htm), с тем, как она осуществляет отбор и обработку предложений о совершенствовании JavaScript, вы вполне можете пропустить этот раздел. Если же вы из тех, кому интересно об этом узнать — вот краткий обзор того, чем занимается TC39.
JavaScript — это реализация стандарта, называемого [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript), который был создан для стандартизации [реализаций](https://en.wikipedia.org/wiki/Category:JavaScript_dialect_engines) языка, которые появились в ранние годы существования веб-браузеров.
Существует восемь [редакций](https://en.wikipedia.org/wiki/ECMAScript#Versions) стандарта ECMAScript и семь релизов (четвёртая редакция стандарта не выходила, после третьей сразу идёт пятая). Разработчики [JavaScript-движков](https://en.wikipedia.org/wiki/JavaScript_engine#JavaScript_engines) приступают к реализации новшеств языка после выхода стандарта. [Здесь](https://kangax.github.io/compat-table/es6/) можно увидеть, что не каждый движок реализует все возможности, при этом некоторым движкам для введения новшеств требуется больше времени, чем другим. Хотя такое положение дел и не идеально, это, всё же, лучше, чем полное отсутствие стандартов.
Предложения
-----------
Новые возможности языка изначально представляют собой так называемые предложения, которые, до включения в стандарт, проходят процедуру согласования. Если предложение признано полезным и обратно совместимым со всем тем, что уже существует, оно будет включено в следующую редакцию стандарта.
Процесс рассмотрения предложений состоит из пяти шагов, описанных в [этом документе](https://tc39.github.io/process-document/). В самом начале предложение находится в состоянии черновика (strawman), это то же самое, что и [Stage 0](https://github.com/tc39/proposals/blob/master/stage-0-proposals.md). На этом шаге предложение либо ещё не представлено техническому комитету, либо оно ещё не отвергнуто, но пока ещё не соответствует критериям, позволяющим перейти к следующему этапу согласования. Те возможности, о которых мы будем говорить ниже, уже прошли Stage 0.
Мне хотелось бы порекомендовать читателям избегать использования в продакшне новшеств JS, предложения, описывающие которые, находятся на этапе Stage 0. Лучше дождаться перехода их к более стабильным этапам согласования. Цель этой рекомендации заключается в том, чтобы помочь вам избежать проблем в том случае, если предложение будет отвергнуто или окажется очень сильно изменённым.
Система тестирования
--------------------
Материалы, в которых рассказывают о новых возможностях языков программирования, часто содержат фрагменты кода, вырванные из контекста. Иногда эти возможности используются для создания неких учебных приложений. Однако, ни того, ни другого мы делать здесь не будем. Так как я — большой поклонник [TDD](https://en.wikipedia.org/wiki/Test-driven_development), я полагаю, что лучший способ изучения некоей новой технологии заключается в её тестировании.
Мы будем использовать здесь, для освоения описываемых возможностей JS, то, что Джим Ньюкирк называет [обучающими тестами](https://smile.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=smi_www_rco2_go_smi_2609328962?_encoding=UTF8&%2AVersion%2A=1&%2Aentries%2A=0&ie=UTF8). Такие тесты построены не на утверждениях о коде, написанном на некоем языке. Они построены на анализе утверждений, касающихся самого языка. Тот же подход может оказаться полезным и при изучении API сторонних разработчиков, и при освоении любой возможности языка.
Транспиляторы
-------------
Если вы не знакомы с транспиляторами, то у вас, возможно, возникнет вопрос о том, как мы собираемся использовать возможности языка, которые пока не реализованы. Тут надо отметить, что JavaScript постоянно развивается, а для реализации в распространённых движках его новых возможностей, интересных программистам, нужно время. В результате в экосистеме JS существует такое понятие, как [транспиляторы](https://scotch.io/tutorials/javascript-transpilers-what-they-are-why-we-need-them).
Они позволяют преобразовывать код, написанный на JS с использованием новейших возможностей, которые, например, ещё не включены в стандарты и не реализованы популярными движками, в JS-код, который понимают существующие среды выполнения JavaScript-программ. Это позволят, например, использовать в коде даже предложения уровня Stage 0, а то, что получится после обработки кода транспилятором, можно будет выполнить, например, в современных браузерах или в среде Node.js. Делается это путём [преобразования](https://babeljs.io/repl/) нового кода таким образом, что он, для среды исполнения, выглядит как код, написанный на одной из поддерживаемых ей версий JS.
Одним из самых популярных JavaScript-транспиляторов является [Babel](https://babeljs.io/), совсем скоро мы поговорим о том, как им пользоваться.
Подготовка рабочей среды
------------------------
Если вы хотите самостоятельно повторить всё то, о чём мы будем говорить — вы можете это сделать, настроив npm-проект и установив необходимые зависимости. Предполагается, что сейчас у вас уже установлены [Node.js](https://nodejs.org/en/) и [NPM](https://www.npmjs.com/).
Для того чтобы подготовиться к нашим экспериментам, выполните следующую команду, находясь в отведённой для этих экспериментов директории:
```
npm init -f && npm i ava@1.0.0-beta.3 @babel/preset-env@7.0.0-beta.42 @babel/preset-stage-0@7.0.0-beta.42 @babel/register@7.0.0-beta.42 @babel/polyfill@7.0.0-beta.42 @babel/plugin-transform-runtime@7.0.0-beta.42 @babel/runtime@7.0.0-beta.42 --save-dev
```
Затем добавьте следующее в файл `package.json`:
```
"scripts": {
"test": "ava"
},
"ava": {
"require": [
"@babel/register",
"@babel/polyfill"
]
}
```
Далее, создайте файл `.babelrc` со следующим содержимым:
```
{
"presets": [
["@babel/preset-env", {
"targets": {
"node": "current"
}
}],
"@babel/preset-stage-0"
],
"plugins": [
"@babel/plugin-transform-runtime"
]
}
```
Теперь вы готовы к тому, чтобы писать тесты, исследующие новые возможности JS.
1. Оператор ?.
--------------
В ходе написания приложений на JavaScript мы постоянно работаем с объектами. Однако иногда эти объекты не имеют той структуры, которой мы от них ожидаем. Вот, например, объект с данными. Подобный объект можно получить, скажем, в результате запроса к базе данных или при обращении к некоему API.
```
const data = {
user: {
address: {
street: 'Pennsylvania Avenue',
},
},
};
```
Этот объект описывает пользователя, прошедшего регистрацию. А вот — похожий объект, но в данном случае пользователь, которого он описывает, регистрацию не завершил.
```
const data = {
user: {},
};
```
Если попытаться получить доступ к свойству `street` объекта `address`, вложенного в этот «неполный» объект, рассчитывая на то, что он будет выглядеть так же, как объект, содержащий все необходимые данные, можно столкнуться с такой ошибкой:
```
console.log(data.user.address.street); // Uncaught TypeError: Cannot read property 'street' of undefined
```
Для того чтобы этого избежать, в текущих условиях необходимо использовать, для обращения к свойству `street`, такую конструкцию:
```
const street = data && data.user && data.user.address && data.user.address.street;
console.log(street); // undefined
```
Я полагаю, что всё это, во-первых, плохо выглядит, во-вторых, это тяжело писать, а в-третьих — подобные конструкции оказываются слишком длинными.
Именно в таких ситуациях как нельзя кстати оказываются опциональные последовательности или опциональные цепочки ([optional chaining](https://github.com/TC39/proposal-optional-chaining)), представленные оператором, выглядящим как знак вопроса с точкой (`?.`).
```
console.log(data.user?.address?.street); // undefined
```
Выглядит это лучше, да и строить такие конструкции проще. Уверен, вы с этим утверждением согласитесь. Убедившись в полезности этой новой возможности, исследуем её. Напишем тест, поместив код в файл `optional-chaining.test.js`. Мы, в этом разделе, будем постепенно дополнять этот файл новыми тестами.
```
import test from 'ava';
const valid = {
user: {
address: {
street: 'main street',
},
},
};
function getAddress(data) {
return data?.user?.address?.street;
}
test('Optional Chaining returns real values', (t) => {
const result = getAddress(valid);
t.is(result, 'main street');
});
```
Этот тест позволяет нам убедиться в том, что оператор `?.`, в том случае, если объект выглядит так, как ожидается, работает точно так же, как способ доступа к свойствам объекта через точку. Теперь проверим поведение этого оператора в ситуации, когда объект не является тем, чем мы его считаем.
```
test('Optional chaining returns undefined for nullish properties.', (t) => {
t.is(getAddress(), undefined);
t.is(getAddress(null), undefined);
t.is(getAddress({}), undefined);
});
```
А вот как опциональные последовательности работают при применении их для доступа к элементам массивов:
```
const valid = {
user: {
address: {
street: 'main street',
neighbors: [
'john doe',
'jane doe',
],
},
},
};
function getNeighbor(data, number) {
return data?.user?.address?.neighbors?.[number];
}
test('Optional chaining works for array properties', (t) => {
t.is(getNeighbor(valid, 0), 'john doe');
});
test('Optional chaining returns undefined for invalid array properties', (t) => {
t.is(getNeighbor({}, 0), undefined);
});
```
Иногда случает так, что нам неизвестно, реализована ли в объекте какая-то функция. Например, такая ситуация распространена при работе с браузерами. Устаревшие браузеры могут не содержать реализаций неких функций. Благодаря оператору `?.` мы можем узнать, реализована ли в объекте интересующая нас функция или нет. Вот как это сделать:
```
const data = {
user: {
address: {
street: 'main street',
neighbors: [
'john doe',
'jane doe',
],
},
getNeighbors() {
return data.user.address.neighbors;
}
},
};
function getNeighbors(data) {
return data?.user?.getNeighbors?.();
}
test('Optional chaining also works with functions', (t) => {
const neighbors = getNeighbors(data);
t.is(neighbors.length, 2);
t.is(neighbors[0], 'john doe');
});
test('Optional chaining returns undefined if a function does not exist', (t) => {
const neighbors = getNeighbors({});
t.is(neighbors, undefined);
});
```
Выражения не будут выполнены, если в цепочке что-то не так. Если говорить о внутренней реализацией этого механизма, то наше выражение преобразуется примерно в следующее:
```
value == null ? value[some expression here]: undefined;
```
В результате после оператора `?.` не будет выполнено ничего в том случае, если значение представлено в виде `undefined` или `null`. Взглянуть на это правило в действии можно с помощью следующего теста:
```
let neighborCount = 0;
function getNextNeighbor(neighbors) {
return neighbors?.[++neighborCount];
}
test('It short circuits expressions', (t) => {
const neighbors = getNeighbors(data);
t.is(getNextNeighbor(neighbors), 'jane doe');
t.is(getNextNeighbor(undefined), undefined);
t.is(neighborCount, 1);
});
```
Как видите, опциональные последовательности позволяют уменьшить потребность в конструкциях `if`, в сторонних библиотеках вроде `lodash`, и в использовании неуклюжих конструкций, в которых применяется `&&`.
### ▍Оператор?.. и производительность
Вероятно, вы заметили, что использование опциональных последовательностей означает дополнительную нагрузку на систему. Всё дело в том, что каждый раз, когда используется оператор `?.`, система вынуждена проводить дополнительные проверки. Злоупотребление оператором `?.` может заметно повлиять на производительность программ.
Я посоветовал бы вам использовать эту возможность вместе с некоей системой проверки, которая позволяет анализировать объекты при их получении откуда-либо или при их создании. Это сократит необходимость в использовании конструкции `?.` и ограничит её воздействие на производительность.
2. Оператор ??
--------------
Вот несколько распространённых операций, с которыми можно встретиться в процессе работы с JavaScript. Обычно они выглядят как единое выражение, смысл которого заключается в следующем:
1. Проверка значения на `undefined` и `null`.
2. Указание значения, используемого по умолчанию.
3. Обеспечение того, что появление значений `0`, `false`, и `''` не приводит к использованию значения, применяемого по умолчанию.
Вот пример подобного выражения:
```
value != null ? value : 'default value';
```
Можно встретить и неграмотно написанный вариант такого выражения:
```
value || 'default value'
```
Проблема второго примера заключается в том, что третий пункт вышеприведённого списка здесь не выполняется. Появление тут числа `0`, значения `false` или пустой строки будет распознано как значение `false`, а это — не то, что нам нужно. Именно поэтому проверку на `null` и `undefined` нужно проводить в явном виде:
```
value != null
```
Это выражение аналогично такому:
```
value !== null && value !== undefined
```
В подобных ситуациях очень кстати окажется новый оператор, называемый «объединение со значением `null`» ([nullish coalescence](https://github.com/tc39/proposal-nullish-coalescing)), который выглядит как два знака вопроса (`??`). В подобной ситуации теперь можно будет воспользоваться следующей конструкцией:
```
value ?? 'default value';
```
Это защищает нас от случайного использования значения по умолчанию при появлении в выражениях значений, распознаваемых как `false`, но при этом позволяет выявлять значения `null` и `undefined`, не прибегая к тернарному оператору и к проверке вида `!= null`.
Теперь, познакомившись с этим оператором, мы можем написать тесты для того, чтобы проверить его в деле. Эти тесты поместим в файл `nullish-coalescing.test.js`.
```
import test from 'ava';
test('Nullish coalescing defaults null', (t) => {
t.is(null ?? 'default', 'default');
});
test('Nullish coalescing defaults undefined', (t) => {
t.is(undefined ?? 'default', 'default');
});
test('Nullish coalescing defaults void 0', (t) => {
t.is(void 0 ?? 'default', 'default');
});
test('Nullish coalescing does not default 0', (t) => {
t.is(0 ?? 'default', 0);
});
test('Nullish coalescing does not default empty strings', (t) => {
t.is('' ?? 'default', '');
});
test('Nullish coalescing does not default false', (t) => {
t.is(false ?? 'default', false);
});
```
Из этих тестов можно понять, что значения по умолчанию используются для `null`, `undefined` и `void 0` (оно преобразуется в `undefined`). При этом значения по умолчанию не применяются в тех случаях, когда в выражении появляются значения, воспринимаемые как ложные, вроде `0`, пустой строки и `false`.
3. Оператор |>
--------------
В функциональном программировании есть такое понятие, как [композиция](https://medium.com/javascript-scene/composing-software-an-introduction-27b72500d6ea). Это — действие, представляющее собой объединение в цепочку нескольких вызовов функций. Каждая функция принимает, в качестве входных данных, выходные данные предыдущей функции. Вот пример композиции, подготовленный средствами обычного JavaScript:
```
function doubleSay (str) {
return str + ", " + str;
}
function capitalize (str) {
return str[0].toUpperCase() + str.substring(1);
}
function exclaim (str) {
return str + '!';
}
let result = exclaim(capitalize(doubleSay("hello")));
result //=> "Hello, hello!"
```
Подобное распространено настолько широко, что средства композиции функций существуют во множестве библиотек, поддерживающих функциональное программирование, например, в таких, как [lodash](https://lodash.com/docs/4.17.5#flow) и [ramda](http://ramdajs.com/docs/#compose).
Благодаря новому конвейерному оператору ([pipeline operator](https://github.com/tc39/proposal-pipeline-operator)), который выглядит как комбинация вертикальной черты и знака «больше» (`|>)`, можно отказаться от использования сторонних библиотек и переписать вышеприведённый пример следующим образом:
```
let result = "hello"
|> doubleSay
|> capitalize
|> exclaim;
result //=> "Hello, hello!"
```
Цель появления этого оператора заключается в том, чтобы улучшить читаемость цепочек вызовов функций. Кроме того, в будущем, этот оператор найдёт применение в конструкциях частичного применения функций. Сейчас это можно сделать следующим образом:
```
let result = 1
|> (_ => Math.max(0, _));
result //=> 1
let result = -5
|> (_ => Math.max(0, _));
result //=> 0
```
Разобравшись с основами, напишем тесты, разместив их в файле `pipeline-operator.test.js`:
```
import test from 'ava';
function doubleSay (str) {
return str + ", " + str;
}
function capitalize (str) {
return str[0].toUpperCase() + str.substring(1);
}
function exclaim (str) {
return str + '!';
}
test('Simple pipeline usage', (t) => {
let result = "hello"
|> doubleSay
|> capitalize
|> exclaim;
t.is(result, 'Hello, hello!');
});
test('Partial application pipeline', (t) => {
let result = -5
|> (_ => Math.max(0, _));
t.is(result, 0);
});
test('Async pipeline', async (t) => {
const asyncAdd = (number) => Promise.resolve(number + 5);
const subtractOne = (num1) => num1 - 1;
const result = 10
|> asyncAdd
|> (async (num) => subtractOne(await num));
t.is(await result, 14);
});
```
Анализируя эти тесты, можно заметить, что при применении в конвейере асинхронной функции, объявленной с использованием ключевого слова `async`, нужно дождаться появления значения, воспользовавшись ключевым словом `await`. Дело тут в том, что значение становится объектом `Promise`. Имеются несколько [предложений изменений](https://github.com/tc39/proposal-pipeline-operator), направленных на поддержку конструкций вида `|> await asyncFunction`, но они ещё не реализованы и решение об их дальнейшей судьбе пока не принято.
Итоги
-----
Надеемся, вам понравились ожидаемые возможности JS, которым посвящён этот материал. [Вот](https://github.com/JustinDFuller/javascript-proposals-tests) репозиторий с тестами, которыми мы занимались в этом материале. А вот, для удобства — ссылки на рассмотренные здесь новшества: [оператор ?.](https://github.com/TC39/proposal-optional-chaining), [оператор ??](https://github.com/tc39/proposal-nullish-coalescing), [оператор |>](https://github.com/tc39/proposal-pipeline-operator).
**Уважаемые читатели!** Как вы относитесь к появлению новых возможностей JS, о которых мы рассказали?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/353446/ | null | ru | null |
# PHP-класс для работы с INI-файлами
Класс-помощник для работы с INI-файлами. Класс реализует шаблон проектирования "Строитель". В представленном классе идет реализация функционала для работы с INI-файлами. В качестве базового функционала представлено создание, добавление и чтение секций, добавление и удаление ключей и другой функционал.
---
Первым делом необходимо объявить переменные, которые отвечают за структуру файла, путь к файлу и тип сканирования:
```
/**
* @var array Структура ini файла
*/
private array $structure = [];
/**
* @var int Тип сканирования
*/
private int $scannerMode;
/**
* @var string Путь к файлу
*/
private string $path;
```
В конструкторе метода укажем путь к файлу (для создания) и тип сканирования, а также вызовем метод получения структуры файла:
```
public function __construct(string $path, int $scannerMode = INI_SCANNER_TYPED) {
$this->path = $path;
file_put_contents($path, null, LOCK_EX);
$this->scannerMode = $scannerMode;
$this->setInitStructure();
}
```
Метод получения структуры файла выглядит следующим образом:
```
private function setInitStructure(): void {
$this->structure = parse_ini_file($this->path, true, $this->scannerMode);
}
```
Метод `parse_ini_file` получает в качестве аргументов путь к файлу, флаг получения многомерного массива и типа сканирования. Мы ставим по умолчанию флаг многомерного массива как `true`, так как нам проще работать с такими массивами. Тип сканирования может быть:
* `INI_SCANNER_NORMAL` (по умолчанию в PHP)
* `INI_SCANNER_RAW`
При `INI_SCANNER_RAW` значения опций (ключ => значение) не будут обрабатываться. Также с версии PHP 5.6.1 завезли тип `INI_SCANNER_TYPED`. В этом режиме типы boolean, null и integer будут, по возможности, сохраняться. Строковые значения `"true"`, `"on"` и `"yes"` будут преобразованы в `TRUE`. `"false"`, `"off"`, `"no"` и `"none"` в `FALSE`. `"null"` преобразуется в `NULL`. Кроме этого, все числовые строки будут, по возможности, преобразованы к целым числам. Вроде как это лучше, чем остальные варианты, по этому используем его.
Вспомогательные методы
----------------------
Напишем публичный метод получения всей структуры файла:
```
public function getStructure(): array {
return $this->structure;
}
```
Чаще всего необходимо получать какое-то значение или всю секцию файла. Давайте напишем простые методы получения этих значений:
```
public function getSection(string $section): array {
return $this->structure[$section];
}
public function getValue(string $section, string $key) {
return $this->getSection($section)[$key];
}
```
С методами получения мы разобрались, теперь нам необходимо формировать файлы, чтобы записывать туда определенные значения. Можно сказать, что этот процесс называется динамическим конфигурированием. Для начала создадим метод добавления секции:
```
public function addSection(string $section): Ini {
if (array_key_exists($section, $this->structure)) {
throw new Exception("Секция {$section} уже существует");
}
$this->structure[$section] = [];
return $this;
}
```
В данном случае выбрасывается простой exception, хотя лучше всего было бы использовать собственные исключения.
Теперь сделаем метод, который добавлял бы значения в определенные секцию:
```
public function addValues(string $section, array $values): Ini {
$this->structure[$section] = array_merge($values, $this->structure[$section]);
return $this;
}
```
Но не всегда надо добавлять значения, иногда нужно из переназначать. Напишем такой метод:
```
public function setValues(string $section, array $values): Ini {
foreach ($values as $key => $value) {
$this->structure[$section][$key] = $value;
}
return $this;
}
```
С добавлением, назначением и чтением мы разобрались, теперь сделаем возможность удаления секции и ключей в секциях:
```
public function removeSection(string $section): Ini {
unset($this->structure[$section]);
return $this;
}
public function removeKeys(string $section, array $keys): Ini {
foreach ($keys as $key) {
unset($this->structure[$section][$key]);
}
return $this;
}
```
Обратите внимание, что методы добавления и удаления реализуют шаблон проектирования "Строитель".
Осталось дело за малым - написать метод записи в файл:
```
public function write(): void {
$iniContent = null;
foreach ($this->structure as $section => $data) {
$iniContent .= "[{$section}]\n";
foreach ($data as $key => $value) {
$iniContent .= "{$key}={$value}\n";
}
$iniContent .= "\n";
}
file_put_contents($this->path, $iniContent, LOCK_EX);
$this->setInitStructure();
}
```
Надеюсь, что вам будет полезен данный помощник по работе с INI файлами в PHP. Если есть предложения по улучшению, то буду рад их выслушать. | https://habr.com/ru/post/519952/ | null | ru | null |
# Как сделать сервис реактивным в одну строку в Vue.js + Typescript
С выходом Composition API в Vue появилось новые возможности повторного использования кода. Больше нет необходимости в миксинах, компонентах высшего порядка и прочих “хаках”, если вам нужно вынести общую логику для нескольких компонентов. Но что если у вас есть нереактивный сервис, инкапсулирующий бизнес-логику, а переписывать все на composition api не хочется?
К примеру возьмем простой класс с состоянием:
```
export class MyService {
foo: Object = {}
setFoo (foo: Object) {
this.foo = foo
}
}
```
В нем все прекрасно, но что если мы хотим сделать его свойство реактивным? Согласно документации, мы можем сделать, например, вот так:
```
import { Ref, ref } from 'vue'
export class MyService {
foo: Ref = ref({})
setFoo (foo: Object) {
this.foo.value = foo
}
}
```
Вроде бы тоже неплохо, но если ваш сервис большой и иерархичный, переводить каждое свойство в ref будет трудно и больно. Тут на помощь приходят декораторы Typescript:
```
export class MyService {
@Reactive foo: Object = {}
setFoo (foo: Object) {
this.foo = foo
}
}
```
Успех! Наше свойство реактивно, но теперь уже без манипуляций c ref-ами. Как это работает? Рассмотрим сам декоратор:
```
import { shallowRef } from 'vue'
function initRefs (target: any, key: string, value ?: any) {
target.__refs = target.__refs ?? {}
if (!target.__refs[key]) {
target.__refs[key] = shallowRef(value)
}
}
export function Reactive (target: any, key: string): void {
Object.defineProperty(target, key, {
configurable: true,
enumerable: true,
get () {
initRefs(this, key)
return this.__refs[key].value
},
set (value) {
initRefs(this, value, key)
this.__refs[key].value = value
}
})
}
```
Благодаря Object.defineProperty, свойство попросту заменяется геттером и сеттером, обращающимся к ref-у, который хранится в том же классе. Его инициализация происходит при первом чтении либо записи.
Заключение
----------
Декораторы - мощный инструмент, позволяющий вынести низкоуровневый код на уровень инфраструктуры и не засорять им приложение. Но какие минусы у такого подхода?
1. Декораторы все еще являются экспериментальной функцией, и ее реализация в будущем может измениться, о чем говорится в [документации](https://www.typescriptlang.org/docs/handbook/decorators.html). Кроме того, для их работы необходимо явно проставить параметр `experimentalDecorators`.
2. Этот подход похож на магию и прячет нюансы реализации от разработчика, что может привести к неожиданным багам и непредсказуемому поведению.
3. Это не работает с SSR из коробки, хотя это преодолимая проблема, например, с помощью Nuxt и его `ssrRef`
Тем не менее, лично мне такой путь нравится, он красив и элегантен и не накладывает драконовских ограничений. А как вы считаете? Комментарии и предложения к подходу охотно принимаются. | https://habr.com/ru/post/674432/ | null | ru | null |
# Использование TAP интерфейса OpenVPN на NAS Synology (с аутентификацией по сертификату)
#### Предыстория
Радость от появления пакета OpenVPN для сетевого хранилища Synology быстро прошла. Попытка настроить сеть для малого офиса, закончилась практически не начавшись. В интерфейсе для настройки пакета отсутствовали все прелести этого самого пакета (доступна только авторизация по логину и паролю).
Недавно наткнулся на статью: [«Учим NAS Synology маршрутизировать трафик в OpenVPN туннель с аутентификацией по сертификату»](http://habrahabr.ru/post/216197/).
Вроде бы то, что надо. Но!
Как оказалось, даже подобное вмешательство «руками» в недра прошивки не позволяет поднимать соединения через TAP-интерфейсы.
Ну, что ж. Не останавливаться же на половине пути…
#### Суть проблемы
Если сделать все, как указано в статье, упомянутой выше, только с типом адаптера TAP, то получим следующий эффект:
1. Выбираем соединение VPN, нажимаем подключить.
2. В SSH сессии видим что туннель поднялся, сервер пингуется, данные идут. Но интерфейс Synology говорит нам что происходит «Подключение».
3. Через 15-20 секунд интерфейс вежливо сообщает, что подключится не удалось, и закрывает работающее соединение.
Детальное изучение происходящего выявило, что во всех скриптах устройства, прописаны алгоритмы для определения статуса OpenVPN соединения, основываясь на том, что они могут быть только TUN.
Об этом так же свидетельствуют все комментарии в скриптах.
#### Решение проблемы
На момент написание статьи на устройстве установлена прошивка DMS 5.0-4493 Update 1.
Соответственно, все описанное здесь **актуально для неё**.
Для удобства управления скриптами было решено хранить все на админской сетевой шаре.
Создаем на ней папку OpenVPN, в ней будет располагаться всё необходимое для работы клиента:
1. Файл конфигурации OpenVPN «tap.conf»:
```
dev tap
proto udp
remote ServerIP 444
client
tls-client
ns-cert-type server
ca key/ca.crt
cert key/Client1.crt
key key/Client1.key
comp-lzo yes
tun-mtu 1500
tun-mtu-extra 32
mssfix 1450
ping-restart 12
ping 3
status log/openvpn-status.log
log log/openvpn.log
script-security 2
float
```
2. Папка с сертификатами: «key»
3. Папка с логами: «log»
4. Скрипты запуска/остановки VPN.
Start.sh (запуск туннеля):
```
#!/bin/sh
CONF_DIR="/volume1/adm/OpenVPN/"
OPENVPN_CONF="tap.conf"
KERNEL_MODULES="x_tables.ko ip_tables.ko iptable_filter.ko nf_conntrack.ko nf_defrag_ipv4.ko nf_conntrack_ipv4.ko nf_nat.ko iptable_nat.ko ipt_REDIRECT.ko xt_multiport.ko xt_tcpudp.ko xt_state.ko ipt_MASQUERADE.ko tun.ko"
SERVICE="ovpnc"
# Make device if not present (not devfs)
if [ ! -c /dev/net/tun ]; then
# Make /dev/net directory if needed
if [ ! -d /dev/net ]; then
mkdir -m 755 /dev/net
fi
mknod /dev/net/tun c 10 200
fi
/usr/syno/bin/iptablestool --insmod $SERVICE ${KERNEL_MODULES}
echo "Starting openvpn client..."
/usr/sbin/openvpn --daemon --cd ${CONF_DIR} --config ${OPENVPN_CONF} --writepid /var/run/ovpn_client.pid
```
Stop.sh (остановка туннеля):
```
#!/bin/sh
echo "Kill openvpn client..."
/bin/kill `cat /var/run/ovpn_client.pid` 2>/dev/null
```
OnLine.sh (перезапуск туннеля, если сервер не доступен):
```
#!/bin/sh
ping -c 3 10.23.122.1
if [ $? -ne 0 ]; then
echo "Stoping VPN.."
sh Stop.sh
echo "Sleep 5."
sleep 5
echo "Start...."
sh Start.sh
fi
```
В общем этого достаточно.
Как показали тесты, VPN успешно перезапускается автоматически при отключении интернета или удаленного сервера. Скрипт OnLine писался больше для автоматического запуска VPN вместе с NAS. Но штатный планировщик позволяет добавить выполнение скрипта «каждый час», поэтому добавил проверку на доступность.
При такой реализации прошивка NAS понятия не имеет о туннели (оно и к лучшему), но при этом все ресурсы удаленной сети доступны (сетевое резервирование на IP из VPN прекрасно проходит). | https://habr.com/ru/post/230517/ | null | ru | null |
# React on λambda
Без особых церемоний начнем раздавать лещей и кричать о функциональщине, да кстати, всем привет!
С развитием реакт плавно избавляется от ООП-шной примеси и всё больше приближается к функциональному программированию. В начале в нем появились компоненты высшего порядка (HOC) вместо миксинов, затем stateless компоненты почти замена классам, и вот последний рывок, выкатили хуки (hooks), которые полностью избавляют реакт от классов.
Не знаю куда приведет следующая ветвь развития, но уверенно могу сказать, пора уже избавляться от JSX, и да в пользу тех самых функций. Будь с нами Сергей Дружко, то мы бы услышали:
*[— Сильное заявление, проверять я его конечно не буду](https://www.youtube.com/watch?v=j978pwMZjmE).*
Но вас я приглашаю это проверить, а точнее прикинуть то, каким может быть реакт без JSX.
### Королевство шаблонов
В мире шаблонов всё крутится вокруг его величества текста, вы погружаетесь в него по самые уши и приступаете к грязным делам, а именно вставляете код, указывая где нужно повторить, а где что-то показать или скрыть. А чтобы обозначить границу между текстом и кодом используются усики (фигурные скобки), теги или еще какие-нибудь директивы.
В отличие от шаблонизаторов, в JSX переход из кода в HTML, происходит автоматически без разметки и эти переходы можно повторять рекурсивно. Именно поэтому можно услышать критику в сторону JSX, что мол вы кодируете JS внутри HTML, а внутри того JS другой вложенный HTML и т.д.
Ну а в остальном же JSX это тот же шаблонизатор, а всё потому, что изначально на реакт оказал свое влияние [XHP](https://en.wikipedia.org/wiki/XHP), по сути это тюнингованный фейсбуком PHP. Если реакт в чистом виде мало, что имеет общего с XHP, то JSX его брат близнец, но только в мире JavaScript.
Ничего плохого в шаблонизаторах нет, наоборот это очень удобный инструмент для работы с текстом. Однако для компонентной разработки, наиболее подходящим инструментом являются функции. Тут может появится закономерный вопрос: каким образом функции могут упростить работу над текстом?
Ведь сейчас вы получаете HTML + CSS от верстальщика/дизайнера, быстро вставили туда усики или директивы и аля компонент готов, а то и гляди вся страница. Да, безусловно тут фреймворки типа Vue/Angular выруливают и тихо плакал наш реакт в стороне. К сожалению, на практике я никогда не встречал дизайнера, который предоставлял HTML + CSS, а верстальщиком был некий мифический персонаж, которого никто не встречал в жизни, а в жизни многих компаний даже дизайнеры в штате — это выдуманные существа, и всю эту работу делает, правильно — фронтэндер. Именно поэтому часто в требованиях на работу мы встречаем подобное:
*— Опыт работы на Bootstrap восьмой версии не менее 10 лет.*
Если это ваш случай, то нет там разницы: верстать в начале HTML с усиками или сразу бацать компонент на чистых функциях. Хотя конечно, есть разница с функциями придется меньше стучать по клавишам.
### Королевство функции
Скорее всего вы уже догадываетесь, в этом мире будет править его величество функция, и все вокруг будут функции, теперь и компоненты — это функции, теги — тоже функции, в этом королевстве дискриминация коснется даже переменных, и опять в пользу функций. Тотальный расизм.
Однако в этом мире не все функции равны, есть обычные функции дворняги, а есть вельможи — [каррированые функции](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), видимо сам сэр [Карри Хаскелл](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8,_%D0%A5%D0%B0%D1%81%D0%BA%D0%B5%D0%BB%D0%BB) даровал им этот титул.
Далее в примерах, я буду использовать библиотеку [react-on-lambda](https://sultan99.github.io/react-on-lambda) от некого автора — меня, но вам ничего не мешает создать свой велосипед.
Окей, давайте посмотрим на этих вельмож:
```
import λ from 'react-on-lambda'
const postLink = λ.a({href: `/posts/123`})
```
На первый взгляд обычная функция, но есть характерная особенность, **postLink** — еще не HTML элемент и даже не реакт элемент, а функция, в которую можно пичкать пропсами и она будет всегда возвращать функцию, пока мы не передадим ей дочерний элемент в виде: строки, числа, другую лямбду функцию или пустое значение, и тогда свершится магия, вернется реакт элемент, который в конечном счете преобразуется в HTML.
К примеру так:
```
postLink(`Read more`)
// JSX equivalent
[Read more](”/posts/123”)
```
Ах, да вас могла смутить греческая буква: **λ** просто проигнорируйте, ее можно заменить на любой другой идентификатор к примеру:
```
import l from 'react-on-lambda'
// or
import {div, h1} from 'react-on-lambda'
```
Думаю такие причуды встречаются не впервые в js, для нас уже как родные символы **$ \_**, казалось бы какая связь с баксами и либой для манипуляции DOM. А лямбда пришлась мне по вкусу, так как она перекликается с названием самой либы.
И так в ходе выполнения программы, свойства элементов/компонентов можно собирать из разных кусочков, не прибегая к глобальным переменным, а главное можно строить point-free композиции:
```
const title = λ.compose(
λ.h1({className: `post-title`}),
postLink
)
const post = λ.div(
title(`How to use react on lambda?`),
λ.p(`
Lorem ipsum dolor sit amet,
Ernestina Urbanski consectetur adipiscing elit.
Ut blandit viverra diam luctus luctus...
`),
postLink(`Read more`)
)
render(
post,
document.getElementById(`app`)
)
```
С помощью композиции, мы создали новую функцию **title**, которая состоит из двух других функций **h1** и **postLink**. Передав значение в **title** мы получим кликабельный заголовок с текстом: "How to use react on lambda?". В композиции результат от одной функции передается в другую, причем поток данных происходит снизу-вверх.
Благодаря этой фишке, функции в композиции размещаются без вложенностей. Вспомните callback-и до появления **Promise** и **async/await**, как они напрягали, и как их только не обзывали: спагетти код, callback hell, pyramid of doom, christmas tree from hell, однако многоэтажные вложенности в HTML почему то никого не смущают.
Далее мы еще раз применили **postLink**, но уже с другим параметром, таким образом функцию мы использовали неоднократно. Безусловно, такое можно провернуть с JSX, завернув его в функцию, но тогда мы придём к главному вопросу, а может просто использовать только функции вместо JSX?
### Королевство React on λambda
Скорее это не королевство, а маленькое графство в королевстве функций. Предлагаю поближе познакомиться с [React on lambda](https://github.com/sultan99/react-on-lambda/blob/master/src/index.js):
Основные фичи библиотеки:
* на выходе получется [размер бандла меньше](https://github.com/sultan99/rol-vs-jsx), аж до 20% в сравнении с аналогичным проектом написанный на JSX;
* не требуется транспайлер (babel) или отдельной настройки webpack, работает прямо в браузере;
* плавная интеграция в существующий реакт проект с JSX.
Для более детального ознакомления предлагаю посмотреть на демо проекты:
* [rol-table](https://github.com/sultan99/rol-table)
* [rol-todos](https://github.com/sultan99/rol-todos)
**Креационизм в RoL**
Чтобы создать реакт элемент достаточно набрать:
```
import λ, {div} from 'react-on-lambda'
div({class: `sample`}, `Hello world!`) // you can use class instead className
// JSX equivalent
Hello world!
```
Свойства можно перекрывать:
```
const span = λ.span({class: `large`}) // -> function
span({class: `small`}, `Sorry we changed our mind`)
// JSX equivalent
Sorry we changed our mind
```
Существующие компоненты достаточно обернуть **λ**, чтобы получить из них функцию и все плюшки ФП.
```
λ(Provider, {store}, app)
// JSX equivalent
```
Все дочернии лямбда функции будут вызваны автоматически родительским элементом:
```
λ.div(
λ.div({class: `followers`}),
λ.br
)
```
То есть не обязательно их вызывать:
```
λ.div(
λ.div({class: `followers`})(),
λ.br()
)()
```
Это было сделано для удобства и простоты интеграции с другими библиотеками, такими как redux.
А дальше я бегло познакомлю вас с другими вспомогательными функциями. Хочу напомнить, что все подданные из **react-on-lambda** являются каррироваными функциями.
### λ.mapKey
Функция mapKey служит для перебора массивов.
```
const pages = [`Home page`, `Portfolio`, `About`]
λ.ul(
λ.mapKey(λ.li, pages)
)
// JSX equivalent
{pages.map((item, key) =>
* {item}
)}
```
Вставка ключа (key) будет автоматической и будет равна индексу элемента из массива. Автоматическая вставка ключа будет только если не был передан ключ.
### λ.mapProps
Функция для преобразования свойств объекта. Довольно спорная функция, ее можно получить из других сторонних библиотек, но я решил ее оставить.
```
const data = [
{id: 123, name: `Albert`, surname: `Einstein`},
{id: 124, name: `Daimaou `, surname: `Kosaka`},
]
const userList = λ.compose(
λ.div({class: `followers`}),
λ.ul,
λ.mapKey(λ.li),
λ.mapProps({key: `id`, children: `name`})
)
userList(data)
// JSX equivalent
const UserList = props => (
{props.data.map(user =>
* {user.name}
)}
)
```
### λ.log
Функция для отладки:
```
const userList = λ.compose(
λ.div,
λ.ul,
λ.log(`after mapping`), // -> will log piping value
λ.mapKey(λ.li)
)
```
### Стилизация компонентов
Для любителей [styled-components](https://www.styled-components.com/), есть встроенная обертка, которая возвращает стилизованный компонент в виде функции:
```
import λ from 'react-on-lambda'
const header = λ.h1`
color: #ff813f;
font-size: 22px;
`
const onClick = () => alert(`Hi!`)
const app = λ.div(
header(`Welcome to React on λamda!`),
λ.button({onClick}, `OK`)
)
```
Я намерено не стал пичкать библиотеку другим функционалом, так как множество фишек можно получить из библиотек: [ramda](https://ramdajs.com/), [rambda](https://github.com/selfrefactor/rambda), [lodash/fp](https://github.com/lodash/lodash/wiki/FP-Guide).
Ну на этом всё, буду рад вашим отзывам.
Берегите себя, да пребудет с вами святой функтор! | https://habr.com/ru/post/449114/ | null | ru | null |
# Как убить Lenovo G580 одним ударом
Помните недавний [баг EFI на Samsung 530U3C](https://bugs.launchpad.net/ubuntu-cdimage/+bug/1040557), который приводил к тому, что ноутбук больше не работал после единоразовой загрузки ubuntu?
**Встречайте EFI на Lenovo G580!**
Итак, в канун нового года и праздничных распродаж, [Adiost](http://habrahabr.ru/users/adiost/) купил Lenovo G580 с FreeDOS, снес его и установил Ubuntu. Через какое-то время захотел установить-посмотреть Windows 8. В ходе этого обнаружил, что не может зайти в настройки EFI нажатием кнопки F2: просто-напросто ничего не происходило и начинала грузиться ОС. Плюнув на это, установил Windows 8, и начал чинить.
Сначала нагрузил гугл. [Таких](http://forums.lenovo.com/t5/Lenovo-3000-and-Essential/BIOS-for-G580-notebook/td-p/890169) [симптомов](http://forums.fedoraforum.org/showthread.php?t=286538) — [полно](http://forums.lenovo.com/t5/Lenovo-3000-and-Essential/G580-Cannot-enter-BIOS-in-UEFI-mode/td-p/883737). Даже [на хабре](http://habrahabr.ru/sandbox/51889/) было. К сожалению, ни один из целых двух способов не помог. Из-под Windows NVRAM не менялся, а все дистрибутивы линукса грузились в режиме эмуляции BIOS, т.к. в EFI она была выбрана первой.
Немного информации: EFI NVRAM нельзя ни прочитать, ни изменить из-под ОС, загруженной в BIOS-режиме. Поэтому нужно было как-то запустить ОС через EFI. Для этого был установлен ArchLinux на флешку с GPT и GRUB2 в качестве EFI-загрузчика. Итак, ArchLinux загружен в EFI, отлично, запускаем efibootmgr, иии… пусто. Нет ни единого EFI-пункта, хотя при выборе устройства загрузки есть некий пункт «ubuntu», и это должен быть именно пункт, добавленный в NVRAM. При попытке удаления «наугад» записи под номером 0000, пункт загрузки сменил имя с ubuntu на Linux.
[Adiost](http://habrahabr.ru/users/adiost/) добавил пустой пункт и перезагрузился. Ноутбук разучился показывать меню загрузки, перестал грузиться вообще с чего либо безо всяких ошибок. Просто POST и все, вечнопустой экран, sad but true.
Из-за чего efibootmgr выдавал пустой результат — непонятно, но могу предположить, почему так получилось с настройкой EFI. Дело в том, что, видимо, на многих ноутбуках Lenovo в NVRAM хранятся не только пункты загрузки ОС, но и вообще все пункты.
Вот что выдает efibootmgr на моем X220:
```
BootCurrent: 0009
Timeout: 0 seconds
BootOrder: 0019,0009,000A,0006,000C,0007,0008,000B,000D,000E,000F,0010,0011,0012,0013
Boot0000 Setup
Boot0001 Boot Menu
Boot0002 Diagnostic Splash Screen
Boot0003 Startup Interrupt Menu
Boot0004 ME Configuration Menu
Boot0005 Rescue and Recovery
Boot0006* USB CD
Boot0007* USB FDD
Boot0008* ATAPI CD0
Boot0009* ATA HDD2
Boot000A* ATA HDD0
Boot000B* ATA HDD1
Boot000C* USB HDD
Boot000D* PCI LAN
Boot000E* ATAPI CD1
Boot000F* ATAPI CD2
Boot0010 Other CD
Boot0011* ATA HDD3
Boot0012* ATA HDD4
Boot0013 Other HDD
Boot0014* IDER BOOT CDROM
Boot0015* IDER BOOT Floppy
Boot0016* ATA HDD
Boot0017* ATAPI CD:
Boot0018* PCI LAN
Boot0019* arch_grub
```
По всей вероятности, Ubuntu перезаписала пункт Boot0000, которым и является Setup. Я попробовал удалить его у себя, и, к счастью, он пересоздался при перезагрузке ноутбука, но перезаписывать его новым не пробовал. | https://habr.com/ru/post/169985/ | null | ru | null |
# CLD — Open source проект для ИТ компаний и SRE/DevOps инженеров
CLD это система для обеспечения комплексной информационной безопасности и организации разграничения доступа к серверам и скриптам с возможностью оперативно внедрять пользовательские модули и инструменты автоматизации.
Мы высоко ценим автоматизацию процессов и унификацию инфраструктуры, проект призван объединить все используемые технологии в одном централизованном и самодокументируемом месте, с безопасным, прозрачным и логируемым доступом к любому серверу и инструменту сразу через несколько пользовательских интерфейсов (CLI, Web, API, Telegram, Discord, Mattermost, Slack).
Проект разработан в соответствии с принципами и правилами "Unix" философии, основой системы являются shell утилиты и дополнительные пользовательские интерфейсы (Web, API, Telegram, Discord, Mattermost, Slack) на Python, каждая из утилит подключает базовую микро библиотеку и выполняет определенную задачу, вместе они составляют логическое ядро.
Все данные хранятся в текстовых файлах с ограниченным доступом, ядро в свою очередь поддерживает работу с модулями.
Каждый модуль может содержать: утилиты, подключаемые элементы дополнительных пользовательских интерфейсов, readme файл, auditor файл (если для модуля требуется отдельный watchdog) и скрипты инициализации модуля.
Все компоненты модулей автоматически парсятся соответствующими компонентами ядра и подключаются к системе, также парсится Readme файл и help вывод имеющихся утилит по блокам (описание, аргументы, примеры использования) для последующей автоматической генерации документации проекта.
Дополнительные пользовательские интерфейсы являются универсальным средством авторизации для использования инструментов ядра и модулей.
При инициализации системы в каждом дополнительном интерфейсе генерируются методы валидации для возможности использования всех обнаруженных скриптов.
Любой имеющийся или кастомный скрипт помимо CLI может быть использован в браузере через консоль веб интерфейса, по API и через чат бота в поддерживаемых мессенджерах.
Веб интерфейс содержит разделы терминала в браузере с возможностью загрузки и скачивания файлов с любого инстанса и раздел администрирования доступный пользователям с ролью admin. Также веб интерфейс предоставляет разделы модулей, если в модуле есть поддержка веб интерфейса.
При доступе к системе в первую очередь используется аутентификация по PAM и доверенным спискам IP адресов на уровне ОС и веб сервера, авторизация доступа к инструменту использует несколько факторов валидации на уровне приложения/веб сервера и/или на уровне системы (sudoers файл генерируемый на основе матрицы доступов), любой имеющийся модуль или инструмент может быть расшарен для использования определенному пользователю через любой доступный интерфейс исключая при этом прямой доступ пользователей к коду скриптов, контенту модулей, а также ко всей директории системы.
Основу безопасности проекта обеспечивает acсess модуль. Он предоставляет пользователям возможность, генерировать персональные VPN ключи и обновлять IP адресы из которых составляются доверенные списки для инстансов в соответствии режимом политики сетевой безопасности. Также он отвечает за централизованное управление SSH ключами и деплой на удаленные серверы доверенных списков и правил фаервола(iptables) для закрытия чувствительных портов с возможностью тонкой настройки для отдельных инстансов или групп.
Важную роль в проекте играет самодокументирование. Каждый новый инструмент и модуль попадает в автоматически генерируемую документацию, это позволяет избежать утрату информации об его назначении и снизить издержки на коммуникацию в команде.
### Примеры использования
Для упрощенного понимания и визуализации концепции проекта ниже представлены несколько из множество возможных примеров использования.
В скринкастах использована ОС Android исключительно для минималистичного представления работы системы через несколько программных интерфейсов и демонстрации переключения между ними, разумеется при работе с системой в основном используются десктопные ОС, также в примерах используется следующее ПО:
* Termius в качестве SSH/SFTP клиента;
* Chromium бразуер при использовании веб интерфейса;
* Telegram, в качестве клиента одного из нескольких чат бот интерфейсов.
#### Централизованная система доступа и SSH гейт
Основой проекта является централизованная система доступа по SSH на основе PAM.
* Все CLD пользователи взаимодействуют с системой в соответствии в внутренней матрицей доступов и имеют настраиваемые разрешения, им могут быть назначены персональные ID аккаунтов мессенджеров, а также автоматически выдается API токен.
* Каждый пользователь авторизуется на сервере через соответствующую PAM учетную запись.
* Доступ к разрешенным серверам обеспечивается через единый приватный ключ или пароль учетной записи инстанса.
* Список разрешенных серверов для подключения пользователь определяется как указанием отдельного инстанса, так и расшариванием группы инстансов пользователю.
* SSH ключ и пароли с помощью которые происходит авторизация на удаленных инстансах не доступны пользователю.
На анимации продемонстрировано как пользователь пытается получить доступ к инстансам, затем admin используя панель управления расшаривает один из инстансов для пользователя, а затем группу инстансов, также демонстрируется работа интерактивного SSH гейта
#### Защита всех серверов на любом хостинге
Доступ на все серверы защищен по доверенным спискам IP адресов.
* Доступ к CLD серверу (как и ко всем подключенным к системе инстансам) ограничивается по доверенным спискам IP адресов.
* Модуль access предоставляет возможность обновлять пользовательские доверенные адреса через мессенджеры (Telegram, Discord, Mattermost, Slack).
* Пользователи могут сгенерировать персональные VPN ключи для доступа к CLD серверу и инстансам.
* Доверенные списки обновляются на инстансах по крону, также обновление инициируется службой аудита по триггеру при изменении в доверенных списках или матрице доступа.
* Списки разрешенных портов на серверах имеют возможность настройки, отдельные списки портов могут быть настроены как для отдельного инстанса так и для группы инстансов.
* Политика сетевой безопасности для всех инстансов представлена в трех режимах -general, private и paranoid:
+ general - Все доверенные IP адресы CLD пользователей имеют сетевой доступ к защищенным портам инстансов - значение по умолчанию;
+ private - Политика сетевых разрешений для каждого инстанса в соответствии с картой доступов;
+ paranoid - Как "private", но все внешние подключения к CLD серверу закрыты даже для `/api/all/*` эндпоинтов в API системы, обновление доверенных IP адресов возможно только через VPN подключение или через уже установленное SSH подключение через CLI и через мессенджеры с указанием IP адреса вручную, т.к. функционал авто определения IP адреса через API в этом политике безопасности недоступен.
На анимации продемонстрировано как пользователь пытается подключиться к серверу, соединение сбрасывается пока пользователь не обновит свой доверенный IP адрес через бота в мессенджере используя ссылку с одноразовым токеном.
#### Интеграция с CloudFlare
Управление DNS зонами в нескольких аккаунтах.
* Просмотр, редактирование и удаление DNS записей для любого домена через любой CLD интерфейс.
* Возможность управлять любыми настройками CloudFlare для домена, а также сбрасывать CDN кэш.
* Резервное копирование DNS зон во всех подключенных аккаунтах.
* Функционал переключения множества доменов с одного IP адреса на другой с авто определением какие домены направлены на текущих IP адрес.
* Поддержка инструментов просмотра гео данных адреса и whois.
* Инструмента для массового выпуска wildcard сертификатов всех подключенных доменов к CloudFlare через DNS валидацию.
На анимации продемонстрировано как пользователь используя различные интерфейсы запрашивает значение DNS записи для домена в терминале, удаляет запись через бота в мессенджере и задает другой адрес для DNS записи через терминал.
#### Единая точка доступа SFTP
Пользователи могут получить логируемый файловый доступ любого инстанса.
* Все файловые операции логируются по пути `/var/cld/log/session/$user/$date/$instance_sftp_$time.gz`.
* 2 инструмента для монтирования файловой системы инстанса: cld-mount (интерактив), cldxmount(монтируется первый инстанс после фильтрации).
* Пользовательские функции монтирования позволяют получить файловый доступ к любому типу серверов и контейнеров по любому протоколу.
* Данный функционал позволяет копировать, синхронизировать и перемещать данные с сервера на сервер без прямого доступа между ними.
На анимации продемонстрировано как пользователь монтирует файловую систему удаленного сервера, проверяет статус монтирования в командной строке и проверяет доступ к файлам через STTP клиент подключенный к CLD серверу.
#### Парсинг групп инстансов
Парсинг публичных облачных провайдеров, гипервизоров, систем оркестрации или чего угодно еще с использованием пользовательских скриптов парсинга инстансов.
* Тип группы "parsing" имеет пользовательский скрипт, он будет постоянно непрерывно синхронизировать списки инстансов в группу, вы всегда будете иметь доступ ко всем вашим серверам где бы они не находились.
* Парсинг любых облачных провайдеров может быть реализован - скрипт парсинга может использовать API или внешние инструменты CLI установленные на CLD сервер, скрипты парсинга ничем не ограничены.
* Встроенный парсинг групп: AWS cloud, Google cloud, Hetzner cloud, DigitalOcean, Azure cloud, Scaleway cloud, OVH cloud, Proxmox LXC, Docker containers, Kubernetes containers.
* Система парсинг инстансов сочетается с различными инструментами автоматизации и безопасности, такими как непрерывное обновление доверенных IP адресов и SSH ключей.
На анимации продемонстрировано как пользователь проверяет список группы инстансов Hetzner cloud, затем меняет тип группы на "parsing" с соответствующим скриптом в панели администрирования CLD, создает инстанс в Hetzner cloud, как только сервер создан он сразу доступен в CLD.
#### Управление KVM виртуальными машинами
Создание, управление и миграция KVM виртуальных машин на PVE гипервизорах:
* Интерактивное создание KVM виртуальных машин с выбором операционной системы, количества ядер процессора, объем ОЗУ, дискового пространства и сетевые настройки.
* Единая точка управления KVM виртуальными машинами на всех гипервизорах (не имеет значения находятся ли они в кластере, в различных ДЦ и т.д.), доступные команды: start, stop, pause, resume и delete.
* Скрипт деплоя PVE гипервизора с сетевыми настройками и конфигурацией стореджей.
* Интерактивная миграция виртуальных машин между гипервизорами с использованием pve-zsync, предварительная поэтапная синхронизация перед переключением (автоматическая миграция IP адресов поддерживается для некоторых хостинг-провайдеров).
* Парсинг доступных бэкапов для всех гипервизоров с прозрачным ежедневным отчетом в мессенджере.
На анимации продемонстрировано интерактивное создание KVM виртуальной машины через веб интерфейс модуля, после создания пользователь проверяет статус ВМ, получает SSH доступ через веб интерфейс и проверяет настройки и ресурсы указанные в процессе создания.
#### Пользовательские модули для любого функционала
Поддержка пользовательских модулей для расширения возможностей системы.
* Интерактивное создание по шаблону модуля, пользовательский API метод, веб страница редактирования модуля и пример shell утилиты.
* Модули расположены в директории `/var/cld/modules/`, модуль может содержать:
+ утилиты `bin/cld-*`;
+ Пользовательские методы интерфейсов `./{api,bot,web}.py`;
+ Пользовательские файлы web интерфейса `web/${module}.html`, `web/content/somefile.{css,js,svg}` и т.д.;
+ Файл документации `./README.md`;
+ Файл аудитор демона `./auditor`;
+ Данные пользовательских модулей рекомендуется располагать в директории `./data`;
* Пользовательские методы интерфейсов модуля могут быть связаны с друг другом, для примера как это реализовано в встроенном access модуле.
* Утилиты модуля могут быть написаны на любом языке программирования, включая компилируемые.
* Код CLD интерфейсов для стандартного запуска утилит модуля генерируется автоматически во время запуска systemd служб CLD интерфейсов, а также код пользовательских методов парсинг и загружается в интерфейсы автоматически.
На анимации продемонстрировано как администратор создает новый модуль, затем создает утилиту комплексного деплоя приложения и запускает ее используя чат бота в интерфейсе мессенджера.
#### Резервное копирование на любой случай
Организация системы резервного копирования конфигураций, файлов и баз данных.
* Независимые методы резервного копирования для каждого инстанса.
* Возможность задавать уникальные параметры, такие как данные для доступа к базам данных, пути к директориям, время выполнения, количество хранимых копий, список файлов, исключение расширений и сервер бэкапа для каждого метода.
* Резервное копирование выполняется на удаленном сервере бэкапа.
* Процесс резервного копирования оптимизирован для многопоточного копирования данных.
* Встроенные методы резервного копирования:
+ ETC: Бэкап файлов конфигурации расположенные в `/etc/` или другой директории;
+ Files: Бэкап файлов и директорий целиком позволяет быстро и удобно настраивать резервное копирование для необходимых элементов;
+ MongoDB: Настраиваемый бэкап баз данных MongoDB любого размера;
+ ClickHouse: Резервное копирование баз данных ClickHouse;
+ MySQL: Бэкап баз данных MySQL, с возможность выполнять локально на сервере базы данных или удаленно на бэкап сервере;
+ PostgreSQL: Бэкап баз данных PostgreSQL.
* Пользователи CLD могут создавать их собственные методы бэкапов, на примере расположенных в `/var/cld/modules/backup/methods`.
На анимации продемонстрировано создание конфигурации бэкап методов для пары инстансов и генерация отчета в мессенджере.
### Интерфейсы:
#### CLI
Основной интерфейс для работы CLD системы, многие основные скрипты работающие в интерактивном режиме разработаны для работы через CLI.
* CLI запуск валидируется пользовательскими алиасами в `~/.bashrc`;
* Каждый алиас содержит запуск через sudo;
* Список алиаслов и доступных CLD утилит в `/etc/sudoers` - генерируется утилитой `cld-initpasswd` в соответствии с матрицей доступов `/var/cld/creds/passwd`;
* Если модуль расшарен для пользователя, все утилиты модуля добавляются в алиасы и становятся через sudo для этого пользователя.
#### API
Интерфейс для доступа к не интерактивным инструментам через API.
* Код интерфейса написан на Python, используя Flask фреймворк;
* Пример запроса: `https://cld.example.com/api/${TOOL}?token=${USER_TOKEN}&args=${ARGUMENTS}`;
* Токены пользователей хранятся в файле `/var/cld/creds/passwd`, персональный токен пользователя доступен через веб интерфейс в разделе профиль;
* Во время запроса, утилита выполняется с предоставленными аргументами через GET аргумент args;
* Необходимые аргументы:
+ token - API токен пользователя CLD.
* Доступные GET аргументы:
+ args - аргументы командной строки будут переданы к CLD утилите как есть с учетом regex фильтрации;
+ output - "plain" или "html" - если задано "html" значение, цветной вывод консоли будет преобразован в html - значение по умолчанию: "plain";
+ mode - пример `?token=${USER_TOKEN}&args=${ARGUMENTS}&mode=track`
- stream - вывод будет передаваться построчно в режиме реального времени, есть возможность наблюдать за прогрессом выполнения, но код ответа будет всегда 200 - это значение по умолчанию;
- track - вывод будет задан как plain/text и будет доступен только после завершения выполнения CLD утилиты, код ответа зависит от кода возврата скрипта:
* если CLD утилита вернет код 0 (без ошибок) - код ответа API будет 200;
* в ином случаи код будет 500 - может быть полезно для отслеживания статуса в CI/CD системах.
* Доступны пользовательские API эндпоинты и функции;
* Во время запуска API интерфейса (systemd служба cld-api) производятся следующие операции:
+ Поиск всех доступных утилит и генерация кода для каждой утилиты с соответствующим эндпоинтом (часть "cld-" обрезается в эндпоинте);
+ Поиск [api.py](http://api.py) файлов в корне каждого модуля, этот код выполняется как есть как часть всего API интерфейса.
* Пример использования пользовательских эндпоинтов и функций можно посмотреть в access модуле, файл `/var/cld/modules/access/api.py`;
* Локейшен /api/:
+ Доступны только для доверенных списков адресов;
+ Автоматически генерируемые эндпоинты для утилит создаются в контексте этого локейшена;
+ Доверенными списками адресов для nginx генерируются в файл `/etc/nginx/accesslist`.
* Локейшен /api/all/:
+ Доступен для всех IP адресов, исключая запрещенный список и если не используется сетевая политика безопасности "paranoid";
+ Может быть доступен только для пользовательских эндпоинтов;
+ Количество запросов для локейшена `/api/all/` ограничено до 60 запросов в минуту.
#### Bot
Telegram/Discord/Mattermost/Slack чат бот интерфейсы для выполнения утилит вне интерактивного режима:
* Код интерфейса каждого чат бота написан на Python;
* При отправке команды в чат или боту напрямую, утилита выполняется с переданными аргументами прошедшими regex фильтрацию;
* Пример выполнения команды: `/command arg1 arg2` (первый символ может отличаться, или не требоваться, как к примеру в Mattermost и Slack);
* Доступ валидируется на уровне приложения на основе ID пользователя, заданного в файле `/var/cld/creds/passwd`;
* Вывод от выполнения утилиты отображается в режиме реального времени через обновление ответного сообщения от бота;
* При запуске бот интерфейса (systemd служб cld-tgbot/cld-dcbot/cld-mmbot/cld-slbot) производятся следующие операции:
+ Поиск всех доступных утилит и генерация кода команды для каждого инструмента (по аналогии с API интерфейсом, "cld-" обрезается из имени каждого инструмента);
+ Поиск [bot.py/mmbot.py/dcbot.py/slbot.py](http://bot.py/mmbot.py/dcbot.py/slbot.py) файлов в корне каждого модуля, этот код выполняется как часть данного чат бот интерфейса.
* Доступны пользовательские команды и функции;
* Пример использования пользовательских команд и функций можно посмотреть в access модуле, файл `/var/cld/modules/access/bot.py`;
* Для расшаривания модуля или утилиты для чат группы необходимо создать отдельного пользователя в CLD и назначить ему ID чат группы мессенджера, ID можно запросить у бота в любом мессенджере командой /getid.
#### Web
Вспомогательный интерфейс для работы с системой
* Код интерфейса написан на Python используя Flask фреймворк и различные модули, например, SocketIO.
* Интерфейс предоставляет различный функционал для управления системой.
* Имеет доступ ко всем CLI элементам включая интерактивные через веб терминал в браузере.
+ Браузерная веб консоль реализована с использование XtermJS и SocketIO.
* Позволяет работать с системой через веб консоль вообще без использования SSH клиента.
* Во время запуска веб интерфейса (systemd служба cld-web) производятся следующие операции:
+ Поиск всех доступных утилит и генерация кода для каждой утилиты с соответствующим эндпоинтом (часть "cld-" обрезается в эндпоинте);
+ Поиск [web.py](http://web.py) файлов в корне каждого модуля, этот код выполняется как часть данного чат бот интерфейса;
- Если [web.py](http://web.py) найден в корне модуля, создается симлинк к `/var/cld/web/modules/${MODULE}/web` директории от `/var/cld/web/modules/${MODULE}` для доступа к файлам статики модуля снаружи Flask директории приложения.
* Каждый отображаемый блок модуля на главной странице веб интерфейса генерируется если [web.py](http://web.py) файл обнаружен и направляется на индекс эндпоинт указанный в [web.py](http://web.py) коде модуля;
+ Имя и описание модулей указывается в свойствах `webmodule` объекта заданном в [web.py](http://web.py) файле каждого модуля, пример можно посмотреть в файле веб интерфейса модуля документации - `/var/cld/modules/doc/web.py`;
+ Логотип модуля будет отображен если находится по пути `/var/cld/web/modules/${MODULE}/content/logo.svg`, в обратном случаи будет отображен стандартный логотип.
* В качестве текстового редактора в веб интерфейсе используется [Ace Cloud9 Editor](https://github.com/ajaxorg/ace).
### Модульный концепт
Внутренняя структура CLD включает систему модулей, которая позволяет существенно расширить базовый функционал и быстро интегрировать любые внешние сервисы. В качестве ознакомления ниже представлен краткий список из некоторых встроенных модулей:
* access - Контроль доступа к серверам по доверенным спискам и централизованное управление SSH ключами;
* backup - Резервное копирование файлов, баз данных и конфигураций CLD инстансов;
* ansible - Запуск плейбуков из стореджа на CLD инстансах доступных пользователю;
* kubernetes - Управление несколькими кластерами, хранилище helm чартов и деплой доверенных списков адресов в ingress;
* cm - создание/управление/миграция виртуальных машин на базе Proxmox Virtual Environment;
* dns - Интеграция с CloudFlare для массового управления DNS записями сразу в нескольких аккаунтах;
* doc - Ядро системы самодокументации - генерация документации на основе парсинга [Readme.md](http://Readme.md) файлов и help вывода всех имеющихся утилит и модулей.
Система спроектирована таким образом, чтобы добавление новых функциональных модулей для любых целей происходило максимально быстро за счет унификации и автоматической генерации кода для API и чат ботов мессенджеров, некоторые из CLD систем содержат до сотни пользовательских модулей предоставляющие самый разнообразный функционал и автоматизацию включая комплексные CI/CD решения.
Доступ к модулям через CLI, чат боты, API и через веб интерфейс отдельно настраивается для каждого пользователя.
### Установка
CLD необходимо устанавливать на **чистую операционную систему**, рекомендуется использовать Centos 8 Stream, т.к. работа с этим дистрибутивом наиболее хорошо протестирована в продакшене.
### Рекомендованные системные требования:
* Virtualization: KVM/Bare metal;
* Поддерживаемые ОС: Centos 7/8, Debian 9/10;
* Процессор: 1 ядро;
+ 1 дополнительное ядро на каждые 500 инстансов.
* ОЗУ: 2 Гб;
+ 1 Гб дополнительной ОЗУ на каждые 500 инстансов.
* Дисковое пространство: 20 Гб;
+ 10 Гб дополнительно на каждые 500 инстансов.
* Прямой публичный ip адрес.
### Данные необходимые для функционирования интерфейсов и модулей
Перед установкой следует подготовить следующее:
* Для интерфейсов (чтобы использовать любой доступный пользовательский интерфейс):
+ Web/API - Подготовить и направить на CLD сервер DNS имя для веб и API интерфейсов ([cld.example.com](http://cld.example.com)).
+ Чат бот:
- Telegram bot token (<http://t.me/BotFather>);
- Discord bot token (<https://discord.com/developers/applications>);
- Расширенная CLD лицензия:
* Mattermost url, port, team, bot token (<https://example.com/yourteam/integrations/bots>);
* Slack app token, bot token (<https://example.slack.com/apps/manage>).
* Для модулей (пример информации которая может быть затребована init скриптами модулей):
+ `cm` - API реквизиты доступа для поддерживаемых bare metal хостинг провайдеров `OVH`/`Online.net`/`Hetzner`;
+ `dns` - Реквизиты доступа к CloudFlare аккаунтам (`login`, `API key`, `user ID`);
+ `zabbix` - Реквизиты доступа к Zabbix server (`login`, `password`, `domain`, `url for Zabbix API`);
+ Информация по данным остальных модулей доступна на странице документации в разделе каждого модуля ( <https://classicdevops.com/documentation/> ).
### Быстрый старт
Установка может быть произведена следующей командой:
```
bash -x <(wget -qO- "https://raw.githubusercontent.com/classicdevops/cld/master/setup/install_cld.sh")
```
В процесс установки будут выполнены все инициализационные скрипты и модулей, для каждого из них в интерактивном режиме будет запрошена активация модуля и дальнейшие инициализационные данные, будет предоставлен пример для каждого поля ввода.
После завершения установки в консоль будут выведены пароль для пользователя admin и ссылка на веб интерфейс.
### Политика поддержки
Пожалуйста не задавайте вопросы в github issues. Такой формат не очень хорошо подходит для ведения FAQ.
Если у Вас есть вопрос, пожалуйста создайте его на [**ServerFault**](https://serverfault.com/questions/ask?tags=cld%20classicdevops).
Укажите к вопросу тэги `cld` и `classicdevops` (оба сразу).
Мы непрерывно парсим список вопросов по этим тэгам, получаем уведомления и постараемся ответить так быстро насколько это возможно. Делайте ваш пользовательский опыт доступным для всех!
[GitHub](https://github.com/classicdevops/cld/issues) issues только для подтвержденных багов и запросов фич. Если у вас есть идея, пожалуйста опишите ее с точки зрения использования и как вы видите желаемый результат.
### Заключение
Хотелось бы отметить, что CLD берёт на себя решение сразу несколько действительно важных задач, от которых напрямую зависит безопасность и эффективность инфраструктуры компании. Комплексный подход позволяет организовать работу по направлениям которые тесно связаны и нуждаются в стандартизированной реализации. Эффективное обеспечение безопасности инфраструктуры предполагает наличие удобных и надежных инструментов защиты, прозрачности процессов, управления доступом и логирования. Руководствуясь основными принципами информационной безопасности: CLD приемлет открытую архитектуру ИС, стойкость, контроль над всеми операциями и простоту использования.
Для Linux системного администратора или DevOps инженера CLD представляет единый набор технологий и инструментов, интеграция и последующее использование не вызовет особых сложностей, а с учетом уже разработанной подробной документации - позволит в короткие сроки начать использовать продукт.
Статус открытого программного обеспечения подразумевает возможность бесплатного использования CLD в своих целях любым пользователем.
Авторы статьи:
Александр Чендев
Александр Багринцев
Контакт: root@classicdevops.com
Ссылки:
[Github](https://github.com/classicdevops/cld)
[Документация](https://classicdevops.com/documentation/)
[Сайт проекта](https://classicdevops.com) | https://habr.com/ru/post/659023/ | null | ru | null |
# Пять Docker-утилит, о которых вам стоит узнать
*[Источник](http://www.mrwallpaper.com/wallpapers/diving-with-whales.jpg) изображения*
На просторах сети Интернет можно найти немало полезных утилит для [Docker](https://xebialabs.com/plugins/docker/). Многие из них принадлежат к разряду Open Source и доступны на Github. В последние два года я достаточно активно использую Docker в большинстве своих проектов по разработке программного обеспечения. Однажды начав работать с Docker, вы осознаете, что он оказывается полезен для гораздо более широкого круга задач, нежели вы изначально предполагали. Вам захочется сделать с Docker еще больше, и он не разочарует!
Docker-сообщество живет активной жизнью, ежедневно производя новые полезные инструменты. За этой бурной деятельностью достаточно сложно уследить. Поэтому я решил выбрать несколько наиболее интересных и полезных из ежедневно используемых мной Docker-утилит. Они делают работу более продуктивной, автоматизируя операции, которые пришлось бы выполнять вручную.
Давайте посмотрим на утилиты, которые помогают мне в процессе докеризации всего и вся.
1. [Watchtower](https://github.com/v2tec/watchtower) — автоматическое обновление Docker-контейнеров
---------------------------------------------------------------------------------------------------
Watchtower мониторит выполняющиеся контейнеры и отслеживает изменения в образах, на основе которых они были созданы. Если образ изменился, Watchtower автоматически перезапускает контейнер, используя новый образ. Это удобно при локальной разработке, если есть желание работать с самыми новыми версиями используемых инструментов.
Утилита Watchtower также поставляется в виде Docker-образа и выполняется в контейнере. Для ее запуска введите следующую команду:
Мы запустили Watchtower с примонтированным файлом **/var/run/docker.sock**. Это нужно для того, чтобы Watchtower мог взаимодействовать с демоном Docker через соответствующий API. Мы также передали опцию **interval**, равную 30 секундам, которая определяет интервал опроса. У Watchtower есть и другие опции, которые описаны в [документации](https://github.com/v2tec/watchtower#options).
Давайте запустим контейнер и помониторим его с помощью Watchtower.
Теперь Watchtower начнет мониторинг контейнера **friendlyhello**. Если я размещу новый образ на Docker Hub, Watchtower во время очередного запуска это обнаружит. Затем она корректно остановит контейнер и перезапустит его из нового образа. Также контейнеру будут переданы указанные нами в команде `run` опции, то есть он будет запущен с **-p 4000:80**.
По умолчанию Watchtower будет искать новые версии образов в реестре Docker Hub. При этом Watchtower может опрашивать закрытые реестры, используя для входа учетные данные из переменных окружения REPO\_USER и REPO\_PASS.
Более подробную информацию о Watchtower вы можете найти [в документации](https://github.com/v2tec/watchtower/blob/master/README.md).
2. [Docker-gc](https://github.com/spotify/docker-gc) — удаление ненужных контейнеров и образов
----------------------------------------------------------------------------------------------
Утилита docker-gc помогает очистить Docker-хост, удалив более не нужные образы и контейнеры. Удаляются контейнеры, завершенные более часа назад, а также образы, не принадлежащие ни одному из оставшихся контейнеров.
Docker-gc может запускаться в виде скрипта или контейнера. Мы воспользуемся вторым вариантом. Запустим docker-gc, чтобы узнать, какие контейнеры и образы можно удалить.
Чтобы docker-gc мог взаимодействовать с Docker через его API, мы подмонтировали сокет-файл Docker. Для поиска контейнеров и образов, которые можно удалить, запустим docker-gc с переменной окружения DRY\_RUN=1. При этом никаких изменений на диске сделано не будет. Всегда лучше сначала убедиться, что docker-gc не собирается удалить ничего лишнего. Вот вывод этой команды:
Если вы согласны с предложенным docker-gc планом очистки, запустите ту же команду, но теперь уже без DRY\_RUN.
В выводе будут перечислены удаленные docker-gc контейнеры и образы.
У docker-gc есть еще несколько опций. Чтобы получить более подробную информацию об этой утилите, рекомендую почитать [соответствующую документацию](https://github.com/spotify/docker-gc/blob/master/README.md).
3. [Docker-slim](https://github.com/docker-slim/docker-slim) — волшебная пилюля, которая поможет вашим контейнерам похудеть
---------------------------------------------------------------------------------------------------------------------------
Обеспокоены размером ваших Docker-образов? Вам поможет docker-slim!
Эта утилита использует статический и динамический анализ для создания легковесных вариантов Docker-образов. Чтобы поработать с docker-slim, загрузите бинарник с [Github](https://github.com/docker-slim/docker-slim/releases) (доступны версии для Linux и Mac), а затем добавьте путь к исполняемому файлу в переменную окружения PATH.
С помощью [инструкции из официальной документации Docker](https://docs.docker.com/get-started/) я создал образ для демонстрационного приложения **friendlyhello**. Размер образа составил 194 МБ.
Для очень простого приложения нам пришлось загрузить 194 МБ! Посмотрим, сколько мегабайт можно скинуть с docker-slim.
Инспектируя исходный образ, docker-slim выполнит несколько шагов, а затем создаст его облегченную версию. Посмотрим, какой в итоге получился размер:
На иллюстрации видно, что размер образа уменьшился до 24.9 МБ. Если запустить контейнер, то он будет работать точно так же, как и его предыдущая версия. Docker-slim хорошо справляется с приложениями на Java, Python, Ruby и Node.js.
Попробуйте docker-slim сами, и, возможно, это позволит вам освободить немало места. Эта утилита корректно отработала практически во всех моих проектах. Получить более подробную информацию о docker-slim можно из соответствующей [документации](https://github.com/docker-slim/docker-slim/blob/master/README.md).
4. [Rocker](https://github.com/grammarly/rocker) — преодолеваем ограничения Dockerfile
--------------------------------------------------------------------------------------
Большинство разработчиков для сборки образов предпочитают использовать Dockerfile. Dockerfile — это декларативный способ определения команд по созданию образа, которые пользователь мог бы выполнить в командной строке.
[Rocker](https://github.com/grammarly/rocker) добавляет в Dockerfile набор новых инструкций. Rocker был создан в [Grammarly](https://tech.grammarly.com/blog/posts/Making-Docker-Rock-at-Grammarly.html) для решения проблем, с которыми эта компания столкнулась при использовании Dockerfile. В Grammarly написали [содержательную статью](https://tech.grammarly.com/blog/posts/Making-Docker-Rock-at-Grammarly.html), объясняющую причины создания Rocker. Если у вас есть желание лучше разобраться с Rocker, рекомендую эту статью к прочтению. В ней отмечены две проблемы:
1. Размер образов.
2. Скорость сборки.
Там также упоминается несколько добавленных Rocker инструкций. Для получения информации о всех поддерживаемых Rocker инструкциях см. [документацию](https://github.com/grammarly/rocker/blob/master/README.md).
1. MOUNT — позволяет настроить совместное использование томов различными сборками, что удобно, например, для инструментов управления зависимостями.
2. FROM — эта инструкция существует и в стандартном Dockerfile. При этом Rocker позволяет добавить несколько FROM в один файл. Это значит, что с помощью одного Rockerfile можно сделать несколько образов, например, один для сборки, а другой для выполнения приложения. Первый набор инструкций соберет артефакт, используя все необходимые зависимости. Второй набор инструкций может использовать артефакт, созданный на первом шаге. С помощью этого приема достигается значительное уменьшение размера образа.
3. TAG позволяет на разных этапах сборки создавать метки образа, то есть вручную это делать больше не нужно.
4. PUSH используется для загрузки образов в реестр.
5. ATTACH позволяет интерактивно подключаться к контейнеру на промежуточных этапах сборки, что очень удобно для отладки.
Rocker требует установки. Для пользователей Mac команды следующие:
Rockerfile выглядит вот так:
Для сборки образа и загрузки его на Docker Hub выполните:
У Rocker очень интересная функциональность. Чтобы узнать больше, обратитесь к его [документации](https://github.com/grammarly/rocker/blob/master/README.md).
5. [Ctop](https://github.com/bcicen/ctop) — top-подобная утилита для вывода информации о контейнерах
----------------------------------------------------------------------------------------------------
Я начал пользоваться ctop сравнительно недавно. Эта утилита в реальном времени отображает метрики сразу нескольких контейнеров. Если вы используете Mac, то для установки ctop можете воспользоваться следующей командой:
Для работы ctop требуется установка переменной окружения DOCKER\_HOST.
Выполните `ctop`, чтобы отобразить состояние всех контейнеров.
Для вывода информации только о запущенных контейнерах выполните `ctop -a`.
Ctop проста в использовании и при этом весьма полезна. Более подробную информацию вы можете найти в [документации](https://github.com/bcicen/ctop/blob/master/README.md).
Ссылки:
1. Оригинал: [5 Docker Utilities You Should Know](https://blog.xebialabs.com/2017/05/18/5-docker-utilities-you-should-know/). | https://habr.com/ru/post/330326/ | null | ru | null |
# Третий глаз для незрячих
В этом посте мы расскажем про «Третий глаз» для незрячих – новшество, которое помогает незрячим людям ориентироваться со скоростью и уверенностью, находя близлежащие препятствия с помощью ультразвуковых волн и уведомляя их звуковым сигналом или вибрацией. Им нужно только носить это устройство как эластичную ленту. Под катом — разбираемся как это работает и может ли подарить людям без зрения надежду снова увидеть мир.
---
По данным ВОЗ, во всем мире незрячими считаются 39 миллионов человек. В повседневной жизни такие люди испытывают много трудностей. Пострадавшие уже много лет используют традиционную белую трость, которая, хотя и эффективна, всё же имеет много недостатков. Другой способ – собака-поводырь, но она дорого стоит. Поэтому цель проекта – разработка более эффективного устройства, которое поможет незрячим людям ориентироваться уверенно, комфортно и быстро. Посмотрим, что же за устройство перед вами?
* Первая носимая электроника для незрячих.
* Оно обнаруживает препятствия ультразвуком.
* Уведомляет пользователя с помощью вибрации или зуммера.
Как это работает?
-----------------
Что нового предлагает проект?
-----------------------------
Этот проект – первая носимая технология для незрячих, решающая все проблемы существующих технологий. Сейчас есть много инструментов и смарт-устройств, облегчающих передвижение незрячих, но у большинства этих технологий есть определённые проблемы с переноской, а также основной недостаток: нужно много времени, чтобы научиться ими пользоваться.
Одна из главных особенностей нового устройства в том, что оно доступно каждому и стоит меньше 25 долларов (~1500 рупий). На рынке нет столь же простых и недорогих устройств, которые можно носить, как одежду. Если устройство улучшить и если оно будет использоваться массово, это принесёт обществу огромную пользу.
Шаг 1. Существующие системы
---------------------------
* Белая трость.
* Собака-поводырь.
* Смарт-устройства (например, Vision).
Проблемы существующих систем
----------------------------
* Белая трость может легко треснуть или сломаться, палка может застрять в трещинах.
* Собака-поводырь дорого стоит (42 000 долларов, или 280 000 индийских рупий).
* Общие недостатки (включая смарт-устройства). **Их непросто переносить**, а чтобы научиться пользоваться, нужно много времени.
**Особенности устройства для незрячих**. С «Третьим глазом» можно отказаться от белой трости и других подобных устройств. Он поможет незрячим ориентироваться, но не держать в руках палку, которая немного раздражает их. Можно носить его как ленту, и он будет работать очень точно. «Третий глаз» не требует много времени на обучение.
Шаг 2. Полное описание проекта
------------------------------
На основе платы Arduino я разработал специальное носимое устройство, которое незрячие смогут носить как одежду. Это устройство оснащено пятью ультразвуковыми датчиками, состоящими из пяти модулей, которые соединены с разными частями тела. Два датчика для плеч, ещё два для колен и один на руку. С помощью этих пяти датчиков незрячие смогут обнаружить объекты, представляя их положение с пяти точек зрения, и смогут легко перемещаться в любом месте. При обнаружении препятствия устройство уведомляет пользователя вибрацией и звуковыми сигналами. Интенсивность вибрации и частота звуковых сигналов увеличиваются с уменьшением расстояния, а устройство полностью автоматическое.
**Проект может быть исполнен в виде жилета, так что устройство не нужно носить как отдельную вещь в руке.** Специально разработанная плата вместо arduino, а также датчики высокого качества ускорят реакцию устройства на препятствия – так «Третий глаз» будет способен работать в многолюдном пространстве.
В фильме "Бладшот" у незрячего персонажа была подобная система, сделанная в виде жилета, обеспечивающая ему зрение на 360 градусовА вот так незрячий человек работает с «Третьим глазом»Шаг 3. Компоненты прототипа
---------------------------
Компоненты и инструменты#### Компоненты
* Пять SparkFun Arduino Pro Mini 328 - 5V/16MHz
* Пять ультразвуковых датчиков.
* Пять перфорированных плат.
* Пять вибрационных двигателей.
* Пять зуммеров.
* Пять красных светодиодов.
* Пять переключателей с ползунком.
* Коннектор на 40 штырьков и гнездовая колодка на 8 разъёмов 0,1".
* Четыре подвесных провода.
* Старая мобильная батарейка 3,3В.
* Литий-полимерный аккумулятор 3.7В
* Лента и наклейки, чтобы устройство можно было надеть.
#### Инструменты
* Универсальный паяльник
* Универсальный термоклеевой пистолет
* Arduino IDE
**Инструкция сборки:**
Заземлите светодиод, зуммер и вибрационный двигатель на цифровую землю Arduino.
* Положительный полюс светодиода и средней ножки переключателя – к выводу Arduino pin-5.
* Положительный полюс зуммера – к первой ножке переключателя.
* Положительный полюс вибрационного двигателя – к третьей ножке переключателя.
* Ультразвуковой датчик.
* VCC ультразвукового датчика к VCC Arduino.
* Заземлите ультразвуковой датчик н цифровое заземлению Arduino.
* Ультразвуковой датчик Trig подключите к Arduino к разъёму pin-12.
* Ультразвуковой датчик Echo подключите к Arduino pin-12.
> Переключатель нужен для выбора режима: зуммер или вибрация.
>
>
Шаг 4. Сборка модулей
---------------------
Рис. 2 – Питание модулей. Подключите 4 штуки Arduino Pro Mini к разъёму USB и блоку питания. Для модуля в руке воспользуйтесь небольшой литиевой батареей.* Обрежьте перфорированную плату до размера 5 х 3 см и припаяйте к плате гнёзда Arduino.
* Припаяйте зуммер.
* С помощью клеевого пистолета подсоедините вибрационный двигатель и припаяйте к нему провода.
* Присоедините LED.
* Присоедините переключатели.
* Затем подключите контакты ультразвуковых датчиков и входа батареи.
* Выполните припой, как показано на принципиальной схеме платы.
* Теперь подключите к плате Arduino и ультразвуковой датчик.
Соедините все модули эластичной лентой.
**То же самое нужно сделать с ещё тремя модулями, но датчик в руке делается несколько иначе. Посмотрите следующий шаг перед тем, как начнёте его делать.**
Шаг 5. Код и изготовление модуля для руки
-----------------------------------------
* Четырьмя соединительными кабелями подключите ультразвуковой датчик к плате.
* Затем подключите к этому модулю мобильную батарею напряжением в 3,7 В.
* Добавьте резинку, как показано на рисунке.
Наконец, загрузите код на каждую плату Arduino и включите 4 других модуля с помощью внешнего аккумулятора.
**Код для Arduino**
```
//VISIT : www.robotechmaker.com
const int pingTrigPin = 12; //Trigger connected to PIN 7
const int pingEchoPin = 10; //Echo connected yo PIN 8
int buz=5; //Buzzer to PIN 4
void setup() {
Serial.begin(9600);
pinMode(buz, OUTPUT);
}
void loop()
{
long duration, cm;
pinMode(pingTrigPin, OUTPUT);
digitalWrite(pingTrigPin, LOW);
delayMicroseconds(2);
digitalWrite(pingTrigPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingTrigPin, LOW);
pinMode(pingEchoPin, INPUT);
duration = pulseIn(pingEchoPin, HIGH);
cm = microsecondsToCentimeters(duration);
if(cm<=50 && cm>0)
{
int d= map(cm, 1, 100, 20, 2000);
digitalWrite(buz, HIGH);
delay(100);
digitalWrite(buz, LOW);
delay(d);
}
Serial.print(cm);
Serial.print("cm");
Serial.println();
delay(100);
}
long microsecondsToCentimeters(long microseconds)
{
return microseconds / 29 / 2;
}
```
> [**Файл .ino**](https://hacksterio.s3.amazonaws.com/uploads/attachments/315262/Third_eye_for_blinds.ino)
>
>
### Схемы
#### Принципиальная схема 1
Код для Arduino
---------------
```
//VISIT : www.robotechmaker.com
const int pingTrigPin = 12; //Trigger connected to PIN 7
const int pingEchoPin = 10; //Echo connected yo PIN 8
int buz=5; //Buzzer to PIN 4
void setup() {
Serial.begin(9600);
pinMode(buz, OUTPUT);
}
void loop()
{
long duration, cm;
pinMode(pingTrigPin, OUTPUT);
digitalWrite(pingTrigPin, LOW);
delayMicroseconds(2);
digitalWrite(pingTrigPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingTrigPin, LOW);
pinMode(pingEchoPin, INPUT);
duration = pulseIn(pingEchoPin, HIGH);
cm = microsecondsToCentimeters(duration);
if(cm<=50 && cm>0)
{
int d= map(cm, 1, 100, 20, 2000);
digitalWrite(buz, HIGH);
delay(100);
digitalWrite(buz, LOW);
delay(d);
}
Serial.print(cm);
Serial.print("cm");
Serial.println();
delay(100);
}
long microsecondsToCentimeters(long microseconds)
{
return microseconds / 29 / 2;
}
```
Вот и все, надеюсь вам был интересен данный материал.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=150321), как прокачаться в перспективных специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=150321)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=150321)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=150321)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=150321)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=150321)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=150321)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=150321)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=150321)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=150321)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=150321)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=150321)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=150321)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=150321)
**КУРСЫ**
* [Курс по 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=150321)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=150321)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=150321)
* [Курс "Математика и 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=150321)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=150321)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=150321)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=150321)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=150321) | https://habr.com/ru/post/547112/ | null | ru | null |
# Четыре способа извлечения значений из скрытых полей в C#
Добрый день. Не так давно на хабре проскакивала статья, в которой показывалась возможность обращения к закрытым полям объекта из другого экземпляра того же класса.
```
public class Example
{
private int JustInt;
// Some code here
public void DoSomething(Example example)
{
this.JustInt = example.JustInt; // Вполне валидная строка, некоторых удивляет
}
}
```
#### Способ 1, не совсем честный: используем protected поля и наследников
Пусть у нас есть класс:
```
public class SecretKeeper
{
private int _secret; // Наше приватное поле
// Для упрощения тестирования
public int Secret{get { return _secret; } set { _secret = value; }}
}
```
Добавим в него protected свойство:
```
protected int SecretForInheritors => _secret; // Теперь наследники могут читать _secret
```
И добавим класс наследник:
```
public class SecretKeeperInheritor : SecretKeeper
{
public int GetSecret()
{
return SecretForInheritors;
}
}
```
Проверяем код:
```
var secret = new SecretKeeperInheritor {Secret = 42}.GetSecret();
Console.WriteLine
(
secret == 42 ? "Inheritors test: passed" : "Inheritors test: failed"
);
```
Иногда способ используется для тестирования: добавление protected поля не меняет публичный контракт класса, наследник создается в тестовом проекте. Помогает избегать заглушек (mocks\stubs) в тестовых методах. Модификацией этого метода можно считать использование internal полей и InternalVisibleTo атрибута в AssemblyInfo.
Недостатки: приходится создавать\поддерживать дополнительное поле, либо менять старое, для чего нужен как минимум доступ к классу. Для внешней библиотеки не применить. Если у класса есть наследники — для них изменится контракт класса, что увеличивает вероятность сделанной в будущем ошибки.
#### Способ 2, классический: рефлексия с GetMemberInfo
Снова используем тестовый класс:
```
public class SecretKeeper
{
private int _secret;
// Для упрощения тестирования
public int Secret{get { return _secret; } set { _secret = value; }}
}
```
Создадим статический класс с методом для извлечения секрета:
```
public static class SecretFinder
{
public static int GetSecretUsingFieldInfo(this SecretKeeper keeper)
{
FieldInfo fieldInfo = typeof (SecretKeeper).GetField("_secret", BindingFlags.Instance | BindingFlags.NonPublic);
int result = (int)fieldInfo.GetValue(keeper);
return result;
}
}
```
Протестировать можно кодом:
```
SecretKeeper keeper = new SecretKeeper {Secret = 42}; // Создаем объект с секретом
int fieldInfoSecret = keeper.GetSecretUsingFieldInfo(); // Извлекаем секрет
Console.WriteLine
(
fieldInfoSecret == 42 ? "FieldInfo test: passed" : "FieldInfo test: failed" // Немного форматируем вывод
);
```
Способ годится в случаях, когда нет доступа к коду SecretKeeper, или нет желания менять контракт класса. Иногда такой код можно увидеть в продакшне: разрабатывается новая версия библиотеки, потребовался доступ к private полю, менять текущий класс нельзя, ибо «работает — не трогай». Иногда применяется в тестировании, когда менять исходный класс нет времени. Если все-таки используете подобный вариант — помните про возможность закешировать FieldInfo (MemberInfo).
Недостатки: завязка на имя поля, что может аукнуться при рефакторинге. Кроме того, рефлексия — инструмент достаточно медленный.
#### Способ 3, ускоренный классический: рефлексия с ExpressionTrees
Рефлексию вполне можно приготовить для шустрой работы. Снова рассмотрим тестовый класс:
```
public class SecretKeeper
{
private int _secret;
// Для упрощения тестирования
public int Secret{get { return _secret; } set { _secret = value; }}
}
```
И добавим в наш статический SecretFinder метод:
```
public static int GetSecretUsingExpressionTrees(this SecretKeeper keeper)
{
ParameterExpression keeperArg = Expression.Parameter(typeof(SecretKeeper), "keeper"); // SecretKeeper keeper argument
Expression secretAccessor = Expression.Field(keeperArg, "_secret"); // keeper._secret
var lambda = Expression.Lambda>(secretAccessor, keeperArg);
var func = lambda.Compile(); // Получается функция return result = keeper.\_secret;
return func(keeper);
}
```
Протестировать можно кодом:
```
SecretKeeper keeper = new SecretKeeper {Secret = 42}; // Создаем объект с секретом
int fieldInfoSecret = keeper.GetSecretUsingExpressionTrees(); // Извлекаем секрет
Console.WriteLine
(
fieldInfoSecret == 42 ? "ExpressionTrees test: passed" : "ExpressionTrees test: failed" // Форматируем вывод
);
```
Лично я применял этот способ во время написания кастомного сериализатора. Полученные функции спокойно работают с приватными полями, кешируются, при этом производительность в два раза меньше аналогичного кода написанного в редакторе (и в 8 раз больше предыдущего примера).
Недостатки: достаточно сложен, даже для примера выше пришлось немного погуглить. В примере выше также наличествует завязка на имя свойства.
#### Способ 4, для тех, кто не ищет легких путей
Способ основан на аналоге union структур из C.
В качестве примера рассмотрим структуру:
```
[StructLayout(LayoutKind.Explicit, Pack = 1)]
public struct StructWithSecret
{
[FieldOffset(0)] private int _secret;
public StructWithSecret(int secret)
{
_secret = secret;
}
}
```
Создадим её копию, создав вместо private \_secret публичное поле по тому же смещению:
```
[StructLayout(LayoutKind.Explicit, Pack = 1)]
public struct Mirror
{
[FieldOffset(0)] public int Secret;
}
```
Добавим структуру, содержащую как секрет, так и зеркало для его обнаружения:
```
[StructLayout(LayoutKind.Explicit, Pack = 1)]
public struct Holmes
{
[FieldOffset(0)] public StructWithSecret HereIsSecret; // Тут хранится секрет
[FieldOffset(0)] public Mirror LetsLookAtTheMirror; // По тому же смещению стоит зеркало
}
```
В статический SecretFinder добавим метод:
```
public static int GetSecretFromStruct(this StructWithSecret structWithSecret)
{
Holmes holmes = new Holmes {HereIsSecret = structWithSecret}; // Передаем Холмсу структуру с секретом
return holmes.LetsLookAtTheMirror.Secret; // Холмс смотрит в зеркальце (а оно у него рядом с секретом) и секрет раскрыт
}
```
Тестируется все кодом:
```
var alreadyNotSecret = new StructWithSecret(42).GetSecretFromStruct();
Console.WriteLine
(
alreadyNotSecret == 42 ? "Structs test: passed" : "Structs test: failed"
);
```
Область применения *крайне* ограничена: способ доступен только для структур, нужно быть предельно внимательным со смещениями, ограничены типы полей в структурах, требуются довольно специфические структуры, информация о выравниваниях. И хотя подход не лишен известной элегантности, я не могу представить себе ситуацию, в которой он оправдан.
В завершение хочу добавить: первые три подхода работают как с геттерами, так и сеттерами. Также можно работать со свойствами и методами. Метод с наследниками неприменим для статических классов (ибо они sealed), сложность рефлексивных методов слегка возрастет при работе с Generic классами.
Всем добра, и пусть ваш код будет ясным и чистым. | https://habr.com/ru/post/304520/ | null | ru | null |
# Статистика появления правил IDS/IPS Suricata для новых угроз
Обязательный атрибут защиты для большой компании — IDS/IPS (система обнаружения и предотвращения вторжений). На рынке большое количество коммерческих и open-source решений, и каждое из них имеет свои достоинства и недостатки. Но общее во всех решениях — необходимость своевременного обновления правил обнаружения угроз. Большинство IDS/IPS позволяют использовать правила, разработанные для Snort. Одним из самых известных поставщиков правил является компания Emerging Threats, ставшая частью Proofpoint.
Мы решили собрать статистику по выпуску правил для наборов pro (коммерческая версия) и open (open-source версия) Emerging Threats для Suricata, так как их синтаксис аналогичен Snort, но при этом немного расширен, что дает больше возможностей.
Со страницы [rules.emergingthreats.net/changelogs](http://rules.emergingthreats.net/changelogs/) были собраны журналы обновлений правил suricata и suricata-1.3 начиная с 2015 года. Первое, что нас интересовало, — какое количество правил выпускалось для выявления эксплуатации уязвимостей. В эту категорию попали правила с привязкой к CVE, правила классов `attack response` и `exploit`.
Для привязки CVE к правилам мы распарсили актуальный файл `sid-msg.map`, а также журнал его изменений. Файл содержит маппинг sid-правил на их метаинформацию и имеет строки такого вида:
```
2021138 || ET WEB_SERVER ElasticSearch Directory Traversal Attempt (CVE-2015-3337) || cve,2015-3337
2021139 || ET TROJAN H1N1 Loader CnC Beacon M1 || url,kernelmode.info/forum/viewtopic.php?f=16&t=3851
```
CVE-идентификатор может содержаться как отдельно, так и в поле msg. Отсюда был получен маппинг CVE на правила.
Поскольку одной атаке могут соответствовать несколько схожих правил, необходимо было делать выборку по уникальности правил. Правила, незначительно отличающиеся друг от друга полем msg (имеющие сходство больше 0,99 по алгоритму [Джаро—Винклера](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance)), в выборку добавлены не были. В итоге были выбраны правила, содержащие маппинг с CVE или содержащие в поле msg один из следующих маркеров: attack response, exploit.
*Статистика по набору ET open за 2015 год*
*Соотношение правил из набора ET open за 2015 год*
*Статистика по набору ET pro за 2015 год*
*Соотношение правил из набора ET pro за 2015 год*
Как видно, в 2015 году количество правил, выпущенных для выявления эксплуатации уязвимостей, не превысило 10%. Наибольшую площадь на диаграмме занимают правила для выявления сетевой активности вредоносных программ.
Следующим шагом был сбор статистики покрытия правилами уязвимостей, опубликованных в 2015 году. Были отобраны уязвимости, имеющие удаленный вектор эксплуатации (AV:N) и CVSSv2-рейтинг больше 7,8. Из них мы отобрали те, для выявления эксплуатации которых были выпущены правила.
На диаграмме видно, что правилами покрывается лишь малая часть уязвимостей. Первая причина заключается в том, что часть CVE выпускается для случаев, которые невозможно (шифрованный трафик) или бессмысленно покрывать правилами (с выявлением и предотвращением эксплуатации уязвимостей в веб-приложениях лучше справиться WAF, для правил же придется использовать громоздкие регулярные выражения, что приведет к замедлению системы). Вторая причина в том, что не всегда известны подробности эксплуатации уязвимости, и у экспертов нет образцов, на основе которых можно разработать правила.
*Статистика покрытия правилами уязвимостей 2015 года*
Итак, существует острая нехватка правил для актуальных уязвимостей. Одна из причин — нежелание вендоров, а также экспертов, находящих уязвимости и создающих правила для IDS/IPS, делиться техническими деталями обнаруженных уязвимостей. Для разработки правил требуются образцы трафика с эксплуатацией уязвимости; при их наличии покрытие новых уязвимостей правилами увеличится в разы, и положение дел не будет таким плачевным.
**Автор**: Алексей Леднёв, Positive Technologies | https://habr.com/ru/post/282029/ | null | ru | null |
# Под прессом. Ломаем и защищаем Wordpress своими руками
WordPress — это удобная блог-платформа для публикации статей и управления ими, на которой базируется огромное число различных сайтов. Из-за своей распространенности эта CMS уже давно является лакомым куском для злоумышленников. К сожалению, базовые настройки не обеспечивают достаточного уровня защиты, оставляя многие дефолтные дырки незакрытыми. В этой статье мы пройдем типичным путем «типового» взлома сайта на Wordpress, а также покажем как устранить выявленные уязвимости.
#### Введение
На сегодняшний день WordPress среди систем управления контентом популярнее всего. Его доля составляет 60,4% от общего числа сайтов, использующих CMS-движки. Из них, согласно статистике, 67,3% сайтов базируется на последней версии данного программного обеспечения. Между тем за двенадцать лет существования веб-движка в нем было обнаружено 242 уязвимости различного рода (без учета уязвимостей, найденных в сторонних плагинах и темах). А статистика сторонних дополнений выглядит еще печальней. Так, компания Revisium провела анализ 2350 русифицированных шаблонов для WordPress, взятых из различных источников. В результате они выяснили, что более половины (54%) оказались зараженными веб-шеллами, бэкдорами, blackhat seo («спам») ссылками, а также содержали скрипты с критическими уязвимостями. Поэтому устраивайся поудобней, сейчас мы будем разбираться, как провести аудит сайта на WordPress и устранить найденные недостатки. Использовать будем версию 4.1 (русифицированную).
#### Индексирование сайта
Первым этапом любого теста обычно бывает сбор информации о цели. И тут очень часто помогает неправильная настройка индексирования сайта, которая позволяет неавторизованным пользователям просматривать содержимое отдельных разделов сайта и, например, получить информацию об установленных плагинах и темах, а также доступ к конфиденциальным данным или резервным копиям баз данных. Чтобы проверить, какие директории видны снаружи, проще всего воспользоваться Гуглом. Достаточно выполнить запрос Google Dorks типа site:example.com intitle:«index of» inurl:/wp-content/. В операторе inurl: можно указать следующие директории:
```
/wp-content/
/wp-content/languages/plugins
/wp-content/languages/themes
/wp-content/plugins/
/wp-content/themes/
/wp-content/uploads/
```
Если сможешь просмотреть /wp-content/plugins/, следующий шаг по сбору информации об установленных плагинах и их версиях значительно упрощается. Естественно, запретить индексирование можно с помощью файла robots.txt. Так как по умолчанию он не включен в установочный пакет WordPress, его необходимо создать самому и закинуть в корневую директорию сайта. Мануалов по созданию и работе с файлом robots.txt довольно много, поэтому оставлю эту тему для самоподготовки. Приведу лишь один из возможных вариантов:
```
User-Agent: *
Disallow: /cgi-bin
Disallow: /wp-login.php
Disallow: /wp-admin/
Disallow: /wp-includes/
Disallow: /wp-content/
Disallow: /wp-content/plugins/
Disallow: /wp-content/themes/
Disallow: /?author=*
Allow: /
```
Если в файлах, хранящихся в папке uploads, имеются сведения конфиденциального характера, добавляем к этому списку строчку: Disallow: /wp-content/uploads/. С другой стороны, в файле robots.txt не рекомендуется размещать ссылки на директории, которые были созданы специально для хранения чувствительной информации. Иначе этим самым ты облегчишь злоумышленнику задачу, так как это первое место, куда обычно все заглядывают в поисках «интересненького».
#### Определение версии WordPress
Еще один важный шаг — идентификация версии CMS. Иначе как подобрать подходящий сплоит? Существует три быстрых способа для определения используемой на сайте версии WordPress:
1. Найти в исходном коде страницы. Она указана в метатеге generator: /> или же в тегах : .
2. Найти в файле readme.html (рис. 1), который входит в состав установочного пакета и находится в корне сайта. Файл может иметь и другие названия типа readme-ja.html.
3. Найти в файле ru\_RU.po (рис. 2), который входит в состав установочного пакета и расположен по адресу /wp-content/languages/: «Project-Id-Version: WordPress 4.1.1\n».
Рис. 1. Версия WordPress в файле readme.html
Рис. 2. Подсматриваем версию WordPress в файле ru\_RU.po
Один из вариантов защиты в данном случае — ограничить доступ к файлам readme.html и ru\_RU.po с помощью .htaccess.
> #### Автоматизация процесса тестирования
>
>
>
> Исследованием безопасности WordPress занялись не вчера, поэтому существует достаточное количество инструментов, позволяющих автоматизировать рутинные задачи.
>
>
>
> Nmap:
>
>
>
> — определение версии и темы с помощью [скрипта http-wordpress-info](http://seclists.org/nmap-dev/2014/q4/102)
>
>
>
>
> ```
> nmap -sV --script http-wordpress-info
>
> ```
>
>
> — подбор пароля по словарям
>
>
>
>
> ```
> nmap -p80 --script http-wordpress-brute --script-args 'userdb=users.txt,passdb=passwords.txt' example.com
>
> ```
>
>
> Metasploit:
>
>
>
> — модуль для определения версии: auxiliary/scanner/http/wordpress\_scanner;
>
> — модуль для определения имени пользователя auxiliary/scanner/http/wordpress\_login\_enum.
>
>
>
> WPScan:
>
>
>
> — перечисление установленных плагинов: wpscan --url [www.exmple.com](http://www.exmple.com) --enumerate p;
>
> — перечисление установленных тем: wpscan --url [www.exmple.com](http://www.exmple.com) --enumerate t;
>
> — перечисление установленного timthumbs: wpscan --url [www.example.com](http://www.example.com) --enumerate tt;
>
> — определение имени пользователя: wpscan --url [www.example.com](http://www.example.com) --enumerate u;
>
> — подбор пароля по словарю для пользователя admin: wpscan --url [www.example.com](http://www.example.com) --wordlist wordlist.txt --username admin;
>
> — подбор пароля с использованием связки имя пользователя / пароль с числом потоков, равным 50: wpscan --url [www.example.com](http://www.example.com) --wordlist wordlist.txt --threads 50.
#### Определение установленных компонентов
Теперь давай соберем информацию об установленных плагинах и темах независимо от того, активированы они или нет. Прежде всего такую информацию можно выудить из исходного кода HTML-страницы, например по JavaScript-ссылкам, из комментариев и ресурсов типа CSS, которые подгружаются на страницу. Это самый простой способ получения информации об установленных компонентах. Например, строчки ниже указывают на используемую тему twentyeleven:
```
```
Далее, HTTP-заголовки, такие как X-Powered-By, могут указывать на наличие плагина (например, на плагин W3 Total Cache).
Так как информация о плагинах не всегда отображается в исходном коде HTML-страницы, то обнаружить установленные компоненты можно с помощью утилиты WPScan (см. врезку). Только не забывай, что перебор путей плагинов зафиксируется в логах веб-сервера.
Получив данные об установленных компонентах, уже можно приступать к поиску уязвимостей своими силами либо найти общедоступные эксплойты на ресурсах типа [rapid7](http://www.rapid7.com/db/) или [exploit-db](http://www.exploit-db.com).
#### Определение имени пользователей
По умолчанию в WordPress каждому пользователю присваивается уникальный идентификатор, представленный в виде числа: example.com/?author=1. Перебирая числа, ты и определишь имена пользователей сайта. Учетная запись администратора admin, которая создается в процессе установки WordPress, идет под номером 1, поэтому в качестве защитной меры рекомендуется ее удалить.
#### Брутфорс wp-login
Рис. 3. Ошибки при аутентификации пользователя
Зная имя пользователя, можно попробовать подобрать пароль к панели администрирования. Форма авторизации WordPress на странице wp-login.php весьма информативна (рис. 3), особенно для злоумышленника: при вводе неправильных данных появляются подсказки о неверном имени пользователя или пароле для конкретного пользователя. Разработчикам известно о данной особенности, но ее решили оставить, так как подобные сообщения удобны для пользователей, которые могли забыть свой логин и/или пароль. Проблему подбора пароля можно решить, используя стойкий пароль, состоящий из двенадцати и более символов и включающий буквы верхнего и нижнего регистра, числа и спецсимволы. Или же, например, при помощи плагина Login LockDown.
> #### Security-плагины для WordPress
>
>
>
> — [Login LockDown](http://www.bad-neighborhood.com/login-lockdown.html) — ограничивает количество неудачных попыток авторизации;
>
> — [Revisium WordPress Theme Checker](http://revisium.com/rwp/) — ищет типичные вредоносные фрагменты в темах WordPress;
>
> — [Sucuri Security](https://wordpress.org/plugins/sucuri-scanner/) — проводит мониторинг и обнаружение вредоносного кода;
>
> — [iThemes Security (бывший Better WP Security)](https://wordpress.org/plugins/better-wp-security/) — многофункциональный плагин для защиты WordPress;
>
> — [BackUpWordPress](https://wordpress.org/plugins/backupwordpress/) — делает резервное копирование файлов и БД;
>
> — [Google Captcha (reCAPTCHA)](https://wordpress.org/plugins/google-captcha/) — устанавливает капчу при регистрации, авторизации, восстановлении паролей и в форме комментариев.
#### Заливаем Shell
После того как мы сбрутили пароль, ничто не мешает залить шелл на скомпрометированный веб-ресурс. Для этих целей вполне сгодится [фреймворк Weevely](https://github.com/epinna/weevely3), который позволяет генерировать шелл в обфусцированном виде, что делает его обнаружение довольно сложным. Чтобы не вызывать подозрения, полученный код можно вставить в любой файл темы (например, в index.php) через редактор темы консоли WordPress. После чего с помощью того же Weevely можно подключиться к машине жертвы и вызывать различные команды:
```
python weevely.py http://test/index.php Pa$$w0rd
[+] weevely 3.1.0
[+] Target:test
[+] Session: _weevely/sessions/test/index_0.session
[+] Browse the filesystem or execute commands starts the connection
[+] to the target. Type :help for more information.
weevely> :help
```
#### Подключаем .htaccess
Для запрета доступа к чувствительной информации лучше воспользоваться файлом .htaccess — это файл конфигурации, используемый в Apache Web Server. Рассмотрим возможности этого файла с точки зрения безопасности. С его помощью можно: запретить доступ к директориям и файлам, заблокировать различные SQL-инъекции и вредоносные скрипты. Для этого [стандартный](http://codex.wordpress.org/htaccess) файл .htaccess для CMS WordPress 4.1 нужно немного расширить. Чтобы закрыть список файлов и папок, добавляем:
```
Options +FollowSymLinks -Indexes
RewriteCond %{QUERY_STRING} base64_encode[^(]*\([^)]*\) [OR] заблокирует ссылки, содержащие кодировку Base64. Избавиться от ссылок, содержащих тег
``` | https://habr.com/ru/post/259843/ | null | ru | null |
# Чему я научился, пока писал свой агрегатор цен на игры
Этот пост не реклама моего проекта, а пример того, что дает человеку pet-project.
Я попробую рассказать, как, будучи тридцатипятилетним java-разработчиком, имеющим обязательства перед женой, маленьким ребенком и работодателем, сумел выделить время на самообразование и интересное хобби. Попутно расскажу, что я приобрел: какие сервисы, языки, фреймворки для себя открыл.
Сам проект представляет собой агрегатор цен online-магазина игр PlayStation Store. На данный момент с его помощью можно посмотреть, как менялась цена на игры в течение последних трех месяцев, увидеть список игр, которые обновили свои ценовые рекорды. В процессе разработки фича подписки на обновления цен.
Если интересно, добро пожаловать под кат.
Код в обеденных перерывах
-------------------------
Уверен, почти каждый разработчик сталкивался с проблемой, что работа покрывает лишь часть его профессиональных интересов. Всегда есть желание попробовать новые технологии, принимать единоличные решения по поводу дизайна приложения и архитектуры всей системы целиком.
Сейчас моей дочери четыре года, моей энергии и энергии жены едва хватает, чтобы после работы искупать и уложить ее спать. Самообразование после этого не в приоритете — пришлось искать другие возможности для своих проектов, и я решил украсть у себя 40 минут обеденного времени и посвятить их самообразованию. Вооружившись персональным ноутбуком и сотовым оператором, который лучше всего выдает интернет в моем бизнес-центре, я приступил к работе.
Изучать технологии в отрыве от полноценной практики не интересно. Повторение примеров уровня "Hello World" быстро надоедает, поэтому я начал придумывать проект, который бы помог мне расширить свой технологический кругозор и при этом был бы мне интересен с точки зрения предметной области.
Я иногда люблю осознанно тратить время за видеоигрой на PlayStation 4. А еще не люблю платить больше, если можно сэкономить. Поэтому решил сделать ресурс, позволяющий отслеживать динамику цен на игры и ловить за хвост хорошие предложения. Уже на стадии анализа я понял, что существуют аналогичные проекты, так что не питал иллюзий о коммерческом успехе своего начинания. Это меня не остановило. Так родился FeedHandler.
К разработке приступал дважды. Сначала пытался создать приложение, разбитое на (микро)сервисы. Сделать это хорошо мне не удалось (возможно, из-за отсутствия промышленного опыта работы с микросервисной архитектурой). Я отказался от идеи сервисов и реализовал свое приложение монолитным. В качестве задела на будущее разбивал логические куски на java-пакеты. С этим подходом я и дошел в итоге до релиза.
Думаю, в первый раз мне помешало то, что я очень хотел сделать все идеально. Когда я переписывал проект заново, то поставил более достижимую цель — сделать MVP (minimum valuable product), — а дальше развивал проект итеративно, делая маленькие, но завершенные части.
Анатомия агрегатора
-------------------
Если нарисовать FeedHandler широкими мазками, то получится такая схема:
Здесь элементы выделены тремя цветами: зеленый – внешние системы, от меня не зависящие (пользователи, сервис рассылки писем, Sony Store API), голубой – реализованные модули, которые можно посмотреть на сайте feedhandler.ru, и желтый – те части, реализацию которых я начал, но пока так и не закончил (как правило, они хотя бы запускаются на локальной машине).
Пойдем сверху вниз по схеме. В отладчике браузера я заметил, что PlayStation Store при отображении страницы обращается к своему API (valkyrie-api). В ответ на GET-запрос API возвращает простыню исчерпывающих данных про игру. При этом [robots.txt](https://store.playstation.com/robots.txt) выдает:
```
# we re-allow /valkyrie-api/ so that it will re-render properly.
# Disallow: /valkyrie-api/
```
Отлично, значит, и нам это можно использовать для сбора цен.
**FeedHandler PriceCollector.** Коллектор раз в сутки забирает данные из API PlayStation при помощи java-приложения и помещает их в базу данных. Java-приложение представляет из себя интеграционный флоу, написанный на Apache Camel, с которым я имел дело несколько лет, пока работал в страховой компании. Открыто говорю, этот фреймворк – моя любовь. Всегда, когда надо наладить интеграцию, пользуюсь им. Так как вначале я плохо представлял, какая схема будет у конечного продукта, я использовал schema-less базу данных — MongoDB. Это был мой первый опыт работы с ней, и мне очень понравилось.
> MongoDB – первый продукт, с которым я познакомился в процессе работы над Feedhandler. Понимаю, что мне далеко до уровня эксперта в области докуменоориентированных баз данных, но был доволен, как получилось разбить задачу на несколько коллекций для разных целей: игры, статистика (агрегированные данные для отображения на сайте) и другие. Довольно интересно было обогащать существующие элементы или агрегировать данные для другой коллекции. В качестве визуального редактора понравился <https://www.robomongo.org/>.
Для разделения этапов запроса мне нужна была персистентная очередь. В свое время я работал с ActiveMQ — этот сервер очередей отлично бы мне подошел, но для своих целей я использовал RabbitMQ, чтобы расширить кругозор.
> RabbitMQ – второй продукт, с которым я познакомился. К сожалению, какой-либо экспертизы по этому продукту я не успел наработать и даже не знаю, как RabbitMQ ведет себя под нагрузкой. Осталось больше вопросов, чем ответов. Надеюсь, когда-нибудь еще удастся познакомиться с этим продуктом поближе.
**FeedHandler Price API.** Всё в том же монолите отдельным java-пакетом стоит REST-сервис, отвечающий за предоставление данных для сайта. Реализован он на spring-boot-starter-web. В планах было добавить туда кэширование, но на данный момент каждый запрос идет напрямую в базу.
**Feedhandler UI.** Сайт реализован на Nuxt.js (сначала написал на Vue.js, затем переделал на Nuxt.js). До этого пробовал Django, jsp, jsf и другие шаблонизированные web ui. Здесь хотелось посмотреть на что-то новое: либо react.js, либо vue.js. Выбор пал на второй. В целом, мне было довольно комфортно писать, хоть я и нисколько не UI-разработчик. Nuxt.js — еще более высокоуровневый фреймворк на базе Vue.js. Он освободил меня от ряда обязательств, например, от ручного конфигурирования путей.
Все модули со схемы собираются в образы и доставляются контейнерами. Давно был соблазн поработать с docker, и я воспользовался шансом.
> Docker и docker-compose оказались идеальными помощниками. Такого удовольствия, пожалуй, давно не испытывал. Изоляция на уровне контейнеров чарует. На данный момент разворачиваю с помощью docker все, начиная от своих простеньких приложений, заканчивая домашним plex-сервером и Jenkins.
Отдельно на схеме выделены желтым те части, работа над которыми не закончена. Это все, что связано с личным кабинетом, где по плану пользователь мог бы подписываться на обновления цен и получать письма.
**Model Synchronizer, Feedhandler Personal Account.** API личного кабинета реализован на Django Rest — фреймворке. За этим API стоит база данных Postgres. API личного кабинета дергает все тот же Feedhandler UI, написанный на Nuxt.js. Обновление Django-модели происходит не напрямую из java-кода, а через celery.
> Celeryproject — это очаровательный проект, который позволяет по RabbitMQ кидать таски в Python (и не только). В моем случае я кидаю события «новая игра», «удалить игру» и т.д. Это влияет на доступность подписки на изменения цен в личном кабинете пользователя. Базовая настройка в Django довольно простая.
Инфраструктура: CI, рассылка писем и другие тулзы. Дешево (бесплатно) и сердито
-------------------------------------------------------------------------------
Свой код я исторически храню на GitHub. Проект FeedHandler разместил в приватных репозиториях.
**Continuous Integration, CI.** Для сборок мне идеально подошел GitLab CI. Из недостатков можно отметить то, что раз пять за год я встретился с недоступностью сервиса. Для моего проекта это не было критичным, зато у этого инструмента есть огромное преимущество в виде облачного Docker registry с весьма щедрыми лимитами. В заголовке проекта указано значение 1GB.
В GitLab CI есть ряд публичных worker’ов, которым он может выдать задачу собрать артефакт. Чтобы не беспокоиться, что мой код или пароли утекут, я пользуюсь персональным worker’ом на своем арендованном VDS. Образ таких сборщиков распространяется GitLab в виде Docker Image, который можно установить на свой сервер. Тогда схема сборки выглядит следующим образом:
Триггером является создание тега на master.
**Почтовая рассылка.** На схеме FeedHandler видно, что я пользуюсь сервисом почтовой рассылки. В качестве него я выбрал Mailgun. Я довольно много времени потратил на выбор, и Mailgun на тот момент обладал кучей преимуществ: во-первых, он был бесплатным. Во-вторых, в тарифный план входил удобный API, по 10000 писем и 100 валидаций в месяц. В интернете я нашел [обзор 2015 года с сайта TexTerra](https://texterra.ru/blog/vybiraem-luchshiy-email-servis-obzor-i-sravnenie-17-samykh-populyarnykh-kompaniy-na-rynke.html), он мне показался наиболее полным и с грамотной оценкой сервисов. В целом, я прошелся почти по всему этому обзору (кстати, Maigun там не было), но ни один из предложенных автором почтовых сервисов мне не приглянулся: либо мало писем в стартовом пакете, либо нет API. В частности, MailChimp имел щедрый бесплатный тарифный план, но API предоставлял лишь за деньги.
> На момент написания статьи заметил, что данного тарифного плана больше нет. На замену ему пришел тарифный план Flex, $0.8 за 1000 писем, что в целом тоже не дорого.
**Issue and Time Tracker** Из средств планирования мне больше всего понравился YouTrack от JetBrains. Имеется бесплатный облачный план на команды до десяти человек. Честно скажу, понравился этот сервис мне тем, что он больше всего напомнил Jira к которой я привык. Конечно, есть интеграция с IntelliJ IDEA.
Пример моей доски:
В процессе работы нашел отличный инструмент трекинга времени – Toggl. Самое главное не забывать выключать таймер. По результатам работы можно посмотреть интересную статистику, например, на что больше времени ушло (инфраструктура, backend, UI).
**Мониторинг.** Я использовал связку Prometheus (средство сбора метрик) и Grafana (знаменитое средство визуализации). Для того, чтобы своевременно получать информацию об ошибках, я добавил интеграцию с Slack. Я снимал несколько показателей: время request/response, количество ошибок в логе, количество обновлений цены.
Понятно, что эта система безопасности в некотором роде игрушечная — ведь расположена она на том же хосте, что и система, за которой она следила. В момент установки Prometheus мне так и не удалось указать псевдоним контейнера для снятия метрик – пришлось указать IP-адрес. Когда IP-адрес изменился, так вышло, что я не стал перенастраивать Prometheus, так как наблюдать за логами этой системы оказалось не очень интересно – мало что происходило.
Мой день в slack обычно выглядел так:
**Nginx и безопасность.** Активно пользовался nginx, раздавая веб-трафик наружу, некоторые порты закрывал для внешнего пользователя, позволяя достучаться до них только через VPN.
> Коллега намекал, что мир шагнул вперед, и есть такая штука как Traefik. И он действительно выглядит очень перспективно, разруливать правила за счет меток на контейнерах — это классная идея. Но это тот продукт, на который я заглядываюсь, но пока побаиваюсь использовать в проде. Будет классно, если кто-то в комментариях расскажет про свой промышленный опыт работы с Traefik.
Также интересная штука – CDN. Я воспользовался CloudFlare. В бесплатном плане есть защита от DDoS атак, поддержка по email. Не могу рассказать о качестве защиты от DDoS — не сталкивался и не знаю, как она устроена. Для меня CloudFlare — это возможность спрятать реальный адрес виртуальной машины, где расположены все сервисы Feedhandler. Схема разруливания трафика имеет следующий вид:
Книги, из которых я черпал идеи
-------------------------------
Это же самое приятное! Я слышал когда-то идею, что наша текущая точка зрения отражает книги, которые мы в данный момент читаем. Отчасти я согласен с этим. В этом разделе главное, что я хочу подчеркнуть, — это не «какой я молодец, вот сколько читаю» или «top-10 книг, которые надо прочесть». Я хочу сказать, что собственный проект – это возможность на лету реализовывать то, что читаешь в книгах. Понравилась идея? Надел походные сапоги и пошел шагать по бездорожью!
Надо отметить, что книги я не в обед читал, а в метро (еще до сами-знаете-чего).
Вот книги, которые я прочел за этот год эксперимента. Все они так или иначе отразились на проекте.
**Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers)** *by Michael T. Nygard.* По-моему, это часть золотого фонда книг про жизненный цикл программного обеспечения. Автор очень живо рассказывает про свой опыт (не всегда удачный) разработки архитектуры и поддержки программного обеспечения. После прочтения сразу хочется реализовать все эти патерны в своем продукте. Ну уж circuit breaker точно.
**Mastering Spring Boot 2.0: Build modern, cloud-native, and distributed systems using Spring Boot** *by Dinesh Rajput* Не могу сказать, что являюсь большим поклонником этой книги, но она отлично справляется с ролью дайджеста всех возможностей Spring Boot. По крайней мере после нее у меня уже не возникали вопросы о том, какие библиотеки spring-boot за что отвечают.
**Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)** *by Robert C. Martin* Слышал много споров о современных высказываниях дядюшки Боба. Сам в эту полемику вступать не буду, но скажу, что именно эта книга мне рассказала про некоторые архитектурные паттерны, которых я не мог до этого впитать из других источников, например, dependency inversion, CQRS и другие.
**The Design of Web APIs** *by Arnaud Lauret* так и не дочитал до конца, но впитал идею серьезного подхода к проектированию API. В частности, описывал спецификацию OpenAPI, прежде чем воплощать ее в коде. Не могу сказать, что сделал все по книге или ощутил какую-то завершенность или уверенность, но это было весело и здорово.
Итоги: много кайфа, интересных идей, и возможно, когда-то приду на собеседование со своим кодом
-----------------------------------------------------------------------------------------------
Что-то получилось, что-то нет.
Например, я не смог интегрировать в свой проект AdSense. Не то, чтобы я хотел зарабатывать на рекламе на сайте, который никто кроме меня не посещает, но было бы интересно посмотреть, как это работает. Получил отказ из-за шаблонности контента страниц. При этом не хочется выгребать из Sony store информацию об играх, некрасиво это выглядит, так что оставил этот вопрос на потом.
Не смог убедить Twitter, что мне нужен доступ к Twitter API, получил отказ. Хотел в аккаунте публиковать новости по ценовым минимумам. Возможно, выберу альтернативную платформу типа Telegram.
Это хобби не остается незамеченным окружающими. В частности, жена сделала мне подарок на день рождения – логотип для моего проекта. Это был полный восторг и наверное, один из лучших и самых запоминающихся подарков потому, что попал в резонанс с делом, которое меня увлекало в тот момент!
Временами я все-таки обедаю час вместо двадцати минут. Тогда я всегда нахожу единомышленников, с которыми можно обсудить свою работу над проектом или спросить совета в том или ином вопросе. Эти беседы мне очень нравятся и помогают находить новые интересные темы.
Хотя, конечно, было бы лукавством говорить, что я смог это все сделать только за обеденные перерывы. После укладывания дочери бывали вечера, когда я тратил час-другой на свой проект, особенно в то время, когда меня зажигала какая-то задача. Например, когда я для себя открыл, насколько легко и непринужденно можно писать Telegram-ботов. Грех был не потратить хотя бы час на это дело. А книги вообще в метро читал.
Вся эта история с карантином и самоизоляцией сбила привычный для меня темп работы, и проект остался без присмотра на пару месяцев. Периодически заглядывал на него с целью убедиться, что все в порядке — и пока он меня не подводил.
Уверен, что смогу применить свои знания и наработки, опробованные на FeedHandler. Проект не брошу, планирую постепенно дописать его. Уже сейчас готова часть с пагинацией (UI, API), частично готов личный кабинет. Должна легко вписаться новая платформа PS5. Хотя я и не думаю, что смогу монетизировать этот проект, единственная выгода, которую я сейчас вижу, – смогу на следующие собеседования идти со своим ноутом, кодом и проектом. | https://habr.com/ru/post/522994/ | null | ru | null |
# Ускоряем код на Android'е
Продолжу начатую в моей предыдущей [статье](http://habrahabr.ru/post/268653/) работу по оптимизации алгоритма. Вкратце расскажу, что было сделано. Были взяты готовые [java исходники и каскадная модель](https://code.google.com/p/jviolajones/) одной из реализаций алгоритма [Виола-Джонса](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%92%D0%B8%D0%BE%D0%BB%D1%8B_%E2%80%94_%D0%94%D0%B6%D0%BE%D0%BD%D1%81%D0%B0). Данный алгоритм используется для поиска объектов на фотографии, в частности для поиска лиц. Тестирование проводил на своем телефоне, по результатам было получено, что изначальный код на java работал 54 секунды на фотографии размером 300 на 400. Это было слишком медленно, переписанный мною код на C++ показал результат в 14 секунд. В комментариях было предложено догнать java-реализацию до C++ следующим образом: отпрофилировать и найти узкие места, и заменить двумерный массив на одномерный. Также у меня в планах было распараллелить алгоритм на C++. Все было сделано и исследовано, результаты ниже.
**Профилируем java-релизацию.** Снимаем статистику в момент работы основной части алгоритма. Видим такую картину(результат в [файле](https://drive.google.com/file/d/0B2RMIFu2ZeMPbVpDODlOU2NFV1k/view?usp=sharing) кому интересно):
методы List'ов съедают немало времени. В данной ситуации все List'ы можем спокойно заменить на массивы, что на C++ и используется. Заменяем и получаем следующий результат([в файле](https://drive.google.com/file/d/0B2RMIFu2ZeMPZW5HQ3E4WDdHWXc/view?usp=sharing)):
обратите внимание на Math.sqrt, процент её исполнения поднялся с 6.7 до 13.5, что значит — другие уменьшили потребления времени, и запуск на телефоне показал — 38 секунд. Все остальное время уходит на примитивные методы: умножение, деление и получение элемента массива и Math.sqrt. Соответственно, уже не вижу, где и что можно изменить, т.к. C++ повторяет код в точности.
**Одномерные массивы вместо двумерных**. Меняем следующий код:
```
int[][] grayImage=new int[width][height];
int[][] squares=new int[width][height];
```
на:
```
int[] grayImage=new int[width * height];
int[] squares=new int[width * height];
```
и в соответствующих местах использования:
```
int total_x = grayImage[(i + w) * height + j + h] + grayImage[i * height + j] - grayImage[i * height + j + h] - grayImage[(i + w) * height + j];
int total_x2 = squares[(i + w) * height + j + h] + squares[i * height + j] - squares[i * height + j + h] - squares[(i + w) * height + j];
...
rect_sum += (int) ((grayImage[rx2 * height + ry2] - grayImage[rx1 * height + ry2] - grayImage[rx2 * height + ry1] + grayImage[rx1 * height + ry1]) * r.weight);
}
```
результат точно такой же. Попробуем сократить количество операций умножения для вычисления элемента массива, т.е. сделаем так:
```
int iwh = (i + w) * height;
int ih = i * height;
int total_x = grayImage[iwh + j + h] + grayImage[ih + j] - grayImage[ih + j + h] - grayImage[iwh + j];
int total_x2 = squares[iwh + j + h] + squares[ih + j] - squares[ih + j + h] - squares[iwh + j];
...
int rx2h = rx2 * height;
int rx1h = rx1 * height;
rect_sum += (int) ((grayImage[rx2h + ry2] - grayImage[rx1h + ry2] - grayImage[rx2h + ry1] + grayImage[rx1h + ry1]) * r.weight);
```
результат не изменился. Одномерный массив не дал плюсов, только минусы в читабельности кода.
И так, с Java закончили на результате 38 против 14 секунд на C++.
**Распараллеливание.** Попробуем распараллелить алгоритм написанный на C++ на телефоне GT-I9300I с четырехядерным процессором. На Android'е можно применить posix threads, как написано в документации он немного урезан, но нам достаточно создать потоки, передать им параметры и дождаться их исполнения. Все это делается просто:
```
#include
...
extern "C" {
struct ThreadArgument {
void \*array;
int threadNum;
};
void \*worker\_thread(void \*arg) {
ThreadArgument \*arg1 = (ThreadArgument\*) arg;
((Detector\*) (arg1->array))->workerTansient(arg1->threadNum);
pthread\_exit(NULL);
}
}
...
pthread\_t m\_pt[threadsNum - 1];
if (threadsNum > 1) {
res2 = new VectorRects\*[threadsNum - 1];
for (int l = 0; l < threadsNum - 1; l++) {
ThreadArgument\* args = new ThreadArgument;
args->array = (void\*)this;
args->threadNum = l + 1;
int success = pthread\_create(&m\_pt[l], NULL, worker\_thread, args);
if (success == 0) {
\_\_android\_log\_print(ANDROID\_LOG\_INFO, "Detector", "thread %d started", l);
}
}
}
\_\_android\_log\_print(ANDROID\_LOG\_INFO, "Detector", "gettFaces3 baseScale=%f maxScale=%f scale\_inc=%f", baseScale, maxScale, scale\_inc);
ret = getResult(0);
if (threadsNum > 1) {
for (int l = 0; l < threadsNum - 1; l++) {
int success = pthread\_join(m\_pt[l], NULL);
for (int b = 0; b < res2[l]->currIndex; b++) {
ret->addRect(res2[l]->rects[b]);
}
}
}
...
VectorRects\* Detector::workerTansient(int threadNum)
{
\_\_android\_log\_print(ANDROID\_LOG\_INFO, "Detector", "workerTansient thread running %d", threadNum);
res2[threadNum - 1] = getResult(threadNum);
return NULL;
}
...
```
Получаем следующий результат 14 секунд для одного потока, 8 секунд для двух потоков, 5 секунд для трех и 4 секунды для четырех и более потоков. На виртуальном устройстве Nexus S с одноядерным процессором распараллеливание не привело ни к чему.
Исходники полученного алгоритма можно скачать [здесь](https://drive.google.com/file/d/0B2RMIFu2ZeMPdFFobzZxY3RRUHM/view?usp=sharing). Использовать следующим образом:
```
Detector detector = Detector.create(inputHaas);
List res = detector.getFaces(image, 1.2f, 1.1f, .05f, 2, true, useCpp, threadsNum);
```
где inputHaas — поток модели, т.е. файл haarcascade\_frontalface\_default.xml из исходного алгоритма, useCpp — использовать C++ или нет, threadsNum — количество потоков для C++ кода. Предполагается, что Detector инициируется один раз.
**Итого.** Замена LinkedList используемых в итерации на массивы в целом дало прирост для текущего алгоритма в 1.5 раза, но все еще отстает в 2,5 раза от реализации на C++. Перевод двумерного массива в одномерный не показал изменений. С помощью распараллеливания на C++ удалось ускорить процесс в 3 раза на четырехядерном процессоре, что уже намного лучше, но до идеала далеко. Можно посмотреть в сторону RenderScript — механизм для сложных вычислений на нативном уровне, может быть это даст какую-либо пользу. | https://habr.com/ru/post/268987/ | null | ru | null |
# Маршрутизация в Linux: VRF Lite
Обычно VRF (Virtual Routing and Forwarding, VPN Routing and Forwarding) используется совместно с MPLS, но без оной в терминологии Cisco называется VRF-Lite. Суть этой технологии в том, что маршрутная информация, принадлежащая различным классам (например, маршруты одного клиента) изолируется друг от друга. Считается, что такие возможности есть только у «взрослых» железных решений, но это не совсем так. Благодаря наличию множественных таблиц маршрутизации, гибких политик маршрутизации всё это можно сделать и в Linux. Кому интересно, добро пожаловать под кат.
##### Типы маршрутов, таблицы маршрутизации и PBR в Linux
Прежде чем понять суть происходящего, познакомимся с некоторыми отличительными чертами сетевого стека Linux.
Первый отличительный момент — это специальные типы маршрутов. Когда ip-пакет приходит с какого-нибудь интерфейса, надо определить, адресован ли он этому хосту, или другому. Определяется это довольно элегантно — просто для адреса назначения ищется нужный маршрут в таблицах маршрутизации. Если пакет попадает на маршрут типа «local», значит он адресован непосредственно хосту, если нет, то значит его надо маршрутизировать дальше (при этом дальнейший маршрут уже известен) или сделать что-то ещё, в зависимости от типа маршрутов.
На данный момент поддерживается несколько типов маршрутов (подробнее о них можно посмотреть в мане ip-route, если пишет, что такого мана нет, то обновите пакет iproute на более свежий). Нас в данный момент интересуют только маршруты следующих типов:
* unicast — обычный маршрут. Ничего интересного.
* local — адрес назначения находится на данном хосте. После того, как выяснится, что пакет попадает на этот маршрут, будет производиться поиск подходящего сокета для него.
* broadcast — широковещательный маршрут. Для входящих пакетов, попадающих на этот маршрут, практически нет отличий от маршрута local, за исключением дополнительных проверок на игнорирование широковещательных пакетов. Для исходящих же есть небольшое отличие: в заголовке канального уровня так же выставляется широковещательный адрес назначения при использовании широковещательных сетей.
* unreachable — запрещающий маршрут. Для пакетов, попадающий на этот маршрут будет отослан отправителю icmp-пакет с сообщением о недоступности.
* prohibit — подобен типу unreachable, только сообщение другое будет отправлено.
* blackhole — пакет на этом маршруте будет молча отброшен
Таким образом, для маршрутизации транзитных пакетов нам достаточно наличия маршрута типа unicast, а для того, чтобы хост мог отвечать на пакеты, нужны ещё маршруты типов local и, опционально, broadcast. Ещё следует учесть то, что нам также нужны маршруты direct-connected сетей для того, чтобы обеспечить связность с соседними маршрутизаторами.
Маршруты сгруппированы в таблицы маршрутизации. По-умолчанию изначально в системе присутствуют три таблицы:
* local (255) — в этой таблице находятся локальные и широковещательные маршруты. Эта таблица обслуживается автоматически и генерируется на основе адресов, назначенных интерфейсам.
* main (254) — основная таблица маршрутизации. Автоматически в неё добавляются direct-connected маршруты. Так же если в параметрах утилиты ip не указана таблица маршрутизации, то подразумевается таблица main.
* default (253) — таблица для маршрутов по-умолчанию. Её использование не прижилось и поэтому она, как правило, пустует всё время.
Имена таблиц хранятся в файле /etc/iproute2/rt\_tables. Под номер таблицы отдано 32 бита, но максимальное количество таблиц в данный момент жёстко ограничено числом 256. Как добавлять/удалять/редактировать маршруты можно почитать в мане к ip-route.
Таблица, в которой надо искать маршруты, определяется политиками маршрутизации. Эта технология называется Policy Based Routing — маршрутизация на основе политик. Суть её в том, что основываясь на каких-либо критериях сетевого пакета мы либо выбираем таблицу, в которой надо искать маршрут, либо определяем действие, которое надо выполнить над пакетом. Каждая политика имеет номер (он может быть даже не уникальным), он же определяем приоритет. Просмотр политик осуществляется в порядке возрастания их приоритетов. Новые политики добавляются перед существующими.
На данный момент «критериями» политики являются
* адреса источника и/или назначения
* значение поля tos
* интерфейс, с которого получен пакет
* интерфейс, к которому привязан сокет
* метка файерволла
Каждая политика имеет тип, который определяет действие над пакетом, если он под неё попадает:
* unicast — используется по-умолчанию, при этом будет производиться поиск маршрута в заданной таблице маршрутизации.
* blackhole/prohibit/unreachable — по действиям аналогичны соответствующим типам маршрутов.
* nat — трансляция адресов без учёта состояний, практически не используется.
##### Запираем маршруты в таблицу
Теперь небольшой практический пример после скучного введения. Для начала, мы реализуем схему с vrf-lite вручную, а затем уже усложним пример динамической маршрутизацией.
Допустим, у нас есть вот такая схема:
Задача состоит в том, чтобы изолировать трафик различного «цвета» друг от друга. При этом адресные пространства цветов могут пересекаться, что делает задачу ещё более интересной. Неформально сформулируем цель: сделать так, чтобы пакеты каждого цвета не уходили за пределы своей таблицы маршрутизации и передавались только по интерфейсам своего цвета.
Для этого для каждого цвета создадим свою таблицу маршрутизации, и для удобства дадим им имя. Затем, добавим в таблицы direct-connected маршруты принадлежащих цвету интерфейсов. И в конце, добавим политики маршрутизации, чтобы пакеты использовали только свою таблицу.
Сначала назначаем интерфейсам адреса. При этом подключенные маршруты будут попадать в таблицу main, а локальные и широковещательные — в таблицу local.
```
ip address add 192.168.0.1/24 dev eth0
ip address add 192.168.1.1/24 dev eth1
ip address add 192.168.2.1/24 dev eth2
ip address add 192.168.3.1/24 dev eth3
```
Добавляем для удобства имена таблиц маршрутизации.
```
echo "10 RED" >> /etc/iproute2/rt_tables
echo "20 GREEN" >> /etc/iproute2/rt_tables
```
Добавляем прямые маршруты в соответствующие таблицы. Нужны это для того, чтобы нам были доступны соседние маршрутизаторы.
```
ip route add 192.168.0.0/24 dev eth0 proto static scope link table RED
ip route add 192.168.1.0/24 dev eth1 proto static scope link table GREEN
ip route add 192.168.2.0/24 dev eth2 proto static scope link table GREEN
ip route add 192.168.3.0/24 dev eth3 proto static scope link table RED
```
Добавляем остальные маршруты.
```
ip route add 10.0.0.0/24 via 192.168.2.10 dev eth2 proto static table GREEN
```
Добавляем политики.
```
ip rule add iif eth0 pref 10 lookup RED
ip rule add iif eth3 pref 10 lookup RED
ip rule add iif eth1 pref 20 lookup GREEN
ip rule add iif eth2 pref 20 lookup GREEN
```
Есть один нюанс: что будет, если пакет одного цвета не находит маршрута в своей таблице? Значит, будет продолжен поиск маршрута в других таблицах, что для нас не очень хорошо. Чтобы «запереть» пакет в пределах своего цвета, мы можем в каждую изолированную таблицу добавить маршрут по-умолчанию (либо юникастовый, либо запрещающий), либо после каждой политики поиска маршрута в пределах цвета добавить запрещающую политику. Сделаем для одного цвета первый вариант, а для другого — второй.
```
ip route add unreachable default proto static table RED
ip rule add unreachable iif eth1 pref 21
ip rule add unreachable iif eth2 pref 21
```
Так же, желательно перенести все маршруты local и broadcast из таблицы local в таблицы соответствующих цветов, чтобы невозможно было обращаться к локальным интерфейсам маршрутизатора из «чужого» цвета. Для этого лучше всего написать какой-нибудь скрипт, чтобы было не так утомительно.
В итоге, наши таблицы маршрутизации и политики будут выглядеть примерно так:
```
ip route list table RED
unreachable default proto static
broadcast 192.168.0.0 dev eth0 proto static scope link
192.168.0.0/24 dev eth0 proto static scope link
local 192.168.0.1 dev eth0 proto static scope host src 192.168.0.1
broadcast 192.168.0.255 dev eth0 proto static scope link
broadcast 192.168.3.0 dev eth3 proto static scope link
192.168.3.0/24 dev eth3 proto static scope link
local 192.168.3.1 dev eth3 proto static scope host src 192.168.3.1
broadcast 192.168.3.255 dev eth3 proto static scope link
ip route list table GREEN
10.0.0.0/8 via 192.168.2.10 dev eth2 proto static
broadcast 192.168.1.0 dev eth1 proto static scope link
192.168.1.0/24 dev eth1 proto static scope link
local 192.168.1.1 dev eth1 proto static scope host src 192.168.1.1
broadcast 192.168.1.255 dev eth1 proto static scope link
broadcast 192.168.2.0 dev eth2 proto static scope link
192.168.2.0/24 dev eth2 proto static scope link
local 192.168.2.1 dev eth2 proto static scope host src 192.168.2.1
broadcast 192.168.2.255 dev eth2 proto static scope link
ip rule list
0: from all lookup local
10: from all iif eth0 lookup 10
10: from all iif eth3 lookup 10
20: from all iif eth1 lookup 20
20: from all iif eth2 lookup 20
21: from all iif eth1 unreachable
21: from all iif eth2 unreachable
32766: from all lookup main
32767: from all lookup default
```
Собранный в GNS3 стенд показал правильность работы схемы. При обращении к чужому цвету, отправитель получает сообщение о недоступности точки назначения, как и было задумано.
На этом пока всё, но продолжение следует. В нём постараюсь рассказать про динамическую маршрутизацию применительно к vrf с помощью демона маршрутизации bird, и обмен маршрутами между таблицами (vrf leaking). | https://habr.com/ru/post/138698/ | null | ru | null |
# Упрощаем автоматизацию API-тестов с помощью Cucumber и Spock
Привет! Я Владимир Пасюга, QA Engineer в NIX. Общий опыт в IT у меня составляет 7 лет, из них 2,5 года я был мануальным тестировщиком в биомедицинском проекте, который включал и UI, и API-часть. Сейчас занимаюсь автоматизированными тестами API в приложении для медицинской сферы.
В этой статье я хочу поделиться своим опытом тестирования API с помощью фреймворков Cucumber и Spock. Я расскажу, что представляет собой API и как проходит мануальное и автоматизированное тестирование этого интерфейса в нашей команде, опишу действенные инструменты и технологии и уделю особое внимание Cucumber и Spock.
---
### Коротко о базовых понятиях
Чтобы предметно говорить о тестировании API, для начала освежим знания о базовых понятиях. API фактически позволяет независимым компонентам программного обеспечения обмениваться информацией. Иными словами API выступает посредником между внутренними и внешними программными функциями. Если программу рассматривать как черный ящик, то API — это набор «ручек», которые доступны пользователю данного ящика и которые он может вертеть и дергать, как ему угодно.
На сегодняшний день существует два основных подхода к построению программного интерфейса веб-приложений: REST (RESTful) API и SOAP API. Если сравнить HTTP-запрос с бумажным носителем, то можно сказать, что REST API в большинстве случаев передает простые записки и время от времени — письмо в конверте (возможно, написав при этом часть послания и на самом конверте). В свою очередь, SOAP API отправляет все инструкции в подробном письме стандартного вида, используя конверт (единичный HTTP-запрос) лишь как средство доставки.
Когда клиенты и серверы работают только в веб-среде, информация об объектах не важна и нет транзакций с несколькими вызовами, применяют REST API. Если же необходимо соблюсти строгий контракт между сервером и клиентом, обеспечить те самые транзакции с несколькими вызовами с высокой безопасностью и нет проблем с пропускной способностью, тогда микросервисы настраивают на SOAP API.
### Какие инструменты нужны для тестирования API?
Отсутствие элементов UI-интерфейса с непривычки может ввести QA-специалиста в ступор: нет ни кнопок, ни полей, ни понятного формата обращения к сервисам. Облегчают взаимодействие с API специальные инструменты. Наиболее популярные среди них — SoapUI и Postman.
**SoapUI.** Приложение с открытым исходным кодом для тестирования Soap и Rest API. SoapUI был первоначально выпущен для SourceForge в сентябре 2005 года. Это бесплатное программное обеспечение с публичной лицензией Европейского Союза. Начиная с первого выпуска, SoapUI был загружен более 2 000 000 раз. Он полностью построен на платформе Java и использует Swing для пользовательского интерфейса (то есть SoapUI — кроссплатформенный). Его функциональные возможности включают проверку веб-службы, запуск, разработку, моделирование и макетирование, функциональное тестирование, тестирование нагрузки и соответствия.
Компания-разработчик программного обеспечения SmartBear также создала коммерческую версию SoapUI Pro (ныне носит название ReadyAPI), которая в основном фокусируется на функциях, предназначенных для повышения производительности. SoapUI может тестировать веб-сервисы SOAP и REST, JMS, AMF, а также выполнять любые вызовы HTTP(S) и JDBC. Для написания автоматизированных скриптов используется язык Groovy.
**Postman.** Как говорят его создатели, это своего рода швейцарский нож, который позволяет формировать и выполнять запросы, документировать и мониторить сервисы в одном месте. Тестировщики могут писать тесты и производить автоматизированное тестирование прямо из Postman.
Его основное предназначение — создавать коллекции с запросами к API. Коллекции позволяют удобно хранить запросы к тестируемому или разрабатываемому приложению, а новичку на проекте быстро разобраться с запросами к приложению. Кроме того, команда разработки может с легкостью использовать Postman для проектирования дизайна API. Для написания автоматизированных скриптов в Postman используется JavaScript.
### Почему мы выбрали именно Cucumber и Spock?
В использовании SoapUI и Postman есть свои нюансы. Подобные тесты очень трудно поддерживать и проблематично использовать системы контроля версий (git, например) для их хранения.
Несмотря на то, что они широко используются в автоматизированном тестировании, SoapUI и Postman позволяют запускать тесты только локально и не могут применяться в системах интеграции (Jenkins). Для решения подобной задачи наша команда обратилась к Cucumber и Spock. С ними можно запускать тесты с Jenkins удаленно. Кроме того, эти фреймворки позволяют создавать автоматизированные смок-тесты, которые запускаются во время установки приложения. А вот с помощью Postman или SoapUI такое сделать не получится.
Spock и Cucumber отражают философию Behavior Driven Development — разработки через поведение. Идея BDD заключается в том, что перед тем, как написать какой-либо тест, необходимо сначала описать на предметно-ориентированном языке желаемый результат от добавляемой функциональности. После этого полученная документация передается разработчикам.
Спецификация поведения подается в полу формальном виде и имеет следующую структуру:
* Заголовок (Title) — в сослагательной форме дается описание бизнес-цели.
* Описание (Narrative) — в краткой форме даются ответы на следующие вопросы:
+ кто является заинтересованным лицом данной истории;
+ что входит в состав истории;
+ какую ценность эта история представляет для бизнеса.
* Сценарии (Scenarios) — спецификация может содержать один и более сценариев, каждый из которых раскрывает одну из ситуаций поведения пользователя.
Сценарий обычно строится по одной и той же схеме:
* одно или несколько начальных условий (Given);
* событие, которое инициирует начало этого сценария (When);
* ожидаемый результат или результаты (Then).
BDD не предоставляет каких-либо формальных правил, но настаивает на том, чтобы использовался ограниченный стандартный набор фраз, включающий все элементы спецификации поведения. В 2007 году «отец» BDD Дэн Норт предложил шаблон для спецификации, который обрел широкую популярность и впоследствии стал известен, как язык Gherkin.
На сегодня один из самых популярных инструментов BDD — Cucumber. Его авторы стремились объединить автоматизированные приемочные испытания, функциональные требования и документацию ПО в единый формат, понятный и техническим, и нетехническим участникам проекта.
Основой описания сценария тестирования являются шаги Given, When, Then. Каждому из них соответствует аннотация, которая с помощью регулярного выражения связывает метод со строкой в текстовом описании сценария. Шаги тестирования группируются в сценарии (Scenario), которые в свою очередь описывают определенную функциональность (Feature).
Для автоматизации описанных сценариев в Cucumber можно использовать Ruby, Java и Python. Тест записывается в виде Gherkin-нотации в отдельный файл с расширением \*.feature. Этот файл может содержать один или несколько сценариев. Сценарии могут писать BA или мануальные QA. Далее специалист, занимающийся автоматизацией тестов, создает отдельный класс с реализацией шагов на определенном языке программирования.
С Cucumber фреймворком я познакомился во время написания сценариев поведения тестируемого API приложения. Точнее говоря, это был не сам Cucumber, а язык Gherkin и наши попытки описывать сценарии поведения приложения согласно правилам BDD. С точки зрения мануального тестировщика это интересный опыт. В команде было несколько мануальных тестировщиков, которые писали сценарии на Gherkin. Основная проблема состояла в сложности договориться с ними о едином формате описания каждого шага и создания набора шагов, которые могут повторяться в разных тестах, чтобы не дублировать их реализацию.
```
Feature: Test OpenWeather API
As a customer
In order to check weather
I want to get my city name in response.
Scenario Outline: Check if city name is returned correctly
When Sent request to openweathermap for “”
Then Check that 200 response code is returned
And Server returns correct city name “”
Examples
| cityReq | cityResp |
| “Kharkiv, UA” | “Kharkiv” |
| “London, GB” | “London” |
```
На примере выше представлена Gherkin-нотация сценария для тестирования открытого OpenWeather API приложения. Для примера я написал простой сценарий, который отправляет запрос с определенными параметрами на сервер приложения и затем проверяет ответ с этого сервера.
```
public class Stepdefs {
@when ( “Sent request to openweathermap for {cityReq} “ )
public void sent_request_to_ openweathermap ( String cityReq) {
HTTP Builder http = null;
try {
http = new HTTP Builder (testUrl);
String [ ] actualCity = cityReq.split ( regex: “, “ ) ;
```
Здесь в коде представлен пример класса Stepsdef на языке Java. Каждый шаг из feature файла привязывается к его реализации в Stepsdef классе с помощью аннотации (@Given, @When, @Then и тд.) и текста шага из feature файла.
Чтобы получить максимальную отдачу от Cucumber, нужно следовать принципам BDD, потому что Cucumber — только активатор для BDD.
Spock — это тестовая среда. Некоторые даже сказали бы «язык, построенный на базе языка Groovy». К этому фреймворку я обратился уже на другом проекте, где выступал в роли автоматизатора. Как я писал ранее, в Cucumber сценарии выполнения и реализация каждой конструкции разделены. Это позволяет составить удобочитаемые сценарии, но занимает много времени. Поэтому такой подход может быть непрактичным при написании реализации.
Описание шагов и их реализация в Spock находятся в одном groovy классе. Благодаря использованию в качестве основы платформы JUnit, этот фреймворк совместим со всеми популярными IDE (в частности, IntelliJ IDEA), различными инструментами сборки (Ant, Gradle, Maven) и CI-сервисами (continuous integration). Тестовый класс являет собой набор методов-сценариев с названиями в кавычках, подобные названиям сценариев в Cucumber. А поскольку эти классы являются производными от JUnit, есть возможность запускать их из IDE как обычный модульный тест Groovy. При этом мы получаем стандартные JUnit отчеты, что очень удобно при разработке и отладке автоматизированных тестов.
В Spock каждая фаза теста выделена в отдельный блок кода, который начинается с лейбла и завершается началом следующего блока кода или окончанием теста. Блок Given отвечает за настройку начальных условий теста. В блоке When — стимулятор, раздражитель системы, а в блоке Then — ответная реакция системы. Оба блока всегда используются вместе. Если есть возможность сократить конструкцию When-Then до одного выражения, можно использовать один блок Expect.
```
class WeatherTestSpec extends Specification {
@Shared def testUrl, testResponse
def setupSpec () {
testUrl = “http:// api. openweathermap.org”
testRequest = [ ‘APPID’ : “aaa” ]
testResponse = ‘ ‘
}
def ‘ Check if city name and coordinates is returned correctly’ () {
when: ‘ Sent request to openweathermap’
def http = new HTTPBuilder(testUrl)
testRequest.put ( ‘q’, cityReq)
testResponse = http.get( path : ‘/data/2.5/weather’ , query : testRequest )
then: “Check that 200 response code is returned”
testResponse. cod == 200
and: “Server returns correct city name”
testResponse. name == cityResp
where:
cityReq << [ “Kharkiv, UA”” , “London, GB”” ]
cityResp << [ “Kharkiv”” , “London ” ]
}
```
На примере выше представлен Groovy класс с тестом на Spock. Описание шага идет после символа «:» и представляет произвольную строку. При этом оно не является обязательным элементом. Spock допускает создание спецификации теста без описания шагов. Однако такая практика не считается общепринятой и в будущем приводит к затруднению понимания логики теста.
### А что лучше?
И Cucumber, и Spock тесно связывают спецификацию на человеческом языке с тестовым кодом. Это прямое следствие парадигмы BDD, для поддержки которой создали обе платформы. Но Cucumber делает это более строго. Большие изменения описания шага на человеческом языке нарушат тестовый код, например, с отсутствующей реализацией шага, если ни одно регулярное выражение метода не соответствует заданному тексту шага. В то время как для Spock текст представляет собой произвольную строку после символа «:». Описание шага проверяется на соответствие в последующей реализации.
Cucumber четко разделяет спецификацию на человеческом языке и тестовым кодом. Для нетехнических специалистов, которые пишут или читают спецификации, это безусловно удобно. Да и сама суть BDD — это тесное сотрудничество Product Owner, BA, QA, архитекторов и разработчиков. Так что в случае с Cucumber спецификация будет согласована и понятна всем участникам проекта до начала разработки.
С другой стороны, Spock предлагает быстрое, краткое и однофайловое решение. Возможность Groovy использовать любую строку в качестве названия метода позволяет применять удобные для восприятия названия отдельного тестового сценария. Spock дает разработчикам единую точку для чтения и понимания спецификации и кода, который ее реализует. А еще давайте не забывать о «плюшках», с которыми поставляется Spock (например, расширенные возможности таблицы данных).
Также стоит отметить, что Cucumber подходит исключительно для интеграционных тестов. В то время, как Spock может использоваться и для Unit-тестов.
Было бы неправильно определять, какой из этих способов автоматизации тестирования API однозначно лучше. Мы в NIX, в зависимости от задач и целей, выбираем и то, и другое. SoapUI и Postman отлично подходят на начальных этапах автоматизации, когда в команде нет или очень мало автоматизаторов. С ростом команды логичнее переходить на Cucumber или Spock. У каждого из этих фреймворков есть свои преимущества, которые упрощают рутинные задачи QA-специалистов и делают процесс тестирования более эффективным. | https://habr.com/ru/post/588400/ | null | ru | null |
# Функции для решения квадратичных сравнений. Реализация в MATLAB
#### Введение
Для решения криптографических задач необходимо уметь решать квадратичные сравнения по заданному модулю. Алгоритм решения квадратичного сравнения достаточно прост и не вызывает сложностей в решении при небольших значениях модуля и свободного члена, однако в связи с применением достаточно больших чисел в криптографии, решение квадратичных сравнений вручную является весьма кропотливым и длительным процессом. Конечно, для решения квадратичных сравнений можно воспользоваться онлайн-сервисом. Но так как решение криптографической задачи не заканчивается на решении квадратичного сравнения, то человеку, занимающемуся криптографией, будет удобно иметь функцию, способную решать квадратичные сравнения и свободно взаимодействовать с другими функциями, которые используются ним. Именно поэтому было решено написать функцию для решения квадратичных сравнений вида *x^2 ≡ a ( mod p )*, где *a* и *p* — взаимно простые числа, в MATLAB.
Сразу замечу, так написание функций для решения квадратичных сравнений носило обучающий характер, некоторые пользовательские функции, используемые при вычислении, дублируют функции, уже имеющиеся в среде MATLAB.
Сначала предлагаю рассмотреть код двух главных функций, одна из которых предназначена для решения квадратичных сравнений по составному модулю, а вторая – для решения квадратичных сравнений по простому модулю. При этом мы ознакомимся, в первую очередь с алгоритмом решения квадратичных сравнений, а уже во вторую очередь с функциями, которые необходимы для выполнения самих вычислений.
#### Функция для решения сравнений по сложному модулю
Данная функция позволяет решать квадратичные сравнения, как по простому, так и по сложному модулю. При вызове функции в нее необходимо передать две переменные *а* и *р*, в результате своего выполнения функция вернет вектор – строку из двух противоположных по знаку решений квадратичного сравнения.
```
function [ result ] = sqcomdif( a, p )
```
Следующим шагом в решении квадратичного сравнения будет определение типа модуля *р*. Для этого будет использоваться пользовательская функция *factorization*, предназначенная для разложения числа на простые множители. Кроме вектора-строки с простыми множителями функция возвращает количество простых множителей. По сути функция *factorization* дублирует стандартную функцию MATLAB *factor*.
```
[ mp, sp ] = factorization( p );
```
После того как модуль был разложен на множители с помощью условного оператора осуществляется проверка количества множителей. Если количество множителей превышает *1*, то есть модуль *р* – составное число, то тогда нам необходимо решить систему из *sp* квадратичных сравнений ( в каждом из сравнений модулем будет служить один из множителей составного модуля *р* ). Перед тем как браться за решение полученной системы квадратичных сравнений, необходимо убедиться в том, что каждое из квадратичных сравнений этой системы имеет решение. Для этого воспользуемся циклом *for*, который будет осуществлять переход между элементами вектора с множителями *mp*. В теле цикла будет вызываться функция, выполняющая вычисление значения символа Лежандра для каждой пары чисел.
```
for i=1:1:sp
SL( 1, i ) = symvol( a, mp( 1, i ) );
```
Если значения символа Лежандра будет равно *1*, то переменная *count* будет увеличена на *1*. Это нужно для того, чтобы после выполнения всех итераций цикла мы могли проверить, все ли уравнения системы имеют решение, ведь от этого зависит, будем ли мы решать квадратичные сравнения из которых состоит система, или выведем сообщения о том, что исходное квадратичное сравнение не имеет решений.
```
if SL( 1, i ) == 1
count = count + 1; % Если есть решение квадратичного сравнения count увеличиваем на 1
end
```
Если количество уравнений системы равняется количеству уравнений, имеющих решения, то создаются векторы-строки для хранения промежуточных результатов вычисления.
```
if count == sp
% Формируем векторы для хранения результатов рассчета
answer1 = zeros ( 1, sp ); % Хранение решения квадратичного сравнения
modul = zeros ( 1, sp ); % Хранение отношения общего модуля р к его множителю
answer2 = zeros ( 1, sp ); % Хранение решения линейного сравнения для нахождения общего ответа по Кит. теореме
```
С помощью цикла *for*, осуществляется переход между множителями модуля *р*. В вектор-строку *answer1* записываются результаты решения квадратичного сравнения по простому модулю, который получен с помощью функции *sqcom*, в которую были переданы значение переменной *а*, а также значение *i-ого* множителя модуля *p*. В вектор-строку *modul* записывается частное от деления составного модуля *р* на *i-ый* множитель модуля *p*. В вектор-строку *answer2* будет сохраняться результат решения линейного неравенства *( p / p( I ) ) \* y ≡ 1 ( p ( i) )*, которое будет необходимо для расчета окончательного ответа по формуле полученной из Китайской теоремы.
```
% Выполнение расчетов для каждого квадратичного сравнения системы
for i=1:1:sp
answer1( 1, i ) = sqcom( a, mp( 1, i ) ) ;
modul( 1, i ) = p / mp( 1, i );
answer2( 1, i ) = lincom ( modul( 1, i ), 1, mp( 1, i ) );
end
```
После того как цикл закончил свое выполнение, необходимо рассчитать окончательный ответ по формуле: *x=( ( p / p( 1)) \* b( 1 ) \* y( 1 ) + ( ( p / p( 2) ) \* b( 2 ) \* y( 2 ) + ( ( p / p( i ) ) \* b( i ) \* y( i )*. Для этого воспользуемся поэлементным умножением. В результате будет получена вектор-строка, сумму элементов которой найдем с помощью команды *sum*. Найдем остаток от деления суммы на составной модуль *р* – это будет одним из решений квадратичного сравнения по составному модулю. Второй ответ получим, записав первый ответ с противоположным знаком.
```
% Расчет окончательного ответа
result = zeros ( 1, 2 );
result( 1, 1 ) = mod( sum( ( modul .* answer1 ) .* answer2 ), p );
result( 1, 2 ) = - result( 1, 1 );
```
В том случае, если изначально модуль *р* оказался простым числом, то решение квадратичного сравнения будет получено, путем одноразового вызова функции для решения квадратичного сравнения — *sqcom*. Второе решение будет получено путем взятия первого ответа с противоположным знаком.
```
else
result( 1, 1 ) = sqcom( a, p );
result( 1, 2 ) = - result( 1, 1 );
end
```
Ниже привожу код функции sqcomdif полностью.
```
function [ result ] = sqcomdif( a, p )
% Функция предназначена для решения квадратичных сравнений по заданному модулю
% Даная функция решает квадратичные сравнения как по простому,
% так и по сложному модулю. При решении квадратичного сравнения по сложному модулю,
% общее решение находится по формуле, полученной из Китайской теоремы.
[ mp, sp ] = factorization( p );
if sp > 1 % Если модуль является составным числом
count = 0;
% Выполняется проверка на возможность решения квадратичного сравнения для
% каждого простого множителя модуля
for i=1:1:sp
SL( 1, i ) = symvol( a, mp( 1, i ) );
if SL( 1, i ) == 1
count = count + 1; % Если есть решение квадратичного сравнения count увеличиваем на 1
end
end
% Если все квадратичные сравнения системы имеют решения
if count == sp
% Формируем векторы для хранения результатов рассчета
answer1 = zeros ( 1, sp ); % Хранение решения квадратичного сравнения
modul = zeros ( 1, sp ); % Хранение отношения общего модуля р к его множителю
answer2 = zeros ( 1, sp ); % Хранение решения линейного сравнения для нахождения общего ответа по Кит. теореме
% Выполнение рассчетов для каждого квадратичного сравнения системы
for i=1:1:sp
answer1( 1, i ) = sqcom( a, mp( 1, i ) ) ;
modul( 1, i ) = p / mp( 1, i );
answer2( 1, i ) = lincom ( modul( 1, i ), 1, mp( 1, i ) );
end
% Расчет окончательного ответа
result = zeros ( 1, 2 );
result( 1, 1 ) = mod( sum( ( modul .* answer1 ) .* answer2 ), p );
result( 1, 2 ) = - result( 1, 1 );
else
result = 'net resheniy';
end
else
result( 1, 1 ) = sqcom( a, p );
result( 1, 2 ) = - result( 1, 1 );
end
end
```
#### Функция для решения квадратичного сравнения по простому модулю
Эта функция неоднократно вызывалась в функции *sqcomdif*, и как уже говорилось, функция *sqcom* применяется для решения квадратичного сравнения по простому модулю и может вызываться независимо от функции *sqcomdif*, то есть ее можно без проблем вызвать и получить верный ответ в том случае, когда вы уверенны, что модуль – простое число. Так как рассматривается лишь лишение квадратичных сравнений вида *x^2 ≡ a ( mod p )*, то в функцию необходимо передать числовые значения переменных *а* и *р*. В результате работы функции будет получено одно решение квадратичного сравнения.
```
function [ answer ] = sqcom( a, p )
```
Так как функция sqcom может использоваться отдельно от функции *sqcomdif*, то необходимо убедиться в том, что число, записанное в переменную *а*, является квадратичным вычетом модуля *р*. Для этого воспользуемся функцией *symvol*, которая позволяет вычислить значение символа Лежандра для указанной пары чисел.
```
[ Symvol_Lejandra ] = symvol( a, p );
```
Если значение переменной *Symvol\_Lejandra* равно *1*, то а является квадратичным вычетом по модулю *р* и будут выполнены дальнейшие действия для нахождения решения квадратичного сравнения. Нам нужно записать число *( р – 1 )* в виде *2^r \* q*. Начальные значения переменным *r*, *q* задаются из расчета, что *( р – 1 )* – нечетное число. Однако если это не так, то они будут изменяться в процессе выполнения цикла ( до тех пор, пока *q* не станет нечетным числом ).
```
q = p - 1;
r = 0;
otn = q / 2;
while ( ( q - floor( otn ) * 2 ) == 0 )
q = otn;
r = r + 1;
otn = q / 2;
end
```
Теперь необходимо найти значение переменной *b*, которая равняется *b = a^q ( mod p )*. Так как *а* и *q*, обычно выражены достаточно большими числами, то возвести число *а* в степень *q* обычным способом не удастся, так как в большинстве случаев возникнет переполнение. Поэтому возведение в степень необходимо выполнять по методу квадрирования. Для того чтобы выполнить это необходимо вызвать функцию *kvadrirovanie* и передать в нее значение основания, показателя степени, а также модуля по которому будут выполняться вычисления.
```
b = kvadrirovanie( a, q, p );
```
Для продолжения вычислений нужно найти наименьшее неотрицательное число *f*, которое будет квадратичным невычетом по модулю *р*. Для этого переменной *f*, присваивается значение *1*, и с помощью функции *symvol*, определяется значение символа Лежандра для пары чисел *f* и *р*. Если символ Лежандра для *1* и *р* равен *1*, то переменная *f*, с помощью цикла *while*, увеличивается, до тех пор, пока не будет достигнуто значение, являющееся квадратичным невычетом по модулю *р*.
```
f = 1;
sym_lej = symvol( f, p );
while sym_lej ~= -1
f = f + 1;
sym_lej = symvol( f, p );
end
```
Теперь значение *f*, являющееся квадратичным невычетом по модулю *p*, необходимо возвести в степень *q*. Для этого также придется прибегнуть к функции *kvadrirovanie*, переменной *k* не обходимо присвоить значение *0*.
```
g = kvadrirovanie( f, q, p);
k = 0;
```
После вышеперечисленных действий необходимо проверить значение переменной *b*. Если *b* сравнимо с *1* по модулю *p*, то необходимо перейти к расчету ответа, в противном случае найти наименьшее неотрицательное число *m*, такое что *b^( 2^m ) ≡ 1 ( mod p )*. Когда такое значение *m* будет найдено, необходимо пересчитать значения переменных *k*, *g*, *b*, после чего переменной *r* присвоить значение *m*. Но это еще не все, необходимо проверить, чтобы новое значение переменной *b*, также было сравнимо с *1* по модулю *р*. Если это не так, то необходимо вернуться к подбору числа *m*. Переменная *pok* нужна для того, чтобы избежать выполнения определенных математических действий дважды.
```
if b ~= 1
while b ~= 1
m = 0;
b1 = kvadrirovanie( b, 2^m, p );
while mod( b1, p) ~= 1
m = m + 1;
b1 = kvadrirovanie( b, 2^m, p );
end
pok = 2^(r-m);
g1 = kvadrirovanie( g, pok, p );
b = mod( ( b*g1), p );
k = fix(k + pok);
r = m;
end
end
```
После того как было найдено *m*, удовлетворяющее перечисленным выше условиям, можно переходить к непосредственному вычислению ответа. Ответ вычисляется по формуле *x = a^( ( q+1) / 2 ) \* g^( k / 2 ) ( mod p )*. Для вычисления обеих множителей воспользуемся функцией квадрирования, полученный результат возьмем по модулю *p*.
```
first = kvadrirovanie( a, ( ( q + 1 ) / 2 ), p );
second = kvadrirovanie( g, ( k / 2 ), p );
answer = mod( ( first * second ), p);
```
Полученный результат не всегда может быть записан оптимально, по модулю *р*. Поэтому необходимо выполнить следующую проверку:
```
delta = p - answer;
if delta < answer
answer = delta;
end
```
Ниже приведен полный код функции *sqcom*:
```
function [ answer ] = sqcom( a, p )
% Функция предназначена для решения квадратичного сравнения по простому
% модулю
% Функция решает квадратичное сравнение вида x^2 = a ( mod p ) , возвращает
% одно решение. Это решение взятое с противоположным знаком будет
% вторым решением.
a=mod(a,p);
% ШАГ 1 проверяем есть ли решение данного квадратичного неравенства
[ Symvol_Lejandra ] = symvol( a, p );
if Symvol_Lejandra == 1
% ШАГ 2 Ищем q, r, вычисляем b
q = p - 1;
r = 0;
otn = q / 2;
while ( ( q - floor( otn ) * 2 ) == 0 )
q = otn;
r = r + 1;
otn = q / 2;
end
b = kvadrirovanie( a, q, p );
% ШАГ 3 Ищем f и квадратичный невычет
f = 1;
sym_lej = symvol( f, p );
while sym_lej ~= -1
f = f + 1;
sym_lej = symvol( f, p );
end
g = kvadrirovanie( f, q, p);
k = 0;
% ШАГ 4 ИТЕРАЦИЯ
if b ~= 1
while b ~= 1
m = 0;
b1 = kvadrirovanie( b, 2^m, p );
while mod( b1, p) ~= 1
m = m + 1;
b1 = kvadrirovanie( b, 2^m, p );
end
pok = 2^(r-m);
g1 = kvadrirovanie( g, pok, p );
b = mod( ( b*g1), p );
k = fix(k + pok);
r = m;
end
end
% ШАГ 5 Рассчет окончательного ответа
first = kvadrirovanie( a, ( ( q + 1 ) / 2 ), p );
second = kvadrirovanie( g, ( k / 2 ), p );
answer = mod( ( first * second ), p);
delta = p - answer;
if delta < answer
answer = delta;
end
else
answer = 'net resheniya';
end
```
А теперь предлагаю ознакомиться с вспомогательными функциями, которые используются как при решении квадратичного сравнения, так могут использоваться и отдельно.
#### Разложение числа на множители
При решении квадратичного сравнения во многих случаях необходимо прибегать к разложению числа на множители, также к этой операции придется прибегать в тех случаях, когда будет необходимо проверить: является число простым или составным.
В функцию *factorization* передается число, которое необходимо разложить на множители. В результате функция возвращает вектор — строку с множителями и количество этих множителей.
```
function [ mnojitel, ind ] = factorization( delimoe )
```
Функция состоит из оператора *switch*, который выполняет различные действия в зависимости от значения входной переменной *delimoe*. Так если *delimoe = 1*, то в вектор, хранящий результат разложения на множители, *mnojitel* записывается *1*, в переменную *ind*, хранящую число множителей, также записывается *1*. Аналогичные действия выполняются и в том случае, если *delimoe* равно *-1*.
```
switch delimoe
case { 1 }
mnojitel( 1, 1 )=1;
ind=1;
case { -1 }
mnojitel( 1, 1 )= -1;
ind = 1;
```
Если эти условия не выполнились, то выполняем проверку знака числа, раскладываемого на множители. Если *delimoe* меньше *0*, то в первый множитель записывается *-1*, в *ind* записывается *2*, и дальнейшая работа функции будет осуществляться с модулем переменной *delimoe*.Если же число больше *0*, то переменной *ind* присваивается значение *1*.
```
otherwise
if delimoe < 0
mnojitel( 1, 1 )= -1;
ind = 2;
delimoe = abs ( delimoe );
else
ind = 1;
end
```
Цикл *while* работает до тех пор, пока *delimoe* не равняется *delitel*, причем изначально переменной *delitel* присвоено значение *2*. При каждой итерации цикла, в переменную *ostatok* записывается остаток от деления *delimoe* на *delitel*. Если остаток равен *0*, то есть *delitel* является множителем *delimoe*, то это значение записывается в вектор, в котором хранятся множители, а счетчик этого вектора увеличивается на *1*. При этом переменной *delimoe* присваивается частное от выполненного деления. Если же остаток от деления не равен *0*, то *delitel* увеличивается на *1*. Когда же происходит выход из цикла, то значение, оставшееся в переменной *delimoe*, записывается в вектор с множителями, как один из множителей.
```
while ( delimoe ~= delitel )
ostatok = mod( delimoe, delitel );
if ostatok ~= 0
delitel = delitel + 1;
else
delimoe = delimoe / delitel;
mnojitel( 1, ind ) = delitel;
ind = ind + 1;
end
end
mnojitel( 1, ind ) = delimoe;
```
Ниже приведу полный код функции *factorization*.
```
function [ mnojitel, ind ] = factorization( delimoe )
% Функция для разложения числа на множители
% Начальные значения
delitel = 2;
% Разложение на множители
switch delimoe
case { 1 }
mnojitel( 1, 1 )=1;
ind=1;
case { -1 }
mnojitel( 1, 1 )= -1;
ind = 1;
otherwise
if delimoe < 0
mnojitel( 1, 1 )= -1;
ind = 2;
delimoe = abs ( delimoe );
else
ind = 1;
end
while ( delimoe ~= delitel )
ostatok = mod( delimoe, delitel );
if ostatok ~= 0
delitel = delitel + 1;
else
delimoe = delimoe / delitel;
mnojitel( 1, ind ) = delitel;
ind = ind + 1;
end
end
mnojitel( 1, ind ) = delimoe;
end
end
```
#### Вычисление значения символа Лежандра
Для того чтобы проверить является ли число квадратичным вычетом по заданному модулю ( в таком случае квадратичное сравнение имеет решение ) или квадратичным невычетом ( тогда такое квадратичное сравнение не имеет решения ) применяется символ Лежандра, который в отечественной литературе обозначается как *L ( a; p )*, в зарубежной литературе как *L (a / p )*.
Символ Лежандра может принимать следующие значения:
*L ( a; p ) = 1*, в таком случае а принадлежит QR, квадратичное сравнение имеет решение
*L ( a; p ) = -1*, в таком случае а принадлежит QNR, квадратичное сравнение не имеет решения
Если *L ( a; p ) = 0*, то а и р не являются взаимно простыми числами, то есть *НОД ( а; р )* не равен *1*
Для вычисления значения символа Лежандра применяются следующие свойства:
1. *L ( 1; p ) = 1*
2. *L ( -1; p ) = ( -1 ) ^ ( ( p — 1 ) / 2 )*
3. *L ( 2; p ) = ( -1 ) ^ ( ( p^2 — 1) / 8 )*
4. Если *а≡ b\*с ( mod p )*, то *L ( b\*с; p ) = L ( b; p ) \* L (с; p )*
5. Если *а≡ b ( mod p )*, то *L ( а; p ) = L ( b; p )*
6. Если *а* и *р* – простые числа, то *L ( а; p ) = (-1) ^( (( p — 1 ) \*(a-1)) / 4 ) \* L( p; a )*. Последнее свойство получило название закона взаимности Гаусса.
Вычисление символа Лежандра выполняется на основе вышеперечисленных свойств. Как только одно из условий выполнилось, начинаем проверять свойства для полученной пары *а* и *р*, до тех пор, пока не будет найдено окончательное значение символа Лежандра.
Теперь рассмотрим, как можно реализовать вычисление значения символа Лежандра программно.
Функция будет возвращать значение символа Лежандра для пары чисел *а* и *р*, которые были переданы в нее. Это видно из заголовка функции:
```
function [ sl ] = symvol( a, p )
```
Следующий шаг по своей сути является применением свойства *5*. Если число *а* больше модуля *р*, то его можно заменить меньшим числом, сравнимым с *а* по модулю *р*.
```
a=mod( a, p ); % Взятие а по модулю р
```
Полученное число *а*, пытаемся разложить на множители. Для разложения числа на множители была написана пользовательская функция *factorization*, возвращающая вектор с простыми множителями, из которых состоит число *а*, а также их количество. Подробно эта функция была описана выше.
```
[ mnoj, ind ] = factorization( a ); % Разложение числа а на множители
```
Если *а* не являлось простым числом, то будем действовать по свойству *4*. То есть значение символа Лежандра для пары чисел *L ( а; p )*, найдем как произведение значений символов Лежандра для чисел, являющихся простыми множителями числа *а*. Для хранения промежуточных результатов создадим вектор-строку, заполненную нулями с размерностью, равной количеству множителей числа *а*. Если *а* – простое, то эта строка будет состоять из одного элемента.
```
sl = zeros( 1, ind ); % Создание матрицы для хранения значений символов Лежандра для каждого множителя
```
Для вычисления символа Лежандра для каждого множителя поочередно воспользуюсь циклом *for*, который будет изменять свои значения от *1* до номера последнего множителя. В теле данного цикла происходит непосредственный процесс вычисления значения символа Лежандра с помощью свойств, перечисленных выше.
Код для проверки свойства 1 имеет следующий вид:
```
% Для символа L(1,p)
if mnoj( 1, i ) == 1
sl( 1, i ) = 1;
end
```
Так как при проверке значения символа при его виде *L(-1,p)*, по свойству *2*, необходимо вычислить значение *( -1 ) ^ ( ( p — 1 ) / 2 )*, то необходимо воспользоваться еще одним условным оператором, в котором будет проверяться, является показатель *-1* четным или нечетным числом. В зависимости от этого будет варьироваться значение символа Лежандра. Если показатель четный – то символ Лежандра будет равен *1*, в противном случае *-1*. Применение этого условного оператора позволяет избежать возведение *-1* в степень *( р — 1)/2*, что является весьма затратной операцией.
```
% Для символа L(-1,p)
if mnoj( 1, i ) == -1
if mod( ( ( p - 1 ) ) / 2, 2 ) == 0
sl( 1, i ) = 1;
else
sl( 1, i ) = -1;
end
end
```
Аналогичные действия выполняются и в том случае, когда необходимо вычислить значение символа Лежандра при его виде *L ( 2; p )*. В таком случае оно будет равняться *( -1 ) ^ ( ( p^2 — 1) / 8 )*.
```
% Для символа L(2,p)
if mnoj( 1, i ) == 2
% Если показатель четный то символ Лежанра будет равен 1, иначе -1
if mod( ( ( p^2 - 1 ) / 8 ), 2 ) == 0
sl(1,i)=1;
else
sl(1,i)=-1;
end
end
```
После проверки этого условия число *а*, передается в функцию, для того, чтобы проверить, простое оно или нет. В случае если число *а* – составное ( число его множителей *ind1* больше *1* ), то происходит рекурсия и число *а* передается в эту же функцию для выполнения дальнейших вычислений.
```
[ mn, ind1 ] = factorization( mnoj( 1, i ) ); % Расскладываем число а на множители
if ind1 > 1 % Если число а - составное
sl( 1, i ) = symvol( mnoj(1,i), p ); % то передаем его в эту же функцию, для дальнейших вычислений
```
В противном случае число *а* – простое. Если при этом оно не равно *-1*, *1*, *2*, то приходится воспользоваться свойством *6* – законом взаимности Гаусса. Знак перед символом Лежандра определяется путем определения четности множителей его показателя. Он обращается в плюс, если хотя бы один из множителей – четный. После чего происходит рекурсивный вызов функции *symvol*, а аргументы в нее передаются в другом порядке.
```
elseif and( mnoj(1,i)~=-1, and( mnoj( 1, i ) ~= 1, mnoj( 1, i ) ~= 2 ) )% если число а - простое, не равно 1, -1, 2
if or( mod( ( ( p - 1 ) / 2 ), 2 ) == 0, mod( ( ( mnoj( 1, i ) - 1 ) / 2 ), 2 ) == 0 ) % если хотя бы один из множителей показателя - четный
sl(1,i)= symvol( p, mnoj( 1, i ) ); % L(p,a)
else
sl(1,i)=-symvol( p, mnoj( 1, i ) ); % -L(p,a)
end
end
```
В результате проверки вышеперечисленных условий были охвачены все возможные варианты значений числа *а*.
Если изначально число *а* было составным, то в переменную *sl* записывается произведение всех элементов строки — вектора *sl*, после чего полученное значение возвращается в программу, вызвавшую данную функцию.
```
if ind ~= 1
sl = prod( sl ); % Вычисление результата L(a,p)
end
```
Полный код функции *symvol*:
```
function [ sl ] = symvol( a, p )
% Функция для вычисления символа Лежандра L(a,p)
% Функция позволяет вычислить символ Лежандра, что дает возможность
% проверить, имеет ли решение квадратичное сравнение по простому модулю
a=mod( a, p ); % Взятие а по модулю р
[ mnoj, ind ] = factorization( a ); % Разложение числа а на множители
sl = zeros( 1, ind ); % Создание матрицы для хранения значений символов Лежандра для каждого множителя
% Цикл перебирающий множители вектора а
for i = 1:ind
% Для символа L(1,p)
if mnoj( 1, i ) == 1
sl( 1, i ) = 1;
end
% Для символа L(-1,p)
if mnoj( 1, i ) == -1
if mod( ( ( p - 1 ) ) / 2, 2 ) == 0
sl( 1, i ) = 1;
else
sl( 1, i ) = -1;
end
end
% Для символа L(2,p)
if mnoj( 1, i ) == 2
% Если показатель четный то символ Лежанра будет равен 1, иначе -1
if mod( ( ( p^2 - 1 ) / 8 ), 2 ) == 0
sl(1,i)=1;
else
sl(1,i)=-1;
end
end
[ mn, ind1 ] = factorization( mnoj( 1, i ) ); % Расскладываем число а на множители,
% чтобы проверить простое число или составное
if ind1 > 1 % Если число а - составное
sl( 1, i ) = symvol( mnoj(1,i), p ); % то передаем его в эту же функцию, для дальнейших вычислений
elseif and( mnoj(1,i)~=-1, and( mnoj( 1, i ) ~= 1, mnoj( 1, i ) ~= 2 ) )% если число а - простое, не равно 1 и не равно 2
if or( mod( ( ( p - 1 ) / 2 ), 2 ) == 0, mod( ( ( mnoj( 1, i ) - 1 ) / 2 ), 2 ) == 0 ) % если хотя бы один из множителей показателя - четный
sl(1,i)= symvol( p, mnoj( 1, i ) ); % L(p,a)
else
sl(1,i)=-symvol( p, mnoj( 1, i ) ); % -L(p,a)
end
end
end
if ind ~= 1
sl = prod( sl ); % Вычисление результата L(a,p)
end
end
```
#### Возведение числа в степень по методу квадрирования
При решении квадратичного сравнения часто приходится сталкиваться с необходимостью возведения больших чисел в степень с показателем равным нескольким сотням, а то и тысячам. При обычном возведении числа в такую степень достаточно легко натолкнуться на такое неприятное явление, как переполнение. Для того чтобы избежать его, необходимо возводить такие числа в степень используя метод квадрирования.
Рассмотрим алгоритм данного метода:
1. Показатель степени записывается в двоичной системе счисления.
2. Если он состоит из двух или более бит, под первой *1* записываем число *m=a*.
3. Смотрим на следующий справа бит:
* Если это единица то возводим *m* в квадрат и берем его по модулю *р*, а полученный результат домножаем на *а* и берем его по модулю *р*, окончательный результат записывается в переменную *m*.
* Если это нуль, то возводим число *m* в квадрат, берем результат по модулю *р*, окончательный результат записывается в переменную *m*.
4. Переходим к следующему справа биту и повторяем действия описанные в пункте 3, пока не будут выполнены расчеты для последнего бита.
А теперь рассмотрим, как работает функция *kvadrirovanie*. В функцию передаются значения основания, показателя и модуля, а возвращает функция одно число – конечный результат.
```
function [ result ] = kvadrirovanie( a, q, p )
```
Показатель степени *q* переведем в двоичный вид, и так как полученный результат будет состоять из отдельных символов, то воспользуемся командой *size*, для определения количества бит, необходимых для записи показателя степени.
```
q = dec2bin( q );
size_q = size(q);
```
Если для записи показателя степени необходимо два или более битов, то программа выполнит следующие действия: запишет в переменную *m* типа *uint64* число *а*. После чего с помощью цикла *for*, который будет изменять значения переменной *i* от *2* с шагом *1* до количества бит, необходимых для записи показателя степени *q*, для того, чтобы иметь возможность осуществлять перебор битов.
```
if size_q( 1, 2 ) >= 2
m = uint64(a);
for i=2:1:size_q(1,2)
```
В теле цикла имеется условный оператор, который, в зависимости от значения *i-го* бита, будет определять действия, которые необходимо произвести с переменной *m*. Как писалось выше, если бит равен *1*, то необходимо возвести *m^2* и взять по модулю *р*, после чего умножить полученное число на *а*, и результат взять по модулю *р*.
```
if q(1,i)=='1'
m = uint64( mod( ( mod( ( m^2 ), p ) * a ), p ));
```
Иначе, *q(1,i)=='0'*, необходимо возвести *m^2* и взять его по модулю *р*.
```
else
m = uint64(mod( ( m^2 ), p ));
end
```
После выполнения всех повторов цикла, окончательное значение переменной *m* записывается в переменную *result*.
```
result =uint64(m);
```
В показатель степени в двоичной форме равен *1*, то в переменную *result* записывается само же исходное число, которое требовалось возвести в степень.
```
elseif q(1,1) == '1'
result = uint64( a );
```
Если же и это условие не выполнилось, то следовательно показатель степени равняется *0*. В таком случае в переменную *result* будет записана *1*.
```
else
result = 1;
end
```
Полный код функции для возведения в степень по методу квадрирования:
```
function [ result ] = kvadrirovanie( a, q, p )
% Функция для возведение числа в степень по указанному модулю
% Показатель переводится в двоичный вид, если бит равен 1 то число
% возводится в квадрат и домножается само на себя, если ноль то возводится
% в квадрат. Полученный результат берется по модулю.
q = dec2bin( q );
size_q = size(q);
if size_q( 1, 2 ) >= 2
m = uint64(a);
for i=2:1:size_q(1,2)
if q(1,i)=='1'
m = uint64( mod( ( mod( ( m^2 ), p ) * a ), p ));
else
m = uint64(mod( ( m^2 ), p ));
end
end
result =uint64(m);
elseif q(1,1) == '1'
result = uint64( a);
else
result = 1;
end
end
```
#### Решение линейных сравнений
При решении квадратичных сравнений по сложному модулю будет применяться формула, полученная из Китайской теоремы. Для того чтобы рассчитать ответ по этой формуле появляется необходимость решить линейное сравнение *k \* x ≡ b ( mod p )*. Данная функция предназначается для их решения с помощью обратного элемента, то есть такого числа *k1* которое при умножении на *k*, даст результат сравнимый с *1* по заданному модулю *р*.
В функцию *lincom* передаются значения коэффициента при неизвестном *k*, число *b*, с которым сравнима левая часть, а также модуль *p*, а возвращает функция соответственно решение линейного сравнения с заданными параметрами.
```
function [ x ] = lincom ( k, b, p)
```
Как указывалось выше, неравенство будем решать с помощью обратного элемента. Для того чтобы найти обратный элемент воспользуемся расширенным алгоритмом Эвклида для нахождения НОДа. Напомню, что расширенный алгоритм Эвклида позволяет найти НОД с помощью коэффициентов, которые рассчитываются при выполнении каждой операции деления. Для нахождения НОДа по данному алгоритму необходима рассчитать два *( a, b )* коэффициента, но при нахождении обратного элемента нам потребуется только один – *b* коэффициент, который как раз и будет обратным элементом для *k*.
В функции необходимо указать начальные значения коэффициентов *b0* и *b1*, которые будут изменяться по мере выполнения расчетов. Если модуль *p*, который был записан в переменную *pr*, делится нацело на коэффициент *k*, то обратный элемент будет равен *1*. Иначе *b1* будет рассчитываться с помощью цикла *while*. В цикле будет пересчитываться значения переменной *b0*. После того как найдено новое значение *b0*, с помощью функции *swap* будет осуществляться обмен значений между переменными *b0* и *b1*. Также при каждой итерации цикла будет происходить присвоение новых значений ряду других переменных.
```
b0=0;
b1=1;
%Нахождение остатка
ostatok = mod( pr, k );
while ostatok ~= 0
chastnoe = floor( pr / k );
b0 = b0 - b1 * chastnoe;
[ b0, b1 ] = swap( b0, b1 );
pr = k;
k = ostatok;
ostatok = mod( pr, k );
end
```
После того, как цикл прекратит свое выполнение будет необходимо рассчитать значение решения линейного сравнения. Оно будет равно произведению переменных *b1* и *b*, взятое по модулю *p* ( именно для этой операции в начале функции значение модуля было продублировано с помощью переменной *pr* ).
```
x = mod( b1*b, p );
```
Ниже приведен код функции целиком:
```
function [ x ] = lincom ( k, b, p)
% Функция предназначена для решения линейных неравенств вида k*x=b ( mod p )
pr=p;
b0=0;
b1=1;
%Нахождение остатка
ostatok = mod( pr, k );
while ostatok~=0
chastnoe = floor( pr / k );
b0 = b0 - b1 * chastnoe;
[ b0, b1 ] = swap( b0, b1 );
pr = k;
k = ostatok;
ostatok = mod( pr, k );
end
x = mod( b1*b, p );
end
```
#### Список источников, которые помогли при создании функций и написании статьи:
1. Конспекты и лекции Плотниковой Л.И. ( кто в теме — поймет )
2. [http://math.hashcode.ru](http://math.hashcode.ru/questions/52339/%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F-%D1%87%D0%B8%D1%81%D0%B5%D0%BB-%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D0%B5-%D1%81%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BF%D0%BE-%D0%BF%D1%80%D0%BE%D1%81%D1%82%D0%BE%D0%BC%D1%83-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E)
3. [http://mathhelpplanet.com](http://mathhelpplanet.com/static.php?p=onlain-naiti-nod-i-nok#sravnenie)
4. <http://www.wolframalpha.com> | https://habr.com/ru/post/247683/ | null | ru | null |
# Windows + Lighttpd + Python краткая инструкция по запуску
Под катом краткая инструкция по установке и настройке вышеуказанной связки. Через поиск не нашел, когда ставил для себя пришлось порыться по инету.
##### Шаг первый.
[Качаем](http://en.wlmp-project.net/downloads.php?cat=lighty) и ставим Lighttpd для Windows.
##### Шаг второй.
[Качаем](http://www.python.org/download/) и ставим питон для Windows.
##### Шаг третий.
Настраиваем конфиги, идем в C:\Program Files\LightTPD\conf и правим файл lighttpd-inc.conf, а именно:
**Раскомментировать**
```
server.modules = (
...
"mod_cgi",
"mod_rewrite",
...
)
```
**Задать полный путь к каталогу в котором будет находиться наш базовый сайт, задать нужно полностью (pytрon.exe не будет исполнять .py файлы по относительным путям) и с прямым слэшем.**
```
server.document-root = "C:/Program Files/LightTPD/HTDOCS/"
```
**Добавить описание заголовочного файла на питоне:**
```
index-file.names = ( "index.py", "index.php", "index.pl", "index.cgi",
"index.html", "index.htm", "default.htm" )
```
**Занести питоновские файлы в исключения, чтобы не относить его к статическому контенту:**
```
static-file.exclude-extensions = ( ".php", ".pl", ".cgi",".py" )
```
**И самое главное, указываем полный путь к местанахождению интерпретатора питона:**
```
cgi.assign = ( ".py" => "C:/Python27/python.exe")
```
**Если 80 порт уже используется каким-либо веб-сервером или приложением стоит проверить строку с привязкой к порту и изменить на свободный:**
```
server.port = 81
```
Запускаем Lighttpd сервер (C:\Program Files\LightTPD\TestMode.bat)
##### Шаг четвертый.
Создаем тестовый файл на питоне. Я использовал следующий код:
```
#!C:\Python27\python.exe -u
#!/usr/bin/env python
import cgi
import cgitb; cgitb.enable() # for troubleshooting
print "Content-type: text/html"
print
print """
Sample CGI Script
### Sample CGI Script
"""
form = cgi.FieldStorage()
message = form.getvalue("message", "(no message)")
print """
Previous message: %s
form
form method="post" action="index.py"
message:
""" % cgi.escape(message)
```
Но конечно можно ограничиться и более простым
```
print "hello";
```
Называем файл index.py и ложим по пути C:\Program Files\LightTPD\htdocs.
[Тестируем](http://localhost:81/index.py) вбив в адресную строку:
```
http://localhost:81/index.py
```
, должно работать и просто
```
http://localhost:81
```
Тестировалось на Windows Server 2008 R2 x64. Должно по идее работать на любой версии ОС. | https://habr.com/ru/post/113190/ | null | ru | null |
# Переход с jQuery на Vue.js
Автор статьи, перевод которой мы публикуем сегодня, полагает, что в мире существует ещё много программистов, которые, когда им нужно разработать простое веб-приложение, обращаются к [jQuery](https://jquery.com/). Обычно это случается тогда, когда некую страницу нужно оснастить простыми интерактивными возможностями, но использование для этого какого-нибудь JavaScript-фреймворка кажется явным перебором. Ведь это — килобайты ненужного кода, шаблоны, инструменты для сборки проектов, средства для упаковки модулей… При этом подключить к странице jQuery, воспользовавшись CDN-ресурсом, проще простого.
[](https://habr.com/company/ruvds/blog/414073/)
В этом материале речь пойдёт о том, как перевести проект, созданный с использованием jQuery, на [Vue.js](https://vuejs.org/). Этот проект будет создан на jQuery, а потом переработан с применением Vue. Автор материала хочет продемонстрировать всем желающим то, что использование Vue, даже в сравнительно небольших проектах, не обязательно означает чрезмерное увеличение размера кода таких проектов и большую дополнительную нагрузку на программиста. Это, наоборот, при практически тех же размерах вспомогательного кода, что и при использовании jQuery, позволяет повысить производительность труда и улучшить качество приложений.
Обзор проекта
-------------
Мы собираемся разработать простой электронный счёт, основанный на [этом](https://github.com/sparksuite/simple-html-invoice-template) опенсорсном шаблоне от Sparksuite.
Нередко в подобных учебных примерах используют всяческие списки дел. Надеюсь, отступление от этой традиции сделает рассказ свежее и интереснее, и, при этом, наша задача окажется достаточно сложной для того, чтобы на её примере можно было продемонстрировать преимущества использования чего-то вроде Vue для разработки небольших проектов. Руководство построено так, чтобы все желающие без особых сложностей могли бы его воспроизвести и освоить предлагаемые методы работы.
Вот шаблон счёта, с которым мы хотим поработать.
*Электронный счёт*
Мы собираемся добавить ему интерактивных возможностей, сделав так, чтобы в нём можно было бы выбирать товар, его количество и цену за единицу. При изменении значений будет пересчитываться итоговая стоимость товара и общая сумма по документу. Кроме того, мы добавим сюда кнопку, которая позволит вставлять в счёт новые пустые строки.
Я модифицировал шаблон, приведя HTML-код пустой строки к следующему виду:
```
| | $ | | $0.00 |
```
Разработка проекта на jQuery
----------------------------
Для начала посмотрим на то, как решить нашу задачу с использованием jQuery.
```
$('table').on('mouseup keyup', 'input[type=number]', calculateTotals);
```
Мы подключаем прослушиватель событий к таблице. Этот прослушиватель вызовет функцию `calculateTotals` при изменении значений, соответствующих стоимости единицы товара или его количеству:
```
function calculateTotals() {
const subtotals = $('.item').map((idx, val) => calculateSubtotal(val)).get();
const total = subtotals.reduce((a, v) => a + Number(v), 0);
$('.total td:eq(1)').text(formatAsCurrency(total));
}
```
Функция берёт строки таблицы и проходится по ним, передавая каждую из строк функции `calculateSubtotal` и суммируя результаты. Результат вычислений попадает в константу `total`. В итоге общая сумма по документу подставляется в соответствующее поле счёта.
```
function calculateSubtotal(row) {
const $row = $(row);
const inputs = $row.find('input');
const subtotal = inputs[1].value * inputs[2].value;
$row.find('td:last').text(formatAsCurrency(subtotal));
return subtotal;
}
```
В этом коде мы берём ссылки на все поля , присутствующие в строке, затем умножаем значения, хранящиеся во втором и третьем полях для получения значения `subtotal`. Потом это значение вставляется в последнюю ячейку строки. Мы форматируем это значение с помощью функции `formatAsCurrency`. Вот её код:
```
function formatAsCurrency(amount) {
return `$${Number(amount).toFixed(2)}`;
}
```
Кроме того, у нас имеется небольшая вспомогательная функция, которую мы используем для того, чтобы обеспечить одинаковый внешний вид полей с суммами по товарам и по документу в целом. А именно, нам надо, чтобы перед числами, находящимися в этих полях, стоял знак $, и чтобы они представляли собой десятичные числа с двумя знаками после запятой.
```
$('.btn-add-row').on('click', () => {
const $lastRow = $('.item:last');
const $newRow = $lastRow.clone();
$newRow.find('input').val('');
$newRow.find('td:last').text('$0.00');
$newRow.insertAfter($lastRow);
$newRow.find('input:first').focus();
});
```
И, наконец, у нас имеется обработчик события нажатия на кнопку `Add row`, которая служит для добавления в документ новой строки. Здесь мы берём последнюю строку в таблице, содержащую данные о товаре, и делаем её копию. При этом в поля этой новой строки мы вставляем стандартные данные. Кроме того, мы можем тут позаботиться об удобстве работы пользователя и установить фокус на первое поле новой строки, что позволит пользователю, сразу же после добавления новой строки, приступить к вводу данных в её первое поле.
[Вот](https://codepen.io/SitePoint/pen/YaBwJQ) рабочий пример счёта, интерактивные возможности которого реализованы средствами jQuery.
Недостатки решения, основанного на jQuery
-----------------------------------------
Зададимся вопросом о том, каковы недостатки вышеописанного подхода, или, скорее, вопросом о том, как улучшить наш проект.
Возможно, вы слышали о новых библиотеках, вроде Vue и React, о которых говорят, что они позволяют работать в декларативном, а не в императивном стиле. Если посмотреть на вышеприведённый jQuery-код, ясно, что он, в основном, читается как набор инструкций, описывающих манипуляции с DOM. Цель каждого раздела этого кода, то есть, ответ на вопрос о том, что он делает, часто довольно сложно выяснить, глядя на то, как он это делает. Конечно, можно сделать намерения используемых фрагментов кода яснее, разбив его на функции с вдумчиво подобранными именами. Однако если оставить этот код на какое-то время, а потом опять к нему вернуться, окажется, что для того, чтобы его понять, всё равно придётся приложить некоторые усилия.
Ещё одна проблема подобного кода заключается в том, что состояние приложения хранится в DOM. Информация о товарах, которые хочет заказать пользователь, существует лишь как часть HTML-разметки в пользовательском интерфейсе. Если всё, что нам надо — это выводить данные в одном месте, то эта проблема не кажется такой уж серьёзной. Однако, как только появляется необходимость выводить эти данные в нескольких местах приложения, перед нами возникает задача синхронизации данных. Не имея, как в нашем случае, единого источника достоверных данных, очень сложно поддерживать их в актуальном состоянии во всём приложении.
Хотя при использовании jQuery ничто не мешает нам хранить состояние приложения за пределами DOM и избежать вышеописанной проблемы, библиотеки, такие как Vue, предоставляют возможности, которые способствуют созданию приложений, обладающих хорошей архитектурой. Эти библиотеки помогают программисту писать более чистый и лучше структурированный код.
Перевод проекта на Vue
----------------------
Теперь поговорим о том, как воссоздать тот же функционал на Vue. Для того чтобы воспользоваться возможностями Vue, достаточно просто подключить эту библиотеку к обычной веб-странице, так же, как это делается в случае с jQuery. То есть, нет необходимости пользоваться системой для упаковки модулей или транспилятором, не нужно разбивать приложение на компоненты и раскладывать их код по .vue-файлам.
Начнём перевод проекта на Vue с замены содержимого тега `</code>:<br/>
<br/>
<pre><code><script src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js">`
На следующем шаге надо создать новый экземпляр Vue:
```
const app = new Vue({
el: 'table'
});
```
Единственным параметром, который надо передать конструктору нового экземпляра Vue, является `el`. Это — селектор (такой же, какими пользуются и в jQuery), который идентифицирует ту часть документа, которой мы хотим управлять с помощью Vue.
Vue можно поручить задачи разного масштаба — от управления целой страницей (в случае, например, с одностраничным приложением), до небольшого фрагмента, заключённого в тег . В нашем примере Vue будет отвечать за работу с HTML-таблицей.
Данные
------
Добавим в экземпляр Vue условные данные для трёх строк документа:
```
const app = new Vue({
el: 'table',
data: {
items: [
{ description: 'Website design', quantity: 1, price: 300 },
{ description: 'Hosting (3 months)', quantity: 1, price: 75 },
{ description: 'Domain name (1 year)', quantity: 1, price: 10 },
]
}
});
```
Свойство `data` — это то место, где мы храним состояние приложения. Состояние включает не только данные, с которыми должно работать наше приложение, но и информацию о состоянии пользовательского интерфейса (например — о том, какой из разделов приложения, состоящего из нескольких вкладок, активен в настоящий момент, или о том, свёрнут ли некий виджет, вроде «аккордеона», или развёрнут).
Vue способствует тому, чтобы состояние приложения было бы отделено от его представления (то есть, от DOM), и помогает централизованно хранить состояние в одном месте, которое является единым источником достоверных данных.
Модификация шаблона
-------------------
Теперь настроим шаблон таким образом, чтобы он выводил данные, хранящиеся в объекте `data`. Так как мы сообщили фреймворку о том, что хотим, с помощью экземпляра Vue, работать с таблицей, мы можем использовать синтаксис шаблонов Vue в HTML-коде, описывающем эту таблицу для того, чтобы сообщить Vue о том, как визуализировать таблицу и как с ней работать.
Используя атрибут `v-for`, мы можем вывести блок HTML-кода для каждого элемента из массива `items`:
```
|
| |
```
Vue повторит эту разметку для каждого элемента массива (или объекта), который передаётся `v-for`. Это позволяет нам обратиться к каждому элементу в цикле. В данном случае этот элемент представлен переменной `item`. Так как Vue наблюдает за свойствами объекта `data`, фреймворк будет динамически обновлять разметку при изменении содержимого массива `items`. Всё, что нам надо сделать — это модифицировать состояние, добавив или удалив элементы, а Vue будет автоматически обновлять пользовательский интерфейс.
Нам, кроме того, надо добавить поля ввода, которые мог бы заполнять пользователь, вводя описание товара, цену за единицу, количество:
```
|
$ |
|
${{ item.price \* item.quantity }} |
```
Здесь мы используем атрибут `v-model` для того, чтобы настроить двустороннюю привязку данных между полями ввода и свойствами в модели данных. Это означает, что изменение данных в полях ввода приведёт к их изменению в модели, и наоборот.
В последней ячейке мы используем фигурные скобки `{{}}`, их мы применяем для вывода текста. В скобках можно использовать любое рабочее JavaScript-выражение. В данном случае мы умножаем два свойства элемента и выводим то, что получилось. Опять же, Vue наблюдает за моделью данных, изменение любого свойства приведёт к автоматическому пересчёту выражения.
События и методы
----------------
Теперь у нас имеется шаблон, готовый к выводу коллекции `items` и перед нами возникает вопрос о том, как добавлять в таблицу новые строки. Так как Vue выведет на страницу всё, что имеется в массиве `items`, для того, чтобы вывести на страницу пустую строку, достаточно передать Vue объект с любыми значениями, которые должны присутствовать в массиве `items`.
Для того чтобы создать функцию, к которой можно обращаться из шаблона, нужно передать эту функцию экземпляру Vue как свойство объекта `methods`:
```
const app = new Vue({
// ...
methods: {
myMethod() {}
},
// ...
})
```
Объявим метод `addRow`, который можно будет вызывать для добавления нового элемента в массив `items`:
```
methods: {
addRow() {
this.items.push({ description: '', quantity: 1, price: 0 });
},
},
```
Обратите внимание на то, что любые создаваемые нами методы будут автоматически привязаны к экземпляру Vue, что даст нам возможность обращаться из этих методов к свойствам объекта `data` и к другим методам как к свойствам `this`.
Итак, метод теперь у нас есть. Как его вызывать по нажатию кнопки `Add row`? Для добавления прослушивателей событий к элементам управления в шаблоне в Vue используется синтаксическая конструкция `v-on:event-name`.
```
Add row
```
В Vue, кроме того, предусмотрено сокращение для конструкции `v-on`:, которое выглядит как `@`. Оно использовано в вышеприведённом фрагменте кода. В качестве обработчика события можно использовать любой метод из экземпляра Vue.
Вычисляемые свойства
--------------------
Теперь нам осталось лишь вывести общую сумму по документу в нижней части счёта. Это вполне можно сделать в самом шаблоне. Как уже было сказано, Vue позволяет размещать в конструкциях из фигурных скобок любые рабочие JS-выражения. Однако гораздо лучше придерживаться подхода, при котором в шаблоне хранят только очень простую логику и ничего больше. Если логика будет отделена от шаблона, код окажется чище, его будет легче тестировать.
Для этой цели мы можем использовать обычный метод, но я полагаю, что в данном случае нам лучше всего подойдёт так называемое [вычисляемое свойство](https://vuejs.org/v2/guide/computed.html#Computed-Properties). Работа с такими свойствами напоминает вышеописанную работу с методами. А именно, для создания таких свойств экземпляру Vue передают объект `computed`, содержащий функции, результаты выполнения которых мы хотим использовать в шаблоне:
```
const app = new Vue({
// ...
computed: {
total() {
return this.items.reduce((acc, item) => acc + (item.price * item.quantity), 0);
}
}
});
```
Теперь на вычисляемое свойство можно сослаться из шаблона:
```
| | Total: ${{ total }} |
```
Как вы уже могли заметить, с вычисляемыми свойствами в шаблоне работают так, как будто они являются данными. «Вызывать» что либо в шаблоне при этом не нужно. У использования вычисляемых свойств есть и другое преимущество. Vue — система достаточно интеллектуальная, она кэширует возвращённые значения и пересчитывает их только в том случае, если меняются свойства, от которых зависят значения вычисляемых свойств.
Если бы мы использовали метод для подсчёта общей суммы по документу, вычисления выполнялись бы каждый раз при выводе шаблона. Но, так как мы используем вычисляемое свойство, общая сумма пересчитывается только при изменении значений `quantity` или `price` в строках таблицы.
Фильтры
-------
Возможно вы заметили, что в реализации нашего проекта, созданной с использованием Vue, есть одна небольшая ошибка. Она заключается в том, что когда цены отдельных товаров выражены целыми числами, вычисленные значения итоговых сумм по строкам и общей суммы по документу выводятся в виде целых долларовых значений, без центов. Нам хотелось бы, чтобы, как и в примере, сделанном на jQuery, в этих числах всегда присутствовали два числа после запятой.
Вместо того, чтобы модифицировать код, ответственный за вычисление итогового значения по строке, и код, вычисляющий общую сумму по документу, мы можем воспользоваться удобными возможностями Vue по форматированию данных. Речь идёт о фильтрах.
Как вы уже, наверное, поняли, для того, чтобы создать фильтр, достаточно передать экземпляру Vue объект (`filters` в данном случае) с соответствующим ключом:
```
const app = new Vue({
// ...
filters: {
currency(value) {
return value.toFixed(2);
}
}
});
```
Здесь мы создали очень простой фильтр, который называется `currency`. Он вызывает функцию `toFixed(2)` для переданного ему числового значения и возвращает полученный результат. Использовать этот фильтр в шаблоне можно так:
```
Total: ${{ total | currency }} |
```
[Вот](https://codepen.io/SitePoint/pen/MVLVmv) готовая реализация нашего проекта на Vue.
Итоги
-----
Если сравнить две версии проекта, одну — созданную с использованием jQuery, вторую — написанную на Vue, можно заметить следующие сильные стороны приложения, основанного на Vue:
* Чёткое разделение между пользовательским интерфейсом, логикой и данными, управляющими интерфейсом. Код получился более понятным, его будет легче тестировать.
* Декларативное описание интерфейса. Программисту надо позаботиться лишь о том, как описать то что ему хочется видеть на экране, а не о том, как обратиться к DOM для того, чтобы придать странице приложения нужный внешний вид.
Библиотеки Vue и jQuery имеют почти одинаковый размер (в килобайтах). Конечно, размер jQuery можно уменьшить, благодаря использованию собственной сборки библиотеки, но, даже в сравнительно простых проектах, таких, как наш пример электронного счёта, полагаю, простота разработки и читабельность кода оправдывают некоторое увеличение размера приложения.
Кроме того, возможности Vue гораздо шире тех, что мы здесь описали. Сила этого фреймворка заключается в том, что он позволяет создавать модульные, подходящие для повторного использования компоненты пользовательского интерфейса, из которых можно строить сложные клиентские приложения.
Если тема разработки веб-приложений на Vue вам интересна — взгляните на [этот материал](https://www.sitepoint.com/up-and-running-vue-js-2-0/). Кроме того, если вы подумываете о переводе проектов с чистого JS на Vue — вот наша недавняя [публикация](https://habr.com/company/ruvds/blog/413311/) на эту тему.
**Уважаемые читатели!** Пользуетесь ли вы jQuery? И, если пользуетесь, планируете ли менять эту библиотеку на что-то другое, например — на Vue?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/414073/ | null | ru | null |
# STM32, C++ и FreeRTOS. Разработка с нуля. Часть 4 (Прерывания, UART и недоHART)
#### Ведение
Попав в отпуске в город на Неве и посетив множество красивых мест, я все таки, вечерами за чашкой пива, разбирался с UARTом. Тем более, что я купил неплохие наушники Fisher FA011, к которым пришлось прикупить USB SOUND BLASTER X-FI HD и хотел послушать музыку.
Предыдущие статьи вначале переехали на Geektime потом я обратно их перегнал, даже и не знаю, куда теперь их деть :)
Но так на всякий случай они тут:
[STM32, C++ и FreeRTOS. Разработка с нуля. Часть 1](http://habrahabr.ru/post/261807//)
[STM32, C++ и FreeRTOS. Разработка с нуля. Часть 2](http://habrahabr.ru/post/261823/) и
[STM32, C++ и FreeRTOS. Разработка с нуля. Часть 3 (LCD и Экраны)](http://habrahabr.ru/post/261837/)
#### UART
После детального изучения микроконтроллера, мне казалось, что все просто. Настройка и тестовая посылка байта в порт прошла без задоринки, все работало как часы, и тут я решил использовать прерывания. Нужно было сделать так, чтобы обработчик прерывания был статическим методом класса. И IAR в руководстве на компилятор, так и писал:
> Special function types can be used for static member functions. For example, in the
>
> following example, the function handler is declared as an interrupt function:
>
>
> ```
> class Device
> {
> static __irq void handler();
> };
>
> ```
>
Но вот незадача, для Cortex M такой способ не подходит и
> On ARM Cortex-M, an interrupt service routine enters and returns in the same way as a
>
> normal function, which means no special keywords are required. **Thus, the keywords
>
> \_\_irq, \_\_fiq, and \_\_nested are not available when you compile for ARM Cortex-M.**
>
> These exception function names are defined in cstartup\_M.c and cstartup\_M.s.
>
> They are referred to by the library exception vector code:
>
> NMI\_Handler
>
> HardFault\_Handler
>
> MemManage\_Handler
>
> BusFault\_Handler
>
> …
>
> The vector table is implemented as an array. It should always have the name
>
> \_\_vector\_table,
>
>
Или по простому, ваш обработчик прерывания должен иметь такое же имя, какое он имеет в таблице векторов определенной в startup файле. Это делается с помощью специального ключевого слова — слабой ссылки \_\_weak (в ассемблере PUBWEAK), которая означает, что данное определение будет использоваться до тех пора, пока не найдется хотя бы одно совпадающее по написанию без ключевого слова \_\_week. Ну т.е., если вы определите функцию с точно таким же именем без этой директивы, то компилятро будет использовать это определение, а если не определите, то которое помечено \_\_weak.
Понятное дело, что я не могу в файл **startup\_stm32l1xx\_md.s** или **startup\_stm32l1xx\_md.с** вставить С++ имя статического метода типа *cUart::USART2\_IRQHandler()*, ассемблер его просто не поймет.
А просто *«USART2\_IRQHandler»* не совпадает с определением *«cUart::USART2\_IRQHandler()»*.
Можно использовать *extern «C» { void USART2\_IRQHandler(void) {...}}*, но это означает, что я тут буду делать вставки из Си, что мне совсем не надо, и вообще доступа из такой функции к атрибутам моего класса, например буферу — не будет, и надо будет городить кучу некрасивого кода :).
Поэтому, я решил пойти другим путем и создать файл **startup\_stm32l1xx\_md.cpp**. Поиск в интернете обнаружил, что точно такая же проблема была у некоторых людей [Вот например](http://community.arm.com/message/6214)
В общем идея заключается в следующем: Объявляем в **startup\_stm32l1xx\_md.cpp** классы со статическими методами (которые и будут являться обработчиками прерываний), создаем таблицу \_\_vector\_table, где на каждом из векторов прерываний стоит указатель на эти статические методы. Дальше делаем \_\_weak определение каждого метода
И теперь когда в коде компилятор видет реализацию *void cUart1::handler()*, он не задумываясь берет её. Конечно же при этом ваши классы и методы должны называться точь в точь так, как они определены в **startup\_stm32l1xx\_md.cpp**.
Нужно еще не забыть про функции FreeRtos: *vPortSVCHandler*, *xPortPendSVHandler*, *xPortSysTickHandler* и поставить их на нужное прерывание и вуаля — все работает:
**startup\_stm32l1xx\_md.cpp**
```
#pragma language = extended
#pragma segment = "CSTACK"
extern "C" void __iar_program_start( void );
extern "C" void vPortSVCHandler(void);
extern "C" void xPortPendSVHandler(void);
extern "C" void xPortSysTickHandler(void);
class cNMI
{
public:
static void handler(void);
};
class cHardFault
{
public:
static void handler(void);
};
class cMemManage
{
public:
static void handler(void);
};
class cBusFault
{
public:
static void handler(void);
};
class cUsageFault
{
public:
static void handler(void);
};
class cDebugMon
{
public:
static void handler(void);
};
class cWindowWatchdog
{
public:
static void handler(void);
};
class cPvd
{
public:
static void handler(void);
};
class cTamperTimeStamp
{
public:
static void handler(void);
};
class cRtcWakeup
{
public:
static void handler(void);
};
class cFlash
{
public:
static void handler(void);
};
class cRcc
{
public:
static void handler(void);
};
class cExti
{
public:
static void line0Handler(void);
static void line1Handler(void);
static void line2Handler(void);
static void line3Handler(void);
static void line4Handler(void);
static void line9Handler(void);
static void line15_10Handler(void);
};
class cDma
{
public:
static void channellHandler(void);
static void channel2Handler(void);
static void channel3Handler(void);
static void channel4Handler(void);
static void channel5Handler(void);
static void channel6Handler(void);
static void channel7Handler(void);
};
class cAdc
{
public:
static void handler(void);
};
class cDac
{
public:
static void handler(void);
};
class cUsb
{
public:
static void highPriorityHandler(void);
static void lowPriorityHandler(void);
static void fsWakeupHandler(void);
};
class cComp
{
public:
static void handler(void);
};
class cLcdDriver
{
public:
static void handler(void);
};
class cTim9
{
public:
static void handler(void);
};
class cTim2
{
public:
static void handler(void);
};
class cTim3
{
public:
static void handler(void);
};
class cTim4
{
public:
static void handler(void);
};
class cTim10
{
public:
static void handler(void);
};
class cTim6
{
public:
static void handler(void);
};
class cTim7
{
public:
static void handler(void);
};
class cTim11
{
public:
static void handler(void);
};
class cI2C1
{
public:
static void eventHandler(void);
static void errorHandler(void);
};
class cI2C2
{
public:
static void eventHandler(void);
static void errorHandler(void);
};
class cSpi1
{
public:
static void handler(void);
};
class cSpi2
{
public:
static void handler(void);
};
class cUart1
{
public:
static void handler(void);
};
class cUart2
{
public:
static void handler(void);
};
class cUart3
{
public:
static void handler(void);
};
class cRtcAlarm
{
public:
static void handler(void);
};
typedef void( *intfunc )( void );
typedef union { intfunc __fun; void * __ptr; } intvec_elem;
// The vector table is normally located at address 0.
// When debugging in RAM, it can be located in RAM, aligned to at least 2^6.
// If you need to define interrupt service routines,
// make a copy of this file and include it in your project.
// The name "__vector_table" has special meaning for C-SPY:
// it is where the SP start value is found, and the NVIC vector
// table register (VTOR) is initialized to this address if != 0.
#pragma location = ".intvec"
extern "C" const intvec_elem __vector_table[] =
{
{ .__ptr = __sfe( "CSTACK" ) },
__iar_program_start,
cNMI::handler,
cHardFault::handler,
cMemManage::handler,
cBusFault::handler,
cUsageFault::handler,
0,
0,
0,
0,
vPortSVCHandler, //функции freeRTOS не трогать!
cDebugMon::handler,
0,
xPortPendSVHandler, //функции freeRTOS не трогать!
xPortSysTickHandler, //функции freeRTOS не трогать!
//External Interrupts
cWindowWatchdog::handler, //Window Watchdog
cPvd::handler, //PVD through EXTI Line detect
cTamperTimeStamp::handler, //Tamper and Time Stamp
cRtcWakeup::handler, //RTC Wakeup
cFlash::handler, //FLASH
cRcc::handler, //RCC
cExti::line0Handler, //EXTI Line 0
cExti::line1Handler, //EXTI Line 1
cExti::line2Handler, //EXTI Line 2
cExti::line3Handler, //EXTI Line 3
cExti::line4Handler, //EXTI Line 4
cDma::channellHandler, //DMA1 Channel 1
cDma::channel2Handler, //DMA1 Channel 2
cDma::channel3Handler, //DMA1 Channel 3
cDma::channel4Handler, //DMA1 Channel 4
cDma::channel5Handler, //DMA1 Channel 5
cDma::channel6Handler, //DMA1 Channel 6
cDma::channel7Handler, //DMA1 Channel 7
cAdc::handler, //ADC1
cUsb::highPriorityHandler, //USB High Priority
cUsb::lowPriorityHandler, //USB Low Priority
cDac::handler, //DAC
cComp::handler, //COMP through EXTI Line
cExti::line9Handler, //EXTI Line 9..5
cLcdDriver::handler, //LCD
cTim9::handler, //TIM9
cTim10::handler, //TIM10
cTim11::handler, //TIM11
cTim2::handler, //TIM2
cTim3::handler, //TIM3
cTim4::handler, //TIM4
cI2C1::eventHandler, //I2C1 Event
cI2C1::errorHandler, //I2C1 Error
cI2C2::eventHandler, //I2C2 Event
cI2C2::errorHandler, //I2C2 Error
cSpi1::handler, //SPI1
cSpi2::handler, //SPI2
cUart1::handler, //USART1
cUart2::handler, //USART2
cUart3::handler, //USART3
cExti::line15_10Handler, //EXTI Line 15..10
cRtcAlarm::handler, //RTC Alarm through EXTI Line
cUsb::fsWakeupHandler, //USB FS Wakeup from suspend
cTim6::handler, //TIM6
cTim7::handler //TIM7
};
__weak void cNMI::handler() { while (1) {} }
__weak void cHardFault::handler() { while (1) {} }
__weak void cMemManage::handler() { while (1) {} }
__weak void cBusFault::handler() { while (1) {} }
__weak void cUsageFault::handler() { while (1) {} }
__weak void cDebugMon::handler() { while (1) {} }
__weak void cWindowWatchdog::handler() { while (1) {} }
__weak void cPvd::handler() { while (1) {} }
__weak void cTamperTimeStamp::handler() { while (1) {} }
__weak void cRtcWakeup::handler() { while (1) {} }
__weak void cFlash::handler() { while (1) {} }
__weak void cRcc::handler() { while (1) {} }
__weak void cExti::line0Handler() { while (1) {} }
__weak void cExti::line1Handler() { while (1) {} }
__weak void cExti::line2Handler() { while (1) {} }
__weak void cExti::line3Handler() { while (1) {} }
__weak void cExti::line4Handler() { while (1) {} }
__weak void cExti::line9Handler() { while (1) {} }
__weak void cExti::line15_10Handler() { while (1) {} }
__weak void cDma::channellHandler() { while (1) {} }
__weak void cDma::channel2Handler() { while (1) {} }
__weak void cDma::channel3Handler() { while (1) {} }
__weak void cDma::channel4Handler() { while (1) {} }
__weak void cDma::channel5Handler() { while (1) {} }
__weak void cDma::channel6Handler() { while (1) {} }
__weak void cDma::channel7Handler() { while (1) {} }
__weak void cAdc::handler() { while (1) {} }
__weak void cUsb::fsWakeupHandler() { while (1) {} }
__weak void cUsb::highPriorityHandler() { while (1) {} }
__weak void cUsb::lowPriorityHandler() { while (1) {} }
__weak void cDac::handler() { while (1) {} }
__weak void cComp::handler() { while (1) {} }
__weak void cLcdDriver::handler() { while (1) {} }
__weak void cTim2::handler() { while (1) {} }
__weak void cTim3::handler() { while (1) {} }
__weak void cTim4::handler() { while (1) {} }
__weak void cTim6::handler() { while (1) {} }
__weak void cTim7::handler() { while (1) {} }
__weak void cTim9::handler() { while (1) {} }
__weak void cTim10::handler() { while (1) {} }
__weak void cTim11::handler() { while (1) {} }
__weak void cI2C1::errorHandler() { while (1) {} }
__weak void cI2C1::eventHandler() { while (1) {} }
__weak void cI2C2::errorHandler() { while (1) {} }
__weak void cI2C2::eventHandler() { while (1) {} }
__weak void cSpi1::handler() { while (1) {} }
__weak void cSpi2::handler() { while (1) {} }
__weak void cUart1::handler() { while (1) {} }
__weak void cUart2::handler() { while (1) {} }
__weak void cUart3::handler() { while (1) {} }
__weak void cRtcAlarm::handler() { while (1) {} }
extern "C" void __cmain( void );
extern "C" __weak void __iar_init_core( void );
extern "C" __weak void __iar_init_vfp( void );
#pragma required=__vector_table
void __iar_program_start( void )
{
__iar_init_core();
__iar_init_vfp();
__cmain();
}
```
#### DWART. Прием передача сообщений
Итак, с прерываниями разобрались, теперь можно браться за реализацию какого-нить несложного протокола. Modbus отпал сразу — уж очень не сложный :). Поиск популярных протоколов для устройств выдал — HART, промышленный протокол для устройств типа датчиков давления, температуры и расходомеров — отлично подойдет.
И задачей, которую я поставил перед собой, будет связаться по этому протоколу с программой настройки устройств, скажем **Pactware**, или **Элемеровким** [HARTConfig](http://www.elemer.ru/po/hart_config.php), подделавшись, каким-нибудь популярным датчиком, к примеру, датчиком давления — Yokogawa EJA, так чтобы эта программа подвоха не обнаружила. Сразу скажу, что все получилось :)
И даже удалось снять тренд температуры воздуха, измеряющийся внутренним сенсором температуры микроконтроллера:
А вот так вот видит мое устройство Pactware :)
Нормальная документация на HART закрыта. Но удалось найти отрывочные описания, которые вполне сойдут для моего демо-проекта. Вот пример одного из таких ресурсов: [Описание протокола HART](http://hart2dde.narod.ru/hartdesc.html) или вот [Модель OSI HART протокола](http://cyberleninka.ru/article/n/realizatsiya-hart-protokola-na-osnove-modeli-iso-osi)
Вкратце — на линии есть мастер(главное) и слейв(подчиненное) устройства. Главное шлет запросы, подчиненное отвечает на скорости 1200 бит в секунду — все просто.
Может быть и два главных устройства на линии, но я просто буду общаться с ОДНИМ мастером по RS232.
По этой же причине мне не надо особо следить за арбитражем шины и по сложному определять когда токен у меня, а когда нет, и весь арбитраж в моем случае заключается только в том, что — токен находится у меня, после 2 символов тишины на линии. На скорости 1200 бит в секунду это примерно 19 мс. Т.е. если в течении 19 мс, у меня нет прерывания по приему — посылка считается принятой, и токен находится у меня, я могу отвечать и должен начать отвечать в течении примерно 250 мс, иначе токен снова перейдет мастеру.
В общем назвал я этот протокол **Dwart**, симбиоз между Dwarf — карлик, гном и HART.
Для начала нужно выделить сущности, которыми будем оперировать:
* Канальный уровень (**LinkLayer**) — будет отвечать просто за посылку и передачу сообщений, а также за определение конца приема запроса от мастера
* Таймер определения конца передачи (**LinkLayerTimer**) — таймер на 19 мс, по истечении которого будет считаться, что запрос от мастера принят. Таймер должен запускаться после каждого принятого байта.
* Кадр (**Frame**) — отвечает за разбор и формирование кадров HART посылок
* Команды (**Command**) — отвечает за реализацию отдельной команды
* Сам главный класс (**Dwart**) — он всем этим делом будет управлять
Для того чтобы соблюсти принцип слоеного пирога — классы нижнего слоя не будут знать про классы слоя находящегося выше, т.е. Например, Command будет работать только с Frame, а Frame c LinkLayer, при этом LinkLayer ничего не будет знать про Command и Frame, а Frame про Command.
Итак в чем же заключается идея — принимать байты до тех пор пока не сработал таймер тишины, затем оповестить Dwart, который вызовет метод разбора принятого сообщения и в зависимости от запроса, выполнит нужную команду.
В общем в идеале, скажем при запросе команды 1 от мастера, хочется чтобы ответ на неё выглядел как-то так:
```
Command1.Response.PrimaryVariable = 3.54
Command1.Send();
```
Вначале прикинем канальный уровень, на данном рисунке показаны только публичные методы, чтобы не засорять картинку.
Немного поясню картинку, методы обработчика прерываний являются статическими, и чтобы обращаться к методам и полям экземпляра класса в этих статических методах нужно чтобы либо поля и методы тоже были статическими, либо обратиться непосредсвенно к экземпляру класса. Я пошел вторым — правильным путем, обращаюсь к конкретному экземпляру класса, который инициализирую в конструкторе указателем **this**.
LinkLayer будет принимать байты из UART порта и складывать их в буфер приема.
Но поскольку в HART есть сихронизирующие байты 0xFF, называемые преамбулами, и их количество может доходить до 20, (а они нам вообще не нужны, так как не несут в себе никакой инофрмации, и все что нам нужно, это определить начало кадра по последовательности( 0xFF 0xFF <Стартовый байт>)), то будет растратно скидывать 20 преамбул в буфер, поэтому я просто буду следить за ними прямо в прерывании и как только они кончатся, я начну складывать байты в буфер.
После приема каждого байта я буду перезапускать таймер на 19 мс, если он сработает, то посылка считается принятой.
Еще стоит задача оповестить linklayer из класса linklayertimer, как только сработает прерывание от таймера, говорящее о конце приема запроса от мастера. Для этого я воспользовался шаблоном проектирования Наблюдатель, в итоге LinkLayer просто подписывается на события от LinkLayerTimer, Выглядит это так:
**linklayertimer.h**
```
#include "types.h" //lint !e537 Стандартные типы проекта
#include "observable.h" //lint !e537 Для iObservable
class cLinkLayerTimer : public iObservable
{
public:
explicit cLinkLayerTimer(tU16 timeout);
void start(void) const;
private:
static void irqHandler(void);
static cLinkLayerTimer* instance;
};
```
**linklayertimer.cpp**
```
#include "linklayertimer.h" //lint !e537 для описания класса
#include "susuassert.h" //lint !e537 для ASSERT
#include //lint !e537 для NULL
cLinkLayerTimer\* cLinkLayerTimer::instance = NULL;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description: Создаем аппаратный таймер TIM2
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cLinkLayerTimer::cLinkLayerTimer(tU16 timeout)
{
ASSERT(instance != NULL);
this->instance = this;
TIM2->ARR = (uint16\_t)timeout;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: start
\* Description: Стартуем таймер. Вызов будет из прерывания
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayerTimer::start(void) const
{
TIM2->CNT = (uint16\_t)0;
TIM2->CR1 |= TIM\_CR1\_CEN;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: irqHandler
\* Description: Обработчик прерывания по срабатыванию таймеру.
\* Это и есть конец посылки, Оповещаем подписчиков
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayerTimer::irqHandler(void)
{
ASSERT(instance != NULL);
instance->notifyObservers();
TIM2->CR1 &=~ TIM\_CR1\_CEN;
TIM2->SR &= ~TIM\_SR\_UIF;
}
```
**linklayer.h**
```
#include "types.h" //lint !e537 Стандартные типы проекта
#include "linklayertimer.h" //lint !e537 Для cLinkLayerTimer
#include "observer.h" //lint !e537 Для iObserver
#define PREAMBUL_SYMBOL (uint16_t) 0xFF
typedef enum
{
LLS_none = 0,
LLS_write = 1,
LLS_writeComplete = 2,
LLS_readComplete = 3,
LLS_error = 4
} tLinkLayerStatus;
class cLinkLayer : private iObserver, public iObservable
{
public:
explicit cLinkLayer(tU8 *pRxBuf, const tU8 rxBufSize,tU8 *pTxBuf, const tU8 preambulCount);
void writeData(tU8 dataSize);
tLinkLayerStatus getStatus() const { return eStatus; };
virtual void eventHandle(const iObservable* pObservable);
tU8* pTxBuffer;
tU8* pRxBuffer;
private:
static void irqHandler(void);
static cLinkLayer* instance;
void endMessageHandler(void);
void enableReceive(void) const { USART2->CR1 |= USART_CR1_RXNEIE;}; //lint !e639 !e511 Тут все верно
void disableReceive(void){USART2->CR1 &=~ USART_CR1_RXNEIE;};//lint !e639 !e511 Тут все верно
void enableTransmit(void) const { USART2->CR1 |= USART_CR1_TCIE; };//lint !e639 !e511 Тут все верно
void disableTransmit(void) const { USART2->CR1 &=~ USART_CR1_TCIE; };//lint !e639 !e511 Тут все верно
tLinkLayerStatus eStatus;
cLinkLayerTimer* pEndTransmitTimer;
tU8 rxBufferSize;
tU8 rxBufferIndex;
tU8 txBufferIndex;
tU8 txBufferSize;
tU8 preambulsCount;
tU8 preambulIndex;
tBoolean readPreambuls;
};
```
**linllayer.cpp**
```
#include //lint !e537 Регистры STM32
#include "linklayer.h" //lint !e537 для описания класса
#include "susuassert.h" //lint !e537 для ASSERT
#include "bitutil.h" //lint !e537 для макросов работы с битами SETBIT, CLRBIT
#include //lint !e537 для NULL
#define END\_MESSAGE\_TIMEOUT (tU16) 19
#define GOOD\_COUNT\_RX\_PREAMBULS (tU8) 2
cLinkLayer\* cLinkLayer::instance = NULL;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description: Создаем таймер на определение конца посылки
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cLinkLayer::cLinkLayer(tU8 \*pRxBuf, const tU8 rxBufSize,tU8 \*pTxBuf, const tU8 preambulCount)
{
ASSERT (rxBuffer != NULL);
ASSERT (txBuffer != NULL);
//преамбул не должно быть меньше 3
ASSERT(preambulCount > (tU8)2);
this->preambulsCount = preambulCount;
this->preambulIndex = (tU8)0;
this->readPreambuls = TRUE;
this->pRxBuffer = pRxBuf;
this->rxBufferSize = rxBufSize;
this->rxBufferIndex = (tU8)0;
this->pTxBuffer = pTxBuf;
this->txBufferSize = (tU8)0;
this->txBufferIndex = (tU8)0;
this->eStatus = LLS\_none;
this->instance = this;
this->pEndTransmitTimer = new cLinkLayerTimer(END\_MESSAGE\_TIMEOUT);
//подписываемся на срабатывание таймера
this->pEndTransmitTimer->addObserver(this);
this->disableTransmit();
this->enableReceive();
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: writeData
\* Description: Стартует передачу, разрешаем прерывание по передаче
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayer::writeData(tU8 dataSize)
{
//блокировка буфера на время передачи, если буфер еще не передан, не надо его
//менять
if (this->eStatus != LLS\_write)
{
this->disableReceive();
this->txBufferSize = dataSize;
this->eStatus = LLS\_write;
USART2->DR = PREAMBUL\_SYMBOL;
this->preambulIndex ++;
this->enableTransmit();
}
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: handler
\* Description: Обработчик прерывания
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayer::irqHandler(void)
{
ASSERT(instance != NULL);
//Передача
if (USART2->SR & USART\_SR\_TC)
{
// Вначале надо передать преамбулы, не менее 3 должно быть
if (instance->preambulIndex != instance->preambulsCount)
{
USART2->DR = PREAMBUL\_SYMBOL;
instance->preambulIndex ++;
}
else
{
//преамбулы передена - передаем буффер передачи
if(instance->txBufferIndex < instance->txBufferSize)
{
USART2->DR = (uint16\_t)instance->pTxBuffer[instance->txBufferIndex++];
}
else
{
instance->txBufferIndex = (tU8)0;
instance->txBufferSize = (tU8)0;
instance->disableTransmit();
instance->eStatus = LLS\_writeComplete;
instance->preambulIndex = (tU8)0;
instance->readPreambuls = TRUE;
instance->enableReceive();
}
}
USART2->SR &=~ USART\_SR\_TC;
};
//Прием
if (USART2->SR & USART\_SR\_RXNE)
{
instance->pRxBuffer[instance->rxBufferIndex] = (tU8)USART2->DR;
instance->pEndTransmitTimer->start();
//Вначале надо принять преамбулы
if (instance->readPreambuls)
{
if (instance->pRxBuffer[instance->rxBufferIndex] == (tU8)PREAMBUL\_SYMBOL)
{
instance->preambulIndex++;
}
else
{
instance->readPreambuls = FALSE;
instance->rxBufferIndex++;
}
}
else
{
//Принятых преамбу должно быть не менее 2
if ((instance->rxBufferIndex <= instance->rxBufferSize) &&
(instance->preambulIndex >= GOOD\_COUNT\_RX\_PREAMBULS))
{
instance->rxBufferIndex++;
}
else
{
instance->eStatus = LLS\_error;
instance->preambulIndex = (tU8)0;
}
}
}
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: endMessageHandler
\* Description: Обработчик конца передачи
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayer::endMessageHandler(void)
{
this->eStatus = LLS\_readComplete;
this->rxBufferIndex = (tU8) 0;
this->readPreambuls = TRUE;
instance->preambulIndex = (tU8)0;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: eventHandle
\* Description: Релизация метода интерфейса наблюдатель
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLinkLayer::eventHandle(const iObservable\* pObservable)
{
this->endMessageHandler();
this->notifyObservers();
} //lint !e715 не нужно использовать pObservable
```
Сам LinkLayer также оповещает о конце приемке запроса от мастера своих подписчиков — это нам понадобиться позже
#### DWART. Разбор и формирование HART кадра
Далее разберемся с классом cFrame, он будет декодировать запросы от мастера, а также формировать кадры ответов и используя LinkLayer отсылать их:
Реализация:
**frame.h**
```
#include "types.h" //lint !e537 Типы проекта для tBoolean
#include "linklayer.h" //lint !e537 Для cLinkLayer
#define LONG_ADDRESS_LENGTH (tU8)5
#define DATA_LENGTH (tU8)255
typedef enum
{
FE_good = 0,
FE_addrError = 1,
FE_comError = 2,
FE_dataCountError = 3,
FE_checkSummError = 4,
FE_preambulsError = 5,
FE_genericError = 6
} tFrameError;
typedef struct
{
// Количество преамбул
tU8 preambulsCount;
// Стартовый байт
tU8 startByte;
// Адресс короткий
tU8 shortAddr;
// Адресс длинный
tU8 longAddr[LONG_ADDRESS_LENGTH];
// Команда
tU8 command;
// Количество данных
tU8 dataCount;
//данные
tU8 *pData;
// Контрольная сумма
tU8 checkSumm;
} tMasterFrame;
class cFrame
{
public:
cFrame(tU8* pLongAddress, const tU8 shortAddress, cLinkLayer *pLnkLayer);
tU8* buildFrameBeforeData (const tU8 commandNumber, const tU8 dataLength);
tU8 getCurrentCommand(void) const { return this->masterFrame.command; }
tFrameError decode(void);
void setCheckSumm(void);
void send(void);
private:
tU8 getCheckSumm(const tU8 *pData, const tU8 dataLength) const;
cLinkLayer *pLinkLayer;
tU8 deviceShortAddress;
tU8 *pDeviceId;
tU8 bufferSize;
tMasterFrame masterFrame;
};
```
**frame.cpp**
```
#include "susuassert.h" //lint !e537 для ASSERT
#include "frame.h" //lint !e537 для описание этого класса
#include //lint !e537 для NULL
#define LONG\_ADDRESS\_MASK (tU8)0x80
#define SLAVE\_MASK (tU8)0x7F
#define START\_BYTE\_SLAVE\_SHORT\_FRAME (tU8) 6
#define START\_BYTE\_SLAVE\_LONG\_FRAME (tU8) 0x86
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cFrame::cFrame(tU8\* pLongAddress, const tU8 shortAddress, cLinkLayer \*pLnkLayer)
{
ASSERT(pLnkLayer != NULL);
ASSERT(pLongAddress != NULL);
//Короткий адрес не должен быть больше 64
ASSERT(shortAddress <= (tU8)64);
this->pLinkLayer = pLnkLayer;
this->pDeviceId = pLongAddress;
this->deviceShortAddress = shortAddress;
this->bufferSize = (tU8)0;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: decode
\* Description: Декодируем посылку, устанавливаем статус
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
tFrameError cFrame::decode(void)
{
tU8 index = (tU8)0;
tU8 cnt = (tU8)0;
tFrameError eResult = FE\_good;
this->masterFrame.startByte = this->pLinkLayer->pRxBuffer[index];
index ++;
// Извлекаем длинный адрес или кортоткий и формируем адресс
if (this->masterFrame.startByte & LONG\_ADDRESS\_MASK)
{
for (tU8 i = (tU8)0; i < LONG\_ADDRESS\_LENGTH; i ++)
{
this->masterFrame.longAddr[i] = this->pLinkLayer->pRxBuffer[index];
index ++;
}
}
else
{
this->masterFrame.shortAddr = this->pLinkLayer->pRxBuffer[index];
index ++;
}
// Извлекаем команду
this->masterFrame.command = this->pLinkLayer->pRxBuffer[index];
index ++;
// Извлекаем количество байт данных
this->masterFrame.dataCount = this->pLinkLayer->pRxBuffer[index];
index ++;
// Извлекаем данные и копируем в массив данных
if (this->masterFrame.dataCount != (tU8)0)
{
this->masterFrame.pData = (tU8\*)&this->pLinkLayer->pRxBuffer[index];
}
index = index + this->masterFrame.dataCount;
//Проверка, что количество байт данных меньше DATA\_LENGTH
if(masterFrame.dataCount < DATA\_LENGTH )
{
// Подсчитываем контрольную сумму
this->masterFrame.checkSumm =
this->getCheckSumm((tU8\*)&this->pLinkLayer->pRxBuffer[cnt], index - cnt);
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Обработка ощибок \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// Неверная контрольная сумма
if(this->pLinkLayer->pRxBuffer[index] != this->masterFrame.checkSumm)
{
eResult = FE\_checkSummError;
}
// Неверный адрес ответ
if (this->masterFrame.startByte & LONG\_ADDRESS\_MASK)
{
if ((this->masterFrame.longAddr[0] & SLAVE\_MASK) != (this->pDeviceId[0] & SLAVE\_MASK))
{
eResult = FE\_addrError;
}
else
{
for (tU8 i = (tU8)1; i < LONG\_ADDRESS\_LENGTH; i ++)
{
if (this->masterFrame.longAddr[i] != this->pDeviceId[i])
{
eResult = FE\_addrError;
break;
}
this->pDeviceId[0] = this->masterFrame.longAddr[0];
}
}
}
else
{
if((this->masterFrame.shortAddr & SLAVE\_MASK) != (this->deviceShortAddress & SLAVE\_MASK))
{
eResult = FE\_addrError;
}
else
{
this->deviceShortAddress = this->masterFrame.shortAddr;
}
}
}
else
{
eResult = FE\_dataCountError;
}
return eResult;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: buildFrameBeforeData
\* Description: Строит буфер до данных, возвращает указаетль не нулевой байт
\* данных буфере. Данные будут заполнятся конктретной командой
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
tU8\* cFrame::buildFrameBeforeData(const tU8 commandNumber, const tU8 dataLength)
{
tU8 index = (tU8)0;
//Заполняем адрес, короткий или длинный в зависимости от запроса мастера
if (!(this->masterFrame.startByte & LONG\_ADDRESS\_MASK))
{
this->pLinkLayer->pTxBuffer[index] = START\_BYTE\_SLAVE\_SHORT\_FRAME;
index ++;
this->pLinkLayer->pTxBuffer[index] = this->deviceShortAddress;
index ++;
}
else
{
this->pLinkLayer->pTxBuffer[index] = START\_BYTE\_SLAVE\_LONG\_FRAME;
index ++;
for (tU8 i = (tU8)0; i < LONG\_ADDRESS\_LENGTH; i ++)
{
this->pLinkLayer->pTxBuffer[index] = this->pDeviceId[i];
index ++;
}
}
//заполняем номер команды и байт длины данных
this->pLinkLayer->pTxBuffer[index] = commandNumber;
index ++;
this->pLinkLayer->pTxBuffer[index] = dataLength;
index ++;
this->bufferSize = index + dataLength;
return (tU8\*)&this->pLinkLayer->pTxBuffer[index];
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: setCheckSumm
\* Description: Расчитывает и устанавливает контрольную сумму отправляемого кадра
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cFrame::setCheckSumm(void)
{
this->pLinkLayer->pTxBuffer[this->bufferSize] =
this->getCheckSumm(this->pLinkLayer->pTxBuffer, this->bufferSize);
this->bufferSize++;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: getCheckSumm
\* Description: Подсчитывем контрольную сумму
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
tU8 cFrame::getCheckSumm(const tU8 \*pData, const tU8 dataLength) const
{
tU8 index = (tU8) 0;
tU8 checkSumm = (tU8)0;
for (index = (tU8)0; index < dataLength; index ++)
{
if(pData != NULL)
{
checkSumm = checkSumm ^ pData[index];
}
else
{
checkSumm = (tU8) 0;
}
}
return checkSumm;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: send
\* Description: посылает кадр
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cFrame::send(void)
{
this->pLinkLayer->writeData(this->bufferSize);
}
```
#### DWART. Формирование команд
Теперь самое интересное — команды, как я уже говорил, хотелось бы чтобы все выглядело красиво, и можно было удобно обращаться к командам — вот так
```
Command0.Response.PrimaryVariable = 3.54
```
Понятно, что если для каждой команды я буду хранить всю структуру ответа Response, а команд может быть 254, то у меня никакой памяти не хватит, поэтому я буду хранить только указатель на структуру ответа Response, и каждый раз присваивать этому указателю, указатель на данные в буфере передачи, который получу с помощью метода buildFrameBeforeData класса сFrame.
Для всех команд сделаю базовый интерфейс iBaseDwartCommand с общими методами, а поскольку у меня запросы и ответы у каждой команды разной длины, и разных типов, то я создам шаблонный класс наследник iDwartCommand. Примерно это выглядит вот так:
Команда 0 — возвращает просто информацию об устройстве.
Команд 1 — возвращает значение первичной переменной, в моем случае это сTrimmer, доступ к которому дает класс cVariablesDirector, поэтому я должен его передать в конструкторе.
В итоге, заполнение данных команды 1 выглядит вот так:
```
void cCommand1::setNewData(void)
{
//Заполнить начало кадра и получить указатель на буффер для данных
this->pResponse = (tCommand1Response*) this->pFrame->buildFrameBeforeData(COMMAND1,
(tU8)sizeof(tCommand1Response)); //lint !e826 такая задумка
this->pResponse->status1 = (tU8)0;
this->pResponse->status2 = (tU8)0;
this->pResponse->PrimaryVariableUnits = (tU8) pVariablesDirector->pTrimmer->getUnits();
this->pResponse->PrimaryVariableValue = cConversion::swap(pVariablesDirector->pTrimmer->getValue());
this->pFrame->setCheckSumm();
}
```
Здесь метод swap класса cConversion используется для перестановки байтов местами, так как HART использует Big Endian представление, а мой микроконтроллер Little Endian. Ну почти получилось, что я хотел :)
Полностью вся реализация выглядит так:
**basedwartcommand.h**
```
class iBaseDwartCommand
{
public:
virtual void send(void) = 0;
virtual void setNewData(void) = 0;
};
```
**dwartcommand.h**
```
#include "frame.h" //lint !e537 для cFrame
#include "basecommand.h" //lint !e537 для iBaseDwartCommand
#include "susuassert.h" //lint !e537 для ASSERT
template
class iDwartCommand : public iBaseDwartCommand
{
public:
explicit iDwartCommand(cFrame \*pDwratFrame);
req \*pRequest;
resp \*pResponse;
void send(void);
protected:
cFrame \*pFrame;
};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
template
iDwartCommand::iDwartCommand(cFrame \*pDwartFrame)
{
ASSERT (pFrame != NULL);
this->pFrame = pDwartFrame;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: send
\* Description: посылка команды
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
template
void iDwartCommand::send(void)
{
this->pFrame->send();
}
```
**command0.h**
```
#include "command.h" //lint !e537 для iDwartCommand
#define COMMAND0 (tU8)0
#pragma pack(push, 1)
typedef struct
{
tU8 status1;
tU8 status2;
tU8 expansion;
tU8 manufacturer;
tU8 deviceType;
tU8 numberOfpreambuls;
tU8 universalCommandRevision;
tU8 deviceSpecificCommandRevision;
tU8 softwareRevision;
tU8 hardwareRevision;
tU8 deviceFlags;
tU8 deviceID[3];
} tCommand0Response;
typedef struct
{
} tCommand0Request;
#pragma pack(pop)
class cCommand0: public iDwartCommand
{
public:
explicit cCommand0(cFrame \*pDwartFrame);
virtual void setNewData(void);
};
```
**command0.cpp**
```
include "susuassert.h" //lint !e537 для ASSERT
#include "command0.h" //lint !e537 описание класса
#include "frame.h" //lint !e537 для сFrame
#include "conversion.h" //lint !e537 для cConversion
/*******************************************************************************
* Function: constructor
* Description:
******************************************************************************/
cCommand0::cCommand0(cFrame *pDwartFrame): iDwartCommand(pDwartFrame)
{
}
/*******************************************************************************
* Function: setNewData
* Description: Заполнение поля данных команды
******************************************************************************/
void cCommand0::setNewData(void)
{
//Заполнить начало кадра и получить указатель на буффер для данных
this->pResponse = (tCommand0Response*) this->pFrame->buildFrameBeforeData(COMMAND0,
(tU8)sizeof(tCommand0Response)); //lint !e826 такая задумка
this->pResponse->status1 = (tU8)0;
this->pResponse->status2 = (tU8)0;
this->pResponse->manufacturer = (tU8)0x37;
this->pResponse->deviceType = (tU8)0x04;
this->pResponse->expansion = (tU8)0;
this->pResponse->deviceSpecificCommandRevision = (tU8)5;
this->pResponse->universalCommandRevision = (tU8)5;
this->pResponse->hardwareRevision = (tU8)1;
this->pResponse->softwareRevision = (tU8)201;
this->pResponse->numberOfpreambuls = (tU8)5;
this->pResponse->deviceID[0] = (tU8)0;
this->pResponse->deviceID[1] = (tU8)0;
this->pResponse->deviceID[2] = (tU8)1;
this->pResponse->deviceFlags = (tU8)0;
this->pFrame->setCheckSumm();
}
```
**command1.h**
```
#include "command.h" //lint !e537 для iDwartCommand
#include "variablesdirector.h" //lint !e537 для cVariablesDirector
#define COMMAND1 (tU8)1
#pragma pack(push, 1)
typedef struct
{
tU8 status1;
tU8 status2;
tU8 PrimaryVariableUnits;
tF32 PrimaryVariableValue;
} tCommand1Response;
typedef struct
{
} tCommand1Request;
#pragma pack(pop)
class cCommand1: public iDwartCommand
{
public:
explicit cCommand1(cFrame \*pDwartFrame,cVariablesDirector \*pVarsDirector);
virtual void setNewData(void);
private:
cVariablesDirector \*pVariablesDirector;
};
```
**command1.cpp**
```
#include "susuassert.h" //lint !e537 для ASSERT
#include "command1.h" //lint !e537 описание класса
#include "frame.h" //lint !e537 для сFrame
#include "conversion.h" //lint !e537 для cConversion
/*******************************************************************************
* Function: constructor
* Description:
******************************************************************************/
cCommand1::cCommand1(cFrame *pDwartFrame, cVariablesDirector *pVarsDirector):
iDwartCommand(pDwartFrame)
{
ASSERT(pVarsDirector != NULL);
this->pVariablesDirector = pVarsDirector;
}
/*******************************************************************************
* Function: setNewData
* Description: Заполнение поля данных команды
******************************************************************************/
void cCommand1::setNewData(void)
{
//Заполнить начало кадра и получить указатель на буффер для данных
this->pResponse = (tCommand1Response*) this->pFrame->buildFrameBeforeData(COMMAND1,
(tU8)sizeof(tCommand1Response)); //lint !e826 такая задумка
this->pResponse->status1 = (tU8)0;
this->pResponse->status2 = (tU8)0;
this->pResponse->PrimaryVariableUnits = (tU8) pVariablesDirector->pTrimmer->getUnits();
this->pResponse->PrimaryVariableValue = cConversion::swap(pVariablesDirector->pTrimmer->getValue());
this->pFrame->setCheckSumm();
}
```
По такому же принципу построены и другие команды. У меня большой запас памяти, я решил, что было бы неплохо все команды, а их может быть до 254 скинуть в один массив, далее я поясню почему посчитал это удобным. Я просто создал класс контейнер cCommandSet:
```
#include "command.h" //lint !e537 для iDwartCommand
#include "variablesdirector.h" //lint !e537 для cVariablesDirector
#define COMMANDS_COUNT 254
class cCommandSet
{
public:
cCommandSet(cFrame *pFrame, cVariablesDirector *pVariablesDirector);
iBaseDwartCommand *pCommands[COMMANDS_COUNT];
};
```
Для того, чтобы две программы Pactware и HartConfig приняли меня за Yokogawa, мне надо реализовать минимальный набор команд, и положить их в контейнер.
commandset.cpp выглядит так:
```
#include "susuassert.h" //lint !e537 для ASSERT
#include "commandset.h" //lint !e537 описание класса
#include "command0.h" //lint !e537 для cCommand0
#include "command1.h" //lint !e537 для cCommand1
#include "command2.h" //lint !e537 для cCommand2
#include "command3.h" //lint !e537 для cCommand3
#include "command12.h" //lint !e537 для cCommand12
#include "command13.h" //lint !e537 для cCommand13
#include "command14.h" //lint !e537 для cCommand14
#include "command15.h" //lint !e537 для cCommand15
#include "command157.h" //lint !e537 для cCommand157
#include "command159.h" //lint !e537 для cCommand159
#include "command160.h" //lint !e537 для cCommand160
#include "command180.h" //lint !e537 для cCommand180
cCommandSet::cCommandSet(cFrame *pFrame, cVariablesDirector *pVariablesDirector)
{
this->pCommands[COMMAND0] = new cCommand0(pFrame);
this->pCommands[COMMAND1] = new cCommand1(pFrame, pVariablesDirector );
this->pCommands[COMMAND2] = new cCommand2(pFrame, pVariablesDirector );
this->pCommands[COMMAND3] = new cCommand3(pFrame, pVariablesDirector );
this->pCommands[COMMAND13] = new cCommand13(pFrame);
this->pCommands[COMMAND12] = new cCommand12(pFrame);
this->pCommands[COMMAND14] = new cCommand14(pFrame);
this->pCommands[COMMAND15] = new cCommand15(pFrame, pVariablesDirector);
this->pCommands[COMMAND160] = new cCommand160(pFrame);
this->pCommands[COMMAND157] = new cCommand157(pFrame);
this->pCommands[COMMAND159] = new cCommand159(pFrame);
this->pCommands[COMMAND180] = new cCommand180(pFrame);
}
```
Тут у меня ошибка, так как почти весь массив не инициализирован, но мне лень было его забивать :) Держим в уме, что там ошибка.
Я понятия не имею, что делают команды 157, 159 и 160, (предполагаю только, что там какая-то пользовательская перменная, которая расчитывается на основе переменной давления, например, для расчета расхода (потому что как известно, расход это есть функция корнеизвлечения от диффиринциального давления, или скажем чтобы считать уровень, который также зависит от разности давления)), но я просто заполнил их какой-то билибердой, и программы это проглотили.
Из-за того, что я сделал массив команд, обращение к командам будет выглядеть очень элегантно — вот так
```
pCommandSet->pCommands[this->pFrame->getCurrentCommand()]->setNewData();
pCommandSet->pCommands[this->pFrame->getCurrentCommand()]->send();
```
Как можно заметить не нужны никакие switсh case, но это потребовало «немного памяти» :)
#### DWART. Завершение
Все, осталось сделать активный класс который будет разбирать принятый от мастера запрос.
Как я уже говорил вышел, этот класс подписывается на событие окончания примема от сLinkLayer,
Обработчик этого события вызывается из прерывания таймера, и я должен быстро в нем что-то сделать и выйти, поэтому я просто поставлю там флажок готовности запроса от мастера на обработку, а в активной задаче буду это флажок опрашивать, если он стоит, то обращусь к cFrame, чтобы он мне декодировал сообщение и если все прошло успешно, то вызову нужную команду и отошлю её.
Этот же класс создаст экземпляры cFrame, cLinkLayer и сCommandSet и передаст cLinkLayer указатель на буффер приема и передачи. А поскольку у меня работа будет в режиме запрос-ответ, то буффер будет один и на передачу и на прием, заодно и память сэкономим.
**dwart.h**
```
#include "types.h" //lint !e537 Типы проекта для tBoolean
#include "frame.h" //lint !e537 для oFrame
#include "observer.h" //lint !e537 для iObserver
#include "linklayer.h" //lint !e537 для cLinkLayer
#include "variablesdirector.h" //lint !e537 для cVariablesDirector
#include "commandset.h" //lint !e537 для cCommandSet
#include "frtosWrapper.h" //lint !e537 Для iActiveObject
#define MAX_BUFFER_SIZE (tU8)255
class cDwart: private iObserver, public iActiveObject
{
public:
cDwart(cVariablesDirector *pVariableDirector);
virtual void eventHandle(const iObservable* pObservable);
virtual void run(void);
private:
cCommandSet *pCommandSet;
cLinkLayer *pLinkLayer;
cFrame *pFrame;
tU8 buffer[MAX_BUFFER_SIZE];
tBoolean isToken;
static const tU8 deviceID[5];
};
```
**dwart.cpp**
```
#include "susuassert.h" //lint !e537 для ASSERT
#include "frame.h" //lint !e537 для описание этого класса
#include //lint !e537 для NULL
#include "dwart.h" //lint !e537 описание класса
#define SHORT\_ADDR (tU8)0
#define PREAMBULS\_COUNT (tU8)7
#define DWART\_WAITING (tU32) (50/portTICK\_PERIOD\_MS)
const tU8 cDwart::deviceID[5] = {(tU8)0x37,(tU8)0x04,(tU8)0x00,(tU8)0x00,(tU8)0x01};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description: Создает объекты классов cLinkLayer, cFrame cCommandSet и
\* подписывается на событие окончания приема запроса от мастера
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cDwart::cDwart(cVariablesDirector \*pVariablesDirector)
{
this->pLinkLayer = new cLinkLayer(this->buffer,MAX\_BUFFER\_SIZE, this->buffer, PREAMBULS\_COUNT);
this->pFrame = new cFrame((tU8\*)deviceID, SHORT\_ADDR,this->pLinkLayer);
this->pCommandSet = new cCommandSet(this->pFrame, pVariablesDirector);
this->pLinkLayer->addObserver(this);
this->isToken = FALSE;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: eventHandle
\* Description: Релизация метода интерфейса наблюдатель. Ставит флак что токен у нас
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cDwart::eventHandle(const iObservable\* pObservable)
{
ASSERT(pObservable != NULL);
this->isToken = TRUE;
} //lint !e715 не собираюсь использовать pObservable
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: run
\* Description: Задача управления обработки принятого сообщения
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cDwart::run(void)
{
for(;;)
{
if (this->isToken)
{
this->isToken = FALSE;
if (this->pFrame->decode() == FE\_good)
{
pCommandSet->pCommands[this->pFrame->getCurrentCommand()]->setNewData();
pCommandSet->pCommands[this->pFrame->getCurrentCommand()]->send();
}
}
oRTOS.taskDelay(DWART\_WAITING);
}
}
```
Осталось добавить создание нового класса cDwart в main.cpp и запустить на проверку
```
void main( void )
{
const cAdcDirector* pAdcDirector = new cAdcDirector(); //lint !e429 не собираемся возвращать указатель.
pAdcDirector->startConversion();
cVariablesDirector *pVariablesDirector = new cVariablesDirector(pAdcDirector);
oRTOS.taskCreate(pVariablesDirector, VARIABLESDIRECTOR_STACK_SIZE, VARIABLESDIRECTOR_PRIORITY, "Var");
cDwart *pDwart = new cDwart(pVariablesDirector);
oRTOS.taskCreate(pDwart, DWART_STACK_SIZE, DWART_PRIORITY, "Dwart");
...
oRTOS.startScheduler();
} //lint !e429 не собираемся возвращать указатели.
```
И вот немецкое чудо под названием Pactware видит Японский датчик давления, даже не замечая, что все это муляж.
И наше отечественное ПО тоже не замечает подвох.
Конечно, многое тут сделано не очень оптимально, например массив из 255 указателей на команды, его можно убрать, и сделать выполнение команд через обычный switch case, также можно использовать один placeholder на все команды, равной по размеру самой большой команде и каждый раз в нем создавать нужную команду, а после удалять.
Но в моем случае у меня памяти немеренно, и проблем оптимизации не было.
Сам проект как обычно в [секретном месте](https://yadi.sk/d/XHXC4v1BiECdQ) | https://habr.com/ru/post/367843/ | null | ru | null |
# Docker: заметки веб-разработчика. Итерация третья
Привет, друзья! Продолжаю делиться с вами заметками о [`Docker`](https://www.docker.com/).
Заметки состоят из 4 частей: 2 теоретических и 2 практических. Если быть более конкретным:
* [первая часть](https://habr.com/ru/company/timeweb/blog/595687/) посвящена `Docker`, `Docker CLI` и `Dockerfile`;
* во [второй части](https://habr.com/ru/company/timeweb/blog/597613/) рассказывается о `Docker Compose`.
В этой части мы разработаем простое приложение, состоящее из трех сервисов и базы данных, а в заключительной — "контейнеризуем" его.
[Репозиторий с кодом приложения](https://github.com/harryheman/docker-test).
Если вам это интересно, прошу под кат.
Подготовка и настройка проекта
------------------------------
Предполагается, что вы хотя бы вкратце ознакомились с содержанием предыдущих частей или изучали другие материалы, посвященные работе с [`Docker`](https://www.docker.com/). Впрочем, в этой части `Docker` будет совсем чуть-чуть.
Также предполагается, что на вашей машине установлен [`Docker`](https://www.docker.com/products/docker-desktop) и [`Node.js`](https://nodejs.org/en/download/).
Хорошо, если на вашей машине установлен [`Yarn`](https://yarnpkg.com/) и вы имеете опыт работы с [`React`](https://ru.reactjs.org/), [`Vue`](https://vuejs.org/), `Node.js`, [`PostgreSQL`](https://www.postgresql.org/) и [sh](https://pubs.opengroup.org/onlinepubs/009604599/utilities/sh.html) или [`bash`](http://www.gnu.org/software/bash/) (все это опционально).
Как я сказал, наше приложение будет состоять из трех сервисов:
* клиента на `React.js`;
* админки на `Vue.js`;
* сервера (API) на `Node.js`.
В качестве базы данных мы будем использовать `PostgreSQL`, а для взаимодействия с ней — [Prisma](https://www.prisma.io/).
Функционал нашего приложения будет следующим:
* в админке задаются настройки для приветствия, темы и базового размера шрифта;
* эти настройки записываются в БД и применяются на клиенте;
* на клиенте реализована "тудушка";
* задачи записываются в БД;
* все это обслуживается сервером.
Создаем директорию для проекта, переходим в нее и создаем еще парочку директорий:
```
mkdir docker-test
cd !$ # docker-test
mkdir services sh uploads
```
В директории `services` будут находиться наши сервисы, в директории `sh` — скрипты для терминала, директорию `uploads` мы использовать не будем, но обычно в ней хранятся различные файлы, загружаемые админом или пользователями.
Переходим в директорию `services`, создаем директорию для API, генерируем шаблон клиента с помощью [`Create React App`](https://create-react-app.dev/) и шаблон админки с помощью [`Vue CLI`](https://cli.vuejs.org/):
```
cd services
mkdir api
yarn create react-app client
# or
npx create-react-app client
yarn create vue-app admin
# or
npx vue create admin
```
Начнем с API.
API
---
Переходим в директорию `api`, инициализируем `Node.js-проект` и устанавливаем зависимости:
```
cd api
yarn init -yp
# or
npm init -y
# производственные зависимости
yarn add express cors
# зависимости для разработки
yarn add -D nodemon prisma
```
* [express](https://www.npmjs.com/package/express) — `Node.js-фреймворк` для разработки веб-серверов;
* [cors](https://www.npmjs.com/package/cors) — утилита для работы с [CORS](https://developer.mozilla.org/ru/docs/Web/HTTP/CORS);
* [nodemon](https://www.npmjs.com/package/nodemon) — утилита для запуска сервера для разработки;
* [prisma](https://www.npmjs.com/package/prisma) — ядро (core) [ORM](https://ru.wikipedia.org/wiki/ORM), которое мы будем использовать для взаимодействия с `postgres`.
Инициализируем `prisma`:
```
npx prisma init
```
Это приводит к генерации директории `prisma`, а также файлов `prisma/schema.prisma` и `.env`.
Определяем генератор, источник данных и модели в файле `prisma/schema.prisma`:
```
// https://pris.ly/d/prisma-schema
generator client {
provider = "prisma-client-js"
// это нужно для контейнера
binaryTargets = ["native"]
}
datasource db {
provider = "postgresql"
// путь к БД извлекается из переменной среды окружения `DATABASE_URL`
url = env("DATABASE_URL")
}
// модель для настроек
model Settings {
id Int @id @default(autoincrement())
created_at DateTime @default(now())
updated_at DateTime @updatedAt
greetings String
theme String
base_font_size String
}
// модель для задачи
model Todo {
id Int @id @default(autoincrement())
created_at DateTime @default(now())
updated_at DateTime @updatedAt
text String
done Boolean
}
```
Определяем путь к БД в файле `.env`:
```
DATABASE_URL=postgresql://postgres:postgres@localhost:5432/mydb?schema=public
```
Здесь:
* `postgres` — имя пользователя и пароль;
* `localhost` — хост, на котором запущен сервер `postgres`;
* `5432` — порт, на котором запущен сервер `postgres`;
* `mydb` — название БД.
Определяем команду для запуска [`контейнера postgres`](https://hub.docker.com/_/postgres) в файле `sh/db` (без расширения):
```
docker run --rm --name postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_USER=postgres -e POSTGRES_DB=mydb -dp 5432:5432 -v $HOME/docker/volumes/postgres:/var/lib/postgresql/data postgres
```
*Обратите внимание*: если вы работаете на `Mac`, вам потребуется предоставить самому себе разрешение на выполнение кода из файла `sh/db`. Это можно сделать так:
```
# мы находимся в директории `sh`
chmod +x db
# or
sudo chmod +x db
```
Находясь в корневой директории проекта, открываем терминал и выполняем команду:
```
sh/db
```
Происходит загрузка образа `postgres` из [`Docker Hub`](https://hub.docker.com/) и запуск контейнера под названием `postgres`.
*Обратите внимание*: иногда может возникнуть ошибка, связанная с тем, что порт 5432 занят другим процессом. В этом случае необходимо найти `PID` данного процесса и "убить" его. На `Mac` это делается так:
```
# получаем `PID` процесса, запущенного на порту `5432`
sudo lsof -i :5432
# предположим, что `PID` имеет значение `103`
# "убиваем" процесс
sudo kill 103
```
Убедиться в запуске контейнера можно, выполнив команду `docker ps`:
Или запустив [`Docker Desktop`](https://www.docker.com/products/docker-desktop):
Или в разделе `Individual Containers` [`расширения Docker` для `VSCode`](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-docker):
Выполняем миграцию:
```
# мы находимся в директории `api`
# migrate dev - миграция для разработки
# --name init - название миграции
npx prisma migrate dev --name init
```
Это приводит к генерации файла `prisma/migrations/[Date]-init/migration.sql`, подключению к БД, созданию в ней таблиц, установке и настройке [`@prisma/client`](https://www.npmjs.com/package/@prisma/client).
Создаем файл `prisma/seed.js` с кодом для заполнения БД начальными данными:
```
import Prisma from '@prisma/client'
const { PrismaClient } = Prisma
// инициализируем клиента
const prisma = new PrismaClient()
// начальные настройки
const initialSettings = {
greetings: 'Welcome to Docker Test App',
theme: 'light',
base_font_size: '16px'
}
// начальные задачи
const initialTodos = [
{
text: 'Eat',
done: true
},
{
text: 'Code',
done: true
},
{
text: 'Sleep',
done: false
},
{
text: 'Repeat',
done: false
}
]
async function main() {
try {
// если таблица настроек является пустой
if (!(await prisma.settings.findFirst())) {
await prisma.settings.create({ data: initialSettings })
}
// если таблица задач является пустой
if (!(await (await prisma.todo.findMany()).length)) {
await prisma.todo.createMany({ data: initialTodos })
}
console.log('Database has been successfully seeded 🚀 ')
} catch (e) {
console.log(e)
} finally {
await prisma.$disconnect()
}
}
main()
```
В `package.json` определяем тип кода сервера (модуль), команды для запуска сервера в режиме для разработки и производственном режиме, а также команду для заполнения БД начальными данными:
```
"type": "module",
"scripts": {
"dev": "nodemon",
"start": "prisma generate && prisma migrate deploy && node index.js"
},
"prisma": {
"seed": "node prisma/seed.js"
}
```
Заполняем БД начальными данными:
```
# мы находимся в директории `api`
npx prisma db seed
```
Открываем нашу БД в интерактивном режиме:
```
npx prisma studio
```
Это приводит к открытию вкладки браузера по адресу `http://localhost:5555`:
Приступаем к разработке сервера.
Структура сервера будет следующей:
```
- routes
- index.js
- settings.routes.js - маршруты (роуты) для настроек
- todo.routes.js - роуты для задач
- index.js
```
Содержание файла `index.js`:
```
// импортируем библиотеки и утилиты
import express from 'express'
import cors from 'cors'
import Prisma from '@prisma/client'
import apiRoutes from './routes/index.js'
import { join, dirname } from 'path'
import { fileURLToPath } from 'url'
const { PrismaClient } = Prisma
// создаем и экспортируем экземпляр `prisma`
export const prisma = new PrismaClient()
// путь к текущей директории
const __dirname = dirname(fileURLToPath(import.meta.url))
// создаем экземпляр приложения `express`
const app = express()
// отключаем `cors`
app.use(cors())
// включаем парсинг `json` в объекты
app.use(express.json())
// это пригодится нам при запуске приложения в производственном режиме
if (process.env.ENV === 'prod') {
// обратите внимание на пути
// путь к текущей директории + `client/build`
const clientBuildPath = join(__dirname, 'client', 'build')
// путь к текущей директории + `admin/dist`
const adminDistPath = join(__dirname, 'admin', 'dist')
// обслуживание статических файлов
// клиент будет доступен по пути сервера
app.use(express.static(clientBuildPath))
app.use(express.static(adminDistPath))
// админка будет доступна по пути сервера + `/admin`
app.use('/admin', (req, res) => {
res.sendFile(join(adminDistPath, decodeURIComponent(req.url)))
})
}
// роутинг
app.use('/api', apiRoutes)
// обработчик ошибок
app.use((err, req, res, next) => {
console.log(err)
const status = err.status || 500
const message = err.message || 'Something went wrong. Try again later'
res.status(status).json({ message })
})
// запускаем сервер на порту 5000
app.listen(5000, () => {
console.log(`Server ready 🚀 `)
})
```
Рассмотрим роуты.
Начнем с роутера приложения (`routes/index.js`):
```
import { Router } from 'express'
import todoRoutes from './todo.routes.js'
import settingsRoutes from './settings.routes.js'
const router = Router()
router.use('/todo', todoRoutes)
router.use('/settings', settingsRoutes)
export default router
```
Роутер для настроек (`routes/settings.routes.js`):
```
import { Router } from 'express'
import { prisma } from '../index.js'
const router = Router()
// получение настроек
router.get('/', async (req, res, next) => {
try {
const settings = await prisma.settings.findFirst()
res.status(200).json(settings)
} catch (e) {
next(e)
}
})
// обновление настроек
router.put('/:id', async (req, res, next) => {
const id = Number(req.params.id)
try {
const settings = await prisma.settings.update({
data: req.body,
where: { id }
})
res.status(201).json(settings)
} catch (e) {
next(e)
}
})
export default router
```
Роутер для задач (`routes/todo.routes.js`):
```
import { Router } from 'express'
import { prisma } from '../index.js'
const router = Router()
// получение задач
router.get('/', async (req, res, next) => {
try {
const todos = (await prisma.todo.findMany()).sort(
(a, b) => a.created_at - b.created_at
)
res.status(200).json(todos)
} catch (e) {
next(e)
}
})
// создание задачи
router.post('/', async (req, res, next) => {
try {
const newTodo = await prisma.todo.create({
data: req.body
})
res.status(201).json(newTodo)
} catch (e) {
next(e)
}
})
// обновление задачи
router.put('/:id', async (req, res, next) => {
const id = Number(req.params.id)
try {
const updatedTodo = await prisma.todo.update({
data: req.body,
where: { id }
})
res.status(201).json(updatedTodo)
} catch (e) {
next(e)
}
})
// удаление задачи
router.delete('/:id', async (req, res, next) => {
const id = Number(req.params.id)
try {
await prisma.todo.delete({
where: { id }
})
res.sendStatus(201)
} catch (e) {
next(e)
}
})
export default router
```
Это все, что требуется от нашего сервера.
Админка
-------
Структура админки будет следующей (`admin/src`):
```
- components
- App.vue - основной компонент приложения
- Settings.vue - компонент для обновления настроек
- index.js
```
Начнем с основного компонента (`components/App.vue`).
Разметка:
```
Admin
=====
Loading...
----------
###
{{ error.message || 'Something went wrong. Try again later' }}
Settings
--------
```
Стили:
```
@import url('https://fonts.googleapis.com/css2?family=Montserrat:wght@200;400;600&display=swap');
:root {
--primary: #0275d8;
--success: #5cb85c;
--warning: #f0ad4e;
--danger: #d9534f;
--light: #f7f7f7;
--dark: #292b2c;
}
* {
font-family: 'Montserrat', sans-serif;
font-size: 1rem;
}
body.light {
background-color: var(--light);
color: var(--dark);
}
body.dark {
background-color: var(--dark);
color: var(--light);
}
#app {
display: flex;
flex-direction: column;
text-align: center;
}
h2 {
font-size: 1.4rem;
}
form div {
display: flex;
flex-direction: column;
align-items: center;
}
label {
margin: 0.5rem 0;
}
input {
padding: 0.5rem;
max-width: 220px;
width: max-content;
outline: none;
border: 1px solid var(--dark);
border-radius: 4px;
text-align: center;
}
input:focus {
border-color: var(--primary);
}
button {
margin: 1rem 0;
padding: 0.5rem 1rem;
background: none;
border: none;
border-radius: 4px;
outline: none;
background-color: var(--success);
color: var(--light);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
cursor: pointer;
user-select: none;
transition: 0.2s;
}
button:active {
box-shadow: none;
}
.error {
color: var(--danger);
}
```
Скрипт:
```
// импортируем компонент для обновления настроек
import Settings from './Settings'
export default {
// название компонента
name: 'App',
// дочерние компоненты
components: {
Settings
},
// начальное состояние
data() {
return {
loading: true,
error: null,
settings: {},
apiUri: 'http://localhost:5000/api/settings'
}
},
// монтирование компонента
created() {
// получаем настройки
this.getSettings()
},
// методы
methods: {
// для получения настроек
async getSettings() {
this.loading = true
try {
const response = await fetch(API_URI)
if (!response.ok) throw response
this.settings = await response.json()
} catch (e) {
this.error = e
} finally {
this.loading = false
}
}
}
}
```
Теперь рассмотрим компонент для обновления настроек (`components/Settings.vue`).
Разметка:
```
Loading...
{{ error.message || JSON.stringify(error, null, 2) }}
Greetings
Theme
Base font size
Save
```
Скрипт:
```
export default {
// название компонента
name: 'Settings',
// пропы
props: {
settings: {
type: Object,
required: true
},
getSettings: {
type: Function,
required: true
},
apiUri: {
type: String,
required: true
}
},
// начальное состояние
data() {
return {
loading: false,
error: null
}
},
// методы
methods: {
// для обновления настроек в БД
async saveSettings(e) {
this.loading = true
const formDataObj = [...new FormData(e.target)].reduce(
(obj, [key, val]) => ({
...obj,
[key]: val
}),
{}
)
try {
const response = await fetch(`${this.apiUri}/${this.settings.id}`, {
method: 'PUT',
body: JSON.stringify(formDataObj),
headers: {
'Content-Type': 'application/json'
}
})
if (!response.ok) throw response
// получаем обновленные настройки
await this.getSettings()
} catch (e) {
this.error = e
} finally {
this.loading = false
}
}
}
}
```
На этом с админкой мы закончили.
Клиент
------
Структура клиента будет следующей (`client/src`):
```
- api
- settings.api.js - API для настроек
- todo.api.js - API для задач
- components
- TodoForm.js - компонент для создания задачи
- TodoList.js - компонент для формирования списка задач
- hooks
- useStore.js - хранилище состояние в виде пользовательского хука
- App.js - основной компонент приложения
- App.css
- index.js
```
Для управления состоянием приложения мы будем использовать [`Zustand`](https://github.com/harryheman/React-Total/blob/main/md/zustand.md).
Устанавливаем его:
```
yarn add zustand
```
Начнем с API для настроек (`api/settings.api.js`):
```
// конечная точка
const API_URI = 'http://localhost:5000/api/settings'
// метод для получения настроек
const fetchSettings = async () => {
try {
const response = await fetch(API_URI)
if (!response.ok) throw response
return await response.json()
} catch (e) {
throw e
}
}
const settingsApi = { fetchSettings }
export default settingsApi
```
API для задач (`api/todo.api.js`):
```
// конечная точка
const API_URI = 'http://localhost:5000/api/todo'
// метод для получения задач
const fetchTodos = async () => {
try {
const response = await fetch(API_URI)
if (!response.ok) throw response
return await response.json()
} catch (e) {
throw e
}
}
// метод для создания новой задачи
const addTodo = async (newTodo) => {
try {
const response = await fetch(API_URI, {
method: 'POST',
body: JSON.stringify(newTodo),
headers: {
'Content-Type': 'application/json'
}
})
if (!response.ok) throw response
return await response.json()
} catch (e) {
throw e
}
}
// метод для обновления задачи
const updateTodo = async (id, changes) => {
try {
const response = await fetch(`${API_URI}/${id}`, {
method: 'PUT',
body: JSON.stringify(changes),
headers: {
'Content-Type': 'application/json'
}
})
if (!response.ok) throw response
return await response.json()
} catch (e) {
throw e
}
}
// метод для удаления задачи
const removeTodo = async (id) => {
try {
const response = await fetch(`${API_URI}/${id}`, {
method: 'DELETE'
})
if (!response.ok) throw response
} catch (e) {
throw e
}
}
const todoApi = { fetchTodos, addTodo, updateTodo, removeTodo }
export default todoApi
```
Хранилище состояния в виде пользовательского хука (`hooks/useStore.js`):
```
import create from 'zustand'
// API для настроек
import settingsApi from '../api/settings.api'
// API для задач
import todoApi from '../api/todo.api'
const useStore = create((set, get) => ({
// начальное состояние
settings: {},
todos: [],
loading: false,
error: null,
// методы для
// получения настроек
fetchSettings() {
set({ loading: true })
settingsApi
.fetchSettings()
.then((settings) => {
set({ settings })
})
.catch((error) => {
set({ error })
})
.finally(() => {
set({ loading: false })
})
},
// получения задач
fetchTodos() {
set({ loading: true })
todoApi
.fetchTodos()
.then((todos) => {
set({ todos })
})
.catch((error) => {
set({ error })
})
.finally(() => {
set({ loading: false })
})
},
// создания задачи
addTodo(newTodo) {
set({ loading: true })
todoApi
.addTodo(newTodo)
.then((newTodo) => {
const todos = [...get().todos, newTodo]
set({ todos })
})
.catch((error) => {
set({ error })
})
.finally(() => {
set({ loading: false })
})
},
// обновления задачи
updateTodo(id, changes) {
set({ loading: true })
todoApi
.updateTodo(id, changes)
.then((updatedTodo) => {
const todos = get().todos.map((todo) =>
todo.id === updatedTodo.id ? updatedTodo : todo
)
set({ todos })
})
.catch((error) => {
set({ error })
})
.finally(() => {
set({ loading: false })
})
},
// удаления задачи
removeTodo(id) {
set({ loading: true })
todoApi
.removeTodo(id)
.then(() => {
const todos = get().todos.filter((todo) => todo.id !== id)
set({ todos })
})
.catch((error) => {
set({ error })
})
.finally(() => {
set({ loading: false })
})
}
}))
export default useStore
```
Компонент для создания новой задачи (`components/TodoForm.js`):
```
import { useState, useEffect } from 'react'
import useStore from '../hooks/useStore'
export default function TodoForm() {
// метод для создания задачи из хранилища
const addTodo = useStore(({ addTodo }) => addTodo)
// состояние для текста новой задачи
const [text, setText] = useState('')
const [disable, setDisable] = useState(true)
useEffect(() => {
setDisable(!text.trim())
}, [text])
// метод для обновления текста задачи
const onChange = ({ target: { value } }) => {
setText(value)
}
// метод для отправки формы
const onSubmit = (e) => {
e.preventDefault()
if (disable) return
const newTodo = {
text,
done: false
}
addTodo(newTodo)
}
return (
New todo text
Add
)
}
```
Компонент для формирования списка задач (`components/TodoList.js`):
```
import useStore from '../hooks/useStore'
export default function TodoList() {
// задачи и методы для обновления и удаления задачи из хранилища
const { todos, updateTodo, removeTodo } = useStore(
({ todos, updateTodo, removeTodo }) => ({ todos, updateTodo, removeTodo })
)
return (
{todos.map(({ id, text, done }) => (
* {
updateTodo(id, { done: !done })
}}
/>
{text}
{
removeTodo(id)
}}
>
Remove
))}
)
}
```
Основной компонент приложения (`App.js`):
```
import { useEffect } from 'react'
import './App.css'
import useStore from './hooks/useStore'
import TodoForm from './components/TodoForm'
import TodoList from './components/TodoList'
// получаем настройки
useStore.getState().fetchSettings()
// получаем задачи
useStore.getState().fetchTodos()
function App() {
// настройки, индикатор загрузки и ошибка из хранилища
const { settings, loading, error } = useStore(
({ settings, loading, error }) => ({ settings, loading, error })
)
useEffect(() => {
if (Object.keys(settings).length) {
// применяем базовый размер шрифта к элементу `html`
document.documentElement.style.fontSize = settings.base_font_size
// применяем тему
document.body.className = settings.theme
}
}, [settings])
// загрузка
if (loading) return Loading...
----------
// ошибка
if (error)
return (
###
{error.message || 'Something went wrong. Try again later'}
)
return (
Client
======
{settings.greetings}
--------------------
)
}
export default App
```
Стили (`App.css`):
```
@import url('https://fonts.googleapis.com/css2?family=Montserrat:wght@200;400;600&display=swap');
:root {
--primary: #0275d8;
--success: #5cb85c;
--warning: #f0ad4e;
--danger: #d9534f;
--light: #f7f7f7;
--dark: #292b2c;
}
* {
margin: 0;
padding: 0;
box-sizing: border-box;
font-family: 'Montserrat', sans-serif;
font-size: 1rem;
}
/* Тема */
body.light {
background-color: var(--light);
color: var(--dark);
}
body.dark {
background-color: var(--dark);
color: var(--light);
}
/* --- */
#root {
padding: 1rem;
display: flex;
justify-content: center;
}
.App {
display: flex;
flex-direction: column;
align-items: center;
}
h1,
h2 {
margin: 1rem 0;
}
h1 {
font-size: 1.6rem;
}
h2 {
font-size: 1.4rem;
}
h3 {
font-size: 1.2rem;
}
label {
margin-bottom: 0.5rem;
display: block;
}
form {
margin: 1rem 0;
}
form input {
padding: 0.5rem;
max-width: 220px;
width: max-content;
outline: none;
border: 1px solid var(--dark);
border-radius: 4px;
text-align: center;
}
form input:focus {
border-color: var(--primary);
}
ul {
list-style: none;
}
li {
margin: 0.75rem 0;
display: flex;
align-items: center;
justify-content: space-between;
}
li input {
width: 18px;
height: 18px;
}
li span {
display: block;
width: 120px;
word-break: break-all;
}
button {
padding: 0.5rem 1rem;
background: none;
border: none;
border-radius: 4px;
outline: none;
background-color: var(--danger);
color: var(--light);
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
cursor: pointer;
user-select: none;
transition: 0.2s;
}
button:active {
box-shadow: none;
}
button.add {
background-color: var(--success);
}
.error {
color: var(--danger);
}
.App {
text-align: center;
}
```
Поскольку отступы и размеры заданы с помощью [rem](https://webref.ru/css/unit/rem), мы легко можем манипулировать этими значениями, меняя размер шрифта элемента `html`.
На этом с клиентом мы также закончили.
Проверка работоспособности приложения
-------------------------------------
Поднимаемся в корневую директорию (`docker-test`), инициализируем `Node.js-проект` и устанавливаем [`concurrently`](https://www.npmjs.com/package/concurrently) — утилиту для одновременного выполнения команд, определенных в файле `package.json`:
```
# мы находимся в директории `docker-test`
yarn init -yp
yarn add concurrently
```
Определяем команды для запуска серверов для разработки в `package.json`:
```
"scripts": {
"dev:client": "yarn --cwd services/client start",
"dev:admin": "yarn --cwd services/admin dev",
"dev:api": "yarn --cwd services/api dev",
"dev": "concurrently \"yarn dev:client\" \"yarn dev:admin\" \"yarn dev:api\""
}
```
Выполняем команду `yarn dev` или `npm run dev`.
Это приводит к запуску 3 серверов для разработки:
* для клиента по адресу `http://localhost:3000`:
* для админки по адресу `http://localhost:4000`":
* для сервера по адресу `http://localhost:5000`.
Меняем настройки в админке:
Перезагружаем клиента:
Видим, что настройки успешно применились.
Работаем с задачами:
Задачи успешно создаются/обновляются/удаляются и сохраняются в БД.
Отлично. Приложение работает, как ожидается.
Пожалуй, это все, о чем я хотел вам рассказать в этой части.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/650969/ | null | ru | null |
# Защита gmail от спама.
Прошу заранее прощения, но мне хочется немного разбавить поток прилизанных пресс-релизов, и хвалебных обзоров гугла, в этом блоге, небольшим user experience.
До недавнего времени я к гуглу относился исключительно положительно (не скажу «любил» т.к. не имею привычки влюбляться в сервисы). Но уже довольно давно он меня сильно и регулярно огорчает вот этим:
`Hi. This is the qmail-send program at powerman.asdfGroup.com.
I'm afraid I wasn't able to deliver your message to the following addresses.
This is a permanent error; I've given up. Sorry it didn't work out.
:
72.14.215.114 failed after I sent the message.
Remote host said: 550-5.7.1 [85.90.198.1] The IP you're using to send email is not authorized
550-5.7.1 to send email directly to our servers. Please use
550 5.7.1 the SMTP relay at your service provider instead.`
Если бы такая проблема возникла не с gmail, а, например, с mail.ru — я бы просто послал того, кто открыл себе ящик на mail.ru (или любом другом сервисе, mail.ru взят исключительно для примера и выбран наобум), открыть себе ящик в любом другом **нормальном** месте. И большинство бы так и поступили.
А что мне в этой ситуации делать? Использовать SMTP провайдера я не могу и не хочу. Во-первых у меня девелоперская машина, и периодически пишутся приложения работающие с почтой, а наличие qmail на своей машине конкретно упрощает жизнь. Во-вторых машина у меня включена 24x7, использует 2 ADSL подключения к разным провайдерам, и когда qmail у меня, мне значительно проще контролировать приём/отправку писем, текущую очередь, etc. В-третьих, как я уже сказал, у меня два разных провайдера, default route настроен одновременно через обоих, и когда у одного проблемы моя машина автоматически переключается на другого — так что использовать SMTP сервер кого-то одного из них означает остаться без почты когда у него проблемы (а проблемы периодически бывают у любого ISP, и не всегда по его вине и под его контролем). Помимо этого у меня на одном из ADSL статический IP, и когда этот канал работает почта ходит именно через него — так что этот не тот случай, когда нужно защищаться от спамеров, использующих динамические IP на ADSL. Ну и последнее — у меня всё-таки Hardened Gentoo, аккуратно настроенный в т.ч. и в плане безопасности, что, как показывает моё знакомство с админами нескольких ISP, делает мою машину значительно более защищённой, чем многие их сервера. :)
Резюмируя: мы имеем ситуацию, когда Google отказывается принимать почту от конкретной машины, которая имеет статический IP, хорошо защищена и никогда не рассылала спам. Причём — без каких либо на то причин. Причём — на мои письма в поддержку гугла ответа нет. Причём — Google ещё и имеет наглость указывать мне, какие SMTP сервера мне использовать, а какие нет. И при всём при этом я абсолютно бессилен, т.к. пользователи gmail менять его на альтернативы в абсолютном большинстве случаев не захотят, безосновательно считая его «правым» по умолчанию в любой ситуации — это-ж САМ Google!
Так выпьем же за здоровье «САМОГО», будь он неладен! :)
**Update:** Проблема была [решена](http://habrahabr.ru/blog/google/25785.html#comment396561) с помощью [masterbo](https://geektimes.ru/users/masterbo/), за что ему громадное спасибо! | https://habr.com/ru/post/14305/ | null | ru | null |
# Компилируем FFmpeg в WebAssembly (=ffmpeg.js): Часть 1 — Приготовления
Список переведённых частей серии:
1. [Приготовления](https://habr.com/ru/post/473098/) (вы тут)
2. [Компиляция с Emscripten](https://habr.com/ru/post/473134/)
3. [Конвертация avi в mp4](https://habr.com/ru/post/473166/)
---
Из этой части вы узнаете:
1. Зачем это всё нужно
2. Как скомпилировать FFmpeg в Docker
---
Зачем это всё нужно
===================
Главные задачи у серии публикаций такие:
1. Создать туториал по использованию [Emscripten](https://ru.wikipedia.org/wiki/Emscripten) для компиляции C/C++ библиотек в JavaScript (более детальный и полезный, чем написанные ранее)
2. Персональная памятка
Почему FFmpeg?
==============
FFmpeg — это свободный проект с открытым исходным кодом, состоящий из обширного набора библиотек и программ для обработки видео, аудио и других мультимедийных файлов/трансляций. (из Википедии)
Библиотеки JavaScript, которая предоставляла бы подобные возможности, попросту не существует. Если вы погуглите «ffmpeg.js», то найдёте несколько решений, подобных тому что мы собираемся сделать:
* [ffmpeg.js](https://github.com/Kagami/ffmpeg.js/)
* [videoconverter.js](https://github.com/bgrins/videoconverter.js)
Эти библиотеки, конечно, можно использовать, но у них есть свои недостатки:
1. Используемые версии как FFmpeg, так и Emscripten устарели
2. Проекты не поддерживаются уже долгое время
Изначально я планировал заняться поддержкой какой-нибудь из двух библиотек, но так как за годы накопилось слишком много изменений, решил сделать всё с чистого листа, попутно создав туториал по использованию Emscripten для компиляции большой C/C++ библиотеки.
Как скомпилировать FFmpeg в Docker
==================================
Для начала клонируем исходники FFmpeg, а так как ветка **master** используется для разработки, выберем ветку с конкретной версией.
На момент написания туториала последняя версия FFmpeg — 4.1.4, поэтому её и будем использовать.
```
$ git clone --depth 1 --branch n4.1.4 https://github.com/FFmpeg/FFmpeg
```
> **--depth 1** добавлять необязательно, но это ускорит клонирование, так как нам не нужно скачивать все коммиты.
>
>
После успешного клонирования скомпилируем исходники с gcc, чтобы убедиться, что всё работает.
Конечно, этот шаг можно пропустить, но мой опыт говорит, что всегда хорошо предварительно пощупать систему сборки. (FFmpeg использует стандартный make, который легче портировать по сравнению с Bazel)
Инструкцию по компиляции и установке FFmpeg можно найти в файле **INSTALL.md**, расположенном в корневой директории:
> # Установка FFmpeg:
>
>
>
> 1. Наберите `./configure` чтобы создать конфигурацию. Список опций для конфигурирования можно получить выполнив `configure — help`.
>
>
>
> `configure` можно выполнять из директории отличной от исходников FFmpeg. Для этого передавайте в `configure` абсолютный путь, напр. `/ffmpegdir/ffmpeg/configure`.
>
>
>
> 2. Теперь наберите `make` для сборки FFmpeg. Понадобится GNU Make 3.81 или выше.
>
>
>
> 3. Наберите `make install` для установки бинарников и библиотек.
>
>
>
> ЗАМЕТКА
>
> — — —
>
>
>
> — Не системные зависимости (напр. libx264, libvpx) по умолчанию отключены.
>
>
Так как устанавливать FFmpeg мы не будем, необходимы лишь первые два шага.
При компиляции с gcc мы воспользуемся [Docker](https://www.docker.com/)'ом для создания окружения, что позволит изолировать весь процесс и добиться его однообразия на разных машинах.
Давайте в корневой директории создадим bash-скрипт **build-with-docker.sh** с таким содержимым:
```
#!/bin/bash
docker pull gcc:4
docker run -it \
-v $PWD:/usr/src \
gcc:9.1 \
sh -c 'cd /usr/src && ./configure --disable-x86asm && make -j4'
```
> **--disable-x86asm** нужно добавить, так как об этом попросит сам ffmpeg
>
>
Запустим скрипт:
```
$ chmod +x build-with-docker.sh
$ ./build-with-docker.sh
```
> В зависимости от скорости интернет-соединения и вашего железа, компиляция займёт где-то 10-30 минут.
>
>
>
> Учтите, что вы увидите много предупреждений, так как gcc 9.1 строже предыдущих версий. Это нормально.
>
>
Если всё завершилось успешно, можно попробовать запустить **ffmpeg**:
```
$ ./ffmpeg
```
Или
```
$ docker run -it -v $PWD:/usr/src gcc:9.1 /usr/src/ffmpeg
```
Вы увидите что-то типа:
> ffmpeg version n4.1.4 Copyright 2000–2019 the FFmpeg developers
>
> built with gcc 9.1.0 (GCC)
>
> configuration: — disable-x86asm
>
> libavutil 56. 22.100 / 56. 22.100
>
> libavcodec 58. 35.100 / 58. 35.100
>
> libavformat 58. 20.100 / 58. 20.100
>
> libavdevice 58. 5.100 / 58. 5.100
>
> libavfilter 7. 40.101 / 7. 40.101
>
> libswscale 5. 3.100 / 5. 3.100
>
> libswresample 3. 3.100 / 3. 3.100
>
> Hyper fast Audio and Video encoder
>
> usage: ffmpeg [options] [[infile options] -i infile]… {[outfile options] outfile}…
>
>
>
> Use -h to get full help or, even better, run ‘man ffmpeg’
>
>
В следующей части мы начнём компиляцию FFmpeg уже с помощью Emscripten. | https://habr.com/ru/post/473098/ | null | ru | null |
# Производительность сетевых приложений Linux. Введение
Веб-приложения ныне используются повсеместно, а среди всех транспортных протоколов львиную долю занимает HTTP. Изучая нюансы разработки веб-приложений, большинство уделяет очень мало внимания операционной системе, где эти приложения реально запускаются. Разделение разработки (Dev) и эксплуатации (Ops) лишь ухудшало ситуацию. Но с распространением культуры DevOps разработчики начинают нести ответственность за запуск своих приложений в облаке, поэтому для них очень полезно досконально познакомиться с бэкендом операционной системы. Это особенно полезно, если вы пытаетесь развернуть систему для тысяч или десятков тысяч одновременных подключений.
Ограничения в веб-службах очень похожи на ограничения в других приложениях. Будь то балансировщики нагрузки или серверы БД, у всех этих приложений аналогичные проблемы в высокопроизводительной среде. Понимание этих фундаментальных ограничений и способов их преодоления в целом позволит оценить производительность и масштабируемость ваших веб-приложений.
Я пишу эту серию статей в ответ на вопросы молодых разработчиков, которые хотят стать хорошо информированными системными архитекторами. Невозможно чётко понять методы оптимизации приложений Linux, не погрузившись в основы, как они работают на уровне операционной системы. Хотя есть много типов приложений, в этом цикле я хочу исследовать сетевые приложения, а не десктопные, такие как браузер или текстовый редактор. Этот материал рассчитан на разработчиков и архитекторов, которые хотят понять, как работают программы Linux или Unix и как их структурировать для высокой производительности.
Linux — это *серверная* операционная система, и чаще всего ваши приложения работают именно на этой ОС. Хотя я говорю «Linux», большую часть времени вы можете с уверенностью предположить, что имеются в виду все Unix-подобные операционные системы в целом. Тем не менее, я не тестировал сопровождающий код на других системах. Итак, если вас интересует FreeBSD или OpenBSD, результат может отличаться. Когда я пробую что-то Linux-специфическое, то указываю на это.
Хотя вы можете использовать полученные знания для создания приложения с нуля, и оно будет великолепно оптимизировано, но лучше так не делать. Если вы напишете новый веб-сервер на C или C++ для бизнес-приложения своей организации, возможно, это будет ваш последний день на работе. Однако знание структуры этих приложений поможет в выборе уже существующих программ. Вы сможете сравнивать системы на основе процессов с системами на основе потоков, а также на основе событий. Вы поймёте и оцените, почему Nginx работает лучше, чем Apache httpd, почему приложение Python на основе Tornado может обслуживать больше пользователей по сравнению с приложением Python на основе Django.
ZeroHTTPd: инструмент обучения
==============================
[ZeroHTTPd](https://github.com/shuveb/zerohttpd) — веб-сервер, который я написал с нуля на C в качестве учебного инструмента. У него нет внешних зависимостей, в том числе доступа к Redis. Мы запускаем собственные процедуры Redis. Подробнее см. ниже.
Хотя мы могли бы долго обсуждать теорию, нет ничего лучше, чем написать код, запустить его и сравнить между собой все серверных архитектуры. Это самый наглядный метод. Поэтому мы будем писать простой веб-сервер ZeroHTTPd, применяя каждую модель: на основе процессов, потоков и событий. Проверим каждый из этих серверов и посмотрим, как они работают по сравнению друг с другом. ZeroHTTPd реализован в одном файле C. В состав сервера на основе событий входит [uthash](https://troydhanson.github.io/uthash/), отличная реализация хэш-таблицы, которая поставляется в одном заголовочном файле. В остальных случаях никаких зависимостей нет, чтобы не усложнять проект.
В коде очень много комментариев, чтобы помочь разобраться. Будучи простым веб-сервером в нескольких строчках кода, ZeroHTTPd также представляет собой минимальный фреймворк для веб-разработки. У него ограниченная функциональность, но он способен выдавать статические файлы и очень простые «динамические» страницы. Должен сказать, что ZeroHTTPd хорошо подходит для обучения, как создавать высокопроизводительные Linux-приложения. По большому счёту, большинство веб-сервисов ждут запросов, проверяют их и обрабатывают. Именно это будет делать ZeroHTTPd. Это инструмент для обучения, а не для продакшна. Он не силён в обработке ошибок и вряд ли похвастается лучшими практиками безопасности (о да, я использовал `strcpy`) или заумными трюками языка C. Но я надеюсь, он хорошо справится со своей задачей.
*Заглавная страница ZeroHTTPd. Он может выдавать разные типы файлов, включая изображения*
Приложение гостевой книги
=========================
Современные веб-приложения обычно не ограничены статическими файлы. У них сложные взаимодействия с различными БД, кешами и т. д. Поэтому мы создадим простое веб-приложение под названием «Гостевая книга», где посетители оставляют записи под своими именами. В гостевой книге сохраняются записи, оставленные ранее. Есть также счётчик посетителей в нижней части страницы.
*Веб-приложение «Гостевая книга» ZeroHTTPd*
Счётчик посетителей и записи гостевой книги хранятся в Redis. Для коммуникаций с Redis реализованы собственные процедуры, они не зависят от внешней библиотеки. Я не большой поклонник выкатывать доморощенный код, когда есть общедоступные и хорошо протестированные решения. Но цель ZeroHTTPd — изучить производительность Linux и доступ к внешним службам, в то время как обслуживание HTTP-запросов серьёзно влияет на производительность. Мы должны полностью контролировать коммуникации с Redis в каждой из наших серверных архитектур. В одной архитектуре мы используем блокирующие вызовы, в других — процедуры на основе событий. Использование внешней клиентской библиотеки Redis не даст такой контроль. Кроме того, наш маленький клиент Redis выполняет только несколько функций (получение, настройка и увеличение ключа; получение и добавление к массиву). К тому же, протокол Redis исключительно элегантный и простой. Его даже учить специально не надо. Сам факт, что всю работу протокол выполняет примерно в ста строчках кода, говорит о том, насколько он хорошо продуман.
На следующем рисунке показаны действия приложения, когда клиент (браузер) запрашивает `/guestbookURL`.
*Механизм работы приложения гостевой книги*
Когда нужно выдать страницу гостевой книги, происходит один вызов к файловой системе для чтения шаблона в память и три сетевых вызова к Redis. Файл шаблона содержит большую часть содержимого HTML для страницы на скриншоте вверху. Там есть также специальные заполнители для динамической части контента: записей и счётчика посетителей. Мы получаем их из Redis, вставляем на страницу и выдаём клиенту полностью сформированный контент. Третьего вызова Redis можно избежать, поскольку Redis возвращает новое значение ключа при увеличении. Однако для нашего сервера с асинхронной архитектурой на основе событий множество сетевых вызовов — хорошее испытание в учебных целях. Таким образом, мы отбрасываем возвращаемое значение Redis о количестве посетителей и запрашиваем его отдельным вызовом.
Серверные архитектуры ZeroHTTPd
===============================
Мы строим семь версий ZeroHTTPd с одинаковой функциональностью, но разными архитектурами:
* Итеративная
* Форк сервер (один дочерний процесс на запрос)
* Пре-форк сервер (предварительный форкинг процессов)
* Cервер c потоками выполнения (один thread на запрос)
* Сервер с предварительным созданием потоков
* Архитектура на базе `poll()`
* Архитектура на базе `epoll`
Измеряем производительность каждой архитектуры, загрузив сервер HTTP-запросами. Но при сравнении архитектур с высокой степенью параллелизма количество запросов увеличивается. Тестируем три раза и считаем среднее.
Методология тестирования
========================
*Установка для нагрузочного тестирования ZeroHTTPd*
Важно, чтобы при выполнении тестов все компоненты не работали на одной машине. В этом случае ОС несёт дополнительные накладные расходы на планирование, поскольку компоненты соперничают за CPU. Измерение накладных расходов операционной системы с каждой из выбранных серверных архитектур является одной из наиболее важных целей этого упражнения. Добавление большего количества переменных станет пагубным для процесса. Следовательно, настройка на рисунке выше работает лучше всего.
### Что делает каждый из этих серверов
* load.unixism.net: здесь мы запускаем `ab`, утилиту Apache Benchmark. Она генерирует нагрузку, необходимую для тестирования наших серверных архитектур.
* nginx.unixism.net: иногда мы хотим запустить более одного экземпляра серверной программы. Для этого сервер Nginx с соответствующими настройками работает как балансировщик нагрузки, поступающей от *ab* на наши серверные процессы.
* zerohttpd.unixism.net: здесь мы запускаем наши серверные программы на семи различных архитектурах, по одной за раз.
* redis.unixism.net: на этом сервере работает демон Redis, где хранятся записи в гостевой книге и счётчик посетителей.
Все серверы работают на одном процессорном ядре. Идея в том, чтобы оценить максимальную производительность каждой из архитектур. Так как все серверные программы тестируются на одном оборудовании, это базовый уровень для их сравнения. Моя тестовая установка состоит из виртуальных серверов, арендованных у Digital Ocean.
### Что мы измеряем?
Можно измерить разные показатели. Мы оцениваем производительность каждой архитектуры в данной конфигурации, загружая серверы запросами на разных уровнях параллелизма: нагрузка растёт от 20 до 15 000 одновременных пользователей.
Результаты тестов
=================
На следующей диаграмме показана производительность серверов на разной архитектуре при различных уровнях параллелизма. По оси y — количество запросов в секунду, по оси x — параллельные соединения.
Ниже таблица с результатами.
| | |
| --- | --- |
| | запросов в секунду |
| **параллелизм** | **итеративный** | **форк** | **пре-форк** | **потоковый** | **пре-потоковый** | **poll** | **epoll** |
| 20 | 7 | 112 | 2100 | 1800 | 2250 | 1900 | 2050 |
| 50 | 7 | 190 | 2200 | 1700 | 2200 | 2000 | 2000 |
| 100 | 7 | 245 | 2200 | 1700 | 2200 | 2150 | 2100 |
| 200 | 7 | 330 | 2300 | 1750 | 2300 | 2200 | 2100 |
| 300 | – | 380 | 2200 | 1800 | 2400 | 2250 | 2150 |
| 400 | – | 410 | 2200 | 1750 | 2600 | 2000 | 2000 |
| 500 | – | 440 | 2300 | 1850 | 2700 | 1900 | 2212 |
| 600 | – | 460 | 2400 | 1800 | 2500 | 1700 | 2519 |
| 700 | – | 460 | 2400 | 1600 | 2490 | 1550 | 2607 |
| 800 | – | 460 | 2400 | 1600 | 2540 | 1400 | 2553 |
| 900 | – | 460 | 2300 | 1600 | 2472 | 1200 | 2567 |
| 1000 | – | 475 | 2300 | 1700 | 2485 | 1150 | 2439 |
| 1500 | – | 490 | 2400 | 1550 | 2620 | 900 | 2479 |
| 2000 | – | 350 | 2400 | 1400 | 2396 | 550 | 2200 |
| 2500 | – | 280 | 2100 | 1300 | 2453 | 490 | 2262 |
| 3000 | – | 280 | 1900 | 1250 | 2502 | большой разброс | 2138 |
| 5000 | – | большой разброс | 1600 | 1100 | 2519 | – | 2235 |
| 8000 | – | – | 1200 | большой разброс | 2451 | – | 2100 |
| 10 000 | – | – | большой разброс | – | 2200 | – | 2200 |
| 11 000 | – | – | – | – | 2200 | – | 2122 |
| 12 000 | – | – | – | – | 970 | – | 1958 |
| 13 000 | – | – | – | – | 730 | – | 1897 |
| 14 000 | – | – | – | – | 590 | – | 1466 |
| 15 000 | – | – | – | – | 532 | – | 1281 |
Из графика и таблицы видно, что выше 8000 одновременных запросов у нас остаётся только две игрока: пре-форк и epoll. С ростом нагрузки сервер на базе poll работает хуже, чем потоковый. Архитектура с предварительным созданием потоков составляет достойную конкуренцию epoll: это свидетельство, насколько хорошо ядро Linux планирует большое количество потоков.
Исходный код ZeroHTTPd
======================
Исходный код ZeroHTTPd [здесь](https://github.com/shuveb/zerohttpd). Для каждой архитектуры отдельный каталог.
```
ZeroHTTPd
│
├── 01_iterative
│ ├── main.c
├── 02_forking
│ ├── main.c
├── 03_preforking
│ ├── main.c
├── 04_threading
│ ├── main.c
├── 05_prethreading
│ ├── main.c
├── 06_poll
│ ├── main.c
├── 07_epoll
│ └── main.c
├── Makefile
├── public
│ ├── index.html
│ └── tux.png
└── templates
└── guestbook
└── index.html
```
Кроме семи директорий для всех архитектур, в каталоге верхнего уровня есть ещё две: public и templates. В первом лежит файл index.html и изображение с первого скриншота. Туда можно поместить другие файлы и папки, и ZeroHTTPd должен без проблем выдать эти статические файлы. Если path в браузере соответствует пути в папке public, то ZeroHTTPd ищет в этом каталоге файл index.html. Контент для гостевой книги генерируется динамически. У него только главная страница, а её содержимое основано на файле 'templates/guestbook/index.html'. В ZeroHTTPd легко добавляются динамические страницы для расширения. Идея заключается в том, что пользователи могут добавлять в этом каталог шаблоны и расширять ZeroHTTPd по мере необходимости.
Для сборки всех семи серверов запустите `make all` из каталога верхнего уровня — и все билды появятся в этом каталоге. Исполняемые файлы ищут каталоги public и templates в том каталоге, откуда они запускаются.
Linux API
=========
Чтобы понять информацию в этом цикле статей, не обязательно хорошо разбираться в Linux API. Однако рекомендую прочитать больше на эту тему, в Сети много справочных ресурсов. Хотя мы коснёмся нескольких категорий Linux API, наше внимание будет сосредоточено в основном на процессах, потоках, событиях и сетевом стеке. Кроме книг и статей про Linux API, рекомендую также почитать маны для системных вызовов и используемых библиотечных функций.
Производительность и масштабируемость
=====================================
Одно замечание о производительности и масштабируемости. Теоретически между ними нет никакой связи. У вас может быть веб-сервис, который работает очень хорошо, с временем отклика в несколько миллисекунд, но он вообще не масштабируется. Точно так же может быть плохо работающее веб-приложение, которое требует несколько секунд для ответа, но оно масштабируется на десятки для обработки десятков тысяч одновременных пользователей. Тем не менее, сочетание высокой производительности и масштабируемости — очень мощное сочетание. Высокопроизводительные приложения в целом экономно используют ресурсы и, таким образом, эффективно обслуживают больше одновременных пользователей на сервере, снижая затраты.
Задачи CPU и I/O
================
Наконец, в вычислениях всегда два возможных типа задач: для I/O и CPU. Получение запросов через интернет (сетевой ввод-вывод), обслуживание файлов (сетевой и дисковый ввод-вывод), коммуникации с базой данных (сетевой и дисковый ввод-вывод) — всё это действия I/O. Некоторые запросы к БД могут немного нагружать CPU (сортировка, вычисление среднего значения миллиона результатов и т. д.). Большинство веб-приложений ограничены по максимально возможному I/O, а процессор редко используется на полную мощность. Когда вы видите, что в какой-то задаче ввода-вывода используется много CPU, скорее всего, это признак плохой архитектуры приложения. Это может означать, что ресурсы CPU тратятся на управление процессами и переключение контекста — и это не совсем полезно. Если вы делаете что-то вроде обработки изображений, преобразования аудиофайлов или машинного обучения, тогда приложение требует мощных ресурсов CPU. Но для большинства приложений это не так.
Более подробно о серверных архитектурах
=======================================
1. [Часть I. Итеративная архитектура](http://unixism.net/2019/04/28/linux-applications-performance-part-i-iterative-servers/)
2. [Часть II. Форк-серверы](http://unixism.net/2019/04/28/linux-applications-performance-part-ii-forking-servers/)
3. [Часть III. Пре-форк серверы](http://unixism.net/2019/04/28/linux-applications-performance-part-iii-preforked-servers/)
4. [Часть IV. Cерверы c потоками выполнения](http://unixism.net/2019/04/28/linux-applications-performance-part-iv-threaded-servers/)
5. [Часть V. Серверы с предварительным созданием потоков](http://unixism.net/2019/04/28/linux-applications-performance-part-v-pre-threaded-servers/)
6. [Часть VI. Архитектура на базе poll](http://unixism.net/2019/04/28/linux-applications-performance-part-vi-polling-servers/)
7. [Часть VII. Архитектура на базе epoll](http://unixism.net/2019/04/28/linux-applications-performance-part-vii-epoll-servers/) | https://habr.com/ru/post/455212/ | null | ru | null |
# Пишем простой интерпретатор на C++ с помощью TDD, часть 1
#### Введение
Многие C++ программисты слышали про разработку через тестирование. Но почти все материалы по данной теме касаются более высокоуровневых языков и сосредоточены больше на общей теории, чем на практике. Итак, в данной статье я попробую привести пример пошаговой разработки через тестирование небольшого проекта на C++. А именно, как можно предположить из названия, простого интерпретатора математических выражений. Такой проект также является неплохой code kata, так как на его выполнение затрачивается не более часа (если не писать параллельно статью об этом).
#### Архитектура
Несмотря на то, что при использовании TDD архитектура приложения постепенно проявляется сама собой, начальная её проработка всё же необходима. Благодаря этому может значительно снизиться общее время, затраченное на реализацию. Это особенно эффективно в тех случаях, когда существуют готовые примеры подобных систем, которые можно взять за образец. В данном случае, существует вполне устоявшееся мнение о том, как должны быть устроены [компиляторы и интерпретаторы](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%82%D0%BE%D1%80), чем и можно воспользоваться.
Существует множество библиотек и инструментов, которые могут облегчить разработку интерпретаторов и компиляторов. Начиная от Boost.Spirit и заканчивая ANTLR и Bison. Можно даже запустить канал интерпретатора командной строки через `popen` и вычислить выражение через него. Целью данной статье является пошаговая разработка достаточно сложной системы с помощью TDD, поэтому будет использоваться только стандартная библиотека C++ и встроенный в IDE тестовый фреймворк.
Для начала, составим список того, что должен уметь наш простой интерпретатор, в порядке убывания приоритета:
* Вычислять значение математического выражения, состоящего из чисел с плавающий точкой и математических операторов (-+/\*).
* Учёт приоритета операторов.
* Учёт скобок.
* Унарные плюс и минус.
* Вычисление нескольких выражений, разделённых точкой с запятой (;).
* Встроенные константы (pi, e).
* Создание собственных констант с помощью оператора присваивания (=).
* Встроенные функции с переменным числом аргументов.
* Задание новых функций.
В данной статье будет реализация только первых трёх пунктов. Сам проект концептуально будет состоять из четырёх частей:
* Лексический анализатор. Преобразовывает входную строку в последовательность токенов.
* Синтаксический анализатор. Строит из токенов синтаксическое представление в виде [постфиксной нотации](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%81%D1%82%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D0%BD%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D1%8F). Делать это будем без рекурсии и таблиц, с помощью [алгоритма сортировочной станции](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D1%87%D0%BD%D0%BE%D0%B9_%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D0%B8).
* Вычислитель. Вычисляет результат выражения на стековой машине.
* Собственно, интерпретатор. Служит фасадом для вышеперечисленных частей.
#### Инструментарий
Программа будет писаться в Visual Studio 2013 с установленным [Visual C++ Compiler Nov 2013 CTP](http://www.microsoft.com/en-us/download/details.aspx?id=41151). Тесты будут на основе встроенного в студию тестового фреймворка для C++ проектов [CppUnitTestFramework](http://msdn.microsoft.com/library/hh694604.aspx). Он предоставляет минимальную поддержку для написания модульных тестов (по сравнению с Boost.Test, или CppUTest), но, с другой стороны, хорошо интегрирован в среду разработки. Альтернативой может служить Eclipse с установленным плагином C/C++ Unit и настроенным Boost.Test, GTest, или QtTest. В такой конфигурации рекомендую использовать clang, так как он предоставляет несколько мощнейших compile- и runtime анализаторов, в результате чего, в связке с TDD, код становится совершенно неуязвимым для ошибок.
Итак, создадим новый проект типа «Native Unit Test Project» и удостоверимся, что всё компилируется.
#### Лексер
Начнём с разработки лексера. Будем следовать привычному для TDD циклу Red-Green-Refactor:
1. Написать тест и заставить его падать (Red).
2. Заставить его пройти (Green).
3. Улучшить дизайн (Refactor).
Напишем первый тест, поместив его в класс `LexerTests`. Я буду пользоваться такой техникой, как список тестов, в который будут записываться те тесты, которые я планирую написать следующими. Также в него заносятся мысли о предстоящих тестах, которые часто возникают во время написания текущего теста и не могут быть реализованы сразу же:
* В ответ на пустое выражение, должен возвращаться пустой список токенов.
Я привык писать названия тестов в BDD стиле. Каждый тест начинается со слова `Should`, в качестве субъекта подразумевается то, что упомянуто в названии класса. То есть Lexer … should … сделать A в ответ на B. Это фокусирует тест на небольшом аспекте поведения и не даёт ему расти в объёме.
```
TEST_CLASS(LexerTests) {
public:
TEST_METHOD(Should_return_empty_token_list_when_put_empty_expression) {
Tokens tokens = Lexer::Tokenize("");
Assert::IsTrue(tokens.empty());
}
};
```
В CppUnitTestFramework макрос `TEST_CLASS` генерирует класс, в котором будут размещаться тестовые методы. Макрос `TEST_METHOD`, соответственно, создаёт сам тестовый метод. Необходимо учесть, что экземпляр класса создаётся только один раз перед запуском всех находящихся в нём тестов. В Boost.Test, к примеру, экземпляр класса создаётся каждый раз заново перед запуском каждого теста. Следовательно, тот, код, который необходимо выполнить перед каждым тестом, будет помещаться в метод, объявленный с помощью макроса `TEST_METHOD_INITIALIZE`, а тот, который после, в `TEST_METHOD_CLEANUP`. Все методы утверждений являются статическими и располагаются в классе `Assert`. Их немного, но основную функциональность они покрывают.
Вернёмся к нашему тесту. Он не то, чтобы не проходит, он даже не компилируется. Создадим функцию `Tokenize` в пространстве имён `Lexer`, принимающую строку и возвращающую `std::vector`, скрытый для удобства за псевдонимом `Tokens`. Я решил пока что не создавать дополнительные классы и ограничиться обычной функцией.
```
#pragma once;
#include
namespace Interpreter {
struct Token {};
typedef std::vector Tokens;
namespace Lexer {
inline Tokens Tokenize(std::string expr) { throw std::exception(); }
} // namespace Lexer
} // namespace Interpreter
```
Сейчас проект компилируется, но тест, что было ожидаемо, падает. Для определения того, что же писать дальше, можно воспользоваться техникой [The Transformation Priority Premise (TPP)](http://web.archive.org/web/20130113152824/http://cleancoder.posterous.com/the-transformation-priority-premise) авторства Роберта Мартина. Трансформации являются аналогами рефакторингов, но, в отличии от них, используются для изменения поведения кода, тогда как рефакторинг к изменению поведения не приводит. Каждая трансформация ведёт к изменению кода от более конкретного к более общему. Главная их особенность в том, что они имеют разные приоритеты, в зависимости от которых выбирается то, какой код писать для прохождения теста и какой будет следующий тест. А именно, те трансформации, которые проще (располагаются выше в списке) должны быть более предпочтительны, чем те, которые снизу. При намерении создать новый тест, выбирается такой, что для его прохождения нужно применить более простую трансформацию. Это не является строгим правилом, но следование TPP может вести к более простому коду за меньшее количество шагов.
Сам список трансформаций:
1. ({} → nil) Заменить отсутствие кода на код, использующий нулевое значение.
2. (nil → constant) Заменить нулевое значение константой.
3. (constant → constant+) Заменить простую константу более сложной (строку из одной буквы на строку из нескольких букв, к примеру).
4. (constant → scalar) Заменить константу на переменную, или аргумент.
5. (statement → statements) Добавить безусловный оператор (break, continue, return и подобное).
6. (unconditional → if) Разбить поток выполнения с помощью условного оператора.
7. (scalar → array) Заменить переменную/аргумент массивом.
8. (array → container) Заменить массив более сложным контейнером.
9. (statement → recursion) Заменить выражение рекурсией.
10. (if → while) Заменить условный оператор циклом.
11. (expression → function) Заменить выражение функцией.
12. (variable → assignment) Изменить значение переменной.
Применим первую трансформацию для прохождения написанного выше теста.
```
inline Tokens Tokenize(std::string expr) { return{}; }
```
Посмотрим, что должен уметь лексер для выполнения первого пункта требований. Занесём это в список тестов.
* ~~В ответ на пустое выражение должен возвращаться пустой список токенов~~.
* В ответ на строку с оператором должен возвращаться токен с оператором.
* В ответ на строку с цифрой должен возвращаться токен с числом.
* В ответ на строку с числом с плавающей точкой должен возвращаться токен с этим числом.
* В ответ на строку с простым выражением должен возвращаться список соответствующих токенов.
* Пробелы между числами и операторами должны игнорироваться.
Отрефакторим код, заменив `std::string` на `std::wstring`. Это будет полезно для упрощения интеграции с тестовым фреймворком, так как он принимает только Unicode. Напишем тест из второго пункта.
```
TEST_METHOD(Should_tokenize_single_plus_operator) {
Tokens tokens = Lexer::Tokenize(L"+");
AssertRange::AreEqual({ Operator::Plus }, tokens);
}
```
Здесь `AssertRange` — это пространство имён, в которое я поместил функцию утверждения `AreEqual`, сравнивающую две последовательности, а точнее, список инициализации и последовательность.
**AssertRange**
```
namespace AssertRange {
template
static void AreEqual(initializer\_list expect, const ActualRange &actual) {
auto actualIter = begin(actual);
auto expectIter = begin(expect);
Assert::AreEqual(distance(expectIter, end(expect)), distance(actualIter, end(actual)), L"Size differs.");
for(; expectIter != end(expect) && actualIter != end(actual); ++expectIter, ++actualIter) {
auto message = L"Mismatch in position " + to\_wstring(distance(begin(expect), expectIter));
Assert::AreEqual(\*expectIter, \*actualIter, message.c\_str());
}
}
} // namespace AssertRange
```
Также пришлось изменить определение токена и добавить перечисление `Operator` с названиями арифметических операторов. Можно было бы использовать для этой цели просто тип `wchar_t` с символом оператора, но тогда в будущем придётся иметь дело с тем, как различать бинарные и унарные операции.
```
enum class Operator : wchar_t {
Plus = L'+',
};
typedef Operator Token;
```
Для успешной компиляции тестов, для каждого класса, экземпляр которого передаётся в статические методы класса `Assert`, необходимо определить функцию `ToString`, возвращающий его строковое представление.
**std::wstring ToString(const Token &)**
```
inline std::wstring ToString(const Token &token) {
return{ static_cast(token) };
}
```
После этого тест компилируется, но не проходит, так как мы продолжаем возвращать пустую последовательность токенов. Исправим это, применив трансформацию (unconditional → if).
```
inline Tokens Tokenize(std::wstring expr) {
if(expr.empty()) { return{}; }
return{ static_cast(expr[0]) };
}
```
* ~~В ответ на пустое выражение должен возвращаться пустой список токенов~~.
* ~~В ответ на строку с оператором должен возвращаться токен с оператором.~~
* В ответ на строку с цифрой должен возвращаться токен с числом.
* …
Теперь третий тест.
```
TEST_METHOD(Should_tokenize_single_digit) {
Tokens tokens = Lexer::Tokenize(L"1");
AssertRange::AreEqual({ 1.0 }, tokens);
}
```
Здесь возникает проблема представления токенов. С одной стороны, они должны хранить коды операторов, с другой — числа. Решений в данном случае, несколько:
* Создать два класса токенов для операторов и числе, унаследовав их от общего класса `Token`. После этого приводить его с помощью `dynamic_cast` для извлечения кода числа, или кода оператора.
* То же, что в варианте выше, но вместо каста использовать двойную диспетчеризацию.
* В качестве токенов может быть `std::function` в которой будет храниться замыкание с необходимыми данными. Получать данные из замыкания можно с помощью посетителя.
* Использовать Boost.Any, или что-либо подобное.
* Использовать обычную структуру с полями для каждого вида данный и флагом типа.
Выберем последний вариант, как наиболее простой. Потом всегда можно перейти на что-то более сложное. Чтобы удостовериться, что токен хранит данные должным образом, добавим несколько тестов в наш список.
* …
* Создать токен с оператором и получить его тип.
* Создать токен с числом и получить его тип.
* Создать токен с оператором и получить этот оператор.
* Создать токен с числом и получить это число.
Временно закомментируем тесты для лексера и добавит тест для токена в новый класс.
```
enum class TokenType {
Operator,
Number
};
class Token {
public:
Token(Operator) {}
TokenType Type() const { return TokenType::Operator; }
};
…
TEST_CLASS(TokenTests) {
public:
TEST_METHOD(Should_get_type_for_operator_token) {
Token opToken(Operator::Plus);
Assert::AreEqual(TokenType::Operator, opToken.Type());
}
};
```
Добавив метод `ToString` для перечисления `TokenType` и подправив аналогичный метод для самого токена, заставим всё компилироваться, а тесты проходить. Напишем следующий тест из списка.
```
TEST_METHOD(Should_get_type_for_number_token) {
Token numToken(1.2);
Assert::AreEqual(TokenType::Number, numToken.Type());
}
```
Он не проходит. Примени трансформацию (constant → scalar) для класса токена.
```
class Token {
public:
Token(Operator) :m_type(TokenType::Operator) {}
Token(double) :m_type(TokenType::Number) {}
TokenType Type() const { return m_type; }
private:
TokenType m_type;
};
```
* …
* ~~Создать токен с оператором и получить его тип~~.
* ~~Создать токен с числом и получить его тип~~.
* Создать токен с оператором и получить этот оператор.
* Создать токен с числом и получить это число.
Теперь реализуем оставшиеся тесты.
```
TEST_METHOD(Should_get_operator_code_from_operator_token) {
Token token(Operator::Plus);
Assert::AreEqual(Operator::Plus, token);
}
```
Для удобства преобразования токена к нужному типу будем использовать оператор неявного приведения.
```
class Token {
public:
Token(Operator op) :m_type(TokenType::Operator), m_operator(op) {}
operator Operator() const { return m_operator; }
…
Operator m_operator;
};
```
Аналогично напишем тест для числового токена.
```
TEST_METHOD(Should_get_number_value_from_number_token) {
Token token(1.23);
Assert::AreEqual(1.23, token);
}
```
Так как в токене не может одновременно храниться и оператор, и число, то их поля можно объединить в `union`. Также добавим проверку на операцию приведения к неверному типу.
**Token**
```
class Token {
public:
Token(Operator op) :m_type(TokenType::Operator), m_operator(op) {}
Token(double num) :m_type(TokenType::Number), m_number(num) {}
TokenType Type() const { return m_type; }
operator Operator() const {
if(m_type != TokenType::Operator) throw std::logic_error("Should be operator token.");
return m_operator;
}
operator double() const {
if(m_type != TokenType::Number) throw std::logic_error("Should be number token.");
return m_number;
}
private:
TokenType m_type;
union {
Operator m_operator;
double m_number;
};
};
inline std::wstring ToString(const Token &token) {
switch(token.Type()) {
case TokenType::Number: return std::to_wstring(static_cast(token));
case TokenType::Operator: return ToString(static\_cast(token));
default: return "Unknown token.";
}
}
```
Все тесты, относящиеся к токену проходят, можно восстановить предыдущие тесты и убедиться, что ничего не сломалось. Последний тест всё так же не проходит. Приступим к его исправлению.
* *В ответ на строку с цифрой должен возвращаться токен с числом.*
* В ответ на строку с числом с плавающей точкой должен возвращаться токен с этим числом.
* В ответ на строку с простым выражением должен возвращаться список соответствующих токенов.
* Пробелы между числами и операторами должны игнорироваться.
Для прохождения теста добавим ещё одно условное выражение:
```
if(expr[0] >= '0' && expr[0] <= '9') {
return{ (double) expr[0] - '0' };
}
return{ static_cast(expr[0]) };
```
Выгладит пока что не очень симпатично, но тест проходит.
* …
* ~~В ответ на строку с цифрой должен возвращаться токен с числом.~~
* *В ответ на строку с числом с плавающей точкой должен возвращаться токен с этим числом.*
```
TEST_METHOD(Should_tokenize_floating_point_number) {
Tokens tokens = Lexer::Tokenize(L"12.34");
AssertRange::AreEqual({ 12.34 }, tokens);
}
```
Вспомним, что в стандартной библиотеке `C` есть такие функции, как `isdigit`, проверяющая, что данный символ является цифрой и `atof`, преобразующая строку в число, а также их аналоги для `wchar_t`. Применим (expression → function). После этого небольшого изменения данный тест также начал проходить.
```
inline Tokens Tokenize(std::wstring expr) {
const wchar_t *current = expr.c_str();
if(!*current) return{};
if(iswdigit(*current)) return{ _wtof(current) };
return{ static_cast(\*current) };
}
```
После этого можно приступить и к более сложным тестам. Попробуем обработать полюс и число одновременно.
```
TEST_METHOD(Should_tokenize_plus_and_number) {
Tokens tokens = Lexer::Tokenize(L"+12.34");
AssertRange::AreEqual({ Token(Operator::Plus), Token(12.34) }, tokens);
}
```
Тест не компилируется, так как не хватает оператора сравнения для токена. Исправим это, теперь тест просто не проходит. Для начала сделаем небольшой рефакторинг. Добавим переменную `result`, в которую будем помещать токены.
```
inline Tokens Tokenize(std::wstring expr) {
Tokens result;
const wchar_t *current = expr.c_str();
if(!*current) return result;
if(iswdigit(*current)) {
result.push_back(_wtof(current));
}
else {
result.push_back(static_cast(\*current));
}
return result;
}
```
Теперь заставить пройти тест довольно просто: применим трансформацию (if → while). Можно было бы использовать рекурсию, но я решил целенаправленно делать не рекурсивный алгоритм.
```
inline Tokens Tokenize(std::wstring expr) {
Tokens result;
const wchar_t *current = expr.c_str();
while(*current) {
if(iswdigit(*current)) {
wchar_t *end = nullptr;
result.push_back(wcstod(current, &end));
current = end;
}
else {
result.push_back(static_cast(\*current));
++current;
}
}
return result;
}
```
Функция `wcstod` делает то же самое, что и `_wtof`, но также возвращает указатель на следующий за числом символ в строке. Так как все операторы на данный момент состоят из одного символа, то во втором случае просто передвигаем указатель на текущий символ на одну позицию вперёд. Как видим, теперь все тесты проходят.
* ~~В ответ на строку с простым выражением должен возвращаться список соответствующих токенов.~~
* Пробелы между числами и операторами должны игнорироваться.
Разберёмся с пробелами.
```
TEST_METHOD(Should_skip_spaces) {
Tokens tokens = Lexer::Tokenize(L" 1 + 12.34 ");
AssertRange::AreEqual({ Token(1.0), Token(Operator::Plus), Token(12.34) }, tokens);
}
```
Применим (unconditional → if) добавив проверку на то, что символ является оператором.
```
while(*current) {
if(iswdigit(*current)) {
wchar_t *end = nullptr;
result.push_back(wcstod(current, &end));
current = end;
}
else if(*current == static_cast(Operator::Plus)) {
result.push\_back(static\_cast(\*current));
++current;
}
else {
++current;
}
}
```
На данном этапе проведём рефакторинг данной функции. Выделим логику в отдельный класс и разобьём на отдельный методы. Поместим этот класс в пространство имён `Detail` чтобы не засорять публичный интерфейс лексера. Теперь функция `Tokenize` просто будет служить фасадом для модуля лексера.
```
inline Tokens Tokenize(const std::wstring &expr) {
Detail::Tokenizer tokenizer(expr);
tokenizer.Tokenize();
return tokenizer.Result();
}
```
**Класс Detail::Tokenizer**
```
namespace Detail {
class Tokenizer {
public:
Tokenizer(const std::wstring &expr) : m_current(expr.c_str()) {}
void Tokenize() {
while(!EndOfExperssion()) {
if(IsNumber()) {
ScanNumber();
}
else if(IsOperator()) {
ScanOperator();
}
else {
MoveNext();
}
}
}
const Tokens &Result() const { return m_result; }
private:
bool EndOfExperssion() const { return *m_current == L'\0'; }
bool IsNumber() const { return iswdigit(*m_current) != 0; }
void ScanNumber() {
wchar_t *end = nullptr;
m_result.push_back(wcstod(m_current, &end));
m_current = end;
}
bool IsOperator() const { return *m_current == static_cast(Operator::Plus); }
void ScanOperator() {
m\_result.push\_back(static\_cast(\*m\_current));
MoveNext();
}
void MoveNext() { ++m\_current; }
const wchar\_t \*m\_current;
Tokens m\_result;
};
} // namespace Detail
```
Как видно, извлечение класса сделало код гораздо понятнее. Без тестов такой рефакторинг был бы, как минимум, рискованным. Теперь добавим поддержку скобок и остальных операторов.
```
TEST_METHOD(Should_tokenize_complex_experssion) {
Tokens tokens = Lexer::Tokenize(L"1+2*3/(4-5)");
AssertRange::AreEqual({
Token(1), Token(Operator::Plus), Token(2), Token(Operator::Mul), Token(3), Token(Operator::Div),
Token(Operator::LParen), Token(4), Token(Operator::Minus), Token(5), Token(Operator::RParen)
}, tokens);
}
```
Добавим необходимые операторы к перечислению `Operator`, чтобы заставить тест компилироваться.
```
enum class Operator : wchar_t {
Plus = L'+',
Minus = L'-',
Mul = L'*',
Div = L'/',
LParen = L'(',
RParen = L')',
};
```
Тест не проходит. Чтобы это исправить необходимо всего лишь изменить метод `IsOperator` класса `Tokenizer`.
```
bool IsOperator() const {
auto all = { Operator::Plus, Operator::Minus, Operator::Mul, Operator::Div, Operator::LParen, Operator::RParen };
return std::any_of(all.begin(), all.end(), [this](Operator o) {return *m_current == static_cast(o); });
}
```
Все тесты проходят и можно приступить к написанию парсера. Ниже приводится весь исходный код на данный момент.
**Interpreter.h**
```
#pragma once;
#include
#include
#include
namespace Interpreter {
enum class Operator : wchar\_t {
Plus = L'+',
Minus = L'-',
Mul = L'\*',
Div = L'/',
LParen = L'(',
RParen = L')',
};
inline std::wstring ToString(const Operator &op) {
return{ static\_cast(op) };
}
enum class TokenType {
Operator,
Number
};
inline std::wstring ToString(const TokenType &type) {
switch(type) {
case TokenType::Operator:
return L"Operator";
case TokenType::Number:
return L"Number";
default:
throw std::out\_of\_range("TokenType");
}
}
class Token {
public:
Token(Operator op) :m\_type(TokenType::Operator), m\_operator(op) {}
Token(double num) :m\_type(TokenType::Number), m\_number(num) {}
TokenType Type() const { return m\_type; }
operator Operator() const {
if(m\_type != TokenType::Operator) throw std::logic\_error("Should be operator token.");
return m\_operator;
}
operator double() const {
if(m\_type != TokenType::Number) throw std::logic\_error("Should be number token.");
return m\_number;
}
friend inline bool operator==(const Token &left, const Token &right) {
if(left.m\_type == right.m\_type) {
switch(left.m\_type) {
case Interpreter::TokenType::Operator:
return left.m\_operator == right.m\_operator;
case Interpreter::TokenType::Number:
return left.m\_number == right.m\_number;
default: throw std::out\_of\_range("TokenType");
}
}
return false;
}
private:
TokenType m\_type;
union {
Operator m\_operator;
double m\_number;
};
};
inline std::wstring ToString(const Token &token) {
switch(token.Type()) {
case TokenType::Number:
return std::to\_wstring(static\_cast(token));
case TokenType::Operator:
return ToString(static\_cast(token));
default: throw std::out\_of\_range("TokenType");
}
}
typedef std::vector Tokens;
namespace Lexer {
namespace Detail {
class Tokenizer {
public:
Tokenizer(const std::wstring &expr) : m\_current(expr.c\_str()) {}
void Tokenize() {
while(!EndOfExperssion()) {
if(IsNumber()) {
ScanNumber();
}
else if(IsOperator()) {
ScanOperator();
}
else {
MoveNext();
}
}
}
const Tokens &Result() const {
return m\_result;
}
private:
bool EndOfExperssion() const { return \*m\_current == L'\0'; }
bool IsNumber() const { return iswdigit(\*m\_current) != 0; }
void ScanNumber() {
wchar\_t \*end = nullptr;
m\_result.push\_back(wcstod(m\_current, &end));
m\_current = end;
}
bool IsOperator() const {
auto all = { Operator::Plus, Operator::Minus, Operator::Mul, Operator::Div, Operator::LParen, Operator::RParen };
return std::any\_of(all.begin(), all.end(), [this](Operator o) {return \*m\_current == static\_cast(o); });
}
void ScanOperator() {
m\_result.push\_back(static\_cast(\*m\_current));
MoveNext();
}
void MoveNext() { ++m\_current; }
const wchar\_t \*m\_current;
Tokens m\_result;
};
} // namespace Detail
inline Tokens Tokenize(const std::wstring &expr) {
Detail::Tokenizer tokenizer(expr);
tokenizer.Tokenize();
return tokenizer.Result();
}
} // namespace Lexer
} // namespace Interpreter
```
**InterpreterTests.cpp**
```
#include "stdafx.h"
#include "CppUnitTest.h"
#include "Interpreter.h"
namespace InterpreterTests {
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Interpreter;
using namespace std;
namespace AssertRange {
template
static void AreEqual(initializer\_list expect, const ActualRange &actual) {
auto actualIter = begin(actual);
auto expectIter = begin(expect);
Assert::AreEqual(distance(expectIter, end(expect)), distance(actualIter, end(actual)), L"Size differs.");
for(; expectIter != end(expect) && actualIter != end(actual); ++expectIter, ++actualIter) {
auto message = L"Mismatch in position " + to\_wstring(distance(begin(expect), expectIter));
Assert::AreEqual(\*expectIter, \*actualIter, message.c\_str());
}
}
} // namespace AssertRange
TEST\_CLASS(LexerTests) {
public:
TEST\_METHOD(Should\_return\_empty\_token\_list\_when\_put\_empty\_expression) {
Tokens tokens = Lexer::Tokenize(L"");
Assert::IsTrue(tokens.empty());
}
TEST\_METHOD(Should\_tokenize\_single\_plus\_operator) {
Tokens tokens = Lexer::Tokenize(L"+");
AssertRange::AreEqual({ Operator::Plus }, tokens);
}
TEST\_METHOD(Should\_tokenize\_single\_digit) {
Tokens tokens = Lexer::Tokenize(L"1");
AssertRange::AreEqual({ 1.0 }, tokens);
}
TEST\_METHOD(Should\_tokenize\_floating\_point\_number) {
Tokens tokens = Lexer::Tokenize(L"12.34");
AssertRange::AreEqual({ 12.34 }, tokens);
}
TEST\_METHOD(Should\_tokenize\_plus\_and\_number) {
Tokens tokens = Lexer::Tokenize(L"+12.34");
AssertRange::AreEqual({ Token(Operator::Plus), Token(12.34) }, tokens);
}
TEST\_METHOD(Should\_skip\_spaces) {
Tokens tokens = Lexer::Tokenize(L" 1 + 12.34 ");
AssertRange::AreEqual({ Token(1.0), Token(Operator::Plus), Token(12.34) }, tokens);
}
TEST\_METHOD(Should\_tokenize\_complex\_experssion) {
Tokens tokens = Lexer::Tokenize(L"1+2\*3/(4-5)");
AssertRange::AreEqual({
Token(1), Token(Operator::Plus), Token(2), Token(Operator::Mul), Token(3), Token(Operator::Div),
Token(Operator::LParen), Token(4), Token(Operator::Minus), Token(5), Token(Operator::RParen)
}, tokens);
}
};
TEST\_CLASS(TokenTests) {
public:
TEST\_METHOD(Should\_get\_type\_for\_operator\_token) {
Token opToken(Operator::Plus);
Assert::AreEqual(TokenType::Operator, opToken.Type());
}
TEST\_METHOD(Should\_get\_type\_for\_number\_token) {
Token numToken(1.2);
Assert::AreEqual(TokenType::Number, numToken.Type());
}
TEST\_METHOD(Should\_get\_operator\_code\_from\_operator\_token) {
Token token(Operator::Plus);
Assert::AreEqual(Operator::Plus, token);
}
TEST\_METHOD(Should\_get\_number\_value\_from\_number\_token) {
Token token(1.23);
Assert::AreEqual(1.23, token);
}
};
}
```
[Код к статье на GitHub](https://github.com/Unril/InterpreterTDD/releases/tag/%D0%9A%D0%BE%D0%BD%D0%B5%D1%86_%D0%BF%D0%B5%D1%80%D0%B2%D0%BE%D0%B9_%D1%87%D0%B0%D1%81%D1%82%D0%B8). Названия коммитов и их порядок соответствуют тестам и рефакторингам, описанным выше. Окончанию первой части соответствует метка «Конец\_первой\_части».
Разработка парсера [будет рассмотрена во второй части](http://habrahabr.ru/post/232081/). Разработка вычислителя и фасада для парсера, а также рефакторинг всего кода [будут рассмотрены в третьей части](http://habrahabr.ru/post/232097/). | https://habr.com/ru/post/231657/ | null | ru | null |
# Кортеж здорового человека
Эта статья — об одном из лучших изобретений Python: именованном кортеже (namedtuple). Мы рассмотрим его приятные особенности, от известных до неочевидных. Уровень погружения в тему будет нарастать постепенно, так что, надеюсь, каждый найдёт для себя что-то интересное. Поехали!
Введение
--------
Наверняка вы сталкивались с ситуацией, когда нужно передать несколько свойств объекта одним куском. Например, информацию о домашнем питомце: тип, кличка и возраст.
Часто создавать отдельный класс под это дело лень, и используют кортежи:
```
("pigeon", "Френк", 3)
("fox", "Клер", 7)
("parrot", "Питер", 1)
```
Для большей наглядности подойдёт именованный кортеж — `collections.namedtuple`:
```
from collections import namedtuple
Pet = namedtuple("Pet", "type name age")
frank = Pet(type="pigeon", name="Френк", age=3)
>>> frank.age
3
```
Это все знают ツ А вот несколько менее известных особенностей:
Быстрое изменение полей
-----------------------
Что делать, если одно из свойств надо изменить? Френк стареет, а кортеж-то неизменяемый. Чтобы не пересоздавать его целиком, придумали метод `_replace()`:
```
>>> frank._replace(age=4)
Pet(type='pigeon', name='Френк', age=4)
```
А если хотите сделать всю структуру изменяемой — `_asdict()`:
```
>>> frank._asdict()
OrderedDict([('type', 'pigeon'), ('name', 'Френк'), ('age', 3)])
```
Автоматическая замена названий
------------------------------
Допустим, вы импортируете данные из CSV и превращаете каждую строчку в кортеж. Названия полей взяли из заголовка CSV-файла. Но что-то идёт не так:
```
# headers = ("name", "age", "with")
>>> Pet = namedtuple("Pet", headers)
ValueError: Type names and field names cannot be a keyword: 'with'
# headers = ("name", "age", "name")
>>> Pet = namedtuple("Pet", headers)
ValueError: Encountered duplicate field name: 'name'
```
Решение — аргумент `rename=True` в конструкторе:
```
# headers = ("name", "age", "with", "color", "name", "food")
Pet = namedtuple("Pet", headers, rename=True)
>>> Pet._fields
('name', 'age', '_2', 'color', '_4', 'food')
```
«Неудачные» названия переименовались в соответствии с порядковыми номерами.
Значения по умолчанию
---------------------
Если у кортежа куча необязательных полей, всё равно приходится каждый раз перечислять их при создании объекта:
```
Pet = namedtuple("Pet", "type name alt_name")
>>> Pet("pigeon", "Френк")
TypeError: __new__() missing 1 required positional argument: 'alt_name'
>>> Pet("pigeon", "Френк", None)
Pet(type='pigeon', name='Френк', alt_name=None)
```
Чтобы этого избежать, укажите в конструкторе аргумент `defaults`:
```
Pet = namedtuple("Pet", "type name alt_name", defaults=("нет",))
>>> Pet("pigeon", "Френк")
Pet(type='pigeon', name='Френк', alt_name='нет')
```
`defaults` присваивает умолчательные значения с хвоста. Работает в питоне 3.7+
Для старых версий можно более коряво добиться того же результата через прототип:
```
Pet = namedtuple("Pet", "type name alt_name")
default_pet = Pet(None, None, "нет")
>>> default_pet._replace(type="pigeon", name="Френк")
Pet(type='pigeon', name='Френк', alt_name='нет')
>>> default_pet._replace(type="fox", name="Клер")
Pet(type='fox', name='Клер', alt_name='нет')
```
Но с `defaults`, конечно, куда приятнее.
Необычайная лёгкость
--------------------
Одно из преимуществ именованного кортежа — легковесность. Армия из ста тысяч голубей займёт всего 10 мегабайт:
```
from collections import namedtuple
import objsize # 3rd party
Pet = namedtuple("Pet", "type name age")
frank = Pet(type="pigeon", name="Френк", age=None)
pigeons = [frank._replace(age=idx) for idx in range(100000)]
>>> round(objsize.get_deep_size(pigeons)/(1024**2), 2)
10.3
```
Для сравнения, если Pet сделать обычным классом, аналогичный список займёт уже 19 мегабайт.
Так происходит, потому что обычные объекты в питоне таскают с собой увесистый дандер `__dict__`, в котором лежат названия и значения всех атрибутов объекта:
```
class PetObj:
def __init__(self, type, name, age):
self.type = type
self.name = name
self.age = age
frank_obj = PetObj(type="pigeon", name="Френк", age=3)
>>> frank_obj.__dict__
{'type': 'pigeon', 'name': 'Френк', 'age': 3}
```
Объекты-namedtuple же лишены этого словаря, а потому занимают меньше памяти:
```
frank = Pet(type="pigeon", name="Френк", age=3)
>>> frank.__dict__
AttributeError: 'Pet' object has no attribute '__dict__'
>>> objsize.get_deep_size(frank_obj)
335
>>> objsize.get_deep_size(frank)
239
```
Но как именованному кортежу удалось избавиться от `__dict__`? Читайте дальше ツ
Богатый внутренний мир
----------------------
Если вы давно работаете с питоном, то наверняка знаете: легковесный объект можно создать через дандер `__slots__`:
```
class PetSlots:
__slots__ = ("type", "name", "age")
def __init__(self, type, name, age):
self.type = type
self.name = name
self.age = age
frank_slots = PetSlots(type="pigeon", name="Френк", age=3)
```
У «слотовых» объектов нет словаря с атрибутами, поэтому они занимают мало памяти. «Френк на слотах» такой же лёгкий, как «Френк на кортеже», смотрите:
```
>>> objsize.get_deep_size(frank)
239
>>> objsize.get_deep_size(frank_slots)
231
```
Если вы решили, что namedtuple тоже использует слоты — это недалеко от истины. Как вы помните, конкретные классы-кортежи объявляются динамически:
```
Pet = namedtuple("Pet", "type name age")
```
Конструктор namedtuple применяет разную тёмную магию и генерит примерно такой класс (сильно упрощаю):
```
class Pet(tuple):
__slots__ = ()
type = property(operator.itemgetter(0))
name = property(operator.itemgetter(1))
age = property(operator.itemgetter(2))
def __new__(cls, type, name, age):
return tuple.__new__(cls, (type, name, age))
```
То есть наш Pet — это обычный `tuple`, к которому гвоздями приколотили три метода-свойства:
* `type` возвращает нулевой элемент кортежа
* `name` — первый элемент кортежа
* `age` — второй элемент кортежа
А `__slots__` нужен только для того, чтобы объекты получились лёгкими. В результате Pet и занимает мало места, и может использоваться как обычный кортеж:
```
>>> frank.index("Френк")
1
>>> type, _, _ = frank
>>> type
'pigeon'
```
Хитро придумано, а?
Не уступает дата-классам
------------------------
Раз уж мы заговорили о генерации кода. В питоне 3.7 появился убер-генератор кода, которому нет равных — дата-классы (dataclasses).
Когда впервые видишь дата-класс, хочется перейти на новую версию языка только ради него:
```
from dataclasses import dataclass
@dataclass
class PetData:
type: str
name: str
age: int
```
Чудо как хорош! Но есть нюанс — он толстый:
```
frank_data = PetData(type="pigeon", name="Френк", age=3)
>>> objsize.get_deep_size(frank_data)
335
>>> objsize.get_deep_size(frank)
239
```
Дата-класс генерит обычный питонячий класс, объекты которого изнемогают под тяжестью `__dict__`. Так что если вы начитываете из базы вагон строк и превращаете их в объекты, дата-классы — не лучший выбор.
Но постойте, дата-класс ведь можно «заморозить», как кортеж. Может тогда он станет легче?
```
@dataclass(frozen=True)
class PetFrozen:
type: str
name: str
age: int
frank_frozen = PetFrozen(type="pigeon", name="Френк", age=3)
>>> objsize.get_deep_size(frank_frozen)
335
```
Увы. Даже замороженный, он остался обычным увесистым объектом со словарём атрибутов. Так что если вам нужны лёгкие неизменяемые объекты (которые к тому же можно использовать как обычные кортежи) — namedtuple по-прежнему лучший выбор.
⌘ ⌘ ⌘
Мне очень нравится именованный кортеж:
* честный iterable,
* динамическое объявление типов,
* именованный доступ к атрибутам,
* лёгкий и неизменяемый.
И при этом реализован в 150 строк кода. Что ещё надо для счастья ツ
*Если хотите узнать больше о стандартной библиотеке Python — подписывайтесь на канал [@ohmypy](https://t.me/ohmypy)* | https://habr.com/ru/post/438162/ | null | ru | null |
# Альтернативный терминал для Windows
Часто путают терминал и шелл. В тех же \*nix есть шеллы (bash, csh, zsh, …) и терминалы (konsole/guake/yaquake/tilda и т.д. и т.п.) Для мира Windows общеизвестный терминал только один – стандартное консольное окошко, которое часто ошибочно называют «cmd.exe». И мало кто знает о существовании множества других эмуляторов терминала. Известных шеллов больше, их целых два: cmd.exe и powershell.exe. И хотя есть как минимум три порта bash (MinGW, CygWin, GIT) многие юниксоиды предпочитают ругать cmd.exe.
Меня не устраивал ни один из найденных альтернативных терминалов (как в 2009-м, когда я начал работу над [ConEmu](http://conemu.github.io/), так и сейчас). Казалось бы требований немного, вот основные:
* работа с консольными приложениями, использующими [консольное API](http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms682073): например [Far](http://www.farmanager.com/) просто не запустится в [mintty](http://en.wikipedia.org/wiki/Mintty) или [PowerShell ISE](http://technet.microsoft.com/ru-ru/library/dd819514.aspx);
* визуальные улучшения вроде [табов (вкладок)](http://en.wikipedia.org/wiki/Tab_%28GUI%29) и [split-screen](http://ru.wikipedia.org/wiki/Split_screen);
* быстрая и удобная работа с пометкой/копированием/вставкой текста;
* должен быть похож на терминал, а не на рождественскую игрушку с кучей графических свистелок и сопелок которые даже отключить нельзя;
* не должен зависеть от сторонних библиотек типа .Net, Qt, VC/GCC redist и прочих устанавливаемых пакетов, занимать по возможности мало места и не требовать инсталляции на новую машину;
* наконец, мне, как приверженцу Far Manager, хотелось интеграции с этим файловым менеджером — редакторы и вьюверы в табах, drag&drop файлов между Far и другими приложениями и т.п.
Отвечает ли этим требованиям ConEmu? Терминал (Free & OpenSource) пишется программистом «для себя» с учетом пожеланий других пользователей программы. В минимально-необходимой комплектации занимает около 2 мегабайт, что конечно больше нескольких килобайт, но все-таки пренебрежимо мало. Установки не требует, может быть портабельным если рядом с ConEmu.exe создать файлик [ConEmu.xml](http://conemu.github.io/ru/ConEmuXml.html). От сторонних библиотек не зависит.
Обзор возможностей
------------------
Рассказать «про все» в рамках одной статьи невозможно, поэтому здесь описаны только некоторые функции, на мой взгляд наиболее интересные большинству пользователей.
**Наглядность**. В табах могут отображается не только заголовки консолей, но и дополнительная информация вроде активного процесса, прогресса архивации, chkdsk, powershell, копирования в Far Manager. Например, не нужно переключаться в таб чтобы узнать закончилась ли компиляция проекта, запущенная в этом табе. В статусной строке можно настроить список отображаемых «колонок» вроде координат видимой области и курсора, PID активного процесса в консоли, статусов CAPS/NUM/SCRL, коэффициента прозрачности и др. Многие колонки кликабельны, например можно щелкнуть по «колонке» с прозрачностью для быстрого ее изменения.
**Минималистичность**. Интерфейс (самого терминала, а не окна настроек) содержит всего два дополнительных графических элемента — табы и статусная строка. Но и их можно отключить, если вы предпочитаете «чистую» консоль.
**Портабельность**. Настройки можно хранить в файле [ConEmu.xml](http://conemu.github.io/ru/ConEmuXml.html) созданном в папке программы.
**Работа с текстом**. Поддерживаются два стиля пометки текста — обычный для текстовых редакторов и «прямоугольный» как в обычной консоли. Пометка и вставка текста удобна как с клавиатурой так и с мышкой.
**Quake/Tilda**. Поддержка режима игровых консолей. Терминал умеет «выезжать» при нажатии выбранной комбинации клавиш (по умолчанию Ctrl+~) и прятаться при потере фокуса или нажатии Esc.
**Запуск любых приложений**. Пользователь может настроить любое количество предопределенных задач (Task) для быстрого запуска в ConEmu или из списка переходов (jump list) панели задач Windows 7. Задача может запускать один или несколько процессов или шеллов (powershell, SDK, компиляция проектов и т.д.) Можно даже запускать простые GUI приложения вроде PuTTY, TaskManager, GVim.
**Работа с цветом**. Несколько предопределенных палитр (например Solarized, PowerShell, xterm, и др.), возможность настройки своих цветов консоли, поддержка управляющих кодов ANSI X3.64, 24-битный цвет при работе в Far Manager.
**Интеграция**. Умеет добавлять себя (и выбранные команды-шеллы) в контекстное меню Windows Explorer. Умеет перехватывать создание стандартного терминала Windows.
**Гибкая настройка и управление**. В диалоге Settings можно найти настройки на любой вкус и цвет. Практически любому действию можно назначить комбинацию клавиш, а простейший макро-язык позволяет выполнять нестандартные действия.
Немного истории
---------------
В начале был Zoin и его анонс [Эмулятор консоли](http://forum.farmanager.com/viewtopic.php?p=21200#p21200) на форуме Far Manager. Не знаю, планировал ли автор развитие эмулятора, но в 2009-м году появилось несколько форков предлагающих разные улучшения: вертикальную прокрутку, табы для редакторов и вьюверов Far, отображение контекстного меню для файлов по правой кнопке и перетаскивание файлов между консольным Far и другими приложениями. Идея мне понравилась и, объединив все «патчи», я стал развивать эмулятор добавляя новые возможности и исправляя баги. На тот момент было несколько альтернатив (самые известные – [Console2](http://sourceforge.net/projects/console) из бесплатных и [TakeCommand](http://jpsoft.com/) из платных), но ни одна у меня не прижилась. «Пользуюсь фаром 15 лет» поэтому в первую очередь нужна была оболочка для него.
Установка
---------
ConEmu можно скачать с [оф.сайта](http://conemu.github.io/en/Downloads.html) в двух вариантах: инсталлятор и 7z архив. Разницы между ними в общем-то никакой, просто инсталлятор умеет создавать ярлыки и позволяет отключить не нужные части продукта. Рекомендую пробовать последние Alpha-версии, т.к. с момента выхода последнего Stable прошло много времени, исправлено много багов, появилось много новых возможностей.
Для адептов bash на зеркале проекта есть специально подготовленные [пакеты для MinGW](http://sourceforge.net/projects/conemu/files/MinGW/). Их достаточно развернуть в папку MinGW чтобы в ConEmu сразу запускался «sh.exe –login –i».
Пользователям Far Manager: для полноценной работы в Far должны быть загружены плагины ConEmu. Убедитесь, что при использовании инсталлятора плагины устанавливаются в подпапку Plugins вашего каталога с Far.exe. Обратите внимание, что инсталлятор позволяет выбрать папку установки как для самого ConEmu так и для плагинов к Far.
Пользователям антивирусов: инсталлятор как и сам ConEmu троянов не содержит, как говорится, «исходники открыты».
При первом запуске программа спросит где вы предпочитаете хранить настройки — в файле [ConEmu.xml](http://conemu.github.io/ru/ConEmuXml.html) или в реестре.
Теперь можно запускать ConEmu.exe или ConEmu64.exe (разница между 32-битной и 64-битной версией отсутствует).
По умолчанию ConEmu при старте запускает один таб с «предпочитаемым» шеллом:
* Far.exe (если найден рядом с ConEmu.exe);
* cmd.exe или tcc.exe (если установлен TakeCommand или TCC/LE);
* sh.exe (если ConEmu установлен в режиме «MinGW»).
Первый запуск
-------------
При первом запуске отображается диалог «Fast configuration», он содержит несколько основных опций влияющих на работу программы.
**Install keyboard hooks**. ConEmu умеет отбирать у системы определенные комбинации клавиш (когда в фокусе окно программы). Например Win+цифра можно переключаться на таб с определенным номером. Практически все комбинации клавиш с ConEmu настраиваются или отключаются (Win+Alt+K), но если вам вообще не нужен перехват комбинаций с модификатором Win – можете отключить флажок.
**Inject ConEmuHk.dll**. Для многих возможностей ConEmu требуется перехват определенных функций WinAPI. Библиотека ConEmuHk.dll (или ее 64-битная версия ConEmuHk64.dll) внедряется в запускаемые во вкладках ConEmu процессы и перехватывает функции через разделы импорта. К сожалению, перехватываемых функций становится все больше и соответственно увеличивается время перехвата. И хотя в цифрах это лишь миллисекунды, некоторые пользователи жалуются на замедление выполнения команд в ConEmu. Если вы из них – отключите этот флажок. В планах попробовать перейти на перехват в стиле detours, возможно это ускорит процесс.
**Enable automatic updates**. Думаю, в переводе не нуждается. Обновление выполняется тем же способом, что и при установке. То есть если вы установили ConEmu распаковкой 7z–архива, то для обновления потребуется архиватор (7–zip или WinRar).
Настройка
---------
В принципе, ConEmu работает сразу и настройки не требует, но у любого пользователя/админа/программиста есть свои предпочтения и специфика работы.
Полный диалог настроек открывается либо с клавиатуры комбинацией Win+Alt+P либо вызовом из системного меню ConEmu пункта «Settings».
Можно заблудиться в куче вкладок и настроек, но все настройки сгруппированы по смыслу, а для неочевидных опций отображаются всплывающие подсказки при наведении курсора мышки. Наверное не стоит рассказывать в этой статье про каждую опцию, поэтому пробежимся только по основным и наиболее интересным.
Выбор шелла
-----------
Итак, скорее всего вам нужно будет настроить свой список шеллов, как запускаемых при старте, так и быстро доступных.
Идем на вкладку «Startup». Если нужно запускать только один шелл — все просто: выбираем «Command line» и вводим требуемое, например:
`C:\MinGW\msys\1.0\bin\sh.exe --login -i`
В принципе, в качестве шелла можно запускать любое консольное приложение или командный файл для cmd, python, и т.п. Можно даже запускать некоторые GUI приложения вроде PuTTY, notepad, gvim и т.п.
Если при старте нужно запустить сразу несколько шеллов — идем на вкладку «Tasks» (задачи) и начинается магия. Диалог настроек и так перегружен, поэтому задачи создаются «в текстовом виде».
`>C:\MinGW\msys\1.0\bin\sh.exe --login -i`
`cmd /k set ConEmuHooks=OFF & "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" -new_console:sV -new_console:t:SDK & set ConEmuHooks=`
`cmd -new_console:s1TH`
`*powershell -new_console:s2TH -new_console:t:PowerShell`
Называем его «Shells», возвращаемся на вкладку «Startup» и выбираем «Specified named task».
В итоге при старте ConEmu получаем 4 консоли в сетке 2x2 причем активной будет вкладка sh.exe, а powershell.exe запускается в режиме админа (после подтверждения UAC) и его вкладка получает фиксированное название «PowerShell».
Параметр "-new\_console" специальный параметр, обрабатывающийся в ConEmu и вырезающийся из командной строки при запуске программы. О нем можно писать много и долго, а пока отошлю на [сайт проекта](http://conemu.github.io/en/NewConsole.html).
Запуск новых консолей
---------------------
Если отображается панель кнопок (toolbar) то кнопка [+] открывает диалог запуска новой консоли. Здесь можно указать любую программу с параметрами, выбрать строку запуска из истории или выбрать заранее созданную задачу. Здесь можно создать «split», запустив новую консоль на одном экране с текущей. «Run as administrator» запускает новую консоль в режиме администратора. Флажок «New window» запустит новый процесс ConEmu.exe с выбранной командой.
На панели кнопок у кнопки [+] есть «стрелка» для открытия меню. Это же меню можно открыть комбинацией Win+N. Здесь отображаются команды из истории и заранее созданные задачи. Правый щелчок мышкой по пункту с задачей открывает меню второго уровня со списком команд этой задачи – так можно посмотреть ее содержимое или запустить только одну из команд задачи.
Можно создать ярлык и запускать новую консоль в уже запущенной копии ConEmu. Например, создайте на рабочем столе ярлык для запуска Far Manager (считаем что Far и ConEmu установлены в папку C:\Far)
`"C:\Far\ConEmu.exe" /single /cmd "C:\Far\Far.exe"`
Запуск из [списка переходов](#JumpList) (Jump List) панели задач Windows 7. Отсюда удобно запускать наиболее употребительные задачи, например запуск компиляции ваших проектов.
Быстрый запуск по комбинации клавиш. Если ярлыков (хоткей можно задать в свойствах ярлыка) и задач (Win+N и цифра номера задачи) не хватает – можно создать макрос запуска любой команды. Откройте вкладку «Keys & Macro» диалога настройки (Win+Alt+K), выберите один из «Macro NN» и введите в поле «GUI Macro» что-то вроде:
`shell("",@"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe")`
Поддерживаются два синтаксиса строк: C-string где используются `\r\n\t\a\e\"\\`, и Verbatim-string вроде `@"app.exe ""C:\My Documents\File.txt"""`.
Из командной строки шелла, запущенного во вкладке ConEmu можно запустить новую вкладку с помощью специального параметра [-new\_console](http://conemu.github.io/en/NewConsole.html). Его опции позволяют запускать вкладки в режиме администратора, под другим пользователем, включать и отключать подтверждение закрытия после завершения команды, запускать вкладки «в фоне», разбить активную консоль вертикально или горизонтально (split-screen).
`cmd /c dir /s c:\ -new_console:bc`
или использовать cmd-файл, включенный в поставку ConEmu
`csudo dism.exe /online /enable-feature /featurename:NetFX3 /All /Source:D:\sources\sxs /LimitAccess`
В контекстном меню таба (правый клик на табе или Shift+правый клик в консоли) есть пункт «Duplicate root». Он создает копию шелла в новой вкладке. Например в текущей вкладке cmd вы запустили компиляцию проекта, при вызове «Duplicate root» будет создана новая вкладка с тем же текущим путем, что был до запуска компиляции, и с теми же переменными окружения.
Аналогично действуют комбинации клавиш Ctrl+Shift+O и Ctrl+Shift+E, но они создают копию шелла, разбивая активную консоль вертикально или горизонтально (split-screen).
Пометка, копирование и вставка текста
-------------------------------------
Настроек на вкладках «Mark & Paste» и «Controls» много. Расскажу об умолчаниях.
Поддерживается два типа пометки текста:
* **Text selection** — стандарт для текстовых редакторов;
* **Block selection** — прямоугольные блоки, как в обычной консоли.
Варианты для начала пометки в стиле «Text selection»: Shift+СтрелкаВлево, Shift+СтрелкаВправо или удерживая ЛевыйShift начните пометку мышкой (drag с зажатой левой кнопкой мышки).
Варианты для начала пометки в стиле «Block selection»: Shift+СтрелкаВверх, Shift+СтрелкаВниз или удерживая ЛевыйAlt начните пометку мышкой (drag с зажатой левой кнопкой мышки).
**Примечание**: при работе в Far Manager Shift+Стрелка обрабатываются в Far а не в ConEmu.
Копирование в буфер обмена помеченного блока с клавиатуры: Ctrl+C или Enter. Нажатие Esc отменяет пометку.
При пометке текста мышкой копирование выполняется сразу при отпускании левой кнопки мышки.
### Вставка текста из буфера обмена
Ctrl+V вставляет только первую строку из буфера обмена. Почему только первую? Чаще всего в терминале запущен шелл и было бы обидно, если команда начнет выполняться **до** того как вы проведете ревизию того, что вставилось в консоль.
Shift+Ins и щелчок правой кнопки мышки вставляет все строки из буфера обмена.
### Выбор и вставка путей к файлам и папкам
Комбинации Ctrl+Shift+D и Ctrl+Shift+F открывают стандартные Windows-диалоги выбора пути к папке или файлу и вставляют выбранный путь в консоль.
### Бонус в командной строке
При щелчке левой кнопкой мышки в командной строке ConEmu пытается переместить курсор в позицию щелчка. А Ctrl+BackSpace удаляет слово слева от курсора.
### Гиперссылки и ошибки компиляции
ConEmu умеет открывать гиперссылки в браузере по умолчанию (ShellExecute) а ссылки на ошибки компиляции в редакторе. Удерживая ЛевыйCtrl щелкните левой кнопкой мышки по гиперссылке `www...` или по файлу с ошибкой `test.c(50): error: ...`.
Шрифт
-----
Вкладка «Main». Шрифт можно выбрать любой: моноширный или пропорциональный, растровый или векторный, с включенным сглаживанием или отключенным (Clear Type, Standard, None). Пропорциональный шрифт в консоли смотрится несколько странно, но если хочется – то можно отключить флажок «Monospace».
Хочется отметить также то, что ConEmu умеет использовать не только шрифты установленный в системе. Просто скопируйте желаемые файлы шрифтов (поддерживаются fon, ttf, otf, и моноширные bdf) в папку ConEmu и перезапустите программу. Новые шрифты появятся в списке доступных на вкладке настройки шрифтов «Main». Не стоит копировать слишком много шрифтов – их обработка может занять значительное время при старте программы. Регистрацию «локальных» шрифтов можно отключить на вкладке «Features» флажком «Auto register fonts».
Для отображения псевдографики (рамки в Far Manager и т.п.) можно настроить отдельный шрифт. В некоторых шрифтах используемых в качестве основного рамки получаются несимпатичными.
Иногда нужно быстро поменять размер шрифта. Это можно сделать не открывая окно настроек — удерживая клавишу Ctrl крутите колесико мышки.
Quake/Tilda
-----------
Вызов ConEmu в стиле игровых консолей доступен «из коробки». Открываем вкладку «Main» и включаем флажок «Quake style slide down». При желании там же включаем «Auto–hide on focus lose». Если рамка вообще не нужна – в поле «Frame width» поставьте «0» вместо "-1" ("-1" — показывать рамку полностью). Здесь же можно настроить отступы поля консоли от краев окна ConEmu – включите «Center console in ConEmu workspace» и выберите количество пикселей в «Pad size».
Режим «поверх всех окон» можно включит на вкладке «Appearance» флажком «Always on top».
Показывать ли окно ConEmu на панели задач? Открываем вкладку «Task bar» и выбираем желаемые опции. По умолчанию в Quake режиме при минимизации (скрытии) окно скрывается в TSA (taskbar status area – область рядом с часиками), это опция «Auto minimize to TSA». А чтобы вообще не показывать иконку в панели задач – щелкните радиокнопку «Don't show ConEmu window on Taskbar» и включите «Always show TSA icon» чтобы не потерять ConEmu.
Клавиша активации. Их может быть две (так все запущено на некоторых раскладках клавиатуры). Открываем вкладку «Keys & Macro» и в самом начале списка видим «Minimize/Restore» и «Minimize/Restore (alternative)». Можно выбрать любую комбинацию клавиш (по умолчанию это Ctrl+~), но имейте в виду, что эта комбинация регистрируется как глобальный хоткей в системе со всеми вытекающими. Например, некоторые комбинации могут быть уже зарезервированы системой или другими приложениями.
Клавиша скрытия. Та же что и клавиша активации, но дополнительно окно ConEmu можно скрывать просто клавишей Esc. Откройте вкладку «Task bar» и в группе «Minimize ConEmu by Esc» выберите опцию «Always». Там же есть флажок «Map Shift+Esc to Esc» чтобы можно было все-таки послать в консоль клавишу «Esc» если это необходимо.
Размер (высоту) окна можно менять. Наведите мышку на рамку (или на то место, где она должна быть), подождите пару секунд, и у окна появится обычная resizable рамка которую можно тянуть мышкой.
Панель задач Windows 7
----------------------
Поддержка списка переходов (Jump List). После создания вашего списка задач на вкладке «Tasks» включите флажок «Add ConEmu tasks to taskbar» и нажмите кнопку «Update Now».
Отображение прогресса на панели задач.
Фоновая картинка
----------------
Если вам не нравится унылое черное окошко – фон можно заменить на картинку или сплошной цвет. Замена фона выполняется для выбранных индексов цветов – поле «Replace color indexes». По умолчанию в поле стоит "\*" – автовыбор, но если, например, нужно заменять фон для темно-зеленого цвета (палитру можно посмотреть на вкладке «Colors») введите "#2" вместо "\*". Фоновая картинка указывается в поле «Path» (bmp, jpg, png файлы), но в этом же поле можно указать и сплошной цвет, например «48 10 36» чтобы получить цвет фона терминала в Ubuntu. Если картинка слишком яркая – ее можно притушить слайдером «Darkening».
Еще одна возможность для пользователей Far Manager – установка цвета фона из плагинов Far. На Хабре уже была статья "[Визуализация разных дисков в файловом менеджере или Не совсем консольный FAR](http://habrahabr.ru/post/103534/)". Описываемый там плагин устарел и не работает в текущих версиях ConEmu, но аналогичный функционал реализован плагином «ConEmu Background». Чтобы включить раскраску панелей откройте в Far Manager список «Plugins configuration» (Alt+Shift+F9 в панелях), выберите плагин «ConEmu Background» и включите флажок «Enable plugin».
Автообновление
--------------
ConEmu умеет обновляться автоматически, если он был установлен инсталлятором или развернут из 7z–архива. Для обновления 7z–архивом требуется установленный архиватор 7zip или WinRar. На владке «Update» можно выбрать параметры обновления: проверять при запуске или ежечасно; показывать диалог с сообщением о новой версии или только нотификацию в TSA; обновляться на последнюю или только на стабильную версию; настройка proxy–сервера; путь для хранения скачанных версий и т.д.
Цветовые палитры
----------------
На вкладке «Colors» можно выбрать одну из предопределенных цветовых схем (Solarized, Standard VGA, PowerShell, xterm, и др.) или настроить свою схему цветов. Настроенную схему можно сохранить: введите имя в поле «Schemes» и нажмите кнопку «Save».
Стандартной палитры в 16 цветов не всегда хватает, но в ConEmu есть две возможности расширения цветового пространства.
Extend foreground colors
------------------------
За счет потери одного индекса цвета фона в ConEmu можно настроить дополнительно 16 цветов для текста. Например, для приглашения командной строки можно указать ярко-красный цвет фона, выбрать в выпадающем списке его индекс (#12) и настроить палитру цветов с индексами 16..31. После этого текст будет отображен цветами палитры 16..31, а цвет фона (ярко-красный) заменен на окружающий (скорее всего это будет черный).
Подробнее можно почитать [здесь](http://stackoverflow.com/a/12914627/1405560).
TrueColor
---------
Унылая 16-цветная консольная палитра надоела разработчику плагина Colorer для редактора Far Manager и появился Colorer TrueMod. В результате консольный редактор засиял новыми красками, а информация о цветах стала храниться в SharedMemory в дополнение к собственно консоли. Кроме цветов появилась возможность использовать Bold/Italic/Underline шрифты для участков текста.
В Far 3.0 поддержка TrueColor стала нативной и настройку расширенных атрибутов (24бита на цвет и Bold/Italic/Underline) можно выполнить для любого элемента интерфейса. Кто говорил, что в фаре недостаточно цветов для подсветки групп файлов?
Опция может быть отключена на вкладке «Colors» флажком «TrueMod (24bit color) support». Ее отключение экономит некоторое количество мегабайт памяти.
ANSI X3.64
----------
В \*nix терминалах можно использовать [Escape-последовательности](http://ru.wikipedia.org/wiki/ANSI_X3.64) и даже в DOS они были доступны со стандартным драйвером ANSI.SYS. В терминале Windows про них решили забыть, правда есть несколько программ позволяющих использовать ANSI в Windows, например [ANSICON](https://github.com/adoxa/ansicon).
В ConEmu поддержка ANSI X3.64 встроена. Для этого должны быть включены флажки «Inject ConEmuHk» и «ANSI X3.64» на вкладке «Features». Полный список поддерживаемых в ConEmu [ANSI кодов](http://conemu.github.io/ru/AnsiEscapeCodes.html).
С помощью ANSI можно не только выводить цветной текст. Например в заголовке таба можно отображать [текущую директорию в cmd](http://superuser.com/a/459227/139371).
Прозрачность окна ConEmu
------------------------
При желании на вкладке «Transparency» можно настроить прозрачность окна ConEmu. Можно выбрать различные значения прозрачности для активного и неактивного окна. Например ConEmu может полностью «исчезнуть» с экрана при потере фокуса если слайдер прозрачности для неактивного окна передвинуть в крайнее левое положение.
Если вы не отключили статусную строку, то в ней может отображаться текущее значение прозрачности в процентах (список отображаемых «колонок» статусной строки тоже настраивается). При щелчке мышкой по колонке с прозрачностью всплывает меню в котором можно быстро изменить коэффициент прозрачности или отключить его.
Табы
----
При работе с несколькими консолями одновременно или при работе с редакторами и просмотрщиками в Far Manager (в Far должен быть загружен плагин ConEmu) табы сильно облегчают жизнь. Кроме того, в заголовке таба показывается прогресс операции в процентах (копирование, распаковка архивов, chkdsk, прогресс в PowerShell, и др.)
В табе отображается значок «Щит» если эта консоль запущена в режиме администратора.
Отображаемый текст можно настроить по шаблону, например можно в табе показывать имя и PID активного процесса, порядковый номер консоли, заголовок окна консоли, имя редактируемого или просматриваемого в Far Manager файла, признак наличия изменений в редакторе.
Если cmd.exe запущен в режиме администратора – в заголовке окна консоли он отображает префикс «Администратор:». ConEmu умеет отбрасывать эту избыточную информацию.
Если табы не нужны – их можно полностью отключить или включить автопоказ при появлении более одного таба.
Переключение между табами также настраивается по желанию. Стандартные комбинации Ctrl+Tab и Ctrl+Shift+Tab. Режим «Recent mode» включенный по умолчанию позволяет перебирать табы в порядке их активации. При включенном «Lazy tab switch» фактическое переключение таба произойдет при отпускании клавиши Ctrl. А до отпускания клавиши Ctrl табы можно переключать и стрелками Влево/Вправо.
Табы можно активировать по номеру консоли, который можно показывать в заголовке таба. По умолчанию предлагается комбинация Win+цифра (должны быть включены флажки «Install keyboard hooks» и «Win+Number – activate console» на вкладке «Controls»). То есть Win+1 активирует первую консоль, Win+2 – вторую и т.д. Если консолей открыто более 9 то нужно нажимать последовательно две цифры удерживая клавишу Win, например «Win+2,4» активирует 24-ю консоль (и кому их столько понадобится?). Если открыты редакторы/вьюверы в Far Manager то Win+цифра будет последовательно перебирать их (флажок «Host-Key+Number iterates Far windows»).
Вместо клавиши «Win» можно выбрать любую другую комбинацию клавиш-модификаторов, например Ctrl+Shift или Apps. Перейдите на вкладку «Keys & Macro» и прокрутите список клавиш до пункта «Activate console by number». Вы можете выбрать любые три клавиши-модификатора.
Статусная строка
----------------
По желанию отключается и настраивается. Доступно большое количество колонок вроде имени и PID активного процесса, координаты видимой области и курсора, ИД текущей раскладки клавиатуры, статусы CAPS/NUM/SCROLL, номер активной консоли, коэффициент прозрачности и т.д. По многим колонкам можно щелкать мышкой для их изменения.
ConEmu Here
-----------
На вкладке «Integration» можно настроить контекстное меню для Windows Explorer и установить ConEmu как терминал по умолчанию для запуска консольных приложений.
«ConEmu Here» и «ConEmu Inside». Вы можете создать неограниченное количество пунктов меню для запуска разных шеллов (cmd, powershell, bash, SDK и т.п.) Введите команду в поле «Command» дайте пункту меню соответствующее название в поле «Menu item», опционально укажите путь к иконке отображаемой в меню (не работает в WinXP) и нажмите кнопку «Register». Список ранее зарегистрированных пунктов отображается в выпадающем списке «Menu item».
Отличие «ConEmu Inside» от «ConEmu Here» в том, что терминал будет запущен как часть окна Windows Explorer (Inside).
ConEmu может использоваться как плагин и в других программах. Для этого укажите дескриптор окна в котором должен разместиться ConEmu и команду, которую он должен выполнить. Например:
`ConEmu.exe /insidewnd 0x13A40 /cmd powershell.exe`
Default terminal
----------------
ConEmu может подменять собой стандартный терминал Windows, запуск с ярлыка «Windows SDK Command Prompt», запуск «ipconfig /all» из диалога Win+R, запуск консольных приложений из TotalCmd, отладка консольных программ в Visual Studio – все может быть перехвачено и запущено в ConEmu.
Как это работает: на вкладке «Integration» нужно указать список процессов, в которые будет загружена библиотека ConEmuHk.dll (например «explorer.exe|devenv.exe|totalcmd.exe») и включить флажок «Force ConEmu as default terminal» а также, при желании, «Register on OS startup». В указанных процессах будут перехвачены функции CreateProcessA, CreateProcessW, WinExec для запуска консольного приложения в ConEmu.
IDE style
---------
Выше уже было сказано про запуск любых команд из [списка переходов](#JumpList). Например, для сборки ConEmu я сделал cmd-файл настраивающий окружение SDK и запускающий nmake или devenv.com.
Ключ "/single" в поле «Task parameters» указывает использовать один экземпляр ConEmu (запуск в новом табе). Ключ "-new\_console:c" в тексте команды является аналогом «pause» в cmd, чтобы консоль не закрылась после завершения компиляции.
В случае ошибок компиляции (вывод компилятора сохраняется в файл Error.log) вызывается скрипт `TypeBuildErrors.cmd "%~dp0Errors.log"` подсвечивающий строки с информацией об ошибках красным шрифтом, а предупреждения — синим. Исправив ошибки [в редакторе Far Manager](#Hyperlinks) можно перезапустить компиляцию — Win+~ (хоткей по умолчанию для перезапуска таба).
App distinct
------------
Здесь можно изменить некоторые опции в зависимости от процесса в консоли.
Например для PowerShell запущенном в режиме админа задать свою палитру.
Здесь же будет возможность задать свою фоновую картинку (просят давно, но пока не готово).
Keys & Macro
------------
Здесь можно увидеть список всех комбинаций клавиш используемых в программе. Быстрый способ открыть эту вкладку – Win+Alt+K.
Также есть возможность задавать некоторое количество пользовательских действий через [GuiMacro](http://conemu.github.io/ru/GuiMacro.html). Например назначить на Ctrl+D выход из текущего шелла: `print("exit\n")`.
Far Manager
-----------
Интеграция с Far это тема для отдельной статьи. Важно, чтобы в Far был загружен плагин ConEmu (то есть в списке F11 из панелей был виден пункт «ConEmu»).
Краткий список возможностей.
* Drag&Drop файлов из панелей в другие приложения;
* щелчок правой кнопкой мышки помечает файлы, а длинный щелчок (удерживайте правую кнопку мышки >1 секунды) открывает графическое EMenu;
* панели можно двигать мышкой
* в плагине Unicode CharMap символы отображаются соответствующим шрифтом;
* файлы в панелях можно отображать в режиме Tile и Thumbnail;
* поддержка тачскринов, например прокрутка двумя пальцами, жест zoom, длинный тап по кейбару открывает меню (Alt/Shift/Ctrl/Fn).
Вкладка Debug
-------------
В основном вкладка для отлова багов. Но может быть интересна и пользователям.
Например, при выборе радиокнопки «Shell» ConEmu показывает запускаемые в консоли процессы и загружаемые dll-ки. Почти то же самое можно подсмотреть в ProcessMonitor, но здесь есть бонус — при компиляции проектов VC cl.exe и link.exe запускаются не с ключами а с параметром пакетным-файлом. ConEmu покажет содержимое этого файла.
Разное
------
Win+A или кнопка на тулбаре — заморозить консоль (поставить на паузу).
Щелчок правой кнопкой мышки по крестику в заголовке окна скрывает ConEmu в область уведомлений (Taskbar status area).
Полоса прокрутки по умолчанию скрыта и появляется при наведении мышки в правый край консоли. При работе в Far Manager колесо мышки обычно обрабатывается самим Far (прокрутка панелей, меню, и пр.), но при наведении курсора на полосу прокрутки — колесо прокручивает консоль.
Поиск текста — Apps+F или из меню «Edit» пункт «Find text». Искать умеем по всей консоли, но для этого консоль должна быть заморожена (Freeze console).
Можно показать «настоящую» консоль комбинацией Ctrl+Win+Alt+Space.
Заключение
----------
Казалось бы от терминала нужно не много, но работа над ConEmu далека от завершения и в планах реализация многих возможностей. Например «бесконечный» буфер (сейчас ограничен 9999 строками «реальной» консоли), полноценная поддержка xterm 256 colors, горизонтальная прокрутка, сниппеты, оптимизация и т.д.
И, конечно, документация. Банально не хватает времени чтобы поддерживать актуальность [wiki](http://conemu.github.io/ru/TableOfContents.html), некоторые страницы ожидают перевода, а многие возможности описаны только в WhatsNew.
### Обновлено
Официальный сайт переехал по адресу [http://conemu.github.io](http://conemu.github.io/ru/ConEmu.html). | https://habr.com/ru/post/164687/ | null | ru | null |
# Погружение в технологию блокчейн: Быстрые и безопасные транзакции
Представляем вам серию статей о первых в России проектах, разработанных на основе технологии блокчейн. Мы спросили у команд-участниц хакатона InspiRussia о технологической составляющей их решений.
В этом материале речь пойдет о победителях хакатона — проекте от команды разработчиков Модульбанка, который решает существующие проблемы в банковской сфере и помогает осуществлять быстрые и безопасные транзакции между юридическими лицами.
Цикл статей «Погружение в технологию блокчейн»
----------------------------------------------
1. Серия материалов, посвященных технологии Emer:
1.1. [Секреты EmerCoin](https://habrahabr.ru/company/microsoft/blog/311690/).
1.2. [Децентрализованная нецензурированная система доменных имён](https://habrahabr.ru/company/microsoft/blog/314368/).
1.3. [Инфраструктура публичных ключей всемирного масштаба](https://habrahabr.ru/company/microsoft/blog/316326/).
1.4. [Децентрализованная беспарольная система безопасности](https://habrahabr.ru/company/microsoft/blog/316864/).
2. [Быстрые и безопасные транзакции](https://habrahabr.ru/company/microsoft/blog/312308/).
3. [Экосистема цифровой стоматологии](https://habrahabr.ru/company/microsoft/blog/313130/).
4. [Борьба с контрафактными товарами](https://habrahabr.ru/company/microsoft/blog/312054/).
5. [Взаимное страхование животных](https://habrahabr.ru/company/microsoft/blog/323548/).
6. [Что такое ICO и как его провести](https://habrahabr.ru/company/microsoft/blog/328896/).
7. Loading…
Проблемы в банковской сфере, которые можно решить с помощью технологии блокчейн
-------------------------------------------------------------------------------
Так как представители проекта работают в банковской сфере, они не понаслышке знакомы с проблемой расчета между юридическими лицами: этот процесс может занимать до трех дней, что крайне долго для малого бизнеса и динамичных предпринимателей. Кроме того, у банков сегодня есть еще одна проблема: часть безналичных расчетов между компаниями является «транзитом» чёрных денег. Обычно это очень сложно определить, потому что нет цепочки прохождения транзакции и связи между ними. Нет истории движения денег в других банках. Банки придумывают различные аналитические алгоритмы, чтобы выявлять такие транзакции. Но и они часто ошибаются, так как не хватает данных для полноценного анализа. В свою очередь, сеть блокчейн подразумевает единое распределённое хранилище транзакций. Это значит, что каждый платёж навсегда остаётся в единой базе движения средств, поэтому для анализа всегда доступен весь денежный поток.
#### Скорость платежей
Проблему скорости платежей решает то, что транзакции в блокчейн происходят мгновенно. Единственным замедляющим фактором может стать время, которое принимающая сторона будет ожидать подтверждение этой транзакции, так как они приходят от других участников сети — PoW.
#### Безопасность транзакций
Безопасность транзакций обеспечивается тем, что в блокчейн в каждый блок данных встраивается вычисленная контрольная сумма предыдущего блока, таким образом, каждый блок имеет ссылку на предыдущий. Мы считаем, что благодаря этой особенности технология блокчейн позволит существенным и даже радикальным образом повысить прозрачность транзакций и сделает процедуры проверки (в части противодействия отмыванию денег и финансирования терроризма) простыми и эффективными.
На хакатоне было протестировано решение, упрощающее анализ движения денежных средств между счетами: при прохождении транзакции через каждый счет «деньги» помечали специальной уникальной меткой этого счета. Поэтому, каждый рубль, который проходит через сеть, может тянуть за собой не только хвост всех меток, но и последовательность всех счетов, через которые он прошел. Вместе с остальными достоинствами сети блокчейн (скорость, безопасность, единая база транзакций), это решение исключает непрозрачное прохождение денег и позволяет однозначно восстановить маршрут их движения в любой момент времени в рамках финансового консорциума.
Реализация идеи
---------------
Ключевая цель команды заключалась в том, чтобы показать, что их идея рабочая для конечного пользователя, поэтому для наглядности были созданы: клиентское приложение для мобильного устройства, веб-приложения для банка и регуляторов. Для back-end было принято решение развернуть сеть Ethereum (платформу для создания децентрализованных онлайн-сервисов на базе блокчейна) на основе Azure Blockchain as a Service.
Мобильное приложение под iOS для осуществления переводов было создано на Objective-C. Веб-приложения для мониторинга — на Angular. Для back-end интеграции использовали язык C# и инструменты Visual Studio.
Архитектура реализованной системы достаточна проста. Ниже вы можете увидеть её.
#### Почему Microsoft Azure?
Microsoft Azure был выбран, так как существует готовый шаблон для развёртывания всей необходимой инфраструктуры для Ethereum — DevTest Labs for Blockchain as a Service. Данный шаблон разворачивает в Azure виртуальную машину на Ubuntu, внутри которой из стандартного репозитория разворачивается сеть Ethereum, после чего с помощью артефактов настраиваются параметры её работы.
#### Почему Ethereum?
Так как для связывания клиентских приложений с сетью Ethereum использовался .NET WebApi, крайне удобно использовать Nethereum — готовое решение для доступа к сети Ethereum. Основное преимущество Ethereum для текущего решения — программируемые смарт-контракты. Для их создания существует удобный инструмент Solidity extension для Visual Studio. Дополнительным преимуществом можно выделить то, что back-end приложение также можно без проблем развернуть на веб-сервисе в Azure.
#### Развертывание сети блокчейн
Самой сложной и одновременно интересной стала задача по развёртыванию сети блокчейн. Для этого был использован шаблон DevTest Labs, позволяющий развернуть Ethereum в Azure затратив минимум усилий, так как многие вещи в нём происходят автоматически.
Фактически, при его использовании создается группа ресурсов, полностью готовая к развертыванию сети Ethereum. Но! Виртуальную машину она не создает. Выход простой — кликнув на Add просто выбираем и добавляем новый ресурс — виртуальную машину на Ubuntu Server 14.04:
Примерно через 5 минут вы увидите готовую среду для развёртывания блокчейн сети:
Примечание: здесь стоит оговориться, что развёртывание сети Ethereum может проходить в полностью автоматическом режиме с помощью подключения артефактов перед созданием виртуальной машины. Этот способ описан в [этой](https://blogs.msdn.microsoft.com/uk_faculty_connection/2016/08/01/getting-started-with-blockchain-as-a-service-using-microsoft-azure-dev-test-labs/) статье. Но в рамках тестового аккаунта Azure, предоставленного для хакатона, такая возможность была недоступна. Поэтому сеть была развернута вручную.
Далее, с помощью заготовленных [скриптов](https://github.com/Azure/azure-blockchain-projects/tree/master/baas-artifacts/linux-ethereum-homg), подцепившись к виртуальной машине через SSH-клиент, выполняем несколько команд (добавляем репозиторий Ethereum, обновляем список пакетов, устанавливаем Ethereum):
```
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install ethereum
```
Далее необходимо всё это запустить. Для этого отправляем скрипты на виртуальную машину с помощью команды:
```
pscp "C:\path to your scripts folder\*" @:./
```
Далее запускаем сеть Ethereum, выполнив:
```
sh seed-blockchain.sh
```
Здесь при создании сети используется genesis-файл `lab-seed.json`, который содержит следующее:
```
{
"config": {
"homesteadBlock": 10
},
"alloc": {},
"nonce": "0x0000000000000042",
"difficulty": "0x0400",
"mixhash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
"coinbase": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82ee",
"gasLimit": "0x4c4b40"
}
```
После этого создаём первый аккаунт:
```
geth --datadir "chains/devtest" account new
```
И запускаем майнинг:
```
geth --mine --identity "Node1" --datadir "/home/deathys/chains/devtest/" --nodiscover --rpc --rpccorsdomain "*" --networkid 552 console
```
В результате видим запуск процесса майнинга — в сети создаются новые блоки. Сейчас они без транзакций:
Примечание: обратите внимание, что если в сети не происходит майнинг, то сеть не считает созданные в ней транзакции подтверждёнными.
Теперь, когда виртуальные машины готовы, можно погружаться в саму «сеть». Чтобы не останавливать майнинг, подключаемся к ней в параллельной сессии. Команда для подключения приведена в скрипте `attachOne.sh`. Так как майнинг идёт полным ходом, мы получаем за него вознаграждение в эфирах — стандартной валюте сети. На текущий момент мы имеем следующее количество эфиров для тестирования решения:
Примечание: на самом деле, это довольно внушительная сумма для Homestead «production». На момент проведения хакатона стоимость одного ether приближалась к С$17.
#### Распределенная сеть блокчейн
Для того, чтобы развернуть распределенную блокчейн сеть будет необходима хотя бы еще одна виртуальная машина (нода). Чтобы поднять вторую ноду нашей сети, нужно выполнить все действия, аналогичные созданию основной ноды.
Кроме того в Azure в разделе Network security group необходимо открыть исходящие и входящие порты, на которых работает сеть Ethereum. В разделе Inbound security rules открываем порты 30303 и 34964:
Теперь свяжем ноды, чтобы они увидели друг друга в сети. Для этого нужно представить одну ноду другой, введя команду, в рамках подключения одной из нод:
```
admin.addPeer("enode://@:30303")
```
Чтобы узнать ID представляемой ноды, нужно в рамках подключения к ней выполнить команду:
```
admin.nodeInfo.enode
```
Итак, теперь у нас появилась распределённая сеть блокчейн и можно начинать переводить криптовалюту между счетами.
Чтобы было интереснее, создадим больше аккаунтов:
```
personal.newAccount()
```
В результате получим:
Теперь мы можем переводить между ними ether, но есть один нюанс — чтобы перевести деньги с одного аккаунта на другой нужно снять блокировку с аккаунта с которого будем делать перевод. Блокировка на счет устанавливается автоматически. Это сделано для обеспечения безопасности пользования аккаунтом.
```
personal.unlockAccount('0xa2081622fcc99aec3c1efb575b548c90bdadf8cf','12345678', 0)
```
Здесь первый аргумент — это адрес счета, второй — пароль, а последним аргументом мы задаем время на которое аккаунт будет разблокирован (если указать 0, то аккаунт будет разблокирован на время жизни данного подключения к сети Ethereum). Если подключение прерывается, то аккаунт сразу же блокируется.
Переходим к созданию транзакции:
```
eth.sendTransaction({from: “0xa2081622fcc99aec3c1efb575b548c90bdadf8cf", to: "0x847a20cdec0b3ba98aced771bd1df7e8a2e004f5", value: web3.toWei(1, "ether")})
```
В данном случае мы переводим 1 эфир между счетами. В ответ на вызов, если всё прошло успешно, возвратится адрес транзакции:
По этому адресу можно запросить данные, которые транзакция содержит:
```
eth.getTransaction('0x88839260b77b250458731ba07d351753aba5042dd22c8420a1f6f104f3deede9')
```
Теперь посмотрим баланс на счёте назначения:
Видим, что сеть успешно функционирует. Теперь прикрутим к ней клиентские приложения. Для этого можно использовать SSH-клиент. Пример использования:
```
using (var client = new SshClient(hostUrl, 22, userName, pass))
{
client.Connect();
string commStr = @"curl http://localhost:8545 -X POST --data '{""method"":
""eth_sendTransaction"",
""params"": [{
""from"": ""0xa2081622fcc99aec3c1efb575b548c90bdadf8cf"",
""to"": ""0x847a20cdec0b3ba98aced771bd1df7e8a2e004f5"",
""gas"": ""0x76c0"",
""gasPrice"": ""0x9184e72a000"",
""value"": ""0x9184e72a"",
""data"": ""bla bla""
}], ""id"":1}'";
var comm = client.RunCommand(commStr);
client.Disconnect();
}
```
Это часть кода, в которой переводятся средства с одного счета на другой, с использованием команды `curl` — по сути запрос RPC в нашу сеть. В ответ мы получаем результат выполнения команды в формате JSON с данными созданной транзакции.
#### Заключение
При промышленном применении все будет гораздо сложнее, так как необходимо внедрение и развитие интеллектуальных аналитических алгоритмов, позволяющих установить полный путь движения средств со счета на счет. А также, необходимо будет учесть взаимодействие данного решения на платформе блокчейн с уже существующими сервисами внутри банка.
В данной статье мы продемонстрировали только переводы ether между счетами. Способы при помощи которого отмечали переводы ether с одного счета на другой — уже темы будущих статей.
На фотографии ниже авторы материала: Лёвин Денис, Анастасиев Святослав, Андрей Вариков, — команда разработчиков Модульбанка.
 | https://habr.com/ru/post/312308/ | null | ru | null |
# Виртуальный квадрокоптер на Unity + OpenCV (Часть 2)
Доброго времени суток, дорогие хабравчане!
Этой статьей я хотел бы продолжить серию о том, как подружить Unity, C++ и OpenCV. А также, как получить виртуальную среду для тестирования алгоритмов компьютерного зрения и навигации дронов на основе Unity. В [предыдущей статье](http://habrahabr.ru/post/267791/) я рассказывал о том, как сделать виртуальный квадрокоптер в Unity. В этой статье речь пойдет о том, как подключить C++ плагин, передать туда изображение с виртуальной камеры и обработать его посредством OpenCV.
#### Идея
Идея состоит в том, чтобы рендерить изображение с камеры в текстуру. Далее эта текстура загружается в память видеокарты в Unity, откуда посредством OpenGL извлекается уже внутри C++ и загружается в матрицу OpenCV. Далее можно анализировать/обрабатывать ее OpenCV. И в конце можно передать модифицированную текстуру назад в Unity, загрузив ее на место соответствующей текстуры в память видеокарты. Итак приступим.
#### Рендерим камеры в текстуры
Для начала нам надо создать текстуры, в которые будут помещаться изображения с камер. Для этого в папке assets жмем правую кнопку, затем Create -> Render Texture. Далее нам нужно добавить камеру в наш квадрик. Это делается в Hierarchy, с помощью Create -> Camera. Добавим нашу камеру в Quadrocopter -> Frame, чтобы она прикрепилась к раме. В свойстве камеры Target Texture указываем Render Texture, который мы создали. Также нам хорошо бы видеть текстуру камеры в Unity. Для этого нам потребуется Create -> UI -> Canvas в нашей сцене. Этот объект служит для отображения элементов управления (как правило, двухмерных) на экране. Я назвал его CamerasTextures. В канвас нам надо добавить UI -> RawImage. В параметре Texture картинки указываем нашу текстуру. С помощью Rect Transform внутри RawImage позиционируем картинку в нужное место на экране, это проще всего сделать во вкладке Game. Запускаем и видим как меняется картинка с камеры, пока квадрокоптер летит.
#### Передача текстур в C++
Официальную документацию по плагинам можно найти вот [тут](http://docs.unity3d.com/ru/current/Manual/Plugins.html). Также могут быть полезны официальные примеры: [этот](http://docs.unity3d.com/ru/current/uploads/Examples/RenderingPluginExample45.zip) и [этот](http://docs.unity3d.com/ru/current/uploads/Main/SimplestPluginExample-4.0.zip). Передавать и получать из C++ текстуры я буду в отдельном скрипте. Назовем его GameManager. Чтобы он работал надо добавить на сцену пустой объект и добавить в него этот скрипт. Ниже я, сначала, опишу отдельные части скрипта, потом приведу скрипт целиком. **Функция, передающая идентификатор текстуры в C++**
```
//указатель на текстуру, которая будет передана в плагин.
//указатель нам нужен чтобы иметь доступ в других частях скрипта
private Texture2D cam1Tex;
//эта функция вызывается один раз в начале работы программы
private void PassCamerasTexturesToPlugin () {
// Создаем текстуру
cam1Tex = new Texture2D(256,256,TextureFormat.ARGB32,false);
// Убираем фильтрацию
cam1Tex.filterMode = FilterMode.Point;
// Вызов Apply() загружает текстуру в GPU
cam1Tex.Apply();
// Помещаем вновь созданную текстуру на наш канвас.
// Да, мы меняем текстуру, заданную в предидущем параграфе
GameObject.Find ("/CamerasTextures/Camera1RawImage").GetComponent().texture = cam1Tex;
// Функции, которые непосредственно передают идентификатор текстуры в плагин
#if UNITY\_GLES\_RENDERER
SetTextureOfCam1 (cam1Tex.GetNativeTexturePtr(), cam1Tex.width, cam1Tex.height);
#else
SetTextureOfCam1 (cam1Tex.GetNativeTexturePtr());
#endif
}
// Так выглядит объявление функции передачи идентификатора текстуры
// Определение ее будет внутри плагина
#if UNITY\_IPHONE && !UNITY\_EDITOR
[DllImport ("\_\_Internal")]
#else
// Здесь указывается имя подгружаемой динамической библиотеки, в которой лежит плагин
[DllImport ("QuadrocopterBrain")]
#endif
#if UNITY\_GLES\_RENDERER
private static extern void SetTextureOfCam1(System.IntPtr texture, int w, int h);
#else
private static extern void SetTextureOfCam1(System.IntPtr texture);
#endif
```
**Функция, которая будет обновлять текстуру cam1Tex данными с камеры.**
```
private IEnumerator CallPluginAtEndOfFrames () {
while (true) {
// Подождать пока выполнится рендеринг кадра
yield return new WaitForEndOfFrame();
RenderTexture cam1RT = GameObject.Find ("/Quadrocopter/Frame/Camera1").GetComponent().targetTexture;
// Активный Render Texture - это тот, с которого будут прочитаны пиксели
RenderTexture.active = cam1RT;
cam1Tex.ReadPixels(new Rect(0, 0, cam1RT.width, cam1RT.height), 0, 0);
// Помещаем текстуру в GPU
cam1Tex.Apply ();
RenderTexture.active = null;
// Передаем управление в плагин
// Передающийся int можно использовать например для
// определения какое действие надо совершить в плагине.
// Я его использую как счетчик кадров в debug целях
GL.IssuePluginEvent(GetRenderEventFunc(), frameIndex++);
}
}
// Объявление функции, которая будет возвращать функцию,
// куда будет передано управление в C++
#if UNITY\_IPHONE && !UNITY\_EDITOR
[DllImport ("\_\_Internal")]
#else
[DllImport("QuadrocopterBrain")]
#endif
private static extern IntPtr GetRenderEventFunc();
}
```
**Весь код скрипта должен выглядеть так**
```
using UnityEngine;
using UnityEngine.UI;
using System;
using System.Collections;
using System.Runtime.InteropServices;
public class GameManager : MonoBehaviour {
private Texture2D cam1Tex;
private int frameIndex = 0;
IEnumerator Start () {
PassCamerasTexturesToPlugin ();
yield return StartCoroutine ("CallPluginAtEndOfFrames");
}
private IEnumerator CallPluginAtEndOfFrames () {
while (true) {
// Подождать пока выполнится рендеринг кадра
yield return new WaitForEndOfFrame();
RenderTexture cam1RT = GameObject.Find ("/Quadrocopter/Frame/Camera1").GetComponent().targetTexture;
// Активный Render Texture - это тот, с которого будут прочитаны пиксели
RenderTexture.active = cam1RT;
cam1Tex.ReadPixels(new Rect(0, 0, cam1RT.width, cam1RT.height), 0, 0);
// Помещаем текстуру в GPU
cam1Tex.Apply ();
RenderTexture.active = null;
// Передаем управление в плагин
// Передающийся int можно использовать например для
// определения какое действие надо совершить в плагине.
// Я его использую как счетчик кадров в debug целях
GL.IssuePluginEvent(GetRenderEventFunc(), frameIndex++);
}
}
private void PassCamerasTexturesToPlugin () {
// Создаем текстуру
cam1Tex = new Texture2D(256,256,TextureFormat.ARGB32,false);
// Убираем фильтрацию
cam1Tex.filterMode = FilterMode.Point;
// Вызов Apply() загружает текстуру в GPU
cam1Tex.Apply();
// Помещаем вновь созданную текстуру на наш канвас.
// Да, мы меняем текстуру, заданную в предидущем параграфе
GameObject.Find ("/CamerasTextures/Camera1RawImage").GetComponent().texture = cam1Tex;
// Функции, которые непосредственно передают идентификатор текстуры в плагин
#if UNITY\_GLES\_RENDERER
SetTextureOfCam1 (cam1Tex.GetNativeTexturePtr(), cam1Tex.width, cam1Tex.height);
#else
SetTextureOfCam1 (cam1Tex.GetNativeTexturePtr());
#endif
}
// Так выглядит объявление функции передачи идентификатора текстуры
// Определение ее будет внутри плагина
#if UNITY\_IPHONE && !UNITY\_EDITOR
[DllImport ("\_\_Internal")]
#else
// Здесь указывается имя подгружаемой динамической библиотеки, в которой лежит плагин
[DllImport ("QuadrocopterBrain")]
#endif
#if UNITY\_GLES\_RENDERER
private static extern void SetTextureOfCam1(System.IntPtr texture, int w, int h);
#else
private static extern void SetTextureOfCam1(System.IntPtr texture);
#endif
// Объявление функции, которая будет возвращать функцию,
// куда будет передано управление в C++
#if UNITY\_IPHONE && !UNITY\_EDITOR
[DllImport ("\_\_Internal")]
#else
[DllImport("QuadrocopterBrain")]
#endif
private static extern IntPtr GetRenderEventFunc();
}
```
#### OpenCV
Так как мы собираемся использовать OpenCV для обработки изображений вам нужно будет установить его себе. Подойдет обычный ванильный OpenCV, взятый с [официального сайта](http://opencv.org/). Ставил я его себе по [гайду](http://tilomitra.com/opencv-on-mac-osx/). Если вы пытаетесь повторять написанное в статье, то советую для начала сделать и скомпилировать пустой проект динамической библиотеки, которая бы как-либо использовала OpenCV. Вышеназванный гайд должен вам помочь. Также будут нужны функции работы с OpenGL.
**Пример пустой библиотеки**
```
#include
void someFunc () {
cv::Mat img (256, 256, CV\_8UC4);
return 0;
}
```
#### Получение и обработка текстур в плагине
Здесь я тоже для начала приведу отдельные фрагменты программы, а потом уже весь код целиком.
**Функция передачи идентификатора текстуры**
```
//переменные для хранения идентификатора текстуры
static void* g_Cam1TexturePointer = NULL;
#ifdef SUPPORT_OPENGLES
static int g_TexWidth = 0;
static int g_TexHeight = 0;
#endif
//Определение функции передачи идентификатора текстуры.
//Объявление находится в C# скрипте
#ifdef SUPPORT_OPENGLES
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API SetTextureOfCam1(void* texturePtr, int w, int h)
#else
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API SetTextureOfCam1(void* texturePtr)
#endif
{
g_Cam1TexturePointer = texturePtr;
#ifdef SUPPORT_OPENGLES
g_TexWidth = w;
g_TexHeight = h;
#endif
}
```
**Функция обработки текстуры**
```
static void UNITY_INTERFACE_API OnRenderEvent(int eventID) {
//если вы посмотрите в пример RenderingPluginExampleXX.zip,
//то увидите здесь большее количество кода для разных платформ, я оставил здесь только OpenGL.
//Передача текстур на разных платформах осуществляется по разному, если у вас другая платформа
//обратитесь к коду примера
#if SUPPORT_OPENGL
if (g_Cam1TexturePointer) {
GLuint gltex = (GLuint)(size_t)(g_Cam1TexturePointer);
glBindTexture (GL_TEXTURE_2D, gltex);
int texWidth, texHeight;
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texWidth);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &texHeight);
// Матрица OpenCV, в которую будет считана текстура
cv::Mat img (texHeight, texWidth, CV_8UC4);
// Считывание текстуры в матрицу
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.data);
// В качестве тестовой обработки просто напишем на текстуре Cam1
cv::putText(img, "Cam1", cv::Point2f(10,50), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 0, 255), 3);
// Загружаем назад в память текстуру, чтобы отобразить ее в Unity.
// Unity не позволяет обращаться к GUI функциям OpenCV, так что никакие imshow работать не будут
// Поэтому весь вывод графической информации надо осуществлять передачей ее в Unity
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, img.data);
}
#endif
}
// см GameManager.cs
extern "C" UnityRenderingEvent UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API GetRenderEventFunc() {
return OnRenderEvent;
}
```
У меня плагин состоит из 2х файлов:
**Main.h**
```
#ifndef __QuadrocopterBrain__Main__
#define __QuadrocopterBrain__Main__
// Which platform we are on?
#if _MSC_VER
#define UNITY_WIN 1
#elif defined(__APPLE__)
#if defined(__arm__)
#define UNITY_IPHONE 1
#else
#define UNITY_OSX 1
#endif
#elif defined(__linux__)
#define UNITY_LINUX 1
#elif defined(UNITY_METRO) || defined(UNITY_ANDROID)
// these are defined externally
#else
#error "Unknown platform!"
#endif
// Which graphics device APIs we possibly support?
#if UNITY_METRO
#define SUPPORT_D3D11 1
#elif UNITY_WIN
#define SUPPORT_D3D9 1
#define SUPPORT_D3D11 1 // comment this out if you don't have D3D11 header/library files
#ifdef _MSC_VER
#if _MSC_VER >= 1900
#define SUPPORT_D3D12 1
#endif
#endif
#define SUPPORT_OPENGL 1
#elif UNITY_IPHONE || UNITY_ANDROID
#define SUPPORT_OPENGLES 1
#elif UNITY_OSX || UNITY_LINUX
#define SUPPORT_OPENGL 1
#endif
#endif /* defined(__QuadrocopterBrain__Main__) */
```
**Main.cpp**
```
#include
#include
#include
#include
#include "Unity/IUnityGraphics.h"
#include
#include "Main.h"
// --------------------------------------------------------------------------
// Include headers for the graphics APIs we support
#if SUPPORT\_D3D9
#include
#include "Unity/IUnityGraphicsD3D9.h"
#endif
#if SUPPORT\_D3D11
#include
#include "Unity/IUnityGraphicsD3D11.h"
#endif
#if SUPPORT\_D3D12
#include
#include "Unity/IUnityGraphicsD3D12.h"
#endif
#if SUPPORT\_OPENGLES
#if UNITY\_IPHONE
#include
#elif UNITY\_ANDROID
#include
#endif
#elif SUPPORT\_OPENGL
#if UNITY\_WIN || UNITY\_LINUX
#include
#else
#include
#endif
#endif
// Prints a string
static void DebugLog (const char\* str)
{
#if UNITY\_WIN
OutputDebugStringA (str);
#else
fprintf(stderr, "%s", str);
#endif
}
//переменные для хранения идентификатора текстуры
static void\* g\_Cam1TexturePointer = NULL;
#ifdef SUPPORT\_OPENGLES
static int g\_TexWidth = 0;
static int g\_TexHeight = 0;
#endif
//Определение функции передачи идентификатора текстуры.
//Объявление находится в C# скрипте
#ifdef SUPPORT\_OPENGLES
extern "C" void UNITY\_INTERFACE\_EXPORT UNITY\_INTERFACE\_API SetTextureOfCam1(void\* texturePtr, int w, int h)
#else
extern "C" void UNITY\_INTERFACE\_EXPORT UNITY\_INTERFACE\_API SetTextureOfCam1(void\* texturePtr)
#endif
{
g\_Cam1TexturePointer = texturePtr;
#ifdef SUPPORT\_OPENGLES
g\_TexWidth = w;
g\_TexHeight = h;
#endif
}
static void UNITY\_INTERFACE\_API OnRenderEvent(int eventID) {
//если вы посмотрите в пример RenderingPluginExampleXX.zip,
//то увидите здесь большее количество кода для разных платформ, я оставил здесь только OpenGL.
//Передача текстур на разных платформах осуществляется по разному, если у вас другая платформа
//обратитесь к коду примера
#if SUPPORT\_OPENGL
if (g\_Cam1TexturePointer) {
GLuint gltex = (GLuint)(size\_t)(g\_Cam1TexturePointer);
glBindTexture (GL\_TEXTURE\_2D, gltex);
int texWidth, texHeight;
glGetTexLevelParameteriv (GL\_TEXTURE\_2D, 0, GL\_TEXTURE\_WIDTH, &texWidth);
glGetTexLevelParameteriv (GL\_TEXTURE\_2D, 0, GL\_TEXTURE\_HEIGHT, &texHeight);
// Матрица OpenCV, в которую будет считана текстура
cv::Mat img (texHeight, texWidth, CV\_8UC4);
// Считывание текстуры в матрицу
glGetTexImage(GL\_TEXTURE\_2D, 0, GL\_RGBA, GL\_UNSIGNED\_BYTE, img.data);
// В качестве тестовой обработки просто напишем на текстуре Cam1
cv::putText(img, "Cam1", cv::Point2f(10,50), cv::FONT\_HERSHEY\_SIMPLEX, 2, cv::Scalar(0, 0, 0, 255), 3);
// Загружаем назад в память текстуру, чтобы отобразить ее в Unity.
// Unity не позволяет обращаться к GUI функциям OpenCV, так что никакие imshow работать не будут
// Поэтому весь вывод графической информации надо осуществлять передачей ее в Unity
glTexSubImage2D (GL\_TEXTURE\_2D, 0, 0, 0, texWidth, texHeight, GL\_RGBA, GL\_UNSIGNED\_BYTE, img.data);
}
#endif
}
// --------------------------------------------------------------------------
// UnitySetInterfaces
static void UNITY\_INTERFACE\_API OnGraphicsDeviceEvent(UnityGfxDeviceEventType eventType);
static IUnityInterfaces\* s\_UnityInterfaces = NULL;
static IUnityGraphics\* s\_Graphics = NULL;
static UnityGfxRenderer s\_DeviceType = kUnityGfxRendererNull;
extern "C" void UNITY\_INTERFACE\_EXPORT UNITY\_INTERFACE\_API UnityPluginLoad(IUnityInterfaces\* unityInterfaces)
{
DebugLog("--- UnityPluginLoad");
s\_UnityInterfaces = unityInterfaces;
s\_Graphics = s\_UnityInterfaces->Get();
s\_Graphics->RegisterDeviceEventCallback(OnGraphicsDeviceEvent);
// Run OnGraphicsDeviceEvent(initialize) manually on plugin load
OnGraphicsDeviceEvent(kUnityGfxDeviceEventInitialize);
}
extern "C" void UNITY\_INTERFACE\_EXPORT UNITY\_INTERFACE\_API UnityPluginUnload()
{
s\_Graphics->UnregisterDeviceEventCallback(OnGraphicsDeviceEvent);
}
// --------------------------------------------------------------------------
// GraphicsDeviceEvent
// Actual setup/teardown functions defined below
#if SUPPORT\_D3D9
static void DoEventGraphicsDeviceD3D9(UnityGfxDeviceEventType eventType);
#endif
#if SUPPORT\_D3D11
static void DoEventGraphicsDeviceD3D11(UnityGfxDeviceEventType eventType);
#endif
#if SUPPORT\_D3D12
static void DoEventGraphicsDeviceD3D12(UnityGfxDeviceEventType eventType);
#endif
#if SUPPORT\_OPENGLES
static void DoEventGraphicsDeviceGLES(UnityGfxDeviceEventType eventType);
#endif
static void UNITY\_INTERFACE\_API OnGraphicsDeviceEvent(UnityGfxDeviceEventType eventType)
{
UnityGfxRenderer currentDeviceType = s\_DeviceType;
switch (eventType)
{
case kUnityGfxDeviceEventInitialize:
{
DebugLog("OnGraphicsDeviceEvent(Initialize).\n");
s\_DeviceType = s\_Graphics->GetRenderer();
currentDeviceType = s\_DeviceType;
break;
}
case kUnityGfxDeviceEventShutdown:
{
DebugLog("OnGraphicsDeviceEvent(Shutdown).\n");
s\_DeviceType = kUnityGfxRendererNull;
g\_Cam1TexturePointer = NULL;
break;
}
case kUnityGfxDeviceEventBeforeReset:
{
DebugLog("OnGraphicsDeviceEvent(BeforeReset).\n");
break;
}
case kUnityGfxDeviceEventAfterReset:
{
DebugLog("OnGraphicsDeviceEvent(AfterReset).\n");
break;
}
};
#if SUPPORT\_D3D9
if (currentDeviceType == kUnityGfxRendererD3D9)
DoEventGraphicsDeviceD3D9(eventType);
#endif
#if SUPPORT\_D3D11
if (currentDeviceType == kUnityGfxRendererD3D11)
DoEventGraphicsDeviceD3D11(eventType);
#endif
#if SUPPORT\_D3D12
if (currentDeviceType == kUnityGfxRendererD3D12)
DoEventGraphicsDeviceD3D12(eventType);
#endif
#if SUPPORT\_OPENGLES
if (currentDeviceType == kUnityGfxRendererOpenGLES20 ||
currentDeviceType == kUnityGfxRendererOpenGLES30)
DoEventGraphicsDeviceGLES(eventType);
#endif
}
// --------------------------------------------------------------------------
// GetRenderEventFunc, an example function we export which is used to get a rendering event callback function.
extern "C" UnityRenderingEvent UNITY\_INTERFACE\_EXPORT UNITY\_INTERFACE\_API GetRenderEventFunc()
{
return OnRenderEvent;
}
```
#### Как собрать все воедино
Создаем в папке Assets папку Plugins. В нее помещаем наш плагин. Просто воспользовавшись вашей любимой утилитой для работы с файловой системой. Unity загружает динамическую библиотеку только один раз, поэтому если вы будете вносить изменения в нее, то необходимо будет перезапускать Unity. Запускаем и видим зеркально отображенную надпись «Cam1» на картинке с камеры. Так происходит из-за различия представления текстуры в OpenGL и OpenCV.
Код доступен на [гитхабе](https://github.com/parilo/quadrocopter-unity-opencv.git) в ветке habr\_part2 | https://habr.com/ru/post/269007/ | null | ru | null |
# Самопальная ORM для Битрикс
Не смотря на то, что модуль с поддержкой ORM разработчики битрикса анонсировали ещё в конце прошлого года, и того, что этот модуль заявлен в списке доступных в практически всех редакциях, реально его пока что нет в комплекте, как нет по нему и документации. Оставим за кадром неэтичность включения отсутствующих фич в описание продукта в разделе покупки, вернемся к ORM. Раз его нет — почему бы не реализовать нечто подобное самостоятельно?
Для нетерпеливых — сразу дам [ссылку на исходники модуля, на GitHub'е.](https://github.com/Newbilius/bitrix.orm) Это как-бы прототип — потому что имеет некоторые проблемы, да и не все моменты решены красиво, но тем не менее, он уже работает. Так что всё-таки наш продукт. Хоть и прототип. На написание кода ушло менее 4х часов, со всеми вытекающими.
#### Полезности
* Реализован механизм создания объектов нужных классов через фабрику.
```
$item=new ORM(5); //создаем объект инфоблока с номером 5
$item=ORM::Factory(5); //аналогично
$item=new ORM("news"); //создаем объект инфоблока с CODE=news
$item=ORM::Factory("news"); //сначала будет попытка создать объект класса newsBitrixOrm или NewsBitrixOrm, если таковой не будет найдет - попытка создать объект инфоблока с CODE=news
```
* Есть поддержка сеттеров и геттеров, автоматически применяемых при работе с полями.
```
class NewsBitrixORM extends ORM{
protected $IBlockID=1;
protected $auto_getters = array("NAME"=>"GetNameValue");
protected $auto_setters = array("NAME"=>"SetNameValue");
public function GetNameValue($value){
return str_replace(" (имя новости!)", "", $this->_data["NAME"]);
}
public function SetNameValue($value){
$this->_data["NAME"]=$value." (имя новости!)";
$this->_changed_fields["NAME"]="NAME";
return true;
}
}
```
* Реализованы все базовые действия (создание, удаление, изменение, поиск по различным фильтрам).
```
$ormNews = ORM::Factory(4);
$list=$ormNews->Where("WIDTH","=","140")->FindAll();
foreach ($list as $_news){
$_news->NAME="Новость с номером {$_news->ID}";
$_news->WIDTH=24;
echo "
```
".print_r($_news->AsArray(true),true)."
```
";
if ($_news->ID%2==0) $_news->Delete(); else {
$_news->NAME.=" [обновлена!]";
$_news->Save();
}
}
```
* Работа как со стандартными полями, так и с пользовательскими свойствами идет совершенно одинаково.
* Есть своя особенность при работе с полями типа «список». Например, у нас есть свойство `COLOR`. При работе с ним будет видно два поля — `COLOR`, содержащее текстовое значение выбранного элемента списка, и `COLOR__ID` (два подчеркивания), содержащее ID выбранного варианта. Для изменения значения нужно назначить ему ID другого варианта списка (например `$item->ID=5`), при этом автоматически `COLOR__ID` получит это значение, а `COLOR` — изменит текстовое значение.
#### Недостатки
* некоторое уменьшение скорости. Работает с уже существующим API для работы с данными инфоблоков, а не напрямую с базой. С другой стороны, эти части можно и переписать, после чего весь код, завязанный на данную ORM продолжит работать
* работает исключительно с элементами (не с папками)
* отсутствуют нормальные механизмы для сложных запросов со вложениями запросами, с OR-запросами.
* отсутствует возможность наполнять свойства-массивы (множественные свойства) запросом вида $obj->item[]=«значение»; Вместо него пока приходится использовать AddToArrayValue(«item»,«значение»). Как обойти этот момент, пока что не придумал.
* отсутствует решения для создания зависимостей между инфоблоками (один к одному, один ко многим и т.п.) | https://habr.com/ru/post/175705/ | null | ru | null |
# Создание шейдера дыма на GLSL
*[Дым на КДПВ несколько сложнее получаемого в туториале.]*
Дым всегда был окружён ореолом таинственности. На него приятно смотреть, но сложно моделировать. Как и многие другие физические явления, дым — это хаотическая система, которую очень сложно предсказать. Состояние симуляции сильно зависит от взаимодействия между отдельными частицами.
Именно поэтому его так сложно обрабатывать в видеопроцессоре: дым можно разбить на поведение одной частицы, повторяемой миллионы раз в различных местах.
В этом туториале я подробно расскажу о создании шейдера дыма с нуля и научу вас некоторым полезным техникам разработки шейдеров, чтобы вы могли расширить свой арсенал и создавать собственные эффекты.
Чему мы научимся
----------------
Вот конечный результат, к которому мы будем стремиться:
Мы реализуем алгоритм, описанный в [работе Джоса Стэма о динамике жидкостей в играх в реальном времени](http://www.dgp.toronto.edu/people/stam/reality/Research/pdf/GDC03.pdf). Кроме того, мы узнаем, как *рендерить в текстуру*, эта техника также называется *буферы кадров*. Она очень полезна в программировании шейдеров, потому что позволяет создать множество эффектов.
Подготовка
----------
В примерах и реализации кода этого туториала используется JavaScript и [ThreeJS](http://threejs.org/), но вы сможете применять его на любой платформе с поддержкой шейдеров. (Если вы незнакомы с основами программирования, то вам стоит изучить [этот туториал](https://habrahabr.ru/post/333002/).)
Все примеры кода хранятся на CodePen, но их можно также найти в связанном со статьёй [репозитории GitHub](https://github.com/OmarShehata/Beginners-Guide-to-Shaders) (там код может быть удобнее читать).
Теория и основы
---------------
Алгоритм из работы Джоса Стэма отдаёт приоритет скорости и визуальному качеству в ущерб физической точности, именно это и нужно нам в играх.
Эта работа может показаться намного сложнее, чем на есть самом деле, в особенности если вы не знакомы с дифференциальными уравнениями. Однако смысл техники вкратце изложен на этом рисунке:
*Благодаря рассеиванию каждая ячейка обменивается своей плотностью с соседями.*
Это всё, что потребуется для создания реалистично выглядящего эффекта дыма: значение в каждой ячейке при каждой итерации «рассеивается» во все её соседние ячейки. Этот принцип не всегда понятен сразу, если вы хотите поэкспериментировать с примером, то можно [изучить интерактивное демо](http://codepen.io/tutsplus/full/RrVpxd/):
[Просмотреть интерактивное демо на CodePen](http://codepen.io/tutsplus/full/RrVpxd/).
При нажатии на любую ячейку ей присваивается значение `100`. Вы видите, как каждая ячейка постепенно передаёт своё значение соседним. Проще всего это увидеть, нажав **Next** для просмотра отдельных кадров. Переключите **Display Mode**, чтобы увидеть, как это будет выглядеть, когда этим числам соответствуют значения цвета.
Представленное выше демо работает на центральном процессоре, цикл перебирает каждую ячейку. Вот как выглядит этот цикл:
```
//W = количество столбцов в сетке
//H = количество строк
//f = коэффициент распределения/рассеивания
//Сначала мы копируем сетку в newGrid, чтобы не изменять сетку, потому что выполняем считывание из неё
for(var r=1; r
```
Этот фрагмент кода является основой алгоритма. Каждая ячейка получает часть значений четырёх соседних ячеек минус её собственное значение, где `f` — коэффициент меньше 1. Мы умножаем текущее значение ячейки на 4, чтобы оно рассеивалось от высоких к низким значениям.
Чтобы это стало понятно, рассмотрим следующую ситуацию:
Возьмём **ячейку посередине** (в позиции `[1,1]` в сетке) и применим указанное выше уравнение рассеивания. Допустим, что `f` равен `0.1`:
```
0.1 * (100+100+100+100-4*100) = 0.1 * (400-400) = 0
```
Никакого рассеивания не происходит, потому что все ячейки имеют одинаковые значения!
Рассмотрим тогда *ячейку в верхнем левом углу* (считаем, что значения всех ячеек за пределами показанной сетки равны `0`):
```
0.1 * (100+100+0+0-4*0) = 0.1 * (200) = 20
```
Итак, теперь у нас получился чистый *прирост* 20! Давайте рассмотрим последний случай. После одного временного шага (после применения этой формулы ко всем ячейкам) наша сетка будет выглядеть вот так:
Давайте снова посмотрим на рассеивание в *ячейке посередине*:
```
0.1 * (70+70+70+70-4*100) = 0.1 * (280 - 400) = -12
```
Мы получили чистое *уменьшение* в 12! Поэтому значения всегда изменяются от больших к меньшим.
Теперь, если мы хотим большей реалистичности, нам нужно уменьшить размер ячеек (что можно сделать в демо), но на определённом этапе всё начнёт очень тормозить, потому что мы должны последовательно проходить через каждую ячейку. Наша цель — написать этот алгоритм в шейдере, который сможет использовать мощь видеопроцессора для обработки всех ячеек (как пикселей) одновременно и параллельно.
Итак, подведём итог: наша общая техника заключается в том, что каждый пиксель каждый кадр теряет часть своего значения цвета и передаёт его соседним пикселям. Звучит очень просто, не так ли? Давайте реализуем эту систему и посмотрим, что получится!
Реализация
----------
Мы начнём с базового шейдера, который выполняет отрисовку всего экрана. Чтобы убедиться, что он работает, попробуем закрасить экран сплошным чёрным цветом (или любым другим). Вот как выглядит схема, которую я использую в Javascript.
Нажимайте на кнопки вверху, чтобы увидеть код HTML, CSS и JS.
Наш шейдер прост:
```
uniform vec2 res;
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
gl_FragColor = vec4(0.0,0.0,0.0,1.0);
}
```
`res` и `pixel` сообщают нам координаты текущего пикселя. Мы передаём размеры экрана в `res` как uniform-переменную. (Пока мы их не используем, но скоро они пригодятся.)
### Шаг 1: перемещаем значения между пикселями
Повторю ещё раз то, что мы хотим реализовать:
> *Наша общая техника заключается в том, что каждый пиксель каждый кадр теряет часть своего значения цвета и передаёт его соседним пикселям.*
В этой формулировке реализация шейдера *невозможна*. Понимаете, почему? Вспомните, единственное, что может делать шейдер — возвращать значение цвета текущего обрабатываемого пикселя. То есть нам нужно переформулировать задачу таким образом, чтобы решение влияло только на текущий пиксель. Мы можем сказать:
> Каждый пиксель должен **получить** немного цвета своих соседей и потерять немного своего.
Теперь это решение можно реализовать. Однако если попробовать сделать это, то мы наткнёмся на фундаментальную проблему…
Рассмотрим более простой случай. Допустим, нам нужен шейдер, постепенно перекрашивающий изображение в красный цвет. Можно написать следующий шейдер:
```
uniform vec2 res;
uniform sampler2D texture;
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
gl_FragColor = texture2D( tex, pixel );// Это цвет текущего пикселя
gl_FragColor.r += 0.01;// Инкремент красного компонента
}
```
Можно ожидать, что каждый кадр красный компонент каждого пикселя будет увеличиваться на `0.01`. Вместо этого мы получим статичное изображение, в котором все пиксели стали всего немного краснее, чем в начале. Красный компонент каждого пикселя увеличится только один раз, несмотря на то, что шейдер выполняется каждый кадр.
Понимаете, почему так происходит?
#### Проблема
Проблема в том, что любая операция, которую мы выполняем с шейдером, передаётся на экран, а потом исчезает навечно. Сейчас наш процесс выглядит так:
Мы передаём uniform-переменные и текстуру шейдеру, он делает пиксели немного краснее, отрисовывает их на экране, а затем начинает всё заново. *Всё, что мы отрисовываем в шейдере, очищается при следующем шаге отрисовки.*
Нам же нужно что-то вроде этого:
Вместо прямой отрисовки на экран, мы можем отрисовывать пиксели в текстуру, а затем отрисовывать на экране уже *эту текстуру*. На экране будет отображаться то же самое изображение, за исключением того, что теперь мы можем передавать выходные данные в качестве входных. Так можно получить шейдеры, которые накапливают или распространяют значения, а не просто сбрасываются каждый кадр. Вот это и называется «фокусом с буфером кадра».
#### Фокус с буфером кадра
Общая техника будет одинакова для всех платформ. Загуглите *«рендеринг в текстуру»* для любого используемого вами языка или инструмента и изучите подробности реализации. Также можно посмотреть, как использовать *объекты буфера кадра*, которые являются просто ещё одним названием для функции рендеринга в какой-нибудь буфер вместо экрана.
В ThreeJS аналог этой функции — [WebGLRenderTarget](http://threejs.org/docs/#Reference/Renderers/WebGLRenderTarget). Именно его мы будем использовать в качестве промежуточной текстуры для рендеринга. Однако осталось небольшое препятствие: *нельзя считывать и рендерить в одну текстуру одновременно*. Проще всего обойти это ограничение использованием двух текстур.
Пусть A и B — это две созданные нами текстуры. Тогда способ будет следующим:
1. Передаём A через шейдер, рендерим в B.
2. Рендерим B на экран.
3. Передаём B через шейдер, рендерим в A.
4. Рендерим A на экран.
5. Повторяем 1.
Более краткий код будет следующим:
1. Передаём A через шейдер, рендерим в B.
2. Рендерим B на экран.
3. Меняем A и B *(то есть переменная A теперь содержит текстуру, находившуюся в B, и наоборот).*
4. Повторяем 1.
На этом всё. Вот реализация этого алгоритма в ThreeJS:
Новый код шейдера находится во вкладке **HTML**.
Мы по-прежнему видим чёрный экран, с которого и начинали. Шейдер тоже не слишком отличается:
```
uniform vec2 res; // Ширина и высота экрана
uniform sampler2D bufferTexture; // Входная текстура
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
gl_FragColor = texture2D( bufferTexture, pixel );
}
```
Кроме того, что теперь мы добавили эту строку ([протестируйте!](http://codepen.io/tutsplus/pen/gPWmoN)):
```
gl_FragColor.r += 0.01;
```
Вы увидите, что экран постепенно становится красным. Это довольно важный шаг, поэтому мы можем ненадолго остановиться на нём и сравнить его с тем, как работал алгоритм изначально.
**Задача:** Что произойдёт, если мы вставим `gl_FragColor.r += pixel.x;` в примере с буфером кадра, в отличие от первоначального примера? Подумайте немного, почему отличаются результаты, и почему они именно такие.
### Шаг 2: получаем источник дыма
Прежде чем мы заставим всё двигаться, нам нужно найти способ создания дыма. Простейший способ — вручную закрасить произвольную область в шейдере белым цветом.
```
// Получаем расстояние от этого пикселя до центра экрана
float dist = distance(gl_FragCoord.xy, res.xy/2.0);
if(dist < 15.0){ // Создаём круг радиусом 15 пикселей
gl_FragColor.rgb = vec3(1.0);
}
```
Если мы хотим проверить правильность работы буфера кадра, то можно попробовать *прибавлять* к значению цвета, а не просто назначать его. Вы увидите, что круг постепенно становится всё белее.
```
// Получаем расстояние от этого пикселя до центра экрана
float dist = distance(gl_FragCoord.xy, res.xy/2.0);
if(dist < 15.0){ // Создаём круг радиусом 15 пикселей
gl_FragColor.rgb += 0.01;
}
```
Ещё один способ — заменить эту фиксированную точку положением мыши. Мы можем передавать третье значение, сообщающее о том, нажата ли клавиша мыши. Таким образом мы можем создавать дым нажатием левой клавиши. Вот реализация этой возможности:
Нажмите, чтобы создать дым.
Вот как выглядит наш шейдер:
```
// Ширина и высота экрана
uniform vec2 res;
// Входная текстура
uniform sampler2D bufferTexture;
// x,y - это положение. z - это сила/плотность
uniform vec3 smokeSource;
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
gl_FragColor = texture2D( bufferTexture, pixel );
// Получаем расстояние от текущего пикселя до источника дыма
float dist = distance(smokeSource.xy,gl_FragCoord.xy);
// Создаём дым, когда нажата клавиша мыши
if(smokeSource.z > 0.0 && dist < 15.0){
gl_FragColor.rgb += smokeSource.z;
}
}
```
**Задача:** не забывайте, что ветвление (условные переходы) обычно в шейдерах затратны. Можете переписать шейдер без использования конструкции if? (Решение есть в CodePen.)
Если вы не понимаете, то в [предыдущем туториале](https://habrahabr.ru/post/333002/) есть подробное объяснение использования мыши в шейдерах (в части об освещении).
### Шаг 3: рассеиваем дым
Теперь простая, но самая интересная часть! Мы собрали всё воедино, нам осталось наконец сказать шейдеру: *каждый пиксель должен* получать *часть цвета от его соседей, и терять часть своего.*
Это выражается примерно так:
```
// Рассеивание дыма
float xPixel = 1.0/res.x; // Размер единичного пикселя
float yPixel = 1.0/res.y;
vec4 rightColor = texture2D(bufferTexture,vec2(pixel.x+xPixel,pixel.y));
vec4 leftColor = texture2D(bufferTexture,vec2(pixel.x-xPixel,pixel.y));
vec4 upColor = texture2D(bufferTexture,vec2(pixel.x,pixel.y+yPixel));
vec4 downColor = texture2D(bufferTexture,vec2(pixel.x,pixel.y-yPixel));
// Уравнение рассеивания
gl_FragColor.rgb +=
14.0 * 0.016 *
(
leftColor.rgb +
rightColor.rgb +
downColor.rgb +
upColor.rgb -
4.0 * gl_FragColor.rgb
);
```
Коэффициент `f` остаётся прежним. В этом случае у нас есть временной шаг (`0.016`, то есть 1/60, потому что программа выполняется с частотой 60 fps), и я подбирал разные числа, пока не остановился на значении `14`, которое хорошо выглядит. Вот результат:
#### Ой-ёй, всё зависло!
Это то же самое уравнение рассеивания, которое мы использовали в демо для центрального процессора, но наша симуляция останавливается! В чём причина?
Оказывается, что текстуры (как и все числа в компьютере) имеют ограниченную точность. В какой-то момент коэффициент, который мы вычитаем, становится слишком маленьким и округляется до 0, поэтому симуляция останавливается. Чтобы исправить это, нам нужно проверять, что он не опускается ниже какого-нибудь минимального значения:
```
float factor = 14.0 * 0.016 * (leftColor.r + rightColor.r + downColor.r + upColor.r - 4.0 * gl_FragColor.r);
// Нам нужно учитывать низкую точность текселов
float minimum = 0.003;
if (factor >= -minimum && factor < 0.0) factor = -minimum;
gl_FragColor.rgb += factor;
```
Я использую для получения коэффициента компонент `r` вместо `rgb`, потому что легче работать с отдельными числами и потому, что все компоненты всё равно имеют одинаковые значения (так как дым белый).
Путём проб и ошибок я обнаружил, что хорошим пороговым значением будет `0.003`, при котором программа не останавливается. Меня беспокоит только коэффициент при отрицательном значении, чтобы гарантировать его постоянное уменьшение. Добавив это исправление, мы получим следующее:
### Шаг 4: рассеивание дыма вверх
Но это всё ещё не очень похоже на дым. Если мы хотим, чтобы он поднимался вверх, а не во всех направлениях, нам нужно добавить веса. Если нижние пиксели всегда будут влиять сильнее, чем другие направления, то будет казаться, что пиксели поднимаются вверх.
Поэкспериментировав с коэффициентами, мы можем подобрать то, что выглядит в этом уравнении очень прилично:
```
// Уравнение рассеивания
float factor = 8.0 * 0.016 *
(
leftColor.r +
rightColor.r +
downColor.r * 3.0 +
upColor.r -
6.0 * gl_FragColor.r
);
```
И вот как выглядит шейдер:
#### Примечание об уравнении рассеивания
Я просто поиграл с коэффициентами, чтобы поднимающийся вверх дым выглядел красиво. Вы можете заставить его двигаться в любом другом направлении.
Важно добавить, что очень просто «взорвать» симуляцию. (Попробуйте [изменить](http://codepen.io/tutsplus/pen/OMmpwJ) значение `6.0` на `5.0` и посмотрите, что получится). Очевидно, что это происходит из-за того, что ячейки получают больше, чем теряют.
Это уравнение на самом деле упоминается в процитированной мной работе как модель «плохого рассеивания». В работе есть другое уравнение, которое более стабильно, но оно не очень удобно для нас, в основном потому, что ему требуется запись в сетку, из которой мы считываем. Другими словами, нам потребуется считывать и записывать одну текстуру одновременно.
Того, что у нас есть, достаточно для наших целей, но если интересно, можете изучить объяснение в работе. Кроме того, другое уравнение реализовано в [интерактивном демо для центрального процессора](http://codepen.io/tutsplus/full/RrVpxd/), см. функцию `diffuse_advanced()`.
#### Небольшое исправление
Вы могли заметить, что при создании дыма в нижней части экрана он там застревает. Так происходит потому, что пиксели в нижней строке пытаются получить значения из несуществующих пикселей под ними.
Чтобы исправить это, мы дадим нижним пикселям находить под собой `0`:
```
// Обрабатываем нижнюю границу
// Эти строки нужно выполнять до функции рассеивания
if(pixel.y <= yPixel){
downColor.rgb = vec3(0.0);
}
```
В демо для ЦП я справился с этим, просто сделав так, чтобы нижние ячейки не рассеивались. Можно также вручную задать всем ячейкам за границами значение `0`. (Сетка в демо для ЦП выходит за границы во всех направлениях на одну строку и один столбец, то есть мы никогда не видим границ)
Сетка скоростей
---------------
Поздравляю! Теперь у вас есть готовый шейдер дыма! В конце я хотел бы кратко рассказать об упоминаемом в работе поле скоростей.
*Этап переноса (адвекции) перемещает плотность по статичному полю скоростей.*
Дым не обязан одинаково рассеиваться вверх или в любом другом направлении, он может следовать общему шаблону, например тому, который показан на рисунке. Можно реализовать это отправкой другой текстуры, в которой значения цветов представляют направление, в котором должен двигаться дым в текущей точке. Это аналогично использованию карты нормалей для указания направления каждого пикселя в туториале об освещении.
На самом деле текстура скоростей тоже не обязана быть статичной! Можно использовать фокус с буфером кадра для изменения скоростей в реальном времени. Я не буду рассказывать об этом в туториале, но эта функция имеет большой потенциал для исследований.
Заключение
----------
Самое важное, что можно почерпнуть из этого туториала: возможность рендеринга в текстуру вместо экрана — это очень полезная техника.
#### Для чего могут пригодиться буферы кадров?
Их часто используют для *постпроцессинга* в играх. Если вы хотите применить цветной фильтр, вместо использования его с каждым объектом, можно отрендерить все объекты в текстуру по размеру экрана, а затем применить шейдер к этой текстуре и отрисовать её на экране.
Ещё один пример использования — реализация шейдеров, требующих *нескольких проходов. например blur*. Обычно изображение пропускается через шейдер, размывается по оси x, а затем пропускается снова для размывания по оси y.
Последний пример — это *отложенный рендеринг*, который мы обсуждали в [предыдущем туториале](https://habrahabr.ru/post/333002/). Это простой способ эффективного добавления в сцену множества источников света. Здесь здорово то, что вычисление освещения больше не зависит от количества источников света.
#### Не бойтесь технических статей
Намного больше подробностей можно найти в процитированной мной работе. Оно требует знакомства с линейной алгеброй, но пусть это не помешает вам проанализировать и попробовать реализовать систему. Суть её довольно просто реализовать (после некоторой подстройки коэффициентов).
Надеюсь, что вы немного больше узнали о шейдерах и статья оказалась полезной. | https://habr.com/ru/post/333718/ | null | ru | null |
# Укрощение батчинга за счет оптимизации масок UI
Часто мы сталкиваемся с задачей оптимизации интерфейсов, и приходится отлаживать то, что давно работает, но периодически усложняется. На таких экранах проблемы могут нарастать как снежный ком — до тех пор, пока не станут заметны невооруженным глазом. И когда придет время улучшить производительность, придется выбирать: либо переделывать все заново и сразу хорошо, либо решать проблемы по очереди.
В какой-то момент мы в War Robots столкнулись с необходимостью оптимизировать экран акций: обнаружилось, что для отрисовки этого экрана Unity совершала более 300 батчей. Для сравнения: куда более сложный экран ангара, содержащий 3D-сцену, 3D- и 2D-интерфейсы, эффекты и анимации, рисовался примерно за 100 батчей.
В этой статье я расскажу о том, как нам удалось починить динамический батчинг, упростить иерархию и поднять FPS в интерфейсе.
---
Прежде всего, давайте разберемся, что же такое батч.
***Батч*** (batch) — это одна команда от ЦП, содержащая в себе данные и инструкцию, по которой GPU создает изображение на экране. Один кадр состоит из множества таких батчей — примерно как слои в любом графическом редакторе. Нельзя сказать, что в общем случае уменьшение количества батчей означает больше FPS, но нередко можно получить выигрыш производительности именно за счет такой оптимизации.
В Unity есть возможность включить автоматический процесс совмещения таких команд — ***батчинг***. Если две или более команды, идущие подряд, должны отрисовываться одним и тем же материалом, то данные от всех этих команд объединяются и отправляются одним батчем.
Как было раньше
---------------
Для показа товара по акции создается префаб такого вида:
Как видно, довольно простой префаб сам по себе требует довольно много батчей для своей отрисовки — 26 (в статистике еще учтен один батч от камеры, которая обновляет фон). Но куда хуже картина становится при создании второго такого же префаба:
Количество батчей удвоилось — а значит, у нас полностью сломан батчинг между одинаковыми сущностями! Так происходит из-за того, что мы используем стандартный компонент Unity — Mask. Здесь он нужен для диагональных полос на фоне:
А вот как это выглядит в иерархии:
Здесь выделены те объекты, к которым применяются маски:
* *new-back* — ограничивает отрисовку изображения границами префаба,
* *angle-glow* — за счет поворота трансформа создают косые ленты.
Тут стоит отметить, что градиент на лентах достигается за счет подкрашенной текстуры грейскейла: таким образом достигается любой цвет и любая простая форма без использования дополнительных текстур.
Однако в этом же месте и возникает проблемность использования компонента маски: она полностью ломает батчинг. Более того, сам компонент добавляет два батча: до и после отрисовки спрайта, на который воздействует маска, со специальными настройками шейдера. Именно из-за такого поведения оказывается невозможно сбатчить спрайты внутри одного префаба и между соседними префабами.
Таким образом, для отрисовки всего лишь четырех спрайтов требуется десять батчей. Несколько префабов также не могут сбатчиться между собой — а с учетом не самой лучшей оптимизации префабов даже без учета масок количество батчей в реальной ситуации исчислялось бы сотнями.
Что мы сделали
--------------
Нам хотелось полностью сохранить визуал, но исправить проблему поломки батчинга. Для этого мы написали собственные маски для работы в UI. При этом необходимо было сделать универсальное решение, не требующее серьезных ресурсов.
Мы объединили вместе два объекта — границу маски и изображение. Идея в том, сразу рисовать изображение уже с примененной на него маской. Для этого нужно создать новый материал и написать для него шейдер, в котором и будет считаться форма маски:
```
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#pragma multi_compile __ UNITY_UI_ALPHACLIP
struct appdata_t
{
float4 vertex : POSITION;
float4 color : COLOR;
float2 texcoord : TEXCOORD0;
};
struct v2f
{
float4 vertex : SV_POSITION;
fixed4 color : COLOR;
float2 uv : TEXCOORD0;
};
fixed4 _Color;
fixed4 _TextureSampleAdd;
v2f vert(appdata_t IN)
{
v2f OUT;
OUT.vertex = UnityObjectToClipPos(IN.vertex);
OUT.color = IN.color * _Color;
OUT.uv = IN.texcoord;
return OUT;
}
sampler2D _MainTex;
fixed4 _MainTex_ST;
sampler2D _AlphaTex;
fixed4 _AlphaTex_ST;
fixed4 frag(v2f IN) : SV_Target
{
float4 color = (tex2D(_MainTex, IN.uv * _MainTex_ST.xy + _MainTex_ST.zw) + _TextureSampleAdd) * IN.color;
const float mask_alpha = (tex2D(_AlphaTex, IN.uv * _AlphaTex_ST.xy + _AlphaTex_ST.zw) + _TextureSampleAdd).a;
color.a *= mask_alpha;
return color;
}
ENDCG
```
Применив такой шейдер, можно избавиться от поломки батчинга — но у него есть одна существенная проблема: для двух разных изображений можно использовать одинаковую текстуру маски только в том случае, если форма, по которой должна браться маска, полностью совпадает. В нашем случае толщина лент отличается, и это требовало использования разных текстур. А тот факт, что ленты должны обрезаться по диагонали, приводило к необходимости использовать эти технические текстуры в высоком разрешении, занимая память. Иначе возникали проблемы анти-алиасинга: изображение становилось ступенчатым.
Поэтому мы начали искать решение дальше и нашли возможность задавать форму маски новым способом. Чтобы его описать, надо вспомнить, как Unity рисует изображение.
Итак, *Image* — это компонент, который берет данные из *RectTransform* с того *GameObject*, на котором он находится. У RectTransform заданы четыре вершины-координаты, а также четыре стандартные UV-координаты — по одной на каждую вершину: [(0, 0), (1, 0), (0, 1), (1, 1)]. В коде мы можем менять координаты, а также использовать и другие наборы UV-координат: для обычных мешей доступны восемь наборов UV-координат, но Unity UI поддерживает лишь до четырех наборов. Тогда почему бы нам не использовать другие координаты для определения формы маски? Сказано — сделано.
В первую очередь надо убедиться, что в нашем Canvas включен дополнительный UV-канал:
Теперь, нужно расширить функционал *Image* так, чтобы он умел читать данные из этого канала и передавать его в меш, откуда будет читать уже шейдер:
```
public class ImageWithCustomUV2 : Image
{
[SerializeField] private Vector2[] _uvs2;
protected override void Start()
{
base.Start();
if (!canvas.additionalShaderChannels.HasFlag(AdditionalCanvasShaderChannels.TexCoord1))
{
canvas.additionalShaderChannels |= AdditionalCanvasShaderChannels.TexCoord1;
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
base.OnPopulateMesh(vh);
if (_uvs2?.Length != 4)
{
return;
}
var vertex = new UIVertex();
for (var i = 0; i < 4; ++i)
{
vh.PopulateUIVertex(ref vertex, i);
vertex.uv1 = _uvs2[i];
vh.SetUIVertex(vertex, i);
}
}
```
Для упрощения настройки координат мы написали кастомный инспектор:
Код инспектора
```
[CustomEditor(typeof(ImageWithCustomUV2))]
public class ImageWithCustomUV2Inspector : ImageEditor
{
private readonly string[] _options = {"Custom", "Rectangle"};
private readonly GUIContent _blLabel = new GUIContent("Bottom left");
private readonly GUIContent _brLabel = new GUIContent("Bottom right");
private readonly GUIContent _tlLabel = new GUIContent("Top left");
private readonly GUIContent _trLabel = new GUIContent("Top right");
private bool _foldout = true;
private int _selectedOption = -1;
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
var prop = serializedObject.FindProperty("_uvs2");
if (prop.arraySize != 4)
{
ResetUVs(prop);
}
_foldout = EditorDrawUtilities.DrawFoldout(_foldout, "UV2");
if (_foldout)
{
EditorGUI.indentLevel++;
DrawUVs(prop);
EditorGUI.indentLevel--;
}
serializedObject.ApplyModifiedProperties();
}
private void DrawUVs(SerializedProperty prop)
{
if (_selectedOption < 0)
{
CheckSelectedOption(prop);
}
_selectedOption = GUILayout.Toolbar(_selectedOption, _options);
switch (_selectedOption)
{
case 1: // rect
DrawRectOption(prop);
break;
default: // custom
DrawCustomOption(prop);
break;
}
}
private void CheckSelectedOption(SerializedProperty prop)
{
var bl = prop.GetArrayElementAtIndex(0).vector2Value;
var br = prop.GetArrayElementAtIndex(3).vector2Value;
var tl = prop.GetArrayElementAtIndex(1).vector2Value;
var tr = prop.GetArrayElementAtIndex(2).vector2Value;
if (bl.x == tl.x && bl.y == br.y && tr.x == br.x && tr.y == tl.y)
{
_selectedOption = 1;
}
else
{
_selectedOption = 0;
}
}
private void DrawCustomOption(SerializedProperty prop)
{
var w = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 100;
EditorGUILayout.BeginHorizontal();
DrawVector2Element(prop, 1, _tlLabel);
DrawVector2Element(prop, 2, _trLabel);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
DrawVector2Element(prop, 0, _blLabel);
DrawVector2Element(prop, 3, _brLabel);
EditorGUILayout.EndHorizontal();
EditorGUIUtility.labelWidth = w;
}
private void DrawRectOption(SerializedProperty prop)
{
var w = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 100;
var bl = prop.GetArrayElementAtIndex(0).vector2Value;
var tr = prop.GetArrayElementAtIndex(2).vector2Value;
var min = bl;
var max = tr;
EditorGUILayout.BeginHorizontal();
min = EditorGUILayout.Vector2Field("min", min);
max = EditorGUILayout.Vector2Field("max", max);
EditorGUILayout.EndHorizontal();
if (min != bl || max != tr)
{
prop.ClearArray();
AddVector2(prop, min);
AddVector2(prop, new Vector2(min.x, max.y));
AddVector2(prop, max);
AddVector2(prop, new Vector2(max.x, min.y));
}
EditorGUIUtility.labelWidth = w;
}
private void DrawVector2Element(SerializedProperty array, int index, GUIContent label)
{
var prop = array.GetArrayElementAtIndex(index);
EditorGUILayout.PropertyField(prop, label);
}
private void ResetUVs(SerializedProperty prop)
{
prop.ClearArray();
AddVector2(prop, Vector2.zero);
AddVector2(prop, Vector2.up);
AddVector2(prop, Vector2.one);
AddVector2(prop, Vector2.right);
}
private void AddVector2(SerializedProperty array, Vector2 value)
{
var id = array.arraySize;
array.InsertArrayElementAtIndex(id);
var prop = array.GetArrayElementAtIndex(id);
prop.vector2Value = value;
}
}
```
Сам код шейдера: в нем изменился только расчет UV для текстуры, по которой берется маска:
```
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#pragma multi_compile __ UNITY_UI_ALPHACLIP
struct appdata_t
{
float4 vertex : POSITION;
float4 color : COLOR;
float2 texcoord : TEXCOORD0;
float2 texcoord1 : TEXCOORD1;
};
struct v2f
{
float4 vertex : SV_POSITION;
fixed4 color : COLOR;
float2 uv : TEXCOORD0;
float2 uv1 : TEXCOORD1;
};
fixed4 _Color;
fixed4 _TextureSampleAdd;
v2f vert(appdata_t IN)
{
v2f OUT;
OUT.vertex = UnityObjectToClipPos(IN.vertex);
OUT.color = IN.color * _Color;
OUT.uv = IN.texcoord;
OUT.uv1 = IN.texcoord1;
return OUT;
}
sampler2D _MainTex;
fixed4 _MainTex_ST;
sampler2D _AlphaTex;
fixed4 _AlphaTex_ST;
fixed4 frag(v2f IN) : SV_Target
{
float4 color = (tex2D(_MainTex, IN.uv * _MainTex_ST.xy + _MainTex_ST.zw) + _TextureSampleAdd) * IN.color;
const float mask_alpha = (tex2D(_AlphaTex, IN.uv1 * _AlphaTex_ST.xy + _AlphaTex_ST.zw) + _TextureSampleAdd).a;
color.a *= mask_alpha;
return color;
}
ENDCG
```
В качестве маски теперь можно использовать довольно простую текстуру:
Обратите внимание: непрозрачная часть здесь — квадрат, занимающий четверть площади изображения, его окружает прозрачная рамка. Такая текстура позволяет настраивать практически любые четырехугольные формы.
Теперь, после настройки форм масок получается сохранить визуал, упростив иерархию, не ломая батчинг и используя минимальные дополнительные данные: текстуру для маски в формате Alpha8 размером 256x256 занимает в памяти всего 64 КБ.
И самое главное — сохранился батчинг между разными префабами:
Итоги
-----
После всех произведенных действий нам удалось упростить иерархию объектов в Unity и в несколько раз сократить количество батчей: с 300+ до ~70. Значение FPS в экране увеличилось примерно на 5-10%. Платой за это стала чуть более сложная настройка компонентов.
*Было:*
*Стало:*
В итоге нам удалось реализовать задуманное: производительность экрана увеличилась, при этом верстка не изменилась, а иерархия объектов упростилась и стала понятнее. Удалось создать универсальный инструмент, который можно использовать в других экранах и элементах интерфейса.
Дополнительные ресурсы оказались минимальными и, опять же, универсальными. Из неприятного — настройка конкретной маски стала немного сложнее, но когда понимаешь, как работает механизм, она уже не составляет труда. | https://habr.com/ru/post/596863/ | null | ru | null |
# Как использовать новейшие функции JavaScript в любом браузере
JavaScript — это язык, который развивается очень быстро, и иногда мы хотим использовать его новейшие функции, но, если наш браузер или среда не позволяют этого напрямую, нам придется транспилировать его, чтобы он мог это сделать.
Транспилирование — это преобразование исходного кода, написанного на одном языке, на другой язык с сопоставимым уровнем абстракции. Следовательно, в случае JavaScript транспилятор берет синтаксис, который старые браузеры не понимают, и превращает его в синтаксис, который они понимают.
### Polyfilling vs. Transpiling
Оба метода работают с одной и той же целью: мы можем написать код, использующий новые функции, которые не реализованы в нашей целевой среде, а затем применить один из этих методов.
**Полифил** — это часть кода, в котором современные функции реализуются таким образом, чтобы их можно было применить для работы в старых версиях браузера.
**Транспилирование** — это сочетание двух слов: transforming — преобразование и compiling
— компиляция. Иногда новый синтаксис не может быть реализован с помощью полифилов, в таком случае мы используем транспилятор.
Представим, что мы используем старый браузер, который не поддерживает функцию **Number.isNaN**, представленную в спецификации ES6. Чтобы использовать эту функцию, нам нужно создать полифил для этого метода, но нам это понадобится только в том случае, если он еще не доступен в браузере.
Для этого мы создадим функцию, которая имитирует поведение функции **isNaN** и добавит её к свойству прототипа Number.
```
//Имитирует функцию isNaN
if (!Number.isNan) {//ещё не доступно.
Number.prototype.isNaN = function isNaN(n) {
return n !== n;
};
}
let myNumber = 100;
console.log(myNumber.isNaN(100));
```
Теперь мы собираемся транспилировать код для недавно созданной функции. Представим, что большинство браузеров не может выполнить эту функцию, и в этом случае мы не можем создать полифилл для имитации поведения. Мы хотим запустить следующий код в Internet Explorer 11, поэтому собираемся преобразовать его с помощью транспилятора:
```
class mySuperClass {
constructor(name) {
this.name = name;
}
hello() {
return "Hello:" +this.name;
}
}
const mySuperClassInstance = new mySuperClass("Rick");
console.log(mySuperClassInstance.hello());
//Hello Rick
```
Полученный код был перенесен с помощью онлайн-транспилятора [Babel](https://babeljs.io/en/repl), и теперь мы можем выполнить его в Internet Explorer 11:
```
"use strict";
function _instanceof(left, right) { if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { return !!right[Symbol.hasInstance](left); } else { return left instanceof right; } }
function _classCallCheck(instance, Constructor) { if (!_instanceof(instance, Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var mySuperClass = /*#__PURE__*/function () {
function mySuperClass(name) {
_classCallCheck(this, mySuperClass);
this.name = name;
}
_createClass(mySuperClass, [{
key: "hello",
value: function hello() {
return "Hello:" + this.name;
}
}]);
return mySuperClass;
}();
var mySuperClassInstance = new mySuperClass("Rick");
console.log(mySuperClassInstance.hello()); //Hello Rick
```
Один из самых распространенных транспиляторов для JavaScript — это Babel. Babel — это инструмент, который был создан для помощи в переносе кода между различными версиями JavaScript и может быть установлен через диспетчер пакетов Node (npm).
Babel стал стандартом для компиляции приложений ECMAScript в версию ECMAScript, которая работает в браузерах, не поддерживающих такие приложения. Babel может компилировать другие версии ECMAScript, такие как React JSX.
В следующих шагах мы увидим, как использовать Babel для транспиляции и выполнения предыдущего класса **mySuperMethod** на машине Linux с установленным старым **Node.js**. В других операционных системах, таких как Windows 10 или macOS, действия аналогичны.
*Примечание. На вашем компьютере должен быть установлен [Node.js](https://nodejs.org/ru/). Npm добавлен как функция в установщик Node.js*
1. Откройте командную строку и создайте каталог с именем babelExample:
```
/mkdir babelExample
/cd babelExample
```
2. Создайте проект [npm](https://www.npmjs.com/) и оставьте значения по умолчанию. Следующая команда создаст файл с именем package.json:
```
npm init
```
*скриншот содержимого файла package.json после выполнения команды npm init*
Здесь **index.js** (имя файла может быть другим) — это точка входа в наше приложение. Сюда мы собираемся поместить наш код javascript, поэтому создайте файл index.js и поместите в него следующий код:
```
class mySuperClass {
constructor(name) {
this.name = name;
}
hello() {
return "Hello:" +this.name;
}
}
const mySuperClassInstance = new mySuperClass("Rick");
console.log(mySuperClassInstance.hello());
//Hello Rick
```
3. Хотя мы и можем установить Babel CLI глобально, лучше делать это локально, проект за проектом. Следующая команда добавит каталог node\_modules и изменит файл package.json, чтобы добавить зависимости Babel:
```
npm install -save-dev @babel/core @babel/cli
```
*скриншот package.json с зависимостями babel*
4. Добавьте файл конфигурации **.babelrc** в корневую папку проекта и включите плагины для преобразований ES2015+.
*Примечание. В Babel каждый трансформатор — это плагин, который мы можем установить индивидуально. Каждый пресет представляет собой набор связанных плагинов. Используя пресеты, нам не нужно самостоятельно устанавливать и обновлять десятки плагинов.*
Установите пресет для всех функций ES6 (содержит группу плагинов):
```
npm install @babel/preset-env --save-dev
```
*скриншот package.json с зависимостью preset-env babel*
Отредактируйте файл .babelrc и добавьте конфигурацию, которая включает преобразования для ES6.
Запишите в файл .babelrc следующий код:
```
{
"presets": ["@babel/preset-env"]
}
```
5. Использование
*Примечание. Если вы используете Windows 10 PowerShell, будьте осторожны с кодированием файлов, поскольку при запуске Babel могут возникнуть ошибки синтаксического анализа. Желательно, чтобы файлы были в кодировке UTF-8.*
вход: index.js
выход: папка out (здесь Babel оставит перенесённые файлы)
Непосредственно, выполнив следующую команду в консоли:
```
./node_modules/.bin/babel index.js -d out
```
С помощью сценария npm, добавляющего следующую строку в ваш файл package.json:
```
"build": "babel index.js -d out"
```
*скриншот содержимого файла package.json после добавления скрипта сборки*
Выполните следующую команду:
```
npm run build
```
В обоих случаях вы получаете в папке out файл (или файлы), транспилированные в готовый для работы в браузерах, которые не поддерживают синтаксис класса ES6, код:
```
"use strict";
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var mySuperClass = /*#__PURE__*/function () {
function mySuperClass(name) {
_classCallCheck(this, mySuperClass);
this.name = name;
}
_createClass(mySuperClass, [{
key: "hello",
value: function hello() {
return "Hello:" + this.name;
}
}]);
return mySuperClass;
}();
var mySuperClassInstance = new mySuperClass("Rick");
console.log(mySuperClassInstance.hello());
```
### Заключение
Язык JavaScript постоянно меняется, и, благодаря этим инструментам, мы можем писать код с новым синтаксисом и новыми функциями, которые еще не реализованы во всех версиях браузеров.
Надеюсь, вам понравилась эта статья. Эту и многие другие полезные статьи для начинающих Frontend-разработчиков я транслирую в Telegram-канале [Frontend.school()](https://t.me/frontend_school), где также готовлю полезные викторины для проверки своих знаний. *Обращаю внимание, что канал является исключительно хобби и желанием помочь и не несет для меня материальной выгоды.* | https://habr.com/ru/post/517134/ | null | ru | null |
# Олимпиады по программированию, взгляд из НГУ. Статья 5 — как играет команда
Во время своих предыдущих статей я уже более-менее описал то, как проходит типичный тур обычной олимпиады по программированию изнутри. Кого-то заинтересовала эта внутренняя механика, а кто-то хотел услышать больше о непосредственно кодинге. В сегодняшней статье я расскажу о том, чем именно занимается команда во время тура, как и что делает, какие ухищрения применяет и что из этого выходит. О тренировках и о личных контестах я, пожалуй, расскажу попозже, хотя после этой статьи там и рассказывать будет почти не о чем.
Жду комментарии от действующих и бывших ACM-овцев, может почерпну какие новые тонкости и методы, ведь скоро мой последний сезон и хочется провести его крайне ударно.
[Первая статья — про составление задач.](http://habrahabr.ru/blogs/sport_programming/62655/)
[Вторая статья — про тестирующие системы.](http://habrahabr.ru/blogs/sport_programming/63005/)
[Третья статья — про работу оргкомитета.](http://habrahabr.ru/blogs/sport_programming/63045/)
[Четвёртая статья — про тур непосредственно.](http://habrahabr.ru/blogs/sport_programming/63187/)
#### Состав команды
Команда — это три человека. Больше — никак, меньше (по текущим правилам) — тоже. Нам с Мишей в прошлом сезоне ультимативно поставили просьбу искать третьего или никто никуда не идёт. Благо, Коля [Orfest](https://habrahabr.ru/users/orfest/) был свободен и мы устремились. Сыграться на уровень первых 3 команд нашего университета мы, увы, не успели, потому и не прошли в полуфинал в очередной раз. В этом году попытаемся починить взаимодействие в команде.
В лучших командах каждый участник в отдельности может взять весь тур (ну или большинство задач из него). В командах уровнем пониже зачастую отдельные участники специализируются на отдельных темах. Так у нас почти вся геометрия ложится на плечи Миши, а решать теорию чисел или какие комбинаторные измышления никто вперёд меня не лезет. Так, за счёт специализации на разных темах, можно получить команду, обладающую суммарно знаниями на уровне более сильных в персоналиях сборных.
Обычно в команде можно выделить 3 роли — кодер, математик и алгоритмист. Каждый из участников должен исполнять хотя бы 2 из них, а в идеале — все 3. Но не все случаи идеальны, поэтому иногда некоторые участники за тур не пишут ни одной строчки кода, а другие — не читают половину задач, в то время как команда достигает неплохого результата. Злоупотреблять этим не стоит, лучше уж пусть все знают всё =)
#### Начало тура
Минут за 10 до начала команду допускают к компьютеру. За машину садится самый быстрый кодер команды и набивает шаблоны на языках, на которых предполагается письмо, подстраивает IDE (настройка любимой перспективы в Eclipse с нуля уже настолько отработана, что доходит почти до автоматизма). Остальные подготавливают рабочее место — ручки, блокноты, нервы.
Появляются задачи, обычно в бумажном варианте. В идеале — 3 экземпяра, по одному на участника, но может быть и меньше. Две — минимум для удобной работы. Дальше задания жадно расхватывают два участника команды, не обременённые в данный момент клавиатурой и начинают искать «утешалку». В 90% туров, которые я писал, есть хотя бы одна задача, которую надо решать сразу, быстро, без вариантов и с первой попытки. После нахождения её (минуты за 2) алгоритмист садится к кодеру и в общих словах знакомит его с задачей, с сутью — чтобы тот не сильно утруждал себя чтением и переводом текста (на большинстве олимпиад текст на английском языке, потому лучше избежать лишних затыков). Далее кодер остаётся один на один с клавиатурой и условием данной задачи, а остальные двое устремляются разбирать весь тур.
Ребята прочитывают весь тур и ищут задачу, которую будут писать следующей. Далее, пока клавиатура занята, код аккуратно пишется в блокноте. Не схематично, а именно готовый для переноса код. Тогда, как только быстрый и грязный кодер справится с 1 задачей (предполагается, что он сумеет это сделать без внешнего вмешательства), кто-то из оставшейся двойки садится на его место, кодер идёт вдумчиво читать тур. Третий участник в этот момент отряжается наблюдать за написанием кода — парный кодинг в спортивном программировании очень полезен. Заодно этот участник составляет тесты на текущую задачу.
Да, чуть не забыл сказать. Примерно во время написания первой-второй задачи периодически мониторится состояние турнира, чтобы знать, что решают люди, дабы не уйти не в ту степь. Заодно составляется персональная очередь написания задач в команде, исходя из сложности/познаний/пожеланий.
#### Середина тура
Пока есть, что решать, решают именно то, что есть :) Обычно это происходит по следующей системе — один человек пишет, второй наблюдает, третий думает о другой задаче. + второй и третий составляют тесты для задачи первого, вручную просчитывая результат. Если всё плохо и все решаемые задачи закончились, то команда садится штурмовать. Технология мозгового штурма всем и так знакома, так что тут уточнять не буду.
При поступлении задач в «очередь написания» очень полезна следующая технология из командных математических турниров. Когда у кого-то в голове рождается разумеется правильное и самое хорошее решение, то он направляется к тому человеку, который над этой задачей не думал и объясняет ему решение задачи. Очень помогает при отсеве бреда и лажи.
#### Конец тура
Конец тура проходит 3 разными способами. Первый, самый красивый вариант — это часа за полтора-два до 5часовой отсечки, со всеми плюсами в рейтинге и гордо поднятой головой. Такое у нас было только на паре-тройке тренировок. А среди московских и питерских команд такое практикуется и на четвертьфиналах =)
Второй вариант — это в том случае, если писанина ещё есть и много, а времени нет и мало. Тогда голосованием по команде (примерно за час до конца тура) решается, какие задачи писать, в зависимости от уверенности в них и в вероятной скорости написания.
И третий путь — это «балет». Когда идей уже нет, а что-нибудь сделать хочется. Тогда начинают писать разные грязные лобовые решения, в надежде на то, что тайм-лимит обойдёт нас стороной. Может быть вообще цирк.
*Так единожды на туре CBOSS мы решали задачу бинарным поиском в тестирующей системе. Задачу мы написали, причём довольно тупо и в лоб. В ней по эмпирическим соображениям было предположено, что если на первых ~2 миллионах у нас ничего не зациклится, то и далее ничего не сломается. Сломалось ограничение по времени. Поставили ограничение на полмиллиона — валится по точности. Делать было нечего, поэтому мы последовательными приближениями добрались до решения. Сдали попытки с 30-й*
#### Ужимки и прыжки
Во время написания туров часто применяются разные интересные и полезные трюки. Зачастую они выглядят удивительно для неопытных команд, но полезны всем.
##### Хитрый прекальк
Многие задачи кошерно решать предварительным просчётом. Как я уже писал раньше, 5 минут работы компьютера команды позволят решить задачу методом
`read(a); write (res[a]);`
Но зачастую задача вроде бы и считается прекальком или тупо в лоб, но для первого не хватает места в коде, а для другого — таймлимита. Тогда можно применить грязный хак номер один.
Вот [пример задачи](http://acm.timus.ru/problem.aspx?space=1&num=1309), решающейся именно таким способом. Мы с Колей начали решать её одновременно, он пошёл путём матана, сгенерировал хитрую табличку и как-то из неё вычислял решение в произвольной точке. Я же поступил прямолинейней, но не менее творчески. Цикл длиной 100000 за допустимое время выполняется, а 1000 предварительно просчитанных значений в код входит. Таким образом была просчитана сетка решений, а дальше считалось в лоб от ближайшего значения. Справился я быстрее, правда подход куда как менее научный и масштабируемый.
##### Генератор добра
Методика, которую в нашу команду принёс Дима Ковчин. Применяется в основном на целочисленных задачах. Быстро, минут за 10 пишется генератор, который нагло просчитывает первые значений 20 целевой функции. Дальше лучшие умы команды садятся и методом глазуального анализа пытаются выявить общую закономерность. Зачастую закономерность по первым 2-3 значениям может быть ошибочной, значений 20 уже позволяют достаточно достоверно верить гипотезе. Просчёт руками по бумаге занимает куда больше времени. Стоит заметить, что методом Ньютона можно построить кривую хорошего порядка через любое количество точек, так что злоупотреблять методом не стоит.
##### Excel — лучший друг программиста
Не знаю, как у команд других университетов, но у нас это уже пословица. Разные подлые и гадостные тесты мы всегда пишем в экселе (точнее в OpenOffice Calc). Эксель помогает нам в графическом анализе входных данных. А у весёлых ребят из СибГУТИ, с которыми наша команда постоянно делила 1 место среди лучших команд КВН в ACM =), даже какое-то время ходил слух, что NSU MOM и NSU NAN задачи в экселе решают и отсылают в тестирующую систему xls-файлы. Это, конечно, не так, но лучше, чем в экселе, строить макстесты для издевательств над задачей просто негде.
##### Фигурный гуглинг
По намёку [Orfest](https://habrahabr.ru/users/orfest/) вспомнил и о том, что без гугла бывает сложновато. На крупных турнирах по типу Всесибирской олимпиады такую роскошь, конечно, в руки нам никто не даст, но на том же CBOSS воспользоваться этим можно невозбранно. В гугле и википедии можно освежить математические познания, дабы не возиться с выводом чего-то, невспоминаемого навскидку, а если уж очень хочется — дорваться и до готового алгоритма. Не стоит считать это панацеей от всех болезней, на многих турнирах внешний интернет запрещён как таковой, но иногда услуги веб-сервисов бывают полезными. Хотя бы даже для перевода непонятных слов, которые могут быть существенными при решении задачи. А на стадии «балета» это может свестись к очередному шоу.
*Года 3 назад наша команда решала какую-то задачу про рассадку эльфов в упряжке Санта Клауса. Дело было уже под конец тура, градус кипения мозга был достигнут ещё раньше. Шоу началось с того, что переменные для массива оленей были именованы «loses» с комментарием «Лоси — они и в Лапландии лоси». Когда же было принято решение поискать в Яндексе алгоритм, коллективный разум родил лишь такой запрос: «эльфы олени рассадить». Тур на этом запросе был закончен, а в послужной список нашей команды добавился ещё один весёлый момент.*
Пока, увы, темы про спортивное программирование у меня иссякли. Если кто подкинет идею, о чём можно написать ещё, буду очень признателен. | https://habr.com/ru/post/64144/ | null | ru | null |
# Ввод данных в STM32F4xx с параллельного АЦП через DCMI
Известно, что семейство микроконтроллеров STM32F4xx, имея на борту достаточно производительные ядра, вполне подходящие для «не мясорубочных» задач ЦОС не имеют полноценного интерфейса ввода данных с простейшей параллельной шины в режиме «pipe-line» (clk-data). «Покурив» «dm00037051.pdf», нашел не специфичный, но на первый взгляд подходящий вариант – интерфейс DCMI (Digital camera interface).
Конечно, использование для нагруженной классической ЦОС (КИХ, БИХ, FFT) микроконтроллеров STM32, не совсем является оптимальным вариантом, но если вдруг так легли карты и все-таки возможностей данного микроконтроллера вполне достаточно, плюс нужно достаточное количество низкоскоростных интерфейсов. Об этом под катом.
На одном из проектов с «горячими» сроками и бюджетом была необходимость реализовать «железку» с оптимальными: массой, габаритами, потреблением. В качестве базовой функции требовалась цифровая обработка сигнала (фильтрация и статистический анализ), поступающего с АЦП в режиме «мягкого» реального времени. Для обработки хотелось иметь плавающую точку одинарной точности. Сигнал с АЦП поступал на промежуточной частоте 48 МГц. Полоса сигнала 1 МГц. Реализовать переноса спектра сигнала с промежуточной частоты в ноль, желательно с использованием субдискретизации широкополосного АЦП. Также, нужно было принимать и передавать информацию по интерфейсам Ethernet, SPI, UART, I2C и работать с прерываниями.
Сроки на реализацию и специфичные функции ЦОС не позволили использовать FPGA для этих целей. С широко известным сигнальным процессором семейства Blackfin от всем известной Analog Devices не было опыта общения и отсутствовали в ближайшем доступе отладочные средства и демоплаты. Имелся только опыт тесного и длительного общения с дорогущим, некогда флагманом ЦОС, процессора ADSP-TS201 TigerSHARC. К тому-же в Blackfin отсутствует аппаратная реализация IEEE-754. Также, требовалось принимать непрерывный блок данных с АЦП размером 128 Кбайт, плюс 30 Кбайт накладные расходы на обработку и уже без внешней памяти сложно было все впихнуть во что-то более менее бюджетное.
Вообщем, под рукой были только платы STM32F407 (Discovery и кастомные с Китая). Как я подозреваю у многих, кто занимается смежной тематикой сейчас под рукой такие универсальные выручалочки имеются. Также имелась плата ADA-HSMC от Terasic, на которой установлено двухканальное АЦП AD9228 (12-bit, Fd=65 msps, bandwidth = 315 MHz).
Не специфичный, но вполне подходящий вариант – интерфейс DCMI (Digital camera interface), аппаратно реализованный в STM32F4.
Работа данного интерфейса описана в RM0090, DocID018909, стр. 454/1718. Последующие четыре рисунка приведены из данного документа.
Итак, заявленная частота поступления входных данных до 54 МГц. Что вполне достаточно — наша частота субдискретизации 10 МГц. Вот набор используемых сигналов интерфейса DCMI:
Примечание: D13, D14 реализованы только в 144-контактном корпусе. Мы имеем 100-контактный, но нам они и не нужны. (хотя у Analog Devices существует аналогичное 14 bit АЦП — AD9248).
Вот обобщенная временная диаграмма работы интерфейса:
А это временная диаграмма работы интерфейса в режиме формата кадра JPEG:
Данный режим работы и будем использовать т.к. он нам наиболее подходит.
В этом режиме сигнал VSYNC подтягиваем к питанию. HSYNC будем использовать как внешний сигнал разрешения запуска приема данных по интерфейсу.
Мы использовали микроконтроллер STM32F407RGT6 в корпусе LQFP100.
У АЦП AD9238 есть вход режима отключения (энергосбережения) соответствующего канала PDWN\_A(B), и разрешения по выходу OEB\_A(B). Логично их завести с каких-либо пинов контроллера. В итоге схема соединения выводов будет выглядеть вот так:
Так как у данного АЦП нет выходного тактового сигнала, необходимо использовать размножитесь (тактовый буфер). Мы использовали LMK00101 от Texas Instruments – хорошее соотношение цены, низкого джиттера, а главное, опять-же — под рукой ).
В обработке учитываем, что данные на параллельной шине АЦП появляются с задержкой на 7 тактов относительно входного тактового сигнала.
Прием данных будем осуществлять (конечно-же) через DMA. Вот исходный код инициализации DCMI и DMA.
Включаем тактирование нужных нам портов, DCMI и DMA2
```
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable DCMI GPIOs clocks */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOE |
RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOD, ENABLE);
/* Enable DCMI clock */
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
```
Этим пином (PA5) будем имитировать разделение на кадры – HSYNC. Инициализируем на выход
```
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_ResetBits(GPIOA, GPIO_Pin_5); //HSYNC_PA4 -PA5 -> GND
```
Настраиваем соответствующие выводы в режиме DCMI
```
/* PCLK */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_DCMI);
/* D0-D7 */
GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_DCMI); //D0*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_DCMI); //D1*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_DCMI); //D2*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_DCMI); //D3*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_DCMI); //D4*
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_DCMI); //D5*
GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_DCMI); //D6*
GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_DCMI); //D7*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_DCMI); //D8*
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_DCMI); //D9*
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_DCMI); //D10*
GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_DCMI); //D11*
/* VSYNC */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_DCMI);
/* HSYNC */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_DCMI);
/* DCMI GPIO configuration **************************************************/
/* D0,D1,D2,D3,D4,D8,D9 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/* D6,D7*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* D10, D5, VSYNC(PB7) */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* D11(PD2) */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* PCLK(PA6) HSYNC(PA4)*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
```
Здесь самое интересное – настройка DCMI в режиме, соответствующего JPEG кадрам.
```
DCMI_InitStructure.DCMI_CaptureMode = DCMI_CaptureMode_Continuous;
DCMI_InitStructure.DCMI_SynchroMode = DCMI_SynchroMode_Embedded;
DCMI_InitStructure.DCMI_PCKPolarity = DCMI_PCKPolarity_Rising;
DCMI_InitStructure.DCMI_VSPolarity = DCMI_VSPolarity_Low;
DCMI_InitStructure.DCMI_HSPolarity = DCMI_HSPolarity_High;
DCMI_InitStructure.DCMI_CaptureRate = DCMI_CaptureRate_All_Frame;
DCMI_InitStructure.DCMI_ExtendedDataMode = DCMI_ExtendedDataMode_12b;
```
Настройка DMA
```
DCMI_Init(&DCMI_InitStructure);
DMA_InitStructure.DMA_Channel = DMA_Channel_1;
DMA_InitStructure.DMA_PeripheralBaseAddr = DCMI_DR_ADDRESS; //0x50050028
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)DCMI_PendingData;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = MAX_DOWBLE_BUF;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(DMA2_Stream1, &DMA_InitStructure);
```
Настройка прерываний по окончании приема данных с соответствующего канала DMA
```
NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
```
Код нашего обработчика, в котором отключаем прием данных по DCMI и выставляет флаг готовности данных.
```
void EXTI1_IRQHandler()
{
EXTI_ClearFlag(EXTI_Line1);
DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1);
DMA_Cmd(DMA2_Stream1, DISABLE);
DCMI_Cmd(DISABLE);
dma_recv_f = 1;
//GPIO_ResetBits(GPIOE, GPIO_Pin_0); //VSYNC reset
}
```
С настройками все. Теперь включаем наш канал DMA, блок DCMI, стартуем прием данных по DCMI в режиме кадров JPEG.
```
/* Enable DMA transfer */
DMA_Cmd(DMA2_Stream1, ENABLE);
/* Enable DCMI interface */
DCMI_Cmd(ENABLE);
/* Start Image capture */
DCMI_CaptureCmd(ENABLE);
DCMI_JPEGCmd(ENABLE);
```
Цикл основной программы. Здесь опрос флага и перезапуск приема данных.
```
uint8_t dma_recv_f = 0; //флаг, сигнализирующий окончание приема блока данных.
uint16_t DCMI_PendingData[8500]; //буфер приема данных с DCMI
int main(void)
{
DCMI_Config(); //это та функция куски кода которой приведены выше
__enable_irq(); //разрешаем прерывания
while(1)
{
while(dma_recv_f!=1){}; //ждем окончание приема данных
dma_recv_f = 0; //сбрасываем флаг
/*ЗДЕСЬ ДОЛЖЕН БЫТЬ КОД ОБРАБОТКИ ДАННЫХ*/
Re_DMA_Config(DCMI_PendingData, glob_cnt); //перезапускаем DMA
}
}
```
Примечание: если необходимо принимать и обрабатывать данные в жестком реальном времени с двойной буферизацией в stm32f4 есть механизм прерывания при заполнении половины буфера. В настройках DMA тогда необходимо задать непрерывный циклический режим приема данных. Например:
```
// DMA2 Stream0 channel0 configuration **************************************
DMA_InitStructure.DMA_Channel = DMA_Channel_1;
DMA_InitStructure.DMA_PeripheralBaseAddr = DCMI_DR_ADDRESS; //0x50050028
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)DCMI_PendingData;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_BufferSize = buf_size;
**DMA\_InitStructure.DMA\_Mode = DMA\_Mode\_Circular;** //режим непрерывного циклического приема данных
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
**DMA\_InitStructure.DMA\_FIFOThreshold = DMA\_FIFOThreshold\_HalfFull;** //прерывание от DMA по заполнению половины буфера
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
```
В обработчике прерывания тогда необходимо сбрасывать бит окончания DMA только после заполнения всего буфера, и пользовательской программе обработки указывать номер текущего буфера, в который закончился прием данных. Примерно вот так:
```
if(DMA_GetITStatus(DMA2_Stream1,DMA_IT_TCIF1)){
DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TCIF1);
num_buf = 1;
}
else{
num_buf = 0;
}
```
Вот в принципе и все, что необходимо для приема данных с нашего АЦП по интерфейсу DCMI.
К сожалению, в данный момент не могу в живую продемонстрировать весь этот механизм т.к. железка уже года 3 как в эксплуатации ))). Могу только привести сохраненные данные тестовой регистрации с тех времен.
Вот это гармонический сигнал с генератора SMB100A на частоте 48.001 МГц, равный нашей ПЧ с отстройкой на 1 КГц:
А это его спектр:
Для проверки максимальных характеристик на стандартных макетных проводах длиной примерно 200 мм, с помощью которых были соединены ADA-HSMC и STM32F4 Discovery, корректный прием данных осуществлялся на частоте тактирования 40 МГц.
На изготовленной под данную задачу «родной» плате, через плоский шлейф длиной 100 мм, при комнатной температуре, получилось частоту дискретизации поднять до максимальной — 54 МГц.
На нужной нам частоте дискретизации 10 МГц работоспособность была проверена на промышленном диапазоне: от -40 до +60.
Собственно все. Спасибо за внимание! | https://habr.com/ru/post/482506/ | null | ru | null |
# Немного SQL алхимии
О популярной библиотеке SQLAlchemy для работы с разными СУБД из Python было написано довольно много статей. Предлагаю вашему вниманию обзор и сравнение запросов с использованием ORM и SQL подходов. Данное руководство будет интересно прежде всего начинающим разработчикам, поскольку позволяет быстро окунуться в создание и работу с SQLAlchemy, поскольку документация от разработчика SQLAlchemy на мой скромный взгляд тяжела для чтения.
Мы с вами разберем практический пример нормализации плоской таблицы, содержащей дублирующиеся данные, до состояния 3НФ ([третьей нормальной формы](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B5%D1%82%D1%8C%D1%8F_%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0)).
Из вот такой таблицы:
**Таблица с данными**
сделаем вот такую БД:
**Схема связей БД**
Для нетерпеливых: код, готовый к запуску находится в [этом репозитории](https://github.com/Yuribtr/py-homeworks-db-6). Интерактивная [схема БД здесь](https://dbdiagram.io/d/5faeec7e3a78976d7b7bd7b5). Шпаргалка по составлению ORM запросов находится в конце статьи.
Договоримся, что в тексте статьи мы будем использовать слово «Таблица» вместо «Отношение», и слово «Поле» вместо «Аттрибута». По заданию нам надо таблицу с музыкальными файлами поместить в БД, при этом устранив избыточность данных. В исходной таблице (формат CSV) имеются следующие поля (track, genre, musician, album, length, album\_year, collection, collection\_year). Связи между ними такие:
* каждый музыкант может петь в нескольких жанрах, как и в одном жанре могут выступать несколько музыкантов (отношение многие ко многим)
* в создании альбома могут участвовать один или несколько музыкантов (отношение многие ко многим)
* трек принадлежит только одному альбому (отношение один ко многим)
* треки могут в ходить в состав нескольких сборников (отношение многие ко многим)
* трек может не входить ни в одну в коллекцию.
Для упрощения предположим что названия жанров, имена музыкантов, названия альбомов и коллекций не повторяются. Названия треков могут повторяться. В БД мы запроектировали 8 таблиц:
* genres (жанры)
* genres\_musicians (промежуточная таблица)
* musicians (музыканты)
* albums\_musicians (промежуточная таблица)
* albums (альбомы)
* tracks (треки)
* collections\_tracks (промежуточная таблица)
* collections (коллекции)
\* данная схема тестовая, взята из одного из ДЗ, в ней есть некоторые недостатки — например нет связи треков с музыкантом, а также трека с жанром. Но для обучения это несущественно, и мы опустим этот недостаток.
Для теста я создал две БД на локальном Postgres: «TestSQL» и «TestORM», доступ к ним: логин и пароль test. Давайте наконец писать код!
Создаем подключения и таблицы
-----------------------------
**Создаем подключения к БД**
\* код функций read\_data и clear\_db есть в [репозитории](https://github.com/Yuribtr/py-homeworks-db-6/blob/master/inc/utils.py).
```
DSN_SQL = 'postgresql://test:test@localhost:5432/TestSQL'
DSN_ORM = 'postgresql://test:test@localhost:5432/TestORM'
# Прочитаем данные из CSV в память в виде словаря.
DATA = read_data('data/demo-data.csv')
print('Connecting to DB\'s...')
# Мы будем работать с сессиями, поэтому создадим их раздельными для каждой БД.
engine_orm = sa.create_engine(DSN_ORM)
Session_ORM = sessionmaker(bind=engine_orm)
session_orm = Session_ORM()
engine_sql = sa.create_engine(DSN_SQL)
Session_SQL = sessionmaker(bind=engine_sql)
session_sql = Session_SQL()
print('Clearing the bases...')
# Удаляем все таблицы из БД перед заливкой содержимого. Используем только для учебы.
clear_db(sa, engine_sql)
clear_db(sa, engine_orm)
```
**Создаем таблицы классическим путем через SQL**
\* код функции read\_query есть в [репозитории](https://github.com/Yuribtr/py-homeworks-db-6/blob/master/inc/utils.py). Тексты запросов также есть в [репозитории](https://github.com/Yuribtr/py-homeworks-db-6/tree/master/queries).
```
print('\nPreparing data for SQL job...')
print('Creating empty tables...')
session_sql.execute(read_query('queries/create-tables.sql'))
session_sql.commit()
print('\nAdding musicians...')
query = read_query('queries/insert-musicians.sql')
res = session_sql.execute(query.format(','.join({f"('{x['musician']}')" for x in DATA})))
print(f'Inserted {res.rowcount} musicians.')
print('\nAdding genres...')
query = read_query('queries/insert-genres.sql')
res = session_sql.execute(query.format(','.join({f"('{x['genre']}')" for x in DATA})))
print(f'Inserted {res.rowcount} genres.')
print('\nLinking musicians with genres...')
# assume that musician + genre has to be unique
genres_musicians = {x['musician'] + x['genre']: [x['musician'], x['genre']] for x in DATA}
query = read_query('queries/insert-genre-musician.sql')
# this query can't be run in batch, so execute one by one
res = 0
for key, value in genres_musicians.items():
res += session_sql.execute(query.format(value[1], value[0])).rowcount
print(f'Inserted {res} connections.')
print('\nAdding albums...')
# assume that albums has to be unique
albums = {x['album']: x['album_year'] for x in DATA}
query = read_query('queries/insert-albums.sql')
res = session_sql.execute(query.format(','.join({f"('{x}', '{y}')" for x, y in albums.items()})))
print(f'Inserted {res.rowcount} albums.')
print('\nLinking musicians with albums...')
# assume that musicians + album has to be unique
albums_musicians = {x['musician'] + x['album']: [x['musician'], x['album']] for x in DATA}
query = read_query('queries/insert-album-musician.sql')
# this query can't be run in batch, so execute one by one
res = 0
for key, values in albums_musicians.items():
res += session_sql.execute(query.format(values[1], values[0])).rowcount
print(f'Inserted {res} connections.')
print('\nAdding tracks...')
query = read_query('queries/insert-track.sql')
# this query can't be run in batch, so execute one by one
res = 0
for item in DATA:
res += session_sql.execute(query.format(item['track'], item['length'], item['album'])).rowcount
print(f'Inserted {res} tracks.')
print('\nAdding collections...')
query = read_query('queries/insert-collections.sql')
res = session_sql.execute(query.format(','.join({f"('{x['collection']}', {x['collection_year']})" for x in DATA if x['collection'] and x['collection_year']})))
print(f'Inserted {res.rowcount} collections.')
print('\nLinking collections with tracks...')
query = read_query('queries/insert-collection-track.sql')
# this query can't be run in batch, so execute one by one
res = 0
for item in DATA:
res += session_sql.execute(query.format(item['collection'], item['track'])).rowcount
print(f'Inserted {res} connections.')
session_sql.commit()
```
По сути мы создаем пакетами справочники (жанры, музыкантов, альбомы, коллекции), а затем в цикле связываем остальные данные и строим вручную промежуточные таблицы. Запускаем код и видим что БД создалась. Главное не забыть вызывать commit() у сессии.
Теперь пробуем сделать тоже самое, но с применением ORM подхода. Для того чтобы работать с ORM нам надо описать классы данных. Для этого мы создадим 8 классов (по одному на кажую таблицу).
**Список классов БД**
Код скрипта [объявления классов](https://github.com/Yuribtr/py-homeworks-db-6/blob/master/inc/db_classes.py).
```
Base = declarative_base()
class Genre(Base):
__tablename__ = 'genres'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String(20), unique=True)
# Объявляется отношение многие ко многим к Musician через промежуточную таблицу genres_musicians
musicians = relationship("Musician", secondary='genres_musicians')
class Musician(Base):
__tablename__ = 'musicians'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String(50), unique=True)
# Объявляется отношение многие ко многим к Genre через промежуточную таблицу genres_musicians
genres = relationship("Genre", secondary='genres_musicians')
# Объявляется отношение многие ко многим к Album через промежуточную таблицу albums_musicians
albums = relationship("Album", secondary='albums_musicians')
class GenreMusician(Base):
__tablename__ = 'genres_musicians'
# здесь мы объявляем составной ключ, состоящий из двух полей
__table_args__ = (PrimaryKeyConstraint('genre_id', 'musician_id'),)
# В промежуточной таблице явно указываются что следующие поля являются внешними ключами
genre_id = sa.Column(sa.Integer, sa.ForeignKey('genres.id'))
musician_id = sa.Column(sa.Integer, sa.ForeignKey('musicians.id'))
class Album(Base):
__tablename__ = 'albums'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String(50), unique=True)
year = sa.Column(sa.Integer)
# Объявляется отношение многие ко многим к Musician через промежуточную таблицу albums_musicians
musicians = relationship("Musician", secondary='albums_musicians')
class AlbumMusician(Base):
__tablename__ = 'albums_musicians'
# здесь мы объявляем составной ключ, состоящий из двух полей
__table_args__ = (PrimaryKeyConstraint('album_id', 'musician_id'),)
# В промежуточной таблице явно указываются что следующие поля являются внешними ключами
album_id = sa.Column(sa.Integer, sa.ForeignKey('albums.id'))
musician_id = sa.Column(sa.Integer, sa.ForeignKey('musicians.id'))
class Track(Base):
__tablename__ = 'tracks'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String(100))
length = sa.Column(sa.Integer)
# Поскольку по полю album_id идет связь один ко многим, достаточно указать чей это внешний ключ
album_id = sa.Column(sa.Integer, ForeignKey('albums.id'))
# Объявляется отношение многие ко многим к Collection через промежуточную таблицу collections_tracks
collections = relationship("Collection", secondary='collections_tracks')
class Collection(Base):
__tablename__ = 'collections'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String(50))
year = sa.Column(sa.Integer)
# Объявляется отношение многие ко многим к Track через промежуточную таблицу collections_tracks
tracks = relationship("Track", secondary='collections_tracks')
class CollectionTrack(Base):
__tablename__ = 'collections_tracks'
# здесь мы объявляем составной ключ, состоящий из двух полей
__table_args__ = (PrimaryKeyConstraint('collection_id', 'track_id'),)
# В промежуточной таблице явно указываются что следующие поля являются внешними ключами
collection_id = sa.Column(sa.Integer, sa.ForeignKey('collections.id'))
track_id = sa.Column(sa.Integer, sa.ForeignKey('tracks.id'))
```
Нам достаточно создать базовый класс Base для декларативного стиля описания таблиц и унаследоваться от него. Вся магия отношений между таблицами заключается в правильном использовании relationship и ForeignKey. В коде указано в каком случае мы создаем какое отношение. Главное не забыть прописать relationship с обеих сторон связи «многие ко многим».
Непосредственно создание таблиц с использованием ORM подхода происходит путем вызова:
```
Base.metadata.create_all(engine_orm)
```
> И вот тут включается магия, **буквально все классы**, объявленные в коде через наследование от Base становятся таблицами. Сходу я не увидел как указать экземпляры каких классов надо создать сейчас, а какие отложить для создания позже (например в другой БД). Наверняка такой способ есть, но в нашем коде все классы-наследники Base инстанцируются одномоментно, имейте это ввиду.
**Обновление от 08.12.20**: [создать отдельные таблицы можно](https://docs.sqlalchemy.org/en/14/core/metadata.html#creating-and-dropping-database-tables) используя следующий синтаксис:
```
genre.create(engine_orm)
```
Но для этого требуется инстанцировать объекты классов.
Наполнение таблиц при использовании ORM подхода выглядит так:
**Заполнение таблиц данными через ORM**
```
print('\nPreparing data for ORM job...')
for item in DATA:
# создаем жанры
genre = session_orm.query(Genre).filter_by(name=item['genre']).scalar()
if not genre:
genre = Genre(name=item['genre'])
session_orm.add(genre)
# создаем музыкантов
musician = session_orm.query(Musician).filter_by(name=item['musician']).scalar()
if not musician:
musician = Musician(name=item['musician'])
musician.genres.append(genre)
session_orm.add(musician)
# создаем альбомы
album = session_orm.query(Album).filter_by(name=item['album']).scalar()
if not album:
album = Album(name=item['album'], year=item['album_year'])
album.musicians.append(musician)
session_orm.add(album)
# создаем треки
# проверяем на существование трек не только по имени но и по альбому, так как имя трека по условию может
# быть не уникально
track = session_orm.query(Track).join(Album).filter(and_(Track.name == item['track'],
Album.name == item['album'])).scalar()
if not track:
track = Track(name=item['track'], length=item['length'])
track.album_id = album.id
session_orm.add(track)
# создаем коллекции, учитываем что трек может не входить ни в одну в коллекцию
if item['collection']:
collection = session_orm.query(Collection).filter_by(name=item['collection']).scalar()
if not collection:
collection = Collection(name=item['collection'], year=item['collection_year'])
collection.tracks.append(track)
session_orm.add(collection)
session_orm.commit()
```
Приходится поштучно заполнять каждый справочник (жанры, музыканты, альбомы, коллекции). В случае SQL запросов можно было генерировать пакетное добавление данных. Зато промежуточные таблицы в явном виде не надо создавать, за это отвечают внутренние механизмы SQLAlchemy.
Запросы к базам
---------------
По заданию нам надо написать 15 запросов используя обе техники SQL и ORM. Вот список поставленных вопросов в порядке возрастания сложности:
1. название и год выхода альбомов, вышедших в 2018 году;
2. название и продолжительность самого длительного трека;
3. название треков, продолжительность которых не менее 3,5 минуты;
4. названия сборников, вышедших в период с 2018 по 2020 год включительно;
5. исполнители, чье имя состоит из 1 слова;
6. название треков, которые содержат слово «me».
7. количество исполнителей в каждом жанре;
8. количество треков, вошедших в альбомы 2019-2020 годов;
9. средняя продолжительность треков по каждому альбому;
10. все исполнители, которые не выпустили альбомы в 2020 году;
11. названия сборников, в которых присутствует конкретный исполнитель;
12. название альбомов, в которых присутствуют исполнители более 1 жанра;
13. наименование треков, которые не входят в сборники;
14. исполнителя(-ей), написавшего самый короткий по продолжительности трек (теоретически таких треков может быть несколько);
15. название альбомов, содержащих наименьшее количество треков.
Как видите, вышеизложенные вопросы подразумевают как простую выборку так и с объединением таблиц, а также использование агрегатных функций.
Ниже предоставлены решения по каждому из 15 запросов в двух вариантах (используя SQL и ORM). В коде запросы идут парами, чтобы показать идентичность результатов на выводе в консоль.
**Запросы и их краткое описание**
```
print('\n1. All albums from 2018:')
query = read_query('queries/select-album-by-year.sql').format(2018)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Album).filter_by(year=2018):
print(item.name)
print('\n2. Longest track:')
query = read_query('queries/select-longest-track.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Track).order_by(Track.length.desc()).slice(0, 1):
print(f'{item.name}, {item.length}')
print('\n3. Tracks with length not less 3.5min:')
query = read_query('queries/select-tracks-over-length.sql').format(310)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Track).filter(310 <= Track.length).order_by(Track.length.desc()):
print(f'{item.name}, {item.length}')
print('\n4. Collections between 2018 and 2020 years (inclusive):')
query = read_query('queries/select-collections-by-year.sql').format(2018, 2020)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Collection).filter(2018 <= Collection.year,
Collection.year <= 2020):
print(item.name)
print('\n5. Musicians with name that contains not more 1 word:')
query = read_query('queries/select-musicians-by-name.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Musician).filter(Musician.name.notlike('%% %%')):
print(item.name)
print('\n6. Tracks that contains word "me" in name:')
query = read_query('queries/select-tracks-by-name.sql').format('me')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Track).filter(Track.name.like('%%me%%')):
print(item.name)
print('Ok, let\'s start serious work')
print('\n7. How many musicians plays in each genres:')
query = read_query('queries/count-musicians-by-genres.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Genre).join(Genre.musicians).order_by(func.count(Musician.id).desc()).group_by(
Genre.id):
print(f'{item.name}, {len(item.musicians)}')
print('\n8. How many tracks in all albums 2019-2020:')
query = read_query('queries/count-tracks-in-albums-by-year.sql').format(2019, 2020)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Track, Album).join(Album).filter(2019 <= Album.year, Album.year <= 2020):
print(f'{item[0].name}, {item[1].year}')
print('\n9. Average track length in each album:')
query = read_query('queries/count-average-tracks-by-album.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Album, func.avg(Track.length)).join(Track).order_by(func.avg(Track.length)).group_by(
Album.id):
print(f'{item[0].name}, {item[1]}')
print('\n10. All musicians that have no albums in 2020:')
query = read_query('queries/select-musicians-by-album-year.sql').format(2020)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
subquery = session_orm.query(distinct(Musician.name)).join(Musician.albums).filter(Album.year == 2020)
for item in session_orm.query(distinct(Musician.name)).filter(~Musician.name.in_(subquery)).order_by(
Musician.name.asc()):
print(f'{item}')
print('\n11. All collections with musician Steve:')
query = read_query('queries/select-collection-by-musician.sql').format('Steve')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Collection).join(Collection.tracks).join(Album).join(Album.musicians).filter(
Musician.name == 'Steve').order_by(Collection.name):
print(f'{item.name}')
print('\n12. Albums with musicians that play in more than 1 genre:')
query = read_query('queries/select-albums-by-genres.sql').format(1)
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
for item in session_orm.query(Album).join(Album.musicians).join(Musician.genres).having(func.count(distinct(
Genre.name)) > 1).group_by(Album.id).order_by(Album.name):
print(f'{item.name}')
print('\n13. Tracks that not included in any collections:')
query = read_query('queries/select-absence-tracks-in-collections.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
# Important! Despite the warning, following expression does not work: "Collection.id is None"
for item in session_orm.query(Track).outerjoin(Track.collections).filter(Collection.id == None):
print(f'{item.name}')
print('\n14. Musicians with shortest track length:')
query = read_query('queries/select-musicians-min-track-length.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
subquery = session_orm.query(func.min(Track.length))
for item in session_orm.query(Musician, Track.length).join(Musician.albums).join(Track).group_by(
Musician.id, Track.length).having(Track.length == subquery).order_by(Musician.name):
print(f'{item[0].name}, {item[1]}')
print('\n15. Albums with minimum number of tracks:')
query = read_query('queries/select-albums-with-minimum-tracks.sql')
print(f'############################\n{query}\n############################')
print('----SQL way---')
res = session_sql.execute(query)
print(*res, sep='\n')
print('----ORM way----')
subquery1 = session_orm.query(func.count(Track.id)).group_by(Track.album_id).order_by(func.count(Track.id)).limit(1)
subquery2 = session_orm.query(Track.album_id).group_by(Track.album_id).having(func.count(Track.id) == subquery1)
for item in session_orm.query(Album).join(Track).filter(Track.album_id.in_(subquery2)).order_by(Album.name):
print(f'{item.name}')
```
Для тех, кому не хочется погружаться в чтение кода, я попробую показать как выглядит «сырой» SQL и его альтернатива в ORM выражении, поехали!
Шпаргалка по сопоставлению SQL запросов и ORM выражений
-------------------------------------------------------
1. название и год выхода альбомов, вышедших в 2018 году:
SQL
```
select name
from albums
where year=2018
```
ORM
```
session_orm.query(Album).filter_by(year=2018)
```
2. название и продолжительность самого длительного трека:
SQL
```
select name, length
from tracks
order by length DESC
limit 1
```
ORM
```
session_orm.query(Track).order_by(Track.length.desc()).slice(0, 1)
```
3. название треков, продолжительность которых не менее 3,5 минуты:
SQL
```
select name, length
from tracks
where length >= 310
order by length DESC
```
ORM
```
session_orm.query(Track).filter(310 <= Track.length).order_by(Track.length.desc())
```
4. названия сборников, вышедших в период с 2018 по 2020 год включительно:
SQL
```
select name
from collections
where (year >= 2018) and (year <= 2020)
```
ORM
```
session_orm.query(Collection).filter(2018 <= Collection.year, Collection.year <= 2020)
```
*\* обратите внимание что здесь и далее фильтрация задается уже с использованием filter, а не с использованием filter\_by.*
5. исполнители, чье имя состоит из 1 слова:
SQL
```
select name
from musicians
where not name like '%% %%'
```
ORM
```
session_orm.query(Musician).filter(Musician.name.notlike('%% %%'))
```
6. название треков, которые содержат слово «me»:
SQL
```
select name
from tracks
where name like '%%me%%'
```
ORM
```
session_orm.query(Track).filter(Track.name.like('%%me%%'))
```
7. количество исполнителей в каждом жанре:
SQL
```
select g.name, count(m.name)
from genres as g
left join genres_musicians as gm on g.id = gm.genre_id
left join musicians as m on gm.musician_id = m.id
group by g.name
order by count(m.id) DESC
```
ORM
```
session_orm.query(Genre).join(Genre.musicians).order_by(func.count(Musician.id).desc()).group_by(Genre.id)
```
8. количество треков, вошедших в альбомы 2019-2020 годов:
SQL
```
select t.name, a.year
from albums as a
left join tracks as t on t.album_id = a.id
where (a.year >= 2019) and (a.year <= 2020)
```
ORM
```
session_orm.query(Track, Album).join(Album).filter(2019 <= Album.year, Album.year <= 2020)
```
9. средняя продолжительность треков по каждому альбому:
SQL
```
select a.name, AVG(t.length)
from albums as a
left join tracks as t on t.album_id = a.id
group by a.name
order by AVG(t.length)
```
ORM
```
session_orm.query(Album, func.avg(Track.length)).join(Track).order_by(func.avg(Track.length)).group_by(Album.id)
```
10. все исполнители, которые не выпустили альбомы в 2020 году:
SQL
```
select distinct m.name
from musicians as m
where m.name not in (
select distinct m.name
from musicians as m
left join albums_musicians as am on m.id = am.musician_id
left join albums as a on a.id = am.album_id
where a.year = 2020
)
order by m.name
```
ORM
```
subquery = session_orm.query(distinct(Musician.name)).join(Musician.albums).filter(Album.year == 2020)
session_orm.query(distinct(Musician.name)).filter(~Musician.name.in_(subquery)).order_by(Musician.name.asc())
```
11. названия сборников, в которых присутствует конкретный исполнитель (Steve):
SQL
```
select distinct c.name
from collections as c
left join collections_tracks as ct on c.id = ct.collection_id
left join tracks as t on t.id = ct.track_id
left join albums as a on a.id = t.album_id
left join albums_musicians as am on am.album_id = a.id
left join musicians as m on m.id = am.musician_id
where m.name like '%%Steve%%'
order by c.name
```
ORM
```
session_orm.query(Collection).join(Collection.tracks).join(Album).join(Album.musicians).filter(Musician.name == 'Steve').order_by(Collection.name)
```
12. название альбомов, в которых присутствуют исполнители более 1 жанра:
SQL
```
select a.name
from albums as a
left join albums_musicians as am on a.id = am.album_id
left join musicians as m on m.id = am.musician_id
left join genres_musicians as gm on m.id = gm.musician_id
left join genres as g on g.id = gm.genre_id
group by a.name
having count(distinct g.name) > 1
order by a.name
```
ORM
```
session_orm.query(Album).join(Album.musicians).join(Musician.genres).having(func.count(distinct(Genre.name)) > 1).group_by(Album.id).order_by(Album.name)
```
13. наименование треков, которые не входят в сборники:
SQL
```
select t.name
from tracks as t
left join collections_tracks as ct on t.id = ct.track_id
where ct.track_id is null
```
ORM
```
session_orm.query(Track).outerjoin(Track.collections).filter(Collection.id == None)
```
*\* обратите внимание что несмотря на предупреждение в PyCharm надо именно так составлять условие фильтрации, если написать как предлагает IDE («Collection.id **is** None») то оно работать не будет.*
14. исполнителя(-ей), написавшего самый короткий по продолжительности трек (теоретически таких треков может быть несколько):
SQL
```
select m.name, t.length
from tracks as t
left join albums as a on a.id = t.album_id
left join albums_musicians as am on am.album_id = a.id
left join musicians as m on m.id = am.musician_id
group by m.name, t.length
having t.length = (select min(length) from tracks)
order by m.name
```
ORM
```
subquery = session_orm.query(func.min(Track.length))
session_orm.query(Musician, Track.length).join(Musician.albums).join(Track).group_by(Musician.id, Track.length).having(Track.length == subquery).order_by(Musician.name)
```
15. название альбомов, содержащих наименьшее количество треков:
SQL
```
select distinct a.name
from albums as a
left join tracks as t on t.album_id = a.id
where t.album_id in (
select album_id
from tracks
group by album_id
having count(id) = (
select count(id)
from tracks
group by album_id
order by count
limit 1
)
)
order by a.name
```
ORM
```
subquery1 = session_orm.query(func.count(Track.id)).group_by(Track.album_id).order_by(func.count(Track.id)).limit(1)
subquery2 = session_orm.query(Track.album_id).group_by(Track.album_id).having(func.count(Track.id) == subquery1)
session_orm.query(Album).join(Track).filter(Track.album_id.in_(subquery2)).order_by(Album.name)
```
Как видите, вышеизложенные вопросы подразумевают как простую выборку так и с объединением таблиц, а также использование агрегатных функций и подзапросов. Все это реально сделать с SQLAlchemy как в режиме SQL так и в режиме ORM. Разноообразие операторов и методов позволяет выполнить запрос наверное любой сложности.
Надеюсь данный материал поможет начинающим быстро и эффективно начать составлять запросы. | https://habr.com/ru/post/531472/ | null | ru | null |
# Как генерировать стихи с помощью силлабо-тонической трансформенной языковой модели (часть первая)
Всем привет! Меня зовут Илья Козиев, я работаю в Управлении экспериментальных систем машинного обучения SberDevices над вопросами генерации текстового контента. В этой статье я хочу представить эффективный способ решения такой интересной задачи, как генерация стихов, с помощью одной из самых современных нейросетевых архитектур — GPT-3. Я подробно распишу все необходимые шаги на пути к получению стихов примерно вот такого уровня:
*Я оставляю брошенные фразы
Иного смеха, слабости и слёз
Я превращаюсь в голубые стразы
Кружась ветвями молодых берёз*
Ещё пример:
*Люблю грозу в начале мая
Седую стужу в летний зной
И солнцем землю заливая
Весна придёт в мой край родной*
Или даже так, с оттенком Агнии Барто:
*Опять весна, и вечер наступает
Идет бычок, вздыхает на ходу
И мать кричит, и друга обнимает
Ищу его, покой я не найду*
Можно даже сделать продолжение стиха с заданной строчки:
*Мчатся тучи, вьются тучи
Опускается рассвет
Мысли пламенные жгучи
И весны тревожный след*
Кажется, что все эти эмоции, нечёткие ассоциации и аллюзии, обёрнутые в строгую форму ритма и рифмы, не так-то просто совместить с холодной и бездушной математикой машинного обучения. По сути затронем одну из самых горячих тем в области искусственного интеллекта — машинное творчество. Кроме описания подхода, в конце будет ссылка на докер-образ с кодом и готовыми моделями для ваших экспериментов.
### Как насчёт ruGPT-3 и ruT5?
На первый взгляд кажется, что генерация стихов мало чем отличается от генерации текста вообще. А что у нас есть хорошего для генерации текста в текущей точке пространства-времени? Конечно же, большие языковые модели GPT и T5 (а также их многочисленные родственники). Для русского языка существуют ruGPT и ruT5, выложенные [в общий доступ](https://huggingface.co/sberbank-ai), так что было бы странно не проанализировать их применимость для такой задачи.
Кстати, поскольку в рамках описываемого подхода мы будем тренировать свою «поэтическую» GPT **с нуля**, будет полезно заглянуть в [описание тренировки ruGPT](https://habr.com/ru/company/sberbank/blog/567776/). А для погружения в тему текстовой генерации с помощью ruGPT полезным будет заглянуть в статьи «[Тестируем ruGPT-3 на новых задачах](https://habr.com/ru/company/sberbank/blog/528966/)» и «[Всё, что нам нужно — это генерация](https://habr.com/ru/company/sberbank/blog/550056/)».
Итак, модели ruGPT [обучены](https://habr.com/ru/company/sberbank/blog/567776/) на очень большом (десятки Гб) массиве русскоязычных текстов и хорошо знают морфологию, синтаксис и всякие нюансы словоупотребления для русского языка в текстах разных видов, включая художественную литературу, болтовню на форумах, статьи Википедии, новости. Что надо сделать, чтобы GPT начала радовать нас стихами? В нашем распоряжении три подхода.
Во-первых, можно взять большую модель ([Large](https://huggingface.co/sberbank-ai/rugpt3large_based_on_gpt2) или лучше даже [XL](https://huggingface.co/sberbank-ai/rugpt3xl)) и применить **zero-shot** или **few-shot** подходы. Так как при начальном обучении ruGPT видела некоторое количество стихов, оба эти подхода позволят получить какой-то результат без затрат на дообучение моделей.
Во-вторых, можно дообучить ruGPT целенаправленно на корпусе из стихов, чтобы увеличить шансы на получение стихотворной «годноты». Об этом подходе можно почитать в статье «[Как ИИ учится литературному творчеству, или Любовные письма от тостера](https://habr.com/ru/company/sberdevices/blog/566738/)». Корпус стихов можно взять [готовый](https://github.com/IlyaGusev/PoetryCorpus), или наскрапить свой с сайтов поэтического самиздата, о чём я более подробно расскажу во второй части.
Третий подход основан на prompt tuning’е лежит где-то между первыми двумя. С одной стороны, тут будет нужен набор обучающих примеров, так что совсем без подготовки своего корпуса тут не обойтись. Но с другой стороны, количество этих примеров может быть намного меньше, чем для настоящего файнтюна самой языковой модели, так как требуется обучить намного меньшую по размеру вспомогательную нейросетку с более простой архитектурой. Подробности и примеры данного подхода можно найти в статье «[Управляем генерацией ruGPT-3: библиотека ruPrompts](https://habr.com/ru/company/sberdevices/blog/596103/)».
Насколько хорошо работают эти подходы для генерации стихов? Увы и ах, если вы попробуете их (а я крайне рекомендую «пощупать» эти подходы своими руками!), то увидите, что получается не очень. Модели будут стараться выдавать обычную прозу, хотя и не лишенную какого-то налёта верлибра. Причина в том, что привычные нам стихи, а именно силлабо-тоническая поэзия, — это не только и не столько грамматически корректное **содержание**, но и определённая **форма**, а именно [порядок чередования ударных и безударных слогов](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BB%D0%BB%D0%B0%D0%B1%D0%BE-%D1%82%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D1%81%D1%82%D0%B8%D1%85%D0%BE%D1%81%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), а также фонетическое соответствие [заударных окончаний последних слов](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%83%D0%B7%D1%83%D0%BB%D0%B0) в строках. Эту информацию языковая модель в ходе обучения на обычных текстах в явном виде не получает, и вывести её как правила синтаксиса из обычных текстов стихов она тоже может лишь с большим трудом и напряжением всех машинных сил. Говоря проще, модели ruGPT и ruT5 не знают **ничего** про позиции ударений и разбивку слов на слоги. Да, после дообучения такая модель может запомнить некоторое количество пар рифмуемых слов, но этого мало.
Впрочем, иногда такая отфайнтюненная ruGPT выдаёт что-то интересное:
*А в небе звёздочка горит,
Сияет так красиво!
И на ветвях берёз шумит
Своей листвой игриво*
Но это будут редкие сокровища в терриконах плохо зарифмованных текстов, которые напоминают стихи только «геометрией»:
*Я знаю, ты не станешь смеяться
В этот день над моими стихами.
Только белая берёза проснётся
Под моим окном, и заплачет с нами*
ОК, раз ruGPT сама не может «в рифму», почему не подсказать ей? Можно взять [словарь рифм](https://rifmovnik.ru/find), какую-то готовую [библиотеку](https://github.com/alexeykarnachev/tom_rhymer), или даже натренировать свою нейромодель рифмовки, чтобы сначала подбирать последнее слово для каждой строки, а стартовые фрагменты строк генерировать с помощью отфайнтюненной на стихах ruT5 и так называемых sentinel tokens. Первые две строки стиха можно генерировать просто в отфайнтюненной rugpt, хотя это ограничит нас схемой рифмовки ABAB:
Заодно можно генерировать и заголовок стиха отдельной ruGPT, решая задачу «поэтической суммаризации». Да, такая *немного* переусложненная архитектура работает чуть лучше просто отфайнтюненной ruGPT, но мы ведь можем сделать намного лучше, да?
Ключевая идея силлабо-тонической модели
---------------------------------------
Как я уже сказал, стать хорошим поэтом ruGPT мешает полное непонимание фонетики русского языка. Можем ли мы научить модель GPT русской фонетике? Да легко! Всё, что для этого нужно — выбрать **правильное** представление текста, чтобы в явном виде представить знания об ударных и безударных гласных. А как это сделать? Через правильную **токенизацию**.
Оригинальная GPT (и ruGPT тоже) представляет текст как последовательность неких токенов. Количество этих токенов выбирается заранее ([чуть больше 50 тысяч](https://huggingface.co/sberbank-ai/rugpt3large_based_on_gpt2/blob/main/vocab.json) по сложившейся практике), и словарь формируется автоматически — так, чтобы любое слово языка представлять заранее фиксированным набором токенов. К примеру, в ruGPT самые частотные слова, наподобие «*были*», состоят из 1 токена, а более редкие бьются на кусочки. В результате, слово «*фальшивомонетчицею*» представляется цепочкой токенов «фаль | ши | вом | он | ет | чи | це | ю». Почти слоги, кстати. Фонетическая неконсистентность такого разбиения слов — проблема, от которой нам надо избавиться. Поэтому давайте бить слова явно и регулярно на нормальные **слоги**, чтобы, например, «*были*» представлялось как «бы | ли». И заодно пометим ударные слоги каким-то маркером, например стандартным юникодным символом справа от гласной:
`В ле|су́ ро|ди́|лась ё́|лоч|ка`
Таким образом, слоги «су» и «су́» становятся **разными** токенами (технически — имеют разные числовые индексы), и в ходе обучения модель поймёт, где какой употребляется.
Отлично, а что с рифмами? Может, они как-то сами собой начнут возникать?
Тут стоит вспомнить, как происходит генерация текста в авторегрессионных моделях типа GPT. А происходит она **слева направо**, так как обучающие тексты она видит именно в таком порядке. В случае стихов это означает, что к моменту, когда надо выбирать последнее слово в строке, модель уже нагенерировала всю начальную цепочку. И зачастую наскрести в языковых сусеках слово с нужной рифмой уже нереально сложно, не поломав метрику. Вот если бы делать наоборот, сначала выбрать последнее слово в строке с нужной рифмой, а потом дописать начало строки…
А что, собственно, мешает нам писать стихотворную строку **справа налево**? Правильно, ничто, кроме привычки и зашоренности. В других частях нашего обитаемого мира люди пишут и справа налево, и сверху вниз. Вот и давайте отбросим предрассудки, развернём все слова в каждой строке, так сказать «арабизируем» текст.
Было так:
*И в нарастающей воде
Призывный стон из глубины
А дале гул звучит везде
То первый вздох и глас весны*
А стало так:
`де́ во | щей ю ста́ ра на | в | И
ны́ би глу | из | сто́н | вный зы́ При
зде́ ве | чи́т зву | гу́л | ле да́ | А
сны́ ве | гла́с | и | вздо́х | вый пе́р | То`
Обратите внимание, что символы в слогах написаны слева направо, а слова и слоги записаны **справа налево**. Кстати, через некоторое время такие тексты можно научиться читать невооруженным глазом. Хотя делать это приходится только при отладке кода, так что волноваться не надо.
Приглядевшись к новому представлению стиха, можно увидеть, что **рифмуемые** слова идут уже в **начале** каждой строки. Генерация текста сначала будет выбирать рифмуемое слово, затем дописывать к нему строку. Хотя может показаться совсем не очевидным, что какая-то там нейросетка сможет писать русский текст справа налево, в то время как его носители вроде бы делают это наоборот. Уверяю — сможет, и неплохо!
Собственно говоря, в этот момент термин «[силлабо-тонический](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BB%D0%BB%D0%B0%D0%B1%D0%BE-%D1%82%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D1%81%D1%82%D0%B8%D1%85%D0%BE%D1%81%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5)» в названии модели должен уже стать полностью раскрытым :)
Разобравшись с представлением стихотворного текста, можно приступать к тренировке языковой модели.
Тренировка силлабо-тонической языковой модели
---------------------------------------------
В этой части я кратко опишу пайплайн тренировки генератора стихов, а важные технические нюансы я подробно опишу в отдельной статье.
Большие языковые модели (далее ЯМ), в чьи ряды должна влиться и наша поэтическая GPT, обычно обучаются в 2 захода. Сначала ЯМ тренируется на очень большом наборе текстов без ручной разметки (претрейн). Корпус для претрейна в нашем случае состоит из автоматически размеченной русскоязычной прозы объёмом примерно 10 миллиардов символов. Этот этап формирует у модели общее понимание грамматики языка, необходимое для генерации связного текста. Плохая новость состоит в том, что претрейн это чрезвычайно ресурсоёмкое и длительное мероприятие. В нашем случае много времени (2—3 недели) занимает расстановка ударений в тексте, и ещё 2—3 дня собственно тренировка трансформенной модели. Хорошая новость заключается в том, что предобученная ЯМ может затем использоваться многократно для экспериментов с файнтюном в качестве базовой. Чтобы сэкономить время тех читателей, которые захотят поэкспериментировать с генерацией стихов и натренировать свою ЯМ, во второй части будет дана ссылка на скачивание готового корпуса.
На втором этапе ЯМ подвергается дообучению под целевую задачу (файнтюн). Используемый для этого корпус состоит из автоматически размеченного набора стихов с небольшой добавкой ручного труда. Основное время тут тратится на сбор стихотворного «сырья», а тренировка модели происходит почти мгновенно — всего несколько часов. Среди важных технических деталей этого этапа я бы назвал разметку стихов с подбором метра, фильтрацию некачественных стихов, и подготовку данных для управления генерацией. Во второй части я также дам ссылку на скачивание готового корпуса для файнтюна и расскажу, как его запускать.
И претрейн, и файнтюн модели делается немного [модифицированной версией кода](https://github.com/Koziev/verslibre/blob/stressed_gpt/py/pretrain_transformers.py) из репозитория ru-gpts. Метаданные и веса моделей получаются в формате, пригодном для запуска инференса с помощью библиотеки transformers, хотя для токенизации придётся использовать свой класс, а не имеющиеся в transformers готовые токенизаторы.
Кстати, тот факт, что у нас модель в целом является вариантом GPT со штатным API инференса, позволяет легко делать самые разные эксперименты, пробуя всякие новинки в теме генерации текстов. О некоторых таких экспериментах я планирую рассказать в одной из будущих статей.
Генератор стихов
----------------
Итогом всех наших трудов будут две модели. Первая будет генерировать четверостишье на заданную тему в заданном формате. Вторая модель будет продолжать начатое первой, генерировать следующие четыре строчки, самостоятельно подлаживаясь под метрику и содержание начальных строк. Остаётся завернуть это в какой-то удобный для использования вид, например — телеграм-бот. Я подготовил докер-образ такого бота со всеми необходимыми моделями и кодом для инференса. Вы можете скачать его и запустить у себя примерно так:
`sudo docker pull inkoziev/verslibre:latest
sudo docker run -it inkoziev/verslibre:latest`
После запуска образа в консоли надо будет ввести токен телеграм-бота, и ваш личный генератор к вашим услугам:
Возвращаясь к теме машинного творчества, упомянутой в самом начале, стоит пару слов сказать про виртуальных ассистентов. Сегодня мы вплотную приблизились к созданию таких чат-ботов, которые будут способны не только отвечать на заранее отобранные вопросы и выполнять простые поручения, играя роль секретаря. Ассистенты нового поколения, возможно, уже скоро будут создавать для нас персональный контент, выполняя роль своего личного [композитора](https://habr.com/ru/company/sberdevices/blog/591441/), писателя или [художника](https://habr.com/ru/company/sberbank/blog/586926/).
Подборка результатов генерации
------------------------------
\* \* \* *Моя любовь, стихи и песни, стоны
И шёпот, шёпот, шёпот тишины
Когда алеют розы, как пионы
Когда искрятся праздники весны*
\* \* \* *Мне хочется пройти сквозь тающий песок
И вылиться ручьями этой влаги
Упасть, сорваться, стать на волосок
Швырнуть, на лист промасленной бумаги*
\* \* \* *Погода - ядовитая отрава
Осоки, травы, смятые кусты
Обиды и слова - дурная слава
Вникают в строки - смятые листы*
\* \* \*
*Принёс букеты алых роз
Ей из неведомого края
Восторг, и грусть, и море слёз
Апофеоз любви и рая*
\* \* \*
*Открыв глаза, увижу сон
И лишь однажды я узнаю
Я боль, когда я вижу сон
Вдыхаю, выдыхаю, таю* | https://habr.com/ru/post/660717/ | null | ru | null |
# Еще раз о регекспах, бэктрекинге и том, как можно положить на лопатки JVM двумя строками «безобидного» кода
Раннее утро, десятая чашка кофе, безуспешные попытки понять почему ваше клиентское (или еще хуже – серверное) java-приложение намертво зависло при вычислении простого регекспа на небольшой строке… Если подобная ситуация уже возникала в вашей жизни, вы уже наверняка знаете про [бэктрекинг](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D1%81_%D0%B2%D0%BE%D0%B7%D0%B2%D1%80%D0%B0%D1%82%D0%BE%D0%BC) и темную сторону регулярных выражений. Остальным – добро пожаловать под кат!
Бэктрекинг, или вечное ожидание результата
------------------------------------------
Проблема бэктрекинга при матчинге регулярных выражений уже неоднократно поднималась в различных статьях на хабре ([раз](https://habr.com/ru/company/mailru/blog/270507/), [два](https://habr.com/ru/post/55863/), [три](https://habr.com/ru/post/56765/)), поэтому опишем ее суть без погружения в детали. Рассмотрим простой синтетический пример – типичный экземпляр из так называемых *"evil regexes"* (аналог изначально представлен [тут](https://dzone.com/articles/how-kill-java-regular)):
```
@Test
public void testRegexJDK8Only() {
final Pattern pattern = Pattern.compile("(0*)*1");
Assert.assertFalse(pattern.matcher("0000000000000000000000000000000000000000").matches());
}
```
*Напомню: символ* ***\**** *в регулярных выражениях ("ноль или несколько символов") называется квантификатором. Им же являются такие символы, как ?, +, {n} (n – количество повторений группы или символа).*
Если запустить код на **JDK8** (почему на более актуальных версиях воспроизводиться не будет – опишем далее), то JVM будет **очень** долго вычислять результат работы метода matches(). Едва ли вам удастся его дождаться, не состарившись на несколько месяцев или даже лет.
Что же пошло не так? Стандартная реализация Pattern/Matcher из пакета `java.util.regex`будет искать решение из теста следующим образом:
1. **\*** - *жадный квантификатор*, поскольку всегда будет пытаться захватить в себе как можно большее количество символов. Так, в нашем случае группа **(0)**захватит полностью всю строку, звезда снаружи группы увидит, что может повториться ровно один раз, а единицы в строке не окажется. Первая проверка на соответствие провалилась.
2. Произведем откат *(backtrack)* к начальному состоянию. Мы попытались захватить максимальную группу из нулей и нас ждал провал; давайте теперь возьмём на один нолик меньше. Тогда группа**(0)** захватит все нули без одного, снаружи группы укажет на наличие единственной группы, а оставшийся нольне равен единице. Снова провал.
3. Снова откатываемся к начальному состоянию и забираем группой**(0)** все нули без двух последних. Но ведь оставшиеся два нуля тоже могут заматчиться группой **(0)**!И теперь эта группа тоже попытается сначала захватить два нуля, после чего попытается взять один ноль, и после этого произойдет откат и попытка матчинга строки уже без трех нулей.
Легко догадаться, что по мере уменьшения "начальной" жадной группы будет появляться множество вариаций соседних групп**(0)**, которые также придется откатывать и проверять все большее количество комбинаций. Сложность будет расти экспоненциально; при наличии достаточного количества нулей в строке – прямо как в нашем примере – возникнет так называемый [*катастрофический бэктрекинг*](http://www.regular-expressions.info/catastrophic.html), который и приведет к печальным последствиям.
**"Но ведь пример абсолютно синтетический! А в жизни так бывает?"** - резонно спросите вы. Ответ вполне ожидаем: бывает, и очень часто. Например, для решения бизнес-задачи программисту необходимо составить регулярку, проверяющую, что в строке есть не более 10 слов, разделенных пробелами и знаками препинания. Не заморачиваясь с аккуратным созданием регекспа, на свет может появиться следующий код:
```
@Test
public void testRegexAnyJDK() {
final Pattern pattern = Pattern.compile("([A-Za-z,.!?]+( |\\-|\\')?){1,10}");
Assert.assertFalse(pattern.matcher("scUojcUOWpBImlSBLxoCTfWxGPvaNhczGpvxsiqagxdHPNTTeqkoOeL3FlxKROMrMzJDf7rvgvSc72kQ").matches());
}
```
Представленная тестовая строка имеет длину 80 символов и сгенерирована случайным образом. Она не заставит JVM на JDK8+ работать вечно – всего лишь около 30 минут – но этого уже достаточно, чтобы нанести вашему приложению существенный вред. В случае разработки серверных приложений риск многократно увеличивается из-за возможности проведения [ReDoS-атак](https://en.wikipedia.org/wiki/ReDoS). Причиной же подобного поведения, как и в первом примере, является бэктрекинг, а именно – сочетание квантификаторов **"+"** внутри группы и **"{1,10}"** – снаружи.
Война с бэктрекингом или с разработчиками Java SDK?
---------------------------------------------------
Чем запутаннее паттерн, тем сложнее для неопытного человека увидеть проблемы в регулярном выражении. Причем речь сейчас идет вовсе не о внешних пользователях, использующих ваше ПО, а о разработчиках. Так, с конца нулевых было создано значительное количество тикетов с жалобой на бесконечно работающий матчинг. Несколько примеров: [JDK-5026912](https://bugs.openjdk.java.net/browse/JDK-5026912), [JDK-7006761](https://bugs.java.com/bugdatabase/view_bug.do?bug_id=7006761), [JDK-8139263](https://bugs.java.com/bugdatabase/view_bug.do?bug_id=8139263). Реже можно встретить жалобы на [StackOverflowError](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StackOverflowError.html), который тоже типичен при проведении матчинга ([JDK-5050507](https://bugs.java.com/bugdatabase/view_bug.do?bug_id=5050507)). Все подобные баги закрывались с одними и теми же формулировками: "неэффективный регексп", "катастрофический бектрекинг", "не является багом".
Альтернативным предложением сообщества в ответ на невозможность "починить" алгоритм было внедрение таймаута при применении регулярного выражения или другого способа остановить матчинг, если тот выполняется слишком долго. Подобный подход можно относительно легко реализовать самостоятельно (например, часто его можно встретить на сервисах для проверки регулярных выражений - таких как [этот](https://www.freeformatter.com/java-regex-tester.html)), но предложение реализации таймаута в API `java.util.regex` также неоднократно выдвигалось и к разработчикам JDK (тикеты [JDK-8234713](https://bugs.openjdk.java.net/browse/JDK-8234713), [JDK-8054028](https://bugs.openjdk.java.net/browse/JDK-8054028), [JDK-7178072](https://bugs.openjdk.java.net/browse/JDK-7178072)). Первый тикет все еще не имеет исполнителя; два остальных были закрыты, поскольку *"правильным решением будет улучшить реализацию, которая лучше справляется с кейсами, в которых наблюдается деградация"* ([пруф](https://bugs.openjdk.java.net/browse/JDK-7178072?focusedCommentId=12255535&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-12255535)).
Доработки алгоритма действительно происходили. Так, в JDK9 реализовано следующее улучшение: каждый раз, когда применяется жадный квантификатор, не соответствующий данным для проверки, выставляется курсор, указывающий на позицию в проверяемом выражении. При повторной проверке после отката достаточно убедиться, что если для текущей позиции проверка уже была провалена, продолжение текущего подхода лишено смысла и проводиться не будет ([JDK-6328855](https://bugs.openjdk.java.net/browse/JDK-6328855), [пояснение](https://andy.hammerhartes.de/regex-improvements-in-openjdk-9-less-exponential-backtracking.html)). Это позволило исключить бесконечный матчинг в тесте `testRegexJDK8Only()` начиная с версии [jdk9-b119](http://mail.openjdk.java.net/pipermail/jdk9-dev/2016-May/004336.html), однако второй тест вызывает задержки вне зависимости от версии JDK. Более того, при наличии обратных ссылок в регулярных выражениях оптимизация не используется.
Опасный враг: внешнее управление
--------------------------------
Публикации, упомянутые в самом начале статьи, отлично раскрывают варианты оптимизации регулярных выражений, в результате чего катастрофический бектрекинг перестает быть опасным врагом; для сложных случаев потребуется дополнительная экспертиза, но в целом регулярное выражение можно почти всегда записать "безопасным" образом. Да и проверить себя тоже можно, например, на [npmjs.com](https://www.npmjs.com/package/safe-regex). Проблема остается при составлении очень сложных регулярок, а также в тех сценариях, когда регулярное выражение задается **не программистом, а аналитиком, заказчиком после передачи решения, или же пользователем**. В последнем случае управление сложностью регулярного выражения оказывается снаружи – и вам придется позаботиться о том, чтобы при любых условиях приложение продолжало корректную работу.
Использование стандартной библиотеки в таком случае, очевидно, не лучший выбор. К счастью, существуют сторонние фреймворки, позволяющие производить матчинг за линейное время. Одним из таких фреймворков является [RE2](https://en.wikipedia.org/wiki/RE2_(software)), под капотом которого используется **DFA** - подход. Не будем вдаваться в детали реализации и подробно описывать разницу подходов; отметим лишь его растущую популярность – RE2 используется как дефолтный движок в Rust, а также активно применяется во множестве продуктов экосистемы Google. Для JDK7+ существует [RE2/J](https://github.com/google/re2j), которая является прямым портом из C++ - версии библиотеки.
В конце января 2021 года был опубликован [драфт JEP-а](https://openjdk.java.net/jeps/8260688), в котором предлагается создать движок для регулярных выражений с матчингом за линейное время, и одним из основных подходов в реализации является именно RE2.
RE2/J - серебряная пуля?
------------------------
Может показаться, что переход на RE2/J – отличный выбор практически для каждого проекта. Какова цена линейного времени выполнения?
* У RE2/J отсутствует ряд методов API у Matcher;
* Синтаксис регулярных выражений совпадает не полностью (у RE2/J отсутствует часть конструкций, в том числе – обратные ссылки, backreferences). Вполне вероятно, после замены импорта ваша регулярка перестанет корректно распознаваться;
* Несмотря на то, что формально код принадлежит Google, библиотека не является официальной, а основным ее мейнтейнером является единственный разработчик – [Джеймс Ринг](https://github.com/sjamesr).
* Разработчик фреймворка [подчеркивает](https://groups.google.com/g/re2j-discuss/c/t8yW4rP1IbU): "Основная задача RE2/J заключается в обеспечении линейного времени выполнения матчинга при наличии регулярных выражений от внешних источников. *Если все регулярные выражения находятся под контролем разработчика, вероятно, использование java.util.regex является лучшим выбором*".
Надеюсь, этих пунктов достаточно, чтобы убедиться: **RE2/J – не серебряная пуля**; фреймворк не является бескомпромиссным решением для проверки на соответствие регулярным выражениям. Реализация при создании кода повлечет ограниченный функционал, а прямая замена импорта в уже существующем коде может негативно сказаться на стабильности работы приложения.
Итоги
-----
1. Даже простые регулярные выражения при невнимательном написании могут сделать ваш продукт уязвимым для ReDoS.
2. Движков регулярных выражений, которые были бы одновременно максимально функциональны, быстры и стабильны, не существует.
3. Если все регулярные выражения в приложении находятся под контролем разработчика – обязательно [тестируйте их](https://www.npmjs.com/package/safe-regex), чтобы убедиться в отсутствии риска падения.
Если возможность самостоятельно задавать регулярное выражение есть не только у разработчика, то стоит реализовать защиту от вечной проверки с помощью [создания таймаута](https://www.ocpsoft.org/regex/how-to-interrupt-a-long-running-infinite-java-regular-expression/) или использования сторонних решений, позволяющих решать задачу матчинга за линейное время – например, таких, как RE2/J. | https://habr.com/ru/post/544688/ | null | ru | null |
# Малоизвестные функции Python
В этой статье будут описаны малоизвестные, но полезные, функции Python. Многие функции из этого списка могут сильно уменьшить ваш код, оптимизировать его и сделать более читаемым.
Функция filter
--------------
Функция filter предназначена для "фильтрации" массива и может заменить цикл. Filter работает быстрее цикла, в некоторых случаях скорость работа программы увеличивается в десятки раз при использовании filter, вместо классических циклов.
Функция filter принимает на вход:
1. Другую функцию, которая возвращает True или False
2. Cписок, элементы которого будут подаваться на вход функции
В функции, передаваемой в filter, должно содержатся условие, которое определяет критерии для элементов нового массива. Если функция возвращает True - элемент добавляется в новый массив, если False - элемент не добавляется.
Функция filter возвращает объект класса Filter, используйте list(), чтобы переделать его в массив.
Filter поможет вам сделать код более оптимизированным и читаемым.
Например, вам дан массив a, надо все числа, которые меньше 10, записать в массив b и вывести его на экран.
Как это выглядит без использования filter:
```
a = [1, 10, 24, 6, 8, 19]
b = []
for i in range(len(a)):
if a[i] < 10:
b.append(a[i])
print(b)
```
Если использовать filter, то это выглядит так:
```
a = [1, 10, 24, 6, 8, 19]
b = list(filter(lambda x: x< 10, a))
print(b)
```
Код выглядит лаконичнее и работает быстрее.
Функция map
-----------
Функцией map, так же как и функцией filter, можно заменить циклы. Циклы работают медленнее чем map, но не каждый цикл можно заменить на map.
Функция map, принимает на вход:
1. Функцию, которой передают каждый элемент массива
2. Массив
Каждый элемент массива подается на вход функции. Конечный массив формируется из возвращаемых функцией значений.
Функция map позволяет сделать код красивее и ускорить его работу.
ля примера возьмем проблему, которая часто встречается у меня. Вам необходимо прочитать с клавиатуры 5 чисел, введённых через пробел и вывести их сумму на экран. Так как с клавиатуры читается строка, а не числа, необходимо их всех преобразовывать в числа.
Пример без использования map:
```
a = input().split(" ")
b = []
for i in range(5):
b.append(int(a[i]))
print(b[0]+b[1]+b[2]+b[3]+b[4])
```
Программа с использованием map:
```
a = list(map(int, input().split(" ")))
print(a[0]+a[1]+a[2]+a[3]+a[4])
```
Программа с использованием map имеет меньший размер и работает быстрее, но ее можно сделать еще более быстрой с помощью следующей функции.
Функция reduce
--------------
Функция reduce работает так же как map, но reduce возвращает лишь одно значение которое получается из последнего выполнения переданной функции. Перед использованием reduce, его необходимо импортировать из модуля functools.
Функция reduce получает на вход:
1. Функцию, которая получает более одно значения
2. Массив, элементы которого будут поданы на вход функции
Reduce предает на вход функции элемент массива и выход предыдущего выполнения, при первом выполнении в функцию передаются первые элементы массива.
Для примера возьмем проблему которую рассматривали в прошлый раз.
Пример без reduce:
```
a = list(map(int, input().split(" ")))
print(a[0]+a[1]+a[2]+a[3]+a[4])
```
Пример с использованием reduce:
```
from functools import reduce
def summa(a, b):
return a+b
print(reduce(summa, list(map(int, input().split(" ")))))
```
В данном случае программа стала больше и не сильно быстрее, это показывает, что необходимо анализировать насколько уместно использование таких функций. В других случаях программа будет оптимизирована и уменьшена.
Множества
---------
Множества это тип данных который работает быстрее остальных, но не может иметь повторяющихся элементов. Для создания множества используется функция set(), которой передается строка, массив, и так далее. Множества имеют методы и новые операторы:
1. add() - добавление элемента в множество
2. discard() - удаление элемента из множества
3. union() - объединяет множество, из которого вызывается функция, с тем которое передается как аргумент
4. intersection() - находит пересечение множеств, из которого вызывается, с тем которое передается как аргумент
5. difference() - находит все элементы которые есть в множестве, из которого вызывают функцию, но которых нет в множестве переданном как аргумент
6. symmetric\_difference() - выдает множество, которое содержит все элементы из двух множеств, за исключением их общих элементов
7. isdisjoint() - выдает True если оба множества не имею общих элементов, и False если имеют
8. | - то же самое, что union
9. & - то же самое, что intersection
10. -(минус) - то же самое, что difference
11. ^ - то же самое, что symmetric\_difference
Множества имеют обширные сферы применения, даже для исключения одинаковых элементов из массива. Множества могут помочь вам сделать свой код быстрее и добавить новые возможности.
Функции any и all
-----------------
Функции any и all используются вместо операторов OR и AND. Они позволяют сократить ваш код и сделать его более читаемым, в тех случаях когда вы используете большое количество условий в своей программе.
Они оба принимают массив из условий или булевых значений как аргумент, и возвращают одно булево значение.
Any - заменяет собой оператор OR, если в аргументах есть хотя бы одно True, на выходе будет True.
All - заменяет собой оператор AND, если в аргументах будет хотя бы один False, ответ будет False.
Для примера возьмем программу, которая должна вывести "1", если есть одинаковые переменные, и "-1", если таковых нет. Потом она должна проверить равна ли первая переменная второй и вторая третей, если это так вывести "2".
Пример без any и all:
```
a = input()
b = input()
c = input()
d = input()
if (a == b) OR (a == c) OR (a == d) OR (b == c) OR (b == d) OR (c == d):
print("1")
else:
print("-1")
if (a==b) AND (c == d):
print("2")
```
Пример с использованием any и all:
```
a = input()
b = input()
c = input()
d = input()
if any([(a == b), (a == c), (a == d), (b == c), (b == d), (c == d)]):
print("1")
else:
print("-1")
if all([(a==b), (c == d)]):
print("2")
```
Код стал приятнее глазу и немного уменьшился, эти функции уместно использовать, если вы используете большое количество условий для одного оператор if или while.
На этом все, я надеюсь вы узнали что-то новое. Если я что-то пропустил, то пишите в комментариях, если там будет много малоизвестных фишек Python, то я выпущу вторую часть. | https://habr.com/ru/post/595081/ | null | ru | null |
# Kotlin Best Practices
Kotlin, созданный всего 5 лет назад, с 2019 года считается приоритетным языком программирования под Android. И все же этот язык достаточно молод и продолжает развиваться, поэтому иногда бывает непонятно, каким образом лучше написать код. У нас в команде часто бывают обсуждения на тему чистого Kotlin-кода, и на их основе мы составили свои best practices. Хотим поделиться этими рекомендациями и ждем ваших вопросов.
Ну что ж, приступим! В первую очередь, в Котлине много синтаксического сахара, и если им злоупотреблять, то читать такой код становится затруднительно. Следующие несколько пунктов можно отнести к борьбе между **краткостью и читаемостью**.
### Не пишите объявление класса в одну строчку
Даже если сегодня объявление вашего класса уместилось в одну строчку и не выходит за поля – завтра может добавиться еще один аргумент в конструктор или еще один интерфейс в список наследуемых типов. В таком случае этот самый список может уехать вправо и пропасть из поля видимости.
```
class ChannelViewModel(
val conversationId: String,
getChannelUseCase: GetChannelUseCase,
) : ViewModel() {
```
Размещая каждый параметр конструктора на отдельной строке, мы также получаем бонусы:
* Если при рефакторинге надо поменять местами параметры, сделать это будет быстрее (в Android Studio сдвигаем строчку кода вверх/вниз с помощью сочетания клавиш Shift+Command+Up/Down)
* В гите изменения параметров будут отображаться более наглядно.
### Вложенный return
Рассмотрим такой пример:
```
data class MyClass(val number: Int, val flag: Boolean)
fun create(numberParam: Int?, flag: Boolean?): MyClass? {
return MyClass(numberParam ?: return null, flag == true)
}
```
Обычно если мы доходим до выражения с return, то это такая точка, в которой завершается выполнение функции. В этом же примере в случае, когда numberParam равен null, мы мысленно проходим сперва через return MyClass(...) и затем через return null. Лучше в данном случае использовать простой if, чтобы поток выполнения программы выглядел понятнее:
```
fun create(numberParam: Int?, flag: Boolean?): MyClass? {
if (numberParam == null) {
return null
}
return MyClass(numberParam, flag == true)
}
```
### Анонимный параметр it
Как [давно замечали на Хабре](https://habr.com/ru/post/308312/), цепочка из вложенных методов с анонимным параметром it читается тяжело, однако такие злоупотребления по-прежнему регулярно встречаются в коде:
```
values?.filterNot { selectedValues?.contains(it) == true }
?.let {
selectedValues?.addAll(it)
result[key]?.values = selectedValues?.filter { it.isChecked }
}
```
Именованный параметр следует добавить как минимум в функцию let:
```
values?.filterNot { allSelectedValues?.contains(it) == true }
?.let { newValues ->
allSelectedValues?.addAll(newValues)
result[key]?.values = allSelectedValues?.filter { it.isChecked }
}
```
В этом коде it – не единственная проблема. В данном примере обнуляемые типы можно заменить на не-null, в результате код станет опрятнее. Сравните:
```
val newValues = values.filterNot { selectedValues.contains(it) }
selectedValues.addAll(newValues)
result[key]?.values = selectedValues.filter { it.isChecked }
```
### Сокращайте цепочки безопасных вызовов ?. заменой обнуляемых типов на не-null типы
Продолжим затронутую в предыдущем пункте тему с обнуляемыми типами и рассмотрим такой пример:
```
private var animatedView: FrameLayout? = null
...
animatedView?.animate()?.alpha(1f)?.setDuration(500)?.interpolator = AccelerateInterpolator()
```
Здесь фактически значение null могло бы появиться только в том случае, когда animatedView равен null. Добавление простой проверки if (animatedView != null) избавит нас от цепочки безопасных вызовов. Но в данном примере вообще нет необходимости в том, чтобы animatedView принимало значение null. Поэтому лучше его сделать lateinit переменной, и тогда код вообще не будет содержать проверок на null:
```
private lateinit var animatedView: FrameLayout
...
animatedView.animate().alpha(1f).setDuration(500).interpolator = AccelerateInterpolator()
```
> Некоторые проблемы появляются при автоматическом переводе файлов **с Java на Kotlin**, особенно если разработчик поторопился и оставил код “как есть”. Обычно такой код пестрит восклицательными и вопросительными знаками и требует пересмотра. При переходе с Java какие-то if можно заменить на when, можно использовать функции области видимости (let, apply, also, with, run), функции для работы с коллекциями, переписать классы Utils на extension функции.
>
>
### Избавляемся от !!
Использование оператора !! считается дурным тоном, так как оно означает игнорирование потенциального NullPointerException, да и сам код с обилием знаков !! выглядит “костыльно”.
От !! можно избавиться следующими способами:
* заменой обнуляемых типов на не-null типы (как было сделано в примере с lateinit animatedView)
* функцией let с безопасным вызовом ?.let { … }
* элвис-оператором ?:
* и наконец, если мы действительно допускаем, что в приложении должно произойти исключение, когда переменная приняла значение null, то можно воспользоваться функцией checkNotNull или requireNotNull. Они отличаются только типом выбрасываемого исключения: IllegalStateException и IllegalArgumentException соответственно.
Для того, чтобы предупредить появление !! при переводе кода с Java на Kotlin, можно добавить аннотации @NonNull в Java-код.
### Отдаем предпочтение when перед if
Сравните:
```
val price = if (priceData.isWeightPrice) {
priceData.minDiscountPrice.toInt()
} else if (priceData.discountPrice != 0.0) {
priceData.discountPrice.toInt()
} else {
priceData.price.toInt()
}
```
и вариант с when:
```
val price = when {
priceData.isWeightPrice -> priceData.minDiscountPrice.toInt()
priceData.discountPrice != 0.0 -> priceData.discountPrice.toInt()
else -> priceData.price.toInt()
}
```
С when мы можем не писать лишние круглые и фигурные скобки, но код все равно выглядит структурированным, так как условия отделены от результатов стрелками.
Преимущества when заметны в том случае, когда проверяется более двух условий. Конечно, нет смысла использовать when для проверки значений булевского флага.
### Заменяем классы Util на функции расширения
Если статические вспомогательные функции можно отнести к какому-то определенному классу, лучше оформить их в виде функций extension. Тогда код будет выглядеть более идиоматичным.
Еще один плюс функций расширения в том, что автокомплит сам их предлагает. Не надо держать в голове, реализована ли уже на проекте та или иная вспомогательная функция, и в каком файле она лежит.
Это не значит, что от объектов Util в Kotlin надо полностью избавляться (обратите внимание: статические методы в Java содержатся в классах, а в Kotlin – в объектах). Если вспомогательная функция не относится к какому-то конкретному типу, не стоит оформлять ее в виде статической функции верхнего (package) уровня. Иначе такие функции будут постоянно появляться в автокомплите (extension функцию автокомплит предложит после того, как мы напечатаем название переменной определенного типа и точку, и это нормально; а функция верхнего уровня появится сразу после того, как мы начнем что-то печатать). Кроме того, код будет лучше организован и структурирован, если вспомогательные функции помещать внутри объекта, а не просто внутри файла.
> Котлин периодически обновляется, и иногда разработчик может не уследить за отдельными новшествами (и это не говоря о случаях “прочитал и забыл”). Приведем несколько полезных возможностей языка, которые мы советуем использовать.
>
>
### Замыкающие запятые (trailing commas)
Замыкающие запятые появились в версии языка 1.4. Мы рекомендуем их использовать в сочетании с приведенной выше рекомендацией располагать параметры конструктора (и вообще метода) на отдельных строках по той же причине: с замыкающей запятой аккуратнее выглядит diff в гите при добавлении параметра в конец.
### Single Abstract Method interface (Fun interface)
Тоже появились в Kotlin 1.4.0. Сравните, как выглядит создание анонимного объекта для обычного и fun интерфейса:
```
this.actionClickListener = object : BubbleView.ClickListener {
override fun onBubbleViewClick() {
...
}
}
```
и
```
this.actionClickListener = BubbleView.ClickListener {
...
}
```
Во втором случае к объявлению интерфейса добавилось только fun:
```
fun interface ClickListener {
fun onBubbleViewClick()
}
```
Таким образом, вместо одного интерфейса в Java, в Kotlin можно использовать обычный интерфейс, SAM-интерфейс или лямбду. Предлагаем в этом выборе руководствоваться следующим правилом:
* для простых колбеков и мапперов используем функциональный тип (T) -> R;
* если для наглядности мы хотим иметь название для типа или для вызываемого метода, то SAM-интерфейс;
* если должно быть несколько методов, то обычный интерфейс.
### Функции для работы с коллекциями
Kotlin содержит огромное множество функций для сортировки, фильтрации, поиска, преобразования коллекций. Каждый раз, когда в коде встречается цикл для обхода коллекции, велика вероятность, что его можно переписать с использованием уже существующей функции. Поэтому если вы регулярно пишете циклы, рекомендуем вам изучить/освежить в памяти [документацию](https://kotlinlang.org/docs/collections-overview.html).
Как можно улучшить представленный код?
```
val itemIdsSet: Set = ...
val currentItemIds: Set = ...
for(itemId in itemIdsSet) {
if(!currentItemIds.contains(itemId)) {
repository.exclude(itemId)
}
}
```
Как вариант:
```
val itemIdsSet: Set = ...
val currentItemIds: Set = ...
for (itemId in itemIdsSet subtract currentItemIds) {
repository.exclude(itemId)
}
```
Или если отредактировать API репозитория так, чтобы функция exclude могла принимать коллекции, тогда мы сможем написать:
```
repository.exclude(itemIdsSet subtract currentItemIds)
```
### Согласуйте code style
Иногда стиль написания кода у разработчиков в команде может настолько различаться, что проект рискует превратиться в “кашу”. Поэтому лучше согласовывать такие моменты:
* принципы наименования переменных (например, запрет на использование префикса \_ для теневых полей или написание констант enum только заглавными буквами)
* порядок следования функций внутри классов
* положение companion object внутри класса (в начале или в конце) и т.п.
Заключение
----------
В этой статье мы поделились несколькими правилами, которые показали свою эффективность в нашей команде. Однако, мы не претендуем на их истинность и рекомендуем вам обсуждать и формировать свои наборы best practices.
Как пример, больше идей по улучшению Kotlin-кода можно почерпнуть здесь:
<https://developer.android.com/kotlin/style-guide> <https://proandroiddev.com/an-opinionated-guide-on-how-to-make-your-kotlin-code-fun-to-read-and-joy-to-work-with-caa3a4036f9e>
<https://developer.android.com/kotlin/coroutines/coroutines-best-practices> | https://habr.com/ru/post/546452/ | null | ru | null |
# Книга «Java для всех»
[](https://habr.com/ru/company/piter/blog/472076/) Привет, Хаброжители! Данная книга предназначена для начинающих.
Вот уже многие годы язык Java входит в число самых популярных и востребованных. Он красивый, эффектный и, самое главное, очень производительный. Но, к сожалению, не самый простой. Именно поэтому спрос на Java-программистов неизменно высок. Язык Java — это бриллиант, который украсит багаж знаний любого программиста. А учить Java, как, я надеюсь, предстоит убедиться читателям этой книги, не только полезно, но и интересно. В основу книги положены курсы лекций, в разное время прочитанные мной для магистров физического факультета Киевского национального университета им. Тараса Шевченко, бакалавров медико-инженерного факультета Национального технического университета Украины «Киевский политехнический институт» и слушателей различных курсов по программированию. Материал книги и способ изложения адаптированы для всех, кто желает изучать Java не только в учебных заведениях, но и самостоятельно. Поэтому книга может использоваться и как самоучитель.
Массивы
-------
Под массивом подразумевают набор однотипных значений (переменных), к которым можно обращаться по общему имени. Именно массивам посвящена эта глава.
Переменные, относящиеся к одному массиву, называются элементами этого массива. Чтобы однозначно идентифицировать элемент массива, необходимо знать имя массива и позицию (размещение) элемента в массиве. Позиция элементов в массиве определяется с помощью целочисленных индексов. Количество индексов, необходимых для идентификации элемента массива, называется размерностью массива. Одномерный массив — это такой массив, в котором идентификация элементов осуществляется с помощью одного индекса.
Одномерные массивы
------------------
Одномерный массив удобно себе представлять в виде упорядоченной цепочки или последовательности переменных (одного типа). Для объявления одномерного массива необходимо задать тип, к которому относятся элементы массива, название массива, а также количество элементов, входящих в массив. Синтаксис объявления одномерного массива такой:
```
тип[] имя=new тип[размер];
```
Вначале указывается тип элементов массива, а после идентификатора типа следуют пустые квадратные скобки. Далее указывается имя массива, оператор присваивания, инструкция (оператор) new, снова тип элементов массива и в квадратных скобках размер массива (количество элементов в массиве). Например, командой int nums=new int[20] объявляется целочисленный массив nums из 20 элементов.
Строго говоря, представленная здесь команда объявления массива является симбиозом двух команд: команды int[] nums объявления переменной nums типа «целочисленный массив» (переменная массива) и инструкции new int[20], которой, собственно, и создается массив. Данная инструкция присваивается значением переменной nums, и в результате ссылки на массив записывается в переменную nums. Другими словами, процесс создания массива можно выполнить двумя командами:
```
int[] nums;
nums=new int[20];
```
Причем эти команды могут быть разнесены в программном коде — то есть мы можем объявить переменную массива и лишь затем, в другом месте кода, создать массив (и записать ссылку на этот массив в переменную массива).
> ПОДРОБНОСТИ Ранее мы в основном имели дело с базовыми, или примитивными, типами (такими, как int, char или double). Переменная базового типа хранит значение. Технически это выглядит так: под переменную выделяется место в памяти, и значение переменной записывается именно в это место. Но есть другой способ работы с данными, при котором переменная ссылается на данные. Так происходит с объектами, и так реализуются массивы. Есть собственно массив, но доступ к нему мы получаем не напрямую, а с помощью посредника, которым является переменная массива. Значением переменной массива является не массив, а адрес массива. Поэтому создание переменной массива не означает создания массива. Массив создается отдельно. Мы будем описывать данную ситуацию как такую, при которой переменная массива ссылается на массив. Каждый раз, когда нам нужно будет получить доступ к массиву, мы будем обращаться к переменной массива, которая ссылается на данный массив.
>
> Хотя на первый взгляд такая схема может показаться излишней, тем не менее она имеет свои преимущества. И мы в этом убедимся.
В случаях, когда не возникает недоразумений, мы будем переменную массива отождествлять с массивом.
При объявлении переменной массива допускается указывать квадратные скобки либо после идентификатора типа, либо после имени массива. Например, вместо команды int[] nums можно использовать команду int nums[].
Обращение к элементу одномерного массива осуществляется через имя массива с указанием в квадратных скобках индекса элемента. Индексация элементов массива начинается с нуля. Таким образом, ссылка на первый элемент массива nums будет иметь вид nums[0]. Если в массиве 20 элементов, то последний элемент массива имеет индекс 19, то есть инструкция обращения к элементу выглядит как nums[19].
Длину массива можно узнать с помощью свойства length: указывается имя массива и, через точку, свойство length. Например, чтобы узнать длину массива nums, можно воспользоваться инструкцией nums.length. Тогда ссылка на последний элемент массива может быть записана как nums[nums.length-1].
> НА ЗАМЕТКУ В Java используется автоматическая проверка на предмет выхода за пределы массива. Поэтому если в коде выполняется обращение к несуществующему элементу массива, то возникает ошибка.
При объявлении массива для него выделяется память. В Java элементы массива автоматически инициализируются с нулевыми значениями — выделенные ячейки обнуляются, а значения этих обнуленных ячеек интерпретируются в зависимости от типа массива. Но на такую автоматическую инициализацию полагаться не стоит. Разумно инициализировать элементы массива в явном виде. Для этого используют оператор цикла или задают список значений элементов при объявлении массива.
Для инициализации массива списком значений при объявлении переменной массива после нее указывается (через оператор присваивания) заключенный в фигурные скобки список значений. Например:
```
int[] data={3,8,1,7};
```
Здесь объявляется переменная data для целочисленного массива, создается массив, и ссылка на него записывается в эту переменную. Размер массива и значения элементов определяются автоматически в соответствии с количеством элементов в списке значений. В данном случае создается целочисленный массив из четырех элементов со значениями элементов 3, 8, 1 и 7. Того же результата можно добиться, воспользовавшись, например, следующими командами:
```
int[] data;
data=new int[]{3,8,1,7};
```
Первой командой int[] data объявляется переменная массива. Инструкцией new int[]{3,8,1,7} создается массив из четырех целых чисел, а ссылка на этот массив присваивается переменной data (имеется в виду команда data=new int[]{3,8,1,7}).
Пример объявления, инициализации и использования массивов приведен в листинге 3.1.
#### Листинг 3.1. Знакомство с одномерными массивами
```
class Demo{
public static void main(String[] args){
// Целочисленные переменные:
int i,n;
// Объявление переменной массива:
int[] data;
// Первый массив:
data=new int[]{3,8,1,7};
// Размер массива:
n=data.length;
// Второй массив:
int[] nums=new int[n];
// Заполнение второго массива:
for(i=0;inums[0]=3
nums[1]=13
nums[2]=-1
nums[3]=11
```
Еще раз отметим, что индексация элементов массива начинается с нуля. Поэтому в операторе цикла индексная переменная i инициализируется с начальным нулевым значением, а в проверяемом условии i
Немаловажно и то обстоятельство, что при создании массива nums его размер определяется с помощью переменной n, значение которой вычисляется в процессе выполнения программы.
Двумерные и многомерные массивы
-------------------------------
Размерность массива может быть больше единицы. Но на практике массивы размерности выше второй используют редко. Далее рассмотрим способы объявления, инициализации и использования двумерных массивов, в которых доступ к элементу массива осуществляется с помощью двух индексов. Если представлять двумерный массив как таблицу, то первый индекс элемента определяет строку, в которой находится элемент, а второй индекс определяет столбец, в котором находится элемент.
> ПОДРОБНОСТИ Хотя двумерный массив и удобно представлять как таблицу, реализуется он совершенно иначе. На самом деле двумерный массив в Java — это одномерный массив, элементами которого являются переменные массива. Каждая такая переменная ссылается на одномерный массив. При использовании этой конструкции возникает иллюзия, что мы имеем дело с таблицей.
Создаются двумерные массивы так же просто, как и одномерные. Но при объявлении переменной для двумерного массива после идентификатора типа указываются две пары пустых квадратных скобок, а в инструкции создания двумерного массива — в отдельных квадратных скобках — указывается размер по каждому из индексов (количество строк и столбцов в массиве). Синтаксис объявления двумерного массива выглядит так:
```
тип[][] имя=new тип[размер][размер];
```
Как и в случае одномерного массива, данная команда может быть разбита на две:
```
тип[][] имя;
имя=new тип[размер][размер];
```
Первой командой объявляется переменная для двумерного массива. Второй командой создается собственно двумерный массив с указанными размерами, и ссылка на этот массив присваивается в качестве значения переменной массива. Например, командой double[][] data=new double[3][4] создается двумерный массив с элементами типа double. В массиве 3 строки и 4 столбца, а ссылка на массив записывается в переменную data. К тому же результату приведет выполнение следующих команд:
```
double[][] data;
data=new double[3][4];
```
Обращение к элементам двумерного массива выполняется в следующем формате: указывается имя массива, в квадратных скобках — первый индекс элемента, в других квадратных скобках — второй индекс элемента массива. Индексация по всем размерностям начинается с нуля. Например, ссылка data[0][3] является обращением к элементу массива data с индексами 0 и 3, и это элемент в первой строке и в четвертом столбце.
Для инициализации двумерного массива используют вложенные операторы цикла или список, состоящий из списков значений. Каждый такой внутренний список определяет значения элементов массива в строке. Ниже приведены примеры инициализации двумерного массива с помощью списка:
```
double[][] data={{0.1,0.2,0.3},{0.4,0.5,0.6}};
int nums[][]={{1,2,3},{4,5}};
```
Первой командой создается и инициализируется двумерный массив data размером 2 на 3 (две строки и три столбца). Количество строк определяется количеством элементов во внешнем списке. Таких элементов два — это списки {0.1,0.2,0.3} и {0.4,0.5,0.6}. В каждом из этих списков по три элемента. Отсюда и получается массив размерами 2 на 3. Список {0.1,0.2,0.3} определяет значения элементов в первой строке, список {0.4,0.5,0.6} определяет значения элементов во второй строке. Например, элемент data[0][0] получает значение 0.1, элемент data[0][2] — значение 0.3, элемент data[1][0] — значение 0.4, а элемент data[1][2] — значение 0.6.
Второй командой создается целочисленный массив nums, который состоит из двух строк (поскольку внутри присваиваемого списка два элемента — списки {1,2,3} и {4,5}). Однако в первой строке созданного массива содержится три элемента (поскольку в списке {1,2,3} три значения), а во второй строке массива — два элемента (поскольку в списке {4,5} два значения). В созданном массиве элемент nums[0][0] имеет значение 1, элемент nums[0][1] — значение 2, элемент nums[0][2] — значение 3, элемент nums[1][0] — значение 4, а элемент nums[1][1] — значение 5.
> ПОДРОБНОСТИ Проблемы в том, что массив nums в разных строках содержит разное количество элементов, нет. Технически все реализуется более чем просто. Переменная двумерного массива nums ссылается на самом деле на одномерный массив из двух элементов (количество строк в двумерном массиве). Но элементы этого массива не целые числа, а переменные, которые могут ссылаться на одномерные целочисленные массивы (условно говоря, элементы относятся к типу int[]). Первая переменная ссылается на одномерный массив из трех элементов (1, 2 и 3), а вторая переменная ссылается на одномерный массив из двух элементов (4 и 5). Когда мы индексируем (одним индексом!) переменную nums, то получаем доступ к элементу одномерного массива, на который ссылается эта переменная. Например, nums[0] — первый элемент, а nums[1] — второй элемент упомянутого массива из переменных массива. И данные элементы являются ссылками на массивы. Их можно индексировать. Поэтому, скажем, nums[0][1] — это второй элемент в массиве, на который ссылается первый элемент nums[0] в массиве, на который ссылается переменная nums. Так все происходит на самом деле. А интерпретируем мы инструкцию nums[0][1] как обращение к элементу в первой строке и во втором столбце двумерного массива.
В листинге 3.2 приведен пример программы, в которой создается двумерный массив, заполняемый с помощью вложенных операторов цикла.
#### Листинг 3.2. Создание двумерного массива
```
class Demo{
public static void main(String[] args){
int i,j,n=3,val=1;
// Создание двумерного массива:
int[][] nums=new int[n-1][n];
// Вложенные операторы цикла:
for(i=0;i
```
Командой int[][] nums=new int[n-1][n] создается целочисленный массив nums, в котором n-1 строк и n столбцов. Переменной n предварительно присвоено значение 3. Заполняется массив с помощью вложенных операторов цикла. Значение элементу массива (при заданных индексах i и j) присваивается командой nums[i][j]=val++. Здесь элементу nums[i][j] присваивается текущее значение переменной val, а сразу после этого значение переменной val увеличивается на единицу.
> НА ЗАМЕТКУ В результате выполнения инструкции val++ значение переменной val увеличивается на единицу. Но поскольку использована постфиксная форма оператора инкремента, то значением выражения val++ является старое (до увеличения на единицу) значение переменной val.
После вычисления значения элемента оно отображается в области вывода. В результате выполнения программы получаем:
Результат выполнения программы (из листинга 3.2)
```
1 2 3
4 5 6
```
В листинге 3.3 приведен код программы, в которой создается двумерный массив со строками разной длины.
#### Листинг 3.3. Массив со строками разной длины
```
class Demo{
public static void main(String[] args){
int i,j,val=1;
// Создание массива (второй размер не указан):
int[][] nums=new int[4][];
// Цикл для создания треугольного массива:
for(i=0;i
```
Командой int[][] nums=new int[4][] создается двумерный целочисленный массив nums. Этот массив состоит из четырех строк. Однако размер строк не указан — вторая пара квадратных скобок в конце команды пуста. Точнее, строк еще нет. Их нужно создать. Строки создаются в операторе цикла. В этом операторе цикла индексная переменная i пробегает значения от 0 до nums.length-1 включительно. Командой nums[i]=new int[i+1] создается строка двумерного массива с индексом i. Такая строка содержит i+1 элемент.
> ПОДРОБНОСТИ Технически все происходит так: инструкцией new int[i+1] создается одномерный массив (строка для двумерного массива) и ссылка на этот массив записывается в переменную nums[i]. При этом nums[i] можно интерпретировать как ссылку на строку с индексом i. Смысл инструкции nums.length станет понятен, если вспомнить, что на самом деле двумерный массив представляет собой одномерный массив, элементы которого ссылаются на одномерные массивы. В таком случае nums.length дает значение для количества элементов в массиве, на который ссылается переменная nums, — то есть это количество строк в двумерном массиве.
В результате мы получаем двумерный массив треугольного вида: в первой строке массива один элемент, во второй — два элемента, и так далее, вплоть до четвертой строки массива.
Заполняется созданный массив с помощью вложенных операторов цикла. Индексная переменная i во внешнем операторе цикла принимает значения от 0 до nums.length-1 и определяет строку в двумерном массиве nums. Для индексной переменной j верхняя граница диапазона изменения определяется инструкцией nums[i].length, которая возвращает количество элементов в строке с индексом i (переменная j изменяется от значения 0 до значения nums[i].length-1 включительно).
> ПОДРОБНОСТИСледует принять во внимание, что nums[i], по сути, является переменной, которая ссылается на одномерный массив, формирующий строку с индексом i. Количество элементов в этом массиве (строке) определяется выражением nums[i].length.
Значение элементам массива присваивается командой nums[i][j]=val++. Ниже показано, как выглядит результат выполнения программы:
Результат выполнения программы (из листинга 3.3)
```
1
2 3
4 5 6
7 8 9 10
```
Как и ожидалось, мы получили массив, у которого в разных строках содержится разное количество элементов.
> НА ЗАМЕТКУ Массивы, размерность которых больше двух, создаются аналогично. При объявлении переменной для многомерного массива после идентификатора типа указываются пары пустых скобок. Количество таких пар определяется размерностью массива. В команде создания массива в отдельных квадратных скобках указывается размер по каждому из индексов.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product_by_id/149017716)
» [Оглавление](https://storage.piter.com/upload/contents/978544611382/978544611382_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611382/978544611382_p.pdf)
Для Хаброжителей скидка 25% по купону — **Java**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/472076/ | null | ru | null |
# Генерируем заголовки фейковых новостей в стиле Ленты.ру
*Сравниваем 2 подхода к генерации текста c помощью нейронных сетей: Char-RNN vs Word Embeddings + забавные примеры в конце.*
Когда становится совсем нечего читать, открывать книгу не хочется, все статьи на Хабре прочитаны, все нотификации на телефоне обработаны, и даже просмотрен спам в ящиках, я открываю Ленту.ру. У моей жены — профессионального журналиста — в такие моменты начинается аллергия, и понятно, почему. После того, как в 2014 году из Ленты ушла старая команда, уровень желтизны издания пошел вверх, а качество текста и редактуры — вниз. Со временем, периодически по инерции продолжая читать Ленту, я стал замечать, что модели заголовков новостей повторяются: «Обнаружено [вставить псевдо-сенсацию]», «Путин [что-то сделал]», «Безработный москвич [[описание его приключений](https://meduza.io/shapito/2015/12/12/samyy-bogatyy-zlodey-strany-udivitelnye-priklyucheniya-bezrabotnogo-moskvicha)]» и так далее. Это была первая вводная.
Вторая вводная — недавно случайно нашел забавный отечественный аналог [@DeepDrumph](https://twitter.com/deepdrumpf) (это твиттер, в котором выкладываются фразы, сгенерированные нейросетью на основе официального твиттера Трампа) — [@neuromzan](https://twitter.com/neuromzan). К сожалению, автор прекратил выкладывать новые твиты и затаился, но описание идеи сохранилось [здесь](https://meduza.io/shapito/2016/08/05/neyroramzan-robot-kotoryy-uchilsya-pisat-na-instagrame-ramzana-kadyrova).
И пришла идея, почему бы не сделать такую же штуку, но на основе заголовков Ленты.ру? Может получиться не менее забавно, учитывая уровень абсурдности некоторых настоящих заголовков на этом ресурсе.
***Замечание**: здесь рассматривается именно задача генерации последующего текста на основе некоторого вводного. Это не задача Text Summarization, когда, например, на основе текста новости генерируется ее заголовок. Текст новости в моем случае вообще никак не используется.*
Данные
------
Перспектива скачивать и парсить весь контент Ленты меня совсем не радовала, и я стал искать, не делал ли кто уже это до меня. И мне повезло: как раз за несколько дней до того, как у меня появилась эта идея, Ильдар Габдрахманов [ildarchegg](https://habrahabr.ru/users/ildarchegg/) выложил [пост](https://habrahabr.ru/post/343838/), где он описывает, как граббил контент Ленты, и делится полным архивом. В конце он добавляет «Надеюсь, что кто-то посчитает эти данные интересными и сможет найти им применение.» Конечно! У меня уже есть применение! Спасибо тебе, Ильдар! Твои усилия сэкономили мне несколько дней!
Итак, берем этот архив и выдергиваем оттуда статьи за нужный нам период: с 01.04.2014 (когда ушла старая команда) по настоящее время. Подробно на предварительной обработке данных я останавливаться не буду. Кому интересно, в [репозитории на Гитхабе](https://github.com/voice32/lenta_ai) есть отдельный ноутбук с пошаговым описанием процесса.
Первая попытка обучения — Char-RNN
----------------------------------
Судя по указанной выше статье, автор neuromzan’а использовал архитектуру Char-RNN, описанную Андреем Карпаты (Andrej Karpathy) в его уже ставшей легендарной статье "[The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)". Давайте попробуем решить нашу задачу с помощью этого подхода. Реализацию Char-RNN под разные языки и фреймворки можно легко найти в интернете. Я взял [вот эту](https://github.com/keras-team/keras/blob/master/examples/lstm_text_generation.py) — на Keras она получается довольно компактной. Немного модифицировав ее под свои нужды (изменил гиперпараметры и добавил сохранение результатов и более информативный вывод), я запустил обучение.
И результаты меня не порадовали. Идея Char-RNN в том, что сеть учится предсказывать следующий символ на основе N предыдущих. То есть сети в качестве входных данных подается некоторый исходный текст, а дальнейший текст генерируется посимвольно. Поэтому, чтобы научиться писать относительно читабельные тексты, сеть должна:
1. Научиться отделять последовательности символов (псевдо-слова) пробелами и иногда ставить точку;
2. Научиться генерировать последовательности символов, похожие на настоящие слова;
3. Научиться генерировать похожие на настоящие слова с учетом предыдущих почти настоящих слов.
Вот что получилось с двухслойной сетью с 64 LSTM-ячейками, обученной на ограниченном наборе заголовков (<800). В квадратных скобках — вводный текст для сети, генерируем следующие 150 символов:
```
1 эпоха: "[грязи в стокгольме . названа причина массового сам]ииоеал стаа и ата еааир онсст рррв аитислт и ио о и скд ииау р п .аа итео ли таи уеаа сао аоеи сооааои лртаип оооа лаае о соа ра тлс от";
2 эпоха: "[о прокомментировал слухи об отстранении россии от ]п ма и во роги . по га мо по по к кал ы та поникита ги . о си кай вав пе петбого . па рака с меры пали ва са па . вока са и . ва 2а с ра по в слило и";
3 эпоха: "[лнении плана по ремонту дорог . в якутии девушка и] подра праттонго пробилерей в постедела . сралива . порграны . престрасий придали пелелия . редодной . сотурика . прусбиря . в россирей . в подирачили";
4 эпоха: "[ую шкуру . кэаз: продукция , которая эффективно за] ворое за полита . дона семе ацерика в советили полино . кий рассии в кодат нашрет с на ды пой подо пояли рассийский за в подовали ресскию уна помода ";
5 эпоха: "[экс - чемпиона мира . маккейн раскритиковал трампа]ни . покодила . придовов разнал российский из ради . воростия . в начил подровать . подовых борту . в примозного об ан дто . ав россия боль . маниц . ";
...
25 эпоха: "[а произошло землетрясение магнитудой 7,2. британка]м приходах полицию пообещала за поставшую собчак за глупеледователеся в москве. подмосковные самое ископью мир-стали. колян признался кратите шезвым м";
...
50 эпоха: "[итета олимпиады - 2018 прокомментировал возможное ]полицейские с горовулеской заглаку у наслучать бесажно с кубанского банки в сообщили о вклачуют признили встревахся в петербурге оказались новый сборн"
```
Дальше обучать не стал. Получается какой-то бред. Да, это похоже на фразы, где есть слова, отделенные пробелами и заканчивающиеся точками. Некоторые “слова” даже являются настоящими словами из русского языка. Но читать это невозможно, и это совсем не похоже на те красивые и смешные реплики, которые были во вдохновивших меня примерах. Изменение гиперпараметров практически никак не сказалось на качестве. Обучение на полном датасете также не сильно улучшило результаты. Возможно, эти товарищи обучали сеть гораздо дольше, добавляли больше слоев и делали их шире, но я решил попробовать другой подход.
Альтернативный метод — Word Embeddings
--------------------------------------
Я вспомнил, что чуть менее года назад на курсе [Udacity Deep Learning Foundation](https://www.udacity.com/course/deep-learning-nanodegree-foundation--nd101) у меня было задание — написать сеть, которая бы генерировала сценарий к Симпсонам (конкретнее, одну сцену в таверне у Мо), взяв для обучения оригинальные сценарии аналогичных сцен из 25 сезонов мультфильма. В этом случае использовался другой подход — Word Embeddings, когда текст генерируется не посимвольно, а по словам, но тоже на основе распределения вероятностей появления определенных слов при заданных [1..N] предыдущих словах.
Этот подход имеет ряд существенных преимуществ перед Char-RNN:
1. Сети не нужно учиться генерировать слова — они уже сами по себе являются атомарными элементами, соответственно, сгенерированные фразы изначально будут состоять только из слов из нашего корпуса, не будет ненастоящих слов;
2. Слова во фразах лучше согласуются друг с другом, потому что для набора слов {«в», «на», «поехал», «машине», «машину»} большей суммарной вероятностью будет обладать последовательность [«поехал», «на», «машине»], чем [«поехал», «в», «машину»].
3. Выше скорость обучения, т.к. для одного и того же корпуса для Char-RNN токенами будут являться символы, а для Word Embeddings — слова. Количество слов в тексте заведомо меньше, чем символов, а для машины что в первом, что во втором случае токен — просто индекс в словаре. Соответственно, за одну итерацию Word Embeddings нужно будет обработать гораздо меньше токенов, чем Char-RNN, и времени на это потребуется примерно пропорционально меньше.
Быстрая проверка гипотезы на ограниченном датасете (те же 2 слоя и 64 ячейки LSTM, генерируем 100 следующих токенов):
```
Эпоха 1: "[макгрегор]...................................................................................................."
...
Эпоха 4: "[макгрегор]... гигантский двойников.. попросили правительство правительство...... facebook........... попросили.......... попросили............... попросили.... попросили...... попросили. попросили......... пользователей. попросили........... боевой попросили попросили попросили..."
...
Эпоха 10: "[макгрегор]. алексей кадры янин пожиратель двойников техники. иркутск техники в в. в. в.. защитить собственный соглашения пользователей iphone8. в... полиция автоматического. гей-партнерстве. джона продажи через соцсеть. савченко. пост возможность в. продлить победа правительство продлить крыма.. от с. продление мира в. для ветераны правительство продлить о.. с facebook в иркутск для в в в продажи кредит. россии. выполнять соглашения по по петербурга. иркутск олимпиаде. покажут facebook в. android. в. мир. на. От"
...
Эпоха 20: "[макгрегор]. опубликованы кадры выброски боевой техники с воздуха в рязанской в рязанской в. россии собственный защитившего арнольд российской авиатехникой. защитившего техники в рио. моргана моргана. моргана мир в ральф лорен надел в в россии. индия российской 12. на арнольд мира в рио. рио.. назвал для. выполнять первый музей крыма. против проект. иркутск для в моргана против крыма. моргана. android от питтсбург авиатехникой. минэкономразвития крыма правительство крыма. гей-партнерстве против санкций. моргана. для в против крыма. россии. продлить мира на выполнять заходили"
```
Итак, что тут происходит. На первой эпохе сеть видит, что один из самых часто встречающихся токенов — точка. «А давай-ка я везде понаставлю точек, раз у нее такая высокая частота», — думает она, и получает гигантскую ошибку. Затем она еще пару итераций сомневается, и на 4-й решает, что между точками стоит вставлять какие-нибудь слова. «Ого! Ошибка стала меньше», — радуется сеть, — «Надо продолжить в этом духе, будем вставлять разные слова, но мне очень нравятся точки, поэтому пока я продолжу их ставить». И продолжает ставить точки, разбавляя их словами. Постепенно она понимает, что чаще стоит ставить слова, чем точки, причем некоторые слова должны идти недалеко друг от друга, например она запоминает некоторые отрывки из датасета: «правительство продлить», «выполнять соглашения», «пожиратель двойников» и т.п. К 20 эпохе она уже помнит довольно длинные фразы, типа «опубликованы кадры выброски боевой техники с воздуха». И это показывает, что в принципе подход работает, но на таком маленьком наборе данных сеть довольно быстро переобучается (даже несмотря на dropout), и вместо уникальных фраз выдает заученные.
Посмотрим, что будет, если обучить ее на полном наборе заголовков:
```
Эпоха 1: "[визажисты] в сша после ссоры с подругой.. девять национализированного украиной приватбанка попросился в отставку. генсек нато похвалил летчиков за перехваты над балтикой. дочка шоколадницы наблюдателей в мире в университете в таиланде после ссоры с подругой. сша заявили об отказе шотландская школьница подлила в подготовке госпереворота. стальная плоть. дк продуктов в париж. девять друзей тесака. в футляр для альта соперницы кислоту. в совфеде предложили дк зил. девять друзей тесака. в новая для ссоры с подругой. сша заявили об отказе объяснено отсутствие антивещества во вселенной. тесак получил 10 лет"
...
Эпоха 5: "[визажисты] в ньюкасле. несвобода вместо свободы. швеция пригласила на вокзалах при ниже 59 рублей. в германии ограничили возможность предвыборных выступлений иностранных политиков. литовский туроператор дать балашихе о часы в свою жизнь. подругу-гадалку слухи о попавшем в плен на воду forbes и путина. тесак получил 10 посетить человек. российских туристов в доминикане выросло в 300. захарова рассказала путина остановить земельный имиджа мире в дтп с такси. путин стали в почти 3 миллиона долларов на неподходящий камуфляж. в хабаровском опекуне-педофиле. власти кндр отказалась от формирования совместной с южной иванушек. резцова рассказала"
…
Эпоха 10: “[визажисты] погиб. велосипедист в буденновске на человека в погибли без перелета. стальная плоть. лесного продажи халифата ввести самые распространенные наркотики в российском tor. в подмосковье. найдена новая опасность солнцезащитных кремов. врачи отговорили горбачева от поездки на прощание с колем. минимальный набор продуктов в россии резко подорожал почти до 72 лет. вирус третьей компанией в турции. приедут архитекторы из россии. слуцкий назвал причину пообещали своем слова об обысках в москве череповца. в нато выразили обеспокоенность растущей военной возможность встречи трампа и съемки репортажа о кражах. забытого матерью в песочнице грудного”
```
Здесь хватило всего 10 эпох, чтобы loss перестал уменьшаться. Как видим, в этом случае сеть также заучила некоторые довольно длинные куски, но при этом, есть и много относительно оригинальных фраз. Часто можно видеть, как сеть создает длинные фразы из других длинных, например вот так: «тиньков назвал дурова быдлом и публично стер telegram» + «пьяный москвич угнал трактор и попал в дтп с такси» = «пьяный москвич угнал трактор и публично стер telegram».
Однако, все равно, в большинстве случаев фразы получаются не такими красивыми, как у DeepDrumph и neuromzan. Что же тут не так? Нужно обучать дольше, глубже и шире? И тут на меня снизошло озарение. Нет, эти ребята не нашли магическую архитектуру, выдающую красивые тексты. Они просто генерят длинные тексты, отбирают потенциально смешные куски и вручную их редактируют! Финальное слово за человеком — вот в чем секрет!
После некоторой ручной правки можно получить вполне приемлемые варианты:
* «в отреагировал. песков продажи возможность заммэра» >>> «песков отреагировал на возможность продажи должности заммэра»
* «вице-спикера сочли человек» >>> «вице-спикера сочли человеком»
* «депутат лебедев признал неуместным предложение предложение убийстве» >>> «депутат лебедев признал неуместным предложение об убийстве»
… и так далее.
Здесь есть еще один важный момент, связанный с русским языком. Генерировать фразы для русского языка гораздо сложнее, потому что слова и фразы в предложении нужно согласовывать. В английском, конечно, тоже, но в гораздо меньшей степени. Вот пример:
«машина» >>> «car»
«на машине» >>> «by car»
«вижу машину» >>> «see the car»
То есть в английском слово в разных падежах — один и тот же токен с точки зрения сети, а в русском — разные за счет отличающихся окончаний и других частей слова. Поэтому результаты работы модели на английском языке выглядят более правдоподобными, чем на русском. Можно, конечно, лемматизировать слова в русском корпусе, но тогда и сгенерированный текст будет состоять из таких слов, и здесь уж точно без ручного допиливания не обойтись. К слову, я попробовал сделать это, используя модуль [pymorphy2](https://pymorphy2.readthedocs.io/en/latest/), но результат, на мой личный взгляд, был местами даже хуже, несмотря на то, что количество уникальных токенов (слов) после нормализации сократилось более чем в 2 раза. После 20 эпох результат был такой:
```
“[звездный]. минфин отказать экономика россия по волейбол. для должник по волейбол. греция пообещать побывать в сжр побывать в побывать в отскок. греция пообещать побывать. в красноярск греция пообещать побывать в русало. для должник по волейбол. в отскок. песок. в россия. индия оснастить собственный авианосец российский авиатехника. песок песок. в россия. греция пообещать побывать в рио. ральф лорен надеть на facebook с мобильный.. в рязанский область. российский пшеница подорожать. в россия. в россия появиться один музей солженицын.. украинец попросить правительство вывесить”
```
Также можно заметить, что часто теряется первоначальное значение слова. Например, в приведенном выше отрывке фамилию “Песков” pymorphy нормализовал в слово “песок” — серьезная потеря для всего корпуса.
Выводы
------
* Word Embeddings гораздо лучше справляется с генерацией текста, чем Char-RNN;
* При прочих равных качество генерации английского текста в общем случае выше, чем русского, из-за особенностей языков;
* Когда вы слышите о том, что ИИ написал книгу (как это было на днях, когда объявили что [алгоритм написал книгу о Гарри Поттере](https://www.newsru.com/cinema/14dec2017/potter.html), делите это утверждение на 1000, потому что, скорее всего, алгоритм лишь мог 1) сгенерировать имена и описания персонажей, или 2) сгенерировать общую канву повествования, или 3) сгенерировать полуабсурдный текст, который потом долго и упорно правили и согласовывали люди-редакторы. Либо все это вместе взятое. Но уж точно ИИ не писал книгу от первого до последнего слова. Не на том уровне развития еще наши технологии.
Десерт
------
Ну и в конце некоторые перлы после ручных правок, как мне кажется, вполне в духе Ленты.ру:
* Минфин отказался от вечеринки в Рязанской области
* Australian отвергла возможность iPhone8 на Android
* Иркутск оставили без воздуха
* Полиция Петербурга против мира Петербурга
* В Китае начались продажи должников
* Минэкономразвития сообщило о гей-партнерстве против санкций
* Греция выступила с мишкой
* Путин помирился с музеем и с Солженицыным
* Голый турист погиб в Буденновске
* Врачи отговорили Горбачева от поездки на прощание с проблемами в области работорговли
* В Британии задумались полуфинальные пары Кубка Конфедераций
* Депутат Лебедев признал неуместным предложение оштрафовать такси
* В Совфеде предложили выбирать почетных Леопольдов
* Вице-спикер Думы обосновал предложение о подготовке госпереворота
* Литовские онкологи в Москве приступили к лечению
* ЦБ выделит деньги на починку каменного пениса тролля
* Снимавшимся в кино сложнее прилично шутить о новой подмосковной ведущей
* Нетрезвый задержанный спровоцировал Госдуму
* Израиль ответил кислотой в лицо
* Глава ФРС США пообещала отсутствие кремов
* Проблему бараков в Ижевске решили через постель
* На Ямале кречеты впервые вывели потомство от самолета Евровидения
* Подмосковье за год потратит больше Бразилии
* У берегов Ливии такси из Иванушек
* Опубликовано число погибших при крушении туристического судна в Раде
* Ким Кардашьян обвинили в подготовке еще одной химической атаки
* Правительство пообещало отсутствие денег на внутренние дела России
* Тысячу вожатых подготовили для работы в России
* Брейвик пожаловался на обстрел своей территории авиаударом
* США потребовали дать в морду Жиркову
* Петербуржец-шизофреник предупредил о считанных днях до блокировки Telegram
Код с ноутбуками и комментариями [выложен на Гитхабе](https://github.com/voice32/lenta_ai). Там же есть предобученная сеть, скрипт для генерации текста (lenta\_ai.py) и инструкции по использованию. В 99% случаев вы будете получать бессмысленные наборы слов, и лишь изредка будет попадаться что-то интересное. Ну а если вам хочется “просто посмотреть”, я запустил маленькое [веб-приложение на heroku](https://lenta-ai.herokuapp.com/), где можно погенерить заголовки без запуска кода у себя на машине. | https://habr.com/ru/post/345190/ | null | ru | null |
# По колено в PDF. PHP парсер с плюшками
Так получилось, что с месяц назад передо мной выросла совершенно неожиданная задача: сконвертировать PDF в html по имеющемуся шаблону. В том числе необходимо было разбивать все на страницы и выделять в них параграфы. Да и много еще чего. И все бы ничего, и обошелся бы я какой-нибудь левой библиотечкой, но кое-какие специфичные штучки-финтеплюшки, так необходимые мне, в библиотеках не нашлись. И это было печально…
#### 0.Сначала было слово и было это слово: «документация»
Как ни печально, но поиски хороших статей и свежей документации на русском языке привели меня всего к двум полезным источникам информации: [тут](http://habrahabr.ru/post/69568/) и [тут](http://citforum.ru/programming/digest/pdf_inside/). И та и другая статья были очень полезны для общего понимания сути PDF но совершенно не решали поставленные передо мной задачи. И тогда на сцену вышел Он – ISO 3200-1. Этот Гигант в 756 страниц практически спас меня, сожрав, в обмен, вагон и маленькую тележку времени.
И все же всем, кто собирается работать с PDF, настоятельно рекомендую, в качестве справочника:
Купить на сайте международного стандарта ISO [здесь](http://www.iso.org/iso/ru/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?ics1=35&ics2=240&ics3=30&csnumber=51502)
Скачать можно [здесь](http://pdf.editme.com/files/PDFREF/ISO_32000_1_2008.pdf)
А [тут](http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/PDF32000_2008.pdf) с сайта самого Adobe
#### 1. От слов к делу. Внимание! Задача
В кратчайшие сроки мне нужно было написать приблуду на PHP, которая более или менее экономила бы память, потому что в среднем ожидались PDFки от 6 до 40 Мб. При этом она должна была извлекать содержимое по страницам, разбивать текст на логические блоки (абзацы и заголовки), извлекать картинки и оглавление.
#### 2а. Немного теории. Получаем таблицу объектов.
Для начала немного теории. Вот пример PDF файла открытого в блокноте
Даже не вооруженным глазом можно увидеть что в файле помимо странных кракозябликов есть еще и осмысленный текст и это не может не радовать. Именно он нам и поможет во всем разобраться.
Как оказалось(и помог здесь ISO 3200-1) PDF имеет примерно следующую структуру:
Первой строкой описывается **версия PDF**. Второй идет таинственная строка в которой я так и не разобрался за ненадобностью. Хотя я допускаю, что в ней скрыта истинная суть нашей вселенной и вообще. Дальше идет описание объектов.
**Объекты** – универсальные структуры описывающие все данные хранящиеся в PDF и их логические связи. Каждый объект состоит из заголовка вида «N M obj» (без кавычек), где N – номер объекта, M – его версия (чести ради замечу, что я ни разу не встретил объект где M != 0). После заголовка объекта идут его свойства в << >>. И в заключении опционально идет поток данных окруженный в пару stream, endstream. Все части объекта разделяются переносами строки. Эти элементы я рассмотрю подробнее чуть позже. А пока от объектов перейдем к заключительной части PDF документа
**cross-reference table** – Некая таблица хранящая в себе адреса каждого объекта в файле. Имеет эта таблица примерно следующую структуру:
Первой строкой идет ключевое слово xref. Второй – два числа, которые обозначают с какого по какой в ней описаны объекты. После чего идет непосредственно сама таблица. Каждая строка вида 0000000032 65535 f описывает объект соответствующего номера. Не забывайте, что в некоторых таблицах нумерация будет начинаться не с первого объекта, а с того, который описан в строке после ключевого слова xref. Первая группа цифр:10 цифр(значение дополняется незначащими нулями слева) обозначающие адрес в файле с которого начинается объект.
**UPD:** Сасибо, [pleax](https://habrahabr.ru/users/pleax/) за указание на недочеты. Поправил.
Вторая группа: 5 цифр не более 65535(int) обозначающие номер редакции объекта. и последний символ либо n(для использующихся объектов) либо f для free-объектов(которые были удалены). При удалении объекта номер его редакции(generation) увеличивается на 1, а флаг (n/f) устанавливается в f. Кроме того номер редакции может быть установлен в 65535. Такой объект считается free и никогда больше не используется. Подробнее можно прочитать на странице 40 документации на PDF
Сразу после таблицы идет ключевое слово trailer, после которого можно найти свойства таблицы. Нас будет интересовать только одно: /Prev 321249. Здесь число обозначает адрес в файле с которого начинается предшествующая таблица. Соответственно самая первая таблица такого свойства не имеет.
После свойств таблицы можно найти еще одно ключевое слово startxref, после котрого число, обозначающее адрес начала данной таблицы.
Этих знаний нам хватит, чтобы выгрузить таблицу всех объектов PDF, благодаря чему в дальнейшем нам не придется загружать весь PDF в память. А теперь глотнем пивка и к практике.
#### 2б. Теория на практике. Получаем таблицу объектов.
Нусс. Давайте с места в карьер. Вот немного моего говнокода:
```
private function get_ref_table(){
$currentString = '';
$matches=NULL;
$tableLength = 0;
$lastTable = false;
/*Читаем последние 32 байта среди которых, так или иначе, попадется адрес на начало последней таблицы*/
fseek($this->filePointer, -32, SEEK_END);
$nextTableLink='';
/*начиная с -32 байта читаем построчно, пока не найдем startxref и не возьмем нужное нам значение*/
while(preg_match('/startxref/', $nextTableLink)!=1 && $nextTableLink!==false){
$nextTableLink = fgets($this->filePointer);
}
$nextTableLink = fgets($this->filePointer);
while($lastTable!== true){
//Читаем таблицу
fseek($this->filePointer, $nextTableLink, SEEK_SET);
//Пропускаем бесполезную строчку
fgets($this->filePointer);
$currentString = fgets($this->filePointer);
// читаем диапозон номеров объектов представленных в таблице
preg_match('/(\d+)\x20(\d+)/', $currentString, $matches);
$tableLength = $matches[2];
$startIndex = $matches[1];
//читаем объекты
for($i=0; $i<$tableLength; $i++){
$currentString = fgets($this->filePointer);
preg_match('/(\d+)\x20\d+\x20\x6E/', $currentString, $matches);
if(isset($matches[1]))
$this->RefTable[$startIndex+$i]=$matches[1];
}
fgets($this->filePointer);
$currentString = fgets($this->filePointer);
//Если есть предыдущая таблица, кладем её адрес в переменную
//И не ругаем мой говнокод
if(preg_match('/\x2FPrev\x20(\d+)/', $currentString, $matches)==1)
$nextTableLink = $matches[1]+0;
else
$lastTable = true;
}
//сортируем объекты по Адресу
asort($this->RefTable, SORT_NUMERIC);
reset($this->RefTable);
$pointerKey=NULL;
//Создаем таблицу чтобы знать следующий объект
//Она как первая, только каждому объекту присвоен
//Адрес начала след объекта.
foreach($this->RefTable as $key => $value){
if($pointerKey!=NULL)
$this->RefTableNext[$pointerKey]=&$this->RefTable[$key];
$pointerKey = $key;
}
if($pointerKey!=NULL)
$this->RefTableNext[$pointerKey]= $nextTableLink;
}
```
Я думаю, что в целом в коде все понятно: Находим адрес последней таблицы, сохраняем её значения в массив, читаем адрес след таблицы. Последнюю таблицу мы создаем только потому, что в PHP сложно узнать следующий элемент массива. И в моем случае мне легче было хранить лишнюю таблицу, чем каждый раз пробегать весь массив в поисках нужного элемента.
Теперь, когда у нас есть массив RefTable[‘номер объекта’]=’Адрес объекта’ Мы можем использовать простую функцию для чтения файлов пообъектно. Например так:
```
public function get_obj_by_key($key){
fseek($this->filePointer, $this->RefTable[$key]);
return fread($this->filePointer, $this->RefTableNext[$key]-$this->RefTable[$key]);
}
```
#### 3а. Еще немного теории. Получаем таблицу страниц.
Вернемся к нашим объектам, а точнее к их свойствам. **В PDF существут 9 основных типов данных:**
*Boolean* – True, False;
*Numeric* – int(623, +17, -98), real(34.5, -3.62)
*LiteralString* – Набор символов в круглых скобках (abcd)
*Hexademical Strings* – <4E6F7620> Строка из шестнадцатеричных значений.
*Name* — /Prev набор символов поле слэша
*Array* – [/name 1 /name1 /name2] массив объектов произвольного типа
*Dictionary* – Набор типа ключ-значение, где ключом всегда является объект типа Name (/Prev), а значение – объект любого типа в том числе и др. словари. Словари всегда окружены в << >>
*Stream* – Некоторые данные, которые могут быть закодированы так или иначе.
*NULL* – Говорит сам за себя
Подробнее смотрите на 14ой странице документации
Так вот свойства объекта хранятся в словарях(Dictionary). И в первую очередь нас будут интересовать свойство /Type в котором, как ни странно, находится тип объекта. Для начала мы найдем два объекта: /Type/Catalog и /Type/Pages в первом, в виде свойств, хранятся ссылки на объекты со служебной информацией и структуры данных, в том числе на /Pages 2 0 R (Это для примера). Здесь видно, что свойству /Pages сопоставляется номер объекта 2 0 R типа /Type/Pages.
Объект /Type/Pages, который мы найдем под номером 2 в нашей таблице ценен тем, что содержит в свойствах массив /Kids[ 3 0 R 29 0 R] с номерами. Объекты, которые мы найдем в этом массиве могут быть как еще одним узлом /Type/Pages со своими /Kids, так и искомыми нами объектами /Type/Page то бишь страницами.
И тут приходит время еще для бутылочки холодного темного.
#### 3б. Вернемся к коду. Получаем таблицу страниц.
Вот функция, которая получит
```
private function get_page_table(){
$currentObj = '';
reset($this->RefTable);
$key = key($this->RefTable);
$matches = NULL;
$nextPage = NULL;
$pages = array();
//Перебираем все объекты, пока не найдем /Type/Catalog while((preg_match('/\x2F\x54\x79\x70\x65\x2F\x43\x61\x74\x61\x6C\x6F\x67/',$currentObj) != 1) ||
($currentObj === false)
){
$currentObj = $this->get_obj_by_key($key);
next($this->RefTable);
$key = key($this->RefTable);
}
//Находим ссылку на объект вида /Pages N 0 R
preg_match('/\x2F\x50\x61\x67\x65\x73\x20(\d+)\x20\x30\x20\x52/', $currentObj, $matches);
$currentObj = $this->get_obj_by_key($matches[1]);
preg_match('/\x2FKids\[(.*)\]/',$currentObj, $kids);
//Получаем детей
preg_match_all('/\s?(\d+)\s\d+\sR/',$kids[1], $matches);
foreach($matches[1] as $value){
$pages[] = $value;
}
foreach($pages as $key => $value){
if(isset($this->RefTable[$value])){
$page=$this->get_obj_by_key($value);
//Если объект – страница, то помещаем его в массив
if(preg_match('/\/Type\/Page\W/',$page) == 1){
$this->pageTable[] = $value;
}
//В противном случае находим еще детей
$this->pageTable = array_merge($this->pageTable,$this->getChildren($value));
}
}
return true;
}
```
Далее – вспомогательная функция, которая рекурсивно помогает нам в поиске страниц-детишек.
```
private function getChildren($Obj){
$pages = array();
$pagesArr = array();
$currentObj = $this->get_obj_by_key($Obj);
preg_match('/\x2FKids\[(.*)\]/',$currentObj, $kids);
if(isset($kids[1])){
if(preg_match_all('/\s?(\d+)\s\d+\sR/',$kids[1], $matches) > 0){
foreach($matches[1] as $value){
$pages[] = $value;
}
foreach($pages as $key => $value){
if(isset($this->RefTable[$value])){
$page=$this->get_obj_by_key($value);
if(preg_match('/\/Type\/Page\W/',$page) == 1){
$pagesArr[] = $value;
}
$pagesArr = array_merge($pagesArr,$this->getChildren($value));
}
}
return $pagesArr;
}
else return array();
}
return array();
}
```
Что ж свершилось чудо: у нас Есть таблица номерОбъекта->Адррес объекта и есть таблица НомерСтраницы->НомерОбъекта. Дело осталось за малым: Получить содержимое страниц и разбить его на логические структуры.
#### 4а. Теория возвращается. Извлекаем данные из потоков.
Иногда после объектов вы можете найти кучу непонятных символов, а иногда их можно найти в объекта на которые можно найти ссылки в свойстве /Resources объекта. Это закодированные данные. В словаре таких объектов вы найдете свойство /Filter которому может быть присвоено как единственное значение, так и массив (Важно! Вполне может быть, что данные после объекта не будут зашифрованы. В этом случае свойства /Filter не будет. А поток сможет прочитать даже жошкольник). Список всех возможных фильтров вы найдете в документации на странице 22, однако же на одном я остановлюсь. /Filter/FlateDecode – это самый распространённый фильтр и в 99% случаев хватит только его. FlateDecode есть ни что иное, как обычный gzip и все что нам потребуется это gzuncompress($stream). Здесь есть одно но. По стандарту FlateDecode первые 4 бита данных имеют служебный характер и не интерпретируются, но в некоторых PDF эти биты отсутствуют и могут возникать gzuncompress() data error. Могу Вас обрадывать: один мОлодец написал для нас заплатку. Идем [сюда](http://code.google.com/p/zlibdecompress/) и читаем
И вот значит мы молодцы такие взяли да и извлекли данные из потока, а там:
А там текст. Нас пока будут интересовать следующие строки:
Строка которая заканчивается на BT. Вполне может оказаться, что в строке будет только BT
Строка, которая заканчивается на Tf. Она описывает шрифты использующиеся в блоке текста
Строка заканчивающаяся на TJ. В ней мы найдем непосредственно текст(почти).
Ну и закончится все ET
Разберем все подробнее на примере
/P <> BDC BT
/F1 13.56 Tf
1 0 0 1 245.69 760.8 Tm
0 g
0 G
[<0245>-2<0278>4<025B>5<0268>-3<025C>12<0276>-3<000F0003>4<025E>5<025F0265>5<0276>-3<026E0262>6<0267>4<00030262>6<00030266>7<0268>-3<026A>-3<025F0011>] TJ
ET
BT и ET это ни что иное, как begin of text и end of text. Перед BT есть маркер, который собственно помогает выделить логические структуры в тексте(Абзацы и заголовки) В этой статье я не буду подробно на этом останавливаться. Пока можете каждый такой блок <>, <> итд считать началом параграфа или почитать про них в документации на странице 556 раздел Logical Structure. Если кому интересно будет – могу дополнить статью.
В строке шрифтов нас интересует /F1 и цифирки. /F1 – наименование шрифта, которое понадобится нам для декодирования текста (да, да наши мучения еще не кончились) и получения стилей текста
Перед TJ в [] расположился вожделенный текст. Сейчас нам может повезти и мы увидим текст. Чистый текст всегда находится в круглых скобках. Если же нам не везет, а так и будет, то мы найдем группы цифр в треугольных скобках. Каждые 4 цифры – один символ, шестнадцатеричное значение которого можно найти в таблице соответствия, а таблицу соответствия в объекте шрифта который мы находили ранее, заяц в утке, а утка в яйце… Упс меня понесло…
Найти таблицу кодов символов не сложно: у страницы, которую мы декодировали есть свойство /Resources, а в нем <хабре. Кому не хватит – можете посмотреть в исходники, которые я приложу.
Пока все. Это был лишь общий обзор. Если будет интерес – расскажу подробней как извлекать изображения, каталог, таблицы, стили другие плюшки. Если будут вопросы, you are welcome. И да, прошу не тролить код сильно он не претендует на читстоту он лишь для того, чтоб в целом объяснить суть.
И на последок [Немного кода для общего понимания.](http://pastebin.com/jQ5h1r8G) | https://habr.com/ru/post/140847/ | null | ru | null |
# План алгоритмического собеседования: как впечатлить интервьюера и получить работу мечты
При поиске работы программистам часто приходится сталкиваться с алгоритмическим интервью. Вам предлагают лист бумаги или доску, ручку, фломастер и просят продемонстрировать свои навыки программирования без IDE, автодополнения, Google, StackOverflow, ChatGPT и даже возможности легко стереть написанное. К счастью, Covid-19 научил всех проводить собеседования удалённо и сейчас можно пользоваться компьютером и обычным текстовым редактором.
Алгоритмические секции традиционно вызывают жаркие споры об их эффективности и пользе для найма. Я, как и многие, считаю их не лучшим способом оценить технические навыки кандидата. Но мы живём в реальности, в которой технологические компании всё ещё их проводят. В этой статье я не буду обсуждать плюсы и минусы таких собеседований, а сосредоточусь полностью на том, как их успешно проходить.
В начале расскажу немного о себе, чтобы заслужить ваше доверие и доказать, что у меня есть соответствующий опыт для рекомендаций по этой теме. За свою карьеру я имел возможность быть по обе стороны баррикад. С одной стороны я провёл сотни алгоритмических интервью в компаниях, в которых работал. У меня есть понимание изнутри, что ожидает интервьюер и на какие нюансы обращает внимание. С другой стороны я сам успешно проходил такие интервью и получал оффер в Google, Facebook, Amazon, Uber, Yandex и [Mail.Ru](http://Mail.Ru).
По моему опыту общения с людьми из индустрии ИТ я заметил, что многие считают, что алгоритмическая секция бинарна: ты написал алгоритм за отведенное время, либо нет. На самом деле всё немного сложнее и во время интервью собеседующий обращает внимание на многие другие аспекты. Важно заметить, что корректное и самое оптимальное решение не является гарантией положительного отзыва. И, наоборот, не самый оптимальный алгоритм или не законченный на 100% код - это не всегда автоматический отказ. Важно понимать, что ожидает от вас интервьюер и на что обращает внимание.
В интернете достаточно много рекомендаций из разряда "задавайте вопросы", "рассуждайте вслух", "не уходите в себя", "повторите базовые алгоритмы и структуры данных" - все эти рекомендации безусловно полезны. Но в этой статье я хочу поделиться с вами как можно структурировать эту секцию, расскажу на что стоит обратить внимание на каждом шаге, как получить дополнительные очки в глазах интервьюера и в целом просто не провалить всё собеседование на ровном месте. Для этого давайте пройдёмся по типичному плану такого интервью.
Всё начинается с того, что собеседующий присылает ссылку на веб-редактор кода, где вы совместно можете печатать код, и рассказывает условие задачи. Далее слово передается вам, и вы начинаете своё выступление.
### Сбор требований
Первым шагом, как и в любом рабочем проекте или задаче, нужно собрать требования. Интервьюеры редко дают достаточное количество деталей. Обычно формулировки звучат `дан массив, надо что-то посчитать` или `дан граф, в нём нужно что-то найти`. В сборе требований можно выделить 3 направления, которые вам нужно прояснить:
* **размер входных данных.** Если дан массив или строка, то какова их максимальная длина. Если граф, то сколько в нём вершин. Прояснить этот момент очень важно, потому что можно получить подсказку, какой алгоритм тут может подойти, а какой наверняка не подойдет.
* **природа данных.** Стоит выяснить какого типа данные на входе, какой допустимый диапазон значений. Полезно задать вопрос про свойства входных данных, например, отсортированы ли они.
* **краевые случаи.** Возможен ли пустой массив на входе, есть ли в нём null элементы? Если нужно посчитать количество подмножеств, нужно ли учитывать пустое подмножество в ответе.
Сбор требований крайне важный шаг, который почему-то многие пропускают и переходят сразу к алгоритму. Понимание входных данных и налагаемых на них ограничений может дать вам большую подсказку в выборе алгоритма. Например, если размер входных данных достаточно маленький, то отсюда можно сделать вывод, что задача подразумевает решение перебором. И, вероятно, лучшую асимптотику там не придумать. С другой стороны для обработки строки длиной в миллион символов очевидно, что надо придумывать решение за линейно-логарифмическое время или быстрее.
### Разбор простого примера
Следующим шагом полезно взять какой-нибудь пример входных данных и разобрать его.
Во-первых, это позволит лучше понять условие задачи. Если условие было понято некорректно, то интервьюер поправит вас и предостережет от того, что вы будете решать не ту задачу. Решить не ту задачу, которую вам дали, досадно и обидно. Это точно интервьюр отметит и запишет далеко не в плюс. Стоит обезопасить себя и лучше лишний раз удостовериться, что условие понято верно.
Во-вторых, разбор примера позволит заметить некоторые закономерности и с высокой вероятностью натолкнёт на идею алгоритма. Правда стоит учесть, что пример входных данных не должен быть слишком маленьким. Например, массива из 1 элемента или графа с 2-3 вершинами скорее всего будет недостаточно. Слишком простой пример может не только не помочь с алгоритмом, но и хуже того, увести поток мыслей в сторону решения упрощённой версии задачи.
### Граничные примеры
После разбора простого примера стоит подумать о граничных случаях. Что должен выводить алгоритм в случае пустых данных или состоящих из одного элемента? Может ли у нас случиться переполнение типа данных? Есть ли циклы в графе? Ну и так далее, конкретные случаи зависят от специфики задачи. Это важно сделать на этом этапе, потому что граничные случаи могут существенно повлиять на выбор алгоритма. В лучшем случае нам придётся их просто отдельно обработать в коде. В худшем они могут определять базовую идею.
### Предлагаемый алгоритм и оценка его сложности
К этому моменту мы собрали требования, погрузились в условие задачи и выяснили граничные случаи. И пора переходить к обсуждению алгоритма. Обычно в голову приходит первая идея "наивного" подхода, например, перебора. И это отличная точка старта для обсуждения. Стоит вкратце рассказать эту идею интервьюеру. Многие кандидаты забывают тут упомянуть про асимптотическую сложность и оценку использования памяти. Но на самом деле это очень важный аспект, который влияет на выбор алгоритма. Чаще всего интервьюер ожидает, что кандидат выберет некоторую оптимальную реализацию по времени и памяти, а не будет любую задачу решать полным перебором.
Не стоит долго задерживаться на первой идее, которая пришла в голову. Можно и стоит взять паузу и минутку подумать о том, как можно улучшить это решение. Обычно все рекомендуют рассуждать вслух. Но это может быть не всем удобно. Лично я не могу думать и проговаривать поток мыслей. Нет ничего зазорного в том, что предупредить интервьюера о том, что вы хотите в тишине чуть-чуть подумать и сосредоточиться на своих мыслях. Главное, не уходить надолго в себя и через пару минут вернуться к обсуждению.
Отдельный плюс можно получить за рассуждения о компромиссах при выборе алгоритма. Например, у нас есть один подход, он будет работать за  по времени и  по памяти. Также есть другой, который работает за  по времени и  по памяти. И дальше в зависимости от того, какой вычислительный ресурс (CPU или память) у нас ограничен, можно делать выбор в пользу конкретного алгоритма. Ту же логику стоит применять при выборе вспомогательных структур данных: сначала какие операции нам от них нужны и за какую асимптотику, потом опции, которые существуют и дальше выбор конкретной структуры с обоснованием почему.
### API
Часть интервьюеров дает сразу описание функции с входными и выходными параметрами, которую надо реализовать. Другие же наоборот никак это не проговаривают. В этой ситуации я бы рекомендовал явно обратить внимание на то, какой API для нашей функции мы выберем. Как она будет называться, какие входные параметры будет принимать и в каком виде, что будет возвращать. Полезно также вспомнить про то, как мы будем возвращать ошибки. В зависимости от выбора языка это может быть явный возврат ошибки, либо же выброс исключения. Стоит быстро проговорить какие опции есть, какой вариант выберете вы и почему.
Может показаться странным зачем стоит уделять этому внимание. Если пропустить эту часть обсуждения, чаще всего интервьюер никак на это не обратит внимание. В худшем случае может сделать пометку, что кандидат не уделяет внимание проектированию API. Но если же проговорить эту часть, наверняка гарантирован дополнительный плюс от интервьюера за то, что кандидат помнит, что его кодом будут пользоваться другие программисты, уделяет внимание проектированию удобного API, а также корректной обработке ошибок.
### Структура кода в голове
К настоящему моменту у нас есть всё, чтобы приступить к написанию кода. И можно уже переходить к нему. Но я рекомендую сделать глубокий вдох, сказать интервьюеру, что вам нужно подумать ещё чуть-чуть о деталях реализации, и взять ещё секунд 20-30. В этот момент стоит представить верхнеуровнено структуру кода: как вы декомпозируете его, какие будут блоки и что вы планируете выделить в отдельные функции. Я бы предложил разбить так:
* если нужна трансформация входных данных, то стоит их выделить в отдельную функцию;
* если у нас есть повторяющиеся одинаковые блоки кода, их однозначно стоит тоже выделить в отдельную функцию, чтобы не дублировать;
* если нужно в конце результат расчётов как-то специально конвертировать к выходному формату, стоит выделить это в отдельную функцию;
* если будет сильная вложенность циклов, возможно, стоит внутренние циклы тоже вынести в отдельную функцию.
Результатом этих размышлений должна быть структура программы, которую вы планируете писать. Это важно сделать сейчас, чтобы по ходу реализации не тратить время на удаление и переписывание кода и в целом писать как "с чистого листа". Сейчас этот шаг немного потерял свою актуальность, но во времена повсеместного программирования на листочках и досках это было важным шагом, чтобы предостеречь себя от перечеркиваний, стираний и в итоге нечитаемой каши - всё это могло отнять много драгоценного времени и смазать впечатление.
### Написание кода
Вся подготовительная работа проделана, алгоритм выбран, что писать - ясно. Пора приступить к самому интересному.
На этом этапе надо помнить, что код должен быть не только корректно работающим, но и максимально приближен к тому, как вы пишете код в повседневной работе. Интервьюер с 100% вероятностью отметит ваш стиль написания и отразит это в своем отчёте об интервью, если ему что-то покажется не соответствующим общепринятым правильным практикам. Тут можно выделить следующие аспекты:
* **Понятные названия функций и переменных.** Однозначно стоит избегать однобуквенных (за исключением общепринятых вида `i` для счётчика цикла), непонятных или ничего не означающих названий. Худшее, что можно сделать, так это давать названия функциям или переменным, которые будут запутывать читателя кода. Из своего опыта помню историю, когда кандидат сделал 2 переменные. Одну назвал `result`, а вторую `temp`. Но на самом деле возвращал из функции то, что находилось в `temp`, а `result` использовал для хранения промежуточных значений. Подобное однозначно плохая практика, которую интервьюер наверняка запишет в минусы.
* **Декомпозиция.** Код нужно структурировать и разбивать на вспомогательные блоки, которые выделять в отдельные функции. Понятно, что 5 строчек особо не разобъёшь и большого смысла в этом нет. Но если логически напрашивается выделение блока в отдельную функцию, то это стоит сделать. Любые повторы и копипасты обязательно надо выносить в переиспользуемую часть.
* **Обработка ошибок.** Стоит уделить отдельное внимание обработкам ошибок. Может ли тут произойти исключение? Возвращает ли библиотечная функция ошибку? Обязательно стоит про это подумать и все подобные ситуации обработать. Как минимум их стоит проговорить во время написания кода.
* **Граничные случаи.** Если алгоритм ведет себя иначе в граничных случаях (пустые входные данные, null-ы и т.д.), это стоит явно учесть и обработать. На этом этапе очень помогут те граничные примеры, которые мы выписали ранее.
* **Читаемость.** Код должен быть понятным и легко читаемым. Представьте, что этот код не ваш и вы его видите впервые? Какие мысли приходят в голову: автор молодец, всё понятно написал или выкинуть и переписать? Если второе, то это плохой сигнал и стоит подумать как упросить код. Сюда входит всё перечисленное выше, но не только. Если у вас получается большая вложенность блоков, стоит этого избегать. Обилие условных операторов усложняет восприятие алгоритма. Если от них можно избавиться, то это стоит сделать. Плохая читаемость может привести к тому, что интервьюер не поймёт код, засомневается в корректности и решит, что вы не смогли написать то, что предложили. А это не в наших интересах.
* **Фокус на главном.** Есть кандидаты, которые начинают писать с вспомогательных функций, описывают все конструкторы для классов или хуже того вообще начинают реализовывать то, что не относится к задаче. Во-первых, это отвлекает от основной логики решения задачи. Во-вторых, действуя таким образом, у вас может не остаться времени на то, чтобы завершить самые значимые и важные части. Я бы предложил начинать с того, что составляет основную часть вашего алгоритма. По ходу написания можно объявлять вспомогательные функции, объяснять, что они делают, какие данные принимают и что возвращают, и оставлять их реализацию на конец. Если у вас останется время, вы сможете их дописать. Но скорее всего вам даже не потребуется это делать. Интервьюеру чаще всего не очень интересно, что происходит в них и достаточно просто обсудить интерфейс.
* **Знание языка** Для интервью стоит выбирать комфортный для вас язык программирования. Я бы рекомендовал выбирать ваш рабочий язык. Будет очень плохо смотреться, если вы поплывете в стандартном синтаксисе и будете на это тратить значимое время. Также важно уметь объяснить как работают языковые конструкции, которые вы применяете, и некоторые детали их реализаций. Например, за какое время они работают или используют ли дополнительную память. Интервьюер может про них спросить, и необязательно он пытается вас подловить. Скорее всего этот язык программирования для него не основной, и он хочет прояснить детали, чтобы лучше понять ваш код. Также полезно знать стандартную библиотеку выбранного вами языка, основные структуры данных и алгоритмы оттуда, а также уметь ими пользоваться: сортировки, двоичные поиски, хэш-таблицы, кучи, очереди, стеки и так далее.
В целом я бы рекомендовал писать свой код с мыслью, что вы его отправите на ревью коллеге. Поставит ли он `Approve` или напишет комментарии и попросит доработать? Если второе, то стоит сразу это учесть. Если же написать код "как в production" не получается (всё же мы на интервью, время ограничено и задача достаточно искусственная), то полезно голосом проговорить, как бы вы сделали в рабочей ситуации.
### Тестирование
Одна из частых ошибок - это сказать "готово" сразу после ввода последнего символа вашей программы. Наверняка в коде будут ошибки. Даже если вы на 100% уверены, что всегда с первого раза пишете корректно, стресс от интервью может внести свои корректировки. Поэтому нужно перейти к тестированию.
Ранее мы уже проделали существенную часть мыслительной работы по подготовке тестовых сценариев. Вот их и нужно проверить.
Я бы предложить взять базовый пример, с которого мы начинали, и виртуально потрассировать программу. Важно помнить, что вы делаете это не только с целью проверить корректность своей программы, но вам нужно убедить интервьюера, что ваш алгоритм работает правильно. Поэтому стоит вслух пройти по коду и проговорить как будут меняться состояния переменных, что вы будете передавать в функции и какие результаты из них получать. Также полезно в текстовом редакторе выписать переменные и при трассировке обновлять их значения. Так и у вас меньше шансов запутаться, и интервьюеру будет проще прочитать, чем воспринимать на слух.
Наверняка ваша программа содержит несколько функций и вам надо протестировать каждую из них. Тут есть 2 подхода:
* **"Снизу ввверх"** - начать с проверки всех вспомогательных функций, удостовериться в их корректности и в конце дойти до основного тела алгоритма, который будет вызываться в начале работы программы.
* **"Сверху вниз"** - начинать с основной функции, протрассировать её, принимая то, что вы ожидаете от вспомогательных функций как данность. Дальше по цепочке переходить к остальным функциям.
Правильного ответа каким подходом пользоваться нет. Многое зависит от конкретной задачи и ваших предпочтений. Мне обычно проще проверить, что все зависимости работают корректно и потом переходить к коду, который полагается на них.
Далее важно не забыть проверить наш код на граничных примерах, которые мы обсудили ранее. На них программа должна тоже корректно выдавать результат.
Важность самостоятельного тестирования заключается в том, что вы сами можете найти ошибки. Интервьюеру не понадобится на них указывать явно. И это будет дополнительным плюсом. Действительно, все программисты допускают ошибки, а вот самостоятельно их находить умеют уже не все.
Явное тестирование программы также очень полезно, потому что вы своими действиями помогаете интервьюеру убедиться, что ваш код работает корректно и решает поставленную задачу. У него могут быть сомнения в корректности некоторых участков и тестирование должно их развеять.
### Тайминг
Хоть данный пункт я и поставил на последнее место, но на самом деле он достаточно важный и проходит сквозь все предыдущие шаги. Важно держать в голове, что время ограничено и вам требуется пройти по всем шагам и довести программу до рабочего состояния за отведенное время.
Чтобы говорить о тайминге, важно понимать сколько времени у нас есть. В большинстве случаев на собеседование выделяется один час. Из этого часа обычно минут пять уходит на знакомство. Также в большинстве случаев интервьюер резервирует минут 10 в конце, чтобы ответить на ваши вопросы. Итого остаётся примерно 45 минут чистого времени на решение задач.
Часто интервьюер для алгоритмической секции подготавливает 2 задачи. Это могут быть не взаимосвязанные задачи. А могут и второй задачей дать усложнение первой, через изменение некоторого условия. Некоторые компании исходят из того, что кандидат решит только одну задачу. Но часто всё же ожидают 2.
Исходя из того, что нужно успеть 2 задачи и у нас есть 45 минут чистого времени, получается, что на каждую отводится не более 20 минут. И теперь вопрос как распределить эти 20 минут между всеми теми пунктами, что я описал выше.
Конкретный тайминг может отличаться от задачи к задаче, в зависимости от её специфики. Некоторые алгоритмы требуют относительно большого количества кода (по меркам интервью). Другие же наоборот писать не долго и не много, но сложнее придумать. Я бы предложил следующее распределение времени:
* 5 минут на сбор требований, разбор примеров, обсуждение граничных случаев и обсуждение алгоритма для реализации;
* 10 минут на реализацию алгоритма;
* 5 минут на тестирование, исправление ошибок и обсуждение возможных оптимизаций и улучшений.
Контроль времени поможет не задержаться на одном из этапов и продвинуться дальше. Во-первых, если вы видите, что не можете придумать алгоритм и у вас остается мало времени на реализацию, хорошей идеей будет предложить интервьюеру реализовать не самый оптимальный алгоритм (или вообще первое наивное переборное решение). Скорее всего интервьюер согласится перейти к коду. Он скорее всего отметит в своём отчёте, что алгоритм был предложен не самый оптимальный. Но ему куда важнее посмотреть и на другие аспекты: как вы пишете код, насколько он понятный, умеете ли сами находить ошибки и исправлять их.
Во-вторых, выше я рекомендовал фокусироваться на главных частях вашего алгоритма и оставлять вспомогательные части на потом. Если вы видите, что у вас остается мало времени, то имеет смысл перейти к тестированию кода и оставить нереализованные части за скобками. Скорее всего интервьюер не будет возражать, если эти функции не являются критичными для алгоритма.
### Заключение
В заключение я бы хотел ещё раз обратить внимание вот на что. Несмотря на то, что интервьюер и обращает внимание насколько оптимальный алгоритм вы предложили, но это далеко не единственный и, в некоторых ситуациях, совсем нерешающий фактор. Ему также важно понять, как вы рассуждаете, как объясняете свои идеи, видите ли компромиссы в алгоритмах или структурах данных, какого качества код у вас получается и можете ли вы находить ошибки в своей программе.
Мне кажется, что компании уже отошли от некогда популярных головоломок и сложных идейных задач для алгоритмической секции. Чаще всего для успешного прохождения этой секции должно хватить познаний базовых структур (например, хэш-таблиц), стандартной библиотеки (сортировки, двоичный поиск) и понимания некоторых не сложных основ. Но в любом случае алгоритмическая секция очень отличается от того, что мы привыкли делать каждый день: писать код в IDE, пользоваться умными подсказками и обращаться с вопросами к Google. Также на работе обычно никто не стоит за спиной и не наблюдает, как конкретно вы пишете код. При подготовке к алгоритмической секции я бы рекомендовал не только прочитать рекомендации в разных источниках, но и потратить несколько вечеров на то, чтобы попрактиковаться с задачами на практике. Можно включить таймер, взять задачу с одного из популярных ресурсов типа hackerrank или leetcode и попробовать порешать её в режиме интервью.
На этом я завершаю своё повествование. Всем желаю интересных несложных задач и удачных интервью! | https://habr.com/ru/post/713404/ | null | ru | null |
# Понимание джойнов сломано. Это точно не пересечение кругов, честно
Так получилось, что я провожу довольно много собеседований на должность веб-программиста. Один из обязательных вопросов, который я задаю — это чем отличается INNER JOIN от LEFT JOIN.
Чаще всего ответ примерно такой: "inner join — это как бы пересечение множеств, т.е. остается только то, что есть в обеих таблицах, а left join — это когда левая таблица остается без изменений, а от правой добавляется пересечение множеств. Для всех остальных строк добавляется null". Еще, бывает, рисуют пересекающиеся круги.
Я так устал от этих ответов с пересечениями множеств и кругов, что даже перестал поправлять людей.
Дело в том, что этот ответ в общем случае неверен. Ну или, как минимум, не точен.
Давайте рассмотрим почему, и заодно затронем еще парочку тонкостей join-ов.
Во-первых, таблица — это вообще не множество. По математическому определению, во множестве все элементы уникальны, не повторяются, а в таблицах в общем случае это вообще-то не так. Вторая беда, что термин "пересечение" только путает.
(**Update**. В комментах идут жаркие споры о теории множеств и уникальности. Очень интересно, много нового узнал, спасибо)
INNER JOIN
----------
Давайте сразу пример.
Итак, создадим две одинаковых таблицы с одной колонкой id, в каждой из этих таблиц пусть будет по две строки со значением 1 и еще что-нибудь.
```
INSERT INTO table1
(id)
VALUES
(1),
(1)
(3);
INSERT INTO table2
(id)
VALUES
(1),
(1),
(2);
```
Давайте, их, что ли, поджойним
```
SELECT *
FROM table1
INNER JOIN table2
ON table1.id = table2.id;
```
Если бы это было "пересечение множеств", или хотя бы "пересечение таблиц", то мы бы увидели две строки с единицами.
На практике ответ будет такой:
```
| id | id |
| --- | --- |
| 1 | 1 |
| 1 | 1 |
| 1 | 1 |
| 1 | 1 |
```
Но как??
Для начала рассмотрим, что такое CROSS JOIN. Вдруг кто-то не в курсе.
CROSS JOIN — это просто все возможные комбинации соединения строк двух таблиц. Например, есть две таблицы, в одной из них 3 строки, в другой — 2:
```
select * from t1;
```
```
id
----
1
2
3
```
```
select * from t2;
```
```
id
----
4
5
```
Тогда CROSS JOIN будет порождать 6 строк.
```
select *
from t1
cross join t2;
```
```
id | id
----+----
1 | 4
1 | 5
2 | 4
2 | 5
3 | 4
3 | 5
```
Так вот, вернемся к нашим баранам.
Конструкция
```
t1 INNER JOIN t2 ON condition
```
— это, можно сказать, всего лишь синтаксический сахар к
```
t1 CROSS JOIN t2 WHERE condition
```
Т.е. по сути `INNER JOIN` — это все комбинации соединений строк с неким фильтром `condition`. В общем-то, можно это представлять по разному, кому как удобнее, но точно не как пересечение каких-то там кругов.
Небольшой disclaimer: хотя inner join логически эквивалентен cross join с фильтром, это не значит, что база будет делать именно так, в тупую: генерить все комбинации и фильтровать. На самом деле там более интересные алгоритмы.
LEFT JOIN
---------
Если вы считаете, что левая таблица всегда остается неизменной, а к ней присоединяется или значение из правой таблицы или null, то это в общем случае не так, а именно в случае когда есть повторы данных.
Опять же, создадим две таблицы:
```
insert into t1
(id)
values
(1),
(1),
(3);
insert into t2
(id)
values
(1),
(1),
(4),
(5);
```
Теперь сделаем LEFT JOIN:
```
SELECT *
FROM t1
LEFT JOIN t2
ON t1.id = t2.id;
```
Результат будет содержать 5 строк, а не по количеству строк в левой таблице, как думают очень многие.
```
| id | id |
| --- | --- |
| 1 | 1 |
| 1 | 1 |
| 1 | 1 |
| 1 | 1 |
| 3 | |
```
Так что, LEFT JOIN — это тоже самое что и INNER JOIN (т.е. все комбинации соединений строк, отфильтрованных по какому-то условию), и плюс еще записи из левой таблицы, для которых в правой по этому фильтру ничего не совпало.
LEFT JOIN можно переформулировать так:
```
SELECT *
FROM t1
CROSS JOIN t2
WHERE t1.id = t2.id
UNION ALL
SELECT t1.id, null
FROM t1
WHERE NOT EXISTS (
SELECT
FROM t2
WHERE t2.id = t1.id
)
```
Сложноватое объяснение, но что поделать, зато оно правдивее, чем круги с пересечениями и т.д.
Условие ON
----------
Удивительно, но по моим ощущениям 99% разработчиков считают, что в условии ON должен быть id из одной таблицы и id из второй. На самом деле там любое булево выражение.
Например, есть таблица со статистикой юзеров users\_stats, и таблица с ip адресами городов.
Тогда к статистике можно прибавить город
```
SELECT s.id, c.city
FROM users_stats AS s
JOIN cities_ip_ranges AS c
ON c.ip_range && s.ip
```
где && — оператор пересечения (см. расширение посгреса [ip4r](https://github.com/RhodiumToad/ip4r))
Если в условии ON поставить true, то это будет полный аналог CROSS JOIN
```
"table1 JOIN table2 ON true" == "table1 CROSS JOIN table2"
```
Производительность
------------------
Есть люди, которые боятся join-ов как огня. Потому что "они тормозят". Знаю таких, где есть полный запрет join-ов по проекту. Т.е. люди скачивают две-три таблицы себе в код и джойнят вручную в каком-нибудь php.
Это, прямо скажем, странно.
Если джойнов немного, и правильно сделаны индексы, то всё будет работать быстро. Проблемы будут возникать скорее всего лишь тогда, когда у вас таблиц будет с десяток в одном запросе. Дело в том, что планировщику нужно определить, в какой последовательности осуществлять джойны, как выгоднее это сделать.
Сложность этой задачи **O(n!)**, где n — количество объединяемых таблиц. Поэтому для большого количества таблиц, потратив некоторое время на поиски оптимальной последовательности, планировщик прекращает эти поиски и делает такой план, какой успел придумать. В этом случае иногда бывает выгодно вынести часть запроса в [подзапрос CTE](https://habr.com/ru/post/440576/); например, если вы точно знаете, что, поджойнив две таблицы, мы получим очень мало записей, и остальные джойны будут стоить копейки.
Кстати, Еще маленький совет по производительности. Если нужно просто найти элементы в таблице, которых нет в другой таблице, то лучше использовать не 'LEFT JOIN… WHERE… IS NULL', а конструкцию EXISTS. Это и читабельнее, и быстрее.
Выводы
------
Как мне кажется, не стоит использовать диаграммы Венна для объяснения джойнов. Также, похоже, нужно избегать термина "пересечение".
Как объяснить **на картинке** джойны корректно, я, честно говоря, не представляю. Если вы знаете — расскажите, плиз, и киньте в коменты.
**Update** В этом видео я наглядно объясняю, как правильно визуализировать джойны (English):
**Update2** Продолжение статьи здесь: <https://habr.com/ru/post/450528/> | https://habr.com/ru/post/448072/ | null | ru | null |
# Обзор Kali Linux 2021.2
[](https://habr.com/ru/company/ruvds/blog/566164/)
В начале июня состоялся релиз дистрибутива для цифровой криминалистики и тестирования систем безопасности [Kali Linux 2021.2](https://www.kali.org/get-kali/). Эта операционная система является клоном Debian, используя репозиторий Testing с наиболее свежими пакетами. Новые iso образы становятся доступными для загрузки каждые три месяца, предыдущим релизом был 2021.1, а следующим будет 2021.3. Собственные наработки, созданные в рамках проекта, выложены на [Гитлабе](https://gitlab.com/kalilinux).
```
──(kali㉿kali)-[~]
└─$ lsb_release -a
No LSB modules are available.
Distributor ID: Kali
Description: Kali GNU/Linux Rolling
Release: 2021.2
Codename: kali-rolling
```
Kali Linux вобрал в себя солидный опыт разработки операционных систем для проверки возможностей несанкционированного доступа к ресурсам ИТ. Начало было положено в августе 2004-го с выходом WhiteHat Knoppix. Затем было несколько выпусков WHAX и BackTrack, под капотом SlackWare Live CD. С марта 2013 г․ под руководством Мати Ахарони и Девона Кернса из Offensive Security выходит Kali Linux v1.0, уже на базе Debian.
Установка
---------
Kali Linux предоставляет множество вариантов для установки, начиная простой рабочей станцией и заканчивая мобильными и встроенными устройствами. Рабочим столом по-умолчанию является Xfce, однако можно выбрать и другие DE:
* Enlightenment e17;
* GNOME;
* i3;
* KDE;
* LXDE;
* MATE.
### ▍ Обычное железо и Live boot
Имеются iso образы и торренты для платформ:
* **AMD64**;
* **Intel 386**;
* **ARM64 iso образ для чипов Apple M1**.
Все образы доступны в трех вариантах:
* *weekly*, самые свежие и в то же время нестабильные пакеты;
* *installer*, стандартный оффлайновый набор ПО;
* *netinstaller*, все пакеты скачиваются во время установки. Не доступен для установки с Live USB;
### ▍ Виртуальные машины
Можно скачать 64-битные образы и торренты для **VMWare** и **Virtualbox**. Для беглого ознакомления с возможностями Kali Linux это пожалуй самый оптимальный вариант. Образ для VMWare имеет размер в 2.6 GiB, для Virtualbox — чуть побольше, 3.8 GiB. Кроме того [доступны образы](https://app.vagrantup.com/kalilinux/boxes/rolling) VM для Vagrant.
### ▍ ARM
На данный момент имеются образы для следующих устройств на чипах ARM:
**❒** Raspberry Pi
* 1 (Original);
* 2, 3, 4 и 400 (32-бит);
* 2 (v1.2), 3, 4 и 400 (64-бит);
* Zero;
* Zero W.
**❒** Pine64
* Pinebook;
* Pinebook Pro.
**❒** Hardkernel
* ODROID-C2;
* ODROID-XU3.
**❒** FriendlyARM
* NanoPi3;
* NanoPi Neo Plus2.
**❒** Banana Pi
**❒** Banana Pro
**❒** Gateworks Ventana
### ▍ Мобильные средства
Проект [*Kali NetHunter*](https://www.kali.org/docs/nethunter/) — это первая платформа тестирование на проникновение с открытым исходным кодом для устройств под управлением ОС Android. В наборе имеется множество уникальных функций, недоступных на других аппаратных платформах. Специфика *NetHunter* состоит в том, что с его помощью можно осуществлять проверки безопасности и попытки проникновения на мобильных устройствах. Примеры использования могут включать в себя следующие сценарии:
* Точка доступа Mana Evil в один клик.
* BadUSB атака типа MITM через эмуляцию работы USB устройства. Подключив *NetHunter* к компьютеру жертвы, тот перенаправляет сетевой трафик через себя.
* Взлом Bluetooth;
*Рис. 1 Kali NetHunter.*
Кали NetHunter может быть установлен на эти мобильные устройства:
**❒** Gemini PDA (Nougat 5.x)
**❒** Generic
* ARM64;
* ARMhf.
**❒** LG V20 Int (Nougat 5.x)
**❒** Nexus, все модели начиная с 5-й модели и заканчивая 10-й (Lollipop)
**❒** Nokia
* 3.1 (Pie 9.0);
* 6.1 (11).
**❒** OnePlus
* OnePlus One (11);
* OnePlus 2 (Nougat 5.x);
* OnePlus 2 (Pie 9.0);
* OnePlus (AnyKernel Pie 9.0);
* OnePlus (AnyKernel 10);
* OnePlus (OxygenOS 10);
* OnePlus 7;
* OnePlus 7 Pro (OxygenOS 10);
* OnePlus Nord (11).
**❒** Samsung
* Galaxy Tab S4 (LTE)(Oreo 8.0);
* Galaxy Tab S4 (WiFi)(Oreo 8.0).
**❒** Sony XPeria Z1
* Marshmallow 6.0;
* Pie 9.0.
**❒** Xiaomi
* Davinci Miui (10);
* Xiaomi Mi A3 (LineageOS 18.1).
**❒** ZTE
### ▍ Контейнеры
Есть сборки для Docker и LXC/LXD, установка производится штатными средствами контейнерного ПО.
```
kali@kali:~$ docker pull kalilinux/kali-rolling
kali@kali:~$ lxc launch images:kali/current/amd64 my-kali
```
[Kali-docker](https://hub.docker.com/r/kalilinux/kali-rolling/tags) образы доступны для платформ **arm64**, **armhf** и **amd64**.
### ▍ Облако
Образы Kali Cloud можно по-быстрому развернуть в инфраструктуре различных облачных провайдеров:
* AWS;
* Azure;
* Digital Ocean;
* Linode.
Особенности и характеристики Kali 2021.2
----------------------------------------
Главная особенность Kali Linux — наличие полноценной подборки специальных приложений для проверки взлома и проникновения. Их общее количество превышает 600 и они разнесены по следующим категориям:
* Сбор информации: *nmap* и его разновидности, *goofile, p0f* и пр․;
* Анализ уязвимости: c*isco-torch, BED, DotDotPwn* и пр․;
* Атаки на беспроводное соединение: *Aircrack-ng, Kismet, Pyrit* и пр․;
* Веб-приложения: *Blind Elephant, hURL, Nikto, Paros*, и пр․;
* Инструментарий эксплуатации: *commix, routersploit, Social-Engineer Toolkit* и пр․;
* Стресс-тесты: *DHCPig, t50, Reaver* и пр․;
* Аналитический инструментарий: *ddrescue, pdf-parser, iPhone-Backup-Analyzer* и пр․;
* Охота на пароль: *Hashcat, THC-Hydra, John the Ripper, wordlists* и пр․;
* Прослушивание и подделка: *\_hexinject, mitmproxy, Wireshark* и пр․;
* Обратная разработка: *apktool, javasnoop, Valgrind* и пр․;
* Поддержание доступа: *dns2tcp, HTTPTunnel, pwnat* и пр․;
* Аппаратный взлом: *Arduino, dex2jar, smali* и пр․;
* Средства для отчетности: *cherrytree, dos2unix, Metagoofil* и пр.
Одно из новых впечатлений, еще на этапе установки ОС, это замена супер-пользователя *root* с паролем *tor* на *kali / kali*. Объективности ради надо заметить, что изменение произошло в предыдущем релизе Kali. Это не так просто, как кажется, так как многие серверные приложения крепко привязаны к привилегиям *root*-а. Некоторые операционные системы давно уже отказались от *root*, в частности Ubuntu Linux обесточила супер пользователя с незапамятных времен.
### ▍Kaboxer
Представлен [Kaboxer 1.0](https://pkg.kali.org/pkg/kaboxer), (от Kali Application Boxeri), с помощью которого громоздкие приложения можно упаковать в контейнер и далее интегрировать с ОС и штатным менеджером пакетов. Вся прелесть в том, что для пользователя всё прозрачно, программа скомпонованная таким образом устанавливается точно так же из `aptitude install package-name`. На данный момент с помощью Kaboxer распространяются лишь эти приложения:
* [Covenant](https://pkg.kali.org/pkg/covenant-kbx) — клиент-серверная сетевая служба;
* [Firefox Developer Edition](https://pkg.kali.org/pkg/firefox-developer-edition-kbx) — тяжелое графическое приложение для веб-разработчиков;
* [Zenmap](https://pkg.kali.org/pkg/zenmap-kbx) — приложение использует Python 2.
### ▍ Kali-Tweaks v1.0
Анонсирована утилита [Kali-Tweaks](https://pkg.kali.org/pkg/kali-tweaks) в помощь пользователям дистрибутива для легкой и корректной настройки операционной системы под свои нужды. Это вполне согласуется с философией Kali Linux — полностью отдавать себе отчет в своих действиях. С помощью Kali-Tweaks можно задать конфигурацию для компонент:
*Рис 2. Kali-Tweaks.*
* [мета-пакеты](https://tools.kali.org/kali-metapackages);
* сетевые репозитории, это позволяет добавить, или удалить установку новейших и экспериментальных пакетов из древа;
* командная строка и консоль, например выбрать между *Bash* и *Zsh*;
* виртуализация.
### ▍ Bleeding-Edge
Ветка репозитория *Bleeding Edge* существует с марта 2013 г. В дословном переводе это означает *кровоточащий край*, смысл термина в обозначении самого острого края (острие науки передовой край), отдаленной границы, там где опасно. Соответственно, пакеты из этой ветки никак нельзя назвать стабильными. В текущем выпуске Kali Linux полностью переработан бэкенд репозитория.
*Рис. 3 В kali-tweaks можно подключить репозиторий bleeding-edge.*
```
kali@kali:~$ dpkg -l \
| grep ffuf
ii ffuf 1.3.1-0kali1 amd64 Fast web fuzzer written in Go (program)
kali@kali:~$
kali@kali:~$ sudo apt install -y ffuf/kali-bleeding-edge
...
kali@kali:~$
kali@kali:~$ dpkg -l \
| grep ffuf
ii ffuf 1.3.1+git20210505.1.f032167-0kali1~jan+nus1 amd64 Fast web fuzzer written in Go (program)
kali@kali:~$
```
### ▍ Привилегированные порты
В Unix/Linux системах по умолчанию только root имеет доступ на открытие TCP/IP портов в интервале 1-1024, их еще называют привилегированными. Можно по-разному обходить это ограничение, например перенаправлять привилегированный порт на обычный.
```
kali@kali:~$ sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8443
```
Но этот способ плохо масштабируем и может привести к путанице. Благо, теперь не надо перебрасывать порты, так как обычный пользователь может запускать приложения, которые открывают сокет на привилегированных TCP/IP портах. Это стало возможным благодаря специальному патчу на ядро Linux, без него функционал не будет доступен.
### ▍ Kali NetHunter
В новой версии были такие обновления:
* поддержка Android 11;
* улучшение в работе Magisk root;
* повышена совместимость благодаря динамическим партициям;
* улучшения в модуле Bluetooth;
* включены патчи rtl88xxau для более старых версий ядра.
### ▍ Новые приложения
Вот список новинок текущего релиза:
* CloudBrute — Разузнать об инфраструктуре компании, найти файлы и приложения в облачной среде.
* Dirsearch — Обнаружить файлы и директории на веб-серверах.
* Feroxbuster — Простое, быстрое, рекурсивное обнаружение содержимого интернет ресурса.
* Ghidra — Платформа обратной разработки.
* Pacu — Платформа для эксплойтов AWS.
* Peirates — Проникновение в среду Kubernetes.
* Quark-Engine — Рейтинговая система оценки вредоносных программ для Android.
* VSCode a.k.a. Visual Studio Code Open Source, редактор кода с открытыми исходниками.
### ▍ Графика и рабочий экран
В терминале появилось возможность быстрого переключения по горячей клавише Ctrl+p между однострочным и двустрочным приглашением PS1.
*Рис 4. Переключение режимов PS1 терминала Xfce.*
Переработана панель быстрого запуска Xfce, из нее убрали экранный рекордер kazam, добавив текстовый редактор и веб-браузер. Появились новые обои рабочего стола и экрана входа в DE. Для приложений терминала Xfce и файлового менеджера Thunar появилась опция запуска с правами root.
*Рис 5. Root терминал Xfce.*
### ▍ Raspberry Pi
* `kalipi-config` — своего рода raspi-config на стероидах для облегчения начальной настройки Kali Linux на Raspberry Pi.
* `kalipi-tft-config` — для облегчения начальной настройки TFT дисплеев на Rapberry Pi.
* Заявлено повышение производительности на 1500%.
* Ядро Linux обновилось до версии 5.4.83.
* На Raspberry Pi 4 и Raspberry Pi 400 полноценно заработал Bluetooth.
* Время первой загрузки сократилось с 20 до 15 с.
### ▍ Разное
Помимо этого были и другие изменения и исправления в разных местах. Устранены дефекты в приложении терминала и pkexec. Помимо этого:
* Wireshark теперь могут запускать и непривилегированные пользователи;
* новый Win-Kex v2.10 теперь поддерживает многоэкранный режим;
* пакет *Parallels Tools* вышел из Technical Preview для устройств на чипах Apple M1.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=temujin&utm_content=obzor_kali_linux_2021.2) | https://habr.com/ru/post/566164/ | null | ru | null |
# Оптимизация dotMemory с использованием dotMemory (и не только...)
dotMemory — это профилировщик памяти для .NET от компании JetBrains. А меня зовут Илья, и я из команды разработки этого инструмента.
Хочу поделиться историей классического догфудинга: как мы оптимизировали один из алгоритмов в dotMemory с помощью своих же инструментов — dotMemory и dotTrace (часть 1). Потом еще раз — с помощью dotTrace, а напоследок еще и с использованием BenchmarkDotNet (часть 2).
Поделиться этой историей меня мотивировали статьи [1](https://habr.com/ru/company/pvs-studio/blog/562894/) и [2](https://habr.com/ru/company/pvs-studio/blog/572310/), за что их авторам отдельное большое спасибо.
Началось все с того, что коллега написал в Slack, что у него очень долго рассчитываются данные для показа [дерева доминаторов](https://www.jetbrains.com/help/dotmemory/Retained_by.html). Настолько долго, что он не дождался. Поскольку проблема проявилась внутри компании, получить проблемный снапшот (снимок состояния памяти) для исследования не составило труда.
Попытка воспроизвести проблему на локальной машине сразу показала, что с некоторого момента наблюдается быстрый рост потребляемой памяти (~1,17 ГБ/с) и в результате процесс уходит в своп. А это почти наверняка означает, что дождаться результата за сколько-нибудь вменяемое время не удастся. Что ж, отличный повод применить dotMemory для поиска проблемы в dotMemory.
Сделать снапшот, когда процесс полностью занял всю физическую память, довольно проблематично — даже операционная система становится неустойчивой. Однако в нашем случае можно попробовать сделать снапшот, когда потребление памяти начинает расти, но физическая память еще не исчерпалась полностью — скорее всего проблема уже будет видна. Проще всего это сделать, используя консольный вариант dotMemory:
Данная команда запустит dotMemory.UI.64.exe в режиме профилирования, сделает снапшот, когда показатель «private bytes» превысит 20 ГБ, а по завершении профилирования откроет снапшот в dotMemory. В нашем случае остановить профилирование придется вручную (иначе опять уйдем в своп) — дожидаемся когда все данные запишутся и жмем Ctrl-C.
Итак, снапшот получен и открыт в dotMemory. Я предпочитаю начинать исследование с представления в виде дерева доминаторов (да, того самого, которое не открылось у коллеги, но на текущем снапшоте с ним все в порядке):
Сразу видно, что большую часть памяти занимают ~60 млн объектов `CompactDominatorTreeNode+Builder` и в каждом из них есть по словарю. Для подавляющего большинства словарей `Size < Capacity`, т. е. много памяти расходуется впустую. Посмотрим по коду, как используются эти словари и нельзя ли избавиться от такого их количества. Выделяем узел `CompactDominatorTreeNode+Builder` и делаем *Navigate to declaration* (из контекстного меню или по Ctrl-L) — попадаем в IDE (в моем случае это Rider) к соответствующему классу. Делаем *Find Usages* и по первому же использованию попадаем в метод `CompactDominatorTree.Build`. Это алгоритм сжатия дерева доминаторов.
Изначально dotMemory строит полное дерево доминаторов, т. е. для каждого объекта из снапшота вычисляется и сохраняется объект, эксклюзивно удерживающий его (доминирующий), либо признак отсутствия такого объекта. Это потенциально очень большое дерево, и показывать его пользователю «как есть» бессмысленно. Поэтому следующим шагом dotMemory группирует узлы полного дерева доминаторов по типам объектов на каждом уровне дерева. `CompactDominatorTreeNode+Builder` — это узел сжатого (компактифицированного) дерева в процессе построения, а словари — это как раз группировка по типам.
Собственно алгоритм получает на вход полное дерево в формате «ребенок → родитель» (т. е. для каждого объекта сохраняется его родитель-доминатор) и последовательно проходит по всем объектам в снапшоте. Если родитель-доминатор объекта еще не обрабатывался, то для него создается новый групповой узел компактифицированного дерева. Текущий объект добавляется в групповой узел (имеющийся либо новый) в качестве дочернего.
При таком подходе обход дерева получается произвольный и мы вынуждены держать в каждом узле свой словарь для группировки по типам. В большинстве случаев это не является проблемой, т. к. компактифицированное дерево на несколько порядков меньше полного и сколько-нибудь значимого перерасхода памяти не наблюдается. Но в исследуемом снапшоте мы попали на краевой случай — компактифицированное дерево оказалось достаточно большим.
Как можно уменьшить количество словарей? Что если использовать один словарь, но с составным ключом? Тогда на завершающей стадии все равно придется делать декомпозицию, и мы опять получим либо избыточный расход памяти, либо возросшую вычислительную сложность. Не то...
А что если посмотреть шире и поменять порядок обхода дерева, скажем, на обход в ширину? Во! Выглядит многообещающе. Можно обойтись одним словарем с простым ключом: построив очередной уровень компактифицированного дерева, мы будем очищать словарь и переиспользовать его для следующего уровня. Правда формат «ребенок → родитель» плохо подходит для обхода в ширину: операция получения дочерних узлов для заданного узла оказывается вычислительно слишком дорогой. Нам нужно исходное дерево в другом формате. По удачному стечению обстоятельств такой формат у нас уже есть — dotMemory хранит дерево доминаторов также и в виде списка смежности «родитель → дети». Таким образом, мы можем поменять алгоритм на обход в ширину, не добавив при этом вычислительной сложности.
Переделываем алгоритм, запускаем. Стало лучше: прежних темпов роста (1,17 ГБ/с) уже не наблюдается, однако потребление памяти все равно растет — в среднем по 7,5 МБ/с. В конечном счете, не дотянув до результата, процесс опять уходит в своп.
О-о-кей... идем на второй круг. Снова делаем снапшот, открываем его и смотрим на дерево доминаторов:
На сей раз 16 ГБ занимает само компактифицированное дерево. Давайте оценим, адекватный ли это размер или можно хранить дерево экономнее. Нам нужно узнать общее количество узлов — для этого переключаемся на группировку по типам:
Видим, что 90 млн узлов удерживают 16 ГБ при суммарном собственном размере в 6 ГБ — уже выглядит подозрительно. Переходим в код и смотрим декларацию `CompactDominatorTree2+Node`:
```
public sealed class Node
{
public DfsNumber DfsNumber { get; } // 8 bytes
public TypeId ObjectsType { get; } // 4 bytes
public int ObjectsCount { get; } // 4 bytes
public int RetainedObjectsCount { get; } // 4 bytes
public ulong RetainedBytes { get; } // 8 bytes
public bool IsContainedInSet { get; } // 1 byte
public Node Parent { get; } // 8 bytes
internal JetArray ChildrenImpl { get; } // 8 bytes
// несущественные для понимания детали опущены
}
```
Полезной нагрузки здесь 45 байт, но с учетом заголовка объекта и выравнивания экземпляр `Node` занимает 72 байта, а удерживает в среднем по 192 байта. Чтобы посмотреть детали, переключаемся на [экземпляры](https://www.jetbrains.com/help/dotmemory/Instances.html) и фильтруем по «CompactDominatorTree2+Node !g !a» («!g» исключает дженерики, «!a» исключает массивы). Открываем первый попавшийся экземпляр:
Смотрим детали выбранного экземпляра:
«…Как же это вышло?... Понимаю! Накладные расходы! Бюрократический аппарат съел все ~~байты~~ деньги». (с) О.Бендер
Теперь видно, что это накладные расходы на хранение дочерних узлов в виде `JetMutableArray` — очевидно не самый оптимальный способ хранения для большого дерева. Естественно, первое, что приходит в голову — бежать разбираться с выравниванием и оптимизировать хранение дочерних узлов. Например, можно свести их к одному стандартному массиву. Но мы решили пойти более радикальным путем.
Объемные структуры данных — не редкость для dotMemory. Например, граф объектов мы храним в виде списка смежности, реализованного через два массива struct-ов, ссылающихся друг на друга при помощи целочисленных индексов в этих массивах. Причем в последних версиях мы даже отказались от управляемых массивов и постепенно переходим на собственную реализацию поверх отображаемых в память файлов. Это дает нам минимальные накладные расходы на доступ к элементам (индексация нативной памяти в стиле старого доброго Си), быструю загрузку/сохранение (полностью на уровне ОС) и бесплатную сериализацию/десериализацию. Кроме того, такие массивы могут фрагментарно выгружаться из памяти (без нашего участия), что позволяет освободить физическую память при более-менее последовательном обходе массива.
Применим этот же подход для компактифицированного дерева доминаторов. Попутно мы сделали признак `IsContainedInSet` битовым флагом и отказались от поля `Parent` (оно нигде не использовалось). В итоге узел дерева представляется следующей структурой:
```
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public readonly struct Node
{
public readonly TypeId ObjectsType;
private readonly uint _objectsCount;
public int ObjectsCount => (int)(_objectsCount & 0x7FFFFFFF);
public bool IsContainedInSet => (_objectsCount & 0x80000000) != 0;
public readonly int RetainedObjectsCount;
public readonly ulong RetainedBytes;
public readonly DfsNumber DfsEnter;
public readonly Range Children;
}
```
Можно заметить, что при таком последовательном представлении хватило бы и одной целочисленной ссылки — на первый дочерний узел. Однако мы используем диапазон, потому что в конце нам нужно будет упорядочить дочерние узлы уже построенного дерева по убыванию величины `RetainedBytes` — так удобнее строить sunburst-диаграмму. Например, для представления, изображенного выше, может измениться порядок узлов #1, #2, #3.
Запускаем... Бинго! Теперь пик потребления — всего 12 ГБ. Дерево доминаторов благополучно открывается за 55 мин — дольше, чем хотелось бы, но все же терпимо. Всего снапшот содержит 275 млн объектов, а в компактифицированном дереве 200 млн узлов.
Что ж, весьма приличный результат. В начале нам не хватало 32 ГБ и мы вообще не могли дождаться окончания расчета, а теперь уложились в 12 ГБ и 55 мин. Но… все же осталось чувство неудовлетворенности. 55 мин — это как-то долго. Давайте посмотрим, на что тратится время, с помощью dotTrace:
Не обязательно дожидаться окончания расчетов. Достаточно снять данные для нескольких минут — используем ключ `--timeout=3m`, который автоматически завершит профилирование через 3 минуты. Открываем полученный файл, устанавливаем фильтр на поток, выполняющий нашу задачу (его легко найти, т. к. он полностью загружен долгое время), и смотрим на дерево вызовов:
Вот так неожиданность: `Dictionary.Clear` 92%! Да ладно! Не может же `Clear` так плохо работать на стандартном библиотечном словаре! Оказывается, может — фокус в том, что на самой первой итерации нашего алгоритма словарь расширяется до ~22 тыс. элементов, а дальше элементов обычно не больше пары десятков. При этом сложность `Clear` для словаря зависит от `Capacity` (точнее от `buckets.Length`, который линейно зависит от `Capacity`), а не от `Count`. Получается, что мы каждый раз чистим и без того пустые элементы! Кажется, мы перестарались с оптимизацией, когда решили очищать и переиспользовать словарь.
Тогда возвращаемся на шаг назад и пробуем самое простое — каждый раз выделять новый словарь. Запускаем, засекаем время и-и-и… теперь расчет занимает всего 1 минуту и 46 секунд! Да, нагрузка на GC увеличилась, но она равномерно распределена, и сборщик отлично справляется — в этом можно убедиться с помощью dotTrace.
275 млн объектов, менее 2 минут времени, пиковое потребление памяти — 12 ГБ. Вот это уже действительно достойный результат! Коммитим!
***Сцена после титров***
Чтобы достичь уж совсем полного-преполного удовлетворения, мы решили сравнить время расчета старым и новым алгоритмом на снапшоте сопоставимого объема, но с другой топологией — так, чтобы справлялся и старый алгоритм. Нашли подходящий снапшот, замерили… и вот незадача! Опять сюрприз: хотя вычислительная сложность не поменялась, новый алгоритм оказался в полтора раза медленнее старого. Но это уже другая история...
***UPD***
Статья интереса не вызвала, поэтому второй части не будет. Но для полноты истории приведу здесь краткое резюме.
Сложность алгоритма в терминах *O* действительно не изменилась, но увеличилась константа, которая прячется за *O*. А увеличилась она из-за изменившегося порядка обхода массивов. Если в исходном варианте это был почти последовательный проход, то в новом - произвольный. В результате на порядок вырос показатель CPU cache misses. Нашли с помощью BenchmarkDotNet с включенным `[HardwareCounters(HardwareCounter.CacheMisses)]`. Поскольку порядок обхода - это неотемлемая часть алгоритма, то тут ничего уже не оптимизируешь. Но нам удалось оптимизациями "вокруг" добиться все же сопоставимого времени с исходным алгоритмом. | https://habr.com/ru/post/574722/ | null | ru | null |
# Варианты использования Java ML библиотек совместно с Spring, Docker, Spark, Rapids, CUDA
Введение
--------
В данной статье рассматривается способ использования GPU nVidia с технологией CUDA в Docker-контейнерах для распределенной тренировки моделей машинного обучения на нескольких машинах. Цель статьи - показать вариант использования Big Data Tool Apache Spark в Docker-контейнерах, совместно с акселератором GPU вычислений Rapids на устройствах nVidia CUDA, с применением библиотек DJL, Spark ML, XGBoost, в приложении Spring Boot на Java 8 (требование Rapids), на нескольких машинах под управлением ОС Windows 10 Pro для решения задачи тренировки моделей машинного обучения в распределенной системе. Те же контейнеры в дальнейшем можно использовать в Kubernetes.
Важное условие, из которого вытекают все болезненные решения - все действия выполняются в ОС Windows 10 Pro. Далее в статье будет рассмотрен рассмотрен вариант использования WSL2 (Linux Subsystem for Windows), но прежде важное требование - [новейшие версии Rapids не работают с видеокартами на архитектуре Pascal](https://github.com/rapidsai/cudf/issues/9427), т.е. для запуска примеров в среде Windows требуется видеокарта nVidia на архитектуре Turing (серии 1600, 2000) и выше. Под OC Linux карты на архитектуре Pascal работать будут, рекомендуется запускать примеры ниже на Ubuntu 20.04 (наверняка, Debian 10 так же будет работать), но не выше - [требование Rapids](https://nvidia.github.io/spark-rapids/docs/download.html).
Еще одним важным условием является реализация всех примеров именно на Java. В мире Spark (вместе со Spark ML) более распространен вариант использования Scala. Scala я не знаю, и особого желания изучать нет, а вот желание изучить Spark и ML для собственного развития и решения широкого круга задач имеется. Учитывая, что Scala и Java равнозначны в среде Spark, в отличие от того же Python, и что на Java существует ряд библиотек ML, которые можно использовать совместно со Spark, и принимая во внимание уже имеющийся опыт работы с ним, решение попробовать реализовать несколько примеров не заставило себя ждать.
Код статьи проверен на Windows 10 Pro, GeForce RTX 2060 и 1080 Ti (с последней на Windows не заработало), часть скриншотов сделано во время настройки второй машины с картой GeForce 1650. Предваряя вопрос читателя, почему бы все не сделать на той же Ubuntu 20.04, отвечаю: а) так каждый сможет, вы на винде попробуйте; б) нет технической возможности (Cloud не вариант - дорогие машины с GPU).
Целевая схема запуска представлена на рисунке ниже:
Т.е. имеется от двух до n нод, на каждой из которых от 1 до m GPU устройств, docker runtime с контейнером Spark worker, из которого доступны GPU.
Hardware и software слои описываются схемой:
Докер позволяет запускать множество контейнеров с различными приложениями:
Это подходит для задач распределенной тренировки моделей ML в инфраструктуре Apache Spark: в настоящей статье рассматривается пример запуска Standalone кластера Apache Spark с одним Master узлом, двумя Worker узлами на разных машинах, и Spring Boot Java 8 приложением с использованием библиотек DJL, Spark ML и XGBoost в отдельном контейнере (спойлер - заработало не все, и не заработает без машины с Linux).
Интересным является возможность использования Embedded устройств nVidia для IoT-устройств.
Весь нижеописанный код доступен в [репозитории GitLab](https://gitlab.com/AlexPit/java-ml-spark-example).
Подготовка окружения
--------------------
Все нижеследующие действия выполняются на Windows 10 Pro. Важно выполнять именно на конфигурации не ниже Pro, и сборке Windows 10 Build 19043.1263 (21H1).
WSL, Docker и CUDA будут установлены в рамках данной статьи.
Рекомендуемая версия WSL 5.10.16.3+;
Docker 19.03+.
Рекомендуется установить Windows Terminal для открытия множества вкладок терминала: PowerShell, cmd, Ubuntu.
### nVidia driver, CUDA
Убедитесь, что версия nVidia CUDA не ниже 11.7. Драйвер, который содержит данную версию, на момент написания статьи имеет версию 516.40.
Проверить версию драйвера и CUDA можно, открыв Powershell (лучше сразу открывать от имени администратора, но это требование для будущих действий) и выполнив команду
```
nvidia-smi
```
### WSL - Windows Subsystem for Linux
Для того, чтобы использовать GPU в Docker-контейнерах, необходимо установить ПО от nVidia (см ниже), которое требует установки WSL2.
Если на ПК пользователя WSL не установлена, то можно установить командой ниже:
```
wsl --install
```
Если WSL уже установлена, лучше обновиться до последней версии и проверить версию Ubuntu, должна быть 2.
Требуется перезагрузка. После перезапуска установится Ubuntu для Windows в отдельном окне
По окончанию установки можно проверить версию WSL в Powershell
```
wsl -l -v
```
В случае, если версия Ubuntu 1, следует ее обновить
```
wsl --set-version Ubuntu-20.04 2
```
### Docker Desktop
Следует установить Docker Desktop, если еще не установлен. Если установлен, рекомендуется обновить.
На момент установки на систему без Docker Desktop, моему выборы были представлены следующие настройки:
Я оставил оба чекбокса активированными. По окончанию установки требуется перезагрузка. В настройках необходимо убедиться, что чекбокс “Use WSL 2 based engine” активирован.
Apply & Restart.
Можно проверить, что в wsl появились новые записи в списке
Проверить работу Docker можно командой
```
docker run -d -p 5000:5000 --restart=always --name registry registry:2
```
Установится локальный docker registry, который будет полезен в последующей работе.
```
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
745b50d66906 registry:2 "/entrypoint.sh /etc…" 2 minutes ago Up 2 minutes 0.0.0.0:5000->5000/tcp registry
```
### CUDA Support for WSL 2
Ключевым моментом является поддержка работы CUDA в докер-контейнерах, для этого у nVidia есть [решение](https://docs.nvidia.com/cuda/wsl-user-guide/index.html).
Выполнить следующие шаги в PowerShell под именем администратора:
```
wsl
sudo -i
apt-key del 7fa2af80
wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin
mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda-repo-wsl-ubuntu-11-7-local_11.7.0-1_amd64.deb
# see the output of the previosly command
cp /var/cuda-repo-wsl-ubuntu-11-7-local/cuda-B81839D3-keyring.gpg /usr/share/keyrings/
apt-get update
apt-get -y install cuda
```
Теперь нужно проверить в отдельном окне PowerShell работу тестового контейнера nVidia с флагом benchmark:
```
docker run --gpus all nvcr.io/nvidia/k8s/cuda-sample:nbody nbody -gpu -benchmark
```
Если вывод содержит нечто подобное, все шаги выполнены корректно и можно продолжать работу.
Если имели место ошибки, рекомендуется обратиться к страницам документации nVidia [здесь](https://docs.nvidia.com/cuda/wsl-user-guide/index.html) и [здесь](https://forums.developer.nvidia.com/t/guide-to-run-cuda-wsl-docker-with-latest-versions-21382-windows-build-470-14-nvidia/178365) для их решения.
Подготовка образов и запуск контейнеров
---------------------------------------
Учитывая, что для работы Rapids необходимо использовать Java 8, следующие шаги по подготовке всех необходимых Docker образов, а в последующем и самих приложений, будут выполнены исходя из данного требования.
### Базовый образ для приложений и Spark Workers
Первоначально необходим самый базовый образ. Ниже листинг Dockerfile.
Используется базовый образ Ubuntu 20.04 с CUDA 11.7.0 из [репозитория образов nVidia](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/cuda/tags). Доступный образ с Ubuntu версии 22.04 не подошел по причине совместимости всех компонентов системного ПО, необходимого для запуска прикладного ПО.
```
FROM nvcr.io/nvidia/cuda:11.7.0-devel-ubuntu20.04
ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en' LC_ALL='en_US.UTF-8'
ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt install -y bash tini libc6 libpam-modules libnss3 procps nano iputils-ping net-tools
RUN apt-get update && \
apt-get install -y openjdk-8-jdk && \
apt-get install -y ant && \
apt-get clean && \
rm -rf /var/lib/apt/lists/* && \
rm -rf /var/cache/oracle-jdk8-installer;
# Fix certificate issues
RUN apt-get update && \
apt-get install -y ca-certificates-java && \
apt-get clean && \
update-ca-certificates -f && \
rm -rf /var/lib/apt/lists/* && \
rm -rf /var/cache/oracle-jdk8-installer;
# Setup JAVA_HOME, this is useful for docker commandline
ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64/
RUN export JAVA_HOME
CMD ["tail", "-f", "/dev/null"]
```
Используемым в образе JDK является openjdk8, что соответствует требованиям Rapids и не испытывает проблем с лицензионным соглашением Oracle JDK. Также в образ устанавливается набор приложений для дебага.
Инструкция CMD не обязательна, но удобна для отладки.
Стоит заметить, что первоначально используется базовый образ nVidia с пометкой “devel” - тестирование происходило именно на нем, чтобы исключить возможные ошибки, связанные с недостаточностью компонентов.
При этом, имеется образ:
отличие от devel - отсутствие “nvcc”.
Собирается образ командой:
```
docker build -f Dockerfile-cuda-java8 -t localhost:5000/cuda-jdk8:v1 .
```
> Обращаю внимание, что на моей локальной машине имеется контейнер с репозиторием образов Docker, мне удобно при работе с локальным кластером Kubernetes указывать в манифесте свои образа из localhost:5000, и загружать их, не используя внешние репозитории.
>
>
Запускается контейнер командой:
```
docker run --gpus all --name=cuda-jdk8 -it -d localhost:5000/cuda-jdk8:v1
```
Примечание: важным флагом является “--gpus”, которому передается значение “all” - благодаря данному флагу контейнеру доступны все ресурсы gpu локальной машины.
Проверить работоспособность базового образа можно путем выполнения в контейнере двух команд:
```
$ nvidia-smi
Sun Jul 10 13:58:20 2022
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 515.48.07 Driver Version: 516.40 CUDA Version: 11.7 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 NVIDIA GeForce ... On | 00000000:0B:00.0 On | N/A |
| 0% 42C P8 20W / 250W | 1241MiB / 11264MiB | 4% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| No running processes found |
+-----------------------------------------------------------------------------+
$ nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2022 NVIDIA Corporation
Built on Tue_May__3_18:49:52_PDT_2022
Cuda compilation tools, release 11.7, V11.7.64
Build cuda_11.7.r11.7/compiler.31294372_0
```
При использовании базового образа “runtime” `nvcc --version` выведет ошибку, так как nvcc отсутствует в данном образе.
Если нет похожего вывода какой-либо из команд, следует вернуться к предыдущим разделам и проверить корректность выполнения всех шагов.
### Образ Spark Worker
Следующий шаг - подготовка образа Spark Worker.
> Здесь следует отметить, что в данной статье рассматривается запуск кластера Spark как Standalone кластера, без менеджера ресурсов. Spark Master запускается на локальной виртуальной машине (у меня уже имелся настроенный мастер на виртуальной машине для тестирования работы Spark с Cassandra в рамках другой задачи, которая в настоящей статье не рассматривается), и к ней подключается Spark Worker в Docker контейнере. Полезность данного теста состоит в том, что:
>
> а) тестируется работоспособность GPU-нагрузки в контейнерах;
>
> б) для последующей работы остается пример Standalone кластера и Docker-образ для Kubernetes кластера.
>
> Следует так же отметить, что образ Spark может быть использован и для запуска контейнера с Spark Master.
>
> Кратко обо всех способах запуска Spark, как в локальном и standalone режимах, так с использованием Kubernetes, можно прочесть [здесь](https://stackoverflow.com/questions/31806188/standalone-manager-vs-yarn-vs-mesos), а о различиях менеджеров Yarn и Mesos можно прочесть [здесь](http://www.quora.com/How-does-YARN-compare-to-Mesos), или изучить вопрос самостоятельно.
>
>
#### Подготовка
Необходимо загрузить архив со Spark с [официального сайта](https://spark.apache.org/downloads.html). Ввиду проблем с совместимостью именно в моей программно-аппаратной конфигурации, мне пришлось использовать версию 3.2.1, хотя, на момент тестирования (и написания данной статьи) уже доступна версия 3.3.0.
Распаковать содержимое в директорию spark (или воспользоваться подготовленными примерами из репозитория).
После распаковки архива директория spark должна иметь следующий вид:
#### Rapids resources
За исключением директории rapids. Ее нужно создать и загрузить в нее файлы \*.jar с [сайта Rapids](https://nvidia.github.io/spark-rapids/docs/download.html). На момент написания статьи доступен релиз 22.06.0, который совмещает в себе два представленных на скриншоте файла. Но на момент тестирования свежей версией была 22.04.0.
Сначала я хотел написать, что оставляю этот момент без изменений, однако, когда я тестировал Spring сервис перед публикацией статьи на 1080 Ti, я все же попробовал использовать 22.06.0. На 1080 Ti все равно не заработало, однако последняя версия вывела сообщение для дебага, благодаря которому я узнал, что новая версия Rapids в связке с Pascal и WSL2 работать не будет. Читатель может использовать любую версию из упомянутых, а в репозитории с примером остается 22.06.0.
Скрипт [getGpusResources.sh](https://github.com/apache/spark/blob/master/examples/src/main/scripts/getGpusResources.sh) нужен для обнаружения GPU ресурсов:
```
#!/usr/bin/env bash
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This script is a basic example script to get resource information about NVIDIA GPUs.
# It assumes the drivers are properly installed and the nvidia-smi command is available.
# It is not guaranteed to work on all setups so please test and customize as needed
# for your environment. It can be passed into SPARK via the config
# spark.{driver/executor}.resource.gpu.discoveryScript to allow the driver or executor to discover
# the GPUs it was allocated. It assumes you are running within an isolated container where the
# GPUs are allocated exclusively to that driver or executor.
# It outputs a JSON formatted string that is expected by the
# spark.{driver/executor}.resource.gpu.discoveryScript config.
#
# Example output: {"name": "gpu", "addresses":["0","1","2","3","4","5","6","7"]}
ADDRS=`nvidia-smi --query-gpu=index --format=csv,noheader | sed -e ':a' -e 'N' -e'$!ba' -e 's/\n/","/g'`
echo {\"name\": \"gpu\", \"addresses\":[\"$ADDRS\"]}
```
#### Datasets
Еще одна директория - datasets. В ней хранятся файлы \*.csv и \*.parquet, которые в последующем будут использованы в приложениях как обучающие и валидирующие датасеты. Взять можно [здесь](https://github.com/NVIDIA/spark-rapids-examples/blob/branch-22.06/datasets/taxi-small.tar.gz).
#### Spark config files
Пройдемся по всем директориям, в которых нужно внести изменения.
Все рабочие конфиги представлены в репозитории примера.
#### Директория conf
Директория содержит шаблоны конфигов. Задействовать каждый можно путем копирования шаблона в ту же директорию и удаления “.template” в имени файла:
Таким образом, редактируется файл **spark-defaults.conf**:
```
spark.master spark://192.168.5.129:7077
spark.executor.memory 2g
spark.executor.cores 4
spark.worker.resource.gpu.amount 1
spark.worker.resource.gpu.discoveryScript /opt/sparkRapidsPlugin/getGpusResources.sh
spark.executorEnv.NCCL_DEBUG INFO
```
**spark-env.sh**:
```
#!/usr/bin/env bash
# Options for the daemons used in the standalone deploy mode
SPARK_MASTER_HOST="192.168.5.129"
SPARK_MASTER_PORT="7077"
SPARK_WORKER_OPTS="-Dspark.worker.resource.gpu.amount=1 -Dspark.worker.resource.gpu.discoveryScript=/opt/sparkRapidsPlugin/getGpusResources.sh -Dspark.rapids.memory.pinnedPool.size=2G -Dspark.executor.resource.gpu.amount=1 -Dspark.executorEnv.NCCL_DEBUG=INFO""
```
#### Docker
Следуя [документации Spark](https://spark.apache.org/docs/latest/running-on-kubernetes.html), следующим шагом должен быть запуск скрипта для создания Docker-образов:
```
$ ./bin/docker-image-tool.sh -r -t my-tag build
```
Подготовленный Dockerfile необходимо изменить до вида:
```
ARG java_image_tag=11-jre-slim
# проставляется в команде docker-build
FROM ${java_image_tag}
ARG spark_uid=1001
ARG UID_GID=1001
ENV UID=${UID_GID}
ENV GID=${UID_GID}
ENV SPARK_RAPIDS_DIR=/opt/sparkRapidsPlugin
ENV SPARK_RAPIDS_PLUGIN_JAR=${SPARK_RAPIDS_DIR}/rapids-4-spark_2.12-22.06.0.jar
# old
#ENV SPARK_CUDF_JAR=${SPARK_RAPIDS_DIR}/cudf-22.04.0-cuda11.jar
#ENV SPARK_RAPIDS_PLUGIN_JAR=${SPARK_RAPIDS_DIR}/rapids-4-spark_2.12-22.04.0.jar
RUN set -ex && \
sed -i 's/http:\/\/deb.\(.*\)/https:\/\/deb.\1/g' /etc/apt/sources.list && \
apt-get update && \
ln -s /lib /lib64 && \
apt install -y bash tini libc6 libpam-modules libnss3 procps nano iputils-ping net-tools iptables sudo \
wget software-properties-common build-essential libnss3-dev zlib1g-dev libgdbm-dev libncurses5-dev \
libssl-dev libffi-dev libreadline-dev libsqlite3-dev libbz2-dev python3 && \
mkdir -p /opt/spark && \
mkdir -p /opt/spark/examples && \
mkdir -p /opt/spark/conf && \
mkdir -p /opt/spark/work-dir && \
mkdir -p /opt/sparkRapidsPlugin && \
touch /opt/spark/RELEASE && \
rm /bin/sh && \
ln -sv /bin/bash /bin/sh && \
echo "auth required pam_wheel.so use_uid" >> /etc/pam.d/su && \
chgrp root /etc/passwd && chmod ug+rw /etc/passwd
RUN apt-get install libnccl2 libnccl-dev -y --allow-change-held-packages && rm -rf /var/cache/apt/*
COPY jars /opt/spark/jars
COPY rapidsNew /opt/sparkRapidsPlugin
# old
#COPY rapids /opt/sparkRapidsPlugin
COPY bin /opt/spark/bin
COPY sbin /opt/spark/sbin
COPY conf /opt/spark/conf
COPY kubernetes/dockerfiles/spark/entrypoint.sh /opt/
COPY kubernetes/dockerfiles/spark/decom.sh /opt/
COPY kubernetes/tests /opt/spark/tests
COPY data /opt/spark/data
COPY datasets /opt/spark/
ENV SPARK_HOME /opt/spark
WORKDIR /opt/spark/work-dir
RUN chmod g+w /opt/spark/work-dir
RUN chmod a+x /opt/decom.sh
# USER
RUN groupadd --gid $UID appuser && useradd --uid $UID --gid appuser --shell /bin/bash --create-home appuser
RUN mkdir /var/logs && chown -R appuser:appuser /var/logs
RUN mkdir /opt/spark/logs && chown -R appuser:appuser /opt/spark/
RUN chown -R appuser:appuser /tmp
RUN ls -lah /home/appuser
RUN touch /home/appuser/.bashrc
RUN echo -e '\
export SPARK_HOME=/opt/spark\n\
export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin\
' > /home/appuser/.bashrc
RUN chown -R appuser:appuser /home/appuser
# Specify the User that the actual main process will run as
USER ${spark_uid}
EXPOSE 4040
EXPOSE 8081
ENTRYPOINT [ "/opt/entrypoint.sh" ]
```
entrypoint.sh:
```
#!/bin/bash
SPARK_DRIVER_BIND_ADDRESS=192.168.5.129:7077 # spark master address
NCCL_DEBUG=INFO
source ~/.bashrc
start-worker.sh spark://$SPARK_DRIVER_BIND_ADDRESS
tail -f /dev/null
```
`SPARK_DRIVER_BIND_ADDRESS` - адрес Spark Master, в моем случае - это адрес локальной виртуальной машины. Для дебага возможных неисправностей в ходе работы с библиотекой nccl следует выставить уровень дебага INFO. Командой `start-worker.sh spark://$SPARK_DRIVER_BIND_ADDRESS` запускается воркер, подключаясь к мастеру.
Исходники kubernetes/dockerfiles/Dockerfile и содержимое той же директории можно найти в репозитории примера.
Сборка образа и запуск контейнера:
```
cd spark
docker build -f kubernetes/dockerfiles/spark/Dockerfile --build-arg java_image_tag=localhost:5000/cuda-jdk8:v1 -t localhost:5000/cuda-jdk8-spark:v1 .
docker run --memory="6g" --cpus="4" --gpus all --name=cuda-jdk8-spark -p 8081:8081 -it -d localhost:5000/cuda-jdk8-spark:v1
```
Следует убедиться, что в образ установилась библиотека nccl корректной версии, для чего нужно экзекнуться в созданный контейнер Spark Worker и выполнить:
```
$ dpkg -l | grep nccl
ii libnccl-dev 2.12.12-1+cuda11.7 amd64 NVIDIA Collective Communication Library (NCCL) Development Files
ii libnccl2 2.12.12-1+cuda11.7 amd64 NVIDIA Collective Communication Library (NCCL) Runtime
```
на момент написания статьи и тестирования корректной версией является `2.12.12-1+cuda11.7`. В версиях ниже может встречаться проблема с запуском задач XGBoost, т.к. nccl не может найти сетевое устройство по причине того, что в докер-контейнере оно является виртуальным.
Проверяем доступность воркера, путем открытия его WEB GUI по адресу localhost:8081 (в соответствии с командой docker run выше):
Видим, что помимо Cores и Memory, доступен ресурс Resources: gpu. На моей локальной машине одно устройство, и его id обозначен в массиве как “0”.
Проверяем WEB GUI мастера (адрес моей локальной виртуальной машины <http://192.168.5.129:8080/>):
Spark Worker, запущенный в контейнере, появился в списке Workers. Можно переходить к приложению.
Разработка и запуск приложения
------------------------------
В текущем разделе рассматривается пример работы простого веб-сервиса, являющимся так же Spark Driver. Приложение будет иметь 3 HTTP Endpoint’a, на каждом будет доступен пример одной из библиотек: DJL, Spark ML, XGBoost.
### Каркас приложения
В виде каркаса приложения используется Spring Boot с зависимость spring-boot-starter-web, используемый JDK - OpenJDK 8 (держим в уме требование Rapids). Я создаю новый проект в тот момент, когда пишу эту статью, поэтому финальный результат также должен заработать у читателя при условии выполнения предварительных шагов, описанных выше.
Структура проекта:
Файл pom.xml можно посмотреть в репозитории, я остановлюсь на важном моменте. Для работы XGBoost на Windows с WSL2 в Docker контейнере проведено детальное обследование проблемы в [GitHub Issue](https://github.com/dmlc/xgboost/issues/7994).
На данный момент версия библиотеки XGBoost, используемая в данном примере, не имеет релизной версии, поэтому в Maven central она отсутствует. Для загрузки библиотеки нужно добавить в pom.xml репозиторий с версиями SNAPSHOT:
```
XGBoost4J Snapshot Repo
XGBoost4J Snapshot Repo
https://s3-us-west-2.amazonaws.com/xgboost-maven-repo/snapshot/
```
Однако, есть нюанс. Доступа с Российских и Казахстанских IP (с других не проверялось) к данному репо с недавнего времени нет. Варианты: либо VPN, либо воспользоваться репозиторием проекта и загрузить джарники xgboost4j-gpu\_2.12-2.0.0-SNAPSHOT.jar и xgboost4j-spark-gpu\_2.12-2.0.0-SNAPSHOT.jar в локальный m2 репозиторий:
Также эти джарники необходимо загрузить в директорию jars проекта (см. скрин выше). Данные \*.jar файлы будут переданы в Spark Executor как зависимости для запуска кода драйвера. Список таких файлов описывается в `SparkConfiguration`:
```
package com.mlwebservice.config;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.SparkSession;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.net.InetAddress;
import java.net.UnknownHostException;
@Configuration
public class SparkConfiguration {
@Value("${spring.application.name}")
private String appName;
@Value("${spark.masterHost}")
private String masterHost;
@Bean
public JavaSparkContext javaSparkContext() throws UnknownHostException {
String host = InetAddress.getLocalHost().getHostAddress();
SparkConf sparkConf = new SparkConf(true)
.setAppName(appName)
.setMaster("spark://" + masterHost)
.setJars(new String[]{
"service.jar",
"jars/config-1.4.1.jar",
"jars/rapids-4-spark_2.12-22.06.0.jar",
"jars/spark-nlp_2.12-3.4.1.jar",
"jars/xgboost4j-gpu_2.12-2.0.0-SNAPSHOT.jar",
"jars/xgboost4j-spark-gpu_2.12-2.0.0-SNAPSHOT.jar"})
// Spark settings
.set("spark.worker.cleanup.enabled", "true")
// executors
.set("spark.executor.cores", "4")
.set("spark.executor.memory", "2g")
.set("spark.executor.resource.gpu.amount", "1")
.set("spark.executorEnv.NCCL_DEBUG", "INFO")
.set("spark.task.resource.gpu.amount", "1")
// driver
.set("spark.ui.enabled", "true")
.set("spark.ui.port", "4040")
.set("spark.driver.host", host)
.set("spark.driver.bindAddress", host)
.set("spark.driver.blockManager.port", "45029")
.set("spark.driver.port", "33139")
.set("spark.port.maxRetries", "16")
.set("spark.driver.maxResultSize", "2g")
.set("spark.executor.heartbeatInterval", "200000")
.set("spark.network.timeout", "300000")
// rapids
.set("spark.rapids.memory.gpu.pooling.enabled", "false")
.set("spark.rapids.memory.gpu.minAllocFraction", "0.0001")
.set("spark.rapids.memory.gpu.reserve", "2")
.set("spark.rapids.sql.enabled", "true")
.set("spark.sql.adaptive.enabled", "false")
.set("spark.rapids.sql.explain", "ALL")
.set("spark.rapids.sql.hasNans", "false")
.set("spark.rapids.sql.csv.read.float.enabled", "true")
.set("spark.rapids.sql.castFloatToString.enabled", "true")
.set("spark.rapids.sql.csv.read.double.enabled", "true")
.set("spark.rapids.sql.castDoubleToString.enabled", "true")
.set("spark.rapids.sql.exec.CollectLimitExec", "true")
.set("spark.locality.wait", "0s")
.set("spark.sql.files.maxPartitionBytes", "512m")
.set("spark.plugins", "com.nvidia.spark.SQLPlugin")
.set("spark.driver.extraClassPath", "/opt/sparkRapidsPlugin/rapids-4-spark_2.12-22.06.0.jar");
return new JavaSparkContext(sparkConf);
}
@Bean
public SparkSession sparkSession(JavaSparkContext context) {
return SparkSession.builder()
.master("spark://" + masterHost)
.appName(appName)
.config(context.getConf())
.config("spark.executorEnv.NCCL_DEBUG", "INFO")
.getOrCreate();
}
}
```
Параметров конфигурации Spark очень много, подробнее с ними можно ознакомиться на странице [Configuration - Spark 3.3.0 Documentation](https://spark.apache.org/docs/latest/configuration.html) .
Контроллер максимально простой, он содержит три сервиса, каждый сервис реализует по 1-2 метода каждой библиотеки. Обращаю внимание, что данный контроллер является инструментом запуска соответствующего примера, сделанный в угоду скорости и самому факту, что несколько технологий можно объединить в приложении Spring, и никак не претендует на использование приложения в продуктивной среде. Для реального приложения здесь должны быть как минимум другие HTTP глаголы, обработчики сообщений, информативные DTO, асинхронные операции, брокеры сообщений для потоков данных, реактивщины, вебсокеты и вот это вот все.
```
package com.mlwebservice.controller;
import ai.djl.translate.TranslateException;
import com.mlwebservice.service.DJLService;
import com.mlwebservice.service.RapidsService;
import com.mlwebservice.service.SparkMLService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
@RestController
@RequestMapping("/")
@RequiredArgsConstructor
public class MLController {
private final DJLService djlService;
private final SparkMLService sparkMLService;
private final RapidsService rapidsService;
@GetMapping("/djl")
public ResponseEntity djl() {
try {
djlService.mlWork();
} catch (TranslateException | IOException e) {
return ResponseEntity.status(500).body(e.getMessage());
}
return ResponseEntity.ok().build();
}
@GetMapping("/forest")
public ResponseEntity sparkML() {
sparkMLService.randomForestTest();
return ResponseEntity.ok().build();
}
@GetMapping("/gpu_test")
public ResponseEntity rapidsGpuTest() {
rapidsService.testRapids();
return ResponseEntity.ok().build();
}
@GetMapping("/xgboost")
public ResponseEntity rapidsXGBoost() {
rapidsService.xgBoost();
return ResponseEntity.ok().build();
}
}
```
### Deep Java Library - DJL
Первая библиотека на очереди - [DJL](https://djl.ai/). Это удобная библиотека машинного обучения для языка Java, особенностью которой является зоопарк моделей (Model Zoo), позволяющий получить готовую модель по описываемым параметрам из списка доступных моделей. Также имеется возможность создать свою модель, сохранить на диск и загрузить для дальнейшего использования.
В данном примере рассматривается реализация модели линейной регрессии. К сожалению, в виду архитектурной особенности данной модели, распараллелить процесс ее обучения довольно сложно, и, вероятно, решается в определенных случаях определенными движками, такими как PyTorch. По крайней мере, распараллеливание обучения с помощью Spark модели линейной регрессии мне не попалось, и быстро сам придумать реализацию также не смог. Однако, есть распространенный пример применения Spark в паре с DJL для классификации изображений с использованием модели из Model Zoo, например [данная статья](https://towardsdatascience.com/deep-learning-with-spark-in-deep-java-library-in-10-minutes-923a73704094).
Реализация модели линейной регрессии сделана на основе статей [3.2. Linear Regression Implementation from Scratch — Dive into Deep Learning 0.1.0 documentation](https://d2l.djl.ai/chapter_linear-networks/linear-regression-scratch.html) и [3.3. Concise Implementation of Linear Regression — Dive into Deep Learning 0.1.0 documentation](https://d2l.djl.ai/chapter_linear-networks/linear-regression-djl.html) и отображена в сервисе `DJLService`.
В целях отладки в main методе приложения логируется вызов нескольких методов, с помощью которых легко опознать некорректность конфигурации приложения. При корректной конфигурации должен вывестись лог вида:
```
2022-07-18 19:38:45.346 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : Initializing DJL lib...
2022-07-18 19:38:45.349 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : CPU: cpu()
2022-07-18 19:38:45.349 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : GPU: gpu(0)
2022-07-18 19:38:45.439 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : CUDA available: true
2022-07-18 19:38:45.440 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : CUDA GPU count: 1
OpenJDK 64-Bit Server VM warning: You have loaded library /root/.djl.ai/pytorch/1.11.0-20220510-cu113-linux-x86_64/libtorch_cpu.so which might have disabled stack guard. The VM will try to fix the stack guard now.
It's highly recommended that you fix the library with 'execstack -c ', or link it with '-z noexecstack'.
2022-07-18 19:38:45.739 INFO 1 --- [ main] ai.djl.pytorch.engine.PtEngine : Number of inter-op threads is 8
2022-07-18 19:38:45.740 INFO 1 --- [ main] ai.djl.pytorch.engine.PtEngine : Number of intra-op threads is 8
2022-07-18 19:38:45.740 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : GPU count: 1
2022-07-18 19:38:45.741 INFO 1 --- [ main] c.mlwebservice.MLWebServiceApplication : Engine: PyTorch:1.11.0, capabilities: [
CUDA,
CUDNN,
OPENMP,
MKL,
MKLDNN,
]
PyTorch Library: /root/.djl.ai/pytorch/1.11.0-20220510-cu113-linux-x86\_64
```
Код примера:
```
package com.mlwebservice.service;
import ai.djl.Model;
import ai.djl.metric.Metrics;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDManager;
import ai.djl.ndarray.types.Shape;
import ai.djl.nn.Block;
import ai.djl.nn.ParameterList;
import ai.djl.nn.SequentialBlock;
import ai.djl.nn.core.Linear;
import ai.djl.training.DefaultTrainingConfig;
import ai.djl.training.EasyTrain;
import ai.djl.training.Trainer;
import ai.djl.training.dataset.ArrayDataset;
import ai.djl.training.dataset.Batch;
import ai.djl.training.listener.TrainingListener;
import ai.djl.training.loss.Loss;
import ai.djl.training.optimizer.Optimizer;
import ai.djl.training.tracker.Tracker;
import ai.djl.translate.TranslateException;
import com.mlwebservice.model.DataPoints;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
@Slf4j
@Service
public class DJLService {
public void mlWork() throws TranslateException, IOException {
// Generating the Dataset
NDManager manager = NDManager.newBaseManager();
NDArray trueW = manager.create(new float[]{2, -3.4f});
float trueB = 4.2f;
DataPoints dp = DataPoints.syntheticData(manager, trueW, trueB, 1000);
NDArray features = dp.getX();
NDArray labels = dp.getY();
// Reading dataset
int batchSize = 10;
ArrayDataset dataset = loadArray(features, labels, batchSize, false);
// mini test
Batch testBatch = dataset.getData(manager).iterator().next();
NDArray X = testBatch.getData().head();
NDArray y = testBatch.getLabels().head();
log.info("X = {}", X);
log.info("y = {}", y);
testBatch.close();
// Defining the model
Model model = Model.newInstance("lin-reg");
SequentialBlock net = new SequentialBlock();
Linear linearBlock = Linear.builder().optBias(true).setUnits(1).build();
net.add(linearBlock);
model.setBlock(net);
// Defining the Loss function
Loss l2loss = Loss.l2Loss();
// Defining the Optimization Algorithm
Tracker lrt = Tracker.fixed(0.03f);
Optimizer sgd = Optimizer.sgd().setLearningRateTracker(lrt).build();
// Instantiate Configuration and Trainer
DefaultTrainingConfig config = new DefaultTrainingConfig(l2loss)
.optOptimizer(sgd) // Optimizer (loss function)
.optDevices(manager.getEngine().getDevices(1)) // single GPU
// .addTrainingListeners(TrainingListener.Defaults.logging()); // Logging
.addTrainingListeners(TrainingListener.Defaults.basic()); // Without logging for increase speed
Trainer trainer = model.newTrainer(config);
log.info("Trainer devices: {}", Arrays.toString(trainer.getDevices()));
// Initializing Model Parameters
// First axis is batch size - won't impact parameter initialization
// Second axis is the input size
trainer.initialize(new Shape(batchSize, 2));
// Metrics
Metrics metrics = new Metrics();
trainer.setMetrics(metrics);
// Training
int numEpochs = 30;
long startTime = System.currentTimeMillis();
for (int epoch = 1; epoch <= numEpochs; epoch++) {
// Iterate over dataset
for (Batch batch : trainer.iterateDataset(dataset)) {
// Update loss and evaulator
EasyTrain.trainBatch(trainer, batch);
// Update parameters
trainer.step();
batch.close();
}
// reset training and validation evaluators at end of epoch
trainer.notifyListeners(listener -> listener.onEpoch(trainer));
}
Block layer = model.getBlock();
ParameterList params = layer.getParameters();
NDArray wParam = params.valueAt(0).getArray();
NDArray bParam = params.valueAt(1).getArray();
long endTime = System.currentTimeMillis();
float[] w = trueW.sub(wParam.reshape(trueW.getShape())).toFloatArray();
log.info("Error in estimating w: [{} {}]", w[0], w[1]);
log.info("Error in estimating b: {}", trueB - bParam.getFloat());
log.info("Training time: " + (endTime - startTime) + " ms");
// Save the model
Path modelDir = Paths.get("models/lin-reg");
Path savedDir = Files.createDirectories(modelDir);
model.setProperty("Epoch", Integer.toString(numEpochs)); // save epochs trained as metadata
model.save(modelDir, "lin-reg");
log.info("Model saved in " + savedDir.toAbsolutePath());
}
// Save in the file for later use
public ArrayDataset loadArray(NDArray features, NDArray labels, int batchSize, boolean shuffle) {
return new ArrayDataset.Builder()
.setData(features) // set the features
.optLabels(labels) // set the labels
.setSampling(batchSize, shuffle) // set the batch size and random sampling
.build();
}
}
```
Модель DataPoints:
```
package com.mlwebservice.model;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDManager;
import ai.djl.ndarray.types.DataType;
import ai.djl.ndarray.types.Shape;
public class DataPoints {
private final NDArray x;
private final NDArray y;
public DataPoints(NDArray x, NDArray y) {
this.x = x;
this.y = y;
}
public NDArray getX() {
return x;
}
public NDArray getY() {
return y;
}
// Generate y = X w + b + noise
public static DataPoints syntheticData(NDManager manager, NDArray w, float b, int numExamples) {
NDArray x = manager.randomNormal(new Shape(numExamples, w.size()));
NDArray y = x.matMul(w).add(b);
// Add noise
y = y.add(manager.randomNormal(0, 0.01f, y.getShape(), DataType.FLOAT32));
return new DataPoints(x, y);
}
}
```
Результат выполнения:
```
2022-07-18 20:29:27.461 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : X = ND: (10, 2) gpu(0) float32
[[ 0.7017, -0.7652],
[ 2.495 , -0.3341],
[-2.175 , -0.452 ],
[ 1.1075, 0.8347],
[-1.8369, -0.7469],
[ 0.5647, 2.1323],
[-0.2754, 0.3807],
[ 0.2902, 1.5136],
[-0.5902, 0.6777],
[ 0.4059, -1.0304],
]
2022-07-18 20:29:27.473 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : y = ND: (10) gpu(0) float32
[ 8.1976, 10.324 , 1.3922, 3.5564, 3.0556, -1.9248, 2.3501, -0.361 , 0.7023, 8.4904]
2022-07-18 20:29:27.491 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : Trainer devices: [gpu(0)]
2022-07-18 20:29:34.665 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : Error in estimating w: [-4.7445297E-5 -1.2493134E-4]
2022-07-18 20:29:34.670 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : Error in estimating b: 1.9073486E-4
2022-07-18 20:29:34.670 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : Training time: 7112 ms
2022-07-18 20:29:34.676 INFO 1 --- [nio-9090-exec-1] com.mlwebservice.service.DJLService : Model saved in /usr/src/app/models/lin-reg
```
### Spark ML
Существует замечательная [документация для начинающих от nVidia](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/predictive-analytics-spark-machine-learning/) по работе со Spark ML на примере модели Random Forest. Учитывая специфику данной модели, процесс обучения можно распараллелить на несколько исполнителей, а затем пользоваться либо средним значением в случае решения задач регрессии, либо голосованием по большинству в случае решения задач классификации. Подробнее можно почитать [на хабре](https://habr.com/ru/company/ods/blog/324402/), в [документации Spark](https://spark.apache.org/docs/latest/ml-classification-regression.html#random-forests), примеры кода Spark ML также можно посмотреть [в документации](https://spark.apache.org/docs/latest/mllib-ensembles.html#random-forests).
В данном примере понадобятся датасеты для тренировки и валидации, можно взять [отсюда](https://github.com/NVIDIA/spark-rapids-examples/blob/branch-22.06/datasets/taxi-small.tar.gz), либо воспользоваться кодом репозитория. Отмечу, в данном разделе не полностью переписан пример из [статьи nVidia по Spark ML](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/predictive-analytics-spark-machine-learning/), а скорее является реализацией задачи из [статьи nVidia по XGBoost](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/tutorial-gpu-accelerated-xgboost/), но с применением Random Forest из Spark ML. Датасеты копируются в сценарии Dockerfile, а в сервисе пути к ним хардкодятся (пример же, можно себе позволить).
Обращаю внимание: в статье по Spark ML говорится, что только XGBoost поддерживает GPU-ускорение в Spark ML. Вполне может быть, что документация устарела (как писали в одном из Issue на GitHub) и в данный момент, так как в [документации Rapids](https://nvidia.github.io/spark-rapids/docs/additional-functionality/ml-integration.html) указывается репозиторий с еще как минимум [одним примером](https://github.com/NVIDIA/spark-rapids-examples/tree/branch-22.06/examples/ML+DL-Examples/Spark-cuML/pca) для [алгоритма Principal component analysis (PCA)](https://spark.apache.org/docs/latest/mllib-dimensionality-reduction#principal-component-analysis-pca).
Код сервиса:
```
package com.mlwebservice.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.spark.ml.Pipeline;
import org.apache.spark.ml.PipelineStage;
import org.apache.spark.ml.evaluation.RegressionEvaluator;
import org.apache.spark.ml.feature.StandardScaler;
import org.apache.spark.ml.feature.VectorAssembler;
import org.apache.spark.ml.param.ParamMap;
import org.apache.spark.ml.regression.RandomForestRegressor;
import org.apache.spark.ml.tuning.CrossValidator;
import org.apache.spark.ml.tuning.CrossValidatorModel;
import org.apache.spark.ml.tuning.ParamGridBuilder;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.springframework.stereotype.Service;
import static org.apache.spark.sql.functions.col;
@Slf4j
@Service
@RequiredArgsConstructor
public class SparkMLService {
private final SparkSession session;
public void randomForestTest() {
String trainPath = "/opt/spark/train/train.parquet";
//test
String evalPath = "/opt/spark/eval/eval.parquet";
Dataset tdf = session.read().parquet(trainPath);
Dataset edf = session.read().parquet(evalPath);
String labelName = "fare\_amount";
String[] featureColumns = {"passenger\_count", "trip\_distance", "pickup\_longitude", "pickup\_latitude", "rate\_code",
"dropoff\_longitude", "dropoff\_latitude", "hour", "day\_of\_week", "is\_weekend", "h\_distance"};
VectorAssembler assembler = new VectorAssembler()
.setInputCols(featureColumns)
.setOutputCol("rawfeatures");
StandardScaler standardScaler = new StandardScaler()
.setInputCol("rawfeatures")
.setOutputCol("features")
.setWithStd(true);
RandomForestRegressor regressor = new RandomForestRegressor()
.setLabelCol(labelName)
.setFeaturesCol("features");
Pipeline pipeline = new Pipeline().setStages(new PipelineStage[]{assembler, standardScaler, regressor});
ParamMap[] paramGrid = new ParamGridBuilder()
.addGrid(regressor.maxBins(), new int[]{100, 200})
.addGrid(regressor.maxDepth(), new int[]{2, 7, 10})
.addGrid(regressor.numTrees(), new int[]{5, 20})
.build();
RegressionEvaluator evaluator = new RegressionEvaluator()
.setLabelCol(labelName)
.setPredictionCol("prediction")
.setMetricName("rmse");
CrossValidator crossvalidator = new CrossValidator()
.setEstimator(pipeline)
.setEvaluator(evaluator)
.setEstimatorParamMaps(paramGrid)
.setNumFolds(3);
CrossValidatorModel pipelineModel = crossvalidator.fit(tdf);
ParamMap[] bestEstimatorParamMap = pipelineModel.getEstimatorParamMaps();
log.info("best params map {}", bestEstimatorParamMap);
Dataset predictions = pipelineModel.transform(edf);
Dataset result = predictions.withColumn("error", col("prediction").minus(col(labelName)));
result.select(labelName, "prediction", "error").show();
result.describe(labelName, "prediction", "error").show();
RegressionEvaluator maevaluator = new RegressionEvaluator()
.setLabelCol(labelName)
.setMetricName("mae");
log.info("mae evaluation: {}", maevaluator.evaluate(predictions));
RegressionEvaluator rmsevaluator = new RegressionEvaluator()
.setLabelCol(labelName)
.setMetricName("rmse");
log.info("rmse evaluation: {}", rmsevaluator.evaluate(predictions));
}
}
```
### Rapids и XGBoost
Последним примером является реализация примера из [статьи nVidia по XGBoost](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/tutorial-gpu-accelerated-xgboost/), который использует и Spark, и Rapids вместе. Данный пример является самым интересным, так как обеспечивает действительно лучшую скорость вычислений по сравнению со Spark ML Random Forest.
Кроме того, в [документации Rapids первым примером](https://nvidia.github.io/spark-rapids/docs/get-started/getting-started-on-prem.html#example-join-operation) рассматривается операция Join двух датафреймов из 10 млн чисел. Данный пример также реализован в тестовом методе сервиса `RapidsService`:
```
@Slf4j
@Service
@RequiredArgsConstructor
public class RapidsService {
private final SparkSession session;
public void testRapids() {
int capacity = 1000000;
List list = new ArrayList<>(capacity);
for (long i = 1; i < (capacity + 1); i++) {
list.add(new LongValue(i));
}
Dataset df = session.createDataFrame(list, LongValue.class);
Dataset df2 = session.createDataFrame(list, LongValue.class);
long result = df.select(col("value").as("a"))
.join(df2.select(col("value").as("b")), col("a").equalTo(col("b"))).count();
log.info("count result {}", result);
}
}
@Data
@AllArgsConstructor
public class LongValue implements Serializable {
private static final long serialVersionUID = 1L;
private Long value;
}
```
Пример несколько отличается от своего исходника на Scala, но также обеспечивает вычисления на GPU. DAG представлен на скрине ниже:
Что касается XGBoost, то пример взят из [статьи nVidia](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/tutorial-gpu-accelerated-xgboost/), датасеты [те же](https://github.com/NVIDIA/spark-rapids-examples/blob/branch-22.06/datasets/taxi-small.tar.gz), что и для Random Forest Spark ML, про сам XGBoost можно почитать [здесь](https://en.wikipedia.org/wiki/Gradient_boosting) и [здесь](https://habr.com/ru/company/ods/blog/645887/).
Реализация XGBoost regressor:
```
package com.mlwebservice.service;
import com.mlwebservice.model.LongValue;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import ml.dmlc.xgboost4j.scala.spark.XGBoostRegressionModel;
import ml.dmlc.xgboost4j.scala.spark.XGBoostRegressor;
import org.apache.spark.ml.PredictionModel;
import org.apache.spark.ml.linalg.Vector;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.springframework.stereotype.Service;
import scala.collection.immutable.HashMap;
import scala.collection.immutable.Map;
import java.util.ArrayList;
import java.util.List;
import static org.apache.spark.sql.functions.col;
@Slf4j
@Service
@RequiredArgsConstructor
public class RapidsService {
private final SparkSession session;
public void xgBoost() {
String trainPath = "/opt/spark/train/train.parquet";
//test
String evalPath = "/opt/spark/eval/eval.parquet";
Dataset tdf = session.read().parquet(trainPath);
Dataset edf = session.read().parquet(evalPath);
String labelName = "fare\_amount";
String[] featureColumns = {"passenger\_count", "trip\_distance", "pickup\_longitude", "pickup\_latitude", "rate\_code",
"dropoff\_longitude", "dropoff\_latitude", "hour", "day\_of\_week", "is\_weekend", "h\_distance"};
Map map = new HashMap<>();
map = map.updated("learning\_rate", 0.05);
map = map.updated("max\_depth", 8);
map = map.updated("subsample", 0.8);
map = map.updated("gamma", 1);
map = map.updated("num\_round", 500);
map = map.updated("tree\_method", "gpu\_hist");
map = map.updated("num\_workers", 1);
XGBoostRegressor regressor = new XGBoostRegressor(map);
regressor.setLabelCol(labelName);
regressor.setFeaturesCol(featureColumns);
PredictionModel model = regressor.fit(tdf);
Dataset predictions = model.transform(edf);
Dataset result = predictions.withColumn("error", col("prediction").minus(col(labelName)));
result.select(labelName, "prediction", "error").show();
result.describe(labelName, "prediction", "error").show();
}
}
```
### Запуск
Пора запустить приложение. Для этого необходимо собрать Docker-образ, воспользовавшись Dockerfile:
```
#FROM adoptopenjdk/openjdk8:ubuntu-jre-nightly
FROM localhost:5000/cuda-jdk8:v1
WORKDIR /usr/src/app
ARG JAR_FILE
ARG UID_GID=1001
ENV UID=${UID_GID}
ENV GID=${UID_GID}
RUN mkdir -p jars
COPY jars jars
ENV PYTHONUNBUFFERED=1
RUN apt-get update && apt install -y python-is-python3 wget curl ca-certificates bash libgomp1 && \
rm -rf /var/cache/apt/*
RUN mkdir -p /opt/spark/
COPY spark /opt/spark
COPY ${JAR_FILE} service.jar
RUN groupadd --gid $UID appuser && useradd --uid $UID --gid appuser --shell /bin/bash --create-home appuser
RUN chown -R appuser:appuser /home/appuser && chown -R appuser:appuser /usr/src/app
EXPOSE 4040
EXPOSE 9090
USER $UID
CMD ["java", "-jar", "service.jar"]
```
Обращаю внимание на первую и вторую строки. Если нужно запускать приложение с логикой библиотеки DJL, нужно воспользоваться базовым образом, созданным ранее для Spark. Он содержит необходимое системное ПО для работы с видеокартами nVidia. Учитывая, что при запуске скачивается указанный в зависимостях движок (PyTorch, MXNet, etc), нужно соединение с интернетом и немного больше времени на запуск сервиса. Есть вариант один раз подключить volume к контейнеру и добавить несколько директив COPY в Dockerfile после первого запуска, чтобы не загружать необходимые файлы из интернета, а сразу скопировать в образ.
В случае, если DJL не используется в сервисе, смысла в использовании “тяжелого” базового образа, и можно воспользоваться более “легким” образом, который содержит JRE8, например, тот, что закомментирован в первой строке.
Команды запуска вынесены в скрипт build.sh:
```
#!/bin/bash
mvn clean install -DskipTests=true
docker rmi localhost:5000/ml:1
docker build -f Dockerfile --build-arg JAR_FILE=target/service.jar -t localhost:5000/ml:1 .
docker run --gpus all -p 9090:9090 -p 4040:4040 -p 33139-33155:33139-33155 -p 45029-45045:45029-45045 --name=ML -it -d localhost:5000/ml:1
```
Через некоторое время контейнер должен запуститься, движки и все необходимое для DJL инициализироваться, а в Web UI Spark Master должен появиться сервис в списке запущенных приложений:
В Web UI Spark Worker должен появиться Executor для указанного приложения:
Web UI сервиса также должен стать доступным:
Согласно контроллеру, имеется 4 доступных GET-метода, которые запускают необходимый пример:
<http://localhost:9090/djl>
<http://localhost:9090/forest>
<http://localhost:9090/gpu_test>
<http://localhost:9090/xgboost>
Лог результата выполнения DJL представлен в соответствующем разделе выше, он не очень интересен, нежели Spark Jobs.
При первом запуске логики, которая должна выполняться на Spark, метод выполняется несколько дольше, чем при последующих запусках - есть необходимость некоторого “прогрева” executor'а. Для этого можно запустить метод gpu\_test.
В деталях джобы видим, что она выполнялась чуть более 8и секунд, что, действительно, довольно долго. Последующие вызовы данного метода выполнялись в два раза быстрее (кроме второго - именно в данный момент подвел vmmem, выделив под WSL 25Гб ОЗУ):
Результат выполнения:
```
2022-07-19 14:05:13.856 INFO 1 --- [nio-9090-exec-4] o.a.spark.ml.tree.impl.RandomForest : init: 1.62514E-4
total: 3.192210057
findBestSplits: 3.17661902
chooseSplits: 3.166410779
2022-07-19 14:05:13.864 INFO 1 --- [nio-9090-exec-4] com.mlwebservice.service.SparkMLService : best params map {
rfr_dc03cc8c5712-maxBins: 100,
rfr_dc03cc8c5712-maxDepth: 2,
rfr_dc03cc8c5712-numTrees: 5
}
+------------------+------------------+--------------------+
| fare_amount| prediction| error|
+------------------+------------------+--------------------+
| 11.4|12.422369509009028| 1.0223695090090281|
| 7.4| 7.289954038707909|-0.11004596129209165|
| 5.0| 4.601351052403492| -0.3986489475965076|
| 8.5| 8.773609129887804| 0.27360912988780406|
| 7.4| 7.351427584678662|-0.04857241532133827|
| 3.8| 4.509977888929194| 0.7099778889291946|
| 5.4|6.1300686499042305| 0.7300686499042301|
| 7.4| 5.310782694363023| -2.0892173056369776|
| 5.3| 6.281121521712063| 0.9811215217120628|
| 4.1| 4.320442646467865| 0.22044264646786527|
| 4.2| 4.358399833924078| 0.15839983392407753|
| 23.0| 21.84539235607258| -1.1546076439274202|
| 6.2| 4.800643228448342| -1.3993567715516582|
| 12.6|13.513431604134931| 0.9134316041349315|
| 7.8| 7.289324492912175| -0.510675507087825|
| 11.0| 12.14859211003076| 1.1485921100307603|
| 24.2| 19.82343367802233| -4.37656632197767|
| 10.6| 9.87204611828728| -0.72795388171272|
| 18.6|19.290663393934967| 0.6906633939349653|
|11.800000000000002|12.322340133504676| 0.5223401335046738|
+------------------+------------------+--------------------+
only showing top 20 rows
+-------+-----------------+------------------+--------------------+
|summary| fare_amount| prediction| error|
+-------+-----------------+------------------+--------------------+
| count| 3000| 3000| 3000|
| mean|9.536166666666665| 9.535967764479922|-1.98902186749770...|
| stddev|6.952558857268078|6.4554477337337675| 1.9208959387344227|
| min| 2.5|3.9593080769885773| -69.80275612138105|
| max| 110.0|53.803333333333356| 12.055956289978678|
+-------+-----------------+------------------+--------------------+
mae evaluation: 0.8626064049871519
rmse evaluation: 1.9205757730272761
```
Random forest сделал очень много Spark Jobs, которые выполнялись с 14:04:02 до 14:05:15 (73 секунды).
XGBoost на том же датасете выполнялся в рамках 433-436 Spark Jobs, которые заняли ~16 секунд.
Результаты:
```
+------------------+------------------+--------------------+
| fare_amount| prediction| error|
+------------------+------------------+--------------------+
| 11.4|11.298457145690918|-0.10154285430908239|
| 7.4| 7.516303539276123| 0.11630353927612269|
| 5.0| 5.16908597946167| 0.16908597946166992|
| 8.5| 9.045893669128418| 0.545893669128418|
| 7.4| 7.355461597442627| -0.0445384025573734|
| 3.8| 4.012299060821533| 0.21229906082153338|
| 5.4| 5.95053768157959| 0.5505376815795895|
| 7.4| 5.841796875| -1.5582031250000004|
| 5.3| 6.106812000274658| 0.8068120002746584|
| 4.1| 4.191019058227539| 0.09101905822753942|
| 4.2|3.9211881160736084| -0.2788118839263918|
| 23.0| 22.72040557861328|-0.27959442138671875|
| 6.2| 4.528580665588379| -1.6714193344116213|
| 12.6| 13.0178804397583| 0.41788043975830114|
| 7.8| 7.767493724822998|-0.03250627517700...|
| 11.0|11.349909782409668| 0.34990978240966797|
| 24.2| 23.78424072265625| -0.4157592773437493|
| 10.6|10.418869972229004|-0.18113002777099574|
| 18.6| 19.02918243408203| 0.42918243408202983|
|11.800000000000002|11.934724807739258| 0.13472480773925533|
+------------------+------------------+--------------------+
+-------+-----------------+------------------+-------------------+
|summary| fare_amount| prediction| error|
+-------+-----------------+------------------+-------------------+
| count| 3000| 3000| 3000|
| mean|9.536166666666665| 9.538236152251562|0.00206948558489451|
| stddev|6.952558857268078|6.8646934667359885| 0.6205967386209823|
| min| 2.5|1.9244213104248047| -4.911700439453128|
| max| 110.0|106.85425567626953| 2.949781894683838|
+-------+-----------------+------------------+-------------------+
```
Именно в данном примере видим, что XGBoost справился быстрее и лучше, судя по значениям ошибок.
Гладко было на бумаге…
----------------------
Разворачивая спойлер из первой части статьи, заработало действительно не все. На двух машинах с Docker Desktop завести целевую схему не удалось по причине невозможности синхронизации двух контейнеров разных машин друг с другом. Network=host не дает нужного результата, роуты и nginx proxy тоже, также настраивал iptables в контейнерах - безуспешно.
Проблему можно решить воспользовавшись Docker Swarm, но все дело в том, что для корректной работы кластера все равно нужна хотя бы одна машина с ОС Linux, выступающей мастером. Естественно, я попробовал сделать схему с запуском мастера на виртуалке, прописывал роуты и направлял трафик со второй физической ноды на определенный порт первой, а на первой ноде прописывал роут с данного порта на виртуалку, но столкнулся с проблемой получения ответных пакетов от мастера, и несколькими другими проблемами.
Также можно было попробовать раскатать Kubernetes, но на этом я решил остановиться, так как:
а) Standalone кластер Spark в контейнерах - по сути бред и априори overhead, так как суть Standalone кластера заключается в том, что его можно использовать на малом количестве нод и для постоянной нагрузки. В таком случае Docker не нужен, и лучше поставить на чистую ОС;
б) Если Kubernetes, то нужно понимать, что он нужен для плавающих нагрузок, для оптимизации использования вычислительных ресурсов, и лучше использовать Kubernetes Operator - вот в этом опыта пока еще нет, и, вероятно, это тема будущей статьи;
в) “Все, стоп, осталось только кубер на винде раскатать, хватит страдать фигней” - раздалось в голове, и я остановился :)
Однако, результат меня все равно обрадовал - работа XGBoost встала на шаге синхронизации датасетов для последующей выдачи результата, что успел запечатлеть на скриншоте.
Итог
----
Цель данной статьи считаю достигнутой. Все три библиотеки оказались работоспособными, сервис написан на Java, запущен как Spring Web Service, в Docker-контейнерах задачи на GPU исполняются.
Что дальше и можно ли что-то улучшить? Естественно, направлений работы несколько:
1. Тюнинг Spark. Как минимум, неплохо бы подключить Kryo serializer. Во время работы с Rapids 22.06.0 у меня он так и не заработал. Кроме Kryo есть множество параметров конфигурации самого Spark, которые все вместе в целом довольно сильно влияют на производительность.
2. Запуск Spark Standalone кластера на bare metal и нативном Ubuntu 20.04.
3. Запуск сервиса в Kubernetes в паре с Spark Kubernetes Operator. Вероятно, гайд по запуску и результаты будут темой отдельной статьи.
4. Дальнейшее R&D в ML и Spark.
Список ресурсов и литературы
----------------------------
ссылки### Common interesting articles
[Accelerating Spark 3.0 and XGBoost End-to-End Training and Hyperparameter Tuning](https://developer.nvidia.com/blog/accelerating-spark-3-0-and-xgboost-end-to-end-training-and-hyperparameter-tuning/)
[Accelerating Deep Learning on the JVM with Apache Spark and NVIDIA GPUs](https://www.infoq.com/articles/deep-learning-apache-spark-nvidia-gpu/)
[How Amazon retail systems run machine learning predictions with Apache Spark using Deep Java Library](https://medium.com/p/3c58dd5fb5f8/edit)
[How Netflix uses Deep Java Library (DJL) for distributed deep learning inference in real-time](https://aws.amazon.com/ru/blogs/opensource/how-netflix-uses-deep-java-library-djl-for-distributed-deep-learning-inference-in-real-time/)
[Adopting machine learning in your microservices with DJL (Deep Java Library) and Spring Boot](https://aws.amazon.com/ru/blogs/opensource/adopting-machine-learning-in-your-microservices-with-djl-deep-java-library-and-spring-boot/)
[Getting Started with RAPIDS Accelerator with on premise cluster or local mode](https://nvidia.github.io/spark-rapids/docs/get-started/getting-started-on-prem.html)
[Accelerating Apache Spark 3.0 with GPUs and RAPIDS](https://developer.nvidia.com/blog/accelerating-apache-spark-3-0-with-gpus-and-rapids/)
[Leverage deep learning in Scala with GPU on Spark 3.0](https://aws.amazon.com/blogs/opensource/leverage-deep-learning-in-scala-with-gpu-on-spark-3-0/)
[Accelerating Deep Learning on the JVM with Apache Spark and NVIDIA GPUs](https://www.infoq.com/articles/deep-learning-apache-spark-nvidia-gpu/)
### nVidia documentation
[nVidia docker containers documentation](https://docs.nvidia.com/deeplearning/frameworks/user-guide/index.html)
[CUDA on WSL User Guide](https://docs.nvidia.com/cuda/wsl-user-guide/index.html)
[How to install CUDA Toolkit on Ubuntu 18.04 LTS — Performatune](https://www.performatune.com/en/how-to-install-cuda-toolkit-on-ubuntu-18-04-lts/#:~:text=The%20public%20CUDA%20GPG%20key,%2D1%2Dlocal%2D10.1.)
[WSL 2 GPU Support for Docker Desktop on NVIDIA GPUs — Docker](https://www.docker.com/blog/wsl-2-gpu-support-for-docker-desktop-on-nvidia-gpus/)
[nVidia Docker images](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/cuda/tags)
### nVidia Rapids documentation
[Get Started — RAPIDS Docs](https://docs.rapids.ai/start)
[On-Prem](https://nvidia.github.io/spark-rapids/docs/get-started/getting-started-on-prem.html)
[On-Prem — Example Join Operation](https://nvidia.github.io/spark-rapids/docs/get-started/getting-started-on-prem.html#example-join-operation)
### nVidia ML documentation
[Predictive Analytics Tutorial with Spark ML | NVIDIA](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/predictive-analytics-spark-machine-learning/)
[What’s New in Deep Learning & Artificial Intelligence from NVIDIA](https://www.nvidia.com/en-us/ai-data-science/spark-ebook/tutorial-gpu-accelerated-xgboost/)
Spark ML library documentation:
[Classification and regression — Spark 3.3.0 Documentation](https://spark.apache.org/docs/latest/ml-classification-regression.html#random-forests)
[Ensembles — RDD-based API — Spark 3.3.0 Documentation](https://spark.apache.org/docs/latest/mllib-ensembles.html#random-forests)
### DJL
[Main — Deep Java Library](https://docs.djl.ai/)
[Examples](http://djl.ai/examples/)
[Troubleshooting — Deep Java Library](http://docs.djl.ai/docs/development/troubleshooting.html#troubleshooting)
[Deep Learning with Spark in Deep Java Library in 10 minutes](https://towardsdatascience.com/deep-learning-with-spark-in-deep-java-library-in-10-minutes-923a73704094)
[Deep Java Library(DJL) — a Deep Learning Toolkit for Java Developers](https://towardsdatascience.com/deep-java-library-djl-a-deep-learning-toolkit-for-java-developers-55d5a45bca7e)
[5.5. GPUs — Dive into Deep Learning 0.1.0 documentation](https://d2l.djl.ai/chapter_deep-learning-computation/use-gpu.html)
[DJL dependency management — Deep Java Library](https://docs.djl.ai/docs/development/dependency_management.html)
[3.2. Linear Regression Implementation from Scratch — Dive into Deep Learning 0.1.0 documentation](https://d2l.djl.ai/chapter_linear-networks/linear-regression-scratch.html)
[3.3. Concise Implementation of Linear Regression](https://d2l.djl.ai/chapter_linear-networks/linear-regression-djl.html)
### XGBoost Java library
[GitHub — dmlc/xgboost: Scalable, Portable and Distributed Gradient Boosting (GBDT, GBRT or GBM) Library, for Python, R, Java, Scala, C++ and more. Runs on single machine, Hadoop, Spark, Dask, Flink and DataFlow](https://github.com/dmlc/xgboost)
[xgboost/jvm-packages/xgboost4j-example at master · dmlc/xgboost](https://github.com/dmlc/xgboost/tree/master/jvm-packages/xgboost4j-example)
[xgboost/SparkMLlibPipeline.scala at master · dmlc/xgboost](https://github.com/dmlc/xgboost/blob/master/jvm-packages/xgboost4j-example/src/main/scala/ml/dmlc/xgboost4j/scala/example/spark/SparkMLlibPipeline.scala)
[A Full Integration of XGBoost and Apache Spark](https://xgboost.ai/2016/10/26/a-full-integration-of-xgboost-and-spark.html)
[XGBoost4J-Spark-GPU Tutorial (version 1.6.1+) — xgboost 2.0.0-dev documentation](https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_gpu_tutorial.html)
[XGBoost4J-Spark-GPU Tutorial (version 1.6.1+) — xgboost 1.6.1 documentation](https://xgboost.readthedocs.io/en/stable/jvm/xgboost4j_spark_gpu_tutorial.html#prediction)
[xgboost4j\_2.12 1.6.1 API](https://xgboost.readthedocs.io/en/stable/jvm/javadocs/index.html)
[spark-rapids-examples/kubernetes-scala.md at branch-22.06 · NVIDIA/spark-rapids-examples](https://github.com/NVIDIA/spark-rapids-examples/blob/branch-22.06/docs/get-started/xgboost-examples/on-prem-cluster/kubernetes-scala.md)
[spark-rapids-examples/Taxi.scala at branch-22.06 · NVIDIA/spark-rapids-examples](https://github.com/NVIDIA/spark-rapids-examples/blob/branch-22.06/examples/XGBoost-Examples/taxi/scala/src/com/nvidia/spark/examples/taxi/Taxi.scala)
### For debugging
[How to extract best parameters from a CrossValidatorModel](https://stackoverflow.com/questions/31749593/how-to-extract-best-parameters-from-a-crossvalidatormodel)
[Use shared library that uses glibc on AlpineLinux](https://stackoverflow.com/questions/70243938/use-shared-library-that-uses-glibc-on-alpinelinux) | https://habr.com/ru/post/679248/ | null | ru | null |
# Марсоход, Посадка
[](https://habrahabr.ru/post/314958/)
В этой серии статей мы строим программное обеспечение марсохода в [соответствии со следующими спецификациями](https://habrahabr.ru/post/314536/). Это позволит применить нам на практике следующие подходы:
* Monolithic Repositories — **MonoRepo** *(Монолитные репозитории)*
* Command/Query Responsibility Segregation — **CQRS** *(Сегрегация ответственности на чтение и запись)*
* Event Sourcing — **ES** *(События как источник)*
* Test Driven Development — **TDD** *(Разработка через тестирование)*
**Оглавление**[Марсоход, Введение](https://habrahabr.ru/post/314536/)
[Марсоход, Инициализация](https://habrahabr.ru/post/314544/)
Марсоход, Посадка
[Марсоход, Координаты посадки](https://habrahabr.ru/post/315684/)
Ранее мы создали [пакет навигации](https://habrahabr.ru/post/314544/), теперь можно приступать к разработке первого варианта использования:
> Марсоход должен будет сначала приземлиться в заданном положении. Положение состоит из координат (`X` и `Y`, являющихся целыми числами) и ориентации (строковое значение `north`, `east`, `west` или `south`).
Упрощаем Command Bus *(Командная Шина)*
---------------------------------------
[Паттерн Command Bus](https://gnugat.github.io/2016/05/11/towards-cqrs-command-bus) состоит из 3х классов:
* класс `Command`, проверяющий входной набор данных с именем к которому будут применятся необходимые манипуляции (например, `LandRover`)
* связанный с ним (отношение один к одному) `CommandHandler`, реализующий логику для конкретного случая использования
* `CommandBus`, который принимает команды и выполняет соответствующие `CommandHandler`, также поддерживает работу через `Middleware`
Мы собираемся упростить этот архитектурный шаблон для нашего марсохода, опуская класс `CommandBus`, т.к. нам на самом деле не нужно реализовывать `middleware` или искать соответствующий `CommandHandler` для полученной `Command`.
Начнем с создания класса `Command`, который позаботится о проверке входных параметров:
```
cd packages/navigation
git checkout -b 2-landing
```
Приземление
-----------
Мы собираемся инициализировать тестовый класс для `LandRover`, используя [phpspec](http://www.phpspec.net/en/stable/):
```
vendor/bin/phpspec describe 'MarsRover\Navigation\LandRover'
```
Получается сгенерированный класс `spec/MarsRover/Navigation/LandRoverSpec.php`:
```
namespace spec\MarsRover\Navigation;
use MarsRover\Navigation\LandRover;
use PhpSpec\ObjectBehavior;
use Prophecy\Argument;
class LandRoverSpec extends ObjectBehavior
{
function it_is_initializable()
{
$this->shouldHaveType(LandRover::class);
}
}
```
Нам остается отредактировать его, начнем с описания входных параметров:
```
namespace spec\MarsRover\Navigation;
use PhpSpec\ObjectBehavior;
class LandRoverSpec extends ObjectBehavior
{
const X = 23;
const Y = 42;
const ORIENTATION = 'north';
function it_has_x_coordinate()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getX()->shouldBe(self::X);
}
function it_has_y_coordinate()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getY()->shouldBe(self::Y);
}
function it_has_an_orientation()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getOrientation()->shouldBe(self::ORIENTATION);
}
}
```
Теперь можно запустить тесты:
```
vendor/bin/phpspec run
```
Это сгенерирует нам `src/MarsRover/Navigation/LandRover.php` файл:
```
namespace MarsRover\Navigation;
class LandRover
{
private $argument1;
private $argument2;
private $argument3;
public function __construct($argument1, $argument2, $argument3)
{
$this->argument1 = $argument1;
$this->argument2 = $argument2;
$this->argument3 = $argument3;
}
public function getX()
{
}
public function getY()
{
}
public function getOrientation()
{
}
}
```
Все, что нам нужно сделать, это изменить его:
```
namespace MarsRover\Navigation;
class LandRover
{
private $x;
private $y;
private $orientation;
public function __construct($x, $y, $orientation)
{
$this->x = $x;
$this->y = $y;
$this->orientation = $orientation;
}
public function getX() : int
{
return $this->x;
}
public function getY() : int
{
return $this->y;
}
public function getOrientation() : string
{
return $this->orientation;
}
}
```
Давайте снова выполним тесты:
```
vendor/bin/phpspec run
```
Все зеленые! Но наша работа еще не закончена, мы не описали недопустимые входные параметры:
```
namespace spec\MarsRover\Navigation;
use PhpSpec\ObjectBehavior;
class LandRoverSpec extends ObjectBehavior
{
const X = 23;
const Y = 42;
const ORIENTATION = 'north';
function it_has_x_coordinate()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getX()->shouldBe(self::X);
}
function it_cannot_have_non_integer_x_coordinate()
{
$this->beConstructedWith(
'Nobody expects the Spanish Inquisition!',
self::Y,
self::ORIENTATION
);
$this->shouldThrow(
\InvalidArgumentException::class
)->duringInstantiation();
}
function it_has_y_coordinate()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getY()->shouldBe(self::Y);
}
function it_cannot_have_non_integer_y_coordinate()
{
$this->beConstructedWith(
self::X,
'No one expects the Spanish Inquisition!',
self::ORIENTATION
);
$this->shouldThrow(
\InvalidArgumentException::class
)->duringInstantiation();
}
function it_has_an_orientation()
{
$this->beConstructedWith(
self::X,
self::Y,
self::ORIENTATION
);
$this->getOrientation()->shouldBe(self::ORIENTATION);
}
function it_cannot_have_a_non_cardinal_orientation()
{
$this->beConstructedWith(
self::X,
self::Y,
'A hareng!'
);
$this->shouldThrow(
\InvalidArgumentException::class
)->duringInstantiation();
}
}
```
Снова проверяем:
```
vendor/bin/phpspec run
```
Они падают, потому что мы должны проверять входные параметры:
```
namespace MarsRover\Navigation;
class LandRover
{
const VALID_ORIENTATIONS = ['north', 'east', 'west', 'south'];
private $x;
private $y;
private $orientation;
public function __construct($x, $y, $orientation)
{
if (false === is_int($x)) {
throw new \InvalidArgumentException(
'X coordinate must be an integer'
);
}
$this->x = $x;
if (false === is_int($y)) {
throw new \InvalidArgumentException(
'Y coordinate must be an integer'
);
}
$this->y = $y;
if (false === in_array($orientation, self::VALID_ORIENTATIONS, true)) {
throw new \InvalidArgumentException(
'Orientation must be one of: '
.implode(', ', self::VALID_ORIENTATIONS)
);
}
$this->orientation = $orientation;
}
public function getX() : int
{
return $this->x;
}
public function getY() : int
{
return $this->y;
}
public function getOrientation() : string
{
return $this->orientation;
}
}
```
И снова выполним тесты:
```
vendor/bin/phpspec run
```
Все прошли! Теперь мы можем закоммитить нашу работу:
```
git add -A
git commit -m '2: Created LandRover'
```
Заключение
----------
Мы сделали первые шаги в **TDD**: написали тесты, затем код, и с помощью `phpspec` этот процесс упростился.
Поскольку мы пишем эти тесты в описательном виде (тестовые методы именуются в виде предложений), то мы можем использовать их в качестве исполнимой спецификации для самоконтроля! `phpspec` позволяет отображать их в явном виде:
```
vendor/bin/phpspec run --format=pretty
```
Должно отображаться:
```
MarsRover\Navigation\LandRover
13 has x coordinate
24 cannot have non integer x coordinate
37 has y coordinate
48 cannot have non integer y coordinate
61 has an orientation
72 cannot have a non cardinal orientation
1 specs
6 examples (6 passed)
10ms
```
> **Примечание**: `navigation`-тесты можно запускать из MonoRepo:
>
>
> ```
> cd ../../
> composer update --optimize-autoloader
> vendor/bin/phpspec run
> ```
>
>
>
Что дальше
----------
В следующей статье мы завершим цикл **TDD** рефакторингом `LandRover`: извлечем `x` и `y` координаты в их собственные классы.
Предыдущая часть: [Марсоход, Инициализация](https://habrahabr.ru/post/314544/)
Следующая часть: [Марсоход, Координаты посадки](https://habrahabr.ru/post/315684/) | https://habr.com/ru/post/314958/ | null | ru | null |
# Хак для поддержки кнопок Android-гарнитуры под Windows
Я почти каждый день слушаю музыку на смартфоне и использую кнопки управления на гарнитуре. Но мне всегда не нравилась одна вещь. Я прихожу домой, продолжая прослушивание, гарнитура подключается к домашнему ПК — и внезапно кнопки перестают работать.
Конечно, я погуглил решение этой проблемы. К сожалению, на Windows эта замечательная функция не слишком поддерживается. Пара минут поиска дали только мутные упоминания на Stack Overflow о звуковых картах и сообщения некоторых людей, что на их ноутбуках всё работает нормально.
Меня это не испугало — и я решил принять проблему как интересный вызов: можно ли создать какую-то программу для активации кнопок управления, если аппаратной поддержки для них вообще нет? Ответ — да, можно. И вот как сделать это за полчаса.
Как работают кнопки гарнитуры Android
=====================================
Первое, что нужно понять — как работают кнопки гарнитуры. Быстрый поиск в интернете нашёл [эту спецификацию](https://source.android.com/devices/accessories/headset/plug-headset-spec) из документации Android. Там есть диаграмма.
Как можно понять, при нажатии кнопки на гарнитуре замыкается цепь на одном из резисторов. Особого внимания заслуживает Кнопка A (Play/Pause/Hook) с сопротивлением 0 Ом, то есть замыканием микрофона. Если мы способны обнаружить короткое замыкание микрофона, то так сможем определить нажатие кнопки Play/Pause.
Проверка гипотезы
=================
Прежде чем начать программировать, хотелось бы проверить разумность наших рассуждений в принципе. То есть того, что по сигналу с микрофона можно определить нажатие кнопки Play/Pause. К счастью, для этого достаточно просто записать звук на компьютере и посмотреть на результат. Я запустил Audacity, нажал во время записи кнопку Play/Pause — и получил такой сигнал.
*Бинго*
Как видим, нажатие кнопки очевидно отражается в форме сигнала: внезапное падение до −1 с последующим внезапным переходом к 1 и постепенным уменьшением до 0. Интуитивно по спецификации я бы предположил, что сигнал подскочит до 1 и останется там, пока кнопку не отпустить, но в реальности выглядит иначе. Тем не менее, такую картинку всё равно легко обнаружить, если захватить аудиопоток с микрофона.
Захват звука средствами Python
==============================
Зная способ, как обнаружить нажатие кнопок на гарнитуре, можно подумать о главной цели: как управлять плеером на рабочем столе с помощью кнопок гарнитуры.
Первый шаг — обнаружение нажатия кнопки. Для этого нужно захватить аудиопоток с микрофона и обнаружить отчётливую подпись, которую мы видели ранее. Для простоты реализуем решение на Python. После ещё одного небольшого поиска в интернете я нашёл пакет под названием sounddevice, который позволяет абстрагироваться от самой трудной части — реального аудиозахвата с микрофона.
Немножко кодирования даёт нам следующее:
```
import sounddevice as sd
SAMPLE_RATE = 1000 # Sample rate for our input stream
BLOCK_SIZE = 100 # Number of samples before we trigger a processing callback
class HeadsetButtonController:
def process_frames(self, indata, frames, time, status):
mean = sum([y for x in indata[:] for y in x])/len(indata[:])
print(mean)
def __init__(self):
self.stream = sd.InputStream(
samplerate=SAMPLE_RATE,
blocksize=BLOCK_SIZE,
channels=1,
callback=self.process_frames
)
self.stream.start()
if __name__ == '__main__':
controller = HeadsetButtonController()
while True:
pass
```
Такой код непрерывно выдаёт среднее значение каждой партии образцов. Мы установили частоту дискретизации 1000, что ужасно мало для обработки звука (обычно используется 44100), но нам в реальности не нужна большая точность. Размер блока определяет, сколько сэмплов в буфере инициируют обратный вызов. Опять же, мы установили очень низкие значения. Размер блока 100 и частота дискретизации 1000 фактически означает срабатывание 10 раз в секунду, где при каждом вызове обрабатывается только 100 сэмплов.
Определение нажатия кнопки: наверное, слишком простой способ
============================================================
Теперь мы захватываем аудиопоток и можно реализовать реальный механизм для обнаружения нажатия кнопки. Напомним, что сигнал подскакивает до 1 всякий раз при нажатии. Это подсказывает самый простой способ обнаружения: если у *N* последовательных блоков значения сигнала выше 0,9, то есть нажатие.
Реализуем алгоритм в нашей функции:
```
import sounddevice as sd
SAMPLE_RATE = 1000 # Sample rate for our input stream
BLOCK_SIZE = 100 # Number of samples before we trigger a processing callback
PRESS_SECONDS = 0.2 # Number of seconds button should be held to register press
PRESS_SAMPLE_THRESHOLD = 0.9 # Signal amplitude to register as a button press
BLOCKS_TO_PRESS = (SAMPLE_RATE/BLOCK_SIZE) * PRESS_SECONDS
...
def process_frames(self, indata, frames, time, status):
mean = sum([y for x in indata[:] for y in x])/len(indata[:])
if mean < PRESS_SAMPLE_THRESHOLD:
self.times_pressed += 1
if self.times_pressed > BLOCKS_TO_PRESS and not self.is_held:
# The button was pressed!
self.is_held = True
else:
self.is_held = False
self.times_pressed = 0
...
```
По сути мы запустили внутренний счётчик, сколько обработанных блоков отвечают пороговому требованию, которое просто установили на 0,9, предусмотрев неизбежное зашумление образца. Если блок не удовлетворяет требованию, счётчик сбрасывается — и мы начинаем заново. Переменная `is_held` отслеживает срабатывания, чтобы не регистрировать их многократно, если кнопка не отпускается.
Управление воспроизведением в Windows
=====================================
Теперь осталось только заменить в реальном коде комментарий *“The button was pressed!”*, чтобы управлять воспроизведением звука в Windows. Снова погуглим, чтобы разобраться, как это сделать: оказывается, можно управлять воспроизведением, имитируя нажатие клавиш соответствующими [кодами виртуальных клавиш](https://msdn.microsoft.com/en-us/library/dd375731%28v=VS.85%29.aspx).
Оказалось, что имитировать нажатия клавиш очень легко с помощью пакета [pywin32](https://github.com/mhammond/pywin32), который является просто оболочкой Python для Windows API. Собрав всё вместе, мы можем создать следующую функцию:
```
import win32api
import win32con
VK_MEDIA_PLAY_PAUSE = 0xB3
def toggle_play():
win32api.keybd_event(VK_MEDIA_PLAY_PAUSE, 0, 0, 0)
```
И у нас получилось! Обращение к функции `toggle_play` в том месте кода, где был комментарий *“The button was pressed!”*, позволяет управлять любым медиаплеером в Windows с помощью кнопок на гарнитуре Android.
Тесты показали, что код работает на удивление хорошо. Единственное различие между функциональностью на Android и Windows заключается в небольшой задержке при нажатии на кнопку, но с этим можно жить.
*И вот что получилось*
Скрипт Python состоит из 51 строки, которые активируют кнопки гарнитуры Android в Windows. Окончательный исходный код этого проекта лежит [на Github](https://github.com/Catuna/AndroidMediaControlsWindows).
Погодите, это ещё не всё!
=========================
После счастливого использования программы в течение нескольких часов я заметил серьёзную проблему:
Программа использует почти 30% CPU! Очевидно, это неприемлемо при длительной работе, что-то нужно делать. Посмотрев на код, я понял, что основной поток находится в состоянии ожидания в основном цикле, хотя там ничего не происходит. Наиболее логичное решение — просто усыпить поток навсегда: поскольку колбэк вызывается автоматически, нам всё равно не нужен цикл.
```
from time import sleep
if __name__ == '__main__':
controller = HeadsetButtonController()
while True:
sleep(10)
```
Я также не хотел запускать скрипт Python вручную после каждого запуска компьютера. К счастью Python для Windows поставляется с полезной утилитой pythonw.exe, которая запускает процесс «демона» без подключенного терминала. Размещаем ярлык к этому процессу в каталоге *Microsoft\Windows\Start Menu\Programs\Startup*, указав наш скрипт в качестве первого аргумента — тогда приложение автоматически запускается и незаметно работает в фоновом режиме. | https://habr.com/ru/post/417303/ | null | ru | null |
# Подделка писем. Как защищаться
Привет habr! В данной заметке решил затронуть тему защиты от поддельных писем (Email spoofing, Forged email). Речь пойдёт о письмах, в которых так или иначе подделывается информация об отправителях. Получатель видит письмо, отправленное якобы доверенным лицом, но на самом деле, письмо отправлено злоумышленником.
В последнее время всё чаще слышим о проблеме поддельных писем от наших заказчиков, да и просто от знакомых. Эта проблема не только актуальна, но, похоже, набирает обороты. Вот реальная история от знакомого, который был близок к тому, чтобы потерять сумму с четырьмя нулями в долларовом эквиваленте. В компании велась переписка на английском языке с зарубежной компанией о приобретении дорогостоящего специализированного оборудования. Сперва нюансы возникли на стороне нашего знакомого – потребовалось изменить реквизиты счёта отправителя (компанию-покупателя). Через некоторое время, после успешного согласования новых реквизитов, поставщик оборудования также сообщил о необходимости изменения реквизитов счёта получателя (компанию-продавца). Вот только письма об изменении данных получателя шли уже от злоумышленников, удачно подменявших адрес отправителя. На фоне некоторой общей суматохи, усугубляющейся ещё и тем, что обе стороны не являлись носителями языка переписки, заметить подмену писем было практически невозможно. Нельзя не отметить и тот факт, что злоумышленники старательно копировали стили, шрифты, подписи и фотографии в письмах. Как именно утекла информация о сделке – скорее всего была скомпрометирована почтовая переписка. За неделю до финального согласования сделки, о которой идет речь в этой статье, на почту знакомого пришло письмо с трояном, в виде счета-фактуры в \*.exe архиве. На момент прихода письма антивирус не отловил зловреда, и тот, некоторое время успел “поработать” на компьютере, и даже подтянуть на подмогу пару своих собратьев.
Через несколько дней сигнатуры антивируса обновились и зловред с собратьями был удален, но к тому моменту в переписку уже вклинились, отправителя подделали, деньги ушли на чужой счёт.
В данном примере подмена адреса отправителя была сделана крайне незамысловато. Реальные адреса мы не опубликуем, но приведём аналогичный пример.
Правильный адрес отправителя: best@bestofall.com
Поддельный адрес отправителя: bestbestofall.com@spoofed.ru.
Почтовая учётная запись злоумышленника включала имя “best@bestofall” и фамилию “.com”. Часть переписки знакомый вел с мобильного устройства, почтовый клиент которого отображал в поле отправителя только имя и фамилию отправителя. А так делают все мобильные почтовые клиенты. Поэтому, входящее письмо в этом почтовом клиенте виделось как от best@bestofall «пробел» .com. Что очень похоже на оригинал. Ниже письмо от злоумышленника и под ним легитимное письмо в интерфейсе Яндекс.Почты:
В Outlook письмо от злоумышленника тоже выглядело достаточно похоже на оригинал, если внимательно не всматриваться, то тоже можно и не заметить подделку.
Всё всплыло, когда позвонил поставщик и спросил: «Веэр из май мани?». К счастью знакомого, из-за двойной смены реквизитов (получателя и отправителя) относительно изначального подписанного соглашения $$$$$ не были окончательно зачислены на счет злоумышленников, а зависли на транзитном счете банка-получателя, и их удалось вернуть.
Компании по всему миру терпят существенные убытки из-за Email-атак ([источник](http://blogs.cisco.com/security/what-is-email-spoofing-and-how-to-detect-it)). Так с октября 2013 по август 2015 совокупный убыток от компрометаций корпоративной электронной почты компаний по всему миру составил 1,2 миллиарда долларов США. А атаки с поддельными письмами находятся среди самых распространённых видов атак на корпоративные почтовые системы.
Особое внимание уделяется атакам, при которых злоумышленник отправляет поддельное письмо от имени высокопоставленного руководителя компании. В тексте письма злоумышленник требует незамедлительного ответа, или какой-либо срочной реакции от сотрудника или группы сотрудников компании. Например, может потребовать ответить на письмо отправкой какой-либо конфиденциальной информации. Это может привести к утечке данных. Или злоумышленник может потребовать срочный банковский перевод какой-либо крупной суммы. В описанных сценариях сотрудник ощущает давление: высокопоставленный руководитель требует безотлагательных действий. Этот факт повышает вероятность успеха атаки. Кроме того, атаке может предшествовать рекогносцировка методами социальной инженерии, чтобы наиболее эффективно сформировать текст письма и наиболее точно выявить целевую группу сотрудников, которые получат поддельное письмо. Данный подход также благотворно влияет на успех атаки.
Для того, чтобы разобраться с механизмом подделки адреса отправителя, вспомним структуру электронного письма, передаваемого по протоколу SMTP. Электронное письмо состоит из конверта (envelope), заголовков (headers) и тела письма (message body). Информация об отправителе содержится в конверте. Эта информация формируется SMTP-командой mail from и оказывает непосредственное влияние на процесс пересылки сообщения по мере прохождения почтовых cерверов Mail Transfer Agent (MTA). Однако, информация об отправителе также содержится в некоторых заголовках письма, таких как “From:”, “Return-Path:”, возможно “Reply-To:”. Заголовок “From:” не обязательно должен совпадать с тем, что написано в конверте письма и может представлять некоторое «дружеское имя» (friendly name, friendly from). Заголовок “Return-Path:” копирует отправителя из конверта. Заголовок “Reply-To:” содержит адрес для ответа. Заголовки значимы для почтового клиента (например, MS Outlook), по заголовкам заполняются соответствующие поля.
Рассмотрим пример SMTP-команд для отправки письма с поддельными заголовками “From:” и “Reply-To:”. Подключаемся к почтовому серверу Exchange с помощью telnet:
```
telnet 10.1.2.3 25
220 Exchange Microsoft ESMTP MAIL Service ready at Wed, 26 Oct 2016 10:28:00 +0300
helo
250 Exchange Hello [192.168.100.100]
mail from: attacker@spoofed.ru
250 2.1.0 Sender OK
rcpt to: uskov@cbs.ru
250 2.1.5 Recipient OK
data
354 Start mail input; end with .
From: Ivanov Ivan
To: Boris
Reply-To: attacker@yandex.ru
Subject: Urgent!
Need your credit card information.
Ivanov Ivan Ivanovich,
CEO,
Computer Business Systems
.
250 2.6.0 Queued mail for delivery
quit
221 2.0.0 Service closing transmission channel
```
В данном примере мы отправляем с реального адреса attacker@spoofed.ru письмо, но в заголовке “From:” указываем имя и адрес руководителя компании, а в заголовке “Reply-to” адрес на mail.yandex, куда невнимательный сотрудник отправит конфиденциальную информацию. В итоге письмо в почтовом клиенте Outlook будет выглядеть следующим образом:
А если нажать «Ответить» автозаполнится адрес получателя:
Как видно из предыдущего примера, отправить поддельное письмо не составляет большого труда, если почтовый сервер не защищён. В худшем случае, значение в конверте письма mail from также может быть подменено на легитимное. Если тело письма составлено аккуратно и с применением результатов социальной инженерии, выявить поддельное письмо становится всё сложнее для конечного пользователя. Ситуация ещё более усугубляется для пользователей мобильных устройств. Концепция мобильности предполагает, что все действия выполняем быстро, «на ходу», да ещё и на небольшом экране, не обращая внимание на мелочи/несоответствия. Кстати говоря, в примере про сделку с зарубежной компанией у знакомого тоже не обошлось без фактора «мобильности». Часть переписки проходила с мобильного устройства, почтовый клиент в поле отправителя отображал только имя/фамилию отправителя, но скрывал полный почтовый адрес.
Не существует единого метода борьбы с подменёнными письмами. Защита от данного вида атак требует комплексного и многоуровневого подхода. Попробую выделить основные подходы борьбы с поддельными письмами:
1. Фильтрация на основе репутации сервера-отправителя.
2. Фильтрация на основе проверок DNS-записей сервера отправителя.
3. Фильтрация на основе проверок DNS-записей домена отправителя из конверта письма.
4. Фильтрация на основе проверок [SPF-записей](https://ru.wikipedia.org/wiki/Sender_Policy_Framework).
5. Фильтрация на основе [DKIM](https://ru.wikipedia.org/wiki/DomainKeys_Identified_Mail).
6. Фильтрация на основе [DMARC](https://ru.wikipedia.org/wiki/DMARC).
7. Создание гранулярных фильтров «вручную».
Из перечисленных методов первые три являются фильтрами грубой очистки, позволяющими бороться с массовыми рассылками спама, вредоносной почты, в том числе с подменённым отправителем. В данном случае злоумышленники используют эффект массовости, не осуществляя до атаки какой-либо специальной рекогносцировки и не стараясь точно подобрать контент под получателя. Например, письма от лица Сбербанка с просьбой сообщить какую-либо конфиденциальную информацию (логин/пароль от личного кабинета, номера карт, PIN-коды), рассылаемые на огромное число получателей. По принципу, кто-нибудь да клюнет.
Методы 4-6 помогают бороться с точными подменами отправителей, то есть ситуациями, когда в заголовках письма злоумышленник указывает с точностью до знака подменяемый отправитель.
К методу 7 предстоит прибегать в случаях как в примере про переписку с зарубежной компанией в начале статьи, когда заголовок письма модифицируется таким образом, чтобы стать похожим на реального отправителя. Но при этом, заголовок в подменённом письме всё же отличается от заголовка реального отправителя, что позволяет обойти проверки методами 4-6.
Рассмотрим перечисленные методы более подробно.
**1. Фильтрация на основе репутации сервера-отправителя.** Если система защиты корпоративной почты обеспечивает качественную базу репутаций отправителей, мы можем фильтровать значительный процент распространителей спама и вредоносной корреспонденции любого вида уже на этапе установления TCP-сессии, не заглядывая ни в тело, ни в конверт письма. Такой подход существенно экономит ресурсы системы. Как только отправитель пытается установить TCP-сессию на порт 25, система защиты определяет репутацию для IP-адреса отправителя, и принимает решение.
**Пример Cisco ESA. Репутационная фильтрация.**Немного конкретики на примере Cisco ESA. Решение использует репутационную базу Sender Base. Мы видим, что репутационная фильтрация помогает останавливать в районе 80% вредоносных писем. Причём по многолетнему опыту внедрения и сопровождения данного решения могу сказать, что количество ложных срабатываний репутационной фильтрации Cisco ESA стремится к нулю.
Ниже сводка по нашей организации:
В зависимости от репутации отправителя Cisco ESA не только принимает решение отбросить письмо или пропустить далее, но и определяет дальнейший сценарий обработки письма. Для различных значений репутации мы можем применять различные политики:
**2. Фильтрация на основе проверок DNS-записей сервера отправителя.** Отправитель почтовых сообщений должен быть корректно зарегистрирован в DNS. Для отправителя должны существовать корректные PTR запись, А-запись. Отправитель должен корректно представляться в SMTP-команде HELO. При массовых рассылках спама и вредоносов злоумышленники постоянно меняют IP-адреса рассылающих серверов. Адреса меняются каждый день и даже чаще. Регистрировать необходимые записи в DNS сложно и даже невозможно. Поэтому, многие распространители спама и вредоносных сообщений пренебрегают данными требованиями, соответственно, появляется возможность их фильтровать по признакам DNS.
**Пример Cisco ESA. DNS-проверки IP-адреса отправителя.**Рассмотрим DNS-проверки на примере Cisco ESA. При установлении TCP-сессии выполняются следующие проверки отправителя по DNS:
1. Проверка наличия PTR-записи. PTR запись должна быть единственной и возвращать корректное каноническое имя хоста отправителя.
2. Проверка наличия А-записи для имени хоста, найденного на первом шаге (по PTR-записи).
3. Проверка совпадения forward DNS lookup для А-записи из предыдущего шага с IP-адресом отправителя.
Если PTR-запись не существует, или найденная A-запись указывает на сторонний IP-адрес, с наибольшей долей вероятности мы принимаем сессию от нелегитимного отправителя. Для таких отправителей на Cisco ESA мы можем применять ограничивающие политики (отбрасываем письмо, отправляем в карантин, модифицируем заголовок, ограничиваем количество сессий и т.д.), в зависимости от поставленных требований.
Хочу обратить внимание, на данном этапе проверок ESA не контролирует легитимность отправителя, то есть не проверяет, имеет ли право отправитель слать письма от указанного домена. Более того, на данном этапе ни конверт письма, ни заголовки не просматриваются. Отрабатывает только проверка по IP-адресу. Например, если письма от домена mycompany.ru будут идти с «левого» IP-адреса с корректными A- и PTR-записями в DNS, например, «smtp.spamer.ru», проверка пройдёт успешно и письмо будет пропущено для дальнейшей обработки. Проверка легитимности отправителей осуществляется другими методами (см. далее SPF-записи, DKIM, DMARC).
**3. Фильтрация на основе проверок DNS-записей домена отправителя из конверта письма.** Информация в mail from также подлежит проверке по DNS. На примере Cisco ESA письмо может быть отброшено если:
1. Информация о домене отправителя отсутствует в конверте.
2. Имя домена не разрешается в DNS.
3. Имя домена не существует в DNS.
Данный тип проверок не особенно эффективен, отбрасываются письма с заведомо неверно сформированными конвертами.
**4. Фильтрация на основе проверок SPF-записей.** SPF – Sender Policy Framework – система проверки отправителей электронных сообщений. Проверка методом 2 «DNS-записи сервера отправителя» говорит только о том, что для IP-адреса отправителя существуют необходимые записи в DNS (PTR- и A-записи). Однако данные проверки не помогают определить, имеет ли право сервер отправитель слать письма от указанного домена. Стоит заметить, часто A-записи почтовых серверов содержат в себе имя домена компании, например, smtp01.mycompany.ru. Если этот же сервер используется для приёма почты, то эта же A-запись будет входить и в MX-запись. Можно предположить, что если письмо от mycompany.ru отправлено с сервера smtp01.mycompany.ru, то это письмо не поддельное, в противном случае, если письмо отправлено с smtp01.anythingelse.ru, письмо поддельно. Но на самом деле часто компании отправляют электронную корреспонденцию не напрямую со своих почтовых серверов, а через какие-либо дополнительные серверы MTA, например, через сервера своих провайдеров. В этом случае получаем, что письмо от домена mycompany.ru отправляется через серверы, к примеру, smtp01.provider.com, smtp02.provider.com и т.д. Канонические имена серверов отправителей не принадлежат домену компании mycompany.ru. Как на стороне получателя в данном случае понять, являются ли серверы-отправители легитимными или нет? Эту задачу решает система проверок SPF.
Задача решается опять же с помощью DNS. Для домена отправителя публикуется TXT-запись специального формата. В данной TXT-записи перечисляются IP-адреса, подсети или А-записи серверов, которые могут отправлять корреспонденцию, серверы, которые не являются легитимными отправителями. Благодаря системе SPF получатель может обратиться к DNS и уточнить, можно ли доверять серверу отправителю письма, или же сервер отправитель пытается выдать себя за кого-то другого.
На данный момент SPF-записи формируют далеко не все компании.
**5. Фильтрация на основе DKIM.** DKIM — DomainKeys Identified Mail – технология аутентификации электронных сообщений. Вернёмся к примеру из рассмотрения SPF-записей, когда компания mycompany.ru отправляет корреспонденцию наружу через провайдерские MTA smtp01.mycompany.ru и smtp02.provider.com. Для MTA существуют SPF-записи, поэтому письма от mycompany.ru, отправленные через эти серверы, успешно проходят проверку. Но что если данные MTA окажутся скомпрометированными, и злоумышленник также получит возможность отправлять поддельные письма через эти серверы? Как установить подлинность отправителя в этом случае? На помощь приходит аутентификация писем.
Для аутентификации используется ассиметричная криптография и хеш-функции. Закрытый ключ известен исключительно серверу отправителю. Открытый ключ публикуется опять же с помощью DNS в специальной TXT-записи. Сервер отправитель формирует отпечаток заголовков письма с помощью хэш-функции и подписывает его, используя закрытый ключ. Подписанный отпечаток вставляется в заголовок письма “DKIM-Signature:”. Теперь получатель письма с помощью открытого ключа может получить расшифрованный отпечаток и сравнить его с отпечатком полей полученного письма (хеш-функция известна). Если отпечатки совпадают, подписанные заголовки не были изменены при передаче, а отправитель письма, сформировавший заголовок “DKIM-Signature:”, является легитимным.
**6. Фильтрация на основе DMARC.** DMARC — Domain-based Message Authentication, Reporting and Conformance — техническая спецификация, описывающая как именно следует использовать результаты проверок SPF и DKIM. Политики DMARC публикуются как обычно с помощью DNS в TXT-записи. Политики DMARC указывают, что именно нужно делать с письмом на стороне получателя (доставить, отбросить, отправить в карантин), в зависимости от результатов проверок SPF и DKIM. Кроме того, DMARC обеспечивает обратную связь отправителя с его получателями. Отправитель может получать отчёты о всех электронных письмах, имеющих домен отправителя. Информация включает IP-адреса серверов-отправителей, количество сообщений, результат в соответствии с политиками DMARC, результаты проверок SPF и DKIM.
**7. Создание гранулярных фильтров «вручную».** К сожалению, далеко не все организации используют SPF, DKIM, DMARC при отправке электронной почты. Кроме того, в некоторых случаях проверки SPF, DKIM и DMARC могут пройти успешно, но письма оказываются всё равно подделанными (Cousin domain, Free Email Accounts). Для таких случаев помогают настройки фильтров. Возможности различных систем по созданию правил фильтрации разнятся. Фильтры настраиваются под различные сценарии проведения атаки и зависят от особенностей организации почтовых систем в компаниях. Например, в каких-то компаниях могут приходит из вне письма с доменом-отправителем этой же компании. Хотя в большинстве случаев такие письма должны пересылаться только в пределах периметра организации.
Мы более ориентированы на Cisco ESA, поэтому в заключении рассмотрим несколько примеров настройки фильтров на этом решении, а также интересную функциональность, появившуюся в релизе 10.0 (от июня 2016) программного обеспечения для Cisco ESA — Forged Email Detection. Данная функциональность как раз позволяет бороться с неточной подделкой отправителей, как в примере из начала статьи. Если заинтересовало, велкам в подкат.
**Пример Cisco ESA. Фильтры.**
Cisco ESA предлагает два типа фильтров: Content Filters и Message Filters. Первые настраиваются с помощью GUI и предлагают конечный (хотя и достаточно обширный) список условий и действий. Пример из GUI:
Если Content Filters не достаточны, чтобы описать условия попадания письма под действие фильтра, можно использовать Message Filters. Message Filters настраиваются из командной строки, используют регулярные выражения для описания условий и позволяют создавать сложные условия (например, If (((A and B) and not C) or D)). Message Filters обрабатывают письмо до Content Filters и позволяют создавать более гранулярные правила.
Рассмотрим несколько сценариев подделки отправителя и соответствующие фильтры Cisco ESA для борьбы с атакой.
*Пример 1.* Письма с доменом организации в отправителе не должны приходить из вне. Пример взят из с cisco.com: [ссылка](http://www.cisco.com/c/en/us/support/docs/security/email-security-appliance/117796-problemsolution-esa-00.html). Пример актуален в том случае, когда организация не готова публиковать свои SPF и Domain Keys в DNS. В данном примере используется следующий Message Filter:
```
MarkPossiblySpoofedEmail:
if ( (recv-listener == "InboundMail") AND
(subject != "\\{Possibly Forged\\}$") ) // Если письмо получено из вне и в заголовке ещё не помечено, что письмо как «Possibly Forged»
{
if (mail-from == "@yourdomain\\.com$") OR
(header("From") == "(?i)@yourdomain\\.com") // Если в конверте в mail from присутствует домен организации или в заголовке From присутствует домен организации
{
strip-header("Subject");
insert-header("Subject", "$Subject {Possibly Forged}");
}
}
// Добавляем к заголовку запись «Possibly Forged»
```
В качестве действия могут быть выбраны и другие варианты: отправить в карантин, отбросить письмо и т.д.
*Пример 2.* В начале статьи мы рассматривали пример, когда mail from из конверта письма был не поддельный (attacker@spoofed.ru, то есть атакующий пишет свой верный адрес), однако в заголовке From указывался поддельный адрес (uskov@cbs.ru). При этом, ничто не мешает атакующему завести SPF и Domain Keys в DNS для домена spoofed.ru. Получаем, что поддельное письмо пройдёт проверки SPF и DKIM. Также, проверки SPF и DKIM будут успешно пройдены, если злоумышленник использует бесплатную почту (free mail accounts – gmail.com, mail.ru и т.д.).
Бороться с данной ситуацией можем, проверяя равенство значений в mail from и заголовке From. Сразу стоит оговориться, в общем случае RFC совершенно не требует, чтобы mail from равнялся From. Поэтому применять такой фильтр нужно только к некоторым отправителям.
У Cisco ESA на данный момент (ноябрь 2016) есть ограничение: нельзя сравнивать значения полей между собой, то есть нельзя просто написать if mail from != header (From). Задачу можно решить другим способом. Создаём словарь имён отправителей Spoofed\_senders, в который будем заносить отправителей, подверженных подмене. В фильтре ставим условие: если mail from не содержит отправителя из словаря, а заголовок From содержит отправителя из словаря, выполнять действие. Можно отправить письмо в карантин или отбросить, но cisco рекомендует записать подделанное значение заголовка From в новый заголовок X-Original-From, а поле From вообще удалить. В этом случае Cisco ESA автоматически сформирует заголовок From из значения mail from. Пример такого фильтра:
```
SpoofedSendersFilter:
if (header-dictionary-match("Spoofed_Senders","From", 1))
AND
(NOT (mail-from-dictionary-match("Spoofed_Senders", 1))) // Если поле From содержит имя из словаря, а значение mail from не содержит имя из словаря
{
insert-header("X-Original-From", "$From");
strip-header("From");
} // Формируем заголовок X-Original-From и удаляем заголовок From
```
*Пример 3.* Злоумышленники используют адреса, похожие на адреса отправителей, так называемые “Cousin domains” и “Cousin addresses”. Например, адрес uskov@cbs.ru заменяется на usk0v@cbc.ru. Для домена cbc.ru формируются SPF и Domain Keys в DNS, поэтому письма проходят соответствующие проверки SPF и DKIM успешно, а получатель письма видит знакомого отправителя. Бороться с такой подменой сложнее. Придётся заносить в словарь Spoofed\_senders из предыдущего примера все похожие варианты имён отправителей и названий домена, что едва-ли возможно.
Для борьбы с данным видом подмены отправителей у Cisco ESA, начиная с релиза AsyncOS 10.0 (от июня 2016 года), появилась интересная функциональность “Forged Email Detection”. Сперва создаётся словарь имён отправителей (в примерах используется имя словаря FED), как и в предыдущем примере, в который будем заносить отправителей, подверженных подмене. Этот словарь формируется из имён отправителей, а не из имён почтовых ящиков. То есть нужно писать Olivia Smith вместо olivia.smith@example.com. Система Forged Email Detection будет сверять заголовок From с именами из словаря FED и выдавать вероятность (от 1 до 100), с которой отправителя можно считать подделанным.
Например, если в словаре есть “John Simons”, а в заголовке From фигурирует j0hn.sim0ns@example.com, система выдаст вероятность подделки 82. Если в заголовке From фигурирует john.simons@diff-example.com (то есть то же имя, но другой домен), система выдаст вероятность подделки 100.
Forged Email Detection настраивается через Content Filters или Message Filters. Ниже скриншот настройки Content Filter:
Необходимо указать имя словаря, и пороговое значение вероятности, после которого считаем отправителя подделанным. Для данного условия можно выбрать любое из доступных действий (отбросить, отправить в карантин, модифицировать тему письма и т.д.). Кроме того, появилось новое дополнительное действие для Forged Email Detection: заменить значение заголовка From на значение из mail from. Данное действие не предлагает каких-либо опций:
**Заключение**
Атаки на электронную почту с подделкой отправителя, к сожалению, повседневная реальность. А последствия успешного проведения такого рода атаки могут быть крайне плачевными как для каждого человека в отдельности, так и для атакуемой организации в целом. Возможны существенные материальные потери и утечки конфиденциальной информации. Надеюсь, статья поможет разобраться как с анатомией атак поддельными письмами, так и со способами защиты. В примерах я оперировал решением Cisco ESA, однако, инструменты защиты, упомянутые в статье, реализуемы и на других системах защиты корпоративной электронной корреспонденции. | https://habr.com/ru/post/314738/ | null | ru | null |
# Cмарт розетка REDMOND SkyPort 100S
Это продолжение [моей первой статьи на смарт цоколь Redmond](https://habr.com/ru/post/450740/). В этой статье речь пойдет о другом девайсе компании Redmond — Cмарт розетка REDMOND SkyPort 100S. Данное устройство тоже базируется [на чипе nRF51822](https://www.nordicsemi.com/?sc_itemid={E343E4D9-21F1-4FBC-881F-10320A687576}) и как говорится тут сам бог велел попробовать. Итак, была куплена данная розетка. Корпус разбирается так же легко как и цоколь, доступ к порту программирования еще удобнее. Но забегая вперед скажу что все немного сложнее, чем мне показалось сначала. Схему данной розетки не стал прозванивать, т.к. уже существует куча [обзоров по модернизации](https://habr.com/ru/post/357936/) и модификации данных розеток.
В одном из обзоров нашел схему, этим и ограничился. Из схемы понятно что задействованы так же как и в смарт цоколе всего 4 пина на модуле nRF51822. На устройстве присутствует тактовая кнопка подключенная к пину p0.00, два светодиода, красный подключен к пину p0.01, зеленый подключен к пину p0.02. Электромагнитное реле на 10A подключено к пину p0.03. Итак запускаем Arduino IDE и начинаем накидывать экземпл:
```
#define BUTTON_PIN 0
#define RED_LED_PIN 1
#define GREEN_LED_PIN 2
#define RELAY_PIN 3
boolean iswitch = 0;
boolean flag_button = 0;
static uint32_t previousMillis;
//#define MY_DEBUG
#define MY_DISABLED_SERIAL
#define MY_RADIO_NRF5_ESB
//#define MY_NRF5_ESB_PA_LEVEL (NRF5_PA_LOW)
#define MY_NRF5_ESB_PA_LEVEL (NRF5_PA_MAX)
//#define MY_PASSIVE_NODE
#define MY_NODE_ID 201
#define MY_PARENT_NODE_ID 0
#define MY_PARENT_NODE_IS_STATIC
#define MY_TRANSPORT_UPLINK_CHECK_DISABLED
#define RELAY_ID 1
#include
MyMessage lMsg(RELAY\_ID, V\_STATUS);
void preHwInit() {
pinMode(BUTTON\_PIN, INPUT\_PULLUP);
pinMode(RED\_LED\_PIN, OUTPUT);
pinMode(GREEN\_LED\_PIN, OUTPUT);
pinMode(RELAY\_PIN, OUTPUT);
}
void before()
{
digitalWrite(RED\_LED\_PIN, HIGH);
}
void presentation()
{
sendSketchInfo("REDMOND R nRF51", "1.0");
wait(300);
present(RELAY\_ID, S\_BINARY, "RELAY SWITCH");
wait(300);
}
void setup()
{
digitalWrite(RED\_LED\_PIN, LOW);
wait(300);
digitalWrite(GREEN\_LED\_PIN, HIGH);
wait(200);
digitalWrite(GREEN\_LED\_PIN, LOW);
wait(200);
digitalWrite(GREEN\_LED\_PIN, HIGH);
wait(200);
digitalWrite(GREEN\_LED\_PIN, LOW);
wait(200);
digitalWrite(GREEN\_LED\_PIN, HIGH);
wait(200);
digitalWrite(GREEN\_LED\_PIN, LOW);
wait(500);
send(lMsg.set(iswitch));
wait(500);
}
void loop()
{
if (digitalRead(BUTTON\_PIN) == LOW && flag\_button == 0) {
flag\_button = 1;
previousMillis = millis();
wait(20);
}
if (digitalRead(BUTTON\_PIN) == LOW && flag\_button == 1) {
//что нибудь потом добавить, может быть
}
if (digitalRead(BUTTON\_PIN) == HIGH && flag\_button == 1) {
if ((millis() - previousMillis > 0) && (millis() - previousMillis <= 3000)) {
if (iswitch == 0) {
digitalWrite(GREEN\_LED\_PIN, HIGH);
wait(10);
} else if (iswitch == 1) {
digitalWrite(GREEN\_LED\_PIN, LOW);
wait(10);
}
flag\_button = 0;
iswitch = !iswitch;
digitalWrite(RELAY\_PIN, iswitch);
wait(1500);
send(lMsg.set(iswitch));
}
if (millis() - previousMillis > 3000)
{
flag\_button = 0;
}
}
}
void receive(const MyMessage & message) {
if (message.type == V\_STATUS) {
if (message.sensor == RELAY\_ID) {
if (mGetCommand(message) == 1) {
if (message.isAck()) {
//AckG = 1;
} else {
wait(50);
if (iswitch == 0) {
digitalWrite(GREEN\_LED\_PIN, HIGH);
}else
if (iswitch == 1) {
digitalWrite(GREEN\_LED\_PIN, LOW);
}
iswitch = !iswitch;
wait(10);
digitalWrite(RELAY\_PIN, iswitch);
wait(1500);
send(lMsg.set(iswitch));
}
}
if (mGetCommand(message) == 2) {
}
}
}
}
```
Как видите код небольшой и достаточно простой, спасибо за это сообществу Mysensors.
Как с кодом было закончено, подключил программатор к устройству и перепрошил. Подключение программатора к розетке делается очень просто, в моем случае я взял два обычных выводных резистора, откусил кусачками проволоку, из проволоки сделал крючки, согнув ее, вставил эти крючки в провода программатора и "подцепился" к розетке, на видео видно как я это делаю.Пришло время тестировать то что получилось. Вставил смарт розетку в розетку :), открыл [Мажордомо](https://mjdm.ru/), все нормально, розетка уже присутствовала в сети Майсенсорс. Отправляю первую команду на включение и… ребут :)… неожиданный поворот. Первое что пришло в голову, просадка по питанию во время включения реле. Сел переделал программу, убрал включение светодиода при включении реле, что бы снизить потребление. И это сработало, розетка перестала перезагружаться при выключении реле.… Но не надолго :). И так стало понятно что модулю не хватает питания. Схема бестрансформаторного блока питания рассчитана так, что бы хватало только на работу в режиме BLE. В Mysensors же используется другой режим радиомодуля 2.4 Ггц (совместимость с RF24 — ANT). Итак имеем дефицит примерно 10мА. Обсудив проблемку в нашем чате Mysensors остановился на решении добавить балластный конденсатор, так как это очень простая манипуляция, то что нужно для повторения. Вот что получилось:
Собрав снова розетку, немного взволнованно приступил к тестам. Отработка теперь шла превосходно. Переписал логику работы программы обратно, добавил еще #define MY\_NRF5\_ESB\_PA\_LEVEL (NRF5\_PA\_MAX), то есть "врубил" радио на полную мощность(да с [Mysensors](http://mysensors.ru/) это очень просто).… Работает. Без ошибок. Без перезагрузок. Это победа :)
А есть же еще у этого производителя другие устройства на nRF51822 — датчик дыма, датчик движения, датчик газа, тепловые конвертеры, вентиляторы, увлажнители, очистители, чайники… ;)
Телеграмм чат нашего сообщества, где всегда помогут установить библиотеки, поддержку плат, объяснят как за полчаса собрать на ардуинках сеть сенсоров без головной боли — <https://t.me/mysensors_rus> | https://habr.com/ru/post/450860/ | null | ru | null |
# Генерация музыки из изображений с помощью Python
[](https://habr.com/ru/company/ruvds/blog/708890/)
Сказать, что музыка является частью моей жизни, будет серьёзным преуменьшением. Я более 20 лет играю на гитаре, и каждый день слушаю других гитаристов. По правде говоря, прежде чем начать свой академический путь в качестве физхимика двенадцать лет назад, я был намерен строить музыкальную карьеру.
И хотя этим моим планам ну было суждено осуществиться, я всё равно продолжаю наслаждаться музыкой и делать с её помощью всякие крутые штуки. К примеру, этот проект возник из идеи написать программу, которая бы создавала музыку из изображений. В прошлом уже были довольно интересные попытки сделать нечто подобное, но вот результаты оказывались не особо музыкальными.
Далее в этой статье я расскажу о своём подходе к генерации из картинок аудиотреков, которые, имхо, звучат весьма неплохо. Здесь я опишу основные результаты и покажу некоторые удачные примеры программы. Если вы захотите посмотреть весь код, то он лежит на моём [сайте](https://victormurcia.github.io/Making-Music-From-Images-in-Python/) и в [репозитории GitHub](https://github.com/victormurcia/Making-Music-From-Images). Я также создал с помощью Streamlit приложение, с которым вы можете поэкспериментировать [здесь](https://victormurcia-making-music-from-images-music-to-images-ce4ydi.streamlitapp.com/).
▍ Основная идея
---------------
Вот моя цепочка рассуждений:
* изображения состоят из пикселей;
* пиксели состоят из массивов чисел, определяющих цвет;
* цвет выражается через цветовые пространства RGB, BGR либо HSV;
* само цветовое пространство можно разбить на разделы;
* музыкальные гаммы через звуковые интервалы подразделяются на ноты;
* звук – это вибрация, в связи с чем каждая нота ассоциируется с частотой;
* из всего этого следует, что подразделы цветового пространства можно сопоставлять с конкретными нотами в музыкальной гамме, имеющими соответствующую частоту.
Попробуем!
▍ Использование цветового пространства HSV
------------------------------------------
HSV или HSB – это цветовая модель, регулируемая тремя значениями – тоном, насыщенностью и яркостью.
*Цилиндр HSV*
*Тон* определяется «степенью, в которой стимул характеризуется похожим или отличающимся от стимулов, описываемых как красный, оранжевый, жёлтый, зелёный, синий, фиолетовый». Иными словами, тон представляет цвет.
*Насыщенность* определяется как «цветность области, оцениваемая пропорционально её яркости». То есть насыщенность отражает степень, до которой цвет смешан с белым.
*Яркость* определяется как «визуальное представление объекта, обусловленное степенью его освещённости». Иначе говоря, яркость отражает степень, в которой цвет смешан с чёрным.
Значения тона основных цветов:
* оранжевый: 0–44
* жёлтый: 44- 76
* зелёный: 76–150
* синий: 150–260
* фиолетовый: 260–320
* красный: 320–360
Я буду работать в цветовом пространстве HSV, потому что оно уже естественным образом разделено, что делает сопоставление с частотами более интуитивным. При этом канал тона (который в большей степени определяет цвет в этой модели) отделён от двух других каналов, что существенно всё упрощает.
Вот пример сравнения цветовых пространств изображения и код для их генерации:
```
# нужна функция, считывающая значение тона пикселя
hsv = cv2.cvtColor(ori_img, cv2.COLOR_BGR2HSV)
# построение изображения
fig, axs = plt.subplots(1, 3, figsize = (15,15))
names = ['BGR','RGB','HSV']
imgs = [ori_img, img, hsv]
i = 0
for elem in imgs:
axs[i].title.set_text(names[i])
axs[i].imshow(elem)
axs[i].grid(False)
i += 1
plt.show()
```
*Цветовые пространства. Автор оригинально изображения RGB — [agsandrew](https://stock.adobe.com/contributor/201652684/agsandrew?load_type=author&prev_url=detail)*
▍ Извлечение канала тона
------------------------
Получив изображение в HSV, нам нужно извлечь значение тона (h) каждого пикселя. Это можно сделать с помощью вложенного цикла `for`, перебирающего изображение по высоте и ширине.
```
i=0 ; j=0
# инициализация массива, содержащего тон каждого пикселя изображения
hues = []
for i in range(height):
for j in range(width):
hue = hsv[i][j][0] # значение тона пикселя по координатам (i,j)
hues.append(hue)
```
Получив массив значений `h` пикселей, я помещаю его в датафрейм Pandas.
В этом датафрейме, который я назвал `pixels_df`, слева указан порядковый номер пикселя, а справа его значение тона.
*Создание `pixels_df` из значений h изображения*
Сейчас датафрейм состоит из одного столбца `hues`, в котором каждая строка представляет канал `h` каждого пикселя загруженного изображения.
▍ Преобразование тонов в частоты
--------------------------------
Мой изначальный замысел по преобразованию значений тона в частоту подразумевал сопоставление предопределённого набора частот со значением `h`. Вот соответствующая функция:
```
# определение частот, составляющих гамму ля минор гармонический
scale_freqs = [220.00, 246.94 ,261.63, 293.66, 329.63, 349.23, 415.30]
def hue2freq(h,scale_freqs):
thresholds = [26 , 52 , 78 , 104, 128 , 154 , 180]
note = scale_freqs[0]
if (h <= thresholds[0]):
note = scale_freqs[0]
elif (h > thresholds[0]) & (h <= thresholds[1]):
note = scale_freqs[1]
elif (h > thresholds[1]) & (h <= thresholds[2]):
note = scale_freqs[2]
elif (h > thresholds[2]) & (h <= thresholds[3]):
note = scale_freqs[3]
elif (h > thresholds[3]) & (h <= thresholds[4]):
note = scale_freqs[4]
elif (h > thresholds[4]) & (h <= thresholds[5]):
note = scale_freqs[5]
elif (h > thresholds[5]) & (h <= thresholds[6]):
note = scale_freqs[6]
else:
note = scale_freqs[0]
return note
```
Она получает значение `h` и массив частот. В данном примере для определения частот задействуется массив `scale_freqs.` Используемые в этом массиве частоты соответствуют гамме ля минор гармонический.
Далее я определяю массив значений порога `thresholds` для `h`, который буду использовать для преобразования `h` в частоту из `scale_freqs` при помощи лямбда-функции.
```
pixels_df['notes'] = pixels_df.apply(lambda row : hue2freq(row['hues'],scale_freqs), axis = 1)
```
*Датафрейм `pixels_df`, в котором частоты сопоставлены с каждым значением тона*
▍ Преобразование массива NumPy в аудио
--------------------------------------
Круто! Теперь, имея массив частот, я преобразую столбец `notes` в массив NumPy `frequencies`, с помощью которого смогу сгенерировать аудио. Для этого я использую SciPy функцию `wavfile.write` и подходящий вид преобразования типа данных (для одномерных массивов это `np.float32`).
```
frequencies = pixels_df['notes'].to_numpy()
song = np.array([])
sr = 22050 # частота дискретизации
T = 0.1 # длительность 0.1 секунды
t = np.linspace(0, T, int(T*sr), endpoint=False) # переменная времени
#создание трека с помощью массива NumPy :]
#nPixels = int(len(frequencies))# все пиксели изображения
nPixels = 60
for i in range(nPixels):
val = frequencies[i]
note = 0.5*np.sin(2*np.pi*val*t) # представляет каждую ноту в виде синусоиды
song = np.concatenate([song, note]) # добавляет ноты в массив song для создания трека
ipd.Audio(song, rate=sr) # загружает массив NumPy в виде аудио
```
Вот трек, который я создал, используя первые 60 пикселей изображения ниже. Можно было задействовать все 230,400 пикселей, но тогда трек получился бы длиной в несколько часов.
Звучит весьма недурно, но мне хочется ещё над этим поработать.
▍ Добавление вариации по октавам
--------------------------------
Я решил внести в программу эффект сдвига октав (то есть понижение или повышение звука). Используемая для конкретной ноты октава будет случайным образом выбираться из массива.
```
song = np.array([])
octaves = np.array([0.5,1,2])
sr = 22050 # частота дискретизации
T = 0.1 # длительность 0.1 секунды
t = np.linspace(0, T, int(T*sr), endpoint=False) # переменная времени
# создание трека с помощью массива NumPy :]
#nPixels = int(len(frequencies))# все пиксели изображения
nPixels = 60
for i in range(nPixels):
octave = random.choice(octaves)
val = octave * frequencies[i]
note = 0.5*np.sin(2*np.pi*val*t)
song = np.concatenate([song, note])
ipd.Audio(song, rate=sr) # загрузка массива NumPy
```
Послушаем!
Превосходно! Мы получили некоторое разнообразие. Но все же у нас есть огромное число пикселей, так почему бы не использовать их путём случайного выбора?
```
song = np.array([])
octaves = np.array([1/2,1,2])
sr = 22050 # частота дискретизации
T = 0.1 # длительность 0.1 секунды
t = np.linspace(0, T, int(T*sr), endpoint=False) # переменная времени
# создание трека с помощью массива NumPy :]
#nPixels = int(len(frequencies))# все пиксели изображения
nPixels = 60
for i in range(nPixels):
octave = random.choice(octaves)
val = octave * random.choice(frequencies)
note = 0.5*np.sin(2*np.pi*val*t)
song = np.concatenate([song, note])
ipd.Audio(song, rate=sr) # загрузка массива NumPy
```
Получился типа Calcucore! Теперь у нас, по сути, есть генератор треков, с которым можно вдоволь экспериментировать.
Я понимаю, прозвучит почти как мем, но «разве это не математический рок?»
▍ Генерация других гамм
-----------------------
Пока что я показал, как можно генерировать музыку из изображений, используя гамму ля минор гармонический. Но, несмотря на всю крутость этой гаммы, было бы неплохо внести немного разнообразия в начальную ноту (тонику) и добавить интервалы, помимо тех, что определяются её структурой. Это позволит нашей программе вносить в генерируемые треки куда больше нюансов и вариативности.
Чтобы это реализовать, первым делом мне нужно найти способ процедурно генерировать частоты для любой тоники, которую я захочу использовать. У Кэти Хе есть [прекрасная статья](https://towardsdatascience.com/music-in-python-2f054deb41f4), в которой она рассматривает возможность работы с музыкой при помощи Python. Я применил одну из представленных в той статье функций для сопоставления нот фортепиано с частотами:
```
def get_piano_notes():
# Белые клавиши указаны в верхнем регистре, а чёрные в нижнем
octave = ['C', 'c', 'D', 'd', 'E', 'F', 'f', 'G', 'g', 'A', 'a', 'B']
base_freq = 440 #Frequency of Note A4
keys = np.array([x+str(y) for y in range(0,9) for x in octave])
# Обрезка до стандартных 88 клавиш
start = np.where(keys == 'A0')[0][0]
end = np.where(keys == 'C8')[0][0]
keys = keys[start:end+1]
note_freqs = dict(zip(keys, [2**((n+1-49)/12)*base_freq for n in range(len(keys))]))
note_freqs[''] = 0.0 # stop
return note_freqs
```
Эта функция служит в качестве основы для моей программы генерации треков/гамм, и с её помощью можно создать словарь сопоставлений нот, соответствующих 88 клавишам стандартного фортепиано, с частотами в герцах, как это показано ниже:
```
# загрузка словаря нот
note_freqs = get_piano_notes()
```
Далее нужно определить интервалы гаммы в тонах, чтобы можно было индексировать ноты.
```
# Определение тонов. В верхнем регистре указаны белые клавиши, а в нижнем - чёрные
scale_intervals = ['A','a','B','C','c','D','d','E','F','f','G','g']
```
Теперь можно находить индекс нашей гаммы в списке тонов, приведённом выше. Это необходимо, поскольку далее я буду реиндексировать этот список, чтобы он начинался с нужной тоники.
```
# поиск индекса нужной клавиши
index = scale_intervals.index(whichKey)
# переопределение интервала гаммы, чтобы он начинался с определённой клавиши
new_scale = scale_intervals[index:12] + scale_intervals[:index]
```
После этого я смогу определять множество разных массивов гамм, в которых каждый элемент соответствует индексу из переиндексированного массива, полученного в предыдущем шаге.
```
#выбор масштаба
if whichScale == 'AEOLIAN':
scale = [0, 2, 3, 5, 7, 8, 10]
elif whichScale == 'BLUES':
scale = [0, 2, 3, 4, 5, 7, 9, 10, 11]
elif whichScale == 'PHYRIGIAN':
scale = [0, 1, 3, 5, 7, 8, 10]
elif whichScale == 'CHROMATIC':
scale = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
elif whichScale == 'DORIAN':
scale = [0, 2, 3, 5, 7, 9, 10]
elif whichScale == 'HARMONIC_MINOR':
scale = [0, 2, 3, 5, 7, 8, 11]
elif whichScale == 'LYDIAN':
scale = [0, 2, 4, 6, 7, 9, 11]
elif whichScale == 'MAJOR':
scale = [0, 2, 4, 5, 7, 9, 11]
elif whichScale == 'MELODIC_MINOR':
scale = [0, 2, 3, 5, 7, 8, 9, 10, 11]
elif whichScale == 'MINOR':
scale = [0, 2, 3, 5, 7, 8, 10]
elif whichScale == 'MIXOLYDIAN':
scale = [0, 2, 4, 5, 7, 9, 10]
elif whichScale == 'NATURAL_MINOR':
scale = [0, 2, 3, 5, 7, 8, 10]
elif whichScale == 'PENTATONIC':
scale = [0, 2, 4, 7, 9]
else:
print('Invalid scale name')
```
Почти готово! Я также определю здесь интервалы на случай, если мне захочется использовать их при генерации музыки.
```
#создание словаря интервалов
#прима = U0 #полутон = ST
#большая секунда = M2 #малая терция = m3
#большая терция = M3 #чистая кварта = P4
#тритон = DT #чистая квинта = P5
#малая секста = m6 #большая секста = M6
#малая септима = m7 #большая септима = M7
#октава = O8
harmony_select = {'U0' : 1,
'ST' : 16/15,
'M2' : 9/8,
'm3' : 6/5,
'M3' : 5/4,
'P4' : 4/3,
'DT' : 45/32,
'P5' : 3/2,
'm6': 8/5,
'M6': 5/3,
'm7': 9/5,
'M7': 15/8,
'O8': 2
}
```
И вот теперь остался последний шаг, чтобы можно было начать генерировать треки.
```
# получение длины гаммы в нотах
nNotes = len(scale)
# инициализация массивов
freqs = []
#harmony = []
#harmony_val = harmony_select[makeHarmony]
for i in range(nNotes):
note = new_scale[scale[i]] + str(whichOctave)
freqToAdd = note_freqs[note]
freqs.append(freqToAdd)
#harmony.append(harmony_val*freqToAdd)
```
Прекрасно! Теперь у меня есть возможность экспериментировать с различными параметрами. Я могу устанавливать гамму, клавишу, октаву, интервал, количество пикселей, а также определять, будут ли пиксели выбираться случайным образом, и определять продолжительность каждой ноты.
Протестируем готовую программу на нескольких изображениях. Частота дискретизации во всех случаях составляет 22050 Гц, если иное не указано явно.
Тем, кто читает статью на смартфоне, я рекомендую слушать треки из следующего раздела в наушниках, поскольку некоторые низкие частоты стандартным динамиком телефона передаются плохо.
▍ Эксперимент с пиксельной графикой
-----------------------------------
Естественным полем для экспериментов является пиксельная графика. Вот один из множества треков, полученных на основе этого прекрасного произведения [@Matej ‘Retro’ Jan](https://medium.com/@retronator?source=post_page-----2e211a6200e2--------------------------------). Данный трек был сгенерирован при использовании третьей октавы и тональности ля мажор. По-моему, звучит очень интересно. У меня он ассоциируется с прогулкой по небольшому жизнерадостному городку. На мой взгляд, этот трек отлично подойдёт в качестве интро для старой видеоигры.
*Пиксельная версия China Mountains, Matej ‘Retro’ Jan, 2013, полученная на основе картины [China Mountains](http://martanael.deviantart.com/art/China-Mountains-345041389) Марты Наэль*
▍ Песнь павлина
---------------
Этот трек с я получил, используя E Dorian и диапазон третьей октавы.
▍ Песнь воды
------------
Этот трек мой любимый. Его я сгенерировал с использованием B Lydian и диапазона второй октавы. Мне кажется, он отлично звучал бы в качестве гитарного риффа. Напоминает музыку Dream Theatre.
▍ Песнь Каттерины
-----------------
Моя кошка Каттерина приносит мне кучу радости. Этот трек я сделал, используя ля минор гармонический и диапазон третьей октавы. На мой взгляд, звучит очень классно.
▍ Добавление в треки интервалов через 2D-массивы NumPy
------------------------------------------------------
Моя программа позволяет добавлять в треки интервалы. Пользователь может выбирать, какой из них использовать (например, чистую квинту, малую сексту и т. п.), после чего с помощью показанных ранее программ из него выводится правильный диапазон нот. Ниже я покажу пример полученного из изображения трека, соответствующий интервал и результат их объединения с помощью 2D-массива NumPy в виде wav-файла.
Согласно документации для `scipy.io.wavfile.write`, если я хочу записать двухмерный массив в wav-файл, то его размеры должны соответствовать форме (`Nsamples`, `Nchannels`). Заметьте, что сейчас наш массив имеет форму (2, 264600), то есть количество `Nchannels = 2`, а `Nsamples = 264600`. Чтобы обеспечить правильность формы нашего массива для `scipy.io.wavfile.write`, я сперва его транспонирую. Этот трек был получен при использовании гармонического минора ля диез, диапазона второй октавы и малой терции.
*Отражение неба в воде (Национальный парк Файордленд в Новой Зеландии). Фото из [галлереи Mark Gray](https://www.markgray.com.au/)*
▍ Добавление в треки эффектов с помощью библиотеки от Spotify
-------------------------------------------------------------
Великолепно! Хотя можно ещё многое сделать. Я собираюсь загрузить wav-файл и поиграться с ним, используя модуль pedalboard. Это прекрасный инструмент, и я настоятельно рекомендую вам с ним ознакомиться. Информацию о нём можно найти [здесь](https://github.com/spotify/pedalboard) и [здесь](https://spotify.github.io/pedalboard/reference/pedalboard.html).
Сначала я переделаю песнь воды, используя предлагаемые pedalboard настройки *Compressor*, *Gain*, *Chorus*, *Phaser*, *Reverb* и *Ladder Filter*. Вот результат:
Супер круто! Просто отпад! Представьте себе этот трек в сочетании с ударными или живыми инструментами.
Теперь я обработаю песнь Каттерины, используя *Ladder Filter*, *Delay*, *Reverb* и *Pitch Shift*. Вот результат:
Мм, довольно приятно!
Ну и в качестве последнего примера я заново сгенерирую трек на основе природного ландшафта из Национального парка, используя *Ladder Filter*, *Delay*, *Reverb*, *Chorus*, *Pitch Shift* и *Phaser*:
▍ Получение нот и номеров MIDI с помощью Librosa
------------------------------------------------
Librosa – это прекрасный пакет, позволяющий производить с аудиоданными различные манипуляции. С ним я тоже советую ознакомиться. Здесь с его помощью я преобразовал частоты в ноты и номера MIDI.
MIDI формат позволяет использовать файлы на различных электронных инструментах, компьютерах и прочих аудио-устройствах, так что возможность сохранять в нём треки даст возможность экспериментировать с ними другим заинтересованным музыкантам или программистам.
Ниже показаны функции, которые можно использовать для сопоставления сгенерированных моей программой частот, чтобы получить музыкальные ноты и `midi_numbers` трека.
```
# преобразование частоты в ноту
catterina_df['notes'] = catterina_df.apply(lambda row : librosa.hz_to_note(row['frequencies']),
axis = 1)
# преобразование ноты в номер MIDI
catterina_df['midi_number'] = catterina_df.apply(lambda row : librosa.note_to_midi(row['notes']),
axis = 1)
```
*Итоговый датафрейм трека, полученный с помощью librosa и pandas*
▍ Получение трека в формате MIDI
--------------------------------
Теперь, когда у меня есть датафрейм с частотами, нотами и номерами MIDI, я могу получить из него MIDI-файл, который позволит сгенерировать партитуру трека.
Создам я этот файл с помощью пакета midiutil, позволяющего генерировать MIDI-файлы на основе массивов MIDI-чисел. Этот инструмент позволяет изменять всяческие настройки вроде громкости, темпа и дорожек. Пока что я просто сделаю MIDI-файл с одной дорожкой.
```
# преобразование столбца номеров MIDI в массив NumPy
midi_number = catterina_df['midi_number'].to_numpy()
degrees = list(midi_number) # номер MIDI ноты
track = 0
channel = 0
time = 0 # в ударах
duration = 1 # в ударах
tempo = 240 # в BPM
volume = 100 # 0-127, согласно стандарту MIDI
MyMIDI = MIDIFile(1) # одна дорожка, по умолчанию устанавливается на 1 (дорожка темпа создаётся автоматически)
MyMIDI.addTempo(track,time, tempo)
for pitch in degrees:
MyMIDI.addNote(track, channel, pitch, time, duration, volume)
time = time + 1
with open("catterina.mid", "wb") as output_file:
MyMIDI.writeFile(output_file)
```
▍ Заключение
------------
Вот я и показал, как можно делать музыку из изображений и экспортировать её в wav-файлы для последующей обработки. Я также продемонстрировал использование этого метода для построения интервалов, которые могут получаться довольно сложными, богатыми и даже странными. Мне хочется добавить в свой инструмент ещё кое-что, но пока я это отложу. Поле для экспериментов здесь огромное!
Если у вас, как у музыканта, вдруг возникнут сложности с поиском нового звука, то попробуйте закинуть картинку в моё приложение, и, быть может, оно подкинет вам годную стартовую идею. Никогда не знаешь, откуда придёт вдохновение.
Для меня этот проект был очень интересен, и, надеюсь, вам его результаты тоже пришлись по нраву.
Для всех желающих я ещё раз продублирую [ссылку на репозиторий GitHub](https://github.com/victormurcia/Making-Music-From-Images) и на [приложение Streamlit](https://victormurcia-making-music-from-images-music-to-images-ce4ydi.streamlitapp.com/).
Развлекайтесь, и благодарю за чтение!
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=generaciya_muzyki_iz_izobrazhenij_s_pomoshhyu_python) | https://habr.com/ru/post/708890/ | null | ru | null |
# Способ связать разные компьютеры в одну сеть
##### Задача
Есть несколько компьютеров, которые необходимо соединить в одну сеть, в не зависимости от операционной системы, аппаратной платформы, способа передачи данных и сетевого расположения. Создаваемая сеть позволит передавать данные от промышленного компьютера, управляющего технологическим процессом на всевозможные потребители (с дальнейшей обработкой этих данных), с возможностью обратной связи (для отдачи команд на исполнение).
##### Возможные средства исполнения
Существует несколько способов связать компьютеры в одну сеть. Например, VPN. В указанном случае неудобно то, что придётся перелопатить прошивку промышленного компьютера, или вмешаться в логику работы АРМа. В первом случае — перепрошивать совсем не хочется, да и нет необходимых средств/навыков, затраты на изучение платформы нерационально велики. Вмешательство в логику работы АРМа(SCADA InTuch) — также приведёт к потери гарантии. Ко всему прочему, довольно важно обеспечивать работу АРМа в режиме реального времени, а это гарантия мгновенной реакции системы на управляющее воздействие. Ни много, ни мало, а кому-то это спасёт жизнь.
Что ещё у нас есть? Ну например, SSH. Не подходит по аналогичным причинам. Хотя уровень требуемой безопасности вполне соответствует, но сложность переделок загоняет в тупик.
##### Приемлемое решение задачи
Итак, во внутренности работающих систем не лезем. Система обеспечивает вполне доступные средства обмена информацией в простых формах простыми средствами. Как правило, это текст с временными метками, указанием на уровень предупреждающих сообщений, отчёт о исполнении команд.
Ничто не мешает брать эти данные с машины под управлением АРМа, и на отдельной машине дальше с ними работать. Так как машина для связи является отдельной — можно не опасаться за подвисания, сбои и падения в самый неудобный момент времени. Впрочем, такое поведение будет говорить о плохой постановке вопроса, и как следствие — плохом решении. Ко всему прочему, машина может не находиться физически на опасном промышленном объекте (ОПО, обязателен к регистрации в органах Ростехнадзора), зачастую на объекте не предусмотрено место под дополнительное оборудование, а если предусмотрено, то потребуется провести проектные мероприятия, лицензирование, перерегистрацию и т. д. В конечном итоге, это тоже дорого и долго. А каналы связи, как правило, закладываются заблаговременно, и являются штатными средствами.
Сам способ связи компьютеров, очевидно, не должен базироваться на DNS, TCP\IP, UDP непосредственно.
##### Выбор технологии
Вполне понятно, что создавать средства связи с чистого листа крайне накладно. Опираться на низкоуровневые средства также невыгодно из-за жёсткой привязки. Очевидно это будет высокоуровневый протокол, с опорой на уже существующие наработки.
Особенности любой SCADA-системы в том, что объём передаваемых данных совсем не велик, но в тоже время, должна быть оперативность. Понятно, что при попытки связать SCADA на PC и мобильный телефон (с Java), необходимо обеспечить оперативность доставки информации. Т. о. из указанных высокоуровневых протоколов исключаются эл. почта, сильно ограничен ftp и др. средства рассчитанные на длительные промежутки времени.
Наиболее подходящим типом связи будет являться протокол, основанный на передаче коротких сообщений. В качестве основы, теоретически, можно рассматривать какие угодно интернет-пейджеры: ICQ, mail.ru, MSN, jabber и ещё с десяток других. Практически, из всего разнообразия, остаётся всего пару штук. Так например, ICQ — закрытый протокол, и в любой момент может измениться. Ко всему прочему, если копирайтер вычислит, что его протокол используется «не по назначению», — возникнут проблемы более чем финансового характера. По тем же причинам отпадают все коммерческие или закрытые протоколы. Малораспространённые, протоколы либо не имеют нормальной поддержки, либо не обеспечивают приемлемое качество связи. В конечном итоге, благодаря открытости, наличию массы библиотек, транспортов и расширений, вот он наш победитель — jabber.
##### Эффект рычага
Технически, можно устроить чехарду с манипуляцией окнами — в одном месте данные прочитал из файла/сокета, послал окну сообщение всплыть на передний план, эмулировать нажатие клавиш, для вставки нужного сообщения, и далее эмулировать нажатие кнопки «отправить», со сворачиванием окна. Этот инверсно-ректальный метод вполне имеет право на существование. Именно так, уже более трёх лет функционирует АРМ диспетчера вагонного депо, из-за того, что какой-то умник решил, что принтер обязательно подключен к com-порту, и подсистема печати де-факто и де-юро в Windows отсутствует. (были перепробованы практически все способы решения проблемы, в т. ч. с виртуальными DOS-принтерами).
В данном случае интересует, всё-таки, человеческое решение проблемы. Человеческое решение предполагает под собой законченный, компактный механизм, не раздражающий ежесекундными произвольными манипуляциями с конами, мышью и клавиатурой. В любом случае, за такой машиной, уже работать нельзя (по крайней мере, не под одной учётной записью, и не на одном рабочем столе).
Jabber обладает как большой группой пользователей, так и развитыми средствами взаимодействия. Децентрализованная сеть, возможность на вполне законных основаниях поднять свой сервер, и связать с другими — приятно завершает перспективу. Впрочем, серверов в интернете более чем достаточно, и необходимость в собственном сервере возникает более чем редко. Ещё раз следует повторить: передавать большие объёмы данных возможно, но не следует злоупотреблять добротой тех, кто содержит сервера.
##### Средства производства
В качестве языка программирования выбран Python. Вполне легковесный, «батарейки идут в комплекте», не ограничен лицензированием, есть подо все платформы, переносим. Этого вполне достаточно для обоснования выбора.
В комплект к Python всё-таки придётся добавить одну «батарейку» — **xmpppy**. Это дополнительная библиотека, специально разработанная для работы по протоколу XMPP/jabber. Она не развивается официально, но сообщество чуть ли не ежедневно добавляет что-либо в неё (официальных релизов уже не было давно). На просторах рунета лежит несколько примеров её использования, они легко ищутся, ссылки будут приведены в случае необходимости).
Итак, код с комментариями, достаточный для обеспечения связи компьютер-компьютер/мобильник/смартфон/тачпад. Подразумевается, что информация приходит на jabber-клиент.
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
пример создания jabber-связи
для передачи данных между несвязанными компьютерами
Author: -=[fantom]=-@jabber.ru
Data: 2011-09-03
License: GPL
'''
import xmpp
from time import sleep
def msgparser(instance, message):
'''
Функция - обработчик сообщения. Нужна для
обратной связи. В противном случае клиент не сможет получать данные
о состоянии системы.
'''
# вообще, использование глобальных переменных - плохая идея не только в Python
global myclient
s=message.getBody()
if s<>None:
print '------------------------'
print 'новое сообщение!'
print 'от: ', message.getFrom()
print 'сбщ: ', s, len(s)
myclient.send(xmpp.Message(message.getFrom(),'hello, '+s))
# задаёмся именем пользователя (в данном случае- JID-автора)
jid=xmpp.protocol.JID('-=[fantom]=-@jabber.org')
# создаём клиента
myclient=xmpp.Client(jid.getDomain(),debug=[None])
# подключаем клиента
print 'Метод шифрования\t=', myclient.connect() #‘tls’
print 'Метод авторизации\t=', myclient.auth(jid.getNode(),'xxxxxxxxxxx') # ‘sasl’, вместо много 'xxxx' - пароль
# делаем статус
print myclient.sendInitPresence()
# устанавливаем статус. Без него часто работать вообще нельзя
presence = xmpp.Presence(status = 'ООО "АРВИ НПК" г. Черняховск', show = 'chat', priority = '1')
print myclient.send(presence)
# регистрируем обработчик сообщений
myclient.RegisterHandler('message', msgparser)
# составляем сообщение для отправки (кому отправляем)
mymsg=xmpp.protocol.Message('-=[fantom]=-@jabber.ru','Проверка отправленного сообщения!', 'chat')
# отправляем сообщение
print myclient.send(mymsg)
# запускаем обработчик процесса
# и делаем это в цикле
myclient.online=1
while myclient.online==1:
# инструкция sleep - как правило не требуется, дополнительная задержка лишь приведёт к сбоям
#sleep(2)
myclient.Process(1)
# корректно завершаем сессию
myclient.disconnect()
```
Приведённый код достаточно прокомментирован, чтобы решить в дальнейшем 99,5% задач.
В промышленных целях крайней не рекомендуется использовать операционные системы семейства Windows. Это не очередной виток холивар, это печальный опыт применения в промышленности. ко всему прочему, возможность связки внешнего оборудования и программной начинки PC — сильно ограничено, по сравнению с конкурентами. При сильном желании и избыточном количестве денег и эта проблема может быть решена, но если «брюки выглядят одинаково, зачем платить больше»?
##### Краткий итог
В приведённом примере не раскрыт механизм связи АРМ и клиента от начала и до конца. Решена лишь та часть, которая обеспечивает связь сколь угодно большого числа компьютеров со сколь угодно странно, в сетевом отношении, расположенными машинами. Дальнейшее наращивание обработчиков (или логики одного обработчика) позволит решить неограниченный круг задач по созданию информационной инфраструктуры. Встроенные средства обеспечения безопасности позволяют закрыть изначально массу брешей. Использование протокола высокого уровня позволяет поверх него создать дополнительные надстройки в интересах пользователей. Обеспечение устойчивой связи сократит время и средства на диагностику и устранение неисправностей. Инженерам АСУП указанная методика сохранит не один час свободного времени и нервов. Подключенные к PC внешний устройства (датчики, сигнализация охранная/пожарная, средства измерения) можно контролировать и программировать дистанционно. | https://habr.com/ru/post/127892/ | null | ru | null |
# Как я программирую под ExtJS и Zend Framework
Как известно последня версия Zend Framework включает в себя js библиотеки dojo. но, не смотря на это, для работы я выбрал связку Zend Framework + Ext JS.
Почему Zend Framework — в нем отлично реализован принцип MVC, он хорошо документирован, имеет много полезных библиотек, поддерживается Zend — ом. Да, есть недостатки — не самый быстрый, некоторые модули нужно брать у сторонних разработчиков.
Почему ExtJS — также хорошо документировано, имеет много компонентов, отлично реализована оконная модель, Grid — доведен до идеала.
Пока что не буду останавливатся на таких деталях как авторизация, построение интерфейса, подгрузка скриптов.
Ибо тут можно и книгу написать, о всех нюансах.
Вкратце раскажу о трех компонентах, которые чаще необходимы для работы с данными — TreePanel, GridPanel, Form Panel.
TreePanel использую в основном для отображения категорий каких либо данных. категории имеют древообразную структуру. для создания дерева использую модель [nested sets](http://dev.mysql.com/tech-resources/articles/hierarchical-data.html).
создаю контроллер для работы с TreePanel. в упрощенно виде он выглядит примерно так:
`class TreeController extends Zend_Controller_Action {
public function init()
{
if ($this->getRequest()->isXmlHttpRequest()) {
Zend_Controller_Action_HelperBroker::removeHelper('viewRenderer');
}
}
public function indexAction()
{
$parent = $this->getRequest()->getParam('node', 0);
$table = $this->getRequest()->getParam('table', 0);
Zend_Loader::loadClass('Tree');
$tree = new Content();
$res = $tree->getItems($parent, $classname);
echo $res;
}
}`
основной момент в работе с Zend Framework с AJAX:
если запрос AJAX — убираем использование вьювера.
`if ($this->getRequest()->isXmlHttpRequest()) {
Zend_Controller_Action_HelperBroker::removeHelper('viewRenderer');
}`
Создаю модель Tree. в методе getItems($parent, $table) прописую выборку с таблицы $table данных с parent = $parent. возвращаю масив в формате JSON (можна XML конечно, кому как нравится).
формат данных получается примерно такой:
`[{"text":"category1","id":"1"},{"text":"category2","id":"2"},{"text":"category3","id":"3"}}]`
дальше работаем с ExtJS.
на панеле размещаю дерево.
`var categoriesTree = new Ext.tree.TreePanel({
id:'tree',
....
loader: new Ext.tree.TreeLoader({
dataUrl: '/tree/',
baseParams: {
table: 'categories'
}
})
});
var rootNode = new Ext.tree.AsyncTreeNode( {
text: 'Root',
draggable:false,
id: 'root',
expanded:true
})
categoriesTree.setRootNode(rootNode);
rootNode.expand();`
примерно код такой. при загрузке странички и отрендеривании дерева, загружаются корневые ветки. по мере необходимости при нажатии на плюсики — подгружаются остальные.
кроме загрузки реализовал добавление/удаление узлов, перетаскивание с ветки на ветку.
аналогично реализовал таблицу GridPanel в паре с контроллером GridController. используется для отображения данных, редактировании порядка, удаления.
для добавления новых данных и для их редактирования использую связку FormPanel + FormController.
Если тема интересна, то продолжу их описание. | https://habr.com/ru/post/54849/ | null | ru | null |
# Дайджест интересных новостей и материалов из мира PHP за последние две недели №22 (15.07.2013 — 28.07.2013)
Предлагаем вашему вниманию очередную подборку с ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [AspectMock — тестируем любой PHP код](http://habrahabr.ru/post/187622/)  — Замечательное применение библиотеки [Go! AOP](http://go.aopphp.com/), благодаря возможностям которой, тестировать в PHP теперь можно буквально все! При этом код становится даже проще. Доступен [скринкаст с демонстрацией AspectMock](http://jeffrey-way.com/blog/2013/07/24/aspectmock-is-pretty-neat/). Отлично!
* [Вышел PHP 5.5.1](http://php.net/index.php#id2013-07-18-1) — Спустя месяц после релиза 5.5 вышло первое обновление, которое включает около 20 исправлений, в том числе безопасности XML парсера, а также ошибок в опкэше, веб-сервере, PDO, Phar и другие.
* [KPHP от ВКонтакте](http://habrahabr.ru/post/187214/)  — На своей странице Дуров рассказал о переводе всего кода ВКонтакте на компилируемый язык программирования — KPHP, что, как стало известно позже, требовало полного избавления от ООП. Вскоре на Хабре появились [ответы на вопросы и комментарии от разработчиков из ВКонтакте](http://habrahabr.ru/company/roem/blog/187352/) . Что ж, дождемся появления KPHP в открытом доступе.
* [Slim Framework 2.3.0](http://slimframework.com/news/version-230) — Обновился популярный микрофреймворк.
* [Командная строка WordPress](http://habrahabr.ru/post/185428/)  — Весьма полезный инструмент для разработчиков использующих WordPress.
* [Gerar PHP](http://rarestblog.com/blog/2013/07/27/gerar-php/) — Автор загорелся идеей реализовать систему управления конфигурациями вроде Chef или Puppet, но на PHP, поскольку ему, как PHP-разработчику, удобно было бы работать с PHP-синтаксисом. Результатом стал [Gerar PHP](https://github.com/slava-vishnyakov/gerar-php).
### PHP
* [Развитие синтаксиса](https://igor.io/2013/07/26/evolving-syntax.html) — Интереснейший пост от Igor Wiedler, core-разработчика PHP, автора [React](http://reactphp.org/) и [Stack](http://stackphp.com/). Описана идея реализации механизма синтаксической абстракции в PHP. Вдохновившись [макросами в Лиспе](http://ru.wikibooks.org/wiki/Лисп/Макросы)  и использовав [PHP Parser](https://github.com/nikic/PHP-Parser), автор создал демонстрацию своей идеи и портировал возможности PHP 5.4 на версию 5.3.
* [Cинтаксический сахар для PHP](http://habrahabr.ru/post/186656/)  — Автор хабрапоста начал создавать проект [PHP Mirror](https://github.com/SerafimArts/Mirror), который предполагает добавление целого ряда полезных возможностей в PHP. На данный момент уже реализовано приведение типов.
* [RFC: Импорт функций из пространств имен](https://wiki.php.net/rfc/use_function) — На данный момент PHP позволяет импортировать из пространств имен отдельные типы (классы/интерфейсы/трейты) с помощью оператора `use`. Автор RFC предлагает добавить возможность импортировать отдельные функции с помощью конструкции `use function` и константы — `use const`.
### Материалы для обучения
* [Интернационализация на PHP с помощью gettext](http://blog.lingohub.com/2013/07/php-internationalization-with-gettext-tutorial/) — Отличный большой и подробный туториал по использованию библиотеки [gettext](http://ru.wikipedia.org/wiki/Gettext) .
* [Laravel 4 — расширяем легко](http://laravel.io/topic/39/laravel-4-easily-extended) — Автор вынужден был помочь в использовании Laravel 4 на shared-хостинге с не самой свежей версией PHP. В посте он демонстрирует, как благодаря компонентной архитектуре фреймворка его можно легко расширять и модифицировать, например, чтобы снизить требования к версии PHP.
* [Масштабируем PHP на EC2 до 30,000 пользователей на сервер](https://coderwall.com/p/__z9ia) — В посте автор приводит несколько рекомендаций по оптимизации производительности PHP-приложения, запущенного на серверах от Amazon. Большинство рекомендаций универсальны и будут актуальны для любых платформ.
* [PHP взрывает Google App Engine](http://venturebeat.com/2013/07/18/google-app-engine-and-php-its-amazing-and-we-didnt-anticipate-this/) — Чуть больше двух месяцев назад Google [анонсировал](http://googlecloudplatform.blogspot.com/2013/05/app-engine-adds-php-support.html) поддержку PHP на своей облачной платформе App Engine. По ссылке интервью с менеджером проекта App Engine, который кроме прочего говорит о намерениях Google конкурировать с Amazon, Microsoft и другими игроками на рынке облачных платформ.
Также [немного мыслей](http://www.eschrade.com/page/google-finally-acknowledges-that-php-exists/) по теме.
* [Использование встроенного веб-сервера PHP в ваших тестах](http://tech.vg.no/2013/07/19/using-phps-built-in-web-server-in-your-test-suites/) — Начиная с версии 5.4 PHP поставляется со встроенным веб-сервером. Автор поста демонстрирует способ конфигурации PHPUnit для запуска веб сервера перед выполнением набора тестов, и завершением его работы после окончания тестирования.
* [Структуры данных для PHP-разработчиков: Куча](http://phpmaster.com/data-structures-3/) — Продолжение серии постов для молодых и начинающих разработчиков. Читайте также о [деревьях](http://phpmaster.com/php-data-structures-2/), [стеке и очереди](http://phpmaster.com/php-data-structures-1/).
* [Использование третьесторонних библиотек в проектах с Composer](http://blog.calevans.com/2013/07/21/using-3rd-party-libraries-in-composer-projects/) — Небольшой совет о том, как подключать библиотеки не поддерживающие Composer в проектах использующих его.
* [Yiistrap и Yiiwheels](http://rmcreative.ru/blog/post/yiistrap-i-yii-wheels)  — Пара отличных расширений для Yii, позволяющих значительно сократить время на реализацию фронт-енд задач.
* [Двойники на PHP с помощью Prophecy](http://techportal.inviqa.com/2013/07/23/php-test-doubles-patterns-with-prophecy/) — В посте речь идет об использовании библиотеки [Prophecy](https://github.com/phpspec/prophecy) для реализации тестовых двойников: dummy-объектов, заглушек, mock-объектов.
* [Работаем с многобайтными строками](http://phpmaster.com/working-with-multibyte-strings/) — Полноценную поддержку UTF-8 в PHP обещают не раньше чем в версии 6.0, а пока можно использовать возможности mbstring. В туториале по ссылке найдете немного теории по кодировкам и информации об использовании расширения mbstring.
* [Создаем достойный API](http://philsturgeon.co.uk/blog/2013/07/building-a-decent-api) — Ряд советов и рекомендаций для PHP-разработчиков по проектированию и реализации API.
* [Beanstalkd и очереди из Laravel 4](http://fideloper.com/ubuntu-beanstalkd-and-laravel4) — Небольшой туториал по использованию очередей в Laravel 4, и о том, как организовать фоновое выполнение задач из очереди с помощью [Beanstalkd](http://kr.github.io/beanstalkd/).
* [Получаем доступ к приватным свойствам объектов в PHP без рефлексии](http://habrahabr.ru/post/186718/)  — Хабраперевод поста, в котором автор был не доволен слишком низкой скоростью работы ReflectionClass и ReflectionProperty, и продемонстрировал более эффективный способ с использованием метода [Closure::bind](http://php.net/manual/en/closure.bind.php).
* [Создаем приложение на Laravel на AppFog](http://bwsewell.com/2013/07/11/creating_a_laravel_app_on_appfog.html) — Скринкаст о развертывании Laravel 3 на популярном PaaS-хостинге.
* [Интернационализация в 5 самых популярных PHP-фреймворках](http://blog.lingohub.com/2013/07/internationalization-how-to-5-most-popular-php-frameworks/) — Обзор реализаций возможностей интернационализации в CakePHP, CodeIgniter, Symfony, Zend Framework и Yii.
* [Symfony2 подписка на динамические события](http://habrahabr.ru/post/187178/)  — Автор хабрапоста описывает один из вариантов реализации обработчика событий, имя которых не известно заранее.
* [Переходим к разработке в облаке](http://phpmaster.com/moving-to-cloud-based-web-development/) — Небольшой пост о том, как организовать процесс разработки с помощью облачных инструментов. Из доступных IDE автор остановил свой выбор на [Cloud9](https://c9.io/), возможности которой действительно впечатляют как для IDE, работающей в браузере.
* [Выполняем HTTP-запросы параллельно](http://tech.vg.no/2013/07/23/php-perform-requests-in-parallel/) — Небольшой пост об использовании функций [curl\_multi\_\*](http://www.php.net/manual/en/function.curl-multi-init.php). Также автор рекомендует к использованию библиотеку [Guzzle](http://guzzlephp.org/), которая упрощает создание RESTful-клиентов на PHP.
* [Пишем SOAP клиент-серверное приложение на PHP](http://habrahabr.ru/post/187390/)  — Большой и подробный хабрапост о создании SOAP-сервиса с примером реализации на PHP.
* [Планы на ближайшие релизы Phalcon](http://blog.phalconphp.com/post/56351424566/the-road-ahead) — Маленький обзор того, что следует ожидать разработчикам в версиях 1.3/1.4.
* [PHP и блокировка файлов сессий](http://blog.preinheimer.com/index.php?/archives/416-PHP-and-Async-requests-with-file-based-sessions.html) — Проблема, описанная в посте, известна давно, но далеко не каждый о ней знает. Описание на русском можно прочитать [тут](http://rmcreative.ru/blog/post/blokirovanie-sessiy-v-php) .
* [Вопросы на собеседовании по PHP](http://phpixie.com/blog/questions-for-php-interview/) — Давно на Хабре была [подборка вопросов по PHP](http://habrahabr.ru/post/21681/) , но мир не стоит на месте и интересно, какие вопросы актуальны сейчас?
* [Определяем устройство на стороне сервера с помощью Browscap](http://phpmaster.com/server-side-device-detection-with-browscap/) — В туториале рассказано о проекте [Browscap](http://tempdownloads.browserscap.com/) и о его применении в PHP-приложениях. Напомню про небольшой но удобный PHP-класс [Mobile Detect](http://mobiledetect.net/), который позволяет определять мобильные устройства.
* [Уязвимость класса SQL Injection в WordPress](http://blog.ircmaxell.com/2013/07/disclosure-wordpress-wpdb-sql-injection.html) — Известный PHP-разработчик Anthony Ferrara обнаружил серьезную уязвимость в коде WordPress, суть которой и описывает в посте. Не смотря на то, что угрозы пользователям уязвимость не несет, так как не может быть эксплуатирована в установке по умолчанию, но примечательно то, что уязвимость не была устранена даже спустя почти 3 месяца после сообщения о ней разработчикам.
* [Обзор HHVM](http://coderoncode.com/2013/07/24/introduction-hhvm.html), [Facebook ускорил PHP в девять раз благодаря HipHop VM](http://habrahabr.ru/post/188056/)  — Пара постов о разрабатываемой в Facebook виртуальной машине PHP, которая позволяет выполнять код значительно быстрее традиционного интерпретатора. На данный момент HHVM поддерживает PHP 5.4 практически полностью. Больше информации о HHVM можно найти в официальном [блоге](http://www.hhvm.com/blog/).
[Ссылка](http://habrahabr.ru/company/zfort/blog/186704/) на предыдущий выпуск.
Напомню также, что имеется [быстрый поиск](http://pronskiy.github.io/php-digest/) по дайджестам. | https://habr.com/ru/post/188156/ | null | ru | null |
# Мой опыт перевода typescript проекта на ESM
Доколе
------
Все любят, чтобы инструменты просто работали. Не works simple, но just works.
А ES6 модули где-то рядом. Нодовские релиз ноуты рапортуют что их поддержка всё стабильней и стабильней, Андрей Мелихов пишет [чат](https://www.youtube.com/watch?v=uAMt7cDV7lU) на чистой ноде (хорошо ему) с использованием модулей, Axel Rauschmayer пишет отличнейший [пост](https://2ality.com/2021/06/typescript-esm-nodejs.html) про использование нативных модулей с тайпскриптом...
Пишет то он пишет, и в статье всё гладко. А надо попробовать самому. Но как-то всё находишь для себя оправдания чтобы не начинать. Ведь как оно всегда бывает. Делаешь всё по туториалу, но получаешь ошибки и вместо налаженного процесса получаешь копание в кишках стек-трейсов. Да зачем мне всё это, меня и здесь неплохо кормят.
И вот уже Rauschmayer строит на основе предыдущего проекта [монорепозиторий](https://2ality.com/2021/07/simple-monorepos.html). Надо же иметь моральное право мне и самому высказываться на данную тему. Доколе!.. Ну и что с того что час ночи? Все равно не спишь а пялишься в потолок. Вставай и иди пробуй.
Мы будем жить теперь по-новому
------------------------------
Итак, что принципиально меняется в настройках нашего проекта.
1) в package.json меняем
```
"main": "index.js" // или что там у вас за точка входа
```
на
```
"module": "index.js",
"type": "module"
```
2) в tsconfig.json проставляем значение
```
"module": "es2020", // ну или es2015, ну или ESNext
"allowSyntheticDefaultImports": true // если вы этого еще не сделали
```
Всё, теперь не отвертимся.
Протокол затыков
----------------
Естественно за основу возьмём туториал Rauschmayer'а. Ну а чо. Надо экономить мыслетопливо. Собственно помимо правки package.json и tsconfig.json он указывает на необходимость некоторой автоматизации. Дело в том, что в выходных файлах после компиляции тайпскрипта импорты указываются без расширения файла, а для ES6 модуля это указание обязательно. Так что после компиляции нужно пробежаться по полученным файлам, определить что импорт идет из другого файла а не из npm пакета и добавить расширение файла в импорт.
Алекс предоставляет нам регулярку для нахождения таких импортов. Респект и уважуха. Сам бы я её полдня составлял. Терпеть не могу регулярки. Напишите в комментариях если вы от них тащитесь. Но только исполнение этой регулярки падает с ошибкой. Ну я же говорил - всё как всегда. Дело в том что символ / который используется в пути к файлу, вотспринимается интерпретатором как конец регулярного выражения, так что его надо ескейпить. Но тут к Алексу и претензий то больших нет, я его прекрасно понимаю. Напишите в комментариях если вы тащитесь от регулярок.
Итак, ескейпим слэш, и hello world вроде работает. Но не реальный проект. Мы же пишем "тот самый, настоящий бэкенд на nodejs [](https://habr.com/ru/post/439434/)[(с)](https://habr.com/ru/post/439434/)". А предложенная регулярка игнорирует файлы с точками в названии, обозванные в соответствии с принятой в Nest.js конвенцией. Такие как app.module.ts. Ну что ж, с этим мы справимся.
Что ещё можно было бы добавить. Получившаяся в итоге регулярка (конечно же будет приведена в конце статьи) расчитана на одиночные кавычки. Если у вас на проекте приняты двойные кавычки, то регулярка исправляется в одно движение. Если же у вас разброд и шатание, то страдайте. Можете написать универсальный регексп с сохранением символа кавычки в переменную, но эту радость я оставляю вам. А лучше всё же прикрутите линтер.
Не импортом единым
------------------
Многим описанных мер будет достаточно. Но в моём конкретном случае нет. Дело в том, что я очень люблю добавлять файл index.ts в папочку с однородными файлами. В индексе экспортировать всё содержание папки, и в остальных местах в импорте указывать путь только для папки а не до конкретного файла. Банальный пример - папка utils (никогда не добавляйте в свой проект папку utils).
Во-первых, с такой практикой нужно будет патчить ещё и строчки с экспортами. Но это конечно не проблема, просто помните об этом. А во-вторых, импорт из папки с индексом (на примере utils) будет преобразован в `'../utils.js'`, а такого файла у нас конечно не будет. Можно в ts файлах писать `import {} from '../utils/index'` но это лажа. Я хотел писать меньше букв, а получил вот это. К тому же автоподгруженные с помощью IDE импорты руками править надо будет...
Короче, скрипт по патчингу выходных файлов усложняется. Теперь, когда мы нашли новый импорт, нужно понять на что он ссылается - на файл или на папку. И если оказалось что на папку, то переделывать ссылку на файл index.js внутри неё.
U Can Touch This
----------------
Ну что ж. Теперь похоже проект дошёл до состояния когда он "just works". Я создал [репозиторий](https://github.com/muturgan/typescript-esm-example) с минимальным примером описанной инфраструктуры. Можете выполнить в нём команду build и посмотреть какие сформировались импорты в папочке dist. Скриптец для патчинга скомпилированных файлов лежит в папочке buildtools. В данном скрипте, собственно, и можно найти приснопамятную регулярку.
Что мне нравится, что я могу просто выполнить команду `node dist/index.js` и всё заработает. Дело в том что это не первая моя попытка затащить в проект ES6 модули. И не вторая. Когда я где-то пол года назад пробовал, то указание type module давало возможность обозвать файл с расширением js только для входной точки проекта. А остальные файлы которые импортятся, всё равно были обязаны иметь расширение mjs. И запуск команды node всё равно нужно было производить с флагом. Тогда я решил что для затаскивания ES6 модулей нужно совершить неоправданно много телодвижений. А теперь рррас и всё :)
Ах да. Ещё не поздно указать что я использовал ноду версии 14.17.4 в своих экспериментах?
Из неожиданных эффектов - скрипты в папочке buildtools (а на реальном проекте в отличии приведённого минимально примера у меня их больше одного) оказывается тоже нужно теперь писать с использованием ES6 модулей. А я думал что это касается только моего приложения...
Пока нерешенные проблемы
------------------------
Как всегда, есть нюансы. Вы знаете анекдот про нюанс?
Первое. На проде статика у меня раздаётся nginx'ом. А при локальной разработке приложение раздаёт статику само себе - чтобы поменьше контейнеров запускать. Чтобы не затаскивать раздачу статики на прод, я добавил соответствующие пакеты в devDependencies а в коде приложения всё организовал приблизительно следующим образом:
```
import { DynamicModule, Module, Type } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import path from 'path';
import { PromoModule } from './promo/promo.module';
const imports: Array> = [
PromoModule,
ConfigModule.forRoot(configOptions),
TypeOrmModule.forRootAsync(dbConfig),
];
if (process.env.NODE\_ENV === 'dev') {
const NestStatic = require('@nestjs/serve-static');
imports.push(
NestStatic.ServeStaticModule.forRoot({
rootPath: path.join(process.cwd(), 'static'),
}),
);
}
@Module({imports})
export class AppModule {}
```
Теперь же я не могу использовать require, а что касается импорта то
An import declaration can only be used in a namespace or module. ts (1232)
А чтобы эта строчка с импортом не упала на верхнем уровне файла на проде, нужно добавлять @nestjs/serve-static и сопутствующие пакеты в основные зависимости, чего мне не хочется.
Второе. Возможно вы решите что я параноик, но мне очень не хотелось добавлять конфиг подключения к БД в несколько файлов. Я в своё время наелся проблем с тем, что в одном месте конфиг обновили, а в другом забыли. Так что в корень проекта я положил вот такой ormconfig.js:
```
const dotenv = require('dotenv');
const {error, parsed} = dotenv.config();
if (error !== undefined || parsed === undefined) {
throw error;
}
const options = {
APP_HOST: parsed.APP_HOST,
APP_PORT: parsed.APP_PORT,
ADMIN_PASS: parsed.ADMIN_PASS,
type: parsed.DB_TYPE,
host: parsed.DB_HOST,
port: parseInt(parsed.DB_PORT, 10),
username: parsed.DB_USER,
password: parsed.DB_PASS,
database: parsed.DB_NAME,
autoLoadEntities: false,
synchronize: parsed.DB_SYNC === 'true',
logging: parsed.DB_LOG === 'true',
timezone: parsed.DB_TIME,
migrations: [
`./dist/promo/dal/migrations/*`
],
cli: {
"migrationsDir": `src/promo/dal/migrations`,
},
};
module.exports = options;
```
Данный конфиг необходим мне в первую очередь для создания и выполнения миграций. А приложение получает конфиг следующим образом:
```
import { ConfigFactory } from '@nestjs/config';
import path from 'path';
import { validateConfig } from './config_validator';
import { IAppConfig } from './typings';
export const configFactory: ConfigFactory = () => {
const ormconfig = require(path.join(process.cwd(), 'ormconfig'));
const config: IAppConfig = {
APP\_HOST: ormconfig.APP\_HOST,
APP\_PORT: parseInt(ormconfig.APP\_PORT, 10),
ADMIN\_PASS: ormconfig.ADMIN\_PASS,
DB\_CONFIG: {
type: ormconfig.type,
host: ormconfig.host,
port: ormconfig.port,
username: ormconfig.username,
password: ormconfig.password,
database: ormconfig.database,
synchronize: ormconfig.synchronize,
logging: ormconfig.logging,
timezone: ormconfig.timezone,
},
};
validateConfig(config);
return config;
};
```
Мне и самому данный подход не вполне нравится, т.к. фактически служебный файл узкоспециализированной тулзы typeorm что-то знает про ADMIN\_PASS и APP\_PORT. Но зато значения присваиваются 1 раз. Но я сейчас не об этом.
В первую очередь я хочу сказать о том, что опять же я теряю возможность подгрузить ormconfig.js при помощи require. Можно перенести данный файл из корня проекта в src и переделать его в ts, а при запуске скрипта миграции переопределять стандартный путь до конфигурационного файла. А можно не выпендриваться и отдельно прочитать переменные окружения внутри приложения и в ormconfig.js. И то и другое всё равно не сработает т.к. typeorm игнорирует конфиг в формате js, который не содержит commonjs экспорта (а я такой теперь написать не могу) и кладёт/ищет файлы миграций не туда куда я хочу, а прямо в корне проекта.
Счастлив ли я?
--------------
Ну хорошо, описанные выше проблемы в принципе не блокируют мне выкатку в прод приложения с ES6 модулями. Раздача статики на проде не нужна и её можно просто выпилить. Переменные окружения можно нормально прочитать в самом приложении, а новые миграции не предвидятся.
Мои импорты стильные-модные-молодёжные, и когда я читаю (часто ли это нужно) скомпиллированный js код то он максимально похож на исходный и не содержит всяких шумных полифиллов. Но только я до сих пор не понимаю, что же я приобретаю, кроме того что я в тренде и на хайпе?
Мой код по синтаксису соответствует тому как это должно быть в браузере? Да плевать на это. Я в принципе пишу на языке который не исполняется в браузере, а во что оно там скомпилируется - не так важно. Люди вообще всё обфусцируют через вебпак и ничего, не страдают от нечитаемости выходного файла. Появилась возможность шарить код между фронтом и бэком? У меня такой необходимости не возникало. Расскажите если у вас были такие кейсы.
Мне вот всё любопытно посмотреть, не упадёт ли потребление памяти после внедрения ES6 модулей, но до этого пока руки не дошли. В любом случае не думаю что это будут значения которые что-то кардинально поменяют (по крайней мере если у вас не 1500 микросервисов).
Так что пока у меня сменанные чувства. Наконец-то всё нормально заработало. И чо?
А что ты?
---------
Напишите, как вы относитесь к возможности писать ES6 модули в ноде, какой профит от этого получаете и какие эмоции это вызывает у вас. Будет интересно узнать мнение умных людей :)
UPD (30.09.2021)
----------------
Давно хотел выкатить то приложение, на котором тренировался, на прод с ES6 модулями. Да что-то руки не доходили. И вот дошли. Приложение очень маленькое, потому что нишевое. За несколько месяцев в нём зарегистрировалось всего 6 пользователей. Так что всё потребление памяти уходит на поддержание своего собственного пассивного состояния.
И вот всё же руки дошли. С commonjs модулями приложение потребляло 49 мегабайт оперативки, с ES6 модулями потребляет 75. Кроме импортов в приложении ничего не поменялось. Приложение провисело 2 дня. Возможно конечно через месяц работы пройдёт какая-нибудь JIT оптимизация.
Для системы с регулярной пользовательской активностью эта разница в потреблении памяти, думаю, растворится в общем объёме. Но что есть то есть. | https://habr.com/ru/post/570734/ | null | ru | null |
# Вращающееся облако тегов на javascripte
Недавно на хабре был топик, в котром было рассказано об [облаке на флеше](http://habrahabr.ru/blogs/wordpress/38114/). Посмотрел, понравилось, решил повторить на javascript-e. Вот что получилось: [demo](http://nacmnogo.ru/cloud.html) [зеркало](http://kron0s.com/cloud.html) [архив](http://kron0s.com/cloud.zip).
Создание облака происходит так:
`> var cloud = new Cloud(
>
> {
>
> radius:200,
>
> parent:document.body
>
> });
>
> cloud.addTag([
>
>
>
> {href:"#",w:"2",text:"нло"},
>
> {href:"#",w:"2",text:"общение"},
>
> {href:"#",w:"1",text:"по"},
>
> {href:"#",w:"1",text:"подкаст"}
>
> ]
>
> );`
Не знаю, пригодится ли, при большом количестве тагов жутко тормозит.
Тестировал в Mozilla 3, IE7.
P.S. Если понравится, можно будет его еще как-то улучшить, но пока смысла не вижу :)
**Вот хабра юзер** [Kron0S](https://habrahabr.ru/users/kron0s/) **сделал [плагин](http://kron0s.com/wp-cloud.zip) для wordpress на основе моего скрипта.**
Судя по комментариям сильно тормозит, я провел не большую оптимизацию при тегах в количестве 100 штук на моей машине(ntel Core 2 Duo 2.3 с 2Gb Vista FF3) почти не тормозит жду ваших комментариев. Может кто предложит еще както оптимизировать код ( Фраемворки не предлагать только алгоритмы). | https://habr.com/ru/post/38264/ | null | ru | null |
# Android IDE Template Format
В процессе создания новых приложений очень часто приходится писать однотипный код и воспроизводить уже проверенные временем структуры классов. IDE (в частности Android Studio) облегчает во многом задачи, связанные с созданием новых компонентов для приложения. Список шаблонных Aсtivity растет с каждой новой версией SDK Tools. Но что если нужно создать свой собственный шаблон? Для одного файла это легко, но что делать, если нужно создать шаблон с созданием нескольких файлов? Зная возможности IDE, это вполне реализуемо, ведь Activity создается вместе с файлом разметки, да и фрагмент к ней добавить можно. Однако описание такой функциональности найдено не было, потому пришлось искать решение для данной возможности самостоятельно.
Под катом хочу рассказать вам о том, как эта возможность реализуется в Android Studio.
Первой мыслью было спросить у коллег, пользующихся продуктами JetBrains, как они решают эту проблему. Ответ был весьма прост. Для создания структуры классов был написан отдельный скрипт, который выполнял все необходимые действия.
Действительно, такое решение было первым, которое приходило на ум. И у него есть свое преимущества, а именно, — независимость от IDE. Однако это неудобно, и вопрос совместимости с IDE оставался актуальным.
В исходниках SDK есть описание способа решить поставленную задачу. **[Android IDE Template Format](https://android.googlesource.com/platform/sdk/+/refs/heads/master/templates/docs/index.html)**.
Получив такой инструмент я сразу решил его опробовать и этим опытом спешу поделиться.
Для создания шаблонов используется [FreeMarker](http://freemarker.org/). Это очень похоже на использование шаблонов PHP и Django.
Суть заключается в том, что у нас есть определенный шаблон и форма для ввода параметров. После ввода, параметры передаются в шаблон, и на основе этих данных собирается необходимый класс.
Список всех используемых шаблонов находится по следующему адресу
*android-studio-folder***\plugins\android\lib\templates\**
Для создания своего шаблона добавляем в директорию activities(или other) новый католог со следующим списком файлов
Обязательными являются только файлы template.xml и recipe.xml.
### template.xml
Этот XML-файл содержит метаданные о шаблоне, в том числе имя, описание, категорию и видимые пользователю параметры, доступные в IDE в качестве опций.
**Пример template.xml**
```
None
Tabs
Swipe Views
Dropdown
template\_default.png
template\_tabs.png
template\_dropdown.png
```
Элемент **template**
*format* — версия шаблона, которой этот шаблон придерживается. Должно быть 4. (ну вот так вот)
*revision* — необязательный параметр. Версия этого шаблона (которую можно увеличить при обновлении шаблона)
*name* — отображаемое имя шаблона.
*description* — описание шаблона.
*minApi* — необязательный параметр. Проверяется минимальный уровень API, для этого шаблона. IDE перед созданием шаблона будет проверять, что minSdkVersion не ниже этого значения.
Элемент **parameter**
Определяет настраиваемые пользователем параметр шаблона.
*id* — идентификатор для переменной. Доступен в файле глобальной переменной. Если идентификатор Foo, то значение параметра будет доступно в FreeMarker файлах как ${Foo}.
*name* — отображаемое имя параметра.
*type* — тип параметра. Доступные значения string, boolean, enum, и separator.
*constraints* — необязательный. Ограничения параметра. Ограничения могут быть объединены с помощью |.
**Типы ограничений*** nonempty — значение не должно быть пустым
* apilevel — указывает уровень API
* package — значение должно представлять собой допустимое имя пакета Java
* app\_package — значение должно представлять собой допустимое имя Android app package
* module — значение должно представлять собой допустимое имя модуля
* class — значение должно представлять собой допустимое Java класса
* activity — значение должно представлять собой полное имя класса Activity
* layout — значение должно представлять собой допустимое имя layout ресурса
* drawable — значение должно представлять собой допустимое имя drawable ресурса
* string — значение должно представлять собой допустимое имя string ресурса
* id — значение должно представлять собой допустимое имя id
* unique — значение должно быть уникальным
* exists — значение должно существовать
*suggest* — необязательный. Автоматически обновляемые выражения, зависящие от значения других параметров.
*default* — необязательный. Значение по умолчанию для этого параметра.
*visibility* — необязательный. FreeMarker выражение, определяющее, видимость компонента.
*help* — необязательный. Подсказка для этого параметра.
Элемент **option**
Для параметров типа enum, представляет собой элементы для выбора.
*id* — значение параметра устанавливается, если выбрана эта опция.
*minApi* — необязательный. Требуется минимальный уровень API.
*[text]* — Текст отображаемый при выборе этого параметра.
Элемент **thumb**
Показывает миниатюру для шаблона. Елементы должны быть внутри элемента . Текст содержащийся в этом элементе это путь к миниатюре. Если этот элемент имеет атрибуты, они будут рассматриваться как селектор.
Пример:
```
template.png
template\_tabs.png
```
В качестве миниатюры будет показана template\_tabs.png, если в navType выбрано значение tabs.
### globals.xml.ftl
XML-файл содержит глобальные переменные для использования в рабочих макетах FreeMarker.
Пример globals.xml.ftl:
```
```
### recipe.xml.ftl
Этот XML-файл содержит отдельные инструкции, которые должны быть выполнены при генерации кода для этого шаблона.
Например, вы можете скопировать некоторые файлы или каталоги(инструкция copy), возможно создание файлов через FreeMarker (инструкция instantiate), и можно попросить IDE открыть файл (инструкция open).
Примечание: Имя файла инструкций определяется в template.xml. Однако по соглашению, лучше называть его recipe.xml.ftl.
Примечание: Глобальные переменные globals.xml.ftl доступны для использования в recipe.xml.ftl.
**Пример recipe.xml.ftl**
```
<#if appCompat?has\_content>
<#if navType?contains("pager")>
<#elseif navType == "tabs" || navType == "dropdown">
<#else>
<#if navType == "none">
<#elseif navType == "pager">
<#elseif navType == "tabs">
<#elseif navType == "dropdown">
```
Инструкции поддерживают следующие методы:
**dependency**
Указывает, что шаблону необходима библиотека. Если ее нет, IDE добавит зависимость в проект.
Атрибут *mavenUrl*
Указание maven пакета библиотеки. Для примера, com.android.support:appcompat-v7:+
**copy**
Единственный обязательный параметр это путь к исходным файлам для копирования относительно каталога root/. Все необходимые подкаталоги создаются автоматически, при необходимости.
Каталог создания по умолчанию совпадает с расположение шаблона относительно папки /root. Есть необязательный параметр для указания пути создания файла. Обратите внимание, что расширение .ftl автоматически убирается. Для примера запись /> является правильной. Будет создан файл с именем strings.xml, а не strings.xml.ftl.
**instantiate**
Тоже самое что и copy, но для исходного файла сперва будет запущен FreeMarker.
**merge**
Эта инструкция будет запускать FreeMarker для исходного файла, а затем объединять содержимое с уже существующим файлом в проекте или создавать новый файл. Наиболее распространенным примером использования этой инструкции является добавление компонентов к файлу AndroidManifest.xml или объединение таких ресурсов, как strings.xml.
**open**
Открывает файл, указанный в аргументах, после завершения генерации кода.
**mkdir**
Проверяет существование каталога, указанного в аргументах
### root/
Все файлы шаблонов (resources, Java sources, Android Manifest) должны располагаться в директории root/
Однако вместо размещения исходные файлов в src/com/google/… можно просто использовать src/app\_package/.
Built-in Template Functions
---------------------------
Существует несколько функций, не входящих в список функций FreeMarker, которые можно использовать.
Вот некоторые из них:
**string activityToLayout(string)**
Преобразует имя класса Activity в строку, подходящую для использования в качестве имени ресурса. Например, FooActivity будет преобразовано к activity\_foo.
**string camelCaseToUnderscore(string)**
Преобразует camel-case строку в строку с подчеркиванием. Например, FooBar будет преобразовано к foo\_bar.
**string classToResource(string)**
Преобразует Android имя класса, например, FooActivity или FooFragment, к соответствующему ресурсу с добавлением суффикса 'Activity' или 'Fragment'.
На данный момент распознаются:
* Activity
* Fragment
* Provider
* Service
**string layoutToActivity(string)**
Преобразует ресурс с суффиксом в строку класса. Например activity\_foo будет переведено к Java классу FooActivity.
**string slashedPackageName(string)**
Преобразует полное имя пакета Java к соответствующему пути к каталогу. Например, если данный аргумент com.example.foo, то возвращаемое значение будет com/example/foo.
**string underscoreToCamelCase(string)**
Преобразует подчеркивания строки к соответствующей camel case строке. Например, foo\_bar к FooBar.
Built-in Template Parameters
----------------------------
Некоторые параметры, доступные для FreeMarker выражений и файлов.
**packageName**
Имя пакета проекта, например, com.example.foo
**isNewProject**
Логическое значение указывающее является ли шаблон шаблоном нового проекта.
**manifestDir**
Каталог с AndroidManifest.xml.
**srcDir**
Каталог исходных файлов Java для проекта.
**resDir**
Каталог корневой директории ресурсов (res/) для проекта.
За полным списком функций и параметров обращайтесь к [документации](https://android.googlesource.com/platform/sdk/+/refs/heads/master/templates/docs/index.html).
В целом, создание собственного шаблона не является чем-то трудным. Потратив некоторое время на его создание, можно избавиться рутины по созданию компонентов и структур в проекте.
Пользуйтесь и автоматизируйте все, что можно автоматизировать.
#### Полезные ссылки
[Документация](https://android.googlesource.com/platform/sdk/+/refs/heads/master/templates/)
[Статья о создании собственного Activity для Google Analytics](http://robusttechhouse.com/tutorial-how-to-create-custom-android-code-templates/)
[Работа с FreeMarker](http://freemarker.org/docs/ref_builtins_string.html) | https://habr.com/ru/post/274959/ | null | ru | null |
# Обзор и установка The Game Closure DevKit в Ubuntu
Неосвещённым событием на Хабрахабре стал выход The Game Closure DevKit. Это игровой движок, использующий Javascript и технологии HTML5 для создания Web, iOS и Android приложений.
GC Devkit обладает интерфейсом для наблюдения объектов в запущенном приложении, при этом разработка на Javascript позволяет использовать среду отладки браузера. GC бесплатен даже для коммерческого использования, а код открыт под [двойной лицензией](http://www.gameclosure.com/license.html) GPLv3 и Game Closure Free License (GCFL). Основные особенности можно увидеть в видеоролике, размещённом на официальном сайте [GC](http://www.gameclosure.com/):
Вкусно, не правда ли? Давайте попробуем поставить Devkit на Ubuntu.
На данный момент официально Game Closure поддерживает только OSX, но при некоторых стараниях набор можно запустить и в Ubuntu. Начнём:
```
sudo apt-get install git openjdk-6-jre
```
Также необходим Node.js. Его надо установить локально, иначе GC при установке будет просить изменить хозяина папки /usr/local.
#### Установка Node.js локально
```
sudo apt-get install g++
```
Добавьте в файл ~/.npmrc строчки:
```
root = /home/YOUR-USERNAME/.local/lib/node_modules
binroot = /home/YOUR-USERNAME/.local/bin
manroot = /home/YOUR-USERNAME/.local/share/man
```
где YOUR-USERNAME — ваш логин в системе.
Скачиваем последнюю версию Node.js с [сайта](http://nodejs.org/download/) (у меня **node-v0.8.22.tar.gz**) и переходим в папку со скачанным архивом:
```
cd ~/Downloads/
tar xf node-v0.8.22.tar.gz
cd node-v0.8.22/
./configure --prefix=~/.local
make
make install
cd ~/
ln -s .local/lib/node_modules .node_modules
```
Выполняем команду:
```
export PATH=$HOME/.local/bin:$PATH
```
Можно добавить эту строчку в конец файла ~/.bashrc, чтобы пути к Node.js подгружались при каждом запуске консоли.
Проверьте:
```
which npm
```
Если вы видите ~/.local/bin/npm, то установка Node.js завершена и всё готово для установки Game Closure.
#### Установка Game Closure DevKit
Перейдём в папку, куда мы хотим загрузить GC и скачаем его:
```
cd ~/
git clone https://github.com/gameclosure/devkit
cd devkit/
```
Теперь в скрипте установки надо закомментировать строчку, которая сообщает о необходимости изменения хозяина /usr/local:
```
nano install.sh
```
Найдём:
```
if [ ! -w "/usr/local" ]; then
error "You need write permissions to /usr/local"
echo "Try running: sudo chown -R \$USER /usr/local"
exit 1
fi
```
и сделаем так:
```
# if [ ! -w "/usr/local" ]; then
# error "You need write permissions to /usr/local"
# echo "Try running: sudo chown -R \$USER /usr/local"
# exit 1
# fi
```
Осталось выполнить:
```
./install.sh
```
Если установка прошла верно, то по команде:
```
basil -v
```
должна отобразиться версия Game Closure (у меня **release-0.1.4**). Теперь можно запустить его:
```
basil serve
```
Если вы перейдёте в браузере по адресу *localhost:9200*, то увидите менеджер проектов с демо-игрой «Whack-that-Mole!», с помощью которой можно оценить некоторые особенности Game Closure.
Спасибо за внимание! В следующей статье я хотел бы описать создание простой игры на этом движке. | https://habr.com/ru/post/171999/ | null | ru | null |
# Учим старую собаку новым трюкам или как я научился любить str.format и отказался от %
Предлагаю вниманию читателей хабры и поклонникам python перевод довольно объемной статьи о форматировании строк. Сказка будет правдивой и намек в ней будет на то, что консерваторам стоит иногда рассматривать что-то новое, даже если привычка упорно сопротивляется.
Предугадывая любознательность читателей, склонных задавать вопросы не по теме разговора, скажу, что картинка имеет опосредованное отношение к python, правда не самое приятное. Предлагаю найти почему в качестве домашнего задания.
Жду замечания по ошибкам в оформлении и опечаткам в личку — с меня традиционные хабраплюшки.
**Далее слова автора оригинальной статьи:**
Я уже много лет пишу на python. Но в самом начале этого пути мне было интересно узнать как форматировать строки в стиле Perl. Напомню, что Perl (и многие интерпретаторы командной строки в Unix) поддерживают два типа строковых литералов — с одинарными кавычками (когда строка выводится как есть), и двойными где на место переменных подставляются их значения. В Perl, например, можно написать что то вроде:
```
$name = 'Reuven';
print "Hello, $name\n";
```
И программа, соответственно, напишет «Hello, Reuven».
Строковые литералы в python не зависят от типа кавычек и переменные в них никогда не разворачиваются в свои значения. Чтобы этого добиться традиционно использовался оператор % для строк. В этом контексте оператор смотрит на строку слева от себя и подсчитывает сколько значений нужно заменить на значения соответствующих переменных справа от себя. Результатом операции является новая строка со вставленными на место плейсхолдеров значениями переменных. Например:
```
>>> name = 'Reuven'
>>> "Hello, %s" % name
'Hello, Reuven'
```
Этот код на python вполне себе работает и выводит персонализированное приветствие. Так, несмотря на мою многолетнюю практику с python — я был вполне удовлетворен применением этого синтаксиса. Да, он не очень приятный и нет, я никогда не держал в памяти гору модификаторов printf, которые влияют на форматирование. В смысле я всегда использовал модификатор 's' (выводить как строку) и мне было достаточно того, что python неявно приводил аргументы к строке.
Но в данный момент факт, что синтаксис % подлежит списанию или, по крайней мере, объявлен устаревшим. В списке рассылки python-dev есть замечание, что в ветке 2.x он проживет минимум до 2022 года, но ничего не сказано про ветку 3.x, так что поддержка этого синтаксиса будет скоро удалена и применять его нежелательно. На смену ему пришел метод str.format.
В своих уроках по python я всегда упоминал о str.format, но в конкретных примерах чаще все полагался все-таки на %. Я даже рекомендовал студентам использовать % так как лично мне он казался намного проще.
Но стойкое ощущение того, что, я делаю что-то не так и, возможно, даже ввожу в заблуждение своих студентов подвигло меня поближе изучить str.format. В ходе исследования, я пришел к следующим выводам: 1) Он ничуть не сложнее % и даже проще в некоторых вариантах применения; 2) Я никогда не применял возможности str.format в полной мере, а они очень удобные, несмотря на некоторое время необходимое для их изучения.
Начнем с простейшего. Скажем кому-нибудь «Good morning», причем обратимся по имени и фамилии, предполагая что они сохранены в переменных «first» и «last». По-старому мы сделали бы так:
```
>>> first = 'Reuven'
>>> last = 'Lerner'
>>> "Good morning, %s %s" % (first, last)
'Good morning, Reuven Lerner'
```
Даже в таком примере мы сталкиваемся с одной из проблем %-синтаксиса — у нас теперь две переменных, и чтобы использовать их обе нам нужно сделать из них кортеж. С точки зрения python это логично, но, уверяю вас, очень многих студентов это очень удивляет.
Как этот пример будет выглядеть в случае str.format? Довольно похоже:
```
>>> "Good morning, {} {}".format(first, last)
'Good morning, Reuven Lerner'
```
Прошу обратить внимание, что мы немного поменяли принцип. Теперь это не бинарный оператор над строками, а метод объекта строка, принимающий ряд параметров. Это логично и более консистентно. Для тех же студентов оператор % в моих примерах выглядел как дополнение к print, а не операция над строками. Нотация с ".format" после строки делает более очевидным факт того, что это метод относящийся именно к этой строке.
Как вы уже наверняка знаете, вхождения “{} {}” в строке говорят что str.format должен принимать два параметра, значения которых будут вставлены в строку в том порядке, в котором они будут переданы в метод. Аргумента два, поэтому в строке должно быть два вхождения {}. Это немного сложнее понять, так как фигурные скобочки в Python намекают людям на словари и пустые скобочки выглядят не очень приятно. Но это ладно, я вполне могу с этим жить и принял это достаточно легко.
Момент, в котором str.format показывает первое преимущество над % — это при необходимости использования параметров в обратном порядке. На самом деле, с %s этого вообще никак не достичь. Невозможно также использовать значение одной переменной несколько раз. При использовании str.format мы вполне можем поменять последовательность подстановки:
```
>>> "Good morning, {1} {0}".format(first, last)
'Good morning, Lerner Reuven'
```
Обратите внимание, что если бы я использовал пустые скобочки “{} {}”, то подстановка произошла бы в том же порядке, в каком передаются в метод параметры. Можно представить себе параметры как индексируемую с нуля последовательность и если я хочу поменять порядок следования, то просто проставляю в фигурных скобочках нужные индексы этой последовательности. Самый первый наш пример с str.format можно записать и так:
```
>>> "Good morning, {0} {1}".format(first, last)
'Good morning, Reuven Lerner'
```
Заметим, что явно указав индексы, мы уже не можем положиться на автоматическую индексацию.
Разумеется, можно использовать последовательность и из списка, воспользовавшись оператором \*:
```
>>> names = ('Reuven', 'Lerner')
>>> "Good morning, {} {}".format(*names)
'Good morning, Reuven Lerner'
```
Можно использовать и именованные аргументы:
```
>>> "Good morning, {first} {last}".format(first='Reuven', last='Lerner')
'Good morning, Reuven Lerner'
```
Этот вариант мне особенно нравится. Именованные параметры более явные (если у них хорошие имена), и применение {first} и {last} достаточно читабельно — особенно в сравнении с %(first)s, которое необходимо с оператором %
Именованные параметры можно, также, развернуть из словаря, используя оператор \*\*:
```
>>> person = {'first':'Reuven', 'last':'Lerner'}
>>> "Good morning, {first} {last}".format(**person)
'Good morning, Reuven Lerner'
```
Я описал все это своим студентам и был достаточно удивлен тем насколько комфортнее им живется с таким синтаксисом. Да и самому стало приятнее работать.
Нужно упомянуть, что именованные и позиционные аргументы технически можно использовать совместно. Но лучше этого не делать:
```
>>> person = {'first':'Reuven', 'last':'Lerner'}
>>> "Good {0}, {first} {last}".format('morning', **person)
'Good morning, Reuven Lerner'
```
Я предупредил.
Чего может не хватать в str.format, так это… гм… форматирования. Плохая новость — в str.format совершенно другие правила определения того как форматировать вывод. Хорошая новость — эти правила достаточно несложно изучить и понять.
Снова начнем с простого: если нужно вывести строку заданной длины, то после имени переменной добавляем двоеточие (:) и затем количество символов. Так, чтобы вывести мое имя и дополнить его до десяти символов пробелами я должен делать так:
```
>>> "Your name is {name:10}".format(name="Reuven")
'Your name is Reuven '
```
(Обратите внимание что строка дополнена пробелами после имени.)
Если нужно задать выравнивание по правой стороне блока — используется знак > между: и числом:
```
>>> "Your name is {name:>10}".format(name="Reuven")
'Your name is Reuven'
```
И да, можно явно указать что я хочу выравнивания по левой стороне с помощью знака <
Если нужно вывести значение в центре блока, то вместо < и > используется символ ^:
```
>>> "Your name is {name:*^10}".format(name="Reuven")
'Your name is **Reuven**'
```
С текстом более менее понятно, но что насчет чисел? Лично мне было трудно предположить как это будет работать, но все оказалось достаточно прямолинейно. Для простого вывода чисел используем синтаксис похожий на строки:
```
>>> "The price is ${number}.".format(number=123)
'The price is $123.'
```
Но для чисел применяется большее количество модификаторов, чем для строк. Например, чтобы вывести число в двоичном виде добавляем модификатор «b», если в шестнадцатеричном — модификатор «x»:
```
>>> "The price is ${number:b}.".format(number=5)
'The price is $101.'
>>> "The price is ${number:x}.".format(number=123)
'The price is $7b.'
```
Разумеется, запись числа можно дополнить лидирующими нулями:
```
>>> "Your call is important to us. You are call #{number:05}.".format(number=123)
'Your call is important to us. You are call #00123.'
```
Заметим, что внутри {} нельзя использовать исполняемый python-код — вместо этого предлагается простенький микроязык отдельный и отличающийся от python в целом. Есть и небольшие исключения. Во-первых можно получить значения атрибутов/свойств через точку, во-вторых получить значение объекта по индексу, используя [].
Например:
```
>>> class Foo(object):
def __init__(self):
self.x = 100
>>> f = Foo()
>>> 'Your number is {o.x}'.format(o=f)
'Your number is 100'n
```
Мы получили атрибут «х» объекта «f». Этот объект доступен по имени «o» внутри строки. Получить атрибут можно, а вот выполнить его — нет:
```
>>> "Your name is {name.upper()}".format(name="Reuven")
AttributeError: 'str' object has no attribute 'upper()'
```
Я пытался выполнить “name.upper()”, предполагая, что будет вызван соответствующий метод, но python не разрешает выполнять код в этом месте и расценивает «upper()» как атрибут вместе со скобками. Без скобок вы получите просто строковое представление функции/метода:
```
>>> "Your name is {name.upper}".format(name="Reuven")
'Your name is '
```
С помощью квадратных скобок можно взять элемент итерируемого объекта (списка, строки) по индексу. Но операции разрезания (slice) не поддерживаются:
```
>>> "Your favorite number is {n[3]}.".format(n=numbers)
'Your favorite number is 3.'
```
Но:
```
>>> "Your favorite numbers are {n[2:4]}.".format(n=numbers)
ValueError: Missing ']' in format string
```
Можно использовать [] и для получения записей в словаре по имени, но имя вводится без кавычек:
```
>>> person = {'first':'Reuven', 'last':'Lerner'}
>>> "Your name is {p[first]}.".format(p=person)
'Your name is Reuven.'
```
При попытке использовать кавычки получим исключение…
```
>>> "Your name is {p['first']}.".format(p=person)
KeyError: "'first'"
```
Здесь приведены не все варианты использования str.format — на деле для каждого типа есть спецификация правил форматирования. Например, опция точности для чисел с плавающей запятой недоступна для строк.
Можно даже добавить собственные правила форматирования для объектов ваших классов так, что у них будет особый способ вывода и модификаторы для его настройки.
Если есть желание изучить эту тему подробнее — стоит начать с PEP 3101, где описан str.format. Могу, также, порекомендовать презентацию Эрика Смита с достаточно хорошим саммари по этой теме. Есть и хорошие примеры о том как перейти от использования % к str.format в документации python
Надеюсь, вам понравилось!
P… S.: Автор оригинальной статьи [замерил](http://blog.lerner.co.il/relative-speeds-str-format/) производительность str.format и %. Пришел к выводу, что % быстрее
P.P.S.: По словам Андрея Светлова [svetlov](http://habrahabr.ru/users/svetlov/) (словам которого можно доверять в силу его вхожести в команду разработки python) — синтаксис % не будет убран из python 3.x минимум ближайшие 20 лет | https://habr.com/ru/post/236633/ | null | ru | null |
# Memcached и метки. Реализация для фреймворка Kohana
Приветствую всех.
Уже довольно давно разрабатываем проект на кохане и встала необходимость эффективного кэширования данных. Не то, чтобы вопрос производительности стоит очень остро в данный момент, но, хотелось бы подготовится заранее, а не писать систему кэширования в ночь после волны посетителей. Да и посещаемость постоянно растет, а в некоторые моменты бывают всплески до 3х раз по сравнению с обычным днем.
Собственно, в выборе системы кэширования особых вопросов не было — на ум сразу приходит всем известный memcached.
Если вы хотя бы немного смотрели memcached, то должны были отметить, что, по большому счету, он поддерживает только 2 операции: получение значения, запись значения. Нет никакой возможности вытянуть все ключи по определенному признаку или паттерну. Сделано это сознательно, с целью сделать его максимально простым, а значит, максимально быстрым.
Итак, представим ситуацию, что мы храним в кэше данные записей блога под ключами post\_. В определенный момент нам требуется сбросить все записи с постами, при этом не очищая кэш полностью (там могут хранится другие данные, значения которых все еще актуальны). Ситуация получается безвыходная. Мы не знаем список ключей постов, получить их нет возможности, сбросить ключи по паттерну тоже невозможно. Что же делать?
Я не буду вдаваться в теоретическое описание способов, как на базе memcached можно реализовать систему тэгирования записей, по этому поводу и так есть много статей. Например, в блоге Андрея Смирнова: [www.smira.ru/2008/10/29/web-caching-memcached-5](http://www.smira.ru/2008/10/29/web-caching-memcached-5). Именно этот способ я и использовал при создание системы кэширования на своем сайте.
Чтобы вы понимали о чем речь, мы собираемся хранить данные нашего кэша в массиве вида:
> `array (
>
> 'tags' => array (
>
> 'tag1' => <...значение...>,
>
> 'tag2' => <...значение...>
>
> ),
>
> 'data' => <....хранимые данные...>,
>
> );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также, каждая метка у нас хранится в memcached с ключем tag\_<имя тэга>. В значении мы храним некое число. В нашем случае, для надежности, мы храним в нем время создания/обновления метки с точностью до миллисекунд.
При добавлении нового элемента в кэш мы считываем это число и сохраняем его в том массиве, который описан выше. При считывании значения ключа мы проверяем, не изменилось ли значение метки относительно хранимых в значении ключа значений. В случае, если они различаются — мы считаем, что ключ сброшен. Таким образом, сброс ключей по метке производится путем изменения значения у ключа метки.
Например:
> `// значение post\_1:
>
> array (
>
> 'tags' => array (
>
> 'posts' => 1
>
> ),
>
> 'data' => 'post content'
>
> )
>
> // значение tag\_posts:
>
> array (
>
> 'data' => 1
>
> )
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При считывании ключа post\_1 алгоритм также считывает значение tag\_posts и сравнивает его со значением, которое хранится в ['tags']['posts'] ключа post\_1. В случае, если они равны — все в порядке, post\_1 валиден. В случае, если значения отличаются — мы считаем, что post\_1 не валиден и возвращаем NULL. Таким образом, мы можем помечать ключи не валидными просто изменив значения, которое хранится в «метках».
Если я объяснил не очень понятно — не беда. Сверху я давал ссылку на статью, где используемая мною методика описана более подробно.
Драйвер memcached в Kohana по умолчанию не поддерживает метки в memcached. Точнее, пару версий назад оно было реализовано, но работало оно так, что в итоге авторы решили отказаться от меток вообще. В кратце — там создавался один ключ в memcached, который хранил массив вида <название ключа> => <список меток>. Вы можете представить, какой размер был у этого массива на мало-мальски крупном сайте.
Скачать мою версию драйвера вы можете тут: [github.com/Kolger/kohana-memcacheimp](http://github.com/Kolger/kohana-memcacheimp)
Это обычный кохана-модуль. Скачиваете код, создаете директорию memcachedimp в папке application/modules вашего проекта. Не забудьте подключить модуль в config.php:
> `$config['modules'] = array
>
> (
>
> //.....
>
> MODPATH.'memcacheimp', // Memcacheimp driver
>
> //.....
>
> );
>
> // а также, выбрать драйвер в cache.php:
>
>
>
> $config['default'] = array
>
> (
>
> 'driver' => 'memcacheimp',
>
> 'lifetime' => 3600,
>
> 'requests' => 1000,
>
> );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь, класс Cache будет работать с новым драйвером.
Использование ничем не отличается от способа, описанного в документации: [docs.kohanaphp.com/libraries/cache](http://docs.kohanaphp.com/libraries/cache)
> `$cache = new Cache();
>
> // Добавление в кэш:
>
> $cache->set('post\_1', 'post content', array('posts'));
>
> $cache->set('post\_2', 'post content', array('posts'));
>
> // Получаем значение
>
> $value = $cache->get('post\_1');
>
> // $value == post content
>
> // "Удаляем" метку. А точнее, изменяем значение, которое хранится в ключе tag\_posts, из за чего ключ post\_1 и post\_2 - сбрасываются
>
> $cache->delete\_tag('posts');
>
> // Пробуем получить значение ключа post\_1
>
> $value = $cache->get('post\_1');
>
> // $value === NULL, чтд. На самом деле в значении ключ post\_1 все еще хранится значение, но оно считается устаревшим, т.к. значение метки не совпадает с текущим.
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Думаю, немного изменив мой класс можно его использовать не только в Кохане, но и в любом другом проекте на PHP. Если есть идеи как улучшить, или оптимизировать класс — милости просим на гитхаб [github.com/Kolger/kohana-memcacheimp](http://github.com/Kolger/kohana-memcacheimp) :)
Что стоит усовершенствовать:
— Получение тэгов в методе get с помощью getMulti, чтобы не плодить запросы к memcached.
— Удаление ключей в случае, если метка изменилась. | https://habr.com/ru/post/73423/ | null | ru | null |
# Классическое наследование в JavaScript. Разбор реализации в Babel, BackboneJS и Ember
В этой статье мы поговорим о классическом наследовании в JavaScript, распространённых шаблонах его использования, особенностях и частых ошибках применения. Рассмотрим примеры наследования в Babel, Backbone JS и Ember JS и попытаемся вывести из них ключевые принципы объектно-ориентированного наследования для создания собственной реализации в EcmaScript 5.
Статья для тех, кто знаком с наследованием в других языках и сталкивался с попытками эмулировать подобное поведение в JavaScript, а также для тех, кому интересно заглядывать «под капот» различных библиотек и фреймворков, сравнивая их реализацию. Оказывается, простую функцию **extend** можно реализовать очень по-разному. Нередко при этом допускаются ошибки (см. пункт «Самая распространённая ошибка» ниже).
> Статья доступна на английском языке с небольшой видео-презентацией на сайте [Today Software Magazine](https://www.todaysoftmag.com/article/2578/front-end-architecture-common-patterns-of-classical-inheritance-in-javascript)
### О классическом наследовании
Под классическим понимается наследование в стиле ООП. Как известно, в чистом JavaScript классического наследования нет. Более того, в нём отсутствует понятие классов. И хотя современная спецификация EcmaScript добавляет синтаксические конструкции для работы с классами, это не меняет того факта, что на самом деле в нём используются функции-конструкторы и прототипирование. Поэтому данная техника нередко называется «псевдоклассическим» наследованием. Она преследует, пожалуй, единственную цель – представлять код в привычном ООП-стиле.
Существуют различные техники наследования, помимо классического: функциональное, прототипное (в чистом виде), фабричное, с использованием миксинов. Сама концепция наследования, набравшая высокую популярность среди разработчиков, подвергается критике и во многих случаях противопоставляется разумной альтернативе – [композиции](https://en.wikipedia.org/wiki/Composition_over_inheritance).
Наследование, к тому же именно в классическом стиле, не является панацеей. Его целесообразность зависит от конкретной ситуации в конкретном проекте. Тем не менее, в данной статье не будем углубляться в вопрос о преимуществах и недостатках данного подхода, а сосредоточимся на способах его правильного применения.
### Критерии сравнения
Итак, мы решили применить ООП и классическое наследование в языке, изначально его не поддерживающем. Такое решение часто принимается в крупных проектах разработчиками, привыкшими к ООП в других языках. Оно, к тому же, используется многими крупными фреймворками: Backbone, Ember JS, и т.д, а также современной спецификацией EcmaScript.
> Лучшим советом по применению наследования будет использовать его в том виде, в каком оно описано в EcmaScript 6, с ключевыми словами class, extends, constructor, и т.д. Если у вас есть такая возможность, ~~то можете не читать дальше~~ то это лучший вариант с точки зрения читаемости кода и производительности. Всё последующее описание будет полезным для случая использования старой спецификации, когда проект уже начат с использованием ES5 и переход на новую версию не представляется доступным.
Рассмотрим некоторые популярные примеры реализации классического наследования.
Проанализируем их в пяти аспектах:
1. Эффективность использования памяти.
2. Производительность.
3. Статические свойства и методы.
4. Ссылка на суперкласс.
5. Косметические детали.
Конечно, в первую очередь следует убедиться в эффективности используемого шаблона с точки зрения памяти и производительности. К рассматриваемым примерам из популярных фреймворков в этом плане особых претензий нет, однако на практике нередко встречаются ошибочные примеры, ведущие к утечке памяти и разрастанию стека, о чём мы поговорим ниже.
Остальные перечисленные критерии относятся к удобству использования и читаемости кода.
Более «удобными» будем считать те реализации, которые ближе по синтаксису и функциональности к классическому наследованию в других языках. Так, ссылка на суперкласс (ключевое слово super) является опциональной, но её наличие желательно для полноценной эмуляции наследования. Под косметическими деталями имеется в виду общее оформление кода, удобство отладки, использование с оператором `instanceof` и т.п.
### Функция «\_inherits» в Babel
Рассмотрим наследование в EcmaScript 6 и то, что мы получаем на выходе при компиляции кода в ES5 при помощи Babel.
Ниже приведён пример расширения класса в ES6.
```
class BasicClass {
static staticMethod() {}
constructor(x) {
this.x = x;
}
someMethod() {}
}
class DerivedClass extends BasicClass {
static staticMethod() {}
constructor(x) {
super(x);
}
someMethod() {
super.someMethod();
}
}
```
Как видно, синтаксис близок к другим ООП-языкам, за исключением, быть может, отсутствия типов и модификаторов доступа. И в этом уникальность использования ES6 с компилятором: мы можем позволить себе удобный синтаксис, и при этом получить на выходе работающий код на ES5. Ни один из последующих примеров не может похвастать такой синтаксической простотой, т.к. в них функция наследования реализуется сразу в готовом виде, без преобразований синтаксиса.
Компилятор Babel реализует наследование при помощи простой функции `_inherits`:
```
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
enumerable: false,
writable: true,
configurable: true
}
});
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}
```
Основную суть здесь можно свести к данной строке:
```
subClass.prototype = Object.create(superClass.prototype);
```
Данный вызов создаёт объект с указанным прототипом. Свойство `prototype` конструктора `subClass` указывает на новый объект, прототипом которого является `prototype` родительского класса `superclass`. Таким образом, это простое прототипное наследование, замаскированное под классическое в исходном коде.
При помощи следующей строки кода реализуется наследование статических полей класса:
```
Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
```
Конструктор родительского класса (т.е. функция) становится прототипом конструктора нового класса (т.е. другой функции). Все статические свойства и методы родительского класса становятся таким образом доступными из класса-наследника. При отсутствии функции `setPrototypeOf` Babel предусматривает прямую запись прототипа в скрытое свойство `__proto__` – техника не рекомендуемая, но подходящая на крайний случай при использовании старых браузеров.
Сама запись методов, как статических, так и динамических, происходит отдельно от вызова `_inherits` простым копированием ссылок в конструктор или его `prototype`. При написании собственной реализации наследования можно использовать данный пример как основу и добавить в него объекты с динамическими и статическими полями в качестве дополнительных аргументов функции `_inherits`.
Ключевое слово «super» при компиляции просто заменяется прямым вызовом прототипа. Например, вызов родительского конструктора из примера выше заменяется следующей строкой:
```
return _possibleConstructorReturn(this, (DerivedClass.__proto__ || Object.getPrototypeOf(DerivedClass)).call(this, x));
```
Babel использует много вспомогательных функций, которые мы не будем здесь освещать. Суть в том, что в данном вызове интерпретатор получает прототип конструктора текущего класса, которым как раз является конструктор базового класса (см. выше), и вызывает его в текущем контексте `this`.
В собственной реализации на чистом ES5 стадия компиляции нам недоступна, поэтому можно добавить поля `_super` в конструктор и его `prototype`, чтобы иметь удобную ссылку на родительский класс, например:
```
function extend(subClass, superClass) {
// ...
subClass._super = superClass;
subClass.prototype._super = superClass.prototype;
}
```
### Функция «extend» в Backbone JS
Backbone JS предоставляет функцию `extend` для расширения классов библиотеки: Model, View, Collection, и т.д. При желании её можно позаимствовать и для собственных целей. Ниже приведён код функции `extend` из версии Backbone 1.3.3.
```
var extend = function(protoProps, staticProps) {
var parent = this;
var child;
// The constructor function for the new subclass is either defined by you
// (the "constructor" property in your `extend` definition), or defaulted
// by us to simply call the parent constructor.
if (protoProps && _.has(protoProps, 'constructor')) {
child = protoProps.constructor;
} else {
child = function(){ return parent.apply(this, arguments); };
}
// Add static properties to the constructor function, if supplied.
_.extend(child, parent, staticProps);
// Set the prototype chain to inherit from `parent`, without calling
// `parent`'s constructor function and add the prototype properties.
child.prototype = _.create(parent.prototype, protoProps);
child.prototype.constructor = child;
// Set a convenience property in case the parent's prototype is needed
// later.
child.__super__ = parent.prototype;
return child;
};
```
Пример использования выглядит следующим образом:
```
var MyModel = Backbone.Model.extend({
constructor: function() {
// ваш конструктор класса; его использование опционально,
// но если используете, нужно обязательно вызвать родительский конструктор
Backbone.Model.apply(this, arguments);
},
toJSON: function() {
// метод переопределён, но можно вызвать родительский через «__super__»
MyModel.__super__.toJSON.apply(this, arguments);
}
}, {
staticMethod: function() {}
});
```
Данная функция реализует расширение базового класса с поддержкой собственного конструктора и статических полей. Она возвращает функцию-конструктор класса. Собственно наследование реализуется следующей строкой, аналогичной примеру из Babel:
```
child.prototype = _.create(parent.prototype, protoProps);
```
Функция `_.create()` – аналог `Object.create()` из ES6, реализованный библиотекой Underscore JS. Её второй аргумент позволяет сразу записать в прототип свойства и методы `protoProps`, переданные при вызове функции `extend`.
Наследование статических полей класса реализуется простым копированием ссылок (или значений) из родительского класса и объекта со статическими полями, переданного в качестве второго аргумента функции extend, в создаваемый конструктор:
```
_.extend(child, parent, staticProps);
```
Указание конструктора является опциональным и производится внутри объявления класса в виде метода «constructor». При его использовании приходится обязательно вызывать конструктор родительского класса (как и в других языках), поэтому вместо этого разработчики чаще используют метод `initialize`, который вызывается автоматически изнутри родительского конструктора.
Ключевое слово «\_\_super\_\_» является лишь удобным дополнением, т.к. вызов родительского метода всё равно происходит с указанием имени конкретного метода и с передачей контекста `this`. Без этого такой вызов привёл бы к зацикливанию в случае многоуровневой цепочки наследования. Метод суперкласса, имя которого, как правило, известно в текущем контексте, может быть вызван и напрямую, так что данное ключевое слово является лишь сокращением для:
```
Backbone.Model.prototype.toJSON.apply(this, arguments);
```
С точки зрения кода, расширение классов в Backbone довольно лаконично. Не приходится вручную создавать конструктор класса и отдельно связывать его с родительским классом. Это удобство имеет свою цену – трудности отладки. В отладчике браузера все экземпляры унаследованных таким образом классов имеют одинаковое имя конструктора, объявленное внутри функции `extend` – «child». Этот недостаток может показаться несущественным, пока не столкнёшься с ним на практике при отладке цепочки классов, когда становится тяжело понять, экземпляром какого класса является данный объект и от какого класса он наследуется:
Гораздо удобнее эта цепочка отлаживается с использованием наследования из Babel:
Ещё одним недостатком является то, что свойство `constructor` является enumerable, т.е. перечисляемым при обходе экземпляра класса в цикле «for-in». Несущественно, однако Babel позаботился и об этом, объявляя конструктор с перечислением необходимых модификаторов.
### Ссылка на суперкласс в Ember JS
Ember JS использует как функцию `inherits`, реализованную Babel, так и свою собственную реализацию `extend` – очень сложную и навороченную, с поддержкой миксинов и прочего. На приведение кода этой функции в данной статье просто не хватит места, что уже ставит под сомнение её производительность при использовании для собственных нужд вне фреймворка.
Что представляет особый интерес, так это реализация ключевого слова «super» в Ember. Она позволяет вызвать родительский метод без указания конкретного имени метода, например:
```
var MyClass = MySuperClass.extend({
myMethod: function (x) {
this._super(x);
}
});
```
Заметьте: при вызове метода супер-класса (`this._super(x)`) мы не указываем название метода. И никаких преобразований кода при компиляции не происходит.
Как это работает? Как Ember узнаёт, какой метод нужно вызвать при обращении к универсальному свойству `_super` без преобразования кода? Всё дело в сложной работе с классами и в хитрой функции `_wrap`, код которой приведён далее:
```
function _wrap(func, superFunc) {
function superWrapper() {
var orig = this._super;
this._super = superFunc; // <--- магия здесь
var ret = func.apply(this, arguments);
this._super = orig;
return ret;
}
// здесь опущена нерелевантная часть кода
return superWrapper;
}
```
При наследовании класса Ember проходит по всем его методам и вызывает для каждого данную функцию-обёртку, заменяя каждую оригинальную функцию на `superWrapper`.
Обратите внимание на строку, помеченную комментарием. В свойство `_super` записывается указатель на родительский метод, соответствующий по названию вызываемому методу (работа по определению соответствий произошла ещё на этапе создания класса при вызове `extend`). Далее вызывается оригинальная функция, изнутри которой можно обращаться к `_super` как к родительскому методу. Затем свойству `_super` присваивается исходное значение, что позволяет использовать его в глубоких цепочках вызовов.
Идея, без сомнения, интересная, и её можно применять в своей реализации наследования. Но важно заметить, что всё это негативно сказывается на производительности. Каждый метод класса (по крайней мере, из тех, которые переопределяют родительский метод), независимо от факта использования свойства `_super` в нём, оборачивается в отдельную функцию. Поэтому при глубокой цепочке вызовов методов одного класса произойдёт разрастание стека. Особенно это критично для методов, вызываемых регулярно в цикле или при отрисовке пользовательского интерфейса. Поэтому можно сказать, что данная реализация является чересчур громоздкой и не оправдывает полученного преимущества в виде сокращённой формы записи.
### Самая распространённая ошибка
Одной из самых распространённых и опасных ошибок на практике является создание экземпляра родительского класса при его расширении. Приведём пример подобного кода, использования которого следует всегда избегать:
```
function BaseClass() {
this.x = this.initializeX();
this.runSomeBulkyCode();
}
// ...объявление методов BasicClass в прототипе...
function SubClass() {
BaseClass.apply(this, arguments);
this.y = this.initializeY();
}
// собственно наследование
SubClass.prototype = new BaseClass();
SubClass.prototype.constructor = SubClass;
// ...объявление методов SubClass в прототипе...
new SubClass(); // создание экземпдяра
```
Заметили ошибку?
Этот код будет работать, он позволит классу *SubClass* унаследовать свойста и методы родительского класса. Однако во время связывания классов через `prototype` создаётся экземпляр родительского класса, вызывается его конструктор, что приводит к лишним действиям, особенно если конструктор производит большую работу при создании объекта (*runSomeBulkyCode*). Так делать **нельзя**:
```
SubClass.prototype = new BaseClass();
```
Это может привести и к тяжело обнаружимым ошибкам, когда свойства, инициализированные в родительском конструкторе (`this.x`), записываются не в новый экземпляр, а в прототип всех экземпляров класса *SubClass*. Кроме того, тот же конструктор *BaseClass* вызывается затем повторно из конструктора подкласса. В случае, если родительский конструктор требует при вызове некоторые параметры, такую ошибку допустить тяжело, а вот при их отсутсвии – вполне возможно.
Вместо этого следует создавать пустой объект, прототипом которого является свойство prototype родительского класса:
```
SubClass.prototype = Object.create(BasicClass.prototype);
```
### Итоги
Мы привели примеры реализации псевдоклассического наследования в компиляторе Babel (ES6-to-ES5) и во фреймворках Backbone JS, Ember JS. Ниже приведена сравнительная таблица всех трёх реализаций по описанным ранее критериям.
| | Babel | Backbone JS | Ember JS |
| --- | --- | --- | --- |
| Память | Равнозначно |
| Производительность | Высшая | Средняя | Низшая |
| Статические поля | + *(только в ES6)\** | + | — *(за исключением внутреннего использования наследования из Babel)* |
| Ссылка на суперкласс | `super.methodName()` *(только в ES6)* | `Constructor.__super__.prototype
.methodName.apply(this)` | `this._super()` |
| Косметические детали | Идеально с ES6;
требует доработки в собственной реализации под ES5 | Удобство объявления; проблемы при отладке | Зависит от способа наследования; те же проблемы с отладкой, что и в Backbone |
*\* — применение Babel идеально при использовании ES6; в случае написания своей реализации на его основе под ES5 статические поля и ссылку на суперкласс придётся дописывать самостоятельно.*
Критерий производительности оценивался не в абсолютных значениях, а относительно остальных реализаций, исходя из количества операций и циклов в каждом варианте. В целом, различия в производительности несущественны, т.к. расширение классов обычно происходит однократно на начальном этапе работы приложения и не вызывается повторно.
Все приведённые примеры имеют свои положительные стороны и недостатки, но наиболее практичной можно считать реализацию Babel. Как упоминалось выше, по возможности стоит использовать наследование, специфицированное в EcmaScript 6 с компиляцией в ES5. При отсутствии такой возможности рекомендуется написать свою реализацию функции `extend` на базе примера из компилятора Babel с учётом приведённых замечаний и дополнений из других примеров. Так наследование может быть реализовано наиболее гибким и подходящим под данный проект образом.
### Источники
1. [JavaScript.ru: Inheritance](http://javascript.ru/tutorial/object/inheritance)
2. [David Shariff. JavaScript Inheritance Patterns](http://davidshariff.com/blog/javascript-inheritance-patterns/)
3. [Eric Elliott. 3 Different Kinds of Prototypal Inheritance: ES6+ Edition](https://medium.com/javascript-scene/3-different-kinds-of-prototypal-inheritance-es6-edition-32d777fa16c9)
4. [Wikipedia: Composition over inheritance](https://en.wikipedia.org/wiki/Composition_over_inheritance)
5. [Mozilla Developer Network: Object.prototype](https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype)
6. [Backbone JS](http://backbonejs.org/)
7. [Ember JS](https://www.emberjs.com/)
8. [Babel](https://babeljs.io/) | https://habr.com/ru/post/353778/ | null | ru | null |
# Линукс не для айтишника или Линукс для неайтишника? Часть 2
Привет, Хабр!
В [первой части](https://habr.com/ru/post/698708/) я рассказал о своём опыте с Simply Linux, пришла очередь поделиться впечатлениями от Astra Linux CE Orel. В этот раз картинки будут.
Почему Astra? Во‑первых, отечественная, во‑вторых, стоит у моих клиентов в ЛПУ (в первой части я писал, что работаю медицинским представителем) и мне было интересно её «пощупать». Немаловажно и то, что в Astra те же команды терминала, к которым я уже привык.
Процесс установки никаких вопросов не вызывает, всё становится без приключений (тем более, диск был уже разбит, и мои файлы в /home были на месте).
Рабочий стол
------------
Выглядит повеселее, чем в Simply LinuxНо вот переключение между виртуальными рабочими столами — это просто ~~песнь души~~ мрак. Насколько я понял, при переключении между рабочими столами, в домашней директории создаётся символическая ссылка ~Desktop на тот рабочий стол, на который в переключаешься. Это вызывает тормоза и жуткую боль, особенно, когда по привычке, оставшейся от работы под Окнами нажимаешь Ctrl+F4, чтобы закрыть вкладку в активном окне, а переключаешься на четвёртый виртуальный рабочий стол. Если открыто несколько приложений, то это затягивается на несколько секунд. Тоже самое, когда пытаешься переключиться между приложениями, нажимая Alt+Tab: между приложениями‑то переключаешься, но только между теми, которые не свёрнуты, а они могут находиться на разных рабочих столах. В общем, боль.
Софт
----
Чаще всего мне приходится работать с Word'овскими документами, таблицами Excel, презентациями Power Point и PDF. При установке Astra Linux, примерно полгода тому назад, в составе дистрибутива был LibreOffice 7.2. Автоматически обновляться он отказывается напрочь, поэтому приходится ходить на сайт, скачивать и ставить его ручками, предварительно снеся предыдущую версию. И это тоже боль.
Сейчас у меня уже установлена версия 7.5, и насколько я понимаю, совместимость с MS Office выросла (по крайней мере, теперь не «съезжают» элементы в презентациях), что радует.
СкриншотБраузер FireFox был снесён моментально после установки и заменён на Chrome, позже установил ещё и Яндекс.Браузер (в нём погоду удобнее смотреть:D ). К сожалению, обновления Chrome тоже ставятся ручками, а с последним обновлением связана ещё одна боль.
Жмём «Переустановить», попадаем на сайт, скачиваем, пытаемся установить вручную и...
Ок. Идём в терминал, пытаемся установить недостающие библиотеки, пишем:
`apt install libcurl4 libgtk-4-1 libu2f-udev`и...
Попытки «прикрутить» репозитории Debian или Ubuntu ничего не дали, поэтому вздыхаем и остаёмся с прежней версией, поскольку знаний, чтобы победить эту проблему, пока ещё не хватает. Боль.
Ещё из софта установил AnyDesk и Remmina (иногда друзья и коллеги просят помочь им справится с какими‑то проблемами), Teams — нужен для работы, SimpleScreenRecorder. Хотел OBS Studio, но его нет в менеджере пакетов, и вручную он ставиться никак не хочет.
Следующий минус связан с тем, что не хочет открываться аудиомикшер KMix — ни через значок на рабочем столе, ни через меню Пуск. Зачем его включили в состав дистрибутива — не понимаю.
Регулятор громкости PulseAudio работает странно: чтобы получить приемлемую громкость, нужно вывести его на 100% и выше, иначе звук тихий. Это при том, что на этом же ноутбуке под Виндой звук был нормальный, выше 60% я его не поднимал.
Из «коробочного» софта очень нравятся скриншотер Spectacle, аудиоплеер Clementine, калькулятор Speedcrunch. Присутствуют довольно неплохие просмотрщики и редакторы изображений, есть целых три программы для работы с камерой, и две для работы со сканером.
Однако, ни одна из них не видит сканер моего МФУ Samsung SCX-4278, подключённого Ethernet-кабелем к роутеру (а Slimply Linux его сразу опознал, как родного), при этом принтер видно и он печатает. Правда, есть нюансы:
1. непонятно почему, печатает очень светло, чтобы текст был читабельным, выставил в настройках разрешение 1200dpi;
2. когда печатаю из браузера (часто PDF-ки скачиваю и они в нём автоматически открываются), принтер мне выдаёт две лишних страницы - первую и последнюю - на которых какая-то ~~абракадабра~~ диагностическая информация. Ещё интересный факт: эти две страницы печатаются чёрным, а не серым, как основной документ. Как победить это, я не нашёл, поэтому из браузера не печатаю.
Достался мне струйный принтер Epson L132, в комплекте «дров» для Linux'ов нет, на просторах тоже не нашёл. Печаль‑тоска.
Далее, Wine. Не от всех Windows‑программ пока удаётся избавится, поэтому эта вещь нужная и в хозяйстве полезная. В составе дистрибутива, но далеко не всё в нём запускается
В Astra Linux неплохая Панель управления:
Скриншот...но очень уж не хватает обнаружения и установки сканера.
Тут есть текст))Из сетевых приложений надо отметить графическую утилиту настройки межсетевого экрана Gufw, там всё достаточно просто и понятно. Хотя, обычному пользователю, который "переезжает" с Windows он вряд ли понадобится.
Выводы
------
В принципе, для рядового пользователя Astra Linux CE вполне пригодный дистрибутив. Легко ставится самостоятельно, легко настраивается (если нужно).
Радует, что "под капотом" стабильный Debian, не радует, что он старый (насколько я понял из прочитанного, 9-й).
Те пользователи, у которых на работе стоит Astra (врачи, учителя и т.д.), будут довольны и разницу вряд ли почувствуют.
Красивый рабочий стол, есть возможность настроить значки, обои, разные эффекты.
Лично я в качестве домашней ОС её рассматривать буду только в том случае, если дальнейшие мои исследования не приведут к лучшему (для меня) дистрибутиву.
**P.S.** Не судите строго )) | https://habr.com/ru/post/715522/ | null | ru | null |
# .NET 6 и провайдеры баз данных
Все материалы, которые будут показываться в ходе данной статьи будут доступны [по данной ссылке](https://github.com/vliashko/CommunicationWithDB). Вполне возможно, что со временем данный репозиторий будет обновляться, или, некоторые захотят сами принять участие в его развитии.
**Можно ли сегодня представить разработку, будь то десктопы или веб, без использования баз?**
Ну, чисто в теории можно, есть еще старенькие проекты, использующие файловую систему, идею которых можно еще увидеть в университетских лабораторных по сей день.
В чем же так плоха файловая система? Ну на самом деле, говоря на своем опыте, можно выделить следующие пункты:
1. Блокировка файла, в который идет запись
2. Отсутствие специализированных программ для работы с файлами (аналог СУБД)
Да, в какой-то мере можно выделить еще минусы, или попытаться закрыть уже названные мной. Но в целом главная идея базы данных – это удобство для чтения данных, а также наличие огромного числа инструментов для работы с данными (возможность быстрого поиска по полям таблицы, соединение таблиц, группировка записей, индексирование и т.д.)
Будем считать, что я смог в какой-то мере убедить, или хотя бы заинтриговать тем, что базы – это крутой механизм, который надо знать и уметь использовать.
Говоря о базах, я упомянул понятие запросов. В общих чертах запрос – это команда, которую ты говоришь выполнить базе. Запросы пишутся на языке SQL, состоят из предложений, и вот основные из них:
* SELECT
* FROM
* JOIN
* WHERE
* GROUP BY
* HAVING
* ORDER BY
Для данной статьи будем использовать базу данных состоящую из 3 таблиц:
*dbo.Student*
* *Id*
* *Name*
* *Course*
* *BirthDate*
*dbo.Department*
* *Id*
* *Name*
*dbo.Coursework*
* *Id*
* *StudentId*
* *DepartmentId*
* *DeliveryDate*
```
-- SELECT указывает на то, какие поля мы хотим выбрать.
-- Если указать *, то это означает выбор всех полей.
SELECT Student.Name, Student.BirthDate, COUNT(*) AS [Количество курсовых]
-- FROM указывает на то, из какой таблицы мы хотим вытащить данные
FROM Student
-- JOIN предназначен для объединения таблиц по какому либо условию.
-- В данном случае мы делаем связь по айдишникам студентов.
JOIN Coursework ON Student.Id = Coursework.StudentId
-- WHERE позволяет фильтровать выбору по какому либо условию .
-- Так, в этом случае я ищу тех студентов, которые имеют в имени начало Vladzimir.
WHERE Student.Name LIKE 'Vladzimir%'
-- GROUP BY нужен для группировки выборки, в данном случае группируем по студентам,
-- чтобы найти сколько у каждого студента сдано курсовых.
GROUP BY Student.Name, Student.BirthDate
-- HAVING представляет собой вторичную фильтрацию, и используется после GROUP BY.
-- В данном случае нам интересны те студенты, у которой больше 1 курсовой работы.
HAVING COUNT(*) > 1
-- ORDER BY служит для сортировки. Так, мы сортируем по убыванию
-- по полю день рождения.
-- Для сортировки по возрастанию надо убрать ключевое слово DESC.
ORDER BY BirthDate DESC
```
Отлично! Итого мы получаем всех студентов и количество их курсовых, если их сдано больше 1. Также нас интересуют только те студенты, у которых имя начинается с Vladzimir. При этом для удобства отсортировали по убыванию даты рождения.
Немного практики с SQL и он уже не кажется таким страшным и сложным. Хотя практиковаться с ним надо много, так как существует запросы куда больше и сложнее.
Теперь хорошая возможность перейти к нашей разработке.. Как же нам подружить наше приложение с базой данных?
Первое с чем надо определиться - это сервер и непосредственно наша база. Если мы пользуемся СУБД, то узнать данные параметры очень легко:
В данном случае, так как я пользовался MS SQL Server, то использовать Microsoft SQL Server Managment Studio (SSMS) является лучшим решением. При использовании, допустим, PostgreSQL можно использовать PG Admin в качестве СУБД.
При установке SQL сервера, в зависимости от версии (Express или расширенная) будет доступно несколько серверов:
{Имя компьютера}\SQLEXPRESS,
{Имя компьютера}.
Также отдельно можно поставить (localdb)\MSSQLLocalDB.
Теперь, определившись с сервером и базой данных (название можно придумать какое угодно, но для примеров ниже база будет называться University), можно приступать к изучению платформы .NET.
На самом деле на платформе .NET есть три основных решения для данной ситуации (в реальности их будет и больше, скорее всего, но реально поддерживаемых, стабильных и проверенных только три).
Поговорим немного о теории.
У нас есть 3 основных понятия, от которых и будет опираться:
1. ORM - это расшифровывается как Object/Relational Mapping, предоставляет большой перечень работы с базой, и базовые удобства, например как, CRUD операции из под коробки, также поддержка Change Tracker, Unit of Work и т.д.
2. Micro-ORM - представляет собой возможность сопоставления данных из таблиц с классами C#. На этом всё.
3. Провайдер базы данных - предоставляет возможность установить соединение с базой данных и отправить туда запрос. Всё остальное лежит на плечах программиста.
**Поэтому, когда говорим об ADO.NET - это провайдер, EntityFramework (EF) - ORM, а Dapper - micro-ORM.**
ADO.NET
-------
**Необходимо наличие следующих пакетов:**
* System.Data.SqlClient
Первым, и главным столпом является ADO.NET. Данный посредник между приложением и базой данных является самым старым, и предоставляет наибольшую свободу при работе с данными. Что предоставляет нам данная технология? На самом деле не так много, он позволяет открыть соединение с базой, и возможность отправки запроса в базу, а дальше.. Ну делайте что хотите в общем, его это уже не касается. В связи с этим большая необходимость в том, чтобы самим отлавливать все исключения, и самим закрыть соединение с базой после выполнения запроса (да, для особо ленивых придумана конструкция using еще).
**Основные классы, используемые для работы с ADO.NET:**
* SqlConnection
* SqlCommand
* SqlDataReader
* SqlParameter
Так, напишем консольное приложение, для того, чтобы попробовать работу с ADO.NET:
Первое, что мы делаем - создаем объект класса SqlConnection, в который передаем connectionString, эта переменная в которой содержится строка подключения к нашей базе
В моем случае она будет такая:
```
var connectionString =
"Data Source=.\\SQLEXPRESS;Initial Catalog=University;Integrated Security=True";
```
```
// Объявлем соединение с определенной строкой подключения.
var sqlConnection = new SqlConnection(connectionString);
```
В дальнейшем можем приступать в работе с базой:
```
try
{
sqlConnection.Open();
Console.WriteLine("SQL соединение открыто.");
// Добавление (аналогичный код для обновления / удаления).
var sqlCommand = sqlConnection.CreateCommand();
sqlCommand.CommandText = "INSERT INTO Student VALUES ('TestUser', 1, '20220101')";
var affectedRows = sqlCommand.ExecuteNonQuery();
Console.WriteLine($"Число затронутых строк: {affectedRows}");
// Чтение.
var sqlCommandForRead = sqlConnection.CreateCommand();
sqlCommandForRead.CommandText = "SELECT * FROM Student";
SqlDataReader reader = sqlCommandForRead.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
// При использовании reader[""] - мы получаем object,
// если хотим конкретный тип,
// то используем reader.GetString() / reader.GetInt() и т.д.
Console.WriteLine($"Студент с Id: {reader["Id"]}, " +
$"с курсом: {reader["Course"]}, " +
$"с именем: {reader["Name"]}, " +
$"с датой рождения: {reader["BirthDate"]}");
}
}
reader.Close();
// Получение результата агрегатной функции
var sqlCommandForCount = sqlConnection.CreateCommand();
sqlCommandForCount.CommandText = "SELECT COUNT(*) FROM Student";
var count = sqlCommandForCount.ExecuteScalar();
Console.WriteLine($"Полное число студентов: {count}");
// Есть два варианта параметризации запросов.
var name = "Some Student Name";
// Плохой вариант, так как позволяет получать и изменять данные
//при помощи механизма SQL-инъекций.
var sqlString = $"INSERT INTO Student VALUES ('{name}', 1, '20220101')";
var sqlCommandForInsertBadPractice = new SqlCommand(sqlString)
{
Connection = sqlConnection
};
affectedRows = sqlCommandForInsertBadPractice.ExecuteNonQuery();
// Хороший вариант, добавление SQL параметров.
sqlString = $"INSERT INTO Student VALUES (@name, 1, '20220101')";
var sqlParamForName = new SqlParameter("@name", name);
var sqlCommandForInsertGoodPractice = new SqlCommand(sqlString);
// Добавление параметра.
sqlCommandForInsertGoodPractice.Parameters.Add(sqlParamForName);
affectedRows = sqlCommandForInsertBadPractice.ExecuteNonQuery();
}
catch (Exception ex)
{
Console.WriteLine($"Ошибка: {ex.Message}");
throw;
}
finally
{
sqlConnection.Close();
Console.WriteLine("SQL соединение закрыто.");
}
```
В целом тут собрано несколько запросов, но надо отметить что основная идея тут одна:
1. Пишем конструкцию try catch finally
2. В try открываем соединение, в finally его закрываем
3. Затем происходит выбор: что нам нужно - чтение или изменение?
Так, в случае изменения данных создается экземпляр класса SqlCommand, затем указывается SQL запрос и выполняется метод ExecuteNonQuery(), который возвращает нам число затронутых строк:
```
var sqlCommand = sqlConnection.CreateCommand();
sqlCommand.CommandText = "INSERT INTO Student VALUES ('TestUser', 1, '20220101')";
var affectedRows = sqlCommand.ExecuteNonQuery();
Console.WriteLine($"Число затронутых строк: {affectedRows}");
```
В данном случае мы делаем вставку 1 записи, а значит на консоли увидим, что число затронутых строк также ровно 1.
В случае чтения данных необходимо создать также создать создать команду, однако вместо того, чтобы вызвать ExecuteNonQuery(), надо будет вызвать ExecuteReader(), который вернет нам экземпляр SqlDataReader.
```
var sqlCommandForRead = sqlConnection.CreateCommand();
sqlCommandForRead.CommandText = "SELECT * FROM Student";
SqlDataReader reader = sqlCommandForRead.ExecuteReader();
```
После получения данного экземпляра, проверяем, вернул ли он какие-то либо строки, и если вернул, то тогда начинаем их читать
```
if (reader.HasRows)
{
while (reader.Read())
{
// При использовании reader[""] - мы получаем object,
// если хотим конкретный тип,
// то используем reader.GetString() / reader.GetInt() и т.д.
Console.WriteLine($"Студент с Id: {reader["Id"]}, " +
$"с курсом: {reader["Course"]}, " +
$"с именем: {reader["Name"]}, " +
$"с датой рождения: {reader["BirthDate"]}");
}
}
```
После того, как мы выйдем из цикла while - обязательно закрываем reader.
```
reader.Close();
```
В случае необходимости получения данных путем вычисления агрегатной функции (COUNT, MIN, MAX, AVG, SUM) - применяют метод ExecuteScalar(), который возвращает первый столбец первой строки (чтоб в целом нам и нужно).
```
var sqlCommandForCount = sqlConnection.CreateCommand();
sqlCommandForCount.CommandText = "SELECT COUNT(*) FROM Student";
var count = sqlCommandForCount.ExecuteScalar();
Console.WriteLine($"Полное число студентов: {count}");
```
Теперь переходим наверное к самому интересному, а именно параметризация запросов.
В общем случае это можно сделать двумя способами: конкатенация строк и SQL-параметры, поговорим про каждый из этих методов по отдельности.
Пусть у нас будет переменная name, содержащая некоторую строку:
```
var name = "Some Student Name";
```
**Интерполяция строк**
К плюсам этого способа можно выделить более простой способ написания, который просто встраивает переменные в строку при помощи интерполяции строк
```
var sqlString = $"INSERT INTO Student VALUES ('{name}', 1, '20220101')";
var sqlCommandForInsertBadPractice = new SqlCommand(sqlString)
{
Connection = sqlConnection
};
affectedRows = sqlCommandForInsertBadPractice.ExecuteNonQuery();
```
В чем минус этого метода? В тот, что входная строка никак не валидируется, а значит если внешний код никак об этом не позаботиться, то имеет место быть всякие SQL-инъекции, лишние добавления записей и т.д.
**SQL-параметры**
Тут ситуация гораздо лучше и не пропускает невалидные ситуации, которые могут быть в ситуации выше, однако приходится написать больше кода:
```
sqlString = $"INSERT INTO Student VALUES (@name, 1, '20220101')";
var sqlParamForName = new SqlParameter("@name", name);
var sqlCommandForInsertGoodPractice = new SqlCommand(sqlString);
sqlCommandForInsertGoodPractice.Parameters.Add(sqlParamForName);
affectedRows = sqlCommandForInsertBadPractice.ExecuteNonQuery();
```
На этом основные возможности ADO.NET заканчиваются. В целом основная идея - следит за ошибками со стороны провайдера, и писать SQL код.
Dapper
------
**Необходимо наличие следующих пакетов:**
* Dapper
* System.Data.SqlClient
Много лишней теории тут говорить не буду. В целом Dapper - это посредник, которому всё еще нужен SqlConnection, однако открытие и закрытие уже будет автоматическим и в общем случае будет использоваться оператор using. Также один из важных плюсов Dapper - это сопоставление результатов запроса с классами C#, а значит не придется не придется делать страшные манипуляции с reader, как это было в случае с ADO.NET
**Классы, используемые при работы с Dapper**
* SqlConnection
И используемые от него методы: .Query() и .Execute().
Чтобы долго не тянуть - перейдем сразу к написанию консольного приложения по работе с Dapper:
```
using (var sqlConnection = new SqlConnection(connectionString))
{
// Добавление (аналогичный код для обновления / удаления).
sqlConnection.Execute(
"INSERT INTO Student VALUES ('TestUserDapper', 1, '20220101')"
);
// Чтение данных.
var students = sqlConnection.Query("SELECT \* FROM Student").ToList();
foreach (var student in students)
{
Console.WriteLine($"Студент с Id: {student.Id}, " +
$"с курсом: {student.Course}, " +
$"с именем: {student.Name}, " +
$"с датой рождения: {student.BirthDate}");
}
// Получение результата агрегатной функции
// В данном случае необходимо использование .FirstOrDefault(), так как
// .Query возвращает IEnumerable, что является коллекцией.
// И так как мы знаем что результатом будет 1 запись, то без зазрений совести
// можем применить .FirstOrDefault(), чтобы получить число записей.
var count = sqlConnection.Query("SELECT COUNT(\*) FROM Student")
.FirstOrDefault();
Console.WriteLine($"Общее число записей в таблице студентов: {count}");
// Использование параметров.
sqlConnection.Execute("INSERT INTO Student VALUES (@Name, @Course, @BirthDate)",
new Student
{
Name = "SomeParamName",
Course = 2,
BirthDate = new DateTime(2022, 04, 04)
});
// Анонимные объекты new { }.
sqlConnection.Execute("DELETE FROM Student WHERE Name = @name",
new { name = "TestUserDapper" });
}
```
Даже сравнивания по объему кода уже видно, насколько Dapper проще в использовании.
В целом использование у Dapper следующее:
1. В конструкции using создать экземпляр SqlConnection с переданной в него строкой подключения
2. В зависимости от того, хотим ли получить данные, или их изменить - написать .Query или .Execute
При чтении данных мы используем .Query, где T - класс, в который будут мапиться результатами из базы. Так, вся работа которую мы делали руками, получая каждое значение каждой строки руками - Dapper делает за нас, и на выходе мы получаем IEnumerable.
```
var students = sqlConnection.Query("SELECT \* FROM Student").ToList();
// В случае единственного перечисления по коллекции students приведение к ToList()
// является избыточным и сделано только в учебных целях.
```
Для получения результата агрегатной функции в общем случае используется также Query, где в T передается тип данных (int, double, float и т.д), а затем берется первая запись из полученной коллекции, так как такая выборка на стороне базы возвращает 1 строку с 1 столбцом.
```
var count = sqlConnection.Query("SELECT COUNT(\*) FROM Student")
.FirstOrDefault();
```
В случае, когда мы работаем с параметрами, мы можем передавать напрямую экземпляр класса, или анонимный объект.
Так, например, при добавлении записи мы можем написать следующую запись:
```
sqlConnection.Execute("INSERT INTO Student VALUES (@Name, @Course, @BirthDate)",
new Student
{
Name = "SomeParamName",
Course = 2,
BirthDate = new DateTime(2022, 04, 04)
});
```
Dapper сам произведет необходимый маппинг по имени. Если типы не соответствует - будет выброшено исключение.
И пример использования анонимного объекта, если не хотим создавать какой-то класс:
```
sqlConnection.Execute("DELETE FROM Student WHERE Name = @name",
new { name = "TestUserDapper" });
```
На этом основные возможности Dapper заканчиваются. Он прост в использовании, и как посмотрим далее, достаточно производителен.
EntityFramework
---------------
**Необходимо наличие следующих пакетов:**
* Microsoft.EntityFrameworkCore
* Microsoft.EntityFrameworkCore.SqlServer
* Microsoft.EntityFrameworkCore.Tools (Не обязательный)
Я даже не знаю с чего начать, данный фреймворк является самый настоящим монстром, и обладает огромным количеством возможностей. О некоторых из них мы поговорим в этой статье, однако если будет необходимость - то EF можно обсудить более детально в отдельной статье.
**Вот несколько сильных сторон от EF:**
1. Поддержка разных способов синхронизации (Code First, Database First)
2. Миграции
3. LINQ To Entities (и расширения напрямую из пакета EntityFrameworkCore)
4. AsNoTracking
5. CRUD операции
Начнем с самого начала - EF является достаточно большой системой, которая требует много подготовительной работы, но сполна награждает за неё. Так, например, создадим все классы для нашей базы данных (Student, Department, Coursework):
```
public class Student
{
public int Id { get; set; }
public int Course { get; set; }
[StringLength(90)]
public string Name { get; set; }
public DateTime BirthDate { get; set; }
}
public class Department
{
public int Id { get; set; }
[StringLength(90)]
public string Name { get; set; }
}
public class Coursework
{
public int Id { get; set; }
public int StudentId { get; set; }
public int DepartmentId { get; set; }
public DateTime DeliveryDate { get; set; }
}
```
После создания данных классов (что в целом достаточно легко), нам необходимо создать её один класс - который обычно называется - НазваниеБазыContext, так в данном случае это будет UniversityContext.
```
public class UniversityContext : DbContext
{
public UniversityContext() { }
public UniversityContext(DbContextOptions options) : base(options) { }
public DbSet Student { get; set; }
public DbSet Department { get; set; }
public DbSet Coursework { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var dbConfig = new DbConfiguration();
optionsBuilder.UseSqlServer(dbConfig.GetConnectionString("connString"));
}
}
```
Тут уже немного сложнее, поэтому пройдемся более детально по этому классу.
Наличие DbSet. В целом, для простого понимания - DbSet представляет собой коллекцию (но не в памяти, а удаленную), которая представляет каждую отдельную таблицу. Так, например, DbSet Student - говорит о том, что у нас "есть" таблица со столбцами такими как поля в классе Student, и название у такой таблицы Student.
Также есть переопределение метода OnConfiguring(DbContextOptionsBuilder optionsBuilder). Это нужно для того, чтобы определить, с какой базой данный будет связан наш контекст. В целом там гораздо больше различных настроек, но на данный момент это основная.
Немного про конструкторы: в данном случае их 2, хотя для наших целей достаточно и одного. В общем случае при разработке веб-приложений и использования механизма DI нам будет достаточно второго конструктора, который принимает параметры. Однако в данном кейсе мы делаем все настройки в методе OnConfiguring, поэтому нам достаточно просто создавать контекст с пустым конструктором. Но не всё так просто.
Есть одна необходимость - это миграции. Чуть ниже мы обсудим что это такое, но для того, чтобы это механизм работал - нам нужно сделать одно из двух условий:
* Иметь конструктор без параметров
* Иметь класс, который реализует интерфейс IDesignTimeDbContextFactory, где T - наш контекст. Вот пример реализации этого интерфейса:
```
public class UniversityContextFactory :
IDesignTimeDbContextFactory
{
public UniversityContext CreateDbContext(string[] args)
{
var dbConfig = new DbConfiguration();
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(dbConfig.GetConnectionString("connString"));
return new UniversityContext(optionsBuilder.Options);
}
}
```
**Миграции**
Миграции - магическое слово EF и одна из самых сильных его сторон. Что такое миграции?
Это механизм, который позволяет нам создать некоторое подобие гита, только для базы данных. Фактически, внося изменения в какую-нибудь из моделей или контекст, вы “фиксируете” эти изменения и создаете миграцию. Она имеет два метода: Up и Down. Соответственно при помощи данных методов вы можете двигаться “вверх” или “вниз”. Немало важный плюс миграций - это то, что они не удаляют данные, когда накатываются на базу. Работа с миграциями всегда будет идти по циклу: внесли изменения в C# классы, создали миграцию, применили миграцию.
Для создания миграции нам нужно открыть Package Manager Console в Visual Studio и написать следующую команду:
```
Add-Migration <Название Миграции>
```
В результате выполнения этой команды появится 2 класса (только при первой миграции, потом будет 1 класс).
Один из классов - ModelSnapshot, которую является некоторым сборщиком миграций, и знает, в каком порядке они должны применяться.
Второй класс - это непосредственно наша миграция и имеет данный класс следующий вид:
```
public partial class Initial : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Coursework",
columns: table => new
{
Id = table.Column(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
StudentId = table.Column(type: "int", nullable: false),
DepartmentId = table.Column(type: "int", nullable: false),
DeliveryDate = table.Column(type: "datetime2",
nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK\_Coursework", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Department",
columns: table => new
{
Id = table.Column(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Name = table.Column(type: "nvarchar(90)",
maxLength: 90, nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK\_Department", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Student",
columns: table => new
{
Id = table.Column(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Course = table.Column(type: "int", nullable: false),
Name = table.Column(type: "nvarchar(90)",
maxLength: 90, nullable: false),
BirthDate = table.Column(type: "datetime2",
nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK\_Student", x => x.Id);
});
}
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "Coursework");
migrationBuilder.DropTable(
name: "Department");
migrationBuilder.DropTable(
name: "Student");
}
}
```
Как и говорилось выше - миграция имеет два метода, один применяется, если мы применяем нашу миграцию (то есть идем "вверх"), а второй применяется, когда мы отменяем миграцию (то есть идем "вниз"). Так, в нашем примере мы создали миграцию с именем Initial, и при применении миграции у нас появятся три таблицы, а при отмене миграции - удалятся 3 таблицы.
Можете попробовать удалить все таблицы из базы (даже саму базу), и ввести в Package Manager Console следующую команду:
```
Update-Database
```
После этого можете удивляться результату.
На самом деле, Миграции являются частью принципа Code First, в котором мы пишем код, а потом говорим, что EF применил этот код для базы. Однако существует и второй принцип - Database First, который, по названию, означает, что сначала мы создаем базу, а потом только C# код. На самом деле реализуется это достаточно простым механизмом, что называется одной командой, которая имеет следующий вид, и вводится в всё тот же Package Manager Console:
```
Scaffold-DbContext "Server=(localdb)\mssqllocaldb;Database=University;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer
```
И так, как и я сказал, это один из самых важных и популярных механизмов, который предоставляет EF, но не единственный.
**LINQ To Entities**
Еще одна классная возможность EF - поддержка построения запросов без знания SQL, так как EF сам делает все преобразования C# кода в SQL.
Например, если вернёмся к тому SQL скрипту, который был в самом начале:
```
SELECT Student.Name, Student.BirthDate, COUNT(*) AS [Количество курсовых]
FROM Student
JOIN Coursework ON Student.Id = Coursework.StudentId
WHERE Student.Name LIKE 'Vladzimir%'
GROUP BY Student.Name, Student.BirthDate
HAVING COUNT(*) > 1
ORDER BY BirthDate DESC
```
На языке LINQ это будет выглядеть так:
```
var sqlQueryToLinq = dbContext.Student
.Where(student => student.Name.Contains("Vladzimir"))
.Join(dbContext.Coursework,
student => student.Id,
coursework => coursework.StudentId,
(student, coursework) => student)
.GroupBy(student => new { student.Name, student.BirthDate })
.Where(grouped => grouped.Count() > 1)
.OrderByDescending(grouped => grouped.Key.BirthDate)
.Select(grouped =>
new { grouped.Key.Name, grouped.Key.BirthDate, Count = grouped.Count() })
.ToList();
```
Выглядит сложно для первого понимания, но в целом любая часть соответствует предложениям из SQL. А трактовка значка '=>' несколько сложная, если не понять что такое делегаты. Но если пояснение, то его можно посмотреть тут:
Пояснение по поводу LINQ запроса
```
// Обращаюсь к базе данных, в частности к таблице Student
dbContext.Student
// Из всех студентов выбрать такого студента,
// у которого имя содержит "Vladzimir"
.Where(student => student.Name.Contains("Vladzimir"))
// Сделать объединение с таблицей Coursework
.Join(dbContext.Coursework,
// Со стороны таблицы Student связь по полю Id
student => student.Id,
// Со стороны таблицы Coursework связь по полю StudentId
coursework => coursework.StudentId,
// В результате объединения остальные данные только по студенту
(student, coursework) => student)
// Сделать группировку по имени и дате рождения
.GroupBy(student => new { student.Name, student.BirthDate })
// Выбрать те записи группировки,
// у которых результат группировки больше 1
// (это мы про количество курсовых говорили)
.Where(grouped => grouped.Count() > 1)
// Отсортировать записи по убыванию дня рождения
.OrderByDescending(grouped => grouped.Key.BirthDate)
// Из результата группировки создать коллекцию анонимных обьектов,
// состоящих из имени, дня рождения и количество курсовых
.Select(grouped =>
new { grouped.Key.Name, grouped.Key.BirthDate,
Count = grouped.Count() })
// Команда выполнения запроса
.ToList();
```
**AsNoTracking**
Еще одна возможность EntityFramework, о которой немного подробнее надо рассказать:
Внутри EntityFramework содержится много разных способ отслеживания изменений, кеширования и т.д.
Так вот один из явных инструментов является Change Tracker, который создает некоторую связь между данными из таблиц и объектами C#. Также, если нам это механизм кажется излишним, то мы его может отключить, при помощи метода AsNoTracking().
Рассмотрим такой пример для большей наглядности этого механизма:
```
var studentVladzimir = dbContext.Student
.Where(student => student.Name.Contains("Vladzimir"))
.FirstOrDefault();
studentVladzimir.Course = 999;
dbContext.SaveChanges();
var studentVladzimirWithoutTracking = dbContext.Student
.Where(student => student.Name.Contains("Vladzimir"))
.AsNoTracking()
.FirstOrDefault();
studentVladzimirWithoutTracking.Course = 777;
dbContext.SaveChanges();
```
Что мы ожидаем увидеть в таблице, если найдем такую запись? Результат будет 999.
Почему так? Потому что когда мы получаем данные при помощи нашего контекста, то он не создаем полностью независимый объект, а ставит между ним и записью из базы связь, которая будет обновлять запись в базе при применении SaveChanges().
В случае применения AsNoTracking() - контекст не будет устанавливать связь, а просто создать новый объект, как будто сделали просто new Student().
**CRUD-операции**
Напоследок, небольшой бонус, который дает EF - готовые реализации для добавления, удаления и изменения записи.
Так, например, для добавления используется следующий код:
```
dbContext.Student.Add(
new Student()
{
Name = "SomeStudent For EF Test",
Course = 3,
BirthDate = new DateTime(2022, 4, 7)
});
```
Аналогичный код используется и для обновления (Update), и удаления (Remove).
Также, один из важных плюсов, поддержка - AddRange, UpdateRange, RemoveRange, они являются возможность делать bulk-операции.
Немного тестов и результаты
---------------------------
В целом, мы познакомились с основными провайдерами баз данных. На самом деле на проектах можно встретить каждый из этих провайдеров, а иногда и несколько сразу.
Я решил написать парочку тестов, в частности для получения данных, так как в целом любое изменение данных во всех провайдерах примерно одинаково.
Так, например, вот такие результаты показали провайдеры на 20000 данных.
| | | |
| --- | --- | --- |
| Method | Time | Allocated Memory |
| GetAll\_EF\_WithTracking | 51.79 ms | 22 MB |
| GetAll\_EF\_WithNoTracking | 16.52 ms | 6 MB |
| GetAll\_ADO | 7.351 ms | 2 MB |
| GetAll\_Dapper | 13.07 ms | 4 MB |
Как видим, EF показываем не самые лучшие результаты, и по большей части это связано с тем, что мы всячески блокируем в тестах попытки кеша каких либо результатов. В реальных условиях ситуация будет такая, что разница между Dapper и EF может быть до 5%. Однако тяжеловесность EF показывает то, как много памяти он кушает.
В большинстве своем - получение такого числа данных - очень редкий кейс, и в среднем надо вытягивать от 1 до 100 записей за раз, и на таких данных разница во времени будет минимальна между ними.
**Вот некоторые выводы к которым можно прийти, прочитав эту статью:**
1. .NET предоставляет различные механизмы работы, и выбор достаточно внушительный, каждый из представленных механизмов отличается от двух других.
2. Знание SQL необходимо, но не обязательно. Влияние EntityFramework с годами увеличивается, как и его производительность.
3. Мы всегда смотрим не только на производительность, но и на то насколько быстро мы можем написать наш код. В таких случаях зачастую выбор остается между Dapper и EntityFramework.
На этом наверное всё, огромное спасибо за прочтение этой статьи!
Как и говорилось в начале, вы можете попробовать сделать всё сами, при помощи github-репозитория, который будет в открытом доступе. | https://habr.com/ru/post/669198/ | null | ru | null |
# Руководство по разработке Web-приложений на React Native
Вы проснулись. Сияет солнце, щебечут птички. В мире никто ни с кем не воюет, никто не голодает, а один и тот же код можно использовать и в веб-проектах, и в нативных приложениях. Как бы было хорошо! К сожалению, на горизонте можно разглядеть лишь универсальный код, но путь к нему, даже сегодня, всё ещё полон неожиданностей.
[](https://habr.com/company/ruvds/blog/428568/)
Материал, перевод которого мы сегодня публикуем, представляет собой небольшое, но достаточно подробное руководство по разработке универсальных приложений с использованием React Native.
Зачем это всё?
--------------
Аббревиатура «PWA» ([Progressive Web Apps](https://en.wikipedia.org/wiki/Progressive_Web_Apps), прогрессивные веб-приложения) сегодня у всех на слуху, этот трёхбуквенный акроним кажется прямо-таки китом в море технических терминов. Но и эта популярная технология всё ещё не лишена [недостатков](https://clutch.co/app-developers/resources/pros-cons-progressive-web-apps). С такими приложениями связано немало технологических сложностей, существуют ситуации, в которых разработчик вынужден параллельно создавать нативные и веб-приложения. [Вот](https://appinstitute.com/pwa-vs-native-apps/) хорошая статья, в которой сравниваются PWA и нативные приложения.
Может быть, бизнесу стоит сосредоточить внимание лишь на нативных приложениях? Нет, не стоит. Это — большая ошибка. В результате логически оправданным шагом становится разработка единого универсального приложения. Это позволяет снизить затраты времени на разработку, уменьшить стоимость создания и поддержки проектов. Именно эти характеристики универсальных приложений и подвигли меня на один небольшой эксперимент.
Речь идёт об универсальном приложении-примере из сферы электронной коммерции для заказа еды. После эксперимента я создал шаблон для будущих проектов и для дальнейших исследований.
*Papu — приложение для заказа еды, предназначенное для Android, iOS и для веба*
Базовые строительные блоки приложения
-------------------------------------
Здесь мы пользуемся React, поэтому нам надо отделить логику приложения от пользовательского интерфейса. Тут лучше всего использовать какую-нибудь систему для управления состоянием приложения вроде Redux или Mobx. Подобный ход сразу же делает логику функционирования приложения универсальной. Её, без изменений, можно использовать на разных платформах.
Визуальная часть приложения — это уже другой разговор. Для того чтобы сконструировать интерфейс приложения, нужно иметь универсальный набор примитивов, базовых строительных блоков. Они должны работать и в вебе, и в нативной среде. К сожалению, язык веба и язык нативных платформ — это разные вещи.
Например, стандартный веб-контейнер обратится к вам так:
```
Здравия желаю! Стандартный веб-контейнер к вашим услугам!
```
А нативный — так:
```
Привет! Я - простой контейнер в React Native
```
Некоторые умные люди нашли выход из этой ситуации. Выходом стали специализированные библиотеки элементов. Одна из моих любимых — это замечательная библиотека [React Native Web](https://github.com/necolas/react-native-web). Она не только берёт на себя заботу о базовых примитивах приложения, позволяя использовать компоненты React Native в вебе (не все компоненты!), но и даёт доступ к различным API React Native. Среди них — `Geolocation`, `Platform`, `Animated`, `AsyncStorage` и многие другие. Взгляните на замечательные примеры, которые можно найти в [руководстве](https://github.com/necolas/react-native-web/tree/master/docs/guides) к этой библиотеке.
Шаблон
------
С примитивами мы разобрались. Но нам ещё нужно связать среды для веб-разработки и для нативной разработки. В моём проекте использованы [create-react-app](https://github.com/facebook/create-react-app) (для веб-приложения) и [скрипт инициализации](https://facebook.github.io/react-native/docs/getting-started) React Native (для нативного приложения, без Expo). Сначала я создал один проект такой командой: `create-react-app rnw_web`. Затем создал второй проект: `react-native init raw_native`. Затем я, последовав примеру Виктора Франкенштейна, взял файлы `package.json` из этих двух проектов и объединил их. После этого я, в папке нового проекта, скормил новый файл `yarn`. Вот о каком `package`-файле идёт речь:
```
{
"name": "rnw_boilerplate",
"version": "0.1.0",
"private": true,
"dependencies": {
"react": "^16.5.1",
"react-art": "^16.5.1",
"react-dom": "^16.5.1",
"react-native": "0.56.0",
"react-native-web": "^0.9.0",
"react-navigation": "^2.17.0",
"react-router-dom": "^4.3.1",
"react-router-modal": "^1.4.2"
},
"devDependencies": {
"babel-jest": "^23.4.0",
"babel-preset-react-native": "^5",
"jest": "^23.4.1",
"react-scripts": "1.1.5",
"react-test-renderer": "^16.3.1"
},
"scripts": {
"start": "node node_modules/react-native/local-cli/cli.js start",
"test": "jest",
"start-ios": "react-native run-ios",
"start-web": "react-scripts start",
"build": "react-scripts build",
"test-web": "react-scripts test --env=jsdom",
"eject-web": "react-scripts eject"
}
}
```
Обратите внимание на то, что в этой версии файла нет навигационных возможностей. Далее, надо скопировать все файлы с исходным кодом из папок веб-приложения и нативного приложения в папку нового унифицированного проекта.
*Папки, которые нужно скопировать в новый проект*
Теперь, в папке `src`, которая лежит в директории нового проекта, создадим два файла: `App.js` и `App.native.js`. Благодаря [webpack](https://webpack.js.org/) мы можем использовать расширения имён файлов для того, чтобы сообщить бандлеру о том, где какие файлы нужно использовать. Разделить `App`-файлы жизненно важно, так как мы собираемся использовать разные подходы для навигации по приложениям.
Вот файл `App.js`, предназначенный для веба. Для навигации используется `react-router`.
```
// App.js - WEB
import React, { Component } from "react";
import { View } from "react-native";
import WebRoutesGenerator from "./NativeWebRouteWrapper/index";
import { ModalContainer } from "react-router-modal";
import HomeScreen from "./HomeScreen";
import TopNav from "./TopNav";
import SecondScreen from "./SecondScreen";
import UserScreen from "./UserScreen";
import DasModalScreen from "./DasModalScreen";
const routeMap = {
Home: {
component: HomeScreen,
path: "/",
exact: true
},
Second: {
component: SecondScreen,
path: "/second"
},
User: {
component: UserScreen,
path: "/user/:name?",
exact: true
},
DasModal: {
component: DasModalScreen,
path: "*/dasmodal",
modal: true
}
};
class App extends Component {
render() {
return (
{WebRoutesGenerator({ routeMap })}
);
}
}
export default App;
```
Вот `App.js` для React Native-приложения. Тут для навигации используется `react-navigation`.
```
// App.js - React Native
import React, { Component } from "react";
import {
createStackNavigator,
createBottomTabNavigator
} from "react-navigation";
import HomeScreen from "./HomeScreen";
import DasModalScreen from "./DasModalScreen";
import SecondScreen from "./SecondScreen";
import UserScreen from "./UserScreen";
const HomeStack = createStackNavigator({
Home: { screen: HomeScreen, navigationOptions: { title: "Home" } }
});
const SecondStack = createStackNavigator({
Second: { screen: SecondScreen, navigationOptions: { title: "Second" } },
User: { screen: UserScreen, navigationOptions: { title: "User" } }
});
const TabNav = createBottomTabNavigator({
Home: HomeStack,
SecondStack: SecondStack
});
const RootStack = createStackNavigator(
{
Main: TabNav,
DasModal: DasModalScreen
},
{
mode: "modal",
headerMode: "none"
}
);
class App extends Component {
render() {
return ;
}
}
export default App;
```
Вот так я создал простой шаблон приложения и подготовил платформу для дальнейшей работы. Можете попробовать данный шаблон, заглянув в [этот](https://github.com/inspmoore/rnw_boilerplate) репозиторий.
Сейчас мы немного этот шаблон усложним, добавим систему маршрутизации/навигации.
Проблемы навигации и их решения
-------------------------------
Приложению, если только оно не состоит из одного экрана, нужна некая система навигации. Сейчас (речь идёт о сентябре 2018 года) существует лишь одна такая универсальная рабочая система, подходящая и для веба, и для нативных приложений. Речь идёт о [React Router](https://reacttraining.com/react-router/). Для веба это решение подходит хорошо, а вот в случае с React Native-проектами всё уже не так однозначно.
В React Router Native нет переходов между экранами, нет поддержки кнопки Назад (для платформы Android), нет модальных экранов, навигационных панелей и других возможностей. Другие средства навигации, вроде [React Navigation](https://reactnavigation.org/), этими возможностями обладают.
Я использовал именно эту библиотеку, но вы можете подобрать что-нибудь другое. Поэтому в моём проекте за навигацию в веб-приложении отвечает React Router, а за навигацию в нативном приложении — React Navigation. Это, правда, создаёт новую проблему. Дело в том, что подходы к навигации и к передаче параметров в этих системах очень сильно различаются.
Для того чтобы сохранить дух React Native Web, используя везде подход, близкий к тому, что применяется в нативных приложениях, я подошёл к решению этой проблемы, создавая веб-маршруты и оборачивая их в HOC. Это дало мне возможность создать API, напоминающее React Navigation.
Такой подход позволил перемещаться между экранами веб-приложения, избавив меня от необходимости создавать отдельные компоненты для двух видов приложения.
Первый шаг реализации этого механизма заключается в создании объекта с описанием маршрутов для веб-приложения:
```
import WebRoutesGenerator from "./NativeWebRouteWrapper"; // функция собственной разработки, которая генерирует маршруты React Router и оборачивает их в HOC
const routeMap = {
Home: {
screen: HomeScreen,
path: '/',
exact: true
},
Menu: {
screen: MenuScreen,
path: '/menu/sectionIndex?'
}
}
//в методе render
{WebRoutesGenerator({ routeMap })}
```
В сущности, тут представлена копия функции создания навигатора React Navigation с добавлениями специфических для React Router возможностей.
Далее, пользуясь моей вспомогательной функцией, я создаю маршруты `react-router` и оборачиваю их в HOC. Это позволяет клонировать компонент `screen` и добавить `navigation` в его свойства. Этот подход имитирует поведение React Navigation и делает доступными методы вроде `navigate()`, `goBack()`, `getParam()`.
Модальные экраны
----------------
React Navigation, благодаря `createStackNavigator`, даёт возможность сделать так, чтобы некая страница приложения выезжала бы снизу в виде модального экрана. Для того чтобы добиться подобного в веб-приложении, мне пришлось использовать библиотеку [React Router Modal](https://github.com/davidmfoley/react-router-modal). Для работы с модальным экраном сначала надо добавить соответствующую опцию в объект `routeMap`:
```
const routeMap = {
Modal: {
screen: ModalScreen,
path: '*/modal',
modal: true //маршрутизатор будет использовать компонент ModalRoute для рендеринга этого маршрута
}
}
```
Кроме того, в макет приложения нужно добавить компонент из библиотеки `react-router-modal`. Выводиться соответствующая страница будет именно там.
Навигация между экранами
------------------------
Благодаря HOC нашей разработки (временно этот компонент называется `NativeWebRouteWrapper` , и это, кстати, ужасное имя), мы можем использовать практически тот же набор функций, что и в React Navigation, для организации перемещения между страницами в веб-версии приложения:
```
const { product, navigation } = this.props
```
Возврат к предыдущему экрану
----------------------------
В React Navigation можно вернуться назад на `n` экранов, которые находятся в навигационном стеке. Подобное в React Router недоступно, тут нет навигационного стека. Для того чтобы решить эту проблему, нам нужно импортировать в код функцию `pop` собственной разработки. Вызывая её, передадим ей несколько параметров:
```
import pop from '/NativeWebRouteWrapper/pop'
render() {
const { navigation } = this.props
return (
)
}
```
Опишем эти параметры:
* `screen` — имя экрана (используемое React Router в веб-версии приложения).
* `n` — число экранов для возврата с использованием стека (используется React Navigation).
* `navigation` — объект, обеспечивающий навигацию.
Результаты работы
-----------------
Если вы хотите поэкспериментировать с представленной здесь идеей разработки универсальных приложений — я создал два шаблона.
[Первый](https://github.com/inspmoore/rnw_boilerplate) представляет собой чистую универсальную среду для разработки веб-приложений и нативных приложений.
[Второй](https://github.com/inspmoore/rnw_boilerplate_nav) — это, в сущности, первый шаблон, который расширен за счёт моей системы для организации навигации по приложению.
[Вот](https://github.com/inspmoore/papu) демонстрационное приложение papu, основанное на высказанных выше соображениях. Оно полно ошибок и тупиков, но вы можете самостоятельно его собрать, запустить его в браузере и на мобильном устройстве, и на практике получить представление о том, как всё это работает.
Итоги
-----
Сообществу React-разработчиков, безусловно, нужна универсальная библиотека для организации навигации по приложениям, так как это упростит разработку проектов, подобных тому, о котором мы говорили. Очень хорошо было бы, если бы библиотека React Navigation работала бы и в вебе (на самом деле, подобная возможность уже [доступна](https://pickering.org/using-react-native-react-native-web-and-react-navigation-in-a-single-project-cfd4bcca16d0), но работа с ней не лишена сложностей).
**Уважаемые читатели!** Пользуетесь ли вы возможностями React при создании универсальных приложений?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/428568/ | null | ru | null |
# Оптимизация портфеля ценных бумаг средствами Python
### Введение
На финансовом рынке обращается, как правило, несколько типов ценных бумаг: государственные ценные бумаги, муниципальные облигации, корпоративные акции и т.п.
Если у участника рынка есть свободные деньги, то их можно отнести в банк и получать проценты или купить на них ценные бумаги и получать дополнительный доход. Но в какой банк отнести? Какие ценные бумаги купить?
Ценные бумаги с низкими рисками, как правило, малодоходны, а высокодоходные, как правило, более рискованны. Экономическая наука может дать некоторые рекомендации для решения этого вопроса, но для этого необходимо иметь соответствующие программные средства, желательно с простым интерфейсом и бесплатные.
Программные средства для анализа портфелей ценных бумах должны работать с матрицами доходности и решать задачи нелинейного программирования с ограничениями в виде строгих и нестрогих неравенств. Символьное решение на Python некоторых типов задач нелинейного программирования мною уже рассматривалось в публикации [1]. Однако, применить предложенные в указанной публикации методы для анализа портфеля ценных бумаг нельзя из-за ограничений в виде строгих неравенств.
Целью настоящей публикации является разработка методов оптимизации портфелей ценных бумаг с использованием библиотеки scipy.optimize. Пришлось исследовать и применить при программировании такие мало известные возможности указанной библиотеки, как введение дополнительных ограничений в функцию цели [2].
### Постановка задачи об оптимальном портфеле Марковица
Рассмотрим общую задачу распределения капитала, который участник рынка хочет потратить на приобретение ценных бумаг. Цель инвестора – вложить деньги так, чтобы сохранить свой капитал, а при возможности и нарастить его.
Набор ценных бумаг, находящихся у участника рынка, называется его портфелем. Стоимость портфеля – это суммарная стоимость всех составляющих его бумаг. Если сегодня его стоимость есть Р, а через год она окажется равной Р', то (Р'- Р)/Р естественно назвать доходностью портфеля в процентах годовых. Доходность портфеля – это доходность на единицу его стоимости.
Пусть **xi** – доля капитала, потраченная на покупку ценных бумаг i-го вида. Весь выделенный капитал принимается за единицу. Пусть **di** – доходность в процентах годовых бумаг i-го вида в расчете на одну денежную единицу.
Доходность колеблется во времени, так что будем считать ее случайной величиной. Пусть **mi**, **ri** – средняя ожидаемая доходность и среднее квадратическое отклонение, называемое риском. Через **CVij** обозначим ковариацию доходностей ценных бумаг i – го и j – го видов.
Каждый владелец портфеля ценных бумаг сталкивается с дилеммой: хочется иметь эффективность больше, а риск меньше. Однако, поскольку “нельзя поймать двух зайцев сразу”, необходимо сделать определенный выбор между эффективностью и риском.
### Модель оптимального портфеля Марковица, которая обеспечивает минимальный риск и заданную доходность
Такая модель в виде системы из уравнений и неравенств имеет вид [3]:
Необходимо определить: x1,x2…xn.
Исходными данными для расчета является матрица доходности ценных бумаг следующей формы (заполненный пример матрицы в листинге программы):
Для реализации модели минимального риска на Python нужно выполнить следующие этапы разработки:
1.Определение средней доходности акций 1-6:
```
from sympy import *
import numpy as np
from scipy.optimize import minimize
from sympy import *
import numpy as np
from scipy.optimize import minimize
"D- матрица доходности (обычно загружается из файла)"
D=np.array([[9.889, 11.603,11.612, 12.721,11.453,12.102],
[12.517, 13.25,12.947,12.596,12.853,13.036],
[12.786, 12.822,15.447,14.452,15.143,16.247],
[11.863, 12.114,13.359,13.437,11.913,15.300],
[11.444, 13.292,13.703,11.504,13.406,15.255],
[14.696, 15.946,16.829,17.698,16.051,17.140]],np.float64)
d= np.zeros([6,1])# столбец для средней доходности
m,n= D.shape#размерность матрицы
for j in np.arange(0,n):
for i in np.arange(0,m):
d[j,0]=d[j,0]+D[i,j]
d=d/n
print("Средняя доходность акций 1-6 : \n %s"%d)
```
**Получим:**
Средняя доходность акций 1-6:
[[ 12.19916667]
[ 13.17116667]
[ 13.98283333]
[ 13.73466667]
[ 13.46983333]
[ 14.84666667]]
2. Построение ковариационной матрицы (m=n=6).
CV= np.zeros([m,n])
for i in np.arange(0,m):
for j in np.arange(0,n):
x=np.array(D[0:m,j]).T
y=np.array(D[0:m,i]).T
X = np.vstack((x,y))
CV[i,j]=round(np.cov(x,y,ddof=0)[1,0],3)
print(«Ковариационная матрица CV: \n %s»%CV)
**Получим:**
Ковариационная матрица CV:
[[ 2.117 1.773 2.256 2.347 2.077 1.975]
[ 1.773 1.903 1.941 2.049 1.888 1.601]
[ 2.256 1.941 2.901 2.787 2.701 2.761]
[ 2.347 2.049 2.787 3.935 2.464 2.315]
[ 2.077 1.888 2.701 2.464 2.723 2.364]
[ 1.975 1.601 2.761 2.315 2.364 3.067]]
3. Символьное определение функции для определения дисперсии доходности портфеля (функции риска).
```
x1,x2,x3,x4,x5,x6,x7,x8,p,q,w=symbols(' x1 x2 x3 x4 x5 x6 x7 x8 p q w' , float= True)
v1=Matrix([x1,x2,x3,x4,x5,x6])
v2=v1.T
w=0
for i in np.arange(0,m):
for j in np.arange(0,n): w=w+v1[p.subs({p:i}),q.subs({q:0})]*v2[p.subs({p:0}),q.subs({q:j})]*CV[p.subs({p:i}),q.subs({q:j})]
print("Дисперсия доходности портфеля (функция риска):\n%s"%w)
```
**Получим:**
Дисперсия доходности портфеля (функция риска):
2.117\*x1\*\*2 + 3.546\*x1\*x2 + 4.512\*x1\*x3 + 4.694\*x1\*x4 + 4.154\*x1\*x5 + 3.95\*x1\*x6 + 1.903\*x2\*\*2 + 3.882\*x2\*x3 + 4.098\*x2\*x4 + 3.776\*x2\*x5 + 3.202\*x2\*x6 + 2.901\*x3\*\*2 + 5.574\*x3\*x4 + 5.402\*x3\*x5 + 5.522\*x3\*x6 + 3.935\*x4\*\*2 + 4.928\*x4\*x5 + 4.63\*x4\*x6 + 2.723\*x5\*\*2 + 4.728\*x5\*x6 + 3.067\*x6\*\*2
4. Определение оптимального портфеля акций для минимального риска и доходности mp=13.25
```
def objective(x):#функция риска
x1=x[0];x2=x[1];x3=x[2]; x4=x[3]; x5=x[4]; x6=x[5]
return 2.117*x1**2 + 3.546*x1*x2 + 4.512*x1*x3 + 4.694*x1*x4 + 4.154*x1*x5 + 3.95*x1*x6\
+ 1.903*x2**2 + 3.882*x2*x3 + 4.098*x2*x4 + 3.776*x2*x5 + 3.202*x2*x6 + 2.901*x3**2 \
+ 5.574*x3*x4 + 5.402*x3*x5 + 5.522*x3*x6 + 3.935*x4**2 + 4.928*x4*x5 + 4.63*x4*x6 \
+ 2.723*x5**2 + 4.728*x5*x6 + 3.067*x6**2
def constraint1(x):#условие для суммы долей -1
return x[0]+x[1]+x[2]+x[3]+x[4]+x[5]-1.0
def constraint2(x): # задание доходности
return d[0,0]*x[0] + d[1,0]*x[1] + d[2,0]*x[2] + d[3,0]*x[3] + d[4,0]*x[4]+ d[5,0]*x[5] - 13.25
x0=[1,1,0,0,0,1]#начальное значение переменных для поиска минимума функции риска
b=(0.0,1.0)# условие для x от нуля до единицы включая пределы
bnds=(b,b,b,b,b,b)#передача условий в функцию риска(подготовка)
con1={'type':'ineq','fun':constraint1} #передача условий в функцию риска(подготовка)
con2={'type':'eq','fun':constraint2} #передача условий в функцию риска(подготовка)
cons=[con1,con2]#передача условий в функцию риска(подготовка)
sol=minimize(objective,x0,method='SLSQP',\
bounds=bnds,constraints=cons)# поиск минимума функции риска
print("Минимум функции риска -%s"%str(round(sol.fun,3)))
print("Акция 1 доля- %s, доходность- %s"%(round(sol.x[0],3),round(d[0,0]*sol.x[0],3)))
print("Акция 2 доля- %s, доходность- %s"%(round(sol.x[1],3),round(d[1,0]*sol.x[1],3)))
print("Акция 3 доля- %s, доходность- %s"%(round(sol.x[2],3),round(d[2,0]*sol.x[2],3)))
print("Акция 4 доля- %s, доходность- %s"%(round(sol.x[3],3),round(d[3,0]*sol.x[3],3)))
print("Акция 5 доля- %s, доходность- %s"%(round(sol.x[4],3),round(d[4,0]*sol.x[4],3)))
print("Акция 6 доля- %s, доходность- %s"%(round(sol.x[5],3),round(d[5,0]*sol.x[5],3)))
```
**Получим:**
Минимум функции риска -1.846
Акция 1 доля- 0.141, доходность- 1.721
Акция 2 доля- 0.73, доходность- 9.616
Акция 3 доля- 0.0, доходность- 0.0
Акция 4 доля- 0.0, доходность- 0.0
Акция 5 доля- 0.0, доходность- 0.0
Акция 6 доля- 0.129, доходность- 1.914
**Вывод:**
Доходными являются 1,2,6 акции. Это и есть часть ответа на вопросы, поставленные в начале публикации.
**Полный листинг программы для минимизации риска по методу Марковица при заданной доходности**
```
from sympy import *
import numpy as np
from scipy.optimize import minimize
"D- матрица доходности(обычно загружается из файла)"
D=np.array([[9.889, 11.603,11.612, 12.721,11.453,12.102],
[12.517, 13.25,12.947,12.596,12.853,13.036],
[12.786, 12.822,15.447,14.452,15.143,16.247],
[11.863, 12.114,13.359,13.437,11.913,15.300],
[11.444, 13.292,13.703,11.504,13.406,15.255],
[14.696, 15.946,16.829,17.698,16.051,17.140]],np.float64)
d= np.zeros([6,1])# столбец для средней доходности
m,n= D.shape#размерность матрицы
for j in np.arange(0,n):
for i in np.arange(0,m):
d[j,0]=d[j,0]+D[i,j]
d=d/n
print("Средняя доходность по столбцам : \n %s"%d)
CV= np.zeros([m,n])
for i in np.arange(0,m):
for j in np.arange(0,n):
x=np.array(D[0:m,j]).T
y=np.array(D[0:m,i]).T
X = np.vstack((x,y))
CV[i,j]=round(np.cov(x,y,ddof=0)[1,0],3)
print("Ковариационная матрица CV: \n %s"%CV)
x1,x2,x3,x4,x5,x6,x7,x8,p,q,w=symbols(' x1 x2 x3 x4 x5 x6 x7 x8 p q w' , float= True)
v1=Matrix([x1,x2,x3,x4,x5,x6])
v2=v1.T
w=0
for i in np.arange(0,m):
for j in np.arange(0,n):
w=w+v1[p.subs({p:i}),q.subs({q:0})]*v2[p.subs({p:0}),q.subs({q:j})]*CV[p.subs({p:i}),q.subs({q:j})]
print("Дисперсия доходности портфеля (функция риска):\n%s"%w)
def objective(x):#функция риска
x1=x[0];x2=x[1];x3=x[2]; x4=x[3]; x5=x[4]; x6=x[5]
return 2.117*x1**2 + 3.546*x1*x2 + 4.512*x1*x3 + 4.694*x1*x4 + 4.154*x1*x5 + 3.95*x1*x6\
+ 1.903*x2**2 + 3.882*x2*x3 + 4.098*x2*x4 + 3.776*x2*x5 + 3.202*x2*x6 + 2.901*x3**2 \
+ 5.574*x3*x4 + 5.402*x3*x5 + 5.522*x3*x6 + 3.935*x4**2 + 4.928*x4*x5 + 4.63*x4*x6 \
+ 2.723*x5**2 + 4.728*x5*x6 + 3.067*x6**2
def constraint1(x):#условие для суммы долей -1
return x[0]+x[1]+x[2]+x[3]+x[4]+x[5]-1.0
def constraint2(x): # задание доходности
return d[0,0]*x[0] + d[1,0]*x[1] + d[2,0]*x[2] + d[3,0]*x[3] + d[4,0]*x[4]+ d[5,0]*x[5] - 13.25
x0=[1,1,0,0,0,1]#начальное значение переменных для поиска минимума функции риска
b=(0.0,1.0)# условие для x от нуля до единицы включая пределы
bnds=(b,b,b,b,b,b)#передача условий в функцию риска(подготовка)
con1={'type':'ineq','fun’: constraint1} #передача условий в функцию риска(подготовка)
con2={'type':'eq','fun’: constraint2} #передача условий в функцию риска(подготовка)
cons=[con1,con2]#передача условий в функцию риска(подготовка)
sol=minimize(objective,x0,method='SLSQP',\
bounds=bnds,constraints=cons)# поиск минимума функции риска
print("Минимум функции риска -%s"%str(round(sol.fun,3)))
print("Акция 1 доля- %s, доходность- %s"%(round(sol.x[0],3),round(d[0,0]*sol.x[0],3)))
print("Акция 2 доля- %s, доходность- %s"%(round(sol.x[1],3),round(d[1,0]*sol.x[1],3)))
print("Акция 3 доля- %s, доходность- %s"%(round(sol.x[2],3),round(d[2,0]*sol.x[2],3)))
print("Акция 4 доля- %s, доходность- %s"%(round(sol.x[3],3),round(d[3,0]*sol.x[3],3)))
print("Акция 5 доля- %s, доходность- %s"%(round(sol.x[4],3),round(d[4,0]*sol.x[4],3)))
print("Акция 6 доля- %s, доходность- %s"%(round(sol.x[5],3),round(d[5,0]*sol.x[5],3)))
```
### Оптимальный портфель Марковица максимальной доходности и заданного, (приемлемого) риска
Система уравнений и неравенств имеет вид:
**Оптимизация портфеля максимальной доходности при заданном риске на Python**
```
import numpy as np
from scipy.optimize import minimize
d=np.array( [[ 12.19916667],
[ 13.17116667],
[ 13.98283333],
[ 13.73466667],
[ 13.46983333],
[ 14.84666667]])
def constraint2(x):
x1=x[0];x2=x[1];x3=x[2]; x4=x[3]; x5=x[4]; x6=x[5]
return 2.117*x1**2 + 3.546*x1*x2 + 4.512*x1*x3 + 4.694*x1*x4 + 4.154*x1*x5 \
+ 3.95*x1*x6 + 1.903*x2**2 + 3.882*x2*x3 + 4.098*x2*x4 + 3.776*x2*x5 + 3.202*x2*x6 \
+ 2.901*x3**2 + 5.574*x3*x4 + 5.402*x3*x5 + 5.522*x3*x6 + 3.935*x4**2 + 4.928*x4*x5 \
+ 4.63*x4*x6 + 2.723*x5**2 + 4.728*x5*x6 + 3.067*x6**2-2
def constraint1(x):
return x[0]+x[1]+x[2]+x[3]+x[4]+x[5]-1.0
def objective(x):
return -(12.199*x[0] + 13.171*x[1] + 13.983*x[2] + 13.735*x[3] + 13.47*x[4]+ 14.847*x[5] )
x0=[1,1,1,1,1,1]
b=(0.0,1.0)
bnds=(b,b,b,b,b,b)
con1={'type':'ineq','fun':constraint1}
con2={'type':'eq','fun':constraint2}
cons=[con1,con2]
sol=minimize(objective,x0,method='SLSQP',\
bounds=bnds,constraints=cons)
print("Максимум функции доходности -%s"%str(round(sol.fun,3)))
print("Акция 1 доля- %s, доходность- %s"%(round(sol.x[0],3),round(d[0,0]*sol.x[0],3)))
print("Акция 2 доля- %s, доходность- %s"%(round(sol.x[1],3),round(d[1,0]*sol.x[1],3)))
print("Акция 3 доля- %s, доходность- %s"%(round(sol.x[2],3),round(d[2,0]*sol.x[2],3)))
print("Акция 4 доля- %s, доходность- %s"%(round(sol.x[3],3),round(d[3,0]*sol.x[3],3)))
print("Акция 5 доля- %s, доходность- %s"%(round(sol.x[4],3),round(d[4,0]*sol.x[4],3)))
print("Акция 6 доля- %s, доходность- %s"%(round(sol.x[5],3),round(d[5,0]*sol.x[5],3)))
```
Часть приведенного листинга не требует пояснений, поскольку всё подробно изложено в предыдущем примере. Однако есть отличия. Столбец средней доходности d и функция условия def constraint2(x) взяты из предыдущего примера, причем в предыдущем примере это была функция минимального риска. Кроме того, для определения максимума перед выводом значения новой функции цели – def objective(x), поставлен знак минус.
**Результат:**
Максимум функции доходности --14.1
Акция 1 доля- 0.0, доходность- 0.0
Акция 2 доля- 0.72, доходность- 9.489
Акция 3 доля- 0.0, доходность- 0.0
Акция 4 доля- 0.0, доходность- 0.0
Акция 5 доля- 0.0, доходность- 0.0
Акция 6 доля- 0.311, доходность- 4.611
Акции 2,6 доходны. Но это не единственный результат оптимизации средствами scipy optimize minimize. Я решил сравнить результаты с решением той же задачи средствами Mathcad и вот что получил:
Mathcad указывает на те же номера 2,6 доходных акций, но доли другие. В Python 0.720,0.311 в Mathcad 0.539, 0.461, при этом разные значения максимальной доходности соответственно 14.1 и 13.9. Для того чтобы окончательно убедиться какая программа вычисляет оптимум правильно, подставим полученные в Python значения долей в Mathcad, получим:
Вывод: на Python оптимум функции, а следовательно доли и доходность вычисляется более точно, чем при использовании Mathcad.
### Формирование оптимального портфеля ценных бумаг по модели Тобина
Портфель Тобина минимального риска:
где d0 – эффективность без рисковых бумаг;
x0 – доля капитала вложенная в без рисковые бумаги;
xi,xj — доля капитала вложенная в ценные бумаги i-го и j–го видов;
di – математическое ожидание (среднее арифметическое) доходности i — й ценной бумаги;
vij – корреляционный момент между эффективностью бумаг i-го и j –го видов.
Подбираем долю капитала заданной доходности, задаём общую доходность, приняв для примера следующие числовые значения x0=0.3, d0 =10, dp=12.7.
**Реализация портфеля Тобина минимального риска на Python**
```
import numpy as np
from scipy.optimize import minimize
d=np.array( [[ 12.19916667],
[ 13.17116667],
[ 13.98283333],
[ 13.73466667],
[ 13.46983333],
[ 14.84666667]])
x00=0.3;d0=10;dp=12.7
def objective(x):#функция риска
x1=x[0];x2=x[1];x3=x[2]; x4=x[3]; x5=x[4]; x6=x[5]
return 2.117*x1**2 + 3.546*x1*x2 + 4.512*x1*x3 + 4.694*x1*x4 + 4.154*x1*x5 + 3.95*x1*x6\
+ 1.903*x2**2 + 3.882*x2*x3 + 4.098*x2*x4 + 3.776*x2*x5 + 3.202*x2*x6 + 2.901*x3**2 \
+ 5.574*x3*x4 + 5.402*x3*x5 + 5.522*x3*x6 + 3.935*x4**2 + 4.928*x4*x5 + 4.63*x4*x6 \
+ 2.723*x5**2 + 4.728*x5*x6 + 3.067*x6**2
def constraint1(x):#условие для суммы долей -1
return x[0]+x[1]+x[2]+x[3]+x[4]+x[5]-1.0+x00
def constraint2(x): # задание доходности
return d[0,0]*x[0] + d[1,0]*x[1] + d[2,0]*x[2] + d[3,0]*x[3] + d[4,0]*x[4]+ d[5,0]*x[5] - dp+x00*d0
x0=[1,1,1,1,1,1]#начальное значение переменных для поиска минимума функции риска
b=(-1.0,100.0)# условие для x от нуля до единицы включая пределы
bnds=(b,b,b,b,b,b)#передача условий в функцию риска(подготовка)
con1={'type':'ineq','fun':constraint1} #передача условий в функцию риска(подготовка)
con2={'type':'eq','fun':constraint2} #передача условий в функцию риска(подготовка)
cons=[con1,con2]#передача условий в функцию риска(подготовка)
sol=minimize(objective,x0,method='SLSQP',\
bounds=bnds,constraints=cons)# поиск минимума функции риска
print("Минимум функции риска : %s"%str(round(sol.fun,3)))
print("Акция 1 доля- %s, доходность: %s"%(round(sol.x[0],3),round(d[0,0]*sol.x[0],3)))
print("Акция 2 доля- %s, доходность: %s"%(round(sol.x[1],3),round(d[1,0]*sol.x[1],3)))
print("Акция 3 доля- %s, доходность: %s"%(round(sol.x[2],3),round(d[2,0]*sol.x[2],3)))
print("Акция 4 доля- %s, доходность: %s"%(round(sol.x[3],3),round(d[3,0]*sol.x[3],3)))
print("Акция 5 доля- %s, доходность: %s"%(round(sol.x[4],3),round(d[4,0]*sol.x[4],3)))
print("Акция 6 доля- %s, доходность: %s"%(round(sol.x[5],3),round(d[5,0]*sol.x[5],3)))
```
Получим:
Минимум функции риска: 0.728
Акция 1 доля- -0.023, доходность: -0.286
Акция 2 доля- 0.666, доходность: 8.778
Акция 3 доля- -1.0, доходность: -13.983
Акция 4 доля- 0.079, доходность: 1.089
Акция 5 доля- 0.3, доходность: 4.048
Акция 6 доля- 0.677, доходность: 10.054
Доходными являются акции 2,4,5,6.
### Портфель Тобина максимальной эффективности
где rp – риск портфеля.
**Реализация портфеля Тобина максимальной эффективности на Python**
```
import numpy as np
from scipy.optimize import minimize
x00=0.8;d0=10;rp=0.07
d=np.array( [[ 12.19916667],
[ 13.17116667],
[ 13.98283333],
[ 13.73466667],
[ 13.46983333],
[ 14.84666667]])
def constraint2(x):
x1=x[0];x2=x[1];x3=x[2]; x4=x[3]; x5=x[4]; x6=x[5]
return 2.117*x1**2 + 3.546*x1*x2 + 4.512*x1*x3 + 4.694*x1*x4 + 4.154*x1*x5 \
+ 3.95*x1*x6 + 1.903*x2**2 + 3.882*x2*x3 + 4.098*x2*x4 + 3.776*x2*x5 + 3.202*x2*x6 \
+ 2.901*x3**2 + 5.574*x3*x4 + 5.402*x3*x5 + 5.522*x3*x6 + 3.935*x4**2 + 4.928*x4*x5 \
+ 4.63*x4*x6 + 2.723*x5**2 + 4.728*x5*x6 + 3.067*x6**2-rp
def constraint1(x):
return x[0]+x[1]+x[2]+x[3]+x[4]+x[5]-1.0+x0
def objective(x):
return -(d[0,0]*x[0] + d[1,0]*x[1] + d[2,0]*x[2] + d[3,0]*x[3] + d[4,0]*x[4]+ d[5,0]*x[5]+x00*d0)
x0=[1,1,1,1,1,1]
b=(-1.0,100.0)
bnds=(b,b,b,b,b,b)
con1={'type':'ineq','fun':constraint1}
con2={'type':'eq','fun':constraint2}
cons=[con1,con2]
sol=minimize(objective,x0,method='SLSQP',\
bounds=bnds,constraints=cons)
print("Максимум функции доходности : %s"%str(round(sol.fun,3)))
print("Акция 1 доля- %s, доходность: %s"%(round(sol.x[0],3),round(d[0,0]*sol.x[0],3)))
print("Акция 2 доля- %s, доходность: %s"%(round(sol.x[1],3),round(d[1,0]*sol.x[1],3)))
print("Акция 3 доля- %s, доходность: %s"%(round(sol.x[2],3),round(d[2,0]*sol.x[2],3)))
print("Акция 4 доля- %s, доходность: %s"%(round(sol.x[3],3),round(d[3,0]*sol.x[3],3)))
print("Акция 5 доля- %s, доходность: %s"%(round(sol.x[4],3),round(d[4,0]*sol.x[4],3)))
print("Акция 6 доля- %s, доходность- %s"%(round(sol.x[5],3),round(d[5,0]*sol.x[5],3)))
```
Получим:
Максимум функции доходности: -11.657
Акция 1 доля- 0.09, доходность: 1.096
Акция 2 доля- 0.196, доходность: 2.583
Акция 3 доля- -1.0, доходность: -13.983
Акция 4 доля- 0.113, доходность: 1.552
Акция 5 доля- 0.411, доходность: 5.538
Акция 6 доля- 0.463, доходность- 6.872
Доходными являются акции 1,2,4,5.
### Выводы:
Впервые средствами Python решена задача оптимизации портфеля ценных бумаг по моделям Марковица и Тобина.
На сравнительном примере c математическим пакетом Mathcad показаны преимущества библиотеки scipy optimize minimize.
**Ссылки:**
1. [Символьное решение задач нелинейного программирования](https://habrahabr.ru/post/340364/)
2. [scipy.optimize.minimize](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html)
3. [Постановка задачи об оптимальном портфеле](https://studopedia.ru/11_31924_postanovka-zadachi-ob-optimalnom-portfele.html) | https://habr.com/ru/post/341992/ | null | ru | null |
# От сортировки пузырьком к генетическим алгоритмам
Данная статья является кратким обзором того, что представляют собой генетические алгоритмы. Будучи новичком в биоинформатике, начну с вещей, близких и понятных людям технических специальностей: алгоритмов сортировки, затем перейду к описанию одной из задач генетического программирования и того, что под алгоритмами понимают биологи.
#### Сортировки
Думаю, что каждый программист подспудно считает, что знает на эту тему если не все, то почти все. Может быть, на данный момент так оно и есть, и читающий эти строки проштудировал третий том «Искусства программирования» Дональда Кнута. Но давайте проведем эксперимент: возьмите ваш любимый алгоритм и попытайтесь его реализовать карандашом на листе бумаги. Если любимого алгоритма нет, то предлагаю сортировку пузырьком. Получилось? Это задание мне неоднократно доводилось предлагать на собеседованиях, но рабочими из предложенных вариантов оказывались немногие, а «пузырьком» оказывались вообще единицы. Недавно мне довелось увидеть конспект лекций по по языку Python, где преподаватель под видом сортировки пузырьком приводит следующий код:
```
def bubble_sort(numbers):
for first in range(0, len(numbers)-1):
for second in range(first+1, len(numbers)):
if numbers[first] > numbers[second]:
numbers[first], numbers[second] = numbers[second], numbers[first]
```
Алгоритм рабочий, сортировать будет, но вот только это явно не «пузырек». С некоторой натяжкой его можно назвать сортировкой выборкой, но и тут допущена досадная оплошность: достоинством сортировки выборкой является минимизация количества замен, то есть количество раз, когда мы меняем местами элементы, должно быть ограничено O(n), чего не наблюдается в приведенном коде.
В беседе на тему алгоритмов бывает интересно перевернуть вопрос о быстрой сортировке. Как правило, люди с легкостью отвечают на вопрос о том, чем она хороша: это и хорошая алгоритмическая сложность в среднем, и отсутствие необходимости в дополнительной памяти (про стек, как правило, забывают). Но тогда интересно спросить, чем же она плоха, раз, кроме нее, существует еще множество других алгоритмов? На этот вопрос ответы гораздо более скудны и однообразны. А какие минусы у Quick Sort сможете назвать вы?
К моему удовольствию, иногда удается встретить эстетов, демонстрирующих знания экзотических методов, например, gnome sort.
Вывод:
1. Если хочешь на собеседовании прослыть эстетом, изучи пару малоизвестных методов сортировки;
2. Если ты сам принимаешь собеседования, умей отличать друг от друга различные методы, а то мало ли попадется кандидат, следующий пункту 1…
#### Блинная сортировка
Следуя советам выше, рассмотрим задачу, которая не имеет практического смысла, зато интересна с теоретической точки зрения: блинную сортировку. Непрактичность ее состоит в том, что в данном алгоритме вообще не учитывается количество сравнений элементов (считается, что эти операции очень дешевы и быстры), а единственной операцией, имеющей цену, является переворот верхушки стопки сортируемых «блинов». Разумеется, изначально они расположены в произвольном порядке, а желаемым результатом является некое подобие ханойской башни, когда блины большего диаметра лежат снизу, а меньшего располагаются сверху.
По поводу этой задачи хочется отметить два интересных факта. Во-первых, способ нахождения достаточно эффективного (хотя и неоптимального) решения был в свое время предложен небезызвестным Биллом Гейтсом, пока тот был еще студентом. Этот алгоритм, предложенный в 1979 году, оставался наиболее эффективным вплоть до 2008, когда результат был превзойден. Во-вторых, как было доказано впоследствии, задача нахождения оптимального решения относится к классу NP-полных. Также Гейтсом и его руководителем Христосом Пападимитриу был предложен усложненный вариант задачи, известный как задача о подгоревших блинах.
#### Задача о подгоревших блинах
В этой форме задачи каждый элемент, помимо размера, имеет еще и бинарный атрибут «направление», то есть у каждого «блина» одна сторона подгоревшая, а другая румяная; результатом решения задачи является стопка, упорядоченная по размеру, но, помимо этого, все «блины» лежат подгоревшей стороной вниз. Не вдаваясь в подробности, скажем, что и эта задача NP-полна, и что в общем случае известны ее достаточно эффективные, но неоптимальные решения. Тем не менее, существуют ограничения на данные, при выполнении которых задача становится полиномиальной. Для рассматриваемой задачи такими данными являются *простые перестановки*. Чтобы понять, что это такое, рассмотрим перестановку чисел от 1 до 7: 2**6475**13. Заметим, что выделенная жирным шрифтом последовательность сама является перестановкой чисел от 4 до 7 (называется *блоком*). Простые перестановки — это те, где нет нетривиальных блоков (блоков длины 1 и n).
За образной постановкой задачи, когда элементы представлены подгоревшими блинами, сложно разглядеть тот факт, что она имеет биологическое значение. Тем не менее, распространенной мутацией является переворот в молекуле ДНК, и если посчитать минимальное количество переворотов, необходимое для преобразования одной молекулы в другую (без рассмотрения более мелких точечных мутаций), то можно примерно оценить родство организмов. Например, геном человека и мыши разделен всего лишь порядка 120 глобальными мутациями; признаюсь, я раньше полагал, что между этими видами разницы гораздо больше…
#### Генетический алгоритм решения задачи о подгоревших блинах
В сравнительной геномике алгоритм используется для аналитического нахождения количества мутаций, разделяющих организмы, но посмотрим на задачу в другой проекции. Теперь уже решение аналитической задачи объявим целью, а живые организмы и процессы, в них протекающие, сделаем инструментом для ее решения.
Как известно, бактерии в состоянии делиться обеспечивая экспоненциальный рост популяции, если им предоставлены необходимые условия; разумеется, через некоторое время колонии бактерий уже не будет хватать питательной среды, также появятся другие факторы, влияющие на рост колонии, но на это необходимо время. Экспериментальным путем мы можем выяснить среднее время, которое требуется бактериям данного вида на появление глобальной мутации, связанной с переворотом части ДНК.
Теперь поставим бактериям задачу. Генетически модифицируем одну из них (биологи любят в подобных экспериментах использовать кишечную палочку), где ген устойчивости к антибиотику разобьем на несколько частей и перемешаем между собой, меняя при этом не только порядок, но и направление некоторых кусков. Таким образом, каждый перевернутый и переставленный кусок гена в нашем случае будет представлять собой «подгоревший блин».
Задача бактерии поставлена, можно начинать эксперимент. Помещаем ее в питательную среду и ждем отведенное время, за которое ожидается появление одной мутации-переворота ДНК. Обращаю внимание на то, что мы считаем одной мутацией: она единственна не на всю колонию (как раз в колонии этих мутаций будет много); это всего лишь ожидаемое количество переворотов у каждой из ныне живущих бактерий по сравнению с их прародителем.
Достаточно ли одного переворота блина для решения задачи? Мы легко это можем проверить, поместив часть колонии в опасную для нее среду. Помещенные в антибиотик бактерии не выжили, и мы продолжаем наблюдать за оставшимися. Пройдет еще два-три периода, и, наконец, в группе бактерий, помещенных в антибиотик, останутся живые. «Коллективный разум» справился с задачей!
#### Итоги
Конечно, полезность решенной задачи нас вряд ли впечатлит: в реальных проведенных экспериментах количество сортируемых «блинов» не превышает четырех, а количество мутаций, происходящее за отведенное время, может быть оценено лишь вероятностно. И все же лично меня поразила фантазия тех биологов, которые смогли поставить эксперимент; не меньшей фантазией обладали и те, кто смог биологическим методом решить задачу коммивояжера (подробности этого эксперимента я оставлю за рамками данной статьи). Во многом сложность задач, решаемых генетическими алгоритмами, сравнима с квантовыми вычислениями, и хочется верить, что оба направления неклассических вычислений смогут дать результаты пока не достижимые в современных условиях. | https://habr.com/ru/post/212893/ | null | ru | null |
# Удаляем старые ненужные DHCP-резервации IP-адресов
Иногда в крупных организациях нужно провести ревизию свободных IP-адресов. Пользователи приезжают на место/уезжают/увольняются, IP адреса остаются зарезервированны хотя за ними уже никого нет. Поиском таких «мертвых душ» и займемся.
Рассмотрим пример, как получаются отчеты из логов MS DHCP.
Технология формирования отчетов по использованию адресного пространства состоит из двух частей:
1) отделение событий DHCP renew и
2) SQL-обработка.
В папке \\dhcp\_server\c$\Windows\System32\dhcp лежат логи DHCP-сервера. Их копии нужно собрать в одну папку на локальном или сетевом диске. Например, в c:\tmp
Из этих файлов можно вытащить все события обновления dhcp lease renew:
`cmd
C:
cd c:\tmp\`
1) На первой стадии выделяем значимые строки. Перечислите через запятую все имена файлов \*.log, которые нужно обработать. Можно собрать файлы за несколько недель, переименовав их как-нибудь.
`c:\tmp>for /f "tokens=1,2,3,4,5,6,7,8 delims=," %a in (DhcpSrvLog-Mon.log,DhcpSrvLog-Tue.log,DhcpSrvLog-Wed.log,DhcpSrvLog-Thu.log,DhcpSrvLog-Fri.log,DhcpSrvLog-Sat.log,DhcpSrvLog-Sun.log) do if [%e] NEQ [] echo %b,%c,%d,%e,%f,%g >> text.csv`
2) Добавить в первую строчку файла text2.csv заголовок «Date,Time,Description,IP,Hostname,MAC», остальные строки заполнить событиями renew:
`c:\tmp>echo Date,Time,Description,IP,Hostname,MAC >> text2.csv`
`c:\tmp>for /f "tokens=1,2,3,4,5,6 delims=," %a in (text.csv) do if "%c" EQU "Renew" echo %a,%b,%c,%d,%e,%f >> text2.csv`
Можно хранить text2.csv за каждую неделю и собирать в один файл конкатенацией. Если, допустим, нужно проверить что адрес не использовался целый месяц, полгода и т.д, то нужно хранить файлы text2.csv за этот период и склеивать перед следующей операцией.
3) формирование отчета:
`c:\tmp >"c:\Program Files (x86)\Log Parser 2.2\LogParser.exe" -i:csv -o:TPL -tpl:dhcp2.tpl "SELECT IP, hostname, mac, max(to_timestamp(add(add(Date, ' '),time), 'MM/dd/yy HH:mm:ss')) as timestamp, EXTRACT_TOKEN(ip, 0, '.') as octet1, EXTRACT_TOKEN(ip, 1, '.') as octet2, EXTRACT_TOKEN(ip, 2, '.') as octet3, EXTRACT_TOKEN(ip, 3, '.') as octet4, add(strrepeat('0',sub(3, to_int(strlen(octet4)))),octet4) as octet4lz, add(strrepeat('0',sub(3, to_int(strlen(octet3)))),octet3) as octet3lz INTO text2.html FROM text2.csv group by IP,mac,hostname order by octet1,octet2,octet3lz,octet4lz"`
Получится файл text2.html, в котором можно увидеть «живые» компьютеры, получающие адреса через DHCP.
Если заменить "-o:TPL -tpl:dhcp2.tpl " на "-o:CSV", «text2.html» на «b8.csv», то выходной файл можно импортировать в excel.
`"c:\Program Files (x86)\Log Parser 2.2\LogParser.exe" -i:csv -o:CSV "SELECT IP, hostname, mac, max(to_timestamp(add(add(Date, ' '),time), 'MM/dd/yy HH:mm:ss')) as timestamp, EXTRACT_TOKEN(ip, 0, '.') as octet1, EXTRACT_TOKEN(ip, 1, '.') as octet2, EXTRACT_TOKEN(ip, 2, '.') as octet3, EXTRACT_TOKEN(ip, 3, '.') as octet4, add(strrepeat('0',sub(3, to_int(strlen(octet4)))),octet4) as octet4lz, add(strrepeat('0',sub(3, to_int(strlen(octet3)))),octet3) as octet3lz INTO b8.csv FROM text2.csv group by IP,mac,hostname order by octet1,octet2,octet3lz,octet4lz"`
LogParser качать тут:
[www.microsoft.com/en-us/download/details.aspx?id=24659](http://www.microsoft.com/en-us/download/details.aspx?id=24659) | https://habr.com/ru/post/161583/ | null | ru | null |
# 5 современных альтернатив старым инструментам командной строки Linux
Используя более современные альтернативы наряду со старыми инструментами командной строки, можно получить больше удовольствия и даже повысить производительность труда.
В повседневной работе в Linux / Unix мы используем множество инструментов командной строки — например, du для мониторинга использования диска и системных ресурсов. Некоторые из этих инструментов существуют уже давно. Например, top появился в 1984 году, а первый релиз du датируется 1971 годом.
За прошедшие годы эти инструменты были модернизированы и портированы на разные системы, но в целом далеко не ушли от своих первых версий, их внешний вид и usability также сильно не изменились.
Это отличные инструменты, которые необходимы многим системным администраторам. Однако сообщество разработало альтернативные инструменты, которые предлагают дополнительные преимущества. Некоторые из них просто имеют современный красивый интерфейс, а другие значительно улучшают удобство использования. В этом переводе расскажем о пяти альтернативах стандартным инструментам командной строки Linux.
1. ncdu vs du
-------------
NCurses Disk Usage ([ncdu](https://dev.yorhel.nl/ncdu)) похож на du, но с интерактивным интерфейсом на основе библиотеки curses. ncdu отображает структуру каталогов, которые занимают большую часть вашего дискового пространства.
ncdu анализирует диск, а затем отображает результаты, отсортированные по наиболее часто используемым каталогам или файлам, например:
```
ncdu 1.14.2 ~ Use the arrow keys to navigate, press ? for help
--- /home/rgerardi ------------------------------------------------------------
96.7 GiB [##########] /libvirt
33.9 GiB [### ] /.crc
7.0 GiB [ ] /Projects
. 4.7 GiB [ ] /Downloads
. 3.9 GiB [ ] /.local
2.5 GiB [ ] /.minishift
2.4 GiB [ ] /.vagrant.d
. 1.9 GiB [ ] /.config
. 1.8 GiB [ ] /.cache
1.7 GiB [ ] /Videos
1.1 GiB [ ] /go
692.6 MiB [ ] /Documents
. 591.5 MiB [ ] /tmp
139.2 MiB [ ] /.var
104.4 MiB [ ] /.oh-my-zsh
82.0 MiB [ ] /scripts
55.8 MiB [ ] /.mozilla
54.6 MiB [ ] /.kube
41.8 MiB [ ] /.vim
31.5 MiB [ ] /.ansible
31.3 MiB [ ] /.gem
26.5 MiB [ ] /.VIM_UNDO_FILES
15.3 MiB [ ] /Personal
2.6 MiB [ ] .ansible_module_generated
1.4 MiB [ ] /backgrounds
944.0 KiB [ ] /Pictures
644.0 KiB [ ] .zsh_history
536.0 KiB [ ] /.ansible_async
Total disk usage: 159.4 GiB Apparent size: 280.8 GiB Items: 561540
```
По записям можно перемещаться с помощью клавиш со стрелками. Если вы нажмёте Enter, ncdu отобразит содержимое выбранного каталога:
```
--- /home/rgerardi/libvirt ----------------------------------------------------
/..
91.3 GiB [##########] /images
5.3 GiB [ ] /media
```
Вы можете использовать этот инструмент, чтобы, например, определить, какие файлы занимают больше всего дискового пространства. В предыдущий каталог можно перейти, нажав клавишу со стрелкой влево. С помощью ncdu вы можете удалить файлы, нажав клавишу d. Перед удалением он запрашивает подтверждение. Если вы хотите отключить функцию удаления, чтобы предотвратить случайную потерю ценных файлов, используйте опцию -r для включения режима доступа только для чтения: ncdu -r.
ncdu доступен для многих платформ и дистрибутивов Linux. Например, вы можете использовать dnf для его установки на Fedora непосредственно из официальных репозиториев:
```
$ sudo dnf install ncdu
```
2. htop vs top
--------------
[Htop](https://hisham.hm/htop/) — это интерактивная утилита для просмотра процессов, похожая на top, но из коробки обеспечивающая приятное взаимодействие с пользователем. По умолчанию htop отображает ту же информацию, что и top, но в более наглядном и красочном виде.
По умолчанию htop выглядит так:
В отличие от top:
Кроме того, в верхней части htop отображает обзорную информацию о системе, а нижней части — панель для запуска команд с помощью функциональных клавиш. Вы можете настроить её, нажав F2, чтобы открыть экран настройки. В настройках можно изменить цвета, добавить или удалить метрики или изменить параметры отображения панели обзора.
Хотя, покрутив настройки последних версий top, тоже можно добиться похожего usability, htop предоставляет удобные конфигурации по умолчанию, что делает его более практичным и простым в использовании.
3. tldr vs man
--------------
Инструмент командной строки tldr отображает упрощённую справочную информацию о командах, в основном примеры. Его разработало сообщество [tldr pages project](https://tldr.sh/).
Стоит отметить, что tldr — это не замена man. Он по-прежнему является каноническим и наиболее полным инструментом вывода справочных страниц. Однако в некоторых случаях man является избыточным. Когда вам не нужна исчерпывающая информация о какой-либо команде, вы просто пытаетесь запомнить основные варианты её использования. Например, страница man для команды curl содержит почти 3000 строк. Страница tldr для curl имеет длину 40 строк. Её фрагмент выглядит так:
```
$ tldr curl
# curl
Transfers data from or to a server.
Supports most protocols, including HTTP, FTP, and POP3.
More information: .
- Download the contents of an URL to a file:
curl http://example.com -o filename
- Download a file, saving the output under the filename indicated by the URL:
curl -O http://example.com/filename
- Download a file, following [L]ocation redirects, and automatically [C]ontinuing (resuming) a previous file transfer:
curl -O -L -C - http://example.com/filename
- Send form-encoded data (POST request of type `application/x-www-form-urlencoded`):
curl -d 'name=bob' http://example.com/form
- Send a request with an extra header, using a custom HTTP method:
curl -H 'X-My-Header: 123' -X PUT http://example.com
- Send data in JSON format, specifying the appropriate content-type header:
curl -d '{"name":"bob"}' -H 'Content-Type: application/json' http://example.com/users/1234
... TRUNCATED OUTPUT
```
TLDR означает «слишком длинно; не читал»: то есть, некоторый текст был проигнорирован из-за его чрезмерной многословности. Название подходит для этого инструмента, потому что man-страницы, хотя и полезны, но иногда бывают слишком длинными.
Для Fedora tldr был написан на Python. Вы можете установить его с помощью менеджера dnf. Обычно для работы инструмента необходим доступ к интернету. Но клиент Python в Fedora позволяет загружать и кэшировать эти страницы для автономного доступа.
4. jq vs sed/grep
-----------------
jq — это JSON-процессор для командной строки. Он похож на sed или grep, но специально разработан для работы с данными в формате JSON. Если вы разработчик или системный администратор, который использует JSON в повседневных задачах, этот инструмент для вас.
Основное преимущество jq перед стандартными инструментами обработки текста, такими как grep и sed, заключается в том, что он понимает структуру данных JSON, позволяя создавать сложные запросы в одном выражении.
Например, вы пытаетесь найти названия контейнеров в этом файле JSON:
```
{
"apiVersion": "v1",
"kind": "Pod",
"metadata": {
"labels": {
"app": "myapp"
},
"name": "myapp",
"namespace": "project1"
},
"spec": {
"containers": [
{
"command": [
"sleep",
"3000"
],
"image": "busybox",
"imagePullPolicy": "IfNotPresent",
"name": "busybox"
},
{
"name": "nginx",
"image": "nginx",
"resources": {},
"imagePullPolicy": "IfNotPresent"
}
],
"restartPolicy": "Never"
}
}
```
Запустите grep для поиска строки name:
```
$ grep name k8s-pod.json
"name": "myapp",
"namespace": "project1"
"name": "busybox"
"name": "nginx",
```
grep вернул все строки, содержащие слово name. Вы можете добавить ещё несколько параметров в grep, чтобы ограничить его, и с помощью некоторых манипуляций с регулярными выражениями найти имена контейнеров.
Чтобы получить этот же результат с помощью jq, достаточно написать:
```
$ jq '.spec.containers[].name' k8s-pod.json
"busybox"
"nginx"
```
Эта команда выдаст вам имена обоих контейнеров. Если вы ищете только имя второго контейнера, добавьте индекс элемента массива в выражение:
```
$ jq '.spec.containers[1].name' k8s-pod.json
"nginx"
```
Поскольку jq знает о структуре данных, он даёт те же результаты, даже если формат файла незначительно изменится. grep и sed в этом случае могут работать некорректно.
У jq много функций, но для их описания нужна ещё одна статья. Для получения дополнительной информации обратитесь к [странице проекта](https://stedolan.github.io/jq/) jq или к tldr.
5. fd vs find
-------------
[fd](https://github.com/sharkdp/fd/) — это упрощённая альтернатива утилите find. Fd не призван заменить её полностью: в нём по умолчанию установлены наиболее распространённые настройки, определяющие общий подход к работе с файлами.
Например, при поиске файлов в каталоге репозитория Git, fd автоматически исключает скрытые файлы и подкаталоги, включая каталог .git, а также игнорирует шаблоны из файла .gitignore. В целом, он ускоряет поиск, выдавая более релевантные результаты с первой попытки.
По умолчанию fd выполняет поиск без учёта регистра в текущем каталоге с цветным выводом. Тот же поиск с использованием команды find требует ввода дополнительных параметров в командной строке. Например, чтобы найти все файлы .md (или .MD) в текущем каталоге, нужно написать такую команду find:
```
$ find . -iname "*.md"
```
Для fd она выглядит так:
```
$ fd .md
```
Но в некоторых случаях и для fd требуются дополнительные параметры: например, если вы хотите включить скрытые файлы и каталоги, вы должны использовать опцию -H, хотя обычно при поиске это не требуется.
fd доступен для многих дистрибутивов Linux. В Fedora его можно установить так:
```
$ sudo dnf install fd-find
```
Необязательно от чего-то отказываться
-------------------------------------
Используете ли вы новые инструменты командной строки Linux? Или сидите исключительно на старых? Но скорее всего, у вас комбо, да? Пожалуйста, поделитесь вашим опытом в комментариях.
---
#### На правах рекламы
Многие наши клиенты уже оценили преимущества **эпичных серверов**!
Это [виртуальные серверы с процессорами AMD EPYC](https://vdsina.ru/cloud-servers?partner=habr28), частота ядра CPU до 3.4 GHz. Максимальная конфигурация позволит оторваться на полную — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe. Спешите заказать!
[](https://vdsina.ru/cloud-servers?partner=habr28) | https://habr.com/ru/post/508748/ | null | ru | null |
# Аналитика для Telegram-ботов, написанных на Python
На данный момент бум на создание телеграмм-ботов начал сходить, но тема их создания не теряет актуальности. Написано множество библиотек для облегчение взаимодействия с Telegram Bot API, но после создания бота я так и не нашёл скрипта(библиотеки) для получения статистики бота. Поэтому решил написать скрипт для всех ботов на Python. Статистику будем получать, логируя действия пользователей и обрабатывая логи в удобный вид.
Требования для среды
--------------------
Для использования скрипта нужно установить следующие библиотеки:
```
pip install datetime
pip install pandas
```
Как внедрить аналитику в своего бота?
-------------------------------------
Скачайте с [репозитория](https://github.com/AleksandSP/tg_analytic) py-скрипт под свою ОС и data.csv файл. Разместите их в папке, где лежит ваш бот.
После подключения используемых вами библиотек в файле с телом бота добавьте строчку:
```
import tg_analytic
```
После команд бота добавьте:
```
tg_analytic.statistics(, <команда>)
```
Если вы используете библиотеку telebot, то это должно выглядеть следующим образом:
Также, чтобы получать статистику прямо из бота, нужно добавить в message\_handler(content\_types=['text']):
```
if message.text[:(длина ключевого слова)] == '<ключевое слово>':
st = message.text.split(' ')
if 'txt' in st or 'тхт' in st:
tg_analytic.analysis(st,message.chat.id)
with open('%s.txt' %message.chat.id ,'r',encoding='UTF-8') as file:
bot.send_document(message.chat.id,file)
tg_analytic.remove(message.chat.id)
else:
messages = tg_analytic.analysis(st,message.chat.id)
bot.send_message(message.chat.id, messages)
```
Ключевое слово нужно придумать и вписать для того, чтобы только вы могли просматривать статистику вашего бота. В репозитории хранится также телеграм-бот с уже внедрённой аналитикой, чтобы вы могли ознакомиться как подключить её на примере.
Какие команды использовать для получение статистики?
----------------------------------------------------
К примеру ключевое слово будет «статистика»:
```
if message.text[:10] == 'статистика' or message.text[:10] == 'Cтатистика':
st = message.text.split(' ')
if 'txt' in st or 'тхт' in st:
tg_analytic.analysis(st,message.chat.id)
with open('%s.txt' %message.chat.id ,'r',encoding='UTF-8') as file:
bot.send_document(message.chat.id,file)
tg_analytic.remove(message.chat.id)
else:
messages = tg_analytic.analysis(st,message.chat.id)
bot.send_message(message.chat.id, messages)
```
Тело команды боту выглядит следующим образом:
> статистика <количество дней> <параметры запроса\*>>
\* — Есть команды: «пользователи», «команды» и «тхт». Можно использовать одновременно. «Пользователи» даёт статистику по людям за необходимое вам количество дней. «Команды» даёт статистику по командам за необходимое вам количество дней. При указание txt, вы получите файл, в ином случае ответ в телеграмм.
### Пример использования команд
*Cтатистика 2 пользователи команды*
*Cтатистика 2 команды*
*Статистика 2 пользователи команды тхт*
Из чего состоит скрипт?
-----------------------
В целом, если вас не интересует работа скрипта, то уже на этом этапе можете закончить чтение статьи и начать внедрение в своего бота.
Первая часть скрипта — это логирование действий пользователей. Я принял решение сохранять только дату, id пользователя и используемую им команду:
```
def statistics(user_id, command):
data = datetime.datetime.today().strftime("%Y-%m-%d")
with open('data.csv', 'a', newline="", encoding='UTF-8') as fil:
wr = csv.writer(fil, delimiter=';')
wr.writerow([data, user_id, command])
```
Вторая часть — это обработка данных по запросу и вывод необходимой статистики. Мы считываем данные из csv в Pandas группируем по пользователям и командам:
```
season = int(bid[1])
#Считывание данных в Dataframe
df = pd.read_csv('data.csv', delimiter=';', encoding='utf8')
#Получение количества всех пользователей и дней
number_of_users = len(df['id'].unique())
number_of_days = len(df['data'].unique())
#Узнаём о количестве пользователей в опредёленные дни
df_user = df.groupby(['data', 'id']).count().reset_index().groupby('data').count().reset_index()
list_of_dates_in_df_user = list(df_user['data'])
list_of_number_of_user_in_df_user = list(df_user['id'])
list_of_dates_in_df_user = list_of_dates_in_df_user[-season:]
list_of_number_of_user_in_df_user = list_of_number_of_user_in_df_user[-season:]
#Узнаем о количестве использованых команд по дням
df_command = df.groupby(['data', 'command']).count().reset_index()
unique_commands = df['command'].unique()
commands_in_each_day = []
list_of_dates_in_df_command = list(df_command['data'])
list_of_number_of_user_in_df_command = list(df_command['id'])
list_of_name_of_command_in_df_command = list(df_command['command'])
commands_in_this_day = dict()
for i in range(len(list_of_dates_in_df_command)):
commands_in_this_day[list_of_name_of_command_in_df_command[i]] = list_of_number_of_user_in_df_command[i]
if i + 1 >= len(list_of_dates_in_df_command) or list_of_dates_in_df_command[i] != list_of_dates_in_df_command[i + 1]:
commands_in_each_day.append(commands_in_this_day)
commands_in_this_day = dict()
commands_in_each_day = commands_in_each_day[-season:]
```
Ответ пользователю составляется на основе данных из предыдущего шага:
```
message_to_user = 'Статистика использования бота за %s %s: \n' % (season, day_type.get(season, 'дней'))
message_to_user += 'Всего статистика собрана за %s %s: \n' % (number_of_days, day_type.get(season, 'дней'))
if season > number_of_days:
season = number_of_days
message_to_user += 'Указанное вами количество дней больше,чем имеется\n' \
'Будет выведена статистика за максимальное возможное время\n'
if 'пользователи' in bid:
message_to_user += 'За всё время бота использовало: ' + '%s' % number_of_users \
+ ' %s ' % users_type.get(number_of_users, 'пользователей') + '\n' \
'Пользователей за последние %s %s: \n' % (season, day_type.get(season, 'дней'))
for days, number, comm_day in zip(list_of_dates_in_df_user, list_of_number_of_user_in_df_user,
commands_in_each_day):
message_to_user += 'Дата:%s Количество:%d Из них новых:%s\n' % (days, number, comm_day.get('/start', 0))
if 'команды' in bid:
message_to_user += 'Статистика команд за последние %s %s: \n' %
(season,day_type.get(season, 'дней'))
for days, commands in zip(list_of_dates_in_df_user, commands_in_each_day):
message_to_user += 'Дата:%s\n' % days
for i in unique_commands:
if i in commands:
message_to_user += '%s - %s раз\n' % (i, commands.get(i))
else:
message_to_user += '%s - 0 раз\n' % i
```
В конце, после составления ответного сообщения, мы проверяем запрос пользователя на наличее команды «тхт», чтобы решить в каком формате ответить:
```
if 'txt' in bid or 'тхт' in bid:
with open('%s.txt' % user_id, 'w', encoding='UTF-8') as fil:
fil.write(message_to_user)
fil.close()
else:
return message_to_user
```
Заключение
----------
Скрипт оттестирован и работает в нормальном режиме.
Ключевое слово: «статистика».
Приятного использования! | https://habr.com/ru/post/487208/ | null | ru | null |
# [ libGDX ] Пишем полноценную игру под Android. Часть 2
Здравствуйте! Не прошло и суток с момента публикации [первой части](http://habrahabr.ru/post/224175/) статьи, а я не могу спать, так как есть незаконченное дело и нужно дописать статью. Приступим.
Оговорюсь еще раз. Я шибкий не знаток Java и поэтому следующий далее код, может смутить многих, но игру я написал меньше, чем за неделю и работал скорее на результат, чем на красоту и порядочность кода. Надеюсь, в комментариях найдется тот, кто поможет сделать код и структуру проекта, если не совершенными, то хотя бы привести к хорошему виду и дать возможность мне и остальным стать более хорошими программистами. Ладно, хватит лирики, продолжим наш «хардкор».
Создадим новый *package* и назовем его **objects**. В нем создадим класс фона, а в него добавим следующий код:
*Файл BackgroundActor.java*
```
package ru.habrahabr.songs_of_the_space.objects;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.scenes.scene2d.Actor;
public class BackgroundActor extends Actor {
private Texture backgroundTexture;
private Sprite backgroundSprite;
public BackgroundActor() {
backgroundTexture = new Texture("images/sky.jpg");
backgroundSprite = new Sprite(backgroundTexture);
backgroundSprite.setSize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
}
@Override
public void draw(Batch batch, float alpha) {
backgroundSprite.draw(batch);
}
}
```
Ничего сложного. Это «актер», который устанавливается по размеру экрана пользователя и делает нашу игру более похожей на звездное небо. Примерно так это должно выглядеть:
**Главный экран игры**
Теперь добавим его в *MyGame.java* и сделаем его доступным извне, для того, чтобы не создавать его на каждом следующем экране. Это избавит нас от мерцания.
*Файл MyGame.java*
```
// Перед методом create()
public BackgroundActor background;
@Override
public void create() {
...
background = new BackgroundActor();
background.setPosition(0, 0);
...
}
```
Далее, мы должны в каждом новой экране добавлять его на сцену:
```
stage.addActor(game.background);
```
Теперь, также в пакете *objects* создадим класс ноты. Он будет хранить все наши ноты в нужной нам последовательности.
*Файл Note.java*
```
package ru.habrahabr.songs_of_the_space.objects;
public class Note {
private String note;
private float delay;
private Star star;
// Устанавливаем ноты. Ноты будем брать из xml файла уровня.
public void setNote(String note) {
this.note = note;
}
public String getNote() {
return this.note;
}
// Устанавливаем задержку для ноты, чтобы можно было создавать мелодии разной сложности
public void setDelay(String delay) {
this.delay = Float.parseFloat(delay);
}
public float getDelay() {
return this.delay;
}
// Наша красавица -- звезда
public void setStar(Star star) {
this.star = star;
}
public Star getStar() {
return this.star;
}
}
```
Теперь, когда мы создали ноту, нам нужно создать звезду, которая будет нашим основным актером в нашей космической сцене. Она будет мерцать и петь свою чудную мелодию для будущих пользователей.
Перед тем, как продолжить немного поясню, зачем нам нужен отдельный класс для ноты и для звезды. Мелодия может повторять свои ноты, а каждая звезда должна быть в единственном экземпляре. Когда я только продумывал идею игры, я как раз хранил каждую ноту внутри звезды. В итоге, либо мелодия была слишком простой, либо звезд на небе становилось слишком много и было сложно пройти уровень даже с восемью повторяющимися нотами.
Итак, создаем звезду.
Файл Star.java
```
package ru.habrahabr.songs_of_the_space.objects;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.Texture.TextureFilter;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Touchable;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
public class Star extends Actor {
// Звук, если пользователь ошибся
private Sound sound, wrong;
// Ноты в строковом представлении
private String note;
// Изображение звезды
private Sprite img;
private Texture img_texture;
// Наш уровень. Он будет говорить, где должна находиться звезда
private Level level;
public Star(String str_img, String str_sound) {
img_texture = new Texture("images/stars/" + str_img + ".png");
img_texture.setFilter(TextureFilter.Linear, TextureFilter.Linear);
img = new Sprite(img_texture);
// Это я сделал для того, чтобы размер звезды менялся в зависимости от экрана пользователя
img.setSize(Gdx.graphics.getHeight() * 15 / 100, Gdx.graphics.getHeight() * 15 / 100);
this.note = str_sound;
this.sound = Gdx.audio.newSound(Gdx.files.internal("sounds/bells/" + str_sound + ".mp3"));
this.wrong = Gdx.audio.newSound(Gdx.files.internal("sounds/bells/wrong.mp3"));
// Слушает события касания пользователя и играет соответствующую ноту, а также создает эффект мерцания за счет увеличения звезды в размерах
addListener(new ClickListener() {
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
img.setScale(1.2f);
if (note.equals(level.getCurrentNoteStr())) {
level.setCurrentNote();
Gdx.input.vibrate(25); // Дадим пользователю понять, что он нажал немного вибрируя в момент касания
getSound().play();
} else {
// Если юзер ошибся, то начинаем сначала. Проигрываем первые четыре ноты и играем их. А также сильнее вибрируем, чтобы оповестить его об ошибке.
level.setCurrentNote(0);
level.setEndNote(true);
level.setPlayMusic();
getWrongSound().play();
Gdx.input.vibrate(80);
}
return true;
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
img.setScale(1.0f); // Как только пользователь отпустил нашу звезду, делаем ее размер таким же, каким он был
}
});
setTouchable(Touchable.enabled); // Делаем нашу звезду активной для касания
}
public void setLevel(Level level) {
this.level = level;
}
// Устанавливаем позицию изображения равной позиции актера, и делаем размеры актера равными размеру звезды
@Override
public void setBounds(float x, float y, float width, float height) {
super.setBounds(x, y, this.img.getWidth(), this.img.getHeight());
this.img.setPosition(x, y);
}
// В каждый момент исполнения, немного крутим нашу звезду. Пусть потанцует.
@Override
public void act(float delta) {
img.rotate(0.05f);
}
// Рисуем звезду на сцене
@Override
public void draw(Batch batch, float alpha) {
this.img.draw(batch);
}
public Sound getSound() {
return this.sound;
}
public Sound getWrongSound() {
return this.wrong;
}
public String getNote() {
return this.note;
}
public Sprite getImg() {
return this.img;
}
}
```
Теперь создадим наш класс уровня. Он будет отвечать за создания всех актрис и актеров, а также играть мелодию и поздравлять в победой. Я добавил его в пакет *objects*, но он лучше подходит как менеджер, поэтому можете перенести его туда самостоятельно.
Файл Level.java
```
package ru.habrahabr.songs_of_the_space.objects;
import java.util.HashMap;
import java.util.Map;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.scenes.scene2d.Touchable;
import com.badlogic.gdx.utils.Array;
public class Level {
private XMLparse xml_parse;
private Array notes = new Array();
private Array stars = new Array();
private Map> starsPos = new HashMap>();
private int currentNote;
private int endNote;
private float delay;
private boolean playMusic;
private boolean win;
private final Sound winner = Gdx.audio.newSound(Gdx.files.internal("sounds/win.mp3")); // Победный звук аплодисментов
public Level(String level) {
xml\_parse = new XMLparse();
Array xml\_stars = xml\_parse.XMLparseStars(); // парсим звезды из всего списка имеющихся
notes = xml\_parse.XMLparseNotes(level); // парсим ноты для уровня
starsPos = xml\_parse.getPos(level); // позиции звезд в текущем уровне
endNote = 3;
delay = 0;
this.win = false;
setPlayMusic();
for (Note n : this.notes) {
for (Star s : xml\_stars) {
if (n.getNote().equals(s.getNote()) && !this.stars.contains(s, true)) { // Поскольку в одном xml у нас хранятся все возможные варианты звезд, этот код отсеит лишние
this.stars.add(s);
}
if (n.getNote().equals(s.getNote())) n.setStar(s); // А здесь мы устанавливаем для каждой ноты свою звезду
}
}
for (Star s : this.stars) {
s.setLevel(this);
s.setBounds(
// Это нужно для того, чтобы позицию звезды можно было описать в процентом от размера экрана пользователя отношении (так как скопления наших звезд будут стараться походить на настоящие созвездия реального космоса)
Gdx.graphics.getWidth() \* Float.parseFloat(starsPos.get(s.getNote()).get(0)) / 100,
Gdx.graphics.getHeight() \* Float.parseFloat(starsPos.get(s.getNote()).get(1)) / 100 - s.getImg().getHeight() / 2,
s.getImg().getWidth(),
s.getImg().getHeight()
);
}
}
public boolean isWin() {
return this.win;
}
// Устанавливаем последнюю ноту
public void setEndNote() {
if (this.endNote < this.notes.size - 1) {
this.endNote += 4;
}
}
// Переопределяем метод для того, чтобы в случае, когда пользователь ошибся, сделать последней четвертую ноту.
// Можно было обойтись и одним методом, но мне так понравилось больше. Переопределяй! Властвуй!
public void setEndNote(boolean begin) {
if (begin) {
this.endNote = 3;
}
}
public void setCurrentNote(int note) {
this.currentNote = note;
}
// Устанавливаем текущую ноту
public void setCurrentNote() {
if (this.currentNote < this.notes.size - 1) {
this.currentNote++;
if (currentNote - 1 == endNote) {
currentNote = 0;
setEndNote(); // Увеличиваем значение на 4 для последней ноты
setPlayMusic(); // Играем мелодию с большим количеством нот
}
} else {
// Если пользователь отыграл все ноты, играем победные аплодисменты
this.endNote = notes.size - 1;
this.currentNote = 0;
this.win = true;
this.winner.play();
}
}
public int getCurrentNote() {
return this.currentNote;
}
public String getCurrentNoteStr() {
return this.notes.get(this.currentNote).getNote();
}
public Array getNotes() {
return this.notes;
}
public Array getStars() {
return this.stars;
}
public void setPlayMusic() {
if (playMusic) {
playMusic = false;
} else {
playMusic = true;
}
}
// Играем наши ноты для пользователя
public void playStars() {
if (playMusic) {
for (Star s : stars) {
s.setTouchable(Touchable.disabled); // Не даем пользователю трогать наши звезды, пока играет мелодия
}
if (getCurrentNote() < notes.size) {
if (getCurrentNote() <= endNote) {
Note note = notes.get(getCurrentNote());
delay += note.getDelay(); // delay позволяет создавать задержку по времени между проигрыванием нот
if (delay >= 0.9f) note.getStar().getImg().setScale(1.2f); // Увеличиваем активную в данный момент звезду для того, чтобы создать эффект мерцания
if (delay >= 1.0f) {
delay = 0;
setCurrentNote(currentNote + 1);
note.getStar().getSound().play();
note.getStar().getImg().setScale(1f);
}
} else {
setPlayMusic();
setCurrentNote(0);
}
} else {
delay = 0;
setCurrentNote(0);
setPlayMusic();
}
} else {
for (Star s : stars) {
s.setTouchable(Touchable.enabled); // Делаем все наши звезды активными для касания
}
}
}
}
```
Надеюсь, все понятно. Старался максимально комментировать код. Единственное, что может вызвать вопросы — это *delay*. Поясню немного. Метод **playStars()** будет вызываться в методе **render()** класса *PlayScreen.java*. Поскольку, он выполняется в потоке, каждый раз при совпадении всех условий, *delay* будет увеличиваться на заданное количество. Таким образом, будет имитироваться задержка в игре нот. Это лучше увидеть в коде. Давайте, наконец наполним наш класс PlayScreen.java. Поскольку, там много кода, я решил его спрятать под спойлер.
**Файл PlayScreen.java**
```
package ru.habrahabr.songs_of_the_space.managers;
import ru.habrahabr.songs_of_the_space.MyGame;
import ru.habrahabr.songs_of_the_space.objects.GamePreferences;
import ru.habrahabr.songs_of_the_space.objects.Level;
import ru.habrahabr.songs_of_the_space.objects.PlayStage;
import ru.habrahabr.songs_of_the_space.objects.PlayStage.OnHardKeyListener;
import ru.habrahabr.songs_of_the_space.objects.Star;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Touchable;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.ui.Skin;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
import com.badlogic.gdx.scenes.scene2d.ui.TextButton.TextButtonStyle;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.viewport.ScreenViewport;
public class PlayScreen implements Screen {
final MyGame game;
private GamePreferences pref;
private Level level;
private String sL, nL;
private Array stars;
private PlayStage stage;
private Table table, table2;
public PlayScreen(final MyGame gam, String strLevel, String strNextLevel) {
game = gam;
this.sL = strLevel;
this.nL = strNextLevel;
stage = new PlayStage(new ScreenViewport());
stage.addActor(game.background); // Добавляем фон
pref = new GamePreferences();
level = new Level(strLevel);
stars = level.getStars();
level.setCurrentNote(0);
for (final Star s : stars) {
stage.addActor(s); // Добавляем всех актрис (звезды) на сцену
}
LabelStyle labelStyle = new LabelStyle();
labelStyle.font = game.font;
// Skin для кнопок, которые показываются в случае победы пользователя
Skin skin = new Skin();
TextureAtlas buttonAtlas = new TextureAtlas(Gdx.files.internal("images/game/images.pack"));
skin.addRegions(buttonAtlas);
TextButtonStyle textButtonStyle = new TextButtonStyle();
textButtonStyle.font = game.font;
textButtonStyle.up = skin.getDrawable("button-up");
textButtonStyle.down = skin.getDrawable("button-down");
textButtonStyle.checked = skin.getDrawable("button-up");
// Для всех кнопок лучше создать таблицу, так как она хорошо справляется с варавниванием
table = new Table();
table.padTop(20);
table.center().top();
table.setFillParent(true);
// label для показа названия созвездия
Label label = new Label(game.langStr.get("Constellation"), labelStyle);
table.add(label);
table.row().padBottom(30);
label = new Label(game.langStr.get("level\_" + strLevel), labelStyle);
table.add(label);
table.setVisible(false);
stage.addActor(table);
table2 = new Table();
table2.center().bottom();
table2.setFillParent(true);
table2.row().colspan(2).padBottom(30);
label = new Label(game.langStr.get("YouWin"), labelStyle);
table2.add(label).bottom();
table2.row().padBottom(20);
TextButton button = new TextButton(game.langStr.get("Again"), textButtonStyle);
// Нужно не забыть заставить кнопки прослушивания событих клика (касания)
// Эта кнопка, после нажатия, запустит уровень сначала
button.addListener(new ClickListener() {
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
Gdx.input.vibrate(20);
return true;
};
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
game.setScreen(new PlayScreen(game, sL, nL));
dispose();
};
});
table2.add(button);
// А эта перенесет пользователя обратно на экран выбора уровня
button = new TextButton(game.langStr.get("Levels"), textButtonStyle);
button.addListener(new ClickListener() {
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
Gdx.input.vibrate(20);
return true;
};
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
game.setScreen(new LevelScreen(game));
dispose();
};
});
table2.add(button);
table2.setVisible(false);
stage.addActor(table2);
Gdx.input.setInputProcessor(stage);
Gdx.input.setCatchBackKey(true);
stage.setHardKeyListener(new OnHardKeyListener() {
@Override
public void onHardKey(int keyCode, int state) {
if (keyCode == Keys.BACK && state == 1){
game.setScreen(new LevelScreen(game));
}
}
});
}
@Override
public void render(float delta) {
// Очистка экрана в каждый момент выполнения потока
Gdx.gl.glClearColor(0, 0, 0, 1);
Gdx.gl.glClear(GL20.GL\_COLOR\_BUFFER\_BIT);
// Рисуем сцену и вызываем метод act() для дополнительных действий актеров, описанных в одноименном методе каждого (в нашем случае, это вращение звезд)
stage.act(delta);
stage.draw();
level.playStars();
// Если пользователь выиграл, то показываем ему все наши кнопки, label'ы и прочее
if (level.isWin()) {
table.setVisible(true);
table2.setVisible(true);
pref.setLevel(nL); // Это для настроек игры. Объяснения ниже.
for (Star s : stars) {
s.setTouchable(Touchable.disabled); // Делаем все звезды неактивными для касания после победы пользователя
}
}
}
@Override
public void resize(int width, int height) {}
@Override
public void show() {}
@Override
public void hide() {}
@Override
public void pause() {}
@Override
public void resume() {}
// На забываем уничтожить сцену и объект класса MyGame
@Override
public void dispose() {
stage.dispose();
game.dispose();
}
}
```
Наверное, код вызвал несколько вопросов, так как в нем можно заметить новый класс *GamePreferences.java*. Этот класс позволит нам хранить все настройки игры в удобном формате. Для Android приложения будет создан, так называемый [«SharedPreferences»](http://developer.android.com/reference/android/content/SharedPreferences.html). Подробнее [здесь](https://github.com/libgdx/libgdx/wiki/Preferences). В данном случае, в нем мы будем хранить пройденные пользователем уровни.
Ну что? Давайте теперь создадим и наполним его.
*Файл GamePreferences.java*
```
package ru.habrahabr.songs_of_the_space.objects;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Preferences;
public class GamePreferences {
private Preferences pref;
private static final String PREFS_NAME = "SONGS_OF_THE_SPACE";
private static final String PREF_LEVEL = "LEVEL_";
public GamePreferences() {
pref = Gdx.app.getPreferences(PREFS_NAME);
}
public boolean getLevel(String level) {
pref.putBoolean(PREF_LEVEL + 1, true);
pref.flush();
return pref.getBoolean(PREF_LEVEL + level, false);
}
public void setLevel(String level) {
pref.putBoolean(PREF_LEVEL + level, true);
pref.flush();
}
}
```
В нем нет ничего сложного. Не буду дублировать документацию, ссылку на нее я дал ниже. Теперь нам нужно немного обновить наш класс *XMLparse.java*. Так, мы еще не научили нашу парсить звезды и ноты. Сделаем это.
**Файл XMLparse.java**
```
package ru.habrahabr.songs_of_the_space.objects;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.badlogic.gdx.Application.ApplicationType;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.XmlReader;
import com.badlogic.gdx.utils.XmlReader.Element;
public class XMLparse {
private Array stars = new Array();
private Array notes = new Array();
private Map> starsPos = new HashMap>();
// В этом методе мы будем парсить наши переводы. А вы как думали? Мы делаем многоязычную игру!
public HashMap XMLparseLangs(String lang) {
HashMap langs = new HashMap();
try {
Element root = new XmlReader().parse(Gdx.files.internal("xml/langs.xml"));
Array xml\_langs = root.getChildrenByName("lang");
for (Element el : xml\_langs) {
if (el.getAttribute("key").equals(lang)) {
Array xml\_strings = el.getChildrenByName("string");
for (Element e : xml\_strings) {
langs.put(e.getAttribute("key"), e.getText());
}
} else if (el.getAttribute("key").equals("en")) {
Array xml\_strings = el.getChildrenByName("string");
for (Element e : xml\_strings) {
langs.put(e.getAttribute("key"), e.getText());
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return langs;
}
// В этом методе парсим звезды
public Array XMLparseStars() {
try {
Element root = new XmlReader().parse(Gdx.files.internal("xml/stars.xml"));
Array xml\_stars = root.getChildrenByName("star");
for (Element el : xml\_stars) {
Star star = new Star(
el.getAttribute("files"),
el.getAttribute("files")
);
stars.add(star);
}
} catch (IOException e) {
e.printStackTrace();
}
return this.stars;
}
// В этом парсим уровни
public Array XMLparseLevels() {
Array levels = new Array();
Array int\_levels = new Array();
FileHandle dirHandle;
if (Gdx.app.getType() == ApplicationType.Android) {
dirHandle = Gdx.files.internal("xml/levels");
} else {
// Это хак, так как libGDX почему-то не хотел видеть этот файл при тестировании Desktop приложения
dirHandle = Gdx.files.internal(System.getProperty("user.dir") + "/assets/xml/levels");
}
for (FileHandle entry : dirHandle.list()) {
levels.add(entry.name().split(".xml")[0]);
}
for (int i = 0; i < levels.size; i++) {
int\_levels.add(Integer.parseInt(levels.get(i)));
}
int\_levels.sort();
levels.clear();
for (int i = 0; i < int\_levels.size; i++) {
levels.add(String.valueOf(int\_levels.get(i)));
}
return levels;
}
// Парсим ноты
public Array XMLparseNotes(String strLevel) {
try {
Element root = new XmlReader().parse(Gdx.files.internal("xml/levels/" + strLevel + ".xml")).getChildByName("notes");
Array xml\_notes = root.getChildrenByName("note");
for (Element el : xml\_notes) {
Note note = new Note();
note.setNote(el.getText());
note.setDelay(el.getAttribute("delay"));
this.notes.add(note);
}
} catch (IOException e) {
e.printStackTrace();
}
return this.notes;
}
// Парсим позицию для звезд. Знаю знаю, можно было сделать это при парсинге уровня, но мне так легче потом читать этот код, если разбить его по задачам
public Map> getPos(String strLevel) {
try {
Element root = new XmlReader().parse(Gdx.files.internal("xml/levels/" + strLevel + ".xml")).getChildByName("positions");
Array xml\_pos = root.getChildrenByName("position");
for (Element el : xml\_pos) {
Array xy = new Array();
xy.add(el.getAttribute("x"));
xy.add(el.getAttribute("y"));
this.starsPos.put(el.getAttribute("note"), xy);
}
} catch (IOException e) {
e.printStackTrace();
}
return this.starsPos;
}
}
```
Осталось немного. Правда. Теперь, раз уж я заикнулся про многоязыковую поддержку, давайте создадим я немного поясню, как это будет. За основу берем локаль пользователя. Для нас она начинается с символом **ru**, для англичан с **en** и так далее. Я перевел приложение на два языка, поэтому языковой файл будет таким (и поэтому в коде метода *XMLparseLangs* немного странное условие):
**Файл langs.xml**
```
xml version="1.0"?
Play
Exit
Again
Levels
You win!
Constellation
Canes Venatici
Triangulum
Equuleus
Apus
Sagitta
Musca
Ursa Minor
Orion
Ursa Major
Eridanus
Lacerta
Играть
Выход
Повторить
Уровни
Вы победили!
Созвездие
Гончие псы
Треугольник
Малый Конь
Райская Птица
Стрела
Муха
Малая медведица
Орион
Большая медведица
Эридан
Ящерица
```
Как видно, мы берем аттрибут и по нему определяем, что отдавать пользователю. Теперь нужно сделать еще кое-что. Создать XML файлы звезд, нот, уровней. Сделаем это.
**Файл stars.xml**
```
xml version="1.0"?
```
Если бегло глянуть этот файл, то можно заметить, что немного слукавил, когда сказал, что для каждой ноты будет своя звезда. Я сделал разное представление звезд в разной тональности. Зачем? Для улучшения звучания, так как если взять более-менее интересное созвездие, то можно заметить, то оно состоит, как минимум из 8-9 звезд, а писать мелодию для 8-9 разных нот не очень-то хотелось, вот я и решил немного упростить себе жизнь, добавив еще одну октаву.
Теперь приведу файл(для примера) уровня.
**Файл 1.xml**
```
xml version="1.0"?
d5
a6
d6
f#6
e5
a6
c#6
e6
d6
f#6
a6
d5
```
Как видно, сначала мы определяем последовательность нот и их задержку, а затем определяем позицию каждой уникальной ноты в процентом отношении. Кажется это все. Если что-то забыл, жду комментариев. Также, жду критики и советов. Если кому-нибудь будет интересно в следующей статье я могу описать процесс подключения AdMob к нашей игре, рассказать как и откуда я брал звуки для игры, и также рассказать о том, как я выкладывал игру в Google Play. Спасибо за внимание!
[Файлы проекта и пример готовой игры.](https://github.com/isayakhov/Song-s-of-the-Space)
**UPDATE.** Я решли не писать новый пост, так как материала на целый пост не набралось, поэтому оставлю здесь некоторые исправления.
**Ошибки и исправления**Для начала, хабраюзер [zig1375](https://habrahabr.ru/users/zig1375/) написал, что было бы неплохо использовать AssetManager. Это действительно справедливое замечание, так как после выбора уровня, игра как бы подвисает на время и в итоге не совсем ясно, то ли она зависла, то ли загружается. Я решил эту проблему следующим образом. Сначала в классе *MyGame.java* создаем объект типа **AssetManager** и делаем его публичным. Затем, создаем новый экран, я назвал его LoaderScreen.java и пишем в него что-то вроде этого:
**Файл LoaderScreen.java**
```
package ru.habrahabr.songs_of_the_space.managers;
import ru.habrahabr.songs_of_the_space.MyGame;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.utils.viewport.ScreenViewport;
public class LoaderScreen implements Screen {
private MyGame game;
private Stage stage;
private Table table;
private LabelStyle labelStyle;
private Label label;
public LoaderScreen(MyGame gam) {
game = gam;
// Загружаем все наши файлы
game.manager.load("some/sounds", Sound.class);
game.manager.load("some/textureatlas.pack", TextureAtlas.class);
stage = new Stage(new ScreenViewport());
stage.addActor(game.background);
game.getHandler().showAds(false);
labelStyle = new LabelStyle();
labelStyle.font = game.levels;
table = new Table();
table.setFillParent(true);
label = new Label(game.langStr.get("Loading"), labelStyle);
table.add(label);
stage.addActor(table);
}
@Override
public void render(float delta) {
Gdx.gl.glClearColor(0, 0, 0, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
stage.act(delta);
stage.draw();
if (game.manager.update()) {
game.setScreen(new MainMenuScreen(game));
dispose();
}
}
```
Теперь, в классе *MyGame.java* просто вызываем этот экран вместо экрана *MainMenuScreen.java* и все. В [документации](https://github.com/libgdx/libgdx/wiki/Managing-your-assets) о нем хорошо написано. А нам нужно изменить везде, где мы обращались к файлам на:
```
game.manager.get("some/file.png", TextureAtlas.class); // Вместо TextureAtlas может быть почти любой класс. Список поддерживаемых классов можно глянуть в документации по ссылке выше
```
Теперь, когда все готово, перед стартом игры, мы увидим экран:
**Экран загрузки**
Также, вы можете добавить какую-нибудь анимацию, чтобы пользователь точно знал, что игра грузится, а не зависла.
Далее. Теперь замечание от хабраюзера [1nt3g3r](https://habrahabr.ru/users/1nt3g3r/). Он написал, что лучше все текстурки упаковать в один файл. Я это сделал с кнопками, но забыл сделать со звездами, а зря. Про упаковку можно почитать в [документации](https://github.com/libgdx/libgdx/wiki/Texture-packer) к libGDX, а я лишь поясню некоторые плюсы такого решения. Во-первых, после упаковки всех звезд, размер уменьшился на 300 килобайт, что довольно существенно. Во-вторых, я создал один объект атласа и обращался к нему, что по моим наблюдениям немного сказалось на производительности, в лучшую сторону. Как упаковать все ваши файлы? Можно одной командой в терминале. Переходим в каталог с вашим libGDX и выполняем оттуда что-то вроде этого:
```
java -cp gdx.jar:extensions/gdx-tools/gdx-tools.jar com.badlogic.gdx.tools.texturepacker.TexturePacker inputDir [outputDir] [packFileName]
```
Помните, что искать region мы будем по имени файла:
```
starsAtlas = manager.get("images/stars/stars.pack", TextureAtlas.class);
// Находим наше изображение
starsAtlas.findRegion("star1"),
```
Далее, хабраюзер [sperson](https://habrahabr.ru/users/sperson/) написал о том, что в libGDX лучше все ресурсы объявлять в json файле и загружать их потом через:
```
Skin.get(String, Class);
```
Также, [1nt3g3r](https://habrahabr.ru/users/1nt3g3r/) написал, что лучше все данные хранить не в xml, а в json. Наверное, они правы, но я пока оставил xml подход. Про json есть немного в [документации](https://github.com/libgdx/libgdx/wiki/Reading-%26-writing-JSON).
Теперь, поговорим про AdMob. На самом деле, в [документации](https://github.com/libgdx/libgdx/wiki/Admob-in-libgdx) все хорошо описано, поэтому нет смысла «копипастить» ее сюда. Немного расскажу про доход за эти несколько дней после публикации приложения. Я заработал, аж целых 16 центов!
Далее, немного расскажу про публикацию приложения в Google Play. Я сделал перевод названия и описания на английский и китайский. Забавно то, что саму игру писал четыре дня, а выкладывал три, из-за того, что ждал, пока переведут на китайский и долго думал над описанием. На счет китайского я сглупил, ибо моя знакомая, живущая в Китае сказала, что у них там не всегда и не очень хорошо работает Google Play. Может это из-за их файервола, а может это у нее проблемы. В любом случае, из Китая еще никто игру не скачал. Также, время заняла публикация в другие маркеты. О них есть замечательная [статья](http://habrahabr.ru/post/164413/) здесь на Хабре.
Теперь о том, где я брал звуки и почему не стал делать фоновую музыку. Звуки я записал с помощью **FL Studio**. Хорошая программа, крайне простая в использовании. Взял инструмент **Sytrus**, нашел понравившийся мне звук, ~~немного покрутил крутилки~~ и записал каждую ноту в двух октавах. Потом, правда пришлось немного поработать с каждой нотой уже в **Audacity**, так как я забыл сделать плавное затухание из-за чего при проигрывании мелодии, ноты накладывались друг на друга, создавая ужасное звучание.
Звук аплодисментов я взял с сайта [FreeSound](http://www.freesound.org/). Полезный ресурс, правда не все звуки качественные, пришлось поискать, а затем немного обработать.
Теперь о том, почему я не стал вставлять фоновую музыку. Какие мелодии ассоциируются у вас с космосом? У меня вообще нет ассоциаций. Я долго что-то пытался сделать, но ничего хорошего не вышло и решил оставить эту затею. Тем более, лично меня раздражают стартовые мелодии в играх. | https://habr.com/ru/post/224223/ | null | ru | null |
# «Истина в последней инстанции» или зачем нужен Database First Design
В этой весьма запоздалой статье я объясню почему, по моему мнению, в большинстве случаев при разработке модели данных приложения необходимо придерживаться подхода "database first". Вместо "Java[любой другой язык] first" подхода, который выведет вас на длинную дорожку, полную боли и страданий, как только проект начнет расти.
*"Слишком занят, чтобы стать лучше" [Licensed CC](https://creativecommons.org/licenses/by/2.0/) by [Alan O’Rourke / Audience Stack](http://audiencestack.com/static/blog.html). [Оригинальное изображение](https://www.flickr.com/photos/toddle_email_newsletters/15596940251/in/photostream)*
[Эта статья вдохновлена недавним вопросом на StackOverflow](https://stackoverflow.com/q/50706556/521799).
Интересные reddit-обсуждения [/r/java](https://redd.it/8p0uj3) и [/r/programming](https://redd.it/8p0qle).
Кодогенерация
-------------
К моему удивлению, одна небольшая группа пользователей похоже была потрясена тем фактом, что [jOOQ](https://www.jooq.org) сильно "завязан" на генерации исходного кода.
При том, что вы можете использовать jOOQ именно так как вам удобно, предпочтительным способ (согласно документации) является начать именно с уже существующей схемы БД, затем сгенерировать необходимые клиентские классы (соответствующие вашим таблицам) с помощью jOOQ, а после этого уже спокойно писать типобезопасные запросы для этих таблиц:
```
for (Record2 record : DSL.using(configuration)
// ^^^^^^^^^^^^^^^^^^^^^^^ Type information derived from the
// generated code referenced from the below SELECT clause
.select(ACTOR.FIRST\_NAME, ACTOR.LAST\_NAME)
// vvvvv ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ Generated names
.from(ACTOR)
.orderBy(1, 2)) {
// ...
}
```
Код может генерироваться либо вручную вне сборки, либо автоматически с каждой сборкой. Например, [такая генерация может происходить сразу же после установки Flyway-миграций](https://blog.jooq.org/2014/06/25/flyway-and-jooq-for-unbeatable-sql-development-productivity), которые также могут запускаться как вручную, так и автоматически.
### Генерация исходного кода
Существуют разные философии, преимущества и недостатки в отношении этих подходов к кодогенерации, которые я не хочу обсуждать в этой статье. Но по сути, смысл сгенерированного кода заключается в том, что он является Java-представлением того, что мы считаем неким "эталоном" (как внутри, так и снаружи нашей системы). В некотором роде компиляторы делают то же самое, когда генерируют байт-код, машинный код или какой-либо другой исходный код из исходников — в итоге мы получаем представление о нашем "эталоне" на другом специфичном языке.
Существует достаточно много таких генераторов кода. Например, [XJC может генерировать Java-код из файлов XSD или WSDL](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/xjc.html). Принцип всегда один и тот же:
* Существует некий эталон (внешний или внутренний), такой как спецификация, модель данных и пр.
* Необходимо получить собственное представление об этом эталоне на нашем привычном языке программирования.
И почти всегда имеет смысл именно *генерировать* это представление, чтобы избежать лишней работы и лишних ошибок.
### "Type providers" и обработка аннотаций
Примечательно, что еще один, более современный, подход к генерации кода в jOOQ — это Type Providers, ([как он сделан в F#](https://docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers)), где код генерируется компилятором при компиляции и никогда не существует в исходной форме. Аналогичный (но менее сложный) инструмент в Java — это обработчики аннотаций, например, [Lombok](https://projectlombok.org).
В обоих случаях происходит все тоже самое что и в обычной кодогенерации, кроме:
* Вы не видите сгенерированный код (возможно, для многих это уже большой плюс?)
* Вы должны обеспечить доступность вашего "эталона" при каждой компиляции. Это не доставляет никаких проблем в случае с Lombok, который непосредственно аннотирует сам исходный код, который и является "эталоном" в данном случае. Немного сложнее с моделями баз данных, которые полагаются на всегда доступное "живое" соединение.
В чем проблема с генерацией кода?
---------------------------------
Помимо каверзного вопроса, нужно ли генерировать код вручную или автоматически, некоторые люди считают, что код вообще не нужно генерировать. Причина, которую я слышу чаще всего — что такую генерацию сложно реализовать в CI/CD pipeline. И да, это правда, т.к. мы получаем накладные расходы на создание и поддержку дополнительной инфраструктуры, тем более если вы новичок в используемых инструментах (jOOQ, JAXB, Hibernate и др.).
Если накладные расходы на изучение работы кодогенератор слишком высоки, то действительно пользы будет мало. Но это единственный аргумент против. В большинстве остальных случаев совершенно не имеет никакого смысла вручную писать код, который является обычным представлением модели чего-либо.
Многие люди утверждают, что у них нет времени на это, т.к. именно сейчас нужно как можно скорее "выкатить" очередной MVP. А доработать свой CI/CD pipeline они смогут когда-нибудь потом. В таких случаях я обычно говорю: "Ты слишком занят, чтобы стать лучше".
"Но ведь Hibernate/JPA делает Java first разработку гораздо проще"
------------------------------------------------------------------
Да, это правда. Это одновременно и радость, и боль для пользователей Hibernate. С помощью него вы можете просто написать несколько объектов, вида:
```
@Entity
class Book {
@Id
int id;
String title;
}
```
И все, почти готово. Далее Hibernate возьмет на себя всю рутину по поводу того, как определить этот объект в DDL и на нужном SQL-диалекте:
```
CREATE TABLE book (
id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
title VARCHAR(50),
CONSTRAINT pk_book PRIMARY KEY (id)
);
CREATE INDEX i_book_title ON book (title);
```
Это действительно отличный способ для быстрого старта разработки — остается только запустить приложение.
Но не все так радужно. Еще остается множество вопросов:
* Сгенерирует ли Hibernate нужное мне имя для первичного ключа?
* Создаст ли необходимый мне индекс на поле TITLE?
* Будет ли генерироваться уникальное значение ID для каждой записи?
Похоже, что нет. Но пока проект находится в стадии разработки, вы всегда можете выбросить свою текущую базу данных и сгенерировать все с нуля, добавив нужные аннотации к модели.
Итак, класс Book в конечном виде будет выглядеть примерно так:
```
@Entity
@Table(name = "book", indexes = {
@Index(name = "i_book_title", columnList = "title")
})
class Book {
@Id
@GeneratedValue(strategy = IDENTITY)
int id;
String title;
}
```
Но вы заплатите за это, чуть позже
----------------------------------
Рано или поздно ваше приложение попадает в production, и описанная схема перестанет работать:
> В живой и настоящей системе вы больше не сможете просто так взять и выбросить свою базу данных, т.к. данные в ней используются и могут стоить кучу денег.
С этого момента вам необходимо писать скрипты миграций на каждое изменение в модели данных, [например, используя Flyway](https://blog.jooq.org/2014/06/25/flyway-and-jooq-for-unbeatable-sql-development-productivity). При этом, что происходит с вашими клиентскими классами? Вы можете либо адаптировать их вручную (что приведет к двойной работе), либо попросить Hibernate генерировать их (но насколько велики шансы того, что результат такой генерации будет соответствовать ожиданиям?). В итоге вас могут ожидать большие проблемы.
Как только код попадает в production, в него почти сразу необходимо вносить исправления, причем как можно быстрее.
И т.к. установка миграций БД не встроена в ваш сборочный конвейер, придется устанавливать такие патчи вручную на свой страх и риск. Чтобы вернуться назад и сделать все правильно уже не хватит времени. Его хватит только на то, чтобы винить Hibernate во всех своих бедах.
Вместо этого вы могли бы поступить совершенно иначе с самого начала. А именно использовать круглые колеса вместо квадратных.
Вперед к "Database First"
-------------------------
Эталон схемы данных и контроль над ней находится в ведомстве вашей СУБД. База данных — это единственное место, где определена схема, и все клиенты имеют *копию* этой схемы, но не наоборот. Данные находятся в вашей базе данных, а не в вашем клиенте, поэтому имеет смысл обеспечить контроль схемы и ее целостности именно там, где находятся данные.
Это старая мудрость, ничего нового. Первичные и уникальные ключи хороши. Внешние ключи прекрасны. Проверка ограничений на стороне БД замечательна. [Assertion (когда они окончательно реализованы)](https://community.oracle.com/ideas/13028) великолепны.
И это еще далеко не все. Например, если вы используете Oracle, вы можете указать:
* В каком табличном пространстве находится ваша таблица
* Какое значение PCTFREE она имеет
* Каков размер кэша последовательности (sequence)
Возможно все это не имеет значения в небольших системах, зато в более крупных системах вам не придется идти по пути "больших данных", пока вы не выжмите все соки из своего текущего хранилища. Ни одна ORM, которую я когда-либо видел (в том числе jOOQ) не позволит вам использовать полный набор параметров DDL, которые предоставляет ваша СУБД. ORM предлагают только некоторые инструменты, которые помогут написать DDL.
В конечном счете, хорошо продуманная схема должна быть написана только вручную с помощью СУБД-специфичного DDL. Весь автоматически сгенерированный DDL являются лишь приближением к этому.
Что насчет клиентской модели?
-----------------------------
Как уже упоминалось ранее, вам понадобится некое представление схемы БД на стороне клиента. Излишне говорить, что это представление должно быть синхронизировано с реальной моделью. Как это сделать? Конечно же используя генераторы кода.
Все базы данных предоставляют доступ к своей метаинформации посредством старого доброго SQL. Вот так, например, можно получить список всех таблиц из разных баз данных:
```
-- H2, HSQLDB, MySQL, PostgreSQL, SQL Server
SELECT table_schema, table_name
FROM information_schema.tables
-- DB2
SELECT tabschema, tabname
FROM syscat.tables
-- Oracle
SELECT owner, table_name
FROM all_tables
-- SQLite
SELECT name
FROM sqlite_master
-- Teradata
SELECT databasename, tablename
FROM dbc.tables
```
Именно такие запросы (а также аналогичные запросы для представлений, материализованных представлений и табличных функций) выполняются при вызове метода [DatabaseMetaData.getTables()](https://docs.oracle.com/javase/10/docs/api/java/sql/DatabaseMetaData.html#getTables(java.lang.String,java.lang.String,java.lang.String,java.lang.String%5B%5D)) конкретного JDBC-драйвера, либо в модуле jOOQ-meta.
Из результатов таких запросов относительно легко создать любое клиентское представление модели БД, независимо от того, какая именно технология доступа к данным используется.
* Если вы используете JDBC или Spring, вы можете создать группу String-констант
* Если используете JPA, можете сами создавать объекты
* Если используете jOOQ, можете создать метамодели jOOQ
В зависимости от количества функций, предлагаемых вашим API доступа к данным (jOOQ, JPA или что-то еще), сгенерированная метамодель может быть действительно богатой и полной. Как пример, [функция неявного соединения в jOOQ 3.11, которая опирается на метаинформацию о взаимоотношениях внешних ключей между вашими таблицами](https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11).
Теперь любое изменение схемы базы данных автоматически приведет к обновлению клиентского кода.
Представьте, что нужно переименовать колонку в таблице:
```
ALTER TABLE book RENAME COLUMN title TO book_title;
```
Вы уверены, что хотите выполнить эту работу дважды? Ни за что. Просто закомитьте этот DDL, запустите сборку и наслаждайтесь обновленным объектом:
```
@Entity
@Table(name = "book", indexes = {
// Would you have thought of this?
@Index(name = "i_book_title", columnList = "book_title")
})
class Book {
@Id
@GeneratedValue(strategy = IDENTITY)
int id;
@Column("book_title")
String **bookTitle**;
}
```
Так же полученный клиентский нет необходимости компилировать каждый раз (как минимум до следующего изменения в схеме БД), что уже может быть большим плюсом!
Большинство изменений DDL также являются семантическими изменениями, а не только синтаксическими. Таким образом, здорово видеть в сгенерированном коде клиента на что именно повлияли последние изменения в БД.
Правда всегда одна
------------------
Независимо от того, какую технологию вы используете, всегда должна быть только одна модель, которая и является эталоном для подсистемы. Или, как минимум, мы должны стремиться к этому и избегать неразберихи в бизнесе, где «эталон» есть везде и нигде одновременно. Это делает все намного проще. К примеру, если вы обмениваетесь XML-файлами с какой-либо другой системой, вы наверняка используете XSD. Как метамодель INFORMATION\_SCHEMA jOOQ в формате XML: <https://www.jooq.org/xsd/jooq-meta-3.10.0.xsd>
* XSD хорошо понятен
* XSD отлично описывает XML-контент и позволяет осуществлять валидацию на всех клиентских языках
* XSD позволяет легко управлять версиями и сохранять обратную совместимость
* XSD можно превратить в Java-код с помощью XJC
Обратим отдельное внимание на последний пункт. При общении с внешней системой через XML-сообщения мы должны быть уверены в валидности сообщений. И это действительно очень легко сделать с помощью таких вещей как JAXB, XJC и XSD. Было бы сумасшествием думать об уместности Java-first подхода в данном случае. Генерируемый на основе объектов XML получится низкого качества, будет плохо задокументирован и трудно расширяем. И если на такое взаимодействие есть SLA, то вы будете разочарованы.
Честно говоря, это похоже на то, что сейчас происходит с различными API для JSON, но это уже совершенна другая история...
### Чем базы данных хуже?
При работе с БД тут все тоже самое. База данных владеет данными, и она так же должна быть хозяином схемы этих данных. Все модификации схемы должны быть выполнены посредством DDL напрямую, чтобы обновить эталон.
После обновления эталона все клиенты должны обновить свои представления о модели. Некоторые клиенты могут быть написаны на Java, используя либо jOOQ и/или Hibernate, либо JDBC. Другие клиенты могут быть написаны на Perl (удачи им) или даже на C#. Это не имеет никакого значения. Основная модель находится в базе данных. Тогда как модели, созданные с помощью ORM, имеют низкое качество, недостаточно хорошо документированы и трудно расширяемы.
Поэтому не делайте этого, причем с самого начала разработки. Вместо этого начните с базы данных. Создайте автоматизированный CI/CD конвейер. Используйте в нем генерацию кода, чтобы автоматически генерировать модель базы данных для клиентов при каждой сборке. И перестаньте волноваться, все будет хорошо. Все что требуется — немного первоначальных усилий по настройке инфраструктуры, но в результате вы получите выигрыш в процессе разработки для остальной части вашего проекта на годы вперед.
Не надо благодарностей.
Пояснения
---------
Для закрепления: эта статья никоим образом не утверждает, что модель базы данных должна распространяться на всю вашу систему (на предметную область, бизнес-логику и пр.). Мои заявления заключается лишь в том, что клиентский код, взаимодействующий с базой данных, должен быть лишь *представлением* схемы БД, но никак не определять и не формировать ее.
В двухуровневых архитектурах, которые по-прежнему имеют место быть, схема БД может быть единственным источником информации о модели вашей системы. Однако в большинстве систем я рассматриваю уровень доступа к данным как «подсистему», которая инкапсулирует модель базы данных. Как-то так.
Исключения
----------
Как и в любом другом хорошем правиле, в нашем тоже есть свои исключения (и я уже предупреждал, что подход database first и генерация кода не всегда является правильным выбором). Вот эти исключения (возможно, список не полный):
* Когда схема неизвестна заранее и ее необходимо исследовать. Например, вы поставщик инструмента, помогающего пользователям осуществлять навигацию по любой схеме. Само собой, тут не может быть никакой генерации кода. Но в любом случае, придется иметь дело с самой БД напрямую и ее схемой.
* Когда для какой-то задачи необходимо создать схему "на лету". Это может быть похоже на одну из вариаций [паттерна Entity-attribute-value](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model), т.к. у вас нет четко определенной схемы. Также как и нет уверенности, что RDBMS в данном случае это верный выбор.
Особенность этих исключений в том, что они довольно редко всречаются в живой природе. В большинстве же случаев при использовании реляционных БД схема заранее известна и является "эталоном" вашей модели, а клиенты должны работать с копией этой модели, сгенерированной с использованием генераторов кода. | https://habr.com/ru/post/413597/ | null | ru | null |
# Асинхронная (и не очень) загрузка данных в Unreal Engine 4
### Содержание:
* [Шаг 1. Использование специальных указателей на ассеты](#2)
* [Шаг 2. Загрузка ресурсов в память по требованию](#3)
* [Примеры](#4)
+ [Пример 1. Выбор персонажа](#5)
- [Структура данных](#6)
- [Загрузка ассетов](#7)
+ [Пример 2. Экраны интерфейса](#8)
+ [Пример 3. Таблицы данных без кода](#9)
* [Заключение](#10)
Всем привет!
Сегодня я расскажу о том, как обращаться с ассетами на **Unreal Engine 4** так, чтобы не было мучительно больно за бесцельно занятую память и стоны игроков за время загрузки вашей игры.
Одной из неочевидных особенностей работы движка является то, что для всех как-либо затронутых через систему ссылок объектов в памяти хранится так называемый **Class Default Object (CDO)**. Более того, для полноценного функционирования объектов в память загружаются и все упомянутые в них ресурсы – меши, текстуры, шейдеры и другие.
Как следствие, в такой системе необходимо очень внимательно следить за тем, как «разворачивается» дерево связей ваших игровых объектов в памяти. Легко привести пример, когда введение простейшего условия из разряда — если игрок в данный момент управляет яблоком, ему будет показана кнопка «Купи Больше Яблок Прямо Сейчас!» – потянет за собой загрузку половины текстур всего интерфейса, даже если пользователь играет только за персонажа-грушу.
Почему? Схема предельно проста:
1. HUD проверяет какого класса игрок, тем самым загружая в память класс **Яблоко** (и все, что упомянуто в Яблоке);
2. Если проверка была успешна — создается виджет **КупиЯблоки** (он упомянут напрямую -> загружается сразу);
3. **КупиЯблоки** по нажатию должны открывать окно **ПремиумМагазина**;
4. **ПремиумМагазин** в зависимости от некоторых условий умеет показывать экран **ОдежкиДляПерсонажа**, где используются 146 иконок одежек и по 20 моделек разных косточек и бочков фруктов на каждый класс.
Дерево продолжит разворачиваться вплоть до всех своих листиков, и таким путем, казалось бы, совершенно безобидных проверок и упоминаний других классов (даже на уровне Cast’а!) – у вас в памяти будут сидеть целые группы объектов, которые никогда игроку не понадобятся в данный момент игрового процесса.
В какой-то момент при разработке это станет критичным для вашей игры, но далеко не сразу (пороги памяти даже у современных мобильных устройств очень высоки). При этом ошибки проектирования такого рода очень сложно и неприятно исправлять.
Я хочу привести несколько практических решений, которыми я пользуюсь постоянно сам, и которые могут служить примером разрешения таких ситуаций, и могут быть легко расширены для нужд вашего проекта.
Шаг 1. Использование специальных указателей на ассеты
=====================================================
Чтобы прервать порочную практику загрузки всего дерева зависимостей в память, господа из Epic Games предоставили нам возможность использования двух хитрых типов ссылок на ассеты, это **TAssetPtr** и **TAssetSubclassOf** (единственное их отличие друг от друга, что в **TAssetSubclassOf** не сможет попасть ассет класса A, только дочерние от него, что удобно, когда класс А – абстрактный).
Особенность использования данных типов в том, что они не загружают ресурсы в память автоматически, лишь только хранят ссылки на них. Тем самым, ресурсы попадают в собранный проект (чего не произошло, например, при хранении библиотеки персонажей в виде массива текстовых ссылок на ассеты), но загрузка в память происходит только тогда, когда об этом скажет разработчик.
Шаг 2. Загрузка ресурсов в память по требованию
===============================================
Для этого нам понадобится такая штука, как **FStreamableManager**. Более подробно я расскажу об этом ниже в рамках примеров, пока лишь достаточно сказать, что загрузка ассетов может быть как асинхронной, так и синхронной, тем самым может полностью заменить «обычные» ссылки на ассеты.
Примеры
=======
Основная цель статьи – это дать практические ответы на вопросы «Кто виноват?» (прямые ссылки на ассеты) и «Что делать?» (загружать их через **TAssetPtr**), поэтому я не буду повторять то, что вы и так можете прочитать в [официальной документации движка](https://wiki.unrealengine.com/TAssetPtr_and_Asynchronous_Asset_Loading), а приведу примеры реализации таких подходов на практике.
### Пример 1. Выбор персонажа
Во многих играх, будь то DOTA 2 или World of Tanks – есть возможность посмотреть персонажа вне боя. Клик по карусели – и вот уже на экране отображается новая моделька. Если на все доступные модели будут прямые ссылки, то, как мы уже знаем, все они попадут в память еще на этапе загрузки. Только представьте – все сто двенадцать персонажей доты и сразу в память! :)
#### Структура данных
Чтобы было удобно загружать персонажей, мы заведем табличку, в которой по айдишнику персонажа сможем получить ссылку на его ассет.
```
/**
* Example #1. Table for dynamic actor creation (not defined in advance)
*/
USTRUCT(Blueprintable)
struct FMyActorTableRow : public FTableRowBase
{
GENERATED_USTRUCT_BODY()
UPROPERTY(EditAnywhere, BlueprintReadWrite)
FString AssetId;
UPROPERTY(EditAnywhere, BlueprintReadWrite)
TAssetSubclassOf ActorClass;
FMyActorTableRow() :
AssetId(TEXT("")),
ActorClass(nullptr)
{
}
};
```
Обратите внимание, я использовал класс **FTableRowBase** в качестве родителя для нашей структуры данных. Этот подход позволяет нам создать таблицу для удобного редактирования прямо в блюпринтах:
 
Для заметки – вы можете спросить, зачем же **AssetId**, если есть некий **Row Name**? Я использую дополнительный ключ для сквозной идентификации сущностей внутри игры, правила именования которых отличаются от тех ограничений, которые налагаются на **Row Name** авторами движка, хотя это и не обязательно.
#### Загрузка ассетов
Функционал для работы с таблицами в блюпринтах небогатый, но его достаточно:
После получения ссылки на ассет персонажа используется нода **Spawn Actor (Async)**. Это кастомная нода, для нее был написан такой код:
```
void UMyAssetLibrary::AsyncSpawnActor(UObject* WorldContextObject, TAssetSubclassOf AssetPtr, FTransform SpawnTransform, const FMyAsyncSpawnActorDelegate& Callback)
{
// Асинхронно загружаем ассет в память
FStreamableManager& AssetLoader = UMyGameSingleton::Get().AssetLoader;
FStringAssetReference Reference = AssetPtr.ToStringReference();
AssetLoader.RequestAsyncLoad(Reference, FStreamableDelegate::CreateStatic(&UMyAssetLibrary::OnAsyncSpawnActorComplete, WorldContextObject, Reference, SpawnTransform, Callback));
}
void UMyAssetLibrary::OnAsyncSpawnActorComplete(UObject\* WorldContextObject, FStringAssetReference Reference, FTransform SpawnTransform, FMyAsyncSpawnActorDelegate Callback)
{
AActor\* SpawnedActor = nullptr;
// Ассет теперь должен быть в памяти, пытаемся загрузить объект класса
UClass\* ActorClass = Cast(StaticLoadObject(UClass::StaticClass(), nullptr, \*(Reference.ToString())));
if (ActorClass != nullptr)
{
// Спавним эктора в мир
SpawnedActor = WorldContextObject->GetWorld()->SpawnActor(ActorClass, SpawnTransform);
}
else
{
UE\_LOG(LogMyAssetLibrary, Warning, TEXT("UMyAssetLibrary::OnAsyncSpawnActorComplete -- Failed to load object: $"), \*Reference.ToString());
}
// Вызываем событие о спавне в блюпринты
Callback.ExecuteIfBound(SpawnedActor != nullptr, Reference, SpawnedActor);
}
```
Главная магия процесса загрузки происходит здесь:
```
FStreamableManager& AssetLoader = UMyGameSingleton::Get().AssetLoader;
FStringAssetReference Reference = AssetPtr.ToStringReference();
AssetLoader.RequestAsyncLoad(Reference, FStreamableDelegate::CreateStatic(&UMyAssetLibrary::OnAsyncSpawnActorComplete, WorldContextObject, Reference, SpawnTransform, Callback));
```
Мы используем **FStreamableManager** для того, чтобы загрузить в память ассет, переданный через **TAssetPtr**. После загрузки ассета будет вызвана функция **UMyAssetLibrary::OnAsyncSpawnActorComplete**, в которой мы уже попробуем создать экземпляр класса, и если все ОК, предпримем попытку спавна эктора в мир.
Асинхронное выполнение операций предполагает уведомление об их выполнении\_=B8, поэтому в конце мы вызываем блюпринтовое событие:
`Callback.ExecuteIfBound(SpawnedActor != nullptr, Reference, SpawnedActor);`
Управление происходящим в блюпринтах будет выглядеть так:
Собственно, все. Используя такой подход, можно спавнить экторов асинхронно, минимально нагружая память игры.
### Пример 2. Экраны интерфейса
Помните пример о кнопке **НужноБольшеЯблок**, и как она потянула за собой загрузку в память других экранов, которые даже не видит игрок на текущий момент?
Не всегда получится этого избежать на все 100%, но самая критичная зависимость между окнами интерфейса – это их открытие (создание) по какому-нибудь событию. В нашем случае кнопка ничего не знает о том окне, которое она порождает, кроме того, какое собственно окно нужно будет показать пользователю при клике.
Воспользуемся полученными ранее знаниями и создадим таблицу экранов интерфейса:
```
USTRUCT(Blueprintable)
struct FMyWidgetTableRow : public FTableRowBase
{
GENERATED_USTRUCT_BODY()
UPROPERTY(EditAnywhere, BlueprintReadWrite)
TAssetSubclassOf WidgetClass;
FMyWidgetTableRow() :
WidgetClass(nullptr)
{
}
};
```
Будет выглядеть она так:
Создание интерфейса отличается от спавна экторов, поэтому создадим дополнительную функцию создания виджетов из асинхронно загружаемых ассетов:
```
UUserWidget* UMyAssetLibrary::SyncCreateWidget(UObject* WorldContextObject, TAssetSubclassOf Asset, APlayerController\* OwningPlayer)
{
// Check we're trying to load not null asset
if (Asset.IsNull())
{
FString InstigatorName = (WorldContextObject != nullptr) ? WorldContextObject->GetFullName() : TEXT("Unknown");
UE\_LOG(LogMyAssetLibrary, Warning, TEXT("UMyAssetLibrary::SyncCreateWidget -- Asset ptr is null for: %s"), \*InstigatorName);
return nullptr;
}
// Load asset into memory first (sync)
FStreamableManager& AssetLoader = UMyGameSingleton::Get().AssetLoader;
FStringAssetReference Reference = Asset.ToStringReference();
AssetLoader.SynchronousLoad(Reference);
// Now load object and check that it has desired class
UClass\* WidgetType = Cast(StaticLoadObject(UClass::StaticClass(), NULL, \*(Reference.ToString())));
if (WidgetType == nullptr)
{
return nullptr;
}
// Create widget from loaded object
UUserWidget\* UserWidget = nullptr;
if (OwningPlayer == nullptr)
{
UWorld\* World = GEngine->GetWorldFromContextObject(WorldContextObject);
UserWidget = CreateWidget(World, WidgetType);
}
else
{
UserWidget = CreateWidget(OwningPlayer, WidgetType);
}
// Be sure that it won't be killed by GC on this frame
if (UserWidget)
{
UserWidget->SetFlags(RF\_StrongRefOnFrame);
}
return UserWidget;
}
```
Здесь есть несколько вещей, на которые стоит обратить внимание.
**Первое**, это то, что мы добавили проверку на валидность ассета, переданного нам по ссылке:
```
// Check we're trying to load not null asset
if (Asset.IsNull())
{
FString InstigatorName = (WorldContextObject != nullptr) ? WorldContextObject->GetFullName() : TEXT("Unknown");
UE_LOG(LogMyAssetLibrary, Warning, TEXT("UMyAssetLibrary::SyncCreateWidget -- Asset ptr is null for: %s"), *InstigatorName);
return nullptr;
}
```
Все может быть в нашем нелегком деле разработчиков игр, поэтому такие случаи предусмотреть будет не лишним.
**Второе**, виджеты не спавнятся в мир, для них используется функция **CreateWidget**:
`UserWidget = CreateWidget(OwningPlayer, WidgetType);`
**Третье**, если в случае эктора он рождался в мире и становился частью его, то виджет, остается обычным подвешенным «голым» указателем, на который с радостью поохотился бы анриловский сборщик мусора. Чтобы дать ему шанс, мы включаем ему защиту от пожирания со стороны GC на текущий фрейм:
`UserWidget->SetFlags(RF_StrongRefOnFrame);`
Тем самым, если никто не возьмет эстафету на себя (окно не показано пользователю, а только создано), то сборщик мусора его удалит.
И **четвертое**, на сладкое – мы загружаем виджет синхронно, в рамках одного тика:
`AssetLoader.SynchronousLoad(Reference);`
Как показывает практика, это отлично подходит даже для мобилок, при этом обращаться с синхронной функцией легче – не требуется заводить дополнительные события загрузки и как-либо обрабатывать их. Конечно, при такой практике, не надо делать все длительные операции в **Construct’е** виджета – если это необходимо, дайте в начале ему появиться для игрока, и потом уже пишите «загрузка», пока все 100500 айтемов игрока и модельки персонажа загружаются на экран.
### Пример 3. Таблицы данных без кода
Что делать, если вам нужно создавать много структур данных с использованием **TAssetPtr**, но не хочется для каждой заводить класс в коде и наследоваться от **FTableRowBase**? В блюпринтах нет такого типа данных, поэтому совсем без кода обойтись не получится, но можно создать прокси-класс со ссылкой на конкретный тип ассетов. Например, для текстурных атласов я использую такую структуру:
```
USTRUCT(Blueprintable)
struct FMyMaterialInstanceAsset
{
GENERATED_USTRUCT_BODY()
UPROPERTY(EditAnywhere, BlueprintReadWrite)
TAssetPtr MaterialInstance;
FMyMaterialInstanceAsset() :
MaterialInstance(nullptr)
{
}
};
```
Теперь вы можете использовать тип **FMyMaterialInstanceAsset** в блюпринтах, и на основе него создавать свои кастомные структуры данных, которые будут использоваться в таблицах:
Во всем остальном работа с этим типом данных отличаться от сказанного выше не будет.
Заключение
==========
Использование ссылок на ассеты через **TAssetPtr** может здорово сократить потребление памяти вашей игрой и значительно ускорить время загрузки. Я постарался привести наиболее практичные примеры использования такого подхода, и надеюсь, они будут вам полезны.
Полный исходный код всех примеров доступен [здесь](https://github.com/ufna/Habr-Articles/tree/master/habr_309228_UE4_Async).
Комментарии и вопросы приветствуются. | https://habr.com/ru/post/309228/ | null | ru | null |
# Магия JavaScript: arguments
`arguments` — очень специфическая штука, о которой новички и даже любители знают только то, что это «вроде массив, но какой-то неправильный». На самом деле, у него есть ряд интересных особенностей. Предлагаю в топике пофантазировать на тему TypeHinting, аргументов по-умолчанию и всякого другого.
```
(function (foo, bar) {
console.log(typeof arguments); // ?
arguments[0] = 42;
console.log(foo); // ?
})(10, 20);
```
А также покажу интересную идею-библиотеку
```
function test (foo, bar) {
Args(arguments).defaults(100, 100);
return [foo, bar];
};
test( ); // 100, 100
test(15 ); // 15, 100
test(21, 42); // 21, 42
```
В первую очередь хотел бы заметить, что множество идей высказанных в топике являются достаточно спорными. Я сам не уверен, что буду ими пользоваться и не советую пользоваться новичкам.
Что такое arguments
-------------------
Это хэш. Обычный хэш, как `var object = {}`
```
(function () { console.log(
typeof arguments, // object
Object.getPrototypeOf(arguments) == Object.prototype // true
) })();
```
Сделать из него массив просто:
```
var array = Array.prototype.slice.call(arguments, 0);
// или покороче, но менее производительно:
var array = [].slice.call(arguments, 0);
```
Мы вызываем метод `slice` прототипа Array от лица `arguments`.
Что есть в arguments
--------------------
`arguments.length` — количество аргументов, переданных в функцию.
```
var count = function () {
console.log(arguments.length);
};
count(); // 0
count(first, second); // 2
```
Не забывайте, что у каждой функции тоже есть свойство `length`, которое указывает на то, сколько элементов объявлено в её заголовке:
```
function one (foo) {};
function three (foo, bar, qux) {};
console.log( one.length); // 1
console.log(three.length); // 3
```
`arguments.callee` — ссылка на саму функцию.
```
function foo () {
console.log(arguments.callee === foo); // true
}
```
Таким образом можно проверить, передано ли правильное количество элементов, или нет:
```
function test (foo, bar, qux) {
return arguments.callee.length === arguments.length;
}
test(1); // false
test(1,2,3); // true
```
Аргументы в arguments
---------------------
В `arguments` содержится также список переданных аргументов.
```
function test (foo, bar) {
console.log(foo, bar); // 'a', 'b'
console.log(arguments[0], arguments[1]); // 'a', 'b'
}
test('a', 'b');
```
Теперь к интересному. Многие не знают, что объект arguments — содержит на самом деле ссылки, а не значения, и тесно связан с аргументами:
```
(function (foo) {
arguments[0] = 42;
console.log(foo); // 42!
foo = 20;
console.log(arguments[0]); // 20
})(5);
```
При этом связь достаточно крепкая:
```
function foo (qux) {
change(arguments);
return qux;
};
function change(a) {
a[0] = 42;
}
foo(10); // 42
```
Что из этого можно получить?
----------------------------
Во многих языках программирования есть «переменные по-умолчанию». К примеру, php:
```
function ($foo = 30, $bar = 'test') {
var_dump($foo);
var_dump($bar);
}
```
В javascript оно будет выглядеть как-то так:
```
function (foo, bar) {
if (typeof foo === 'undefined') foo = 30;
if (typeof bar === 'undefined') bar = 'test';
console.log(foo, bar);
}
```
Зная особенности `arguments` можно создать красивый интерфейс:
```
function test(foo, bar) {
Args(arguments).defaults(30, 'test');
console.log(foo, bar)
}
test(); // 30, 'test'
```
С помощью такого кода:
```
function Args (args) {
if (this instanceof Args) {
this.args = args;
} else {
// Если создано не через new, а просто вызвана функция, создаем и возвращаем новый объект
return new Args(args);
}
};
Args.prototype = {
defaults: function () {
var defaults = arguments;
for (var i = defaults.length; i--;) {
if (typeof args[i] === 'undefined') args[i] = defaults[i];
}
return this;
}
};
```
Аналогично можно сделать автоматическое приведение типов:
```
function test(foo) {
Args(arguments)
.defaults(10)
.cast(Number);
console.log(foo)
}
test('0100'); // 100
```
Или Type Hinting:
```
function test(foo, bar) {
Args(arguments).types(Foo, Bar);
// code
}
test(new Foo(), new Bar());
test(1, 2); // Error
```
Из интересных идей — сообщение, что все аргументы обязательны:
```
function test (foo, bar, qux) {
Args(arguments).allRequired();
}
test(1,2,3); // success
test(1,2); // Error: 3 args required, 2 given
```
Заключение
----------
Все эти идеи и возможности (и даже больше) я оформил в библиотеку — **[Args.js](https://github.com/theshock/args-js)**.
Согласен, что кое-какие вещи (как TypeHinting) не совсем подходят к идеологии языка. В то же время например defaults — очень удобная штука, имхо.
Пока что это прототип и, перед тем как вы будете его использовать — будьте уверены, что оно вам действительно нужно, а не что вы просто стараетесь из прекрасного языка сделать что-то похожее на C#.
Предлагаю обсудить, покритиковать код, найти пару багов и закоммитить несколько строк кода)
### **[Args.js](https://github.com/theshock/args-js)**
К сожалению, из-за бага в трёх популярных браузерах(IE, [Fx](https://bugzilla.mozilla.org/show_bug.cgi?id=292215), Opera) я [не смог добиться желаемого эффекта](http://theshock.github.com/args-js-tests/index.html), полноценно самое вкусное заработало только в Chrome (ну по крайней мере в node.js работать будет)). Надеюсь, решим эту проблему вместе.
**UPD**: В комментах выяснили, что таки это бага Хрома, но, зато, какая приятная! Спасибо [jamayka](https://habrahabr.ru/users/jamayka/) | https://habr.com/ru/post/117868/ | null | ru | null |
# Очередная навигация для Android Jetpack Compose? Brick
Я до последнего верил в [Navigation component](https://developer.android.google.cn/jetpack/compose/navigation?hl=en) от google. Но, к сожалению, ряд задач с которыми я столкнулся при его использовании вместе с compose заставили поменять мое мнение. Идея создания собственного решения для навигации меня посещала часто, но я считал, что в этом нет необходимости. Ситуация вынудила меня!!! ... и теперь я представляю - [**Brick**](https://github.com/alphicc/Brick).
Ну и зачем? В чем преимущество библиотеки?
------------------------------------------
Ну и сразу озвучу основную идею (и главное преимущество на мой взгляд), которую я преследовал - сделать максимально маленькое решение, которое позволит оторваться от фреймворка и строить проект как удобно. Да, отрыв от фреймворка. Например, тот же ViewModel. Штука хорошая, но проблем от нее тоже достаточно. Например, интеграция с Dagger. Ну это просто жесть, какие куски кода я видел по его интеграции. Кароче сложно, избыточно сложно.
Схема работы роутераВ Brick же за рисование Compose отвечает отдельный компонент NavigationContainer и скормленный ему ContainerConnector. Поэтому сам Router может быть где угодно, и вызываться откуда угодно!
Ладно, и что там?
-----------------
Основное понятие в [Brick](https://github.com/alphicc/Brick) как я считаю - это Screen. Но это не просто Screen, который равен UI (как сразу может сложиться ассоциация). UI в Brick это часть Screen. Screen может существовать и без UI. Да, навигацию в Brick можно строить не строить от UI, а от бизнес логики. Да что это я, вы можете производить навигацию без UI! Но я не хотел этим ограничивать разработчиков. Поэтому, если вы хотите строить навигацию от UI, то это тоже можно реализовать.
Screen - имеет жизненный цикл. Не такой сложный как у Fragment, но все же он есть.
Всего два метода *onCreate* и *onDestroy.* Жизненным циклом управляет роутер.
В onCreate вы можете создать нужные зависимости и провести их в UI часть, там может быть ViewModel и прочее. Ну и собственно, Router и хранит всю эту информацию, поэтому важно, к какому ЖЦ вы привяжете сам роутер. Если это будет роутер привязанный к активити, то он будет жить пока живо активити. Если в application, то пока жив application.
Пример ЖЦОкей, не так уж и много, ради того чтобы использовать этот Brick. Еще есть что-то?
----------------------------------------------------------------------------------
Здесь есть то, чего мне не хватало в Navigation от гугла.
1) Легче использовать, в четыре шага.
```
// 1 Создайте роутер
val router: TreeRouter = TreeRouter.new()
...
// 2 Создайте Screen
val screen1 = Screen(
key = "1",
content = { SimpleScreen(1, "new") { smallSampleRouter.addScreen(screen2) } } // content - ui
)
...
// 3 Присоедините Container Connector (его реализует router) к NavigationContainer'у
class SmallSampleActivity : ComponentActivity() {
val containerConnector: ContainerConnector = ... //inject or provide from application class
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ScreensContainer(containerConnector)
}
}
}
// 4 Осуществляйте навигацию!
router.addScreen(screen1)
```
2) Вложенная навигация, multibackstack, multibackstack внтури multibackstack и до бесконечной фантазии вашего разработчика UX.
Пример реализацииНу, а если схематично, то выглядит это вот так:
Справедливо заметить, что она есть и в Navigation Component. Но вы ее видели?) Или хотя бы использовали?) По моему мнению, она громоздка и неудобна в использовании.
3) Child навигация. Ее очень сильно не хватало, в Navigation Component. Конечно есть навигация в диалог и есть даже навигация в Bottom Sheet (правда в accompanist). Но она рушится, когда возникает задача сделать навигацию, где два Bottom Sheet один поверх другого и еще над ними Dialog.
Да, один над другим Bottom Sheet можно сделать использовав вложенность, но как быть, если логика внутри Bottom Sheet по объемам эквивалентна целому экрану? Вмещать три логики в один ViewModel? Разбивать ViewModel? А потом теряться в этих 500+ строчках кода или схемах связки, коммуникации между ViewModel? Слишком много вопросов и слишком рискованно, выбрав неверное решение можно потом увязнуть в трудно читаемом коде.
В [Brick](https://github.com/alphicc/Brick) child навигация такая же как и screen и для условного UI компонента (диалога, bottom sheet) вы можете сделать свою сущность, где будете описывать логику, только для этого UI.
4) Передача аргументов. Вы видели ее в Navigation Component? Ну окей, там у них целая идея вокруг этого, вроде как ссылка и прочее, но мне кажется это неудобным. В Brick навигацию можно осуществлять с аргументами.
5) Общение между Screen. Почему нет? Сколько раз возникает задача общения между экранами? Да постоянно! Так вот, если вам это общение между Screen необходимо, то у каждого Screen есть flow, который принимает адресованные ему данные. И отправить их можно из любого Router'a независимо от того, вложенная у вас навигация или multiback stack
6) И еще множество мелких плюшек.
Хм, интересно...
----------------
Философия этой библиотеки заложена в ее названии. Brick - кирпич. И я хочу и постараюсь сделать так, чтобы Brick стал маленьким кирпичиком в структуре Android проекта. настолько маленьким, что его интеграция не составила большого труда в любой Android проект c Jetpack Compose.
[Brick](https://github.com/alphicc/Brick) на GitHub | https://habr.com/ru/post/594383/ | null | ru | null |
# Учебник Thymeleaf: Глава 2. Хорошая виртуальная бакалейная лавка Thymes
[Оглавление](https://habrahabr.ru/post/350862/)
2 Хорошая виртуальная бакалейная лавка Thymes
---------------------------------------------
Исходный код примеров, показанных в этом и будущих главах руководства, можно найти в репозитории Good Thymes Virtual Grocery GitHub <https://github.com/thymeleaf/thymeleafexamples-gtvg>.
### 2.1 Вебсайт для бакалейной лавки
Чтобы лучше объяснить концепции, связанные с обработкой шаблонов с помощью Thymeleaf, в этом учебнике будет использоваться демонстрационное приложение, которое вы можете загрузить с веб-сайта проекта.
Это приложение является веб-сайтом воображаемого виртуального бакалейного магазина и предоставит нам множество сценариев, чтобы продемонстрировать многие функции Thymeleaf.
Для начала нам нужен простой набор объектов-моделей для нашего приложения: Продукты, которые продаются Клиентам через Заказы. Мы также будем управлять комментариями о продуктах:
Наше приложение также будет иметь очень простой сервис уровень, состоящий из объектов Service, содержащих такие методы, как:
```
public class ProductService {
...
public List findAll() {
return ProductRepository.getInstance().findAll();
}
public Product findById(Integer id) {
return ProductRepository.getInstance().findById(id);
}
}
```
На веб-уровне наше приложение будет иметь фильтр, который делегирует выполнение команд с поддержкой Thymeleaf в зависимости от URL-адреса запроса:
```
private boolean process(HttpServletRequest request, HttpServletResponse response)
throws ServletException {
try {
// This prevents triggering engine executions for resource URLs
if (request.getRequestURI().startsWith("/css") ||
request.getRequestURI().startsWith("/images") ||
request.getRequestURI().startsWith("/favicon")) {
return false;
}
/*
* Query controller/URL mapping and obtain the controller
* that will process the request. If no controller is available,
* return false and let other filters/servlets process the request.
*/
IGTVGController controller = this.application.resolveControllerForRequest(request);
if (controller == null) {
return false;
}
/*
* Obtain the TemplateEngine instance.
*/
ITemplateEngine templateEngine = this.application.getTemplateEngine();
/*
* Write the response headers
*/
response.setContentType("text/html;charset=UTF-8");
response.setHeader("Pragma", "no-cache");
response.setHeader("Cache-Control", "no-cache");
response.setDateHeader("Expires", 0);
/*
* Execute the controller and process view template,
* writing the results to the response writer.
*/
controller.process(
request, response, this.servletContext, templateEngine);
return true;
} catch (Exception e) {
try {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} catch (final IOException ignored) {
// Just ignore this
}
throw new ServletException(e);
}
}
```
Интерфейс нашего контроллера IGTVGController:
```
public interface IGTVGController {
public void process(
HttpServletRequest request, HttpServletResponse response,
ServletContext servletContext, ITemplateEngine templateEngine);
}
```
Все, что осталось сделать — это реализовать интерфейс IGTVGController, запрашивающий данные из сервисов и обрабатывающий шаблоны с помощью объекта ITemplateEngine.
В конце это будет выглядеть так:
### 2.2 Создание и конфигурирование Template Engine
Метод process(…) в нашем фильтре содержит эту строку:
```
ITemplateEngine templateEngine = this.application.getTemplateEngine();
```
Это означает, что класс GTVGApplication отвечает за создание и настройку одного из наиболее важных объектов в приложении Thymeleaf: экземпляр TemplateEngine (реализация интерфейса ITemplateEngine).
Наш объект org.thymeleaf.TemplateEngine инициализируется:
```
public class GTVGApplication {
...
private final TemplateEngine templateEngine;
...
public GTVGApplication(final ServletContext servletContext) {
super();
ServletContextTemplateResolver templateResolver =
new ServletContextTemplateResolver(servletContext);
// HTML is the default mode, but we set it anyway for better understanding of code
templateResolver.setTemplateMode(TemplateMode.HTML);
// This will convert "home" to "/WEB-INF/templates/home.html"
templateResolver.setPrefix("/WEB-INF/templates/");
templateResolver.setSuffix(".html");
// Template cache TTL=1h. If not set, entries would be cached until expelled by LRU
templateResolver.setCacheTTLMs(Long.valueOf(3600000L));
// Cache is set to true by default. Set to false if you want templates to
// be automatically updated when modified.
templateResolver.setCacheable(true);
this.templateEngine = new TemplateEngine();
this.templateEngine.setTemplateResolver(templateResolver);
...
}
}
```
Существует множество способов настройки объекта TemplateEngine, но на данный момент эти несколько строк кода будут достаточно подробно информировать нас о необходимых шагах.
**The Template Resolver**
Давайте начнем с Template Resolver:
```
ServletContextTemplateResolver templateResolver =
new ServletContextTemplateResolver(servletContext);
```
Template Resolvers являются объектами, которые реализуют интерфейс из Thymeleaf API, называемый org.thymeleaf.templateresolver.ITemplateResolver:
```
public interface ITemplateResolver {
...
/*
* Templates are resolved by their name (or content) and also (optionally) their
* owner template in case we are trying to resolve a fragment for another template.
* Will return null if template cannot be handled by this template resolver.
*/
public TemplateResolution resolveTemplate(
final IEngineConfiguration configuration,
final String ownerTemplate, final String template,
final Map templateResolutionAttributes);
}
```
Эти объекты отвечают за определение того, как будут доступны шаблоны, и в этом приложении GTVG org.thymeleaf.templateresolver.ServletContextTemplateResolver означает, что мы собираемся извлекать файлы шаблонов в качестве ресурсов из контекста сервлета: на уровне приложения javax.servlet.ServletContext, который существует в каждом веб-приложении Java, и который разрешает ресурсы из корня веб-приложения.
Но это еще не все, что мы можем сказать о распознавателе шаблона, потому что мы можем установить на нем некоторые параметры конфигурации. Во-первых, режим шаблона:
```
templateResolver.setTemplateMode(TemplateMode.HTML);
```
**HTML** — это режим шаблонов по умолчанию для ServletContextTemplateResolver, но это хорошая практика, чтобы установить его в любом случае, чтобы наши документы кода четко указывали, что происходит.
```
templateResolver.setPrefix("/WEB-INF/templates/");
templateResolver.setSuffix(".html");
```
Префикс и суффикс изменяют имена шаблонов, которые мы передадим движку для получения имен реальных ресурсов, которые будут использоваться.
Используя эту конфигурацию, имя шаблона «product/list» будет соответствовать:
```
servletContext.getResourceAsStream("/WEB-INF/templates/product/list.html");
```
Необязательно, но количество времени, в течение которого анализируемый шаблон может проживать в кеше, настраивается в Template Resolver с помощью свойства cacheTTLMs:
```
templateResolver.setCacheTTLMs(3600000L);
```
Шаблон все еще может исчезнуть из кеша до достижения TTL, если достигнут максимальный размер кеша, и это самая старая запись.
Поведение и размеры кэша могут быть определены пользователем путем реализации интерфейса ICacheManager или путем изменения объекта StandardCacheManager для управления кешем по умолчанию.
Можно еще сказать много слов о template resolvers, но давайте вернемся к созданию нашего объекта Template Engine.
**Template Engine**
Объекты Template Engine — это реализация интерфейса org.thymeleaf.ITemplateEngine. Одна из этих реализаций предлагается ядром Thymeleaf: org.thymeleaf.TemplateEngine, и мы создаем его экземпляр:
```
templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
```
Просто, не так ли? Все, что нам нужно, это создать экземпляр и установить для него template resolvers.
Template resolvers является единственным обязательным параметром, требуемым TemplateEngine, хотя есть много других, которые будут рассмотрены позже (message resolvers, размеры кеша и т. Д.). Пока что это все, что нам нужно.
Наш шаблонный модуль теперь готов, и мы можем начать создавать страницы с помощью Thymeleaf.
[Продолжение. Глава 3. Использование Text](https://habrahabr.ru/post/350868/) | https://habr.com/ru/post/350866/ | null | ru | null |
# Radarr, Jackett и бот в телеге. Качаем торренты по-новому
В итоге, конечно, стриминг таки добьёт торренты. И если в 720/1080p мире это, по сути, уже свершилось, то Blue-ray/4k/8k контент пока ещё держится за счёт торрентов (у нас и в Европе) и юзнетов (штаты).
Сегодня стриминг выигрывает, в основном, за счёт удобства. Открыл апп, зашёл в раздел «новинки» и выбирай на любой вкус. Я прокачал свой процесс с торрентами, и теперь он смотрится, как минимум, не хуже.
Radarr следит за моим IMDB вотчлистом и RSS фидами с новыми релизами. Если то, что я хочу посмотреть, уже вышло – Jackett опрашивает мои торрент трекеры, и qBittorent качает нужный релиз. Можно идти заниматься своими делами, как фильм закачается – я получу сообщение от бота в групповой домашний чат. Если фильм ещё не вышел – Радарр будет просматривать RSS новости с трекеров, дождётся, когда фильм выйдет с нужным мне качеством, и скачает его. Когда появится 4к/блюрей релиз – он обновит фильм сам. При этом мой простенький телеграмм бот будет и тут держать меня в курсе событий.
Всё это работает как часы у меня уже полгода, и этим даже пользуются другие члены семьи, имеющие гуманитарное образование => пора делиться лайфхаком с сообществом.
### Немножко о моей домашней платформе
Сердце моей домашней сети – это NAS Synology DS218+ с расширенной до 16 Гб ОЗУ (вот и пригодилась старая ноутбучная память). НАС спокойно тянет пару виртуальных машин, полдюжины контейнеров, домашнее видеонаблюдение, резалку рекламы (pi-hole) и ещё много чего. Это надёжная, тихая и экономная железка, которая работает 24/7 годами, если её не обижать. В отличие от домашнего сервера, у неё есть готовый набор приложений для телефонов.
Всё нижеописанное я настраивал именно на НАСе, но можно, конечно, выбрать и любую другую платформу.
Докер заметно упрощает обслуживание всего хозяйства в долгосрочной перспективе, хотя и требует первоначальных усилий по настройке контейнеров (но тут я вам помогу).
Питон скрипты, которые вы встретите ниже, можно тоже запустить в докере или даже напрямую на НАСе, но убунта у меня уже есть. Буду использовать её.
Пару слов про ВПНы. Если в вашу модель угроз затесались копирасты или любители охранять детей от интернет-свобод, можно попробовать поднять Synology Virtual DSM внутри реального DSM, настроить принудительный VPN и играть с докером в нём. Есть так же докер-контейнеры с OpenVPN для qBittorent/Transmission и Jackett, но вам придётся настраивать их самим.
Docker
------
1. Создаем новую папку /media с подпапками downloads, watch, movies и temp. Тут будут хранится все наши фильмы/закачки и именно её мы будем монтировать внутрь контейнеров. Монтировать её лучше целиком (а не отдельно по подпапкам), т.к. тогда внутренние операции перемещения (например, из temp в downloads) будут гораздо быстрее. Не забудьте настроить NFS шару и дать всем права на чтение/запись.
2. Создаем папку /docker для хранения файлов конфигурации контейнеров.
3. Создаем пользователя “docker” в панели управления Synology и даём ему RW доступ к созданным папкам. Забираем все остальные права к папкам и приложениям. При желании можно, конечно, создавать уникального пользователя для каждого контейнера
4. Соединяемся с NAS по SSH и узнаем uid/gid созданного пользователя
5. Чтобы создать разом все необходимые контейнеры можно воспользоваться моим [docker-compose файлом](https://github.com/ageev/SmartHouse/blob/master/torrents/docker-compose.yaml). Только его нужно вначале подправить под себя – вставить нужные PUID/PGID из предыдущего пункта, подправить пути/порты/часовой пояс по необходимости. Затем присоединиться по SSH, зайти в папку с docker-compose.yml и выполнить `sudo docker-compose up -d`.
Если захотите в будущем контейнеры обновить, достаточно будет остановить их, почистить докер командой `sudo docker system prune -a` и снова выполнить `sudo docker-compose up -d`.
Теперь у нас есть:
* qBittorent с вебмордой на 6004 порту
* Jackett на 6002
* Radarr на 6003
qBittorent
----------
Дабы убрать аутентификацию у веб морды можно добавить вот такие параметры в qbittorent.conf:
```
WebUI\AuthSubnetWhitelist=192.168.1.0/24, 127.0.0.1/32
WebUI\AuthSubnetWhitelistEnabled=true
```
В настройках qBittorent нужно выставить порт для входящих соединений (у меня 6882) и прокинуть его внутрь сети на домашнем роутере. Это нужно для того, чтобы вы могли не только качать торренты, но и их раздавать. Проверить доступность порта снаружи можно [тут](https://www.yougetsignal.com/tools/open-ports/).
Есть десяток разных плагинов, которые позволяют интегрировать qBittorent с вашим десктопным браузером для удобства. Я вот пользуюсь [Torrent control](https://addons.mozilla.org/en-US/firefox/addon/torrent-control/) для FF.
Jackett
-------
Это интегратор ваших торрент трекеров. Общий дашборд, который можно использовать чтобы искать фильмы сразу везде. У Jackett есть REST API, поэтому его удобно интегрировать с Radarr.
Жми “add indexer”, ищи нужный трекер, добавляй в список. Важно для русских трекеров ставить галку “strip Russian letters”. После того, как все нужные трекеры добавлены в Jackett, добавьте их в Radarr с помощью кнопки “Copy torznab feed”.
Jackett удобно пользоваться и вручную. Он ищет раздачи сразу по всем вашим трекерам и отображает только нужную информацию
Radarr
------
Это софт который решает ряд задач:
1. Картотека фильмов, которые вы хотели бы посмотреть. Эту картотеку можно синхронизировать, например, с Watchlist из IMDB так:
* Регистрируем IDMB аккаунт, добавляем что-нибудь в watchlist
* Открываем watchlist через сайт и нажимаем Edit. Копируем ID вашего листа из URL
* Добавляем новый лист в Radarr (settings -> lists)
* List Update Interval можно поставить минут на 10
2. Поиск релизов по NZB/Torrent трекерам.
Для удобства мы будем перенаправлять все поисковые запросы Radarr на Jackett. Открываем в Radarr /settings/indexers, жмем “ADD -> Torznab” и копируем данные из Jackett. Не забудьте выставить минимальное количество сидов, дабы не нарваться на мертвые раздачи
3. Фильтр качества релизов с возможностью перекачивать релизы, если вышел более качественный рип.
Так это выглядит у меня:
То есть Radarr начнет с HDTV рипа и не остановится, пока не дойдет до 4k Remux.
При этом можно (нужно) на вкладке Quality выставить минимальный/максимальный размер релиза, чтобы отфильтровать мусор.
*Оранжевый для фильма 90 минут, голубой – 140 минут*
4. Загрузка фильмов через различные клиенты. Я остановился на qBittorent из-за удобной вебморды.
В целом, Radarr – мощный пакет с огромным функционалом, но оставим пока остальное за рамками этого скромного мануальчика.
Если вам он понравился — знайте: ещё есть Sonarr для телесералов. Они очень похожи.
Telegram бот
------------
В Радарре можно настроить уведомления через Telegram, но конфигурация минимальна. Нельзя, к примеру, добавить в шаблон сообщений размер релиза.
Я написал [небольшой телеграм бот](https://github.com/ageev/SmartHouse) (ботом его назвать можно с натяжкой, ибо это, по большому счету, простой POST запрос), который может говорить с qBittorent и отправлять сообщения в групповой чат Телеграм. Пока что сообщений всего 2 типа: торрент добавлен, торрент скачан. Но за полгода я не придумал ничего нового, что следовало бы добавить.
Nzb360
------
Это платное приложение на телефон для управления всем упомянутым хозяйством: показывает вашу картотеку Radarr, позволяет мониторить очередь qBittorent и добавлять новые закачки через Jackett. Можно легко обойтись и без него, но уж больно с ним удобно. Если дотерпите до чёрной пятницы – автор частенько устраивает распродажу.
Конечно, всё это намного сложнее, чем просто зайти на торрент-трекер и вручную найти нужный фильм. Но со временем привыкаешь к тому, что тебе уже не нужно следить за новыми киношками каждую неделю. Полайкал Матрицу 4 в приложении IMDB и живи себе дальше. Придёт время, и лучший рип будет уже ждать тебя в папке Movies. Жена хочет пересмотреть вечером старое кино? Теперь она может справится с проблемой сама.
Апдейт от мая 2021
-------------------
Радарр 3 не дает обновлять листы IMDB чаще одного раза в 6 часов. Чтобы обойти это ограничение можно добавить вот это в планировщик:
curl -X POST «[localhost](http://localhost):7878/api/v3/command?apikey=dadada» -H «accept: application/json» -d '{«name»:«ImportListSync»}' | https://habr.com/ru/post/505814/ | null | ru | null |
# С 4 часов до 1 минуты. Как найти одну строчку, которая ускорит сервис на Ruby
Как-то раз у нас перестал работать один сервис. Никто давно его не трогал, никто не помнил, кто его написал. Работает - и ладно. Генерировал CSV отчеты для бизнеса в Sidekiq воркере (асинхронно). Проблема стала очевидной то ли от того, что девопсы переехали на Kubernetes, то ли от того, что бизнес просто раньше никогда не генерировал таких больших отчетов. В этот раз сервис должен был «прожевать» 38\_000 заявок, но зависал в 'in\_progress'. Возможно, спустя какое-то время процесс просто убивался кубером, возможно, юзеры сами, не дожидаясь результата, отменяли экспорт и запускали по новой.
Спойлером скажу, что проблема оказалась до смешного мелкой. Но мне показалось интересным поделиться, как я нашел решение.
Метрика
-------
Поняв, что на малом объеме данных отчет генерируется без проблем, я решил замерить, с какой скоростью работает сервис. Для этого достаточно применить стандартный Ruby модуль Benchmark. Положим вот такой файлик в папку 'profilers':
**performance\_evaluation.rb**
```
# frozen_string_literal: true
require 'benchmark'
class PerformanceEvaluation
def self.call(applications_ids, export_id)
puts "Start"
time = Benchmark.realtime do
ApplicationsManagement::Export.new(applications_ids, export_id).call
end
puts "Finish in #{time.round(2)}"
end
end
```
И затем дернем его из консоли:
```
require './profilers/performance_evaluation'
applications_ids = Application.where(id: (1..100)).pluck(:id)
export_id = FactoryBot.create(:export).id
PerformanceEvaluation.call(applications_ids, export_id)
...
Finish in 40.13
=> nil
```
Сотню заявок наш сервис обсчитывал около 40 секунд. А это значит, на наши 38\_000 записей ему потребовалось бы больше 4 часов! Естественно, цифры выглядели просто неприемлемыми.
Профилирование
--------------
Чтобы понять, куда двигаться дальше, подключим гем [ruby-prof](https://ruby-prof.github.io/#installation). Он умеет не только профилировать и искать «узкие места», но и печатать отчеты в разных форматах. Для этой задачи я выбрал формат 'callgrind', и чтобы его читать нам понадобится утилита [qcachegrind](https://brewinstall.org/install-qcachegrind-on-mac-with-brew). Профайлер положим в ту же папку 'profilers':
**time\_profiler.rb**
```
# frozen_string_literal: true
require 'ruby-prof'
class TimeProfiler
def run(applications_ids, export_id)
RubyProf.measure_mode = RubyProf::WALL_TIME
result = RubyProf.profile do
ApplicationsManagement::Export.new(applications_ids, export_id).call
end
printer = RubyProf::CallTreePrinter.new(result)
printer.print(path: 'profilers/ruby_prof_reports', profile: 'callgrind')
end
end
```
Как видно выше, отчеты этот профайлер будет складывать в папку 'profilers/ruby\_prof\_reports/'. Запускаем его также из консоли:
```
require_relative 'profilers/time_profiler'
applications_ids = Application.pluck(:id).last(100)
export_id = FactoryBot.create(:export).id
TimeProfiler.new.run(applications_ids, export_id)
```
Теперь в папке с отчетами появился новый файл **callgrind.callgrind.out.10176**. Если появилось несколько, нам нужен тот, у которого имя покороче. Открываем его из терминала с помощью утилиты qcachegrind:
```
qcachegrind profilers/ruby_prof_reports/callgrind.callgrind.out.10176
```
И видим такое окно:
(Если у вас вид отличается, можете кликнуть Settings -> Sidebars -> Flat Profile). Здесь Я отсортировал данные по колонке self - что значит, сколько времени процесс потратил на свое выполнение. (Колонка Incl. Показывает - сколько времени он потратил на выполнение себя самого и дочерних процессов). Если кликнем по иконке % в верхнем меню, то увидим, что IO::wait\_readable занимает больше 90% выполнения.
Доки Ruby не очень многословны о модуле [IO::WaitReadable](https://ruby-doc.org/core-2.7.0/IO/WaitReadable.html):
'exception to wait for reading. see IO.select.'
Но в целом, что тут еще говорить - ожидание input/output. Вопрос в том, что это ожидание вызывает?
Проверка гипотез
----------------
Первой моей гипотезой было - ожидание записи в CSV файл. Я решил ее проверить, и прогнать через профилировщик не весь сервис, а лишь этот его метод. Профилировщик в этот раз получился таким:
**time\_profiler.rb**
```
# frozen_string_literal: true
require 'ruby-prof'
class TimeProfiler
attr_reader :applications_ids, :file_path, :errors
def initialize(applications_ids)
@applications_ids = applications_ids
@file_path = Tempfile.new(['', '.csv']).to_path
@errors = []
end
def run
RubyProf.measure_mode = RubyProf::WALL_TIME
result = RubyProf.profile do
to_csv_export
end
printer = RubyProf::CallTreePrinter.new(result)
printer.print(path: 'profilers/ruby_prof_reports', profile: 'callgrind')
end
private
def to_csv_export
CSV.open(file_path, 'w') do |csv|
csv << export_headers # массив заголовков отчета почти на 90 элементов
# ActiveRecord::Relation с экспортируемыми заявками
export_collection.find_each do |instance|
begin
# В оригинальном сервисе здесь вызывается
# export_row(instance.decorate) -
# метод, который формировал каждую строку отчета.
# Заменим его на простую выборку атрибутов модели,
# чтобы минимизировать работу, и проверить,
# вызывается ли наш IO::WaitReadable самим процессом записи в CSV
# или вызовом тех самых методов модели для отрисовки отчета
csv << instance.attributes.values
rescue StandardError => e
errors << "#{instance.id}: #{e}"
end
end
end
end
def export_headers # rubocop:disable Metrics/MethodLength
[
'ID',
'Status',
... # Еще почти 90 заголовков
]
end
def export_collection
Application.where(id: applications_ids).includes(
... # увесистый список связанных моделей, опустим для краткости
).order(created_at: :desc)
end
end
```
Новый отчет callgrind вообще не содержал вызова этого модуля.
Попробуем углубиться, и «прощупать» сам метод формирования строки export\_row.
**time\_profiler.rb**
```
# frozen_string_literal: true
require 'ruby-prof'
class TimeProfiler
def run
RubyProf.measure_mode = RubyProf::WALL_TIME
app = Application.last
result = RubyProf.profile do
export_row(app.decorate)
end
printer = RubyProf::CallTreePrinter.new(result)
printer.print(path: 'profilers/ruby_prof_reports', profile: 'callgrind')
end
private
# Data for writing for each application
def export_row(application) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/LineLength
[
application.id,
application.status,
... # Еще около 90 строк
]
end
end
```
А вот и наш модуль. И опять занимает гигантские 80% времени даже при всего одной записи.
Дальше можно по принципу бинарного поиска закомментировать половину вызываемых методов, и проверить, вызывается ли «долгий» модуль или нет. Если нет - проблема в закомментированных строках. Делим их пополам опять и т.д… Довольно быстро я нашел строку, которая вызывала этот модуль:
```
...
application.photo_urls.present? ? 'Yes' : 'No',
...
```
Смотрим в модель Application, что же это за метод такой?
**models/application.rb**
```
# frozen_string_literal: true
class Application
...
def photo_urls
return if Rails.env.test?
s3 = Aws::S3::Resource.new
bucket = s3.bucket('bucket-name')
return [] if guid.nil?
bucket.objects(prefix: "documents/#{guid}")
.reject { |x| x.key.include?('/preview/') }
.map { |o| o.presigned_url(:get) }
end
end
```
Иными словами, чтобы написать в отчете 'yes' или 'no' мы лезли в AWS, и смотрели, есть ли у нас в определенной папочке какие-нибудь фотографии. Заголовок этого столбца в отчете гласил KYC. То есть менеджеры ожидали видеть, прошел ли заявитель процедуру KYC (know-your-customer, кто работает в Fintech, наверняка знает) или еще нет. Я начал спрашивать бизнес, может, выберем другой способ этот признак определить? Например, можно сохранять этот флаг в бд при загрузке фотографий. Выяснилось, что им вообще этот столбец в отчете не нужен.
Я выпилил эту строчку и снова обратился к нашей [метрике](#metric). PerformanceEvaluation показал всего лишь 3 секунды на обработке той же сотни заявок. На больших объемах разница была еще разительней. Отчет, который до этого не могли сгенерировать за 4+ часа, теперь пишется чуть дольше, чем за одну минуту. Виной всему одна строчка, которая вообще-то никому не была нужна.
P.S./Bonus
----------
На самом деле, найти эту проблему можно было и быстрей. Без разбивания сервиса на части и прогона их через профилировщик. Опытные фанаты Qcachegrind наверное заметили, что я не углублялся в его интерфейс, и в целом я далеко не спец по нему. Наверняка его можно использовать и с бОльшим КПД. Например, если кликнуть по любому процессу, а в правой нижней части окна выбрать режим «Call Graph», можно увидеть дерево вызовов - какой модуль каким модулем был вызван.
Дважды кликаем по любому родителю, и дерево «растет» дальше:
Думаю, модуль Net/HTTPResponse мог на правильную догадку подтолкнуть быстрей, и статья закончилась бы раньше. Но мне хотелось показать пример воркфлоу, который легко можно применить на любых проектах. Если кто-то хорошо знает Qcachegrind (да и ruby-prof) или другие полезные инструменты, поделитесь в комментах, как вы их используете и какие полезные фичи можете порекомендовать? | https://habr.com/ru/post/561258/ | null | ru | null |
# Crosswalk Project — замена Android WebView. Проблемы интеграции
В этой статье я закончу свой рассказ о проекте Crosswalk Project (первую часть вы можете найти [здесь](http://habrahabr.ru/post/263649/)). Расскажу более детально о своем опыте интеграции Crosswalk, некоторых тонкостях при работе с ним, встреченных проблемах и их возможных решениях.
Первое и, возможно, самое очевидно решение всех вопросов — это изменение кода Crosswalk под свои нужды. Это возможно, т.к. проект открытый и даже можно помочь его авторам. Однако, нужно это не всегда и может вызвать дополнительные затруднения. В описываемых примерах такой вариант я не рассматриваю, но изучить код базовых классов полезно.
Контроль загрузки страницы в XWalkView.
---------------------------------------
Пожалуй второй наиболее важной вещью в Crosswalk, после скорости его работы, является предсказуемость вызова калбэков. Возможность ориентироваться на логику вызовов и иметь единый алгоритм для всех версий Android — это просто отлично. Сложности же с контролем загрузки в системном WebView хорошо описаны в [этой статье](http://habrahabr.ru/company/mailru/blog/262167/).
Также как и системный класс, XWalkView имеет два вспомогательных класса, которые могут получать вызовы во время загрузки и работы с XWalkView — это XWalkUIClient и XWalkResourceClient. Как я писал ранее, они не имеют прямого соответствия системным WebChromeClient и WebViewClient, методы в них распределены несколько иначе. Однако, для себя я установил примерное соответствие как WebChromeClient == XWalkUIClient и WebViewClient == XWalkResourceClient.
XWalkUIClient в том числе содержит методы:
* onPageLoadStarted — информирует о начале загрузки основного фрэйма.
* onPageLoadStopped — информирует об окончании загрузки основного фрэйма.
а также:
* onConsoleMessage
* onReceivedTitle
* onConsoleMessage
* onRequestFocus
* shouldOverrideKeyEvent
Кака видно, здесь присутствуют методы входящие как в интерфейс WebViewClient, так и WebChromeClient, но, в целом, XWalkUIClient содержит методы имеющие важность для UI.
XWalkResourceClient в том числе содержит:
* onDocumentLoadedInFrame — информирует о том, что HTML документ получен и обработан, вызывается не дожидаясь загрузки css, изображений и т.д. NB! Замечу, что метод описан в Javadoc и реализован в master ветке, но отсутствует сейчас в классе при интеграции.
* onLoadStarted — информирует о том, что началась загрузка ресурса по указанному url.
* onLoadFinished — информирует о том, что завершилась загрузка ресурса по указанному url.
* onProgressChanged — информирует о проценте загрузки страницы.
* shouldInterceptLoadRequest — аналогично системному калбэку, позволяет клиенту вернуть данные для казанного url.
* shouldOverrideUrlLoading — аналогично системному калбэку, позволяет клиенту перехватить контроль перед загрузкой ресурса.
Последовательность вызова основных калбэков выглядит так:
* shouldOverrideUrlLoading — для указанного url;
* onPageLoadStarted;
* shouldInterceptLoadRequest — загрузка основной страницы;
* onLoadStarted — загрузка основной страницы (дублирует shouldInterceptLoadRequest);
* shouldInterceptLoadRequest в паре с onLoadStarted — загрузка ресурсов, для каждого ресурса;
* onPageLoadStopped;
* onLoadFinished.
Данная последовательность будет аналогична как для url загруженного с помощью метода WXalkView, так и для перехода по ссылке на странице и даже при остановке загрузки с помощью stopLoading().
Практически аналогично выглядит последовательность для загрузки страницы с редиректом:
* shouldOverrideUrlLoading — для указанного url;
* onPageLoadStarted;
* shouldInterceptLoadRequest — загрузка основной страницы;
* onLoadStarted — загрузка основной страницы;
* shouldOverrideUrlLoading — для url, указанного в редиректе;
* onPageLoadStarted;
* shouldInterceptLoadRequest в паре с onLoadStarted — загрузка ресурсов;
* onPageLoadStopped;
* onLoadFinished.
Как видно, при переходе по редиректу мы получили дополнительные вызовы тех же стартовых калбэков и, по сути, логика в этом случае тоже не нарушилась.
Дополнительно можно указать, что метод onPageLoadStopped имеет следующую сигнатуру:
```
onPageLoadStopped(XWalkView view, java.lang.String url, XWalkUIClient.LoadStatus status);
```
Дополнительный параметр типа XWalkUIClient.LoadStatus дает достаточно важную информацию о том, как закончилась загрузка и имеет 3 варианта:
* CANCELLED — в случае вызова stopLoading();
* FAILED — в случае ошибки загрузки;
* FINISHED — нормальное завершение загрузки.
Необошлось и без пары странностей в поведении Crosswalk. Например, метод onLoadFinished вызывается только один раз после загрузки всей страницы и даже после onPageLoadStopped. Логика предполагает, что вызов onLoadFinished должен соответствовать вызову onLoadStarted, который происходит для каждого ресурса, но сейчас это не так.
Также возможна ситуация когда произойдет двукратный вызов пары финальных методов onPageLoadStopped и onLoadFinished. Упоминание о [таком поведении](http://comments.gmane.org/gmane.comp.web.crosswalk.help/1009) я нашел еще для Crosswalk 11ой версии, но очевидно с этой проблемой не справились до сих пор.
Обработка событий от экрана и кнопок.
-------------------------------------
Одной из первых проблем с которой вы столкнетесь при интеграции XWalkView будет обработка событий экрана и клавиатуры (конкретно кнопки Back). В XWalkView, также как и методы onActivityResult и onNewIntent, реализован метод: dispatchKeyEvent(KeyEvent event). В нем происходит перехват события от кнопки Back для перехода из полноэкранного режима и перехода по истории браузера. Соответственно вы не сможете получить это событие, если вы используете методы:
```
public boolean onKeyUp(int keyCode, KeyEvent event);
public void onBackPressed();
```
Вариантом решения может быть обработка этого события также в dispatchKeyEvent(KeyEvent event). Это также полезно знать, если вы хотите реализовать собственный переход по истории навигации.
Аналогичная проблема ожидает вас, если вы хотите использовать onTouchEvent listener для вашего XWalkView. Решение аналогично приведенному выше — реализуйте обработку события в dispatchTouchEvent(MotionEvent event).
Примеры добавлены в тестовый проект, доступный в [GitHub](https://github.com/yaroslav-v/crosswalk-embedded).
Работа с хранилищем cookie.
---------------------------
Важным моментом в работе браузера и WebView является обработка cookies. Например, вы хотите загрузить какую-то страницу не через XWalkView, но отобразить ее в нем и предоставить пользователю возможность с ней работать. Страница может устанавливать свои cookies и для нормальной работы они понадобятся в XWalkView.
В Crosswalk существует специальный компонент [XWalkCookieManager](https://github.com/crosswalk-project/crosswalk/blob/master/runtime/android/core_internal/src/org/xwalk/core/internal/XWalkCookieManagerInternal.java), который собственно и занимается хранением и работой с cookies. Очень странно, но он не описан в Javadoc, хотя и является публичным и доступным для использования. Реализацию и комментарии к методам класса можно найти здесь.
XWalkCookieManager, как и кэш Crosswalk, един для всех инстансов XWalkView в вашем приложении. Класс достаточно прост в использовании и позволяет добавлять и получать cookie для определенного адреса, очистить хранилище и пр. Пример инициализации:
```
mXCookieManager = new XWalkCookieManager();
mXCookieManager.setAcceptCookie(true);
mXCookieManager.setAcceptFileSchemeCookies(true);
```
Однако простота его реализации имеет и некоторые проблемы. Например, метод для установки cookie выглядит так:
```
public void setCookie(String url, String value);
```
Соответсвенно вы не сможете указать время жизни для cookie, а domain и path для cookie будут получены из указанного url, но с некоторыми неприятными нюансами.
Например, вы хотите установить cookie для адреса [m.vk.com](https://m.vk.com) и предполагаете, что установленная cookie будет действительна и для адреса [login.vk.com](https://login.vk.com), но в нашем случае это не так. Для того, чтобы XWalkCookieManager адекватно отработал этот момент необходимо устанавливать cookie для адреса [.vk.com](http://.vk.com).
Также заявлено, что XWalkCookieManager должен обновить cookie, если вы устанавливаете уже имеющуюся в хранилище, но я наблюдал, что иногда он дублирует значения. Очевидно какие-то проблемы в разборе value при установке. Поэтому стоит лишний раз проверить корректность работы этого классы, если вы пользуетесь им.
В качестве простого примера работы с XWalkCookieManager, в тестовом проекте реализован метод синхронизации с CookieManager.
Получение WebSettings и их установка.
-------------------------------------
Как я уже писал ранее, WebSettings не доступны при работе с XWalkView и имеют заранее предустановленные параметры. Точнее в Crosswalk имеется аналог этого класса — [XWalkSettings](https://github.com/crosswalk-project/crosswalk/blob/master/runtime/android/core_internal/src/org/xwalk/core/internal/XWalkSettings.java), его методы вы можете изучить здесь. Для некоторых параметров было сделано исключение и они вынесены в интерфейс самого класса XWalkView. Например, сейчас вы можете установить нужный вам User-Agent.
Однако, может возникнуть необходимость более тонкой настройки. Также может возникнуть необходимость, как в моем случае, получить User-Agent, используемый самим XWalkView. В таком случае можно воспользоваться возможностью получить его через reflection.
Собственно сам класс XWalkView является надстройкой над реализацией [XWalkViewInternal](https://github.com/crosswalk-project/crosswalk/blob/master/runtime/android/core_internal/src/org/xwalk/core/internal/XWalkViewInternal.java) и соединяется с ней посредством bridge через reflection. XWalkViewInternal же имеет публичный метод getSettings(), что мы и можем использовать:
```
Method ___getBridge = XWalkView.class.getDeclaredMethod("getBridge");
___getBridge.setAccessible(true);
XWalkViewBridge xWalkViewBridge = null;
xWalkViewBridge = (XWalkViewBridge) ___getBridge.invoke(webView);
XWalkSettings xWalkSettings = xWalkViewBridge.getSettings();
```
В качестве примера получения XWalkSettings и работы с ним, в тестовом проекте реализован метод получения User-Agent.
Получение изображения XWalkView.
--------------------------------
Поскольку XWalkView использует для отрисовки SurfaceView или TextureView, то нет возможности получить его изображение стандартными методами. Например, такой вариант работает для системного WebView, но не работает для XWalkView:
```
View view = mWebView.getRootView();
view.setDrawingCacheEnabled(true);
Bitmap b = Bitmap.createBitmap(view.getDrawingCache());
view.setDrawingCacheEnabled(false);
```
Происходит это т.к. стандартные методы view, типа getDrawingCache() или draw(), работают с software layer, а в XWalkView используется hardware layer. Именно поэтому разработчики просят установить флаг android:hardwareAccelerated=«true» для приложений использующих Crosswalk. К слову, сейчас он устанавливается по дефолту и отдельно его прописывать нет необходимости.
Получить изображение XWalkView возможно при использовании в качестве основы TextureView, где имеется метод getBitmap(). В кратце, для этого необходимо найти в дереве целевой TextureView и уже у него вызвать этот метод. Пример реализации также доступен в тестовом проекте.
Мелкие нюансы.
--------------
В довесок несколько мелких моментов, которые вам также могут встретиться в процессе интеграции:
* Если вы заменяете системный WebView в старом проекте и используете аннотацию JavascriptInterface, не забудьте исправить импорт. Иначе получите ошибки во время выполнения JavaScript кода. Соответственно:
```
import android.webkit.JavascriptInterface; // remove
import org.xwalk.core.JavascriptInterface; // add
```
* Если вы используете несколько XWalkView, используете его во фрагментах или в каких-то других, более сложных чем в примере, условиях. В этом случае может возникнуть ситуация когда необходимо будет прямо вызывать методы для пробуждения таймеров XWalkView, после возобновления работы с ним:
```
public void resumeTimers();
public void onShow();
```
Выводы
------
Использовать Crosswalk в разработке достаточно просто и удобно, особенно учитывая открытый исходный код. Неплохое комьюнити и достаточно большое распространение проекта позволят решить большинство проблем.
Если вы поддерживаете Android 4.0+ и хотите более предсказуемой работы вашего кода на всех версиях Android, то я определенно рекомендую Crosswalk.
Если же вы поддерживаете Android с версии 4.4 и тем более 5.0, то я бы задумался о применении Crosswalk в своих проектах. Отсутствие некоторых новых возможностей системного WebView может осложнить вам жизнь.
Надеюсь мой опыт поможет вам определиться, что же использовать в качестве WebView для вашего проекта :). | https://habr.com/ru/post/263655/ | null | ru | null |
# Процесс компиляции программ на C++
Цель данной статьи:
-------------------
В данной статье я хочу рассказать о том, как происходит компиляция программ, написанных на языке **C++**, и описать каждый этап компиляции. Я не преследую цель рассказать обо всем подробно в деталях, а только дать общее видение. Также данная статья — это необходимое введение перед следующей статьей про статические и динамические библиотеки, так как процесс компиляции крайне важен для понимания перед дальнейшим повествованием о библиотеках.
Все действия будут производиться на **Ubuntu** версии **16.04**.
Используя компилятор **g++** версии:
```
$ g++ --version
g++ (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609
```
### Состав компилятора g++
* **cpp** — препроцессор
* **as** — ассемблер
* **g++** — сам компилятор
* **ld** — линкер
Мы не будем вызывать данные компоненты напрямую, так как для того, чтобы работать с C++ кодом, требуются дополнительные библиотеки, позволив все необходимые подгрузки делать основному компоненту компилятора — **g++**.
### Зачем нужно компилировать исходные файлы?
**Исходный C++ файл** — это всего лишь код, но его невозможно запустить как программу или использовать как библиотеку. Поэтому каждый исходный файл требуется скомпилировать в исполняемый файл, динамическую или статическую библиотеки (данные библиотеки будут рассмотрены в следующей статье).
Этапы компиляции:
-----------------
Перед тем, как приступать, давайте создадим исходный .cpp файл, с которым и будем работать в дальнейшем.
**driver.cpp**:
```
#include
using namespace std;
#define RETURN return 0
int main() {
cout << "Hello, world!" << endl;
RETURN;
}
```
### 1) Препроцессинг
Самая первая стадия компиляции программы.
**Препроцессор** — это *макро процессор*, который преобразовывает вашу программу для дальнейшего компилирования. На данной стадии происходит происходит работа с препроцессорными директивами. Например, препроцессор добавляет хэдеры в код (**#include**), убирает комментирования, заменяет макросы (**#define**) их значениями, выбирает нужные куски кода в соответствии с условиями **#if**, **#ifdef** и **#ifndef**.
Хэдеры, включенные в программу с помощью директивы **#include**, рекурсивно проходят стадию препроцессинга и включаются в выпускаемый файл. Однако, каждый хэдер может быть открыт во время препроцессинга несколько раз, поэтому, обычно, используются специальные препроцессорные директивы, предохраняющие от циклической зависимости.
Получим препроцессированный код в выходной файл **driver.ii** (прошедшие через стадию препроцессинга C++ файлы имеют расширение **.ii**), используя флаг **-E**, который сообщает компилятору, что компилировать (об этом далее) файл не нужно, а только провести его препроцессинг:
```
g++ -E driver.cpp -o driver.ii
```
Взглянув на тело функции *main* в новом сгенерированном файле, можно заметить, что макрос RETURN был заменен:
```
int main() {
cout << "Hello, world!" << endl;
return 0;
}
```
[driver.ii](https://pastebin.com/7EDJTPKK)
В новом сгенерированном файле также можно увидеть огромное количество новых строк, это различные библиотеки и хэдер iostream.
### 2) Компиляция
На данном шаге g++ выполняет свою главную задачу — компилирует, то есть преобразует полученный на прошлом шаге код без директив в *ассемблерный код*. Это промежуточный шаг между высокоуровневым языком и машинным (бинарным) кодом.
**Ассемблерный код** — это доступное для понимания человеком представление машинного кода.
Используя флаг **-S**, который сообщает компилятору остановиться после стадии компиляции, получим ассемблерный код в выходном файле **driver.s**:
```
$ g++ -S driver.ii -o driver.s
```
**driver.s**
```
.file "driver.cpp"
.local _ZStL8__ioinit
.comm _ZStL8__ioinit,1,1
.section .rodata
.LC0:
.string "Hello, world!"
.text
.globl main
.type main, @function
main:
.LFB1021:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $.LC0, %esi
movl $_ZSt4cout, %edi
call _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl $_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, %esi
movq %rax, %rdi
call _ZNSolsEPFRSoS_E
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE1021:
.size main, .-main
.type _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB1030:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $16, %rsp
movl %edi, -4(%rbp)
movl %esi, -8(%rbp)
cmpl $1, -4(%rbp)
jne .L5
cmpl $65535, -8(%rbp)
jne .L5
movl $_ZStL8__ioinit, %edi
call _ZNSt8ios_base4InitC1Ev
movl $__dso_handle, %edx
movl $_ZStL8__ioinit, %esi
movl $_ZNSt8ios_base4InitD1Ev, %edi
call __cxa_atexit
.L5:
nop
leave
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE1030:
.size _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
.type _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
.LFB1031:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $65535, %esi
movl $1, %edi
call _Z41__static_initialization_and_destruction_0ii
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE1031:
.size _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
.section .init_array,"aw"
.align 8
.quad _GLOBAL__sub_I_main
.hidden __dso_handle
.ident "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609"
.section .note.GNU-stack,"",@progbits
```
Мы можем все также посмотреть и прочесть полученный результат. Но для того, чтобы машина поняла наш код, требуется преобразовать его в машинный код, который мы и получим на следующем шаге.
### 3) Ассемблирование
Так как x86 процессоры исполняют команды на бинарном коде, необходимо перевести ассемблерный код в машинный с помощью **ассемблера**.
Ассемблер преобразовывает ассемблерный код в машинный код, сохраняя его в *объектном файле*.
**Объектный файл** — это созданный ассемблером промежуточный файл, хранящий кусок машинного кода. Этот кусок машинного кода, который еще не был связан вместе с другими кусками машинного кода в конечную выполняемую программу, называется *объектным кодом*.
Далее возможно сохранение данного объектного кода в *статические библиотеки* для того, чтобы не компилировать данный код снова.
Получим машинный код с помощью ассемблера (**as**) в выходной объектный файл **driver.o**:
```
$ as driver.s -o driver.o
```
Но на данном шаге еще ничего не закончено, ведь объектных файлов может быть много и нужно их всех соединить в единый исполняемый файл с помощью компоновщика (линкера). Поэтому мы переходим к следующей стадии.
### 4) Компоновка
**Компоновщик (линкер)** связывает все объектные файлы и статические библиотеки в единый исполняемый файл, который мы и сможем запустить в дальнейшем. Для того, чтобы понять как происходит связка, следует рассказать о *таблице символов*.
**Таблица символов** — это структура данных, создаваемая самим компилятором и хранящаяся в самих объектных файлах. Таблица символов хранит имена переменных, функций, классов, объектов и т.д., где каждому идентификатору (символу) соотносится его тип, область видимости. Также таблица символов хранит адреса ссылок на данные и процедуры в других объектных файлах.
Именно с помощью таблицы символов и хранящихся в них ссылок линкер будет способен в дальнейшем построить связи между данными среди множества других объектных файлов и создать единый исполняемый файл из них.
Получим исполняемый файл **driver**:
```
$ g++ driver.o -o driver // также тут можно добавить и другие объектные файлы и библиотеки
```
### 5) Загрузка
Последний этап, который предстоит пройти нашей программе — вызвать загрузчик для загрузки нашей программы в память. На данной стадии также возможна подгрузка *динамических библиотек*.
Запустим нашу программу:
```
$ ./driver
// Hello, world!
```
Заключение
----------
В данной статье были рассмотрены основы процесса компиляции, понимание которых будет довольно полезно каждому начинающему программисту. В скором времени будет опубликована вторая статья про статические и динамические библиотеки. | https://habr.com/ru/post/478124/ | null | ru | null |
# Перевод Django Documentation: Models. Part 1
Доброго времени суток!
Данный топик представляет собой первую часть перевода [документации Django](http://docs.djangoproject.com/en/dev/), а именно раздела о [моделях](http://docs.djangoproject.com/en/dev/topics/db/models/). Сразу хочу сказать, что я не являюсь профессиональным переводчиком и изначально делал перевод для себя. Все замечания и вопросы просьба писать в комментариях или посылать по хабрапочте. Надеюсь, информация окажется полезной для вас.
\_Модели
\_\_\_Небольшой пример
\_\_\_Использование моделей
\_\_\_Поля
\_\_\_\_\_Типы полей
\_\_\_\_\_Параметры полей
\_\_\_\_\_Автоматические первичные ключи
\_\_\_\_\_Подробные имена полей
[Перевод Django Documentation: Models. Part 2](http://habrahabr.ru/blogs/django/74967/)
[Перевод Django Documentation: Models. Part 3](http://habrahabr.ru/blogs/django/75272/)
[Перевод Django Documentation: Models. Part 4 (Last)](http://habrahabr.ru/blogs/django/80030/)
*Данный документ относится к Django's SVN релизу, который может значительно отличаться от предыдущих. Старая документация (для Django 1.0) доступна [здесь](http://docs.djangoproject.com/en/1.0/topics/db/models/)*
Модели
------
Модель является единственным и окончательным источником сведений о ваших данных. Она описывает поведение данных, которые вы храните, и содержит их основные поля. Как правило, каждая модель является представлением одной из таблиц базы данных.
Основные сведения:
* Каждая модель — это класс, являющийся подклассом [django.db.models.Model](http://docs.djangбыть заданoproject.com/en/dev/ref/models/instances/#django.db.models.Model).
* Каждый атрибут модели представляет отдельное поле базы данных.
* С помощью моделей Django фактически предоставляет вам автоматически-генерируемый API доступа к базе данных (см. [создание запросов](http://docs.djangoproject.com/en/dev/topics/db/queries/#topics-db-queries)).
Дополнением к данному документу является [официальное хранилище примеров использования моделей](http://www.djangoproject.com/documentation/models/) (Так же вы можете найти эти примеры в дистрибутиве Django в директории *tests/modeltests*).
**Небольшой пример**
В данном примере определяется класс *Person*, содержащий поля *first\_name* и *last\_name*:
> `Copy Source | Copy HTML
> from django.db import models
>
> class Person(models.Model):
> first\_name = models.CharField(max\_length=30)
> last\_name = models.CharField(max\_length=30)`
*first\_name* и *last\_name* являются полями нашей модели. Каждое поле определяет атрибут класса, а каждый атрибут в свою очередь представляет собой колонку базы данных.
Вышеприведенный класс *Person* создаст таблицу базу данных примерно такого вида:
> `Copy Source | Copy HTML
> **CREATE TABLE** myapp\_person (
> "id" serial **NOT NULL PRIMARY KEY**,
> "first\_name" varchar(30) **NOT NULL**,
> "last\_name" varchar(30) **NOT NULL**
> );`
Некоторые технические замечания:
* Имя таблицы, *myapp\_person*, автоматически получено из метаданных нашей модели, однакобыть задан оно может быть переопределено (см. [имена таблиц](http://docs.djangoproject.com/en/dev/ref/models/options/#table-names)).
* Поле *id* добавлено автоматически, но вы можете изменить это поведение.
* В нашем примере используется синтаксис SQL, отвечающий PostgreSQL, однако, стоит отметить, что Django использует SQL с учетом базы данных, указанной в вашем [файле настроек](http://docs.djangoproject.com/en/dev/topics/settings/#topics-settings).
**Использование моделей**
Как только вы определили ваши модели, вы должны сообщить Django, что собираетесь использовать их. Делается это с помощью изменения вашего файла настроек, а именно редактирования *INSTALLED\_APPS*, в который нужно добавить имя вашего модуля, содержащего *models.py*.
Например, если модели вашего приложения находятся в модуле *mysite.myapp.models* (данная структура создается после выполнения сценария *manage.py startapp*), нужная нам часть *INSTALLED\_APPS* должна выглядеть так:
> `Copy Source | Copy HTML
> INSTALLED\_APPS = (
> #...
> 'mysite.myapp',
> #...
> )`
После редактирования *INSTALLED\_APPS* не забудьте запустить сценарий *syncdb*.
**Поля**
Наиболее важной и едиhttp://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.\_\_unicode\_\_
нственно необходимой частью любой модели является список полей базы данных, которые она определяет. Поля задаются атрибутами класса.
Например:http://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.\_\_unicode\_\_
> `Copy Source | Copy HTML
> class Musician(models.Model):
> first\_name = models.CharField(max\_length=50)
> last\_name = models.CharField(max\_length=50)
> instrument = models.CharField(max\_length=100)
>
> class Album(models.Model):
> artist = models.ForeignKey(Musician)
> name = models.CharField(max\_length=100)
> release\_date = models.DateField()
> num\_stars = models.IntegerField()`
##### Типы полей
Каждое поле вашей модели должно быть экземпляром соответствующего класса *Field*. Django использует типы класса Field для определения нескольких вещей:
* Тип колонки базы данных (например, *INTEGER, VARCHAR*).
* Виджет для использования интерфейса администратора в Django, если вы хотите его использовать (например, *input type=«text»>*).
* Минимальные требования к проверке, используемой в интерфейсе администраhttp://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.\_\_unicode\_\_тора Django и автоматически-генерируемых формах.
Django поставляется с десятками встроенных типов; вы можете посмотреть полный список в [справке по полям моделей](http://docs.djangoproject.com/en/dev/ref/models/fields/#model-field-types). Так же вы можете создавать [собственные типы полей](http://docs.djangoproject.com/en/dev/howto/custom-model-fields/#howto-custom-model-fields).
##### Параметры полей
Каждое поле имеет определенный набор характерных аргументов, документированных в [справке по полям моделей](http://docs.djangoproject.com/en/dev/ref/models/fields/#model-field-types). Например, *CharField* (и его подклассы) требует аргумент *max\_length*, который определяет размер поля базы данных *VARCHAR*, используемый для хранения ваших данных.
[docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.\_\_unicode\_\_](http://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.__unicode__)
Существует также набор общих аргументов, которые доступны для всех типов полей. Все они являются необязательными. Полное описание предоставлено в [справке](http://docs.djangoproject.com/en/dev/ref/models/fields/#common-model-field-options), однако небольшой обзор наиболее часто-используемых мы приведем здесь:
[null](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.null)
> Если значение аргумента *True*, Django будет сохранять пустые значения в базе данных как *NULL*. По умолчанию *False*.
[blank](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.blank)
> Если значение аргумента *True*, то поле может быть пустым. По умолчанию *False*.
>
>
>
> Заметим, что *blank* отличается *null*. Аргумент *null* относится только к базам данных, а *blank* в свою очередь отвечает за проверку ввода. Если поле имеет аргумент *blank* со значением *TRUE*, то проверка в [docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.defaultинтерфейсе](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.defaultинтерфейсе) администратора Django будет допускать ввод пустого значения. Если же значение атрибута — *False*, поле будетhttp://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.default обязательным для заполнения.
[choices](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.choices)
> Итератор (например, список или кортеж), состоящий из нескольких пар значений, используемых как варианты выбора для данного поля. Если аргумент определен, интерфейс администратора Django будет использовать выпадающий список вместо обычного поля для ввода и ограничит варианты выбора теми, которые заданы.
>
>
>
> Список вариантов выбора выглядит примерно так:
>
>
> > `a href="http://s-c.me/3744/s">Copy Source | Copy HTML
> > YEAR_IN_SCHOOL_CHOICES = (
> > (u'FR', u'Freshman'),
> > (u'SO', u'Sophomore'),
> > (u'JR', u'Junior'),
> > (u'SR', u'Senior'),
> > (u'GR', u'Graduate'),
> > )`
>
>
Первым элементом в каждом кортеже является значение, которое будет занесено в базу данных, второе будет отображено в интерфейсе администратора или в *ModelChoiceField*. При использовании экземпляра объекта модели, вывод значений *choices* для поля может быть осуществлен с помощью метода *get\_FOO\_display*. Например:
> `Copy Source | Copy HTML
> from django.db import models
>
> class Person(models.Model):
> GENDER\_CHOICES = (
> (u'M', u'Male'),
> (u'F', u'Female'),
> )
> name = models.CharField(max\_length=60)
> gender = models.CharField(max\_length=2, choices=GENDER\_CHOICES)`
> `Copy Source | Copy HTML
> >>> p = Person(name="Fred Flinstone", gender="M")
> >>> p.save()
> >>> p.gender
> u'M'
> >>> p.get\_gender\_display()
> u'Male'`
[default](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.default)
> Значение данного аргумента является значением поля по умолчанию или вызываемый объект (в этом случае вызываемый объект будет вызываться каждый раз при создании нового объекта).
[help\_text](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.help_text)
> Значение данного аргумента — текст (дополнительная «помощь»), который будет отображаться в интерфейсе администратора в форме объектов после данного поля. Это полезно для документирования, если ваш объект не имеет формы администратора.
[primary\_key](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.primary_key)
> Если значение аргумента *True*, поле будет являться первичным ключом для модели.
>
>
>
> Если вы не определите [primary\_key=True](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.primary_key) ни для одной из полей вашей модели, Django автоматически добавит [IntegerField](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.IntegerField), чтобы модель имела первичный ключ, поэтому вы можете устанавливать значение *primary\_key=True* для какого-либо поля, только если хотите переопределить стандартное поведение при создании первичного ключа.
[unique](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.unique)
> Если значение аргумента *True*, поле должно быть уникальным во всей таблице базы данных.
Напомним, выше приведено лишь краткое описание часто-используемых аргументов полей. Более детально изучить их вы можете [здесь](http://docs.djangoproject.com/en/dev/ref/models/fields/#common-model-field-options).
##### Автоматические первичные ключи
По умолчанию Django добавляет каждой модели такое поле:
> `Copy Source | Copy HTML
> id = models.AutoField(primary\_key=True)`
Это автоинкрементный первичный ключ.
Если вы хотите создать свой первичный ключ, просто определите атрибут *primary\_key=True* в одном из ваших полей. Если Django увидит, что вы однозначно задали [Field.primary\_key](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.primary_key), то колонка *id* добавлена не будет.
Каждая модель должна иметь одно и только одно поле с [primary\_key=True](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.primary_key).
##### Подробные имена полей
Каждый тип поля, кроме [ForeignKey](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ForeignKey), [ManyToManyField](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ManyToManyField) и [OneToOneField](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.OneToOneField), содержит необязательный первый аргумент — подробное имя (verbose name). Если этот аргумент не задан, Django автоматически создаст его, используя имена атрибутов поля, преобразовывая нижние подчеркивания в пробелы.
В данном примере, подробное имя будет *«Person's first name»*:
> `Copy Source | Copy HTML
> first\_name = models.CharField("Person's first name", max\_length=30)`
В данном примере, подробное имя будет *«first name»*:
> `Copy Source | Copy HTML
> first\_name = models.CharField(max\_length=30)`
[ForeignKey](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ForeignKey), [ManyToManyField](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ManyToManyField) и [OneToOneField](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.OneToOneField) требуют, чтобы первым аргументом была модель, поэтому с ними используется аргумент [verbose\_name](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.verbose_name):
> `Copy Source | Copy HTML
> poll = models.ForeignKey(Poll, verbose\_name="the related poll")
> sites = models.ManyToManyField(Site, verbose\_name="list of sites")
> place = models.OneToOneField(Place, verbose\_name="related place")`
Не принято задавать значение [verbose\_name](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.Field.verbose_name) с большой буквы. Django автоматически переведет первый символ в верхний регистр, когда это потребуется.
Вот и все :) **to be continued**
[Перевод Django Documentation: Models. Part 2](http://habrahabr.ru/blogs/django/74967/)
[Перевод Django Documentation: Models. Part 3](http://habrahabr.ru/blogs/django/75272/)
[Перевод Django Documentation: Models. Part 4 (Last)](http://habrahabr.ru/blogs/django/80030/) | https://habr.com/ru/post/74856/ | null | ru | null |
# Много анонимности не бывает — скрываем User-Agent
Очередной приступ паранойи был вполне обоснован — он наступил после прочтения [статьи о методах анонимности в сети](http://habrahabr.ru/post/203680/), где автор на примере браузера FireFox рассказывал о потенциальных утечках идентификационной информации. И стало интересно — а на сколько озвученные решения применимы, скажем, к браузеру **Google Chrome**?
Скрыть реальный IP — используем разные VPN сервера, отключить львиную долю отслеживающих скриптов — [Adblock Plus](https://chrome.google.com/webstore/detail/adblock-plus/cfhdojbkjhnklbpkdaibdccddilifddb) и [Ghostery](https://chrome.google.com/webstore/detail/ghostery/mlomiejdfkolichcflejclcbmpeaniij)[,](http://blog.kplus.pro/) убрать Referer — [не вопрос](https://chrome.google.com/webstore/detail/referer-control/hnkcfpcejkafcihlgbojoidoihckciin), что то ещё забыли… Ах да — User-Agent — своеобразный «отпечаток», по которому (в связке, скажем, с IP) легко идентифицировать пользователя. И с этим надо было что-то делать. Найденные решения лишь статично изменяли значение User-Agent, чего было явно недостаточно. Тогда и было решено написать плагин для скрытия реального User-Agent'a, а если быть точнее — подменять его на рандомный. Или почти рандомный.
Для нетерпеливых сразу: [исходники на GitHub](https://github.com/tarampampam/random-user-agent) и расширение в [Google Webstore](https://chrome.google.com/webstore/detail/random-hide-user-agent/einpaelgookohagofgnnkcfjbkkgepnp).
#### Немного теории
Вообще, User-Agent (далее по тексту — **UA**) — штука нужная. Нужная в первую очередь для корректного отображения страниц, ведь нам всем известно — разные версии разных браузеров по разному рендерят странички, и заботливые web-программисты учитывают этот факт, выдавая нужным браузерам нужным скрипты и стили. Разнится поддержка доступных технологий «движками». Отсюда вытекает первое требование к итогу — возможность «имитировать» различные браузеры, и что самое важное — иметь возможность **выбора** между ними.
UA — это в первую очередь набор. Набор различных идентификаторов, по которым и происходит определение — какой браузер, какая операционная система, какой версии, и какое специфичное ПО (привет, IE) стоит у пользователя.
Почему именно IP и UA надо скрывать в первую очередь? А давайте посмотрим на лог пустого сайта-заглушки, на котором вообще ничего нет:
```
[meow@hosting /var/log]$ cat somesite.org.access_log | tail -3
10.12.11.254 - - [25/Jul/2014:15:51:16 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (compatible; MJ12bot/v1.4.5; http://www.majestic12.co.uk/bot.php?+)"
10.12.11.254 - - [25/Jul/2014:15:57:38 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)"
10.12.11.254 - - [25/Jul/2014:19:19:25 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:30.0) Gecko/20100101 Firefox/30.0"
```
На сайте ничего нет, а я знаю о посетителе более чем достаточно. Всё потому что «логи знают всё» ©.
#### Немного практики
Итак, решено — подставляем фейковый UA. Но как его сформировать? Я пошел по пути собирания с десятка UA каждого интересующего браузера, и написания регулярки для каждого, которая будет генерировать **максимально правдоподобный** и в то же время а какой-то мере уникальный отпечаток. Хотите пример? Вот вам 10 UA браузера «IE 9», и среди них пять настоящих. Сможете отличить?
```
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; chromeframe/12.0.742.112)
Mozilla/5.0 (Windows; U; MSIE 9.0; Windows NT 6.0; Win64; x64; Trident/5.0; .NET CLR 3.8.50799; Media Center PC 6.0; .NET4.0E)
Mozilla/5.0 (Windows; U; MSIE 9.0; Windows NT 8.1; Trident/5.0; .NET4.0E; en-AU)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 2.0.50727; Media Center PC 6.0)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 8.0; WOW64; Trident/5.0; .NET CLR 2.7.40781; .NET4.0E; en-SG)
Mozilla/5.0 (Windows; U; MSIE 9.0; Windows NT 8.0; Win64; x64; Trident/5.0; .NET4.0E; en)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 2.0.50727; Media Center PC 6.0)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0; .NET CLR 2.0.50727; SLCC2; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; Zune 4.0; Tablet PC 2.0; InfoPath.3; .NET4.0C; .NET4.0E)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 7.0; Trident/5.0; .NET CLR 2.2.50767; Zune 4.2; .NET4.0E)
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0
```
Да, это возможно, но для это нужно анализировать. Анализировать, например, какие .net могут стоять на каких ОС, анализировать версии и сочетания, нюансы. Когда они теряются в куче — задача становиться мало тривиальной. Кому интересно как выглядят регулярки — добро [пожаловать по этой ссылке](https://github.com/tarampampam/random-user-agent/blob/master/background.js). Дня генерации использовал [randexp.js](http://github.com/fent/randexp.js) (за подсказку спасибо хабрачуваку под ником [barkalov](https://habrahabr.ru/users/barkalov/)).
Вообще расширение успешно выдает себя за следующие браузеры:
* IE с 6 по 10;
* Chrome (Win / Mac / Linux);
* Firefox (Win / Mac / Linux);
* Safari (Win / Mac / Linux);
* Opera (Win / Mac / Linux);
* iPad и iPhone.
Что ещё интересного? **Автоматизация**. Отмечаешь галочками какие браузеры мы имитируем, ставишь галочку «Обновлять автоматически», указываешь интервал времени, и забываешь. Ничего лишнего. Для любопытных — посмотрите в консоли «фоновую страницу» — там всё не плохо залогировано.
Открытые исходники. Если есть желание допилить под себя, всё что необходимо, это:
1. Открыть ссылку расширения на гитхабе;
2. Нажать «Download Zip» или склонировать;
3. На странице расширений поставить чекбокс «Режим разработчика»;
4. Нажать «Загрузить распакованное расширение...» и указать путь к распакованному архиву или клону;
Буду очень признателен конструктивной критике и предложениям.
Лучше один раз увидеть: [**Google Webstore**](https://chrome.google.com/webstore/detail/random-hide-user-agent/einpaelgookohagofgnnkcfjbkkgepnp)
##### История изменений
* 1.5 — Добавлены исключения, теперь модно некоторые URL-ы добавить в «белый список», и для них ничего не будет подменяться
###### Хорошие ссылки:
* [Очень хорошее решение по локазизации расширения](http://codethug.com/2013/02/08/clean-markup-with-chrome-extension-i18n/)
* [Исходники на GitHub](http://github.com/tarampampam/random-user-agent)
* [Страница «randexp.js» на GitHub](http://github.com/fent/randexp.js)
* [Викистатья о UserAgent](http://ru.wikipedia.org/wiki/User_Agent) | https://habr.com/ru/post/231107/ | null | ru | null |
# Критический путь рендеринга веб-страниц
В среде веб-разработчиков все больше распространяется знание о том, что скорость важна. Многие стараются ускориться: используют сжатие gzip, минификацию, кеширующие заголовки, сокращение запросов, оптимизацию картинок и другие.
После выполнения этих рекомендаций возникает вопрос: а что именно мы оптимизируем? Оказывается, что в большинстве случаев это время полной загрузки страницы со всеми элементами. Однако, это не совсем то, что нужно. На самом деле важно время, за которое пользователь получает «первый экран» страницы с важными функциональными элементами (заголовок, текст, описание товара и т.д.) Другими словами, важен момент начала рендеринга страницы. Здесь и возникает критический путь рендеринга, который определяет все действия, которые должен выполнить браузер для начала отрисовки страницы. С этой штукой мы и будем разбираться в статье.
Что такое критический путь?
---------------------------
**Критический путь рендеринга** – это набор минимально необходимых для начала отрисовки страницы действий, ресурсов и вычислений.
Критический путь можно измерять в количестве критических ресурсов, минимальном времени загрузки (измеряется в RTT) и объеме критических ресурсов (в байтах).
Для иллюстрации возьмем простейший пример: HTML страницу размером 1 кб без внешних ресурсов. Критический путь будет: 1 ресурс (HTML-документ), 1 RTT (минимально), 1 кб трафика. Однако, таких простых страниц в природе почти не встретить, поэтому покажем, как можно определять критический путь на реальных веб-страницах.
Определение критического пути
-----------------------------
Настоящая веб-страница состоит из HTML-документа и некоторого количества внешних ресурсов: CSS-файлы, JS-файлы, шрифты, картинки и т. д. Современные браузеры стараются максимально оптимизировать процесс загрузки страницы, чтобы начать рендеринг как можно быстрее. Однако, браузеры ограничены спецификациями CSS и JS, поэтому должны строить страницу в строгой последовательности. Конечный этап критического пути – построение Render Tree, по которому браузер может начинать рендеринг.
Посмотрим основные шаги, которые включает в себя критический путь:
1. Получить HTML-документ.
2. Провести парсинг HTML на предмет включенных ресурсов.
3. Построить DOM tree (document object model).
4. Отправить запросы критических элементов.
5. Получить весь CSS-код (также запустить запросы на JS-файлы).
6. Построить CSSOM tree.
7. Выполнить весь полученный JS-код.
8. Перестроить DOM tree (при необходимости).
9. Построить Render tree и начать отрисовку страницы.
Из этой последовательности можно сделать несколько важных выводов.
Во-первых в критическом пути участвуют ресурсы c CSS и JS-кодом. Остальные внешние ресурсы там не учитываются.
Во-вторых, JS-код не может выполняться, пока не получены все ресурсы CSS и не построено CSSOM дерево.
В-третьих, страница не может быть отрисована до выполнения JS-кода, так как он может изменять DOM-дерево.
Но не всё так просто: дело, как обычно, в деталях. Наша задача: максимально сократить критический путь рендеринга для нашей страницы.
Способы сокращения критического пути
------------------------------------
Для примера возьмем код страницы из демонстрации плагина [Autocomplete](http://jqueryui.com/autocomplete/#default) из jQuery UI.
```
jQuery UI Autocomplete - Default functionality
$(function() {
var availableTags = [
"ActionScript",
"AppleScript",
"Scheme"
];
$( "#tags" ).autocomplete({
source: availableTags
});
});
Tags:
```
Из каких элементов состоит критический путь этой страницы?
* Сама страница (HTML).
* 2 СSS-файла.
* 2 JS-файла и JS-код в head страницы.
При условии параллельной загрузки JS-файлов получаем 3 RTT (минимально).
Сокращаем критический путь рендеринга. Что можно сделать в этом случае:
* Объединить два CSS в один файл.
* Объединить JS в один файл.
* Поместить вызов JS-файла и встроенный JS-код в конец страницы до /body.
* Отложить загрузку CSS для элемента autocomplete.
Нужно заметить, что первые две оптимизации актуальны только при использовании обычного HTTP без SPDY или HTTP/2, в которых количество запросов не имеет значения. Так как светлое будущее (HTTP/2) уже не за горами, а SPDY уже настоящее, склейкой файлов заниматься не будем.
Остановимся подробнее на третьей и четвертой оптимизации. Перемещение вызова JS-файла в конец документа позволит браузеру раньше начать рендеринг страницы. Отложенная загрузка CSS от jQuery UI возможна из-за того, что стили из этого файла нужны только для отображения элемента autocomplete (после набора текста в поле).
Вот так будет выглядеть конечный вариант страницы.
```
jQuery UI Autocomplete - Default functionality
Tags:
document.addEventListener("DOMContentLoaded", function(event) {
var availableTags = [
"ActionScript",
"AppleScript",
"Scheme"
];
$( "#tags" ).autocomplete({
source: availableTags
});
});
document.addEventListener("DOMContentLoaded", function(event) {
$('head').append('<link rel="stylesheet" href="http://code.jquery.com/ui/1.11.4/themes/smoothness/jquery-ui.css" type="text/css">');
});
```
Обратите внимание: вызовы плагина jQuery UI обёрнуты в конструкцию:
```
document.addEventListener("DOMContentLoaded", function(event) {
// plugin code
});
```
Это позволяет размещать код, зависимый от jQuery и его плагинов в любом месте страницы. Таким же методом выполнена отложенная загрузка CSS-файла.
Теперь критический путь сокращен на 1 запрос (CSS) и не требуется его загрузка (трафик) для начала отрисовки. За счет того, что весь JS-код перемещен в конец документа, браузер может начать отрисовку еще до выполнения этого кода.
Если на странице есть скрипты, которые можно выполнить потом (например, скрипты-счетчики, социальные плагины и т. д.), то выкинуть их из критического пути рендеринга можно атрибутом async:
```
```
Однако, с jQuery и его плагинами так поступить не получается (есть способ асинхронной загрузки, но он достаточно муторный). Поэтому используем решение, описанное выше.
Результат
---------
Проверяем, что получилось. Загружаем оба файла в Chrome. Открываем Developer tools, включаем «Toggle device mode», ограничиваем сеть до 450 Kbps 150 ms RT, загружаем без кеша. При загрузке находимся на закладке «Timeline».
Нас интересует момент начала отрисовки страницы (первые события Paint, они отображаются зелёным цветом). Для неоптимизированной версии: 5000 мс, для оптимизированной 500 мс.
Используя описанные приёмы можно значительно ускорить рендеринг ваших страниц, особенно если они насыщены JS-функциональностью и имеют большой объем CSS-кода. При внесении оптимизаций будьте осторожны: тестируйте каждое изменение – изменение порядка загрузки JS-библиотек может сломать функциональность.
Что почитать ещё
----------------
* [Ilya Grigorik: Analyzing Critical Rendering Path Performance](https://developers.google.com/web/fundamentals/performance/critical-rendering-path/analyzing-crp?hl=en)
* [Ilya Grigorik: Measuring the Critical Rendering Path with Navigation Timing](https://developers.google.com/web/fundamentals/performance/critical-rendering-path/measure-crp?hl=en) | https://habr.com/ru/post/262239/ | null | ru | null |
# Уведомления об истечении срока действия пароля в Active Directory средствами PowerShell
#### Предыстория
Началась вся история с того, что подошло время очередного IT аудита. Пришли серьезные дяденьки из Price Waterhouse Coopers, дали нам массу указаний и пару скриптов, которые надо было запустить на контроллере домена чтобы потом выслать им логи. После ознакомления с текстами скриптов (а мало-ли что там, безопасность превыше всего) логи были им предоставлены. И тут началось.
Требования PWC в большинстве случаев касались политик безопасности. Одно из них было — ввести password complexity policy и pasword lifetime. Сделать это, естественно, было довольно легко, но вскоре мы столкнулись с вытекающей проблемой: Windows не уведомляет пользователя об истечении срока действия его пароля если подключение осуществляется через VPN из внешней сети. Проблема оказалась довольно серьезной потому, что просто обновить пароль и разблокировать аккаунт такого пользователя было уже недостаточно. Нужно было чтобы ноутбук оказался в родной, офисной сети. С учетом того что некоторые пользователи «живут» в вечных командировках — проблема оказалась очень серьезной. Вручную отслеживать их — та еще головная боль, да и не по админски как-то. Тут и возникла мысль организовать рассылку автоматических уведомлений. После непродолжительного времени, потраченного на поиски, был найден неплохой [скрипт](http://www.itsolutionbraindumps.com/2012/08/expiring-password-notifications-with.html), который отдаленно пытался выполнять нужные действия. Мне предстояло его доработать.
Так как это был мой первый опыт написания скрипта под PowerShell — времени было потрачено немало (почти полный рабочий день).
#### Скрипт
И вот что у меня получилось:
```
Import-Module ActiveDirectory
#System globalization
#$ci = New-Object System.Globalization.CultureInfo("ru-RU")
#SMTP server name
$smtpServer = "mail.domain.local"
#Creating a Mail object
$msg = new-object Net.Mail.MailMessage
#Creating a Mail object for report
$msgr = new-object Net.Mail.MailMessage
#Creating SMTP server object
$smtp = new-object Net.Mail.SmtpClient($smtpServer)
#E-mail structure
Function EmailStructure($to,$expiryDate,$upn)
{
$msg.IsBodyHtml = $true
$msg.From = "notification@domain.com"
$msg.To.Clear()
$msg.To.Add($to)
$msg.Subject = "Password expiration notice"
$msg.Body =
```
`"<html><body><font face='Arial'>This is an automatically generated message from Exchange service.<br><br><b>Please note that the password for your account <i><u>Domain\$upn</u></i> will expire on $expiryDate.</b><br><br>Please change your password immediately or at least before this date as you will be unable to access the service without contacting your administrator.</font></body></html>"`
```
}
Function EmailStructureReport($to)
{
$msgr.IsBodyHtml = $true
$msgr.From = "notification@domain.com"
$msgr.To.Add($to)
$msgr.Subject = "Script running report"
$msgr.Body =
```
`"<html><body><font face='Arial'><b>This is a daily report.<br><br>Script has successfully completed its work.<br>$NotificationCounter users have recieved notifications:<br><br>$ListOfAccounts<br><br></b></font></body></html>"`
```
}
#Set the target OU that will be searched for user accounts
$OU = "OU=Organisation,DC=domain,DC=local"
```
`$ADAccounts = Get-ADUser -LDAPFilter "(objectClass=user)" -searchbase $OU -properties PasswordExpired, extensionAttribute15, PasswordNeverExpires, PasswordLastSet, Mail, Enabled | Where-object {$_.Enabled -eq $true -and $_.PasswordNeverExpires -eq $false}`
```
$NotificationCounter = 0
$ListOfAccounts = ""
Foreach ($ADAccount in $ADAccounts)
{
$accountFGPP = Get-ADUserResultantPasswordPolicy $ADAccount
if ($accountFGPP -ne $null)
{
$maxPasswordAgeTimeSpan = $accountFGPP.MaxPasswordAge
}
else
{
$maxPasswordAgeTimeSpan
```
`= (Get-ADDefaultDomainPasswordPolicy).MaxPasswordAge`
```
}
#Fill in the user variables
$samAccountName = $ADAccount.samAccountName
$userEmailAddress = $ADAccount.ExtensionAttribute15
$userPrincipalName = $ADAccount.UserPrincipalName
if ($ADAccount.PasswordExpired)
{
Write-host "The password for account $samAccountName has expired!"
}
else
{
$ExpiryDate = $ADAccount.PasswordLastSet + $maxPasswordAgeTimeSpan
$TodaysDate = Get-Date
$DaysToExpire = $ExpiryDate - $TodaysDate
#Calculating DaysToExpireDD to DD format (w/o fractional part and dot)
$DaysToExpireDD = $DaysToExpire.ToString() -Split ("\S{17}$")
Write-host
```
`"The password for account $samAccountName expires on: $ExpiryDate. Days left: $DaysToExpireDD"`
```
if (($DaysToExpire.Days -eq 15) -or
```
`($DaysToExpire.Days -eq 7) -or ($DaysToExpire.Days -le 3))`
```
{
$expiryDate = $expiryDate.ToString("d",$ci)
#Generate e-mail structure and send message
if ($userEmailAddress)
{
EmailStructure $userEmailAddress $expiryDate $samAccountName
$smtp.Send($msg)
Write-Host
```
`"NOTIFICATION - $samAccountName :: e-mail was sent to $userEmailAddress"`
```
$NotificationCounter = $NotificationCounter + 1
$ListOfAccounts =
```
`$ListOfAccounts + $samAccountName + " - $DaysToExpireDD days left. Sent to $userEmailAddress<br>"`
```
}
}
}
}
Write-Host "SENDING REPORT TO IT DEPARTMENT"
EmailStructureReport("itdepartment@domain.com")
$smtp.Send($msgr)
```
Сохраняем это как текст в файл с расширением .ps1.
#### Команда запуска
Далее — создаем файл с расширением .cmd и пишем в него параметр запуска скрипта. У меня это выглядит так:
`powershell D:\ExchangeTools\pwde.ps1`
Оба файла у меня лежат на почтовом сервере. Вы можете попробовать свой вариант.
#### Создание графика выполнения
Далее ставим в расписание ежедневный запуск .cmd файла. У меня он выполняется каждый день в 11 утра.
Start > All programs > Accesories > System tools > Task scheduler.
Жмем Action > Create new task.
На вкладке General жмем кнопку «Change user» выбираем пользователя, от имени которого всё это будет работать. У пользователя должны быть права на считывание параметров, необходимых для скрипта из AD. Ставим «Run whether user logged on or not» (запускать независимо от того, залогинен пользователь или нет). При сохранении задачи система попросит вас ввести пароль пользователя.
Далее вкладка Triggers. Тут всё просто — настраиваете время запуска как вам нужно.
Вкладка Actions, жмем «New», выбираем «Start a program» и указываем путь к нашему .cmd файлу. Последние две вкладки можно не трогать, но если есть необходимость — внесите изменения как считаете нужным.
Уведомления посылаются за 15, 7 и 3 и менее дней.
**ВНИМАНИЕ**
Exchange серверу нужно указать собственный адрес в качестве релея если планируется отправка на адреса, находящиеся вне домена (дублирование на личный адрес, например).
Некоторые, вероятно, спросят — «зачем же брать адрес из ExtensionAttribute если есть стандартное поле содержащее e-mail пользователя?». Ответ прост — копия каждого уведомления шлется также в IT department, у пользователя может быть не один адрес и некоторые системные аккаунты не имеют почтовых ящиков в принципе, но уведомления о них нужны для облегчения жизни уже непосредственно администраторам. Вписать адреса в ExtensionAttribute15 вы сможете зайдя в дерево Active Directory на контроллере домена с правами администратора. В свойствах аккаунта будет вкладка «Attribute Editor». Если адресов в поле будет несколько — разделять их следует запятой. | https://habr.com/ru/post/160599/ | null | ru | null |
# Автоматизация публикации приложения в Google Play
Если у вас есть андроид приложение, которые вы собираетесь опубликовать в Google Play или оно уже опубликовано, а так же если вы его только разрабатываете, и оно находится в закрытом бета тестировании, а заказчику\тестерам периодически нужно собирать и передавать сборку руками, возможно лучше автоматизировать этот процесс
Вы можете самостоятельно разобраться с [документацией](https://developers.google.com/android-publisher) на английском языке, но если процесс вызывает сложности или что-то не получается, надеюсь публикация окажется полезной
Перед началом работы нужно вручную опубликовать первую версию приложения
#### Настройка доступа
Откройте [Google Play Developer Console](https://play.google.com/apps/publish) и перейдите в меню *Settings* → *API access*
Консоль нужно связать c Google API проектом. Если у вас нет проекта, то на данный момент из интерфейса будет доступна только кнопка Create new project
Если же есть, то будет доступен список этих проектов. Кнопка link понятное дело их связывает
Но давайте рассмотрим пример с созданием нового проекта. Его можно создать из [Google API Console](https://console.developers.google.com) или прямо из Google Play Developer Console, который у вас уже открыт, нажмите кнопку *Create new project*
Если вы первый раз создаете Google API проект, появится popup-окошко, тут *Accept All*
Отлично, теперь у вас есть проект и service account, который в данном случае создается автоматически
Сейчас нужно разрешить этому аккаунту работать с Google Play и дать ему роль. Это так же можно сделать прямо отсюда, нажмите *Grant access*. Вас перекинет в меню User accounts & right(видно на заднем плане) и откроется popup-окошко, где email и остальные обязательные поля уже будут заполнены. Нажмите *Add user*
Сейчас вы видите, что ваш пользователь успешно добавлен
Теперь нужно сгенерировать пару публичный и приватный ключи, чтобы можно было работать с библиотеками и публиковать новые версии приложения. Для этого откройте [список проектов](https://console.developers.google.com/project) в Google API Console и кликните по нужному, по умолчанию он называется *Google Play Android Developer*
Далее нажмите пункт меню *Credentials* → *Create credentials*, выберите *Service account key*
Выберите из списка *Compute Engine default service account* и перекиньте radio button на *P12*. Нажмите *Create*
С настройками все, пара публичный и приватный ключи с названием *Google Play Android Developer-%кусочек id%.p12* была сохранена на компе
#### Приступим к программированию
Сейчас Google предоставляет библиотеки на java и python для работы с Google Play Developer API. Мы рассмотрим вариант на java, для этого [скачайте zip-архив](https://developers.google.com/android-publisher/androidpublisher_v2_public.zip) с библиотеками и примерами
Откройте вашу IDE и создайте проект, свой я назвал ProductionManager, подключите следующие библиотеки:
* google-api-client-1.19.0.jar
* google-api-services-androidpublisher-v2-rev20141111-1.19.0.jar
* google-http-client-1.19.0.jar
* google-http-client-jackson2-1.19.0.jar
* google-oauth-client-1.19.0.jar
* jackson-core-2.1.3.jar
Скопируйте файл *Google Play Android Developer-%кусочек id%.p12* в resource папку вашего проекта, я его переименовал чтобы не было пробелов, кажется у меня было исключение при попытке его прочитать. Если вы будете держать исходники этого проекта в VCS куда есть доступ у многих людей, наверное лучше хранить файл на сервере непрерывной интеграции, тут на ваше усмотрение.
Перед сборкой и соответственно публикацией приложения я делаю запрос, чтобы узнать последнюю версию кода(versionCode) и обновить ее, потому что мне нравится чтобы они шли в арифметической прогрессии с шагом 1(те просто 1, 2, 3...), вы можете просто подставить buildNumber из CI сервера или revesionNumber из вашей VCS, тоже на ваше усмотрение
**Обновление версии**
```
private Edits getApplicationEdits() throws Exception {
String applicationName = "ApplicationName";
String serviceAccountId = "и-го-го@developer.gserviceaccount.com"
HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
KeyStore keyStore = SecurityUtils.getPkcs12KeyStore();
InputStream inputStream = ProductionManager.class.getResourceAsStream("/resources/key.p12");
PrivateKey privateKey = SecurityUtils.loadPrivateKeyFromKeyStore(keyStore, inputStream, "notasecret", "privatekey", "notasecret");
inputStream.close();
GoogleCredential credential = new GoogleCredential
.Builder()
.setTransport(httpTransport)
.setJsonFactory(jsonFactory)
.setServiceAccountId(serviceAccountId)
.setServiceAccountScopes(Collections.singleton(AndroidPublisherScopes.ANDROIDPUBLISHER))
.setServiceAccountPrivateKey(privateKey)
.build();
AndroidPublisher androidPublisher = new AndroidPublisher
.Builder(httpTransport, jsonFactory, credential)
.setApplicationName(applicationName)
.build();
return androidPublisher.edits();
}
private void updateVersionCode() throws Exception {
String packageName = "com.package.name";
Edits edits = getApplicationEdits();
String editId = edits
.insert(packageName, null)
.execute()
.getId();
ApksListResponse apksResponse = edits
.apks()
.list(packageName, editId)
.execute();
List versions = new ArrayList();
List apks = apksResponse.getApks();
if (apks == null) {
throw new Exception("responsed list of apks is null");
}
for (Apk apk : apks) {
versions.add(apk.getVersionCode());
}
if (versions.isEmpty()) {
throw new Exception("previous versions are not detected");
}
int lastVersionCode = Collections.max(versions);
if (lastVersionCode == 0) {
throw new Exception("version is 0");
}
//TODO update version code
//++lastVersionCode
}
```
**Публикации приложения**
```
private void publishApplication() throws Exception {
String packageName = "com.package.name";
String track = "beta";//release
String setupFilePath = "/path/to/setup/file/app.apk";
Edits edits = getApplicationEdits();
String editId = edits
.insert(packageName, null)
.execute()
.getId();
FileContent mediaContent = new FileContent("application/vnd.android.package-archive", new File(setupFilePath));
Upload uploadRequest = edits
.apks()
.upload(packageName, editId, mediaContent);
Apk apk = uploadRequest.execute();
List versions = new ArrayList<>();
versions.add(apk.getVersionCode());
edits
.tracks()
.update(packageName, editId, track, new Track().setVersionCodes(versions))
.execute();
edits
.commit(packageName, editId)
.execute();
}
```
Скомпилируйте executable jar. Теперь нужно настроить создание инсталляционного файла и его публикацию на вашем CI сервере, я использую TeamCity. Получается, у нас будет 4 build steps:
1. Обновление versionСode. Запустите jar-файл с параметром, который вы обработаете и вызовите метод updateVersionCode(). Вот так это выглядит на TeamCity
2. Обновление versionName
3. Генерация apk. Можно командной строкой, можно выбрать специальный step, есть gradle и IntelliJ IDEA, во втором случае нужно указать имя artifact-а
4. Публикация приложения. Так же запускаете jar-файл с другим параметром и вызываете метод publishApplication()
Спасибо за внимание | https://habr.com/ru/post/281557/ | null | ru | null |
# Перевод Redmine-плагинов с TelegramCLI на Webogram
Ранее мы уже писали о наших плагинах [redmine\_chat\_telegram](https://habrahabr.ru/company/southbridge/blog/281044/) и [redmine\_intouch](https://habrahabr.ru/company/southbridge/blog/272051/), предназначенных
для того, чтобы ваша работа с Redmine и Telegram была продуктивнее. А сегодня мы хотели бы рассказать о том, как избавились от TelegramCLI. Это большой апдейт, призванный упростить работу с нашими telegram-плагинами.
В процессе эксплуатации у нас неоднократно возникали проблемы с настройкой [TelegramCLI](https://github.com/vysheng/tg), поэтому мы решили упростить работу наших плагинов. Для этого мы сочли необходимым избавиться от зависимости TelegramCLI, добавили вместо него [Webogram](https://github.com/zhukov/webogram) и модифицировали под свои нужды. Это позволило больше не запускать на сервере сервис TelegramCLI.
Webogram
--------
Webogram — официальный веб-клиент к Telegram, написанный на AngularJS. Поэтому, чтобы работать с Webogram через скрипты, приходится использовать headless browser, в нашем случае это PhantomJS.
Мы модифицировали код Webogram, чтобы отдавать ему запросы на нужные действия без необходимости работать с интерфейсом. В форме специального запроса плагин отправляет на URL модифицированного Webogram инструкцию сделать некую операцию в Telegram.
### Принцип работы
Сначала плагин дает команду произвести какую-то операцию в Telegram.
```
telegram = TelegramCommon::Telegram.new
result = telegram.execute('Test')
```
Далее формируется строка запуска PhantomJS.
```
module TelegramCommon
class Telegram
...
def make_request
@api_result = `#{cli_command}`
debug(api_result)
api_result
end
def cli_command
cmd = "#{phantomjs} #{config_path} \"#{api_url}\""
debug(cmd)
cmd
end
end
end
```
Затем PhantomJS выполняет запрос и ожидает 10 секунд, чтобы элемент #api-status
получил класс ready, который свидетельствовал бы о том, что Webogram завершил обработку.
```
// plugins/redmine_telegram_common/config/phantom-proxy.js
...
page.open(url, function() {
waitFor(
function () {
return page.evaluate(function () {
return $('#api-status').hasClass('ready');
});
},
function () {
exit()
}, 10000);
});
```
AngularJS-контроллер AppApiController занимается обработкой запросов, и когда он заканчивает работу, то на странице у блока #api-status меняется класс на "ready", тем самым уведомляя PhantomJS о завершении операции.
```
// plugins/redmine_telegram_common/app/webogram/app/js/controllers.js
$scope.promiseStatus = false;
var args = {};
if (typeof $routeParams.args !== 'undefined') {
args = JSON.parse($routeParams.args)
}
$scope.handle = function () {
var command = $routeParams.command;
var handlerName = $scope['api' + command];
if (typeof handlerName === 'function') {
handlerName(args)
} else {
console.error('There is no ' + handlerName + ' api function.')
}
};
$scope.apiTest = function () {
$scope.successApi('api test')
};
...
$scope.successApi = function (msg) {
console.log('success: ' + msg);
$scope.resolveApi()
};
$scope.failedApi = function (msg) {
console.log('failed: ' + msg);
$scope.resolveApi()
};
$scope.resolveApi = function () {
$scope.promiseStatus = true
};
```
Вскоре запрос выполняется, и плагин получает ответ, с которым можно работать.
Заключение
----------
В итоге, чтобы начать работать с нашими плагинами, которые ранее зависели от TelegramCLI, теперь достаточно установить новые зависимости, перейти на страницу настройки плагина redmine\_telegram\_common и пройти простенькую процедуру авторизации, в процессе которой PhantomJS запомнит, под каким логином отправлять запросы на Telegram.
Telegram-боты в наших плагинах redmine\_chat\_telegram и redmine\_intouch научились работать не только через getUpdates (как ранее фоновые процессы через rake), но и через WebHooks (достаточно инициализировать ботов в настройках соответствующих плагинов, однако необходим HTTPS на Redmine). Таким образом, мы избавились от дополнительных фоновых процессов, которые раньше могли быть преградой для установки плагина неопытными пользователями.
Если вы встретили какие-то ошибки, у вас есть предложения по улучшению плагина или вы желаете принять участие в развитии плагинов, мы будем рады вашим откликам. Наши репозитории перечислены ниже.
Ссылки
------
* [redmine\_telegram\_common](https://github.com/centosadmin/redmine_telegram_common)
* [redmine\_chat\_telegram](https://github.com/centosadmin/redmine_chat_telegram)
* [redmine\_intouch](https://github.com/centosadmin/redmine_intouch) | https://habr.com/ru/post/332292/ | null | ru | null |
# Nomad: проблемы и решения
Первый сервис в [Nomad](https://www.nomadproject.io/) я запустил в сентябре 2016 года. На данный момент пользуюсь как программист и занимаюсь поддержкой как администратор двух Nomad кластеров — один "домашний" для своих личных проектов (6 микро-виртуалок в Hetzner Cloud и ArubaCloud в 5 разных датацентрах Европы) и второй рабочий (порядка 40 приватных виртуальных и физических серверов в двух датацентрах).
За прошедшее время накопился довольно большой опыт работы с Nomad окружением, в статье опишу встреченные проблемы Nomad и как с ними можно справиться.
*Ямальский кочевник делает Continous Delivery инстанса вашего ПО © National Geographic Россия*
1. Количество серверных нод на один датацентр
---------------------------------------------
**Решение: на один датацентр достаточно одной серверной ноды.**
В [документации](https://www.nomadproject.io/docs/internals/architecture.html) явно не указано, какое число серверных нод требуется в одном датацентре. Указано только, что на регион нужно 3-5 нод, что логично для консенсуса raft протокола.
В начале я запланировал 2-3 серверных ноды в каждом датацентре для обеспечения резервирования.
По факту использования оказалось:
1. Этого просто не требуется, так как при отказе ноды в датацентре, роль серверной ноды для агентов в данном датацентре будут выполнять другие серверные ноды данного региона.
2. Получается даже хуже, если не решена проблема №8. При перевыборах мастера могут случаться рассогласования и Nomad будет перезапускать какую-то часть сервисов.
2. Ресурсы сервера для серверной ноды
-------------------------------------
**Решение: для серверной ноды достаточно небольшой виртуальной машины. На этом же сервере допускается запускать другие служебные нересурсоёмкие сервисы.**
Потребление памяти демоном Nomad зависит от количества запущенных задач. Потребление CPU — от количества задач и от количества серверов/агентов в регионе (не линейно).
В нашем случае: для 300 запущенных задач потребление памяти — около 500 МБ для текущей мастер-ноды.
В рабочем кластере виртуальная машина для серверной ноды: 4 CPU, 6 GB RAM.
Дополнительно запущены: Consul, Etcd, Vault.
3. Консенсус при нехватке датацентров
-------------------------------------
**Решение: делаем три виртуальных датацентра и три серверных ноды на два физических датацентра.**
Работа Nomad в рамках региона основана на протоколе raft. Для корректной работы нужно не менее 3 серверных нод, расположенных в разных датацентрах. Это даст возможность корректной работы при полной потере сетевой связности с одним из датацентров.
Но у нас только два датацентра. Идём на компромисс: выбираем датацентр, которому мы доверяем больше, и делаем в нём дополнительную серверную ноду. Делаем это путём введения дополнительного виртуального датацентра, которой физически будет находится в том же датацентре (см. подпункт 2 проблемы 1).
**Альтернативное решение: разбиваем датацентры на отдельные регионы.**
В итоге датацентры функционируют независимо и консенсус нужен только внутри одного датацентра. Внутри датацентра в таком случае лучше сделать 3 серверных ноды путём реализации трёх виртуальных датацентров в одном физическом.
Этот вариант менее удобен для распределения задач, но даёт 100% гарантии независимости работы сервисов в случае сетевых проблем между датацентрами.
4. "Сервер" и "агент" на одном сервере
--------------------------------------
**Решение: допустимо, если у вас ограничено число серверов.**
В документации Nomad написано, что так делать нежелательно. Но если у вас нет возможности выделить под серверные ноды отдельные виртуальные машины — можно разместить серверную и агентскую ноду на одном сервере.
Под одновременным запуском подразумевается запуск демона Nomad одновременно в режиме клиента и в режиме сервера.
Чем это грозит? При большой нагрузке на CPU данного сервера серверная нода Nomad будет работать нестабильно, возможны потери консенсуса и хартбитов, перезагрузки сервисов.
Чтобы этого избежать — увеличиваем лимиты из описания проблемы №8.
5. Реализация пространств имён (namespaces)
-------------------------------------------
**Решение: возможно, через организацию виртуального датацентра.**
Иногда требуется запустить часть сервисов на отдельных серверах.
Решение первое, простое, но более требовательное к ресурсам. Разделяем все сервисы на группы по назначению: frontend, backend,… Добавляем meta атрибуты серверам, прописываем атрибуты для запуска всем сервисам.
Решение второе, простое. Добавляем новые сервера, прописываем им meta атрибуты, прописываем эти атрибуты запуска нужным сервисам, всем остальным сервисам прописываем запрет запуска на серверах с этим атрибутом.
Решение третье, сложное. Создаём виртуальный датацентр: запускаем Consul для нового датацентра, запускаем серверную ноду Nomad для данного датацентра, не забывая о количестве серверных нод для данного региона. Теперь можно запускать отдельные сервисы в данном выделенном виртуальном датацентре.
6. Интеграция с Vault
---------------------
**Решение: избегать циклических зависимостей Nomad<->Vault.**
Запускаемый Vault не должен иметь никаких зависимостей от Nomad. Прописываемый в Nomad адрес Vault желательно должен указывать напрямую на Vault, без прослоек балансеров (но допустимо). Резервирование Vault в таком случае можно делать через DNS — Consul DNS или внешний.
Если в конфигурационных файлах Nomad прописаны данные Vault, то Nomad при запуске пытается получить доступ к Vault. Если доступ неуспешен, то Nomad отказывается запускаться.
Ошибку с циклической зависимостью я сделал давно, этим однажды кратковременно почти полностью разрушив кластер Nomad. Vault был запущен корректно, независимо от Nomad, но Nomad смотрел на адрес Vault через балансеры, которые были запущены в самом Nomad. Переконфигурация и перезагрузка серверных нод Nomad вызвала перезагрузку сервисов балансера, что привело к отказу запуска самих серверных нод.
7. Запуск важных statefull сервисов
-----------------------------------
**Решение: допустимо, но я так не делаю.**
Можно ли запускать PostgreSQL, ClickHouse, Redis Cluster, RabbitMQ, MongoDB через Nomad?
Представьте, что у вас есть набор важных сервисов, на работу которых завязана большая часть остальных сервисов. Например, БД в PostgreSQL/ClickHouse. Или общее кратковременное хранилище в Redis Cluster/MongoDB. Или шина данных в Redis Cluster/RabbitMQ.
Все эти сервисы в каком-то виде реализуют отказоустойчивую схему: Stolon/Patroni для PostgreSQL, своя реализация raft в Redis Cluster, своя реализация кластера в RabbitMQ, MongoDB, ClickHouse.
Да, все эти сервисы вполне можно запустить через Nomad с привязкой к конкретным серверам, но зачем?
Плюс — удобство запуска, единый формат сценариев, как и у остальных сервисов. Не нужно мучаться со сценариями ansible/чем-то ещё.
Минус — дополнительная точка отказа, которая не даёт никаких преимуществ. Лично я полностью ронял кластер Nomad два раза по разным причинам: один раз "домашний", один раз рабочий. Это было на первых этапах внедрения Nomad и из-за неаккуратности.
Так же, Nomad начинает себя плохо вести и перезапускать сервисы из-за проблемы №8. Но даже если та проблема у вас решена, опасность остаётся.
8. Стабилизация работы и рестартов сервисов в нестабильной сети
---------------------------------------------------------------
**Решение: использование опций тюнинга хартбитов.**
По умолчанию Nomad сконфигурирован так, что любая кратковременная проблема сети или нагрузка на CPU, вызывает потерю консенсуса и перевыборы мастера или пометку агентской ноды недоступной. И это приводит к самопроизвольным перезагрузкам сервисов и перенос их на другие ноды.
Статистика "домашнего" кластера до исправления проблемы: максимальное время жизни контейнера до рестарта — около 10 дней. Тут всё ещё отягощается запуском агента и сервера на одном сервере и размещением в 5 разных датацентрах Европы, что предполагает большую нагрузку на CPU и менее стабильную сеть.
Статистика рабочего кластера до исправления проблемы: максимальное время жизни контейнера до рестарта — больше 2 месяцев. Тут всё относительно хорошо из-за отдельных серверов для серверных нод Nomad и отличной сети между датацентрами.
Значения по умолчанию
```
heartbeat_grace = "10s"
min_heartbeat_ttl = "10s"
max_heartbeats_per_second = 50.0
```
Судя по коду: в такой конфигурации хартбиты делаются каждые 10 секунд. При потере двух хартбитов начинаются перевыборы мастера или перенос сервисов с агентской ноды. Спорные настройки, на мой взгляд. Отредактируем их в зависимости от применения.
Если у вас все сервисы запущены в нескольких экземплярах и разнесены по датацентрам, то скорее всего, для вас не имеет значения долгий период определения недоступности сервера (примерно 5 минут, в примере ниже) — делаем реже интервал хартбитов и больший период определения недоступности. Это пример настройки моего "домашнего" кластера:
```
heartbeat_grace = "300s"
min_heartbeat_ttl = "30s"
max_heartbeats_per_second = 10.0
```
Если же у вас хорошая сетевая связность, отдельные сервера для серверных нод и важен период определения недоступности сервера (есть какой-то сервис, запущенный в одном экземпляре и важно его быстро перенести), то увеличиваем период определения недоступности (heartbeat\_grace). Опционально можно сделать чаще хартбиты (уменьшив min\_heartbeat\_ttl) — от этого незначительно вырастет нагрузка на CPU. Пример конфигурации рабочего кластера:
```
heartbeat_grace = "60s"
min_heartbeat_ttl = "10s"
max_heartbeats_per_second = 50.0
```
Данные настройки полностью устраняют проблему.
9. Запуск периодических задач
-----------------------------
**Решение: периодические сервисы Nomad использовать можно, но "cron" удобнее для поддержки.**
В Nomad есть возможность периодического запуска сервиса.
Единственный плюс — простота такой конфигурации.
Первый минус — если сервис будет запускаться часто, то он будет захламлять список задач. Например, при запуске каждые 5 минут — в список будет добавляться 12 лишних задач каждый час, до срабатывания GC Nomad, который удалит старые задачи.
Второй минус — непонятно, как нормально настраивать мониторинг такого сервиса. Как понять, что сервис запускается, отрабатывает и выполняет свою работу до конца?
В итоге, для себя я пришёл к "cron" реализации периодических задач:
1. Это может быть обычный cron в постоянно запущенном контейнере. Cron периодически запускает некий скрипт. На такой контейнер легко добавляется script-healthcheck, который проверяет какой-либо флажок, который создаёт запускаемый скрипт.
2. Это может быть постоянно запущенный контейнер, с постоянно запущенным сервисом. Внутри сервиса уже реализован периодический запуск. На такой сервис легко добавляется или аналогичный script-healthcheck, или http-healthcheck, который проверяет статус сразу по своим "внутренностям".
На данный момент я большую часть времени пишу на Go, соответственно, предпочитаю второй вариант с http healthcheck'ами — на Go и периодический запуск, и http healthcheck'и добавляются несколькими строчками кода.
10. Обеспечение резервирования сервисов
---------------------------------------
**Решение: простого решения нет. Есть два варианта посложнее.**
Схема обеспечения резерва, предусмотренная разработчиками Nomad, состоит в поддержке количества запущенных сервисов. Говоришь номаду "запусти мне 5 инстансов сервиса" и он их где-то там запускает. Контроля над распределением нет. Инстансы могут запуститься на одном сервере.
Если сервер упал — инстансы переносятся на другие сервера. Пока инстансы переносятся — сервис не работает. Это плохой вариант обеспечения резерва.
Делаем правильно:
1. Распределяем инстансы по серверам через [distinct\_hosts](https://www.nomadproject.io/docs/job-specification/constraint.html#quot-distinct_hosts-quot-).
2. Распределяем инстансы по датацентрам. К сожалению, только через создание копии сценария вида сервис1, сервис2 с одинаковым содержимым, разными именами и указанием запуска в разных датацентрах.
В Nomad 0.9 появится функционал, который устранит эту проблему: возможно будет распределять сервисы в процентном соотношении между серверами и датацентрами.
11. Web UI Nomad
----------------
**Решение: встроенный UI — ужасен, hashi-ui — прекрасен.**
Консольный клиент выполняет большую часть требуемого функционала, но иногда хочется посмотреть графики, понажимать кнопочки...
В Nomad встроен UI. Он не очень удобен (даже хуже консольного).
Единственная, известная мне альтернатива — [hashi-ui](https://github.com/jippi/hashi-ui).
По факту, сейчас консольный клиент лично мне нужен только для "nomad run". И даже это в планах перенести в CI.
12. Поддержка oversubscription по памяти
----------------------------------------
**Решение: нет.**
В текущих версия Nomad обязательно указывать строгий лимит памяти для сервиса. При превышении лимита — сервис будет убит OOM Killer.
Oversubscription — это когда лимиты сервису могут быть указаны "от и до". Некоторым сервисам при запуске требуется больше памяти, чем при обычной работе. Некоторые сервисы могут кратковременно потреблять больше памяти, чем обычно.
Выбор строго ограничения или мягкого — тема для дискуссий, но, например, Kubernetes даёт программисту сделать выбор. К сожалению, в текущих версиях Nomad такой возможности нет. Допускаю, что появится в будущих версиях.
13. Очистка сервера от сервисов Nomad
-------------------------------------
**Решение:**
```
sudo systemctl stop nomad
mount | fgrep alloc | awk '{print $3}' | xargs -I QQ sudo umount QQ
sudo rm -rf /var/lib/nomad
sudo docker ps | grep -v '(служебный-сервис1|служебный-сервис2|...)' | fgrep -v IMAGE | awk '{print $1}' | xargs -I QQ sudo docker stop QQ
sudo systemctl start nomad
```
Иногда "что-то идёт не так". На сервере убивает агентскую ноду и она отказывается запускаться. Или агентская нода перестаёт отвечать на запросы. Или агентская нода "теряет" сервисы на данном сервере.
Такое иногда случалось со старыми версиями Nomad, сейчас такое или не происходит, или очень редко.
Что в таком случае сделать проще всего, учитывая, что drain сервера не даст нужного результата? Очищаем сервер вручную:
1. Останавливаем агента nomad.
2. Делаем umount на создаваемые им mount.
3. Удаляем все данные агента.
4. Удаляем все контейнеры, фильтруя служебные контейнеры (если есть).
5. Запускаем агента.
14. Как лучше разворачивать Nomad?
----------------------------------
**Решение: конечно, через Consul.**
Consul в данном случае — отнюдь не лишняя прослойка, а органично вписывающийся в инфраструктуру сервис, который даёт больше плюсов, чем минусов: DNS, KV хранилище, поиск сервисов, мониторинг доступности сервиса, возможность безопасного обмена информацией.
Кроме того, он разворачивается так же просто, как и сам Nomad.
15. Что лучше — Nomad или Kubernetes?
-------------------------------------
**Решение: зависит от...**
Раньше у меня иногда появлялась мысль начать миграцию в Kubernetes — так сильно меня раздражал периодическая самопроизвольная перезагрузка сервисов (см. проблему №8). Но после полного решения проблемы могу сказать: Nomad меня устраивает на данный момент.
С другой стороны: в Kubernetes так же существует полу-самопроизвольная перезагрузка сервисов — когда планировщик Kubernetes перераспределяет инстансы в зависимости от нагрузки. Это не очень здорово, но там это настраивается скорее всего.
Плюсы Nomad: очень легко разворачивается инфраструктура, простые сценарии, хорошая документация, встроенная поддержка Consul/Vault, что в свою очередь даёт: простое решение проблемы хранения паролей, встроенный DNS, простые в настройке хелсчеки.
Плюсы Kubernetes: сейчас это "стандарт де факто". Хорошая документация, множество готовых решений, с хорошим описанием и стандартизацией запуска.
К сожалению, у меня нет такого же большого экспертного опыта в Kubernetes, чтобы однозначно ответить на вопрос — что использовать для нового кластера. Зависит от планируемых потребностей.
Если у вас планируется множество неймспейсов (проблема №5) или ваши специфические сервисы потребляют много памяти на старте, далее освобождая её (проблема №12) — однозначно Kubernetes, т.к. эти две проблемы в Nomad решены не до конца или неудобно. | https://habr.com/ru/post/435132/ | null | ru | null |
# Как я собрал первый аналоговый клиент для твиттера
Однажды у нас с друзьями появилась идея, почему бы не сделать так, чтобы на старом дисковом телефоне можно было набрать какое-то сообщение и отправить его. А и правда, подумал я, тем более мне давно хотелось сделать что-нибудь на базе Arduino, ведь платформа доступная и простая в изучении. Да и идея с вдыханием новой жизни в винтажный телефонный аппарат показалась привлекательной. В результате получился [Tweephone](http://twitter.com/#!/tweephone).
Небольшая видео-демонстрация, а ниже расскажу о процессе создания.
Чтобы была возможность набирать символы, я выбрал принцип набора текста на мобильниках с 12-ти кнопочной клавиатурой. Например, чтобы набрать букву «a» нужно провернуть двойку один раз, а для буквы «f» — тройку три раза.
Недолго думая, я организовал среди друзей поиск собственно самого аппарата (который был найден у бабушки моего приятеля), достал Arduino и LCD экран 16\*2 строчек, паяльные принадлежности, свободное время, ну и острое желание сделать что-то руками.
Заполучив Arduino, я сразу подключил к нему LCD, покрутил тестовые примеры для светодиодов, кнопок и LCD экрана. Найти их можно на [сайте Arduino](http://arduino.cc/).
Сняв крышку корпуса телефона и изучив внутренности, я обнаружил, что работа самого номеронаберателя очень проста: он имеет 3 контакта, один из которых замыкается с двумя другими. С первым — в случае, когда диск прокручивается, а со вторым — по умолчанию замкнут, но в процессе того, как диск возвращается в исходное состояние, размыкается определенное количество раз, в зависимости от номера, относительно которого диск начинал движение. Это всё было видно невооруженным взглядом, но дополнительно убедиться в правильности работы можно используя мультиметр, который пищит при коротком замыкании контактов. Также стало понятно, что состояние “трубка на аппарате”/”трубка снята” тоже можно использовать программно, потому что это действие попросту замыкает-размыкает контакты кнопки на плате телефона.
Учитывая эти знания, стало понятно, что грубо говоря, я имею дело с 3-мя кнопками, данные с которых нужно считывать программно, а всё остальное — дело алгоритма. Поэтому каждую из них я подключил по [схеме с сайта](http://arduino.cc/en/Tutorial/Button) к digital-портам Arduino, и собрал всё это дело на макетной плате.
Осталось открыть среду разработки и написать код, который бы считывал импульсы с digital-портов, преобразовывал их в символы и отправлял в твиттер. Так как плат коммуникаций для Arduino под рукой не оказалось, то решено было подключать телефон по USB компьютеру, на котором запущен скрипт, который считывает строки из Serial-порта Arduino и постит их.
Так как алгоритм всего процесса достаточно тривиален, то весь код тут приводить не буду, расскажу только о том, как считываются данные, набранные с диска.
Во-первых, чтобы работать с digital-портом, нужно указать, каков режим этого порта при инициализации:
> `const unsigned int diskState = 7;
>
> const unsigned int diskCounter = 8;
>
>
>
> void setup() {
>
> pinMode(diskState, INPUT);
>
> pinMode(diskCounter, INPUT);
>
> }`
Как видно из листинга, я использовал 7 и 8 порты для подключения непосредственно номеронабирателя.
Далее, внутри бесконечного цикла, в котором происходит выполнение сценария, нужно проверять состояние первого порта, и если на нем есть логическое “да”, то это значит, что пользователь начал крутить диск. Пока диск не вернется обратно, нужно увеличивать счетчик каждый раз, когда второй порт разомкнут.
> `unsigned int prevDiskCountState = HIGH;
>
>
>
> void loop() {
>
> unsigned int currDiskState = digitalRead(diskState);
>
> unsigned int currDiskCountState = digitalRead(diskCounter);
>
>
>
> if(currDiskState == HIGH) {
>
> if(prevDiskCountState == HIGH && currDiskCountState == LOW) {
>
> currDiskCount++;
>
> delay(100);
>
> }
>
>
>
> prevDiskCountState = currDiskCountState;
>
> }else{
>
> if(currDiskCount > 0) {
>
> // обработка набранной цифры
>
> }
>
> }
>
> }`
Такая же проверка осуществляется для статуса телефонной трубки, и в случае, если есть текст и трубку положили, выполняется запись строки в Serial порт.
> `Serial.println(msg);`
А на компьютере запущен небольшой Ruby-скрипт, который считывает строку и отправляет ее в твиттер.
> `require "serialport"
> require "twitter"
>
> # params for serial port
> port\_str = "/dev/tty.usbserial-A900cdNp"
> baud\_rate = 9600
> data\_bits = 8
> stop\_bits = 1
> parity = SerialPort::NONE
>
> sp = SerialPort.**new**(port\_str, baud\_rate, data\_bits, stop\_bits, parity)
>
> # twitter auth
> require './Config.rb'
> Twitter.configure do |config|
> config.consumer\_key = YOUR\_CONSUMER\_KEY
> config.consumer\_secret = YOUR\_CONSUMER\_SECRET
> config.oauth\_token = YOUR\_OAUTH\_TOKEN
> config.oauth\_token\_secret = YOUR\_OAUTH\_TOKEN\_SECRET
> end
>
> client = Twitter::Client.new
>
> while true do
> line = sp.gets
> if line
> puts line
> client.**update**(line)
> end
> end
>
> sp.close`
Убедившись, что всё отлично работает, я перенес всю схему с макетной платы на монтажную, и поместил всё внутрь корпуса, предварительно выпилив отверстие для дисплея.
Весь код проекта доступен на [GitHub](https://github.com/krasnoukhov/tweephone), поэтому каждый может разобраться в деталях и реализовать что-нибуть похожее.
[Твит для ХабраХабра](http://twitter.com/tweephone/status/128128397674156032)
[Твиттер проекта](http://twitter.com/#!/tweephone)
[Страница проекта](http://unteleported.com/tweephone)
Пишите, если есть вопросы. | https://habr.com/ru/post/131065/ | null | ru | null |
# Знакомство с GStreamer: Источники данных
Здравствуй, хабраюзер, интересующийся фреймворком GStreamer! Сегодня мы поговорим о источниках медиа-данных (sources), и тем самым продолжим курс статей посвященный GStreamer.
Предыдущая статья: [Знакомство с GStreamer: Введение](http://habrahabr.ru/post/178813/).
#### Вступление
Источники данных — это класс плагинов GStreamer который позволяет читать медиаданные из различных источников, таких как файловая система или аудио-входы звуковой карты. Также, они позволяют получать медиапоток с различных серверов потокового вещания, такие как HTTP (ICECast, ShoutCast), RTSP, RTMP, TCP и UDP. А еще имеется возможность читать данные с DVB карт, CDDA-дисков (народе известных просто как «компакт-диски»), и еще много всего, при помощи различных плагинов, которых на данный момент около 30.
*Примечание: как говорилось в прошлой статье, источники данных имеют только один pad с названием src, так как его можно подключить к другому элементу, но к нему подключить ничего нельзя.*
В этой статье мы разберем некоторые (пожалуй, наиболее востребованные) источники данных, напишем немного кода на Python и узнаем много нового.
#### Поехали
##### 0. gst-launch-1.0
Утилита gst-launch-1.0 позволяет запускать GStreamer pipeline без написания единой строчки кода. Я буду ее использовать для запуска небольших примеров, и что нам требуется знать сегодня — так это то, что запуск pipeline имеет примерно такой вид:
```
gst-launch-1.0 описание-pipeline
```
а описание pipeline, в свою очередь, делится на описание элементов вида
```
element1 property1=value1 property2=value2 ! element2
```
Вроде в этой схеме все понятно, есть элемент типа element1 с свойствами property1 и property2 которые имеют значения value1 и value2 соответственно, и есть элемент типа element2. Символ «!» указывает на то, что выход element1 необходимо соединить с входом element2.
На этом возможности gst-launch не ограничиваются, просто в сегодняшней статье они нам не пригодятся и будут рассмотрены в дальнейшем.
##### 1. filesrc
filesrc — на мой взгляд, это самый часто используемый источник мультимедийных данных. Как можно понять из его названия, он является элементом для чтения данных из файлов. В прошлой статье мы рассматривали схему примитивного плеера, в котором фигурировал filesrc как источник данных.
Элемент filesrc имеет несколько параметров. Рассмотрим некоторые из них.
###### location
Свойство location должно содержать путь к файлу, из которого необходимо производить чтение.
**Пример:** /foo/bar.mp3
###### blocksize
Данный параметр устанавливает размер буфера чтения. Значение должно быть описано беззнаковым числом.
###### num-buffers
Количество блоков, после прочтения которых будет отправлено сообщение EOS.
Свойства blocksize и num-buffers можно не указывать. В этом случае будут использованы значения по умолчанию. А еще указанные свойства имеются у всех источников данных, и далее рассматриваться не будут.
Пример использования источника filesrc возьмем из предыдущей статьи:
```
gst-launch-1.0 filesrc location=/foo/bar.mp3 ! decodebin ! autoaudiosink
```
##### 2. souphttpsrc
Элемент souphttpsrc предоставляет возможность чтения данных поверх HTTP (HTTPS) протокола. Чтение может производиться как из обычного файла, доступного через HTTP протокол, так и с ICECast/ShoutCast сервера. Также данный элемент позволяет производить чтение данных поверх протоколов ICY и ICYX. По данным протоколам я никакой информации найти не смог.
souphttpsrc имеет чуть больше параметров чем filesrc, рассмотрим наиболее важные.
###### location
Данный параметр аналогичен одноименному параметру элемента filesrc, за исключением того, что поддерживаются только схемы URI http, https, icy или icyx.
###### user-agent
Название говорит само за себя — данный параметр устанавливает, какой использовать User-Agent при отправке HTTP-запросов.
###### automatic-redirect
Устанавливает автоматический переход в случае, если сервер ответил, что ресурс был перемещен (статусы 301 и 302).
###### user-id и user-pw
Данные свойства устанавливают имя пользователя и пароль, на случай, если ресурс требует авторизации (HTTP Basic Authentication).
###### proxy, proxy-id и proxy-pw
Данные свойства устанавливают адрес прокси сервера, имя пользователя и пароль для авторизации (если необходимо). Поддерживаются HTTP и HTTPS прокси.
Использование источника souphttpsrc, ничем не отличается от использования источника filesrc:
```
gst-launch-1.0 souphttpsrc location=http://radio.localhost:1234 ! decodebin ! autoaudiosink
```
##### 3. giosrc
В наборе плагинов GStreamer имеется интересный элемент giosrc. Это почти то же самое что и filesrc, только работает он через библиотеку [GIO](https://developer.gnome.org/gio/stable/), и позволяет получать данные из различных источников с которыми может работать GIO. Таких источников 22, начиная от file, заканчивая mtp. Также, данный элемент поддерживает протоколы ftp, sftp, smb и webdav.
Данный элемент имеет параметры аналогичные элементу filesrc. Пример использования данного источника аналогичен использованию предыдущих:
```
gst-launch-1.0 giosrc location=ftp://ftp.localhost/foo/bar.mp3 ! decodebin ! autoaudiosink
```
##### 4. rtspsrc
Как можно понять из названия, данный элемент позволяет читать данные с RTSP сервера. Подробно рассматривать свойства данного элемента не будем, скажу только то, что он имеет свойство location для указания адреса источника данных, proxy, proxy-id и proxy-pw для указания настроек прокси, и с десяток свойств специфичных для RTSP протокола, рассмотрение которого не входит в наши планы.
Но, у rtspsrc есть одна особенность, у него несколько pad-ов, и имеют они названия подходящие под шаблон source\_%u. Это связано с тем, что сервер может транслировать несколько потоков одновременно, например, аудио и видео могут быть разбросаны по двум потокам.
**Примечание:**
Я не знаком c протоколом RTSP, поэтому я мог ошибиться в предположении выше.
Пример использования rtspsrc аналогичен предыдущим элементам:
```
gst-launch-1.0 rtspsrc location=rtsp://rtsp.localhost/movie.mp4 ! decodebin ! autoaudiosink
```
##### 5. multifilesrc
Суть элемента multifilesrc такая же, как и у элемента filesrc — читать файлы с диска, но имеется одно отличие — multifilesrc читает файлы последовательно (1.mp3, 2.mp3...), в то время как filesrc может читать только по одному файлу. У данного элемента есть один недостаток — имена файлов должны различаться только числом, например, file-1.mp3, file-2.mp3 и так далее. Но такой недостаток можно списать в разряд фич, так как с помощью данного «недостатка» можно с легкостью слепить из изображений 0000.png-9999.png видеоролик из фотографий, ну или мелодию из семплов, или микс из треков.
Элемент multifilesrc имеет немного параметров, и как ни странно — они все полезные. Рассмотрим их подробнее.
###### location
Путь к файлу может (и должен) включать в себя [управляющую последовательность](http://ru.wikipedia.org/wiki/Printf#.D0.A1.D1.82.D1.80.D1.83.D0.BA.D1.82.D1.83.D1.80.D0.B0_.D1.83.D0.BF.D1.80.D0.B0.D0.B2.D0.BB.D1.8F.D1.8E.D1.89.D0.B5.D0.B9_.D0.BF.D0.BE.D1.81.D0.BB.D0.B5.D0.B4.D0.BE.D0.B2.D0.B0.D1.82.D0.B5.D0.BB.D1.8C.D0.BD.D0.BE.D1.81.D1.82.D0.B8) %d, которая будет автоматически заменена с помощью функции sprintf() на число равное текущему индексу.
**Пример:** /foo/bar-%04d.mp3
###### index, start-index и stop-index
Данные свойства содержат в себе текущий индекс, стартовый индекс, и финальный индекс. Данные свойства содержат целочисленное число.
###### loop
Данное свойство может содержать булево значение, и в случае если оно равно true — чтение файлов будет зациклено. Грубо говоря, это аналог функции «Repeat All».
Пример использования элемента multifilesrc который читает файлы с именами начиная от bar-1.mp3 с включенной опцией loop:
```
gst-launch-1.0 multifilesrc location="/foo/bar-%d.mp3" loop=true start-index=1 ! decodebin ! autoaudiosink
```
##### 6. fdsrc
На мой взгляд, самый бесполезный элемент. Читает данные из файлового дескриптора. Может применяться когда лень описывать filesrc для gst-launch.
Данный элемент имеет один параметр:
###### fd
Данный параметр должен содержать число, равное открытому файловому дескриптору. По умолчанию равняется нулю.
Пример использования:
```
cat /foo/bar.mp3 | gst-launch-1.0 fdsrc ! decodebin ! autoaudiosink
```
##### 7. fakesrc
Как следует из названия, данный элемент ничего не делает — он просто является dummy-источником пустых буферов.
##### 8. alsasrc, pulsesrc, osssrc, jackaudiosrc, autoaudiosrc
Данные элементы предназначены для получения потока с микрофонного входа звуковой карты. Из названий следует, что они используются для работы с различными звуковыми подсистемами, такими, как Alsa, PulseAudio, OSS, Jack. Элемент autoaudiosrc является «оберткой» над остальными элементами, и упрощает разработку, забирая на свои плечи всю работу по выбору источника звука.
Свойств у данных элементов не очень много. Основным свойством является *device*, оно присутствует в первых трех элементах и должно содержать название девайса (hw:0, hw:1...). Остальные свойства используются специфичны для каждой звуковой подсистемы, и рассматривать мы их не будем.
##### 9. v4l2src
Этот элемент предназначен для открытия видеопотока через интерфейс [Video4Linux2](http://ru.wikipedia.org/wiki/Video4Linux). Интерфейс V4L2 поддерживает большинство веб-камер, ТВ-тюнеры, DVB-карточки и карточки видеозахвата.
Рассмотрим наиболее важные параметры:
###### device
Указывает имя устройства с которого нужно производить захват. Узнать список доступных устройств можно с помощью
```
ls -l /dev/v4l/by-id
```
В качестве значения этого параметра должен быть указан полный путь к устройству.
**Пример:** device=/dev/video0
###### hue, saturation, contrast. brightness
Данные параметры отвечают за цветовой баланс, насыщенность, контраст и яркость соответственно. Конечно же, если устройство видеозахвата не поддерживает данные параметры, то изображение будет таким, каким его отдает устройство. Значения этих свойств должны находиться в диапазоне от -2147483648 до 2147483647.
Пример использования элемента:
```
gst-launch-1.0 v4l2src ! xvimagesink
```
##### 10. audiotestsrc
Этот элемент аналогичен элементу fakesrc, но отличается тем, что генерирует реальный аудиосигнал. Его можно использовать как для тестирования сложных pipeline запущенных посредством gst-launch, для тестирования работоспособности pipeline в написанном приложении, а также его можно использовать как эталонный генератор для измерения АЧХ и искажений которые вносят разнообразные фильтры.
Рассмотрим наиболее интересные параметры данного элемента.
###### wave
Данный параметр устанавливает форму сигнала. Доступно 13 значений: *sine, square, saw, triangle, silence, white-noise, pink-noise, sine-table, ticks, gaussian-noise, red-noise, blue-noise, violet-noise*.
###### volume
Не сложно догадаться, что этот параметр устанавливает уровень сигнала (громкость). Допустимые значения располагаются в диапазоне от 0 до 1.
###### freq
Это свойство устанавливает частоту сигнала, и значение может располагаться в диапазоне от 0 до 20000.
Пример использования элемента audiotestsrc:
```
gst-launch-1.0 audiotestsrc wave=saw freq=205 ! autoaudiosink
```
##### 11. videotestsrc
Этот элемент, как и audiotestsrc, используется для генерации тестовых данных, а именно, видеопотока. Его можно использовать как для проверки работоспособности всего pipeline, или же для проверки на наличие искажений которые вносятся фильтрами.
Параметров у этого элемента очень много, рассмотрим мы только один, самый интересный на мой взгляд.
###### pattern
Данный параметр устанавливает шаблон видеосигнала. Допустимым значением может быть одно из 21. Полный список: *smpte, snow, black, white, red, green, blue, checkers-1, checkers-2, checkers-4, checkers-8, circular, blink, smpte75, zone-plate, gamut, chroma-zone-plate, solid-color, ball, smpte100, bar*.
На всех значениях останавливаться не буду, скажу только то, что значения smpte, smpte75 и smpte100 — это настроечные таблицы [SMPTE](http://en.wikipedia.org/wiki/Society_of_Motion_Picture_and_Television_Engineers) которые применяются в настройках теле/видео-аппаратуры. Шаблоны checkers-\* — это сетка NxN пикселей, где N равняется числу в имени шаблона. Остальные же значения устанавливают шаблон с монотонным изображением, например заливку цветом.
Пример использования:
```
gst-launch-1.0 videotestsrc pattern=smpte ! xvimagesink
```
#### Пояснения
Выше мы рассмотрели 15 основных источников данных, это где-то половина от всех имеющихся плагинов из категории source. Остальные плагины не были рассмотрены по двум причинам:
* Они узкоспециализированные;
* У меня отсутствуют необходимые «железки» для проверки того или иного плагина.
При рассмотрении плагинов были опущены многие параметры, так как в основном все они используются для «тонкой настройки», а у нас, как вы помните, идет знакомство с GStreamer. Или же данные параметры доступны только для чтения. Чтобы получить список всех доступных свойств, а так же допустимые для них значения, достаточно выполнить `gst-inspect-1.0 <имя_элемента>`, например:
```
gst-inspect-1.0 filesrc
```
и в секции «Element Properties» вы можете наблюдать все свойства (в том числе и унаследованные).
#### Примеры
Сегодня мы рассмотрим один простой пример использования GStreamer. В примере я буду использовать Python 2.7, GStreamer 1.0 и GObject Introspection.
Сразу оговорюсь, код может быть не идеальным, и может быть даже так называемым «говнокодом», но его единственное назначение показать, как использовать GStreamer, не более.
##### Простой плеер
Данный пример показывает, как проводится связывание элементов, как обрабатываются сообщения и изменяются свойства элементов.
**Код плеера**
```
#env python2
# coding=utf-8
import gi
gi.require_version("Gst", "1.0")
gi.require_version("Gtk", "3.0")
from gi.repository import Gst
from gi.repository import Gtk
from gi.repository import GObject
import os
import signal
import argparse
Gst.init("")
signal.signal(signal.SIGINT, signal.SIG_DFL)
GObject.threads_init()
def parse_args():
parser = argparse.ArgumentParser(prog='example1.py')
parser.add_argument('--volume', help='Указать громкость (0-100)', type=int, default=100)
parser.add_argument('location')
args = parser.parse_args()
return args
class Player():
def __init__(self, args):
self.pipeline = self.create_pipeline(args)
## получаем шину по которой рассылаются сообщения
## и вешаем на нее обработчик
message_bus = self.pipeline.get_bus()
message_bus.add_signal_watch()
message_bus.connect('message', self.message_handler)
## устанавливаем громкость
self.pipeline.get_by_name('volume').set_property('volume', args.volume / 100.)
def create_source(self, location):
"""create_source(str) -> Gst.Element"""
if not args.location.startswith('http') and not os.path.exists(args.location):
raise IOError("File %s doesn't exists" % args.location)
if location.startswith('http'):
source = Gst.ElementFactory.make('souphttpsrc', 'source')
else:
source = Gst.ElementFactory.make('filesrc', 'source')
source.set_property('location', location)
return source
def create_pipeline(self, args):
"""create_pipeline() -> Gst.Pipeline"""
pipeline = Gst.Pipeline()
## Создаем нужные элементы для плеера
source = self.create_source(args.location)
decodebin = Gst.ElementFactory.make('decodebin', 'decodebin')
audioconvert = Gst.ElementFactory.make('audioconvert', 'audioconvert')
volume = Gst.ElementFactory.make('volume', 'volume')
audiosink = Gst.ElementFactory.make('autoaudiosink', 'autoaudiosink')
## decodebin имеет динамические pad'ы, которые так же динамически
## необходимо линковать
def on_pad_added(decodebin, pad):
pad.link(audioconvert.get_static_pad('sink'))
decodebin.connect('pad-added', on_pad_added)
## добавляем все созданные элементы в pipeline
[pipeline.add(k) for k in [source, decodebin, audioconvert, volume, audiosink]]
## линкуем элементы между собой по схеме:
## *src* -> (decodebin + audioconvert) -> volume -> autoaudiosink
source.link(decodebin)
audioconvert.link(volume)
volume.link(audiosink)
return pipeline
def play(self):
self.pipeline.set_state(Gst.State.PLAYING)
def message_handler(self, bus, message):
"""Обработчик сообщений"""
struct = message.get_structure()
if message.type == Gst.MessageType.EOS:
print('Воспроизведение окончено.')
Gtk.main_quit()
elif message.type == Gst.MessageType.TAG and message.parse_tag() and struct.has_field('taglist'):
print('GStreamer обнаружил в потоке мета-теги')
taglist = struct.get_value('taglist')
for x in range(taglist.n_tags()):
name = taglist.nth_tag_name(x)
print(' %s: %s' % (name, taglist.get_string(name)[1]))
else:
pass
if __name__ == "__main__":
args = parse_args()
player = Player(args)
player.play()
Gtk.main()
```
Примеры запуска этого скрипта:
```
python2 ./example1.py /foo/bar.mp3
python2 ./example1.py --volume 50 /foo/bar.mp3
python2 ./example1.py http://myradio.localhost:5678/foo.mp3
```
В случае, если все пойдет как нужно — вы услышите нужный вам трек и увидите список ID3 тегов, если таковые имеются.
Пример доступен на [GitHub](https://github.com/POPSuL/gst-examples).
#### Ну вот и все
Сегодня мы рассмотрели около половины имеющихся источников данных которые доступны «из коробки», рассмотрели примеры запуска этих элементов, а также рассмотрели пример простого плеера основанного на GStreamer. В следующих статьях мы будем рассматривать остальные классы плагинов, рассмотрим еще больше примеров использования GStreamer, и конечно же, напишем больше кода.
До встречи через неделю!
#### Литература
1. [GStreamer Application Development Manual](http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/index.html)
2. [GStreamer Core Plugins Reference Manual](http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gstreamer-plugins/html/)
3. [GStreamer Base Plugins Reference Manual](http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-base-plugins/html/)
4. [GStreamer Good Plugins Reference Manual](http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/)
5. [Video4Linux](http://ru.wikipedia.org/wiki/Video4Linux)
6. [GIO Reference Manual](https://developer.gnome.org/gio/stable/ch01.html)
7. [The ID3v2/Shoutcast standart](http://jicyshout.sourceforge.net/oreilly-article/java-streaming-mp3-pt2/java-streaming-mp3-pt2.html)
8. [SHOUTCast](http://en.wikipedia.org/wiki/SHOUTcast)
UPD 1: Добавлены элементы audiotestsrc, videotestsrc.
[Предыдущая статья](http://habrahabr.ru/post/178813/) | [Следующая статья](http://habrahabr.ru/post/204014/) | https://habr.com/ru/post/179167/ | null | ru | null |
# Уменьшаем кол-во запросов requestAction-ов с помощью Cache
[В документации](http://book.cakephp.org/view/434/requestAction) Cakephp 1.2 говорится о том что если requestAction используется без кеширования, то это может уменьшить производительность.
*If used without caching requestAction can lead to poor performance. It is rarely appropriate to use in a controller or model.*
И правда, сами подумайте, каждый раз при просмотре сайта, кроме основных запросов, к базе делается куча мелких, с помощью requestAction-ов, например…
И как истинные политики, они говорят ЧТО может произойти, при этом не говоря КАК этого избежать.
Привожу пример того, КАК с этим разбираюсь я.
Коротко, о том как работает requestAction:
requestAction обычно используется вo view-файле (папка views). из view-файла, вы делаете запрос на другую страницу, и получаете значение.
синтаксис requestAction-а таков: `$this->requestAction('/articles/home');`
который говорит Cakephp что надо сделать запрос по адресу адрес.сайта.сom/articles/home
в самом контроллере к которому обращается requestAction надо прописать return;
`function home(){
$out = $this->Article->find('all');
Cache::write('articleHome', $out);
return $out;
}`
теперь мы можем смело дописать к $this->requestAction('/articles/home'); следующие строки
`$out = Cache::read('articlesHome');
if(empty($out)){
$out = $this->requestAction('/articles/home');
}`
После этого, мы один раз делаем запрос к базе, пишем все в файл. и остальные разы читаем из файла. Если в результате какие-то проблем со стороны НЛО мы не сможем прочитать файл из кеша, ничего страшного. Опять делаем запрос к базе, и опять пишем в файл (у попа была собака...)
и теперь при каждом обновлении этого списка, если мы что-то добавили/изменили не забываем перезаписывать Cache:
`Cache::write('articleHome', $out);`
crosspost с [моего блога](http://azaziz.blogspot.com/2009/09/resuestaction-cache.html) | https://habr.com/ru/post/69401/ | null | ru | null |
# Chaos engineering: Начало
Всем привет! Это моя первая статья в пространстве хабра, и на написание данной статьи меня сподвигли недавние проблемы в гигантах it индустрии. Пересказывать произошедшее я не буду, но вот кое-какие выводы из это сделать можно.
Как показала практика от сбоев в IT системах никто не застрахован, даже у мамонтов индустрии. А убытки от простоев, после таких событий, достигают заоблачных цифр. К примеру, простои от последних событий для Facebook обошлись в миллиарды долларов.
Сбои неизбежны – это факт, но когда – это вопрос. Компаниям нужны решения здесь и сейчас, и эти решения предлагает молодое направление в IT – **Chaos Enginering**. Материала на данную тематику уже написано не мало, но очень мало в русскоязычных сообществах, их можно по пальцам перечитать. В рамках данной статьи я хочу поделиться своим опытом Chaos Enginering, так сказать простыми русскими словами.
Так случилось, что я попал в число первопроходцев по Chaos Enginering в России, и поверти на слово - «не так страшен черт, как его малюют», но всё же есть подводные камни.
Кому интересна история зарождения Chaos, на habr есть отличная статья-перевод, первая часть [здесь](https://habr.com/en/company/flant/blog/460367/). А я в свою очередь не буду ходить вокруг да около и начну прямо с примеров.
Основа направления *Chaos Enginering - что-то специально сломать*, имитируя события из реальной жизни, *чтоб* *посмотреть, что произойдёт* и как ваши системы с этим справятся.
Представите обычный интернет-магазин на микро-сервисах. Микро-сервис Б возвращает какое-либо свойство по товару. Микро-сервис А взаимодействует с микро-сервисом Б, и обрабатывает получаемые значения. Микро-сервисы находятся на разных серверах/облаках. Так вот сеть в этом всём организме является оптимальным звеном для наших экспериментов с хаосом.
Chaos Engineering делится на простые этапы:
Теперь давайте пройдемся по этим этапам на примере нашего магазина
1) Так как это магазин, то стабильная метрика кол-во продаж на единицу времени, вроде логично. Замеряем и получаем 10 продаж в минуту, это стабильное состоянии. (гипотетическая закадровая нагрузка где-то там присудствует)
2) Придумываем гипотезу. Наши микросерсвисы находятся в разных местах, и общаются через сеть, то логично отключить сеть между микросервисами или отключить один из микросервисов и посмотреть, что будет с нашим магазином. Я понимаю, что сейчас это звучит глупо, и если вы с этой идей пойдете к своим руководителям или клиентам, вас поднимут на смех, со словами, у нас есть реплики, балансеры и так далее. Но в этом и один из смыслов chaos engineering, проверить, так ли хороши системы HA на практике.
3) Так как мы не можем отключить сеть или как-то повлиять на неё (можем, но речь сейчас не об этом), мы просто запланировали отключение сервера/облака.
4) Замеряем кол-во продаж и что мы видим, а видим мы 0 (нуль). Магазин не работает.
5) Разбираемся почему это случилось и как исправить.
В ходе разбирательства оказалось, что java http клиент в миросервисе А не обрабатывал исключения таймаута и/или connection reset, обработка строилась только на http кодах 200-500. Исправили, починили, запустили сервисы и повторно провели эксперимент. Ура! Всё прошло удачно. Данный эксперимент можно поставить на поток в пострелизное время.
Да, пример весьма глупый, но он раскрывает суть Chaos Engineering. Любая и даже самая глупая гипотеза моделирования «реальных сбоев» должна быть поэкспериментировала в рамках вашей системы IT, особенно это касается сетей.
Теперь давайте подумаем, как вам строить системы хаоса в ваших компания, и что может пригодиться в этом не легком поприще.
Запомните одно из правил - Нельзя просто открыть поисковик, напечатать «хаос инженеринг, скачать без смс и регистрации» и запускать на ваших ресурсах всё что вы найдете. Оно так не работает и работает вообще не так.
В первую очередь, хаос должен быть целенаправленный и спланированный. Вы должны понимать, что вы собираетесь ломать, когда вы собираетесь ломать, как вы это будете ломать, и самое главное, как наблюдать, что происходит с вашей системой, когда вы её ломаете. Разрушения без замеров – не даст вам понимания, что произошло, соответственно вы не поймете как исправить.
В пространстве интернета, по поиску Chaos Enginering вы наверняка найдете ссылки содержащие слова: Chaos monkey, gremlin, chaos mesh, litmus, pumba, chaos toolkit и многие другие. Некоторые из них вы не сможете даже реализовать под свои нужны, но большую часть, я вам не советую даже запускать. В лучшем случае вы не получите результатов, в худшем вы обрушите ваши сервера, после чего разочаруетесь в данном направлении и прибегните к старому дедовскому НТ.
Chaos Enginering должен строится под конкретную компанию, под конкретное направление в компании или под отдельно взятый проект. Выстраивать его надо обдуманно, начиная с локальных разрушений.
Начните с самого простого. Допустим, используйте утилиту stress-ng. Нагрузите процессор на сервере приложений до 100% и проверяйте как это отобразится на работе основного приложения и какие тайминги будут доступны, время запросов и ответов
Пример команды для 4 ядер: `stress-ng --cpu 4 -v --timeout 30s`
Удачные эксперименты будут внушать доверие, и с подвигать вас на более сложные решения, в итоге проводя эксперименты в production среде, ведь **конечная цель Chaos Enginering – это production** системы.
Инструментов для хаоса много, некоторые из них я уже перечислил выше, но все они делятся на *4 основные группы сбоев приложения: вычислительные ресурсы, сеть, хранилище, инфраструктура*.
Вернёмся к нашему интернет магазину, чтоб провести эксперимент по отключению сервера (группа сбоев инфраструктура), не обязательно скачивать что-то необычное, наверняка у вас есть ansible. С помощью не сложных усилий можно организовать отключение случайного сервера:
```
- name: "Вычисляем жертву"
host: localhost
tasks:
- set_fact:
random_server: "{{ server_list | random | json_query('name') }}"
- name: "Отключаем жертву :)"
host: {{ random_server }}
tasks:
- shell: poweroff
when: random_server is define
```
Собственно, правильно дописав этот playbook под ваши нужны, это уже будет второй эксперимент в вашей библиотеке хаоса, который вы можете использовать.
На текущий момент я разрабатываю свои архитектуры Chaos Enginering способные работать с платформами k8s, openshift, docker, и с классическими bare-metal. Добавлены возможности в автоматическом режиме собирать метрики с систем мониторинга (Zabbix, Prometheus), запускать и останавливать инструменты «разрушения», формировать отчеты проведённого эксперимента.
Если тематика интересна, то в следующих статьях я постараюсь подробно рассматриваться, тестировать и описывать различные инструменты хаоса, предоставленных на рынке.
Спасибо за внимание. | https://habr.com/ru/post/583806/ | null | ru | null |
# Переиспользуемый компонент Svelte: чтобы никому не было больно
Компонентные фреймворки независимо от названия никогда не покинут область только нишевого использования, если сообщество не будет создавать для них общедоступные компоненты, которые можно легко встроить в свой проект.
За последние года полтора для фреймворка Svelte уже создано множество различных компонентов, которые можно найти на [NPM](https://www.npmjs.com/search?q=svelte), [GitHub](https://github.com/search?q=svelte) или [официальном списке](https://sveltesociety.dev/components/). К сожалению, не все из них правильно "приготовлены" и порой их использование раздует размер бандла приложения сильнее, чем должно быть. А бывает, что такие пакеты просто невозможно использовать, потому что его автор не силён в подготовке пакетов и упустил какие-то важные моменты.
В этой статье я расскажу как сделать и опубликовать npm-пакет со Svelte-компонентом так, чтобы им смогли воспользоваться все желающие, не получив при этом головной боли от неожиданных проблем.
Создаем компонент
-----------------
Для примера решим, что мы хотим представить миру компонент, который выводит часы с анимацией смены цифр. Посмотрим на его прототип в работе [тут](https://svelte.dev/repl/f06cba26970b4d0394e60d5b20b22f0b?version=3.32.0). Обратим внимание, что весь наш компонент состоит из трех файлов. Также у него имеется внешняя зависимость в виде библиотеки `'dayjs'`.
Для начала понадобится пустая папка. Открыв её в терминале, инициализируем создание нового npm-пакета:
```
npm init
```
Будет предложен ряд вопросов, первый из которых захочет узнать название нашего будущего пакета. По негласному правилу пакеты, содержащие Svelte-компоненты, принято называть с префиксом `svelte-`, так что назовем наш пакет, например, `svelte-clock-demo`. Это правило совершенно необязательно, но сильно упростит поиск компонента другими людьми. Также этому поспособствует и хороший набор ключевых слов, которые нужно перечислить через запятую в одном из следующих вопросов. Оставшиеся вопросы заполняйте на свое усмотрение, можно оставить значения по умолчанию нажатием клавиши *Enter*.
Теперь наша папка уже не пуста, в ней появился файл `package.json` к которому мы вернемся чуть позже, а пока создадим новую папку `components` рядом с этим файлом, куда поместим все файлы нашего компонента `'App.svelte'`,`'Sign.svelte'` и `'flip.js'`.
Также не забудем и про внешнюю зависимость, добавим её в пакет командой:
```
npm install dayjs
```
Необходимо указать сборщикам Svelte-проектов, где в папке находится файл компонента, чтобы они могли импортировать его. Для этого откроем файл `package.json` и заменим строку `"main":"index.js",` на:
```
...
"svelte":"components/App.svelte",
...
```
В принципе, этого уже достаточно, можно опубликовать пакет в таком виде и большинство разработчиков смогут использовать его в своем проекте. Но большинство – это ещё не все...
Нужны модули
------------
На текущий момент нашим пакетом смогут пользоваться только разработчики, которые делают свой Svelte-проект c настроенным сборщиком, который умеет работать с полем `"svelte"` в `package.json`. Но кроме этого, было бы неплохо если бы наш компонент могли использовать разработчики, которые делают проект на другом фреймворке или вообще без каких-либо фреймворков. Для них мы должны упаковать компонент в модули с которыми они смогут работать не настраивая плагинов для компиляции Svelte файлов в своих проектах.
**ES6 модуль** обычно используется при работе со сборщиками вроде Webpack или Rollup. Он должен содержать скомпилированный в JavaScript код нашего Svelte-компонента, а так же все CSS-стили, которые относятся к нашему компоненту. Однако, в модуль не должны быть включены внешние зависимости и различные вспомогательные функции из пакета `svelte`, например, переходы из `svelte/transition` или хранилища из `svelte/store`, а так же функции из `svelte/internal`. В противном случае, если пользователю понадобится использовать несколько различных пакетов, то в каждом из них будет своя копия фреймворка Svelte, что скажется на размере итогового бандла самым негативным образом.
**IIFE модуль** нужен для непосредственного использования в браузере в теге `</code>. Файлы таких модулей обычно кладут рядом с html-файлом, либо подключают с какого-либо CDN, вроде <a href="https://www.jsdelivr.com" rel="nofollow noopener noreferrer">jsdelivr.com</a> или <a href="https://unpkg.com" rel="nofollow noopener noreferrer">unpkg.vom</a>. Поскольку для таких модулей не существует никаких общепринятых механизмов управления зависимостями, то они должны быть самодостаточные и включать в себя всё, что необходимо для работы, включая все импорты из пакета <code>svelte</code>, а так же внешние зависимости – такие как, <code>dayjs</code> из нашего примера. </p><br/>
<p>Для сборки компонента в модули нам понадобится бандлер. Их существует великое множество – Webpack, Rollup, Parcel и другие. Но лично я, в последнее время использую в своих проектах сборщик <a href="https://esbuild.github.io/" rel="nofollow noopener noreferrer">esbuild</a>, он написан на Go, что позволяет ему собирать проекты невероятно быстро, также он достаточно прост в настройке и умеет оптимизировать бандл tree-шейкингом и минификацией. К нему в компанию нам понадобятся плагин <code>esbuild-svelte</code> и сам <code>svelte</code>. Установим все эти пакеты в dev-зависимости:</p><br/>
<pre><code class="plaintext"> npm install --save-dev esbuild esbuild-svelte svelte</code></pre><br/>
<p>Пакет <code>svelte</code> мы установили в dev-зависимости, поскольку он нам нужен для компиляции кода компонента в Javascript-код. В проектах, которые захотят использовать наш пакет вероятнее всего уже будет установлен <code>svelte</code> и все нужные импорты будут браться из него. Однако, возможна ситуация, когда этот пакет не будет установлен, а разработчик, используя наш ES6 модуль, получит сообщение об отсутствии зависимости. Чтобы избежать этой неприятной ситуации, добавим в <code>package.json</code> секцию с peer-зависимостью.</p><br/>
<pre><code class="json">...,
"peerDependencies": {
"svelte": "3.x"
},
...</code></pre><br/>
<p>Значение <code>3.x</code> говорит, что мы не требуем какой-то определенной версии Svelte, главное чтобы она не была 2й и возможно в будущем 4й, с которыми скомпилированный ES6 модуль вероятнее всего не будет совместим.</p><br/>
<p>Теперь при установке нашего пакета, если у пользователя не найдётся <code>svelte</code> в <code>node\_modules</code>, будет предложено его установить. А NPM начиная с 7й версии сделает это автоматически.</p><br/>
<p>Укажем бандлерам и CDN-сервисам где искать нужные им модули внутри нашего пакета. Для этого сразу под под полем <code>"svelte":...,</code> в <code>package.json</code> добавим ещё несколько полей:</p><br/>
<pre><code class="json"> ...
"module":"dist/clock.mjs",
"cdn":"dist/clock.min.js",
"unpkg":"dist/clock.min.js",
...</code></pre><br/>
<p>К сожалению, среди CDN сервисов нет общепринятого поля из которого они забирают путь до нужного модуля. Неофициально, некоторыми сервисами, например <a href="http://jsdelivr.com" rel="nofollow noopener noreferrer">Jsdelivr</a> поддерживается поле <code>"cdn"</code>, но для других необходимо прописывать поля, которые они требуют. Поэтому, нам пришлось добавить также поле <code>"unpkg"</code>. </p><br/>
<h2 id="konfiguraciya-esbuild">Конфигурация esbuild</h2><br/>
<p>В папке проекта создадим файл <code>esbuild.js</code> с таким содержанием:</p><br/>
<pre><code class="javascript">const {build} = require(`esbuild`);
const sveltePlugin = require(`esbuild-svelte`);
// Берем содержимое package.json в виде объекта pkg
const pkg = require(`./package.json`);
// Настраиваем плагин компиляции Svelte файлов
const svelte = sveltePlugin({
compileOptions:{
// Все стили будут упакованы вместе с компонентом
css: true
}
});
// Собираем IIFE-модуль
build({
// Откуда и куда собирать модули узнаем в package.json
entryPoints: [pkg.svelte],
outfile: pkg.cdn,
format: 'iife',
bundle: true,
minify: true,
sourcemap: true,
plugins: [svelte],
// Задаём имя глобальной переменной для доступа к модулю
globalName: 'svelteClock',
})
// Собираем ES-модуль
build({
entryPoints: [pkg.svelte],
outfile: pkg.module,
format: 'esm',
bundle: true,
minify: true,
sourcemap: true,
plugins: [svelte],
// Просим не включать в модуль зависимости из разделов
// dependencies и peerDependencies в файле package.json
external: [
...Object.keys(pkg.dependencies),
...Object.keys(pkg.peerDependencies),
]
})</code></pre><br/>
<blockquote>Информацию про параметры конфигурации esbuild можно узнать в <a href="https://esbuild.github.io/api/#simple-options" rel="nofollow noopener noreferrer">документации</a>. </blockquote><p>Добавим в <code>package.json</code> в раздел <code>"scripts"</code> скрипт для запуска esbuild:</p><br/>
<pre><code class="json"> ...
"scripts": {
...
"build":"node esbuild",
...
}</code></pre><br/>
<p>Теперь можно запустить сборку модулей: </p><br/>
<pre><code class="plaintext"> npm run build</code></pre><br/>
<p>В результате в папке нашего проекта появится еще одна директория <code>dist</code> внутри которой будут два готовых файла модулей и файлы sourcemap, которые позволят легче отслеживать ошибки в компоненте, если таковые возникнут у пользователей.</p><br/>
<p><img src="https://habrastorage.org/r/w1560/webt/tr/mo/nw/trmonwjx8mph84nhdg2sxwiekdi.png" alt="Текущая структура файлов" data-src="https://habrastorage.org/webt/tr/mo/nw/trmonwjx8mph84nhdg2sxwiekdi.png"/></p><br/>
<h2 id="readmemd">Readme.md</h2><br/>
<p>Добавьте файл <code>README.md</code> в папку проекта, из него пользователи смогут узнать, как работать с вашим компонентом. Многие согласятся, что написать документацию, описывающую все нюансы работы с компонентом, задача, возможно, ещё более трудная, чем придумать сам этот компонент и правильно его собрать. Могу только порекомендовать указать назначение компонента, объяснить зачем он нужен людям. Показать примеры использования в других svelte-проектах, иных проектах и браузере. Если компонент конфигурируется при помощи экспортируемых свойств или отправляет какие-либо события, обязательно опишите как с этим работать. Писать документацию стоит на английском языке, поскольку вашим компонентом будут пользоваться люди со всего мира.</p><br/>
<h2 id="publikaciya-paketa">Публикация пакета</h2><br/>
<p>Вся необходимая подготовка проведена и мы готовы собрать и отправить наш пакет с компонентом на NPM. По умолчанию в пакет попадают все файлы и папки, которые содержатся в папке проекта, кроме директории <code>node\_modules</code> и некоторых других специфичных файлов. Также не нужно включать в пакет файл <code>esbuild.js</code>, поскольку он нужен только на этапе сборки модулей. Для исключения определенных файлов папок из пакета воспользуемся файлом <code>.npmignore</code>, внутри которого на каждой строчке нужно указать какие файлы не должны попадать в пакет. В нашем случае это всего один файл — <code>esbuild.js</code>. В более сложных проектах там стоит перечислить папки содержащие тесты и исходники, которые не нужны в собранном пакете.</p><br/>
<p><img src="https://habrastorage.org/r/w1560/webt/fj/u6/0o/fju60oqsgaqiuf75x2yu-nm\_y\_a.png" alt="Содержимое .npmignore" data-src="https://habrastorage.org/webt/fj/u6/0o/fju60oqsgaqiuf75x2yu-nm\_y\_a.png"/></p><br/>
<p>Каждый раз при публикации новой версии пакета мы должны не забыть выполнить скрипт <code>npm run build</code>, который поместит в папку <code>dist</code> актуальные версии модулей. Чтобы автоматизировать этот процесс добавьте в секцию <code>"scripts"</code> в <code>package.json</code> ещё один скрипт:</p><br/>
<pre><code class="json"> ...
"scripts": {
...
"prepublish":"npm run build",
...
}</code></pre><br/>
<p>Если вы все сделали верно, то целиком файл <code>pacakge.json</code> должен выглядеть примерно так:</p><br/>
<pre><code class="json">{
"name": "svelte-clock-demo",
"version": "1.0.0",
"description": "Animated clock component for Svelte",
"svelte": "components/App.svelte",
"module":"dist/clock.mjs",
"cdn":"dist/clock.min.js",
"unpkg":"dist/clock.min.js",
"scripts": {
"build":"node esbuild",
"prepublish":"npm run build",
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Vasya Pupkin",
"license": "ISC",
"dependencies": {
"dayjs": "^1.10.4"
},
"devDependencies": {
"esbuild": "^0.8.43",
"esbuild-svelte": "^0.4.1",
"svelte": "^3.32.2"
},
"peerDependencies": {
"svelte": "3.x"
}
}
</code></pre><br/>
<p>Наконец, всё готово и можно авторизоваться своей учетной записью в NPM и опубликовать пакет:</p><br/>
<pre><code class="plaintext"> npm login
npm publish</code></pre><br/>
<p>Пакет будет доставлен в NPM и станет доступным для загрузки всеми желающими. А вам останется наблюдать за количеством установок вашего пакета и своевременно исправлять обнаруженные пользователями баги.</p><br/>
<h2 id="ispolzuem-pereispolzuemyy-komponent">Используем переиспользуемый компонент</h2><br/>
<p>Итак компонент уже опубликован. Теперь можно его установить в папке какого-либо своего проекта:</p><br/>
<pre><code class="plaintext"> npm install --save-dev svelte-clock-demo</code></pre><br/>
<p>Если это проект Svelte-приложения, то импортируйте и используйте как обычный компонент:</p><br/>
<pre><code class="html"><script>
import Clock from 'svelte-clock-demo';`
Если же это проект, в котором нет настроенного компилятора Svelte, то будет импортирован ES6 модуль, и компонент инициализируется следующим образом:
```
import Clock from 'svelte-clock-demo';
new Clock({
// Указываем элемент DOM, куда будет отрисован компонент
target: document.getElementById('divForClock'),
// Передаём свойства компоненту
props:{
background: 'white',
color: 'black'
}
})
```
Практически таким же образом можно использовать модуль прямо с CDN. Обычно после публикации пакета на NPM, через пару минут его версия появляется и в различных CDN сервисах, например [jsdelivr.com](https://jsdelivr.com).
```
Страница с часами
// Имя глобальной переменной было задано в конфигурации esbuild
new svelteClock.default({
// Указываем элемент DOM, куда будет отрисован компонент
target: document.getElementById('divForClock'),
// Передаём свойства компоненту
props:{
background: 'white',
color: 'black'
}
})
```
Библиотека компонентов
----------------------
Иногда в один пакет нужно поместить больше, чем один-единственный компонент. Яркий пример, различные библиотеки UI элементов, состоящие из компонентов вроде `Input`,`Button`, `Checkbox` и т.п.
В нашем пакете тоже можно предоставлять пользователю не только готовый компонент часов из `App.svelte`, но и компонент отдельной цифры `Sign.svelte`. Тогда разработчики смогут сделать на его основе, например, таймер обратного отсчета или какой-либо счетчик.
Для создания библиотеки компонентов, добавим в папку `components` файл `index.js` внутри которого сделаем ре-экспорт всех компонентов, которые мы хотим сделать доступными в нашем пакете.
```
export {default as Clock} from './App.svelte';
export {default as Sign} from './Sign.svelte';
```
Затем нужно поменять значение поля `"svelte"` в `package.json`, указав там путь до файла `index.js`.
```
...
"svelte":"components/index.js",
...
```
После публикации пакета, можно импортировать только нужные компоненты:
```
import {Sign} from 'svelte-clock-demo';
```
Заключение
----------
В статье мы не коснулись темы тестирования, а так же организации процесса разработки самого компонента. Но не стоит ими пренебрегать в своих проектах, поскольку без них сделать качественный пакет с минимальным количеством багов практически невозможно.
Если возникнут вопросы про публикацию компонентов, их использование или в целом по фреймоврку Svelte, ответы всегда можно получить в русскоязычном [чате сообщества Svelte в Telegram](https://t.me/sveltejs). | https://habr.com/ru/post/541834/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.