text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как я делал комикс-игру по Лавкрафту
Привет, Хабр! Это будет история о тернистом пути разработки 2D-квеста в сеттинге миров Говарда Филлипса Лавкрафта, который целиком оформлен в виде интерактивного комикса. Ну то есть все в игре, начиная от головоломок и заканчивая интерфейсом — это один бесшовный комикс. Если вас заинтересовала такая концепция, прошу под кат, где будет больше гифок, технические детали и опыт публикации на основных платформах.
#### Об игре
Я немного ~~рисую~~ пытаюсь рисовать и эта игра началась с такого вот рисунка. Микро-комикс с яхтой, бушующим морем и героем, вглядывающимся в таинственный остров на горизонте. С декором в лавкрафтовском духе (ну вы знаете, осьминоги, тентакли и все такое). А еще, с отсылочкой к другому признанному мастеру жанра ужасов. *Кто скажет к какому?*
И я подумал: а ведь игра, оформленная в комикс стилистике — это круто, броско и необычно! Таких игр существует совсем мало. Я могу вспомнить три. Конечно же, это легендарная «Comix Zone», шутер «XIII» (тринадцатый) и не целая игра, а эпизод в «What Remains of Edith Finch». Но делать в одиночку / вдвоем платформер или FPS-шутер, для независимого разработчика — непозволительная роскошь — слишком много анимации, слишком сложно, слишком много времени потребуется и высока вероятность, что игра может вообще не дожить до релиза. Нет, я знаю, что есть люди умудряющиеся разрабатывать платформер в течение 8 лет (Owlboy) и при этом, не растерять мотивацию. Я искренне восхищаюсь и немного завидую таким людям, но боюсь, это не мой случай. А вот игра в жанре puzzle / point-and-click — это совсем другое дело! Тем более, опыт в создании 2D-головоломок у меня есть — некоторые могут помнить меня как автора серии головоломок «Механическая Коробка». Итак, решено! Сеттинг — произведения Г.Ф. Лавкрафта, жанр — point-and-click, визуальный стиль — комикс.
Но делать просто интерактивный комикс или визуальную новеллу, мне не хотелось. Мне хотелось, чтобы этот проект стал больше игрой, чем литературой. И тут помогло еще одно мое увлечение — история видеоигр. Я вспомнил, что недавно читал об одной текстовой компьютерной игре, основная идея которой, мне показалась довольно необычной и интересной.
Игра называлась «Hunt the Wumpus». Это классическая текстовая игра, написанная Грегори Йобом в 1972 году. Как гласит «Википедия», это первая в истории текстовая, а также первая приключенческая компьютерная игра, которая была чрезвычайно популярна в 70-80-е годы прошлого века.
Вкратце, суть игры заключалась в следующем: игрок попадает в лабиринт, который представляет собой 20 пронумерованных комнат, каждая из которых соединена коридорами с тремя другими. То есть карта такого лабиринта — это замкнутый граф. Впрочем, давайте не будем углубляться во всякие термины, на самом деле, все очень просто! В этом лабиринте обитает опасный монстр — Вампус, задача игрока, исследуя лабиринт, найти и подстрелить этого монстра.
В начале игры, игрок оказывается в случайной комнате лабиринта. За один ход он может перейти в одну из трех соседних комнат, либо выстрелить в нее. В комнате, игрок может почувствовать сквозняк, отвратительное зловоние или услышать странный шум. Сквозняк говорит о том, что в одной из соседних комнат — бездонная яма — упав в нее, вы проиграете. Шум издают гигантские летучие мыши, если войти в комнату с ними, они хватают игрока и переносят в другую, выбранную случайно, комнату лабиринта. Ну а зловоние означает что в какой-то из трех соседних комнат находится Вампус. Если игрок оказывается в одной комнате с ним, Вампус его съедает.
Таким образом, путешествуя по лабиринту и запоминая признаки находящихся рядом опасностей, можно составить представление об их расположении и подстрелить Вампуса, точно понимая, где он находится. На самом деле, можно привести в качестве примера еще одну, более распространенную игру с подобной механикой. Это всем известный «Сапер». «Охота на Вампуса», в общем-то, еще один вариант с несколькими типами «мин».
Возвращаясь к Лавкрафту, наш герой направляется морем в Новую Англию, но, очевидно, его планам не суждено сбыться, так как:
> На семнадцатый день путешествия, страшная буря возникает будто бы из ниоткуда, унося обреченный корабль все дальше и дальше в неизведанные воды. Фрегат терпит крушение, а главный герой приходит в себя на песке бухты, окруженной неприступными скалами. От единственного выхода из бухты, вырубленного прямо в утесе, веет необычайной древностью...
Это вход в подземелья Храма Безымянных Культов, где в лучших традициях Лавкрафта главного героя не ждет ничего кроме безумия и смерти (в целых шести вариантах концовок!). Подземелья представляют из себя лабиринт из игры «Hunt the Wumpus», но вместо Вампуса в лабиринте обитает Дагон — покровитель Глубоководных. Его нельзя убить сразу, а можно только ранить — все-таки, один из меньших божеств пантеона мифов Ктулху — это вам не шутки! А в роли гигантских летучих мышей здесь прислужник Древних — Шоггот — бесформенная масса протоплазмы с тысячей глаз, щупалец и других невообразимых конечностей. От Шоггота можно убежать. Побег реализован в виде мини-игры, где нужно на время решать простенькие загадки, выбирая одну из трех дверей. Мой экспромт на тему QTE (Quick Time Event) — довольно распространенного приема в видеоиграх, когда нужно быстро выполнять какие-то действия, нажимать определенные клавиши.
Кроме такой вот вариации на тему «Сапера», в качестве мета-игры, конечно, должны быть головоломки и другие мини-игры — все что присуще классическим квестам. Я не стал ничего изобретать и решил использовать старые, проверенные временем механики — «пятнашки», «вращающиеся элементы», «подбери комбинацию» и тому подобное. Естественно, все аккуратно должно быть вписано в лавкрафтовский сеттинг. Ниже гифка с парой примеров.
#### Разработка
Первый прототип на Unity я собрал довольно быстро, примерно за неделю. И пусть меня закидают тапками, но я понял одну простую вещь — Unity мне не подходит. Да, удобный визуальный редактор, да, море информации, за счет популярности движка. Но… Я большую часть времени потратил на то, чтобы понять, как же из имеющихся кубиков собрать то, что мне нужно. Вместо того, чтобы делать и использовать кубики «нужной формы». Ну и некоторые вещи мне кажутся просто странными (с непривычки, наверное). Например, «зашитые» в анимацию стартовые координаты: если в анимации объект начинает свое движение с позиции (0,0), то при применении этой анимации к объекту, он прыгает на (0,0) в независимости от своего текущего положения. Вы скажете: так это же надо было скачать из Asset Store! Возможно…
В общем, я выбрал более привычный и понятный мне фреймворк — LibGDX. Это кроссплатформенный, бесплатный движок на Java. Я где-то слышал мнение, что Unity — это о быстром конструировании, а LibGDX о красивой архитектуре, коде. То есть LibGDX ближе программистам, а Unity тем, кто наоборот, хочет меньше кода и больше «действия». Из плюсов LibGDX так же стоит отметить легковесность и быстродействие, за все время разработки я не сталкивался с проблемами, что где-то, что-то тормозит. Ну и то, что это Java, для кого-то может послужить решающим фактором.
MENJ4-2R5ZJ-HD7AQ
Имея на руках прототип, я стал искать художника, так как понял, что ни требуемое качество, ни объем арта, мне самостоятельно — не вытянуть. На форуме gamedev.ru, на мое объявление откликнулся замечательный художник — Сергей Ковалев. Все эти клевые гифки, которые вы тут видите — его рук дело. Там же, нашелся и композитор — Максим Грачев. Гифки звук не передают, конечно, но все, кто играл в игру, говорят, что звук в игре — очень атмосферный. Для каждого из нашей маленькой команды, это был проект «в свободное время». Поэтому, долго ли, коротко ли, но спустя полгода выходных и вечеров после работы, игра приблизилась к завершению.
#### Публикация
Так как это Java, то билды под разные платформы, по сути, сводятся к поставке одного и того же кода с нужной для платформы JRE (Java Runtime Environment). Я сразу решил выпускать игру для всех основных ОС: Windows, Mac, Linux, Android и iOS. Не буду подробно останавливаться на мобильных сторах, а расскажу лучше о Steam. Тем более, это мой первый опыт размещения игры в магазине от Valve.
С недавних пор, продавать свои игры в Steam может любой желающий, достаточно пройти процедуру регистрации и заплатить взнос в 100$ (за каждую игру). Регистрация занимает несколько дней, Steam якобы проверяет данные, заполненные по налоговой форме W-8BEN. Не очень понятно, зачем, правда. В других случаях, когда мне приходилось заполнять эту форму, хватало просто ксерокопии.
Так или иначе, когда вы попадаете в Steamworks и проходит первый шок от количества кнопочек, меню, пунктов и подпунктов в нем, приходит время создать страницу игры. Здесь все стандартно: скриншоты, видео, набор промо-арта, описания на разных языках (если вы сделали локализацию, конечно). Страница должна пройти премодерацию. В моем случае, все прошло быстро и почти гладко. Первый раз страницу отклонили, пояснив, что на промо изображениях должно быть хорошо читаемое название игры и когда я исправил это замечание, страницу приняли.
После утверждения, страница становится видна всем пользователям, и игра попадает в категорию «Скоро выйдет». Можно собирать и загружать билд. Расскажу немного подробнее как это происходит в случае с LibGDX. Во-первых, надо сделать чтобы игра запускалась на весь экран, для этого добавляем в DesktopLauncher следующий код:
```
LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
config.vSyncEnabled = true;
config.width = LwjglApplicationConfiguration.getDesktopDisplayMode().width;
config.height = LwjglApplicationConfiguration.getDesktopDisplayMode().height;
config.fullscreen = true;
```
Во-вторых, нам нужно собрать бандл из исполняемого файла (стартера), нашего jar файла, который будет исполняться и JVM под нужную платформу. Для этого есть множество инструментов. Я бы акцентировал внимание на двух: это, многим знакомая утилита, [Launch4J](http://launch4j.sourceforge.net/). И [Packr](https://github.com/libgdx/packr), разработанный командой LibGDX. Что использовать, дело вкуса, лично мне ближе Packr. Делаем конфигурационный файл и одной строкой собираем билд, например, под Linux (можно хоть автоматически):
**Пример конфигурации для Packr**
```
{
"platform": "linux64",
"jdk": "/Users/me/Documents/builds/jdk1.8.0_191-linux-x64.zip",
"executable": "My-Game",
"classpath": [
"desktop.jar"
],
"output": "EFIBB-ZIY32-8Q569",
"mainclass": "com.puzzle.comix.desktop.DesktopLauncher",
"vmargs": [
"Xmx1G"
]
}
```
Далее, нам нужно загрузить сборки в Steam, их у меня три: для Windows, Mac и Linux. Описание этого процесса есть в документации (на русском), поэтому, я просто перечислю ключевые пункты:
1. В Steamworks создать «Хранилища» для соответствующих ОС. Я создал «Windows content», «Mac content» и «Linux content».
2. Там же включить эти «Хранилища» в «Комплекты».
3. Скачать SDK Steamworks — с помощью него происходит загрузка в Steam.
4. В примерах скриптов загрузки заменить ID приложения и хранилищ на свои. Прописать локальный путь к файлам игры.
5. Запустить загрузчик. В моем случае (Mac OS), команда выглядит так:
```
bash ./steamcmd.sh +login "user" "password" +run_app_build ../scripts/app_build_xxxxxx.vdf +quit
```
Вот, собственно, и все. У меня раза три вылетел steamcmd с ошибкой сервера 500, с четвертого раза все загрузилось. После этого отправляем уже сам билд игры на модерацию. Плюс 4-5 дней и можно нажимать заветную зеленую кнопку «Опубликовать».
#### Альтернативные площадки
Сейчас, как грибы после дождя, появляются альтернативные Steam магазины: Discord, GOG, Green Man Gaming и т.д. Все активно обсуждают анонс собственной площадки от Epic Games (есть надежда, что у них получится составить реальную конкуренцию Steam). А я хочу сказать пару слов про itch.io. Если вы меня спросите, как я вижу идеальный магазин для разработчика? Я без колебаний отвечу — itch.io. Я понимаю, что идеальный магазин для разработчика и для игрока — это немного разные вещи. И вообще itch — это утопия. Но как же классно и просто здесь все сделано! Мега-удобный редактор страницы игры, все очень продуманно, быстро и современно. Никакого нагромождения кнопок и действий, всего пару-тройку кликов и ваша игра доступна всему миру!
Проблема одна, та же, что и у всех альтернативных сторов — небольшая аудитория. Я получил фичеринг на главной странице, просто написав создателю itch.io в почту (да, это возможно и даже несложно). И с учетом этого, у игры было всего ~200 просмотров страницы в день и несколько ленивых продаж.
Но то небольшое сообщество, которое здесь есть — очень дружелюбное! У itch есть такая фишка: вы выставляете минимальную, «обязательную» цену игры, а покупатель может ее увеличить по своему желанию, чтобы поддержать разработчика. И такие продажи, выше установленной цены, вполне частое явление! В отличие от Steam, где токсичности и комментариев «купил бы за 15 руб» — слишком уж много.
Да, игра небольшая. Скорее-всего, если быстро вникнете в суть и не застрянете на какой-нибудь головоломке, вы сможете пройти ее за час. Я понимаю, что заработать какие-то серьезные деньги у игры шансов нет. Поэтому, в Steam я поставил максимально честную и бюджетную цену в 99 руб. Пожалуй, ни для кого такая сумма не будет существенной. Тем не менее, требуют скидку в 50%, пишут про 15 руб и вообще «раздавать бесплатно для продвижения имени разработчика» (чтобы это не значило). Впрочем, я отвлекся. Просто это мое «больное место». Я, как никто, знаю сколько усилий вложено в этот условный час геймплея и меня это задевает, признаю.
#### Маркетинг
Расскажу о нескольких мероприятиях, которые я предпринял, чтобы как-то заявить об игре. Во-первых, Keymailer. Этот сервис на слуху, но будет не лишним рассказать принцип его работы. Вы регистрируете игру и загружаете в сервис какое-то количество Steam-ключей для раздачи блогерам. С другой стороны, блогеры регистрируются в сервисе и могут запрашивать у вас ключи, чтобы сделать обзор игры. В теории, звучит неплохо. Но это только в теории. Жаль я не погуглил предварительно отзывы про Keymailer.
Этот сервис монетизируется за счет разработчиков, я ничего не имею против, просто имейте в виду. На бесплатной подписке, практически весь функционал обрезан. Я закинул 50$ на рекламу — игра отображается неделю где-то на видном месте Keymailer-а. Да, запросов на ключи от «блогеров» при этом значительно больше. Но, мне кажется, порочна сама идея этого сервиса, если задуматься. Более-менее крупному каналу не нужно заниматься запросами ключей через какой-то Keymailer, у них и контента хватает, и покупка новинок никаких сложностей не вызывает. Может я ошибаюсь, но мне показалось, что Keymailer используется, в основном, недобросовестными пользователями для выманивания бесплатных ключей, для себя или на перепродажу.
Я акцептовал запросы только от каналов с подписчиками (ну хотя бы 5-10 тыс.) и галками «Accredited» от Keymailer. Раздал 65 ключей, 47 из них активированы, еще 18 где-то до сих пор продаются, наверное (например, я нашел свою игру на плати.ру). В результате, я получил 6 (шесть) видео на YouTube и один твит. С парой десятков просмотров… Не повторяйте моих ошибок.
Но не все так печально. Неплохо показала себя старая-добрая рассылка писем вручную по Ютуберам. Потратив вечер и доказав Гуглу множество раз что «Я не робот», я собрал на YouTube где-то 30 email-ов русскоязычных, подходящих летсплееров. Критерии отбора простые: обозревал инди игры, не очень много подписчиков (но и не совсем мало, я выбирал от 100 тыс.), не специализируется на ААА-играх, не специализируется на какой-то конкретной игре (Майнкрафт, Танки).
Дальше нужно правильное письмо. Если мне не изменяет память, эти советы я прочитал у Сергея Галенкина (ссылку давать не буду, известный человек в игровой индустрии). В моем свободном пересказе они звучат так:
1. Максимально лаконичное описание игры, не больше двух предложений: «Игра в сеттинге произведений Говарда Филлипса Лавкрафта, которая целиком оформлена в виде интерактивного комикса».
2. Что вы хотите? «Было бы круто, если бы вы поиграли в мою игру на канале».
3. Интересная гифка до 2 Мб прямо в теле письма (я вставил сундучок, который выше).
4. Ссылка на Steam и ключ. В общем, главное — это кратко и по сути.
И хочу сказать, что отклик вполне себе! Целых 4 канала опубликовали ролики по игре и даже один «миллионник» ответил на письмо. Это само по себе, достижение! Учитывая, что игра далеко не суперподходящая для стриминга. Правда, аналогичная рассылка по англоязычным блогерам, к сожалению, провалилась. То ли виноват мой неидеальный английский, то ли я не смог правильно подобрать целевые каналы.
#### Заключение
Уф! Пора уже подвести какие-нибудь итоги. Топик становится длиннее, чем я планировал. Давайте подведем финансовые, что ли. На Steam мы наторговали примерно 1000$, еще 70$ — itch (хочу пожертвовать их на развитие магазина), плюс с мобильных сторов должно набежать пару сотен долларов. Хороший ли это результат? Я считаю, неплохой! Учитывая, что в современном мире для инди почти не осталось места, если ты не «звезда», конечно. А я обычный «середнячок», надо признать. И хоть игра получилась небольшой, но именно такой, как я себе представлял. А главное, законченной и цельной. Так что я доволен.
*P.S. Извините за некоторый сумбур повествования, строить четкие, последовательные тексты у меня всегда получалось плохо. С удовольствием расскажу о пропущенных деталях в ответах на вопросы. P.P.S. Обожаю пасхалки и секреты, поэтому в этом топике спрятано три Steam-ключа к игре. Разбирайте!* | https://habr.com/ru/post/431218/ | null | ru | null |
# Натуральный Geektimes — делаем пространство чище
Читая Geektimes я постоянно хотел отключить редакторов, ведь они делают из саморегулирующегося сообщества со свободно возникающими статьями очередной адми или что-то подобное.
После того, как пару дней назад на главной странице я увидел пост "[Школьник расшарил обнажённое фото с телефона учительницы, за что её уволили](https://geektimes.ru/post/272068/)" уже почти пришло решение — больше никогда не приду сюда, еще один ресурс в минус.
Причина такого решения думаю всем понятна — мало кому понравится принудительное кормление таким информационным шлаком. Администрация не хочет давать возможность настройки и отключения редакторов — это ее право. Мое право уйти с ресурса.
Однако, спасибо [lexasss](https://geektimes.com/users/lexasss/), нашлось решение самостоятельной настройки ленты, которым я и хочу поделиться. Повторюсь, идея и совет пришли от [lexasss](https://geektimes.com/users/lexasss/), я лишь публикую это для тех, кто как и я хочет отключить отображение постов от определенных пользователей.
Обновление от 2018 года — рекомендую использовать скрипт от [Keyten](https://geektimes.com/users/keyten/) опубликованный [тут](https://geektimes.com/post/272194/).
### Удаляем посты юзеров в Хроме
Итак, чтобы удалить редакторов в Хроме надо установить расширение Tampermonkey BETA, создать новый скрипт и там поставить код
```
// ==UserScript==
// @name Habr editor blocker
// @description Hides articles that were posted by certain authors
// @match https://geektimes.ru/*
// @version 1
// @grant none
// ==/UserScript==
// @namespace http://tampermonkey.net/
var authors = [
'alizar',
'marks',
'ivansychev',
'ragequit',
'SLY_G',
];
var posts = document.querySelectorAll('.post');
for (var idx = 0; idx < posts.length; ++idx) {
var post = posts[idx];
for (var i = 0; i < authors.length; ++i) {
var selector = '.post-author__link[href$="/' + authors[i] + '/"]';
var blockedAuthor = post.querySelector(selector);
if (blockedAuthor) {
post.style.display = 'none';
break;
}
}
}
```
Где
'alizar',
'marks',
'ivansychev',
'ragequit',
'SLY\_G',
это список пользователей, посты которых не будут отображаться. Вы можете настроить список сами.
### Удаляем посты юзеров в Firefox
Установите GreaseMonkey, создайте новый скрипт, скопируйте туда это:
```
// ==UserScript==
// @name Habr editor blocker
// @description Hides articles that were posted by certain authors
// @include https://geektimes.ru/*
// @version 1
// @grant none
// ==/UserScript==
var authors = [
'alizar',
'marks',
'ivansychev',
'ragequit',
'SLY_G',
];
var posts = document.querySelectorAll('.post');
for (var idx = 0; idx < posts.length; ++idx) {
var post = posts[idx];
for (var i = 0; i < authors.length; ++i) {
var selector = '.post-author__link[href$="/' + authors[i] + '/"]';
var blockedAuthor = post.querySelector(selector);
if (blockedAuthor) {
post.style.display = 'none';
break;
}
}
}
```
### Другие браузеры
Если браузер использует платформу Chrome (например Яндекс браузер, то там выполняются инструкции для Хрома, надо просто [зайти в магазин на страницу плагина](https://chrome.google.com/webstore/detail/tampermonkey-beta/gcalenpjmijncebpfijmoaglllgpjagf) , установить его, и ура, все работает.
Еще раз спасибо [lexasss](https://geektimes.com/users/lexasss/) и всем хороших праздников!
Обновление от 2018 года — рекомендую использовать скрипт от [Keyten](https://geektimes.com/users/keyten/) опубликованный [тут](https://geektimes.com/post/272194/). | https://habr.com/ru/post/391233/ | null | ru | null |
# Подробный разбор простого приложения на Rust
Начнём с самого простого и, при этом, самого важного вопроса...
Что мы будем разрабатывать?
---------------------------
Первый этап, практически, любой разработки - выработка требований. Нужно определиться, какую проблему будет решать наше приложения и какой набор возможностей для этого будет предоставлять.
С проблемой мы определились ещё в первом абзаце - хранить заметки. Можно обдумать некоторые детали, например:
1. Где хранить заметки?
2. Как выводить заметки?
3. Какой пользовательский интерфейс будет у приложения?
На эти вопросы можно придумать множество разных ответов:
1. Хранить заметки можно в: памяти, файле, базе данных...
2. Выводить заметки можно: в порядке добавления, в алфавитном порядке, по датам...
3. Варианты пользовательского интерфейса: в командной строке, графический, веб-интерфейс...
Остановимся на самых простых вариантах, чтобы приложение было максимально простым:
1. Храним заметки в памяти. Это означает, что наши заметки будут существовать, только пока запущено приложение.
2. Выводить их будем в порядке добавления, а значит, нам не потребуется дополнительная сортировка.
3. Пользовательский интерфейс организуем через командную строку, а следовательно, мы сможем обойтись без сторонних библиотек, так как функционал для работы с командной строкой (стандартный ввод/вывод), обычно, присутствует в стандартной библиотеке\* большинства языков.
\*стандартная библиотека - набор программных сущностей, доступных для вызова из любой программы, написанной на этом языке и присутствующих во всех реализациях языка.
Итак, у нас получился список возможностей нашего приложения. Теперь нам нужно свести каждую задачу к набору действий, которыми нас обеспечивает выбранный язык программирования, его стандартная библиотека, либо сторонние библиотеки. Этот процесс называют декомпозицией задачи.
Декомпозиция задачи
-------------------
Для начала определимся со способом хранения каждой заметки: пусть это будет обычная Rust-строка (тип `String`). На самом деле, Rust-строки не совсем обычные. Они хранят свои данные в UTF-8 кодировке, предоставляя возможность использовать в тексте не только любой язык, но и различные вспомогательные символы, например, эмодзи.
Далее, нам нужно найти способ хранить введённые пользователем заметки. Для хранения данных обычно используют структуры данных. Существует множество различных структур данных. Каждая предоставляет различные возможности по добавлению/удалению элементов и доступу к ним. Сейчас нам нужно уметь добавлять новые заметки в конец списка и выводить их все разом в порядке добавления. Для этого мы будем использовать одну из самых простых структур данных - вектор (тип `Vec`). Он представляет собой непрерывную в памяти последовательность элементов, размер которой может расти по мере добавления элементов в конец последовательности. Как раз, то, что нужно.
Теперь опредилимся с выводом заметок. Мы решили использовать интерфейс коммандной строки для взаимодействия с пользователем. Для этого воспользуемся макросом `println!`, который предоставляет Rust для передачи строк в стандартный вывод. Макросы в раст - очень мощный и довольно сложный инструмент. Разбор этого механизма выходит за рамки статьи. Остановимся на том, что использование макроса `println!` позволяет передавать произвольное число параметров, которые будут подставлены в строку-шаблон для последующего вывода на экран. Пример:
```
println!("Меня зовут {}. Мне {} лет.", "Иван", 30);
// Вывод:
// Меня зовут Иван. Мне 30 лет.
//
// Фигурные скобки заменились на текстовую интерпретацию значений,
// перечисленных после строкового шаблона
```
Последнее, чего нам не хватает - это механизм, позволяющий читать пользовательский ввод в нашем интерфейсе командной строки. Для этого воспользуемся абстракцией над стандартным вводом, которую предоставляет стандартная библиотека - типом `Stdin`. Данный тип позволяет получать данные из стандартного ввода, как в виде сырого потока байт, так и интерпретируя ввод в виде строк. Нам интересен последний вариант.
Теперь, имея инструментарий для всех необходимых нам действий, можно приступить к созданию проекта и написанию кода.
Установка инструментов разработки Rust
--------------------------------------
Все операции над исходным кодом Rust производит с помощью набора приложений, установить которые можно воспользовавшись [инструкцией с официального сайта](https://www.rust-lang.org/tools/install).
Создание проекта
----------------
Теперь, когда все необходимые инструменты установлены, воспользуемся менеджером пакетов cargo для создния проекта:
```
cargo new notes_list
```
Данная команда создаст директорию с названием notes\_list, в которую поместит следующие элементы:
* `Cargo.toml` файл, содержащий базовую конфигурацию проекта.
* Поддиректорию `src` с файлом `main.rs`, содержащим исходный код hello world приложения.
* Пустой git репозиторий.
Перейдя в директорию `notes_list`, можно убедиться, что созданный нами шаблонный проект собирается и запускается:
```
cargo run
```
В результате, мы должны увидеть информацию о сборке и запуске приложения:
```
Compiling notes_list v0.1.0 (/home/f3/work/otus/notes_list)
Finished dev [unoptimized + debuginfo] target(s) in 0.44s
Running `target/debug/notes_list`
```
А также вывод приложения:
```
Hello, world!
```
Формируем алгоритм
------------------
Для начала, сформируем общий алгоритм работы программы:
1. Создаём вектор, в котором будут хранится заметки.
2. Выводим пользовательское меню в терминале.
3. Читаем ввод пользователя.
4. Если пользователь ввёл команду "show", отображаем все заметки из вектора.
5. Если пользователь ввёл команду "add", то читаем пользовательский ввод и добавляем новую заметку.
6. Если пользователь ввёл что-то другое, выходим из программы.
Нам нужно, чтобы пользователь мог добавлять/просматривать заметки многократно, поэтому пункты 2-6 будем выполнять циклично, повторяя их, пока не будет выполнено условие пункта 6 для выхода из программы.
Пишем код
---------
Опишем в общем виде логику программы, согласно сформированному алгоритму:
```
fn main() {
// Создаём мутабельный вектор, в котором будут храниться заметки и
// сохраняем его в переменную `notes`.
let mut notes = Vec::new();
// Запускам цикл, который будет выполнять операции многократно,
// пока не дойдёт до операции `break` - выход из цикла.
loop {
// Вызываем функцию для вывода меню.
print_menu();
// Читаем строковую команду, введёную пользователем и
// сохраняем её в переменную `command`.
let command = read_input();
// Сравниваем команду с шаблонами и указываем действие для каждого:
match command.trim() {
// Если была введена команда для отображения заметок - отображаем.
"show" => show_notes(¬es),
// Если была введена команда для добавления заметок - добавляем.
"add" => add_note(&mut notes),
// Если пользователь ввёл что-нибудь другое - выходим из цикла.
_ => break,
}
}
}
```
Остановимся подробнее на некоторых моментах:
* `main()` - функция, с которой начнётся выполнение нашей программы. Программа завершиться, когда функция main закончит выполняться.
* `let` - ключевое слово для объявления переменной.
* `let mut` - объявление переменной, которую мы планируем менять.
* `Vec::new()` - вызов метода new для типа `Vec`. Данный метод вернёт нам экземпляр типа `Vec` без содержимого.
* `loop {...}` - цикл, выполняющийся бесконечно. Для выхода из него используется ключевое слово `break`, либо возврат из функции (`return`).
* `match {...}` - операция соспоставления с шаблоном. После ключевого слова `match` указывается то, что будем сопоствалять. В фигурных скобках, по очереди, указываются шаблоны (слева от `=>`) и операции (справа от `=>`), которые следует выполнять при совпадении с указанным шаблоном.
* `command.trim()` - обрезаем служебные символы в конце пользовательского ввода. При вводе в терминал строки и нажатии Enter, к строке добавляется символ переноса строки. Он нам не нужен и команда trim() его отбросит.
* `¬es` - ссылка на вектор с заметками. Ссылка позволяет читать данные из вектора.
* `&mut notes` - мутабельная ссылка на вектор с заметками. В отличии от `¬e`, позволяет менять данные вектора.
* `break` позволяет выйти из цикла. В нашем случае из цикла `loop`.
* После выхода из цикла завершится и функция `main`, а следовательно, и работа программы.
При попытке собрать приложение:
```
cargo build
```
Мы увидим ряд ошибок, в которых компилятор сообщает нам что не может найти функции:
* `print_menu()`,
* `read_input()`,
* `show_notes()`,
* `add_note()`.
Исправим это, реализовав их.
```
fn print_menu() {
println!();
println!();
println!("**** PROGRAM MENU ****");
println!("Enter command:");
println!("'show' - show all notes");
println!("'add' - add new note");
println!("other - exit");
}
```
Функция `print_menu()` не принимает аргументов и ничего не возвращает.
В каждой строке этой функции выводим на экран сообщения с помощью макроса `println!`.
В начале выводи две пустые строки, чтобы отделить текст от предудущего.
```
fn read_input() -> String {
// Создаём мутабельную строку, в которую будем читать пользовательский ввод.
let mut buffer = String::new();
// Получаем объект типа `Stdin` из функции `stdin()` и вызываем метод
// `read_line()` для чтения пользовательского ввода.
// В метод передаём мутабельную ссылку на ранее созданый буфер,
// в который будут записаны данные.
std::io::stdin().read_line(&mut buffer).unwrap();
// Возвращаем буфер с пользовательским вводом из функции.
buffer
}
```
Функция `read_input()` не принимает аргументов и возвращает строку.
Конструкция `std::io::stdin()` интерпретируется как вызов функции `stdin` из модуля `io` находящегося в модуле `std` (стандартная библиотека). Таким образом, запрашиваем у стандартной библиотеки объект, отвечающий за стандартный ввод. Далее, у этого объекта вызывается метод `read_line()`, читающий строку из стандартного ввода. Метод `read_line()` возвращает перечисление `Result`, в котором, при успехе, содержится количество считанных байт, а в случае неудачи - ошибка. Чтение данных из стандартного ввода в строку может закончиться неудачей, если, например, данные не являются корректной UTF-8 строкой. У полученного объекта типа `Result` мы вызываем метод `unwrap()`, который:
* В случае успеха, возвращает количество прочитанных байт, уже без обёртки. Оно нам не интересно и не используется в коде.
* При ошибке, происходит, так называемая, паника. Работа программы завершается с ошибкой.
Таким образом, у нас нет возможности прочитать, и после этого использовать некорректные данные.
```
fn show_notes(notes: &Vec) {
// Выводим пустую строку.
println!();
// Для каждой заметки в заметках ...
for note in notes {
// выводим её на экран.
println!("{}", note)
}
}
```
Цикл `for` позволяет пройти по всем элементам вектора. На каждой итерации выводим заметку на экран.
```
fn add_note(notes: &mut Vec) {
// Сообщаем пользователю, что можно вводить заметку.
println!();
println!("Enter note:");
// Читаем пользовательский ввод.
let input = read\_input();
// Получаем подстроку без служебных символов и преобразуем её в строку.
let note = input.trim().to\_string();
// Добавлем заметку в конец вектора.
notes.push(note);
}
```
Пользуемся написанной ранее функцией `read_input()` для чтения ввода пользователя.
`input.trim().to_string()` - Обрезаем с помощью метода `trim()` служебные символы у строки, содержащей пользовательский ввод и преобразуем полученную подстроку в строку, с помощью метода `to_string()`.
Теперь наше приложение будет работать и предоставлять все ожидаемые возможности. В этом можно убедиться запустив его (cargo run) и следуя его инструкциям.
Полный код:
```
fn main() {
// Создаём мутабельный вектор, в котором будут храниться заметки и
// сохраняем его в переменную `notes`.
let mut notes = Vec::new();
// Запускам цикл, который будет выполнять операции многократно,
// пока не дойдёт до операции `break` - выход из цикла.
loop {
// Вызываем функцию для вывода меню.
print_menu();
// Читаем строковую команду, введёную пользователем и
// сохраняем её в переменную `command`.
let command = read_input();
// Сравниваем команду с шаблонами и указываем действие для каждого:
match command.trim() {
// Если была введена команда для отображения заметок - отображаем.
"show" => show_notes(¬es),
// Если была введена команда для добавления заметок - добавляем.
"add" => add_note(&mut notes),
// Если пользователь ввёл что-нибудь другое - выходим из цикла.
_ => break,
}
}
}
fn print_menu() {
println!();
println!();
println!("**** PROGRAM MENU ****");
println!("Enter command:");
println!("'show' - show all notes");
println!("'add' - add new note");
println!("other - exit");
}
fn read_input() -> String {
// Создаём мутабельную строку, в которую будем читать пользовательский ввод.
let mut buffer = String::new();
// Получаем объект типа `Stdin` из функции `stdin()` и вызываем метод
// `read_line()` для чтения пользовательского ввода.
// В метод передаём мутабельную ссылку на ранее созданый буфер,
// в который будут записаны данные.
std::io::stdin().read_line(&mut buffer).unwrap();
// Возвращаем буфер с пользовательским вводом из функции.
buffer
}
fn show_notes(notes: &Vec) {
// Выводим пустую строку.
println!();
// Для каждой заметки в заметках ...
for note in notes {
// выводим её на экран.
println!("{}", note)
}
}
fn add\_note(notes: &mut Vec) {
// Сообщаем пользователю, что можно вводить заметку.
println!();
println!("Enter note:");
// Читаем пользовательский ввод.
let input = read\_input();
// Получаем подстроку без служебных символов и преобразуем её в строку.
let note = input.trim().to\_string();
// Добавлем заметку в конец вектора.
notes.push(note);
}
```
Итог
----
Выполнив ряд шагов, мы прошли от идеи до реализации простого прилжения:
1. Формирование требований,
2. Декомпозиция задачи,
3. Формирование алгоритма,
4. Написание кода.
На курсе [Rust developer](https://otus.pw/jAcX/) мы рассматриваем все концепции языка, переходя от простых, описанных выше, к более сложным, таким как трейты, обобщённое программирование, умные указатели, многопоточность, архитектура и другие.
* [Узнать о курсе подробнее](https://otus.pw/jAcX/) | https://habr.com/ru/post/692470/ | null | ru | null |
# Объекты Java
Под впечатлениями от [habrahabr.ru/blogs/java/134102](http://habrahabr.ru/blogs/java/134102/).
Недавно мне приходилось немного поковыряться внутри JVM. Довольно интересный опыт. Текст в вышеупомянутом топике не совсем сходится с моим опытом, но я не считаю себя обладателем абсолютной истины. Ниже я поделюсь с читателями небольшой частью моих экспериментов, которые касаются непосредственно объектов Java.
###### Тестовая система
Windows XP SP3 32bit
D:\dev\puzzles>java -version
java version «1.6.0\_29»
Java(TM) SE Runtime Environment (build 1.6.0\_29-b11)
Java HotSpot(TM) Client VM (build 20.4-b02, mixed mode, sharing)
#### Подготовка
Все эксперименты проводились с использованием утилитарного класса Unsafe. Описание класса нагло украдено с [wasm.ru](http://wasm.ru/article.php?article=unsjav1).
Малоизвестный класс sun.misc.Unsafe входит в комплект Sun Java Runtime начиная с первых версий. Как и все остальные классы в package sun.\*, Unsafe не документирован, но имена (в большинстве своем нативных) функций, видимые при декомпиляции, говорят сами за себя. Явно присутствуют функции работы с памятью (allocateMemory, freeMemory,...), чтения и записи значений по заданному адресу (putLong, getLong,...) и некоторые более специализированные (throwException, monitorEnter, ...).
Но, так просто инстанциировать Unsafe не удасться. Единственный конструктор — приватный, а в getUnsafe() проверяется загрузчик вызвавшего класса и объект возвращается только если класс загружен через Bootloader. В противном случае, получаем SecurityException.
```
public static Unsafe getUnsafe() {
Class class1 = Reflection.getCallerClass(2);
if (class1.getClassLoader() != null)
throw new SecurityException("Unsafe");
else
return theUnsafe;
}
```
К счастью существует еще внутренняя переменная theUnsafe, до которой можно добраться с помощью Reflection. Я собрал небольшой [вспомогательный класс.](https://gist.github.com/1498488)
```
import java.lang.reflect.Field;
import sun.misc.Unsafe;
public class T {
public static Unsafe u;
private static long fieldOffset;
private static T instance = new T();
private Object obj;
static {
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
u = (Unsafe) f.get(null);
fieldOffset = u.objectFieldOffset(T.class.getDeclaredField("obj"));
} catch (Exception ex) {
throw new RuntimeException(ex);
}
};
public synchronized static long o2a(Object o) {
instance.obj = o;
return u.getLong(instance, fieldOffset);
}
public synchronized static Object a2o(long address) {
u.putLong(instance, fieldOffset, address);
return instance.obj;
}
public static Unsafe get() {
return u;
}
}
```
Нам понадобятся операции взятия объекта по адресу и взятия адреса у объекта: o2a(Object o) и a2o(long address).
Теперь можно что-то смотреть.
#### Структура объекта
Рассмотрим работу следующего кода:
```
import sun.misc.Unsafe;
public class V {
private Integer b = 3;
private int a = 2;
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
long obj = T.o2a(new V());
for (int i = 0; i < 28; i++)
System.out.print(u.getByte(obj + i) + " ");
}
}
```
Данный код представляет собой класс, содержащий 2 приватных поля (int и Integer). Мы создаем экземпляр этого класса, узнаем его адрес в памяти, и выводим 28 байт.
Его результат в моем случае был следующим (я отформатировал вывод группами по 4 байта для большей ясности):
```
01 00 00 00
88 D7 79 32
02 00 00 00
D0 7C E4 22
01 00 00 00
E8 09 19 37
68 6F E4 22
```
Итак, что мы видим:
01 00 00 00 — это так называемый *magic*. Это [маска](http://www.google.com/codesearch#Y_pa0sa9c2w/src/share/vm/oops/markOop.hpp) объекта. Хранит различную информацию, например о локах. Подробнее в комментариях.
88 D7 79 32 — забегая вперед скажу, что это ссылка на объект класса.
02 00 00 00 — это значение нашего примитивного поля типа int.
D0 7C E4 22 — опять же, забегая вперед, скажу, что это ссылка на объект поля типа Integer.
А дальше… дальше это уже другой объект, лежащий рядом в памяти. Немного изменив наш код, можно это проверить.
```
import sun.misc.Unsafe;
public class V {
private int a = 2;
private Integer b = 777;
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
long obj = T.o2a(new V());
for (int i = 0; i < 28; i++)
System.out.print(u.getByte(obj + i) + " ");
long field = u.getAddress(obj + 3 * 4);
Object i = T.a2o(field);
System.out.print("\nInteger: " + i);
}
}
```
Результат:
```
01 00 00 00
98 D6 79 32
02 00 00 00
C8 FB E4 22
...
Integer: 777
```
В этом примере мы взяли адрес поля типа Integer, а затем взяли объект, лежащий по этому адресу. Результат подтвердил наши предположения.
Следующий пример подтвердит наши ожидания, касательно второго блока (адрес класса).
```
import sun.misc.Unsafe;
public class V {
private int a = 2;
private int b = 3;
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
long obj = T.o2a(new V());
V v = new V();
v.a = 5;
v.b = 6;
for (int i = 0; i < 32; i++)
System.out.print(u.getByte(obj + i) + " ");
}
}
```
Результат:
```
01 00 00 00
08 D6 79 32
02 00 00 00
03 00 00 00
01 00 00 00
08 D6 79 32
05 00 00 00
06 00 00 00
```
В этом примере я убрал ссылочные поля из класса. Создал 2 объекта, в одном из которых поменял значения полей. И, как результат, объекты попали в память рядом, и их можно отличить по значению примитивных полей.
Еще один пример с массивом:
```
import sun.misc.Unsafe;
public class V {
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
long obj = T.o2a(new Integer[] {1, 2, 3});
for (int i = 0; i < 28; i++)
System.out.print(u.getByte(obj + i) + " ");
}
}
```
```
01 00 00 00
B8 C9 79 32
03 00 00 00
40 78 E4 22
50 78 E4 22
60 78 E4 22
...
```
Массивы действительно хранят количество элементов в нем.
Пример со смещением:
```
import sun.misc.Unsafe;
public class V {
private Integer a = 1;
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
long obj = T.o2a(new V());
for (int i = 0; i < 28; i++)
System.out.print(u.getByte(obj + i) + " ");
}
}
```
Здесь я оставил у класса только одно поле.
Результат:
```
01 00 00 00
B0 D7 79 32
60 78 E4 22
00 00 00 00
01 00 00 00
E8 09 19 37
...
```
Здесь видно, что за ссылкой на значение поля типа Integer идет пустой блок из 4 байт. Все объекты дополняются до размера, кратного 8 байтам.
Пример со смещением:
```
import sun.misc.Unsafe;
public class V {
private int a = 2;
private int b = 3;
public static void main(String[] argv) throws Exception {
Unsafe u = T.get();
V v = new V();
synchronized (v) {
long obj = T.o2a(v);
for (int i = 0; i < 32; i++)
System.out.print(T.hex(u.getByte(obj + i)) + " ");
}
}
}
```
Здесь рассматриваемый объект находится в блоке синхронизации, в итоге значение первых 4 байт изменилось.
Результат:
```
8C 84 F0 00
58 D6 79 32
02 00 00 00
03 00 00 00
...
```
#### Выводы
Java объект состоит из:
4 байта — magic маска.
4 байта — адрес класса.
4 байта — размер массива (только в случае массивов разумеется).
n \* 4 байта — на каждое поле объекта (значение примитивного типа или ссылка на объект).
Все это дополняется до кратности 8 байтам.
Писал в спешке. Исправления, вопросы, пожелания ~~и лучи ненависти~~ приветствуются. | https://habr.com/ru/post/134910/ | null | ru | null |
# Все о Cisco FastLocation
Чем дальше погружаюсь в тему Wi-Fi позиционирования, тем очевиднее становится факт, что основная задача заключается не в достижении необходимой точности, а в получении необходимого количества замеров! Почему я так думаю?
Требования к плотности размещения точек доступа с каждым годом увеличиваются, что положительно сказывается на точности позиционирования, а вот частота замеров по Probe Request не становится выше, скорее наоборот.
В связи с этим многие производители разработали свои собственные инструменты для увеличения частоты замеров. Традиционно, одним из инноваторов в этой области выступает компания Cisco, которая вывела на рынок инструмент под названием Cisco FastLocation.
Давайте попробуем разобраться во всех нюансах этого инструмента.
FastLocate = Data RSSI
======================
Для начала что же подразумевается под маркетинговыми словами Cisco FastLocate? Если совсем кратко, то это замер уровня сигнала (RSSI) не по management пакетам Probe Request, а по пакетам данных (data). Такой режим замера называется “Data RSSI” (в дополнение к “Probe RSSI”). Далее в статье я буду использовать в зависимости от контекста и тот и другой термин.
FastLocate Release 8.0 vs FastLocate Release 10.2
=================================================
Технология Cisco FastLocation появилась в 2014 году, когда система позиционирования Cisco начала сильно эволюционировать.
На тот момент она имела достаточно ограниченный функционал, поддерживалась только на специально установленных модулях мониторинга WSM (Wireless Security Module), которые устанавливались в модульные, то есть топовые офисные точки доступа. Это была так называемый [FastLocate MSE Release 8.0](http://www.cisco.com/c/en/us/td/docs/wireless/controller/technotes/8-0/CMX_FastLocate_DG/b_CMX-FastLocate-DG.html).
Данную технологию мы рассматривать не будем, так как сейчас актуальна новая, совершенно переработанная версия [FastLocate CMX Release 10.2](http://www.cisco.com/c/en/us/td/docs/wireless/mse/release/notes/cmx_10_2_rn.html#pgfId-1553712).
Именно её мы будем тестировать с использованием контроллера Cisco WLC 2504 с версией ПО 8.1.131.20 и точек серии Cisco Aironet 3602.
FastLocate без использования дополнительных модулей
===================================================
Первый вопрос, который мне пришел в голову: можно ли делать Data RSSI без использования дополнительных модулей? В арсенале Cisco уже есть возможность перевести точку доступа в режим мониторинга (сканирования) всех каналов, есть гибридный режим работы, когда точка обслуживает как пользователей, так и сканирует смежные каналы. Можем ли мы использовать эти режимы для Data RSSI?
FastLocate в гибридном режиме ELM
---------------------------------
Если в 8-й версии CMX такое было невозможно, то к 10-й версии CMX такая опция появилась. У точек доступа Cisco есть специальный режим работы Enhanced Local Mode (ELM), в котором помимо обслуживания клиентов, точка доступа выполняет так называемый Off-Channel Scanning, то есть сканирует смежные каналы. Это происходит не без потери производительности, которая составляет порядка 15%.
### Off-Channel Scanning при выключенном FastLocate
Off-Channel Scanning происходит в весьма неспешной манере и изначально предназначен для обнаружения чужих точек доступа на смежных каналах. Как это работает можно посмотреть [здесь](http://www.cisco.com/c/en/us/support/docs/wireless/4400-series-wireless-lan-controllers/112045-handling-rogue-cuwn-00.html) и [здесь](http://www.cisco.com/c/en/us/support/docs/wireless/aironet-3600-series/115612-Aironet-Access-Point-Module-for-WSSI-Guide-00.html).
К примеру, по умолчанию в диапазоне 2.4ГГц настроено сканирование всех каналов и интервал полного сканирования 180с. В данном режиме точка доступа каждые 180/13=14 секунд прерывается на 50мс на сканирование смежного канала (на переход в каждую сторону так же тратиться 10мс). Картина выглядит примерно вот так:
Работу данного алгоритма можно проверить непосредственно на точке доступа при помощи команды **debug dot11 do0 trace print channel**
```
Hyperlocation_2#debug dot11 do0 trace print channel
Oct 4 10:09:37.909: CC0CDA4C-0 Channel 8 (2447) promiscuous 20MHz
Oct 4 10:09:37.957: CC0D772F-0 Channel 11 (2462) 20MHz
Oct 4 10:09:50.753: CCD0DEF8-0 Channel 9 (2452) promiscuous 20MHz
Oct 4 10:09:50.801: CCD17BD3-0 Channel 11 (2462) 20MHz
Oct 4 10:09:53.955: CD948399-0 Channel 10 (2457) promiscuous 20MHz
Oct 4 10:09:53.999: CD951CFD-0 Channel 11 (2462) 20MHz
Oct 4 10:10:06.763: CE57FEC4-0 Channel 11 (2462) promiscuous 20MHz
Oct 4 10:10:06.811: CE589BA7-0 Channel 11 (2462) 20MHz
```
По данному выводу можно увидеть, что периодичность сканирования порядка 13 секунд, что сходится с документацией. Применение Data RSSI в таком режиме было бы не очень эффективно (забегая вперед скажу, что он и не используется).
### Off-Channel Scanning при включенном FastLocate
Если на беспроводном контроллере активировать FastLocate, то Off-Channel Scanning начинает работать несколько иначе.
```
Hyperlocation_2#debug dot11 do0 trace print channel
Oct 4 10:05:40.887: BDEC139E-0 Channel 12 (2467) promiscuous 20MHz
Oct 4 10:05:40.967: BDED365C-0 Channel 11 (2462) 20MHz
Oct 4 10:05:43.691: BE16D8E7-0 Channel 13 (2472) promiscuous 20MHz
Oct 4 10:05:43.771: BE17FBC2-0 Channel 11 (2462) 20MHz
Oct 4 10:05:46.775: BE45D2A0-0 Channel 11 (2462) 20MHz
Oct 4 10:05:46.983: BE4919C1-0 Channel 14 (2484) promiscuous listen_only 20MHz
Oct 4 10:05:47.063: BE4A3D27-0 Channel 11 (2462) 20MHz
Oct 4 10:05:49.795: BE7407C6-0 Channel 1 (2412) promiscuous 20MHz
Oct 4 10:05:49.879: BE75291D-0 Channel 11 (2462) 20MHz
```
Временные интервалы уменьшаются до трех секунд. Технической документации в части того, как работает Off-Channel Scanning при активированном FastLocate я не нашел, но исходя из приведенного вывода можно сделать вывод, что время сканирования составляет так же порядка 50 мс ( 967-887 = 80 мс, это 50-60 мс на сканирование + 10 мс на переключение между каналами).
Очевидно, уменьшение временных интервалах было сделано для улучшения работы механизма FastLocation.
### Зависимость Off-Channel Scanning от режима работы wIPS
Точка доступа может работать с локальным или централизованным wIPS (системой обнаружения и предотвращения вторжений), что регулируется настройкой на точке доступа. Тестируя Off-Channel Scanning в разных режимах работы wIPS я не увидел отличий.
FastLocate в режиме Monitor
---------------------------
Еще до появления технологии FastLocate точки доступа умели работать в режиме Monitor mode AP. Этот режим использовался для централизованной системы обнаружения вторжений. При переходе в этот режим оба радиомодуля перестают обслуживать клиентов и последовательно сканируют каналы с продолжительностью 1.2 секунды.
Данный алгоритм работы подтверждается выводом с точки доступа:
```
pod1-1140#debug dot11 do0 trace print channel
*Oct 4 10:51:22.031: 1FB01CC6-0 Channel 12 (2467) promiscuous 20MHz
*Oct 4 10:51:23.246: 1FC2A970-0 Channel 13 (2472) promiscuous 20MHz
*Oct 4 10:51:24.458: 1FD5283F-0 Channel 14 (2484) promiscuous listen_only 20MHz
*Oct 4 10:51:25.670: 1FE7A716-0 Channel 1 (2412) promiscuous 20MHz
```
В случае Monitor mode AP алгоритм работы не менялся при включении/выключении FastLocate.
### FastLocate работает только для подключенных клиентов
При использовании режима Monitor есть нюанс: FastLocate работает только для подключенных к инфраструктуре клиентов, а при переводе точки доступа в режим Monitor точка перестаёт обслуживать клиентов. То есть подразумевается, что в инфраструктуре будут другие точки доступа, обслуживающие клиентов.
Точки доступа в режиме Monitor предлагается размещать в пропорции 1:5 к обычным точкам доступа.
FastLocate с использованием дополнительного модуля WSM
------------------------------------------------------
Это основной режим работы FastLocate, который предусматривает установку в точки доступа модулей WSM в пропорции [2:5](http://www.cisco.com/c/en/us/td/docs/wireless/technology/wips/deployment/guide/WiPS_deployment_guide.html) (то есть как минимум 2:5 точек доступа должны быть модульные, то есть самые топовые).
WSM имеет свой собственный алгоритм работы. WSM модуль в отличии от радио в режиме мониторинга сканирует канал не по 1.2 секунды, а по 250 мс. Но он это делает не последовательно, а в соответствии с определенными правилами:
```
It will scan 5 slots of L1(serving channel of the APs) followed by a cleanAir slot (if enabled), followed by one slot of L2 (channels in the country/DCA list). If there are less than 5 channels in the L1 list, the same channels will be scanned repeatedly till the 5 L1 slots are filled up.
```
Можно сказать, что большой приоритет отдаётся инфраструктурным каналам (на которых работают свои точки доступа), что и понятно, потому что FastLocation работает только для подключенных клиентов и сканирование смежных каналов не так важно.
Как этот алгоритм выглядит при выводе на точке доступа:
```
Sep 20 16:24:17.824: 2EC10B2D-2 Channel 1 (2412) promiscuous 20MHz
Sep 20 16:24:17.903: 2EC24019-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:18.151: 2EC60A5D-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:18.383: 2EC99BD3-2 Channel 11 (2462) promiscuous 20MHz
Sep 20 16:24:18.627: 2ECD54AC-2 Channel 1 (2412) promiscuous 20MHz
Sep 20 16:24:18.895: 2ED16A1E-2 Channel 161 (5805) promiscuous 20MHz
Sep 20 16:24:19.435: 2ED99B31-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:19.555: 2EDB7010-2 Channel 60 (5300) promiscuous 20MHz
Sep 20 16:24:19.807: 2EDF53C5-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:20.046: 2EE2EF52-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:20.282: 2EE695CB-2 Channel 11 (2462) promiscuous 20MHz
Sep 20 16:24:20.514: 2EEA16E6-2 Channel 1 (2412) promiscuous 20MHz
Sep 20 16:24:21.010: 2EF1B48A-2 Channel 11 (2462) promiscuous 20MHz
Sep 20 16:24:21.166: 2EF40C9B-2 Channel 161 (5805) promiscuous 20MHz
Sep 20 16:24:21.454: 2EF86DA9-2 Channel 60 (5300) promiscuous 20MHz
Sep 20 16:24:21.710: 2EFC5A8F-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:21.929: 2EFFBC42-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:22.161: 2F033F09-2 Channel 11 (2462) promiscuous 20MHz
Sep 20 16:24:22.645: 2F0AA07D-2 Channel 36 (5180) promiscuous 20MHz
Sep 20 16:24:22.785: 2F0CCDC0-2 Channel 1 (2412) promiscuous 20MHz
Sep 20 16:24:23.061: 2F10F3CB-2 Channel 161 (5805) promiscuous 20MHz
Sep 20 16:24:23.337: 2F1539E8-2 Channel 60 (5300) promiscuous 20MHz
Sep 20 16:24:23.593: 2F192133-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:23.813: 2F1C798A-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:24.297: 2F23E056-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:24.433: 2F25EE6C-2 Channel 11 (2462) promiscuous 20MHz
Sep 20 16:24:24.673: 2F299DFA-2 Channel 1 (2412) promiscuous 20MHz
Sep 20 16:24:24.937: 2F2D9ABB-2 Channel 161 (5805) promiscuous 20MHz
Sep 20 16:24:25.221: 2F31F49A-2 Channel 60 (5300) promiscuous 20MHz
Sep 20 16:24:25.473: 2F35CF9A-2 Channel 48 (5240) promiscuous 20MHz
Sep 20 16:24:25.977: 2F3D7AA1-2 Channel 40 (5200) promiscuous 20MHz
Sep 20 16:24:26.097: 2F3F532D-2 Channel 6 (2437) promiscuous 20MHz
Sep 20 16:24:26.329: 2F42D521-2 Channel 11 (2462) promiscuous 20MHz
```
Интервал сканирование не такой ровный, как в других режимах, и находится в пределах 50-250мс.
И действительно, не инфраструктурные каналы (в моём случае это каналы 36, 40) обходились достаточно редко, с периодичностью более 3 секунд, что так же можно увидеть в логах.
Оценка частоты замеров
======================
При активации режима FastLocation частота замеров напрямую зависела от активности клиента. Если клиент (смартфон, телефон, ноутбук) находились в спящем режиме, то есть не использовался активно Wi-Fi адаптер, частота замеров была сравнима с методом Probe RSSI. Если же устройство использовало активно Wi-Fi адаптер, то частота замеров резко возрастала.
Я не стал тестировать все возможные схемы работы Cisco FastLocation, так как есть очень много факторов, влияющих на частоту замеров, как со стороны инфраструктуры, так и со стороны клиента, поэтому тесты проводились только в режиме WSM.
Использовалось три типа устройств: смартфон, планшет и ноутбук. Для всех тестируемых устройств интервал между замерами был соизмерим и составлял порядка 2-6 секунд при активном использовании Wi-Fi адаптера.
Общие выводы
============
**1.** FastLocate (Data RSSI) по сравнению с Probe RSSI в общем случае для персональных устройств позволяет значительно увеличить частоту замеров, особенно при использовании Wi-Fi модуля.
**2.** Но если клиентское устройство находится в спящем режиме и не использует Wi-Fi адаптер, частота замеров падает до стандартной при Probe RSSI.
**3.** Очень сложно говорить о каком-то конкретном значении частоты замеров в случае использования Wi-Fi позиционирования для персональных устройств. Есть очень много факторов, как со стороны инфраструктуры, так и со стороны клиента, влияющих на данную характеристику. Для получения конкретных значений, я полагаю, надо действовать по аналогии с радиообследованием, то есть проводить полевые испытания всей системы целиком и с требуемыми клиентскими устройствами. | https://habr.com/ru/post/311722/ | null | ru | null |
# Я спарсил больше 1000 топовых Github-профилей по машинному обучению и вот что я узнал
При поиске по ключевой фразе «машинное обучение» (речь идет об англоязычном ключе «machine learning» — прим. перев.) я нашел 246632 репозиториев по машинному обучению. Поскольку все они имеют отношение к этой отрасли, я ожидал, что их владельцы являются экспертами или хотя бы достаточно компетентны в машинном обучении. Поэтому я решил проанализировать профили этих пользователей и показать результаты анализа.
### Как я работал
**Инструменты**
Я использовал три инструмента для скрейпинга:
* [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) для извлечения URL всех репозиториев с тегом «машинное обучение». Это Python библиотека, которая позволяет значительно упростить скрейпинг.
* [PyGithub](https://pygithub.readthedocs.io/en/latest/introduction.html) позволяет извлекать информацию о пользователях. Это еще одна Python-библиотека для использования с Github API v3. Она дает возможность управлять различными Github-ресурсами (репозитории, профили пользователей, организации и т.п.) при помощи Python-скриптов.
* [Requests](https://requests.readthedocs.io/en/master/user/quickstart/) для извлечения информации о репозиториях и линков на профили контрибьюторов.
**Методы**
Я спарсил далеко не все, а лишь владельцев и 30 самых активных контрибьюторов 90 топовых репозиториев, которые оказались в результатах поиска.
После удаления дублей и профилей организаций вроде udacity, я получил список из 1208 пользователей. Для каждого из них я спарсил информацию по 20 ключевым параметрам.
*new\_profile.info()*
Первые 13 параметров были получены отсюда.
Оставшиеся я взял из репозиториев пользователя:
* total\_stars общее количество звезд всех репозиториев
* max\_star максимальное количество звезд всех репозиториев
* forks общее количество форков всех репозиториев
* descriptions описания из всех репозиториев пользователя всех репо
* contribution количество контрибуций за последний год
### Визуализируем данные
**Гистограммы**
После очистки данных наступил черед самого интересного этапа: визуализации данных. Для этого я использовал Plotly.
```
import matplotlib.pyplot as plt
import numpy as np
import plotly.express as px # for plotting
import altair as alt # for plotting
import datapane as dp # for creating a report for your findings
top_followers = new_profile.sort_values(by='followers', axis=0, ascending=False)
fig = px.bar(top_followers,
x='user_name',
y='followers',
hover_data=['followers'],
)
fig.show()
```
Вот что [получилось](https://datapane.com/u/khuyentran1401/reports/followers-f9556855/?utm_medium=embed&utm_content=viewfull).
Гистограмма немного неудобна, поскольку в ней очень длинный «хвост» пользователей с количеством фолловеров ниже 100. Так что лучше увеличить все это.
Как видим, у llSourcell (Siraj Raval) больше всего фолловеров (36261). У второго по популярности количество фолловеров меньше в три раза (12682).
Мы можем пойти дальше и выяснить, что 1% профилей получил 41% всех фолловеров!
```
>>> top_n = int(len(top_followers) * 0.01)12>>> sum(top_followers.iloc[0: top_n,:].loc[:, 'followers'])/sum(top_followers.followers)0.41293075864408607
```
Далее визуализируем информацию по total\_stars, max\_star, forks при помощи логарифмической шкалы.
```
figs = [] # list to save all the plots and table
features = ['followers',
'following',
'total_stars',
'max_star',
'forks',
'contribution']
for col in features:
top_col = new_profile.sort_values(by=col, axis=0, ascending=False)
log_y = False
#change scale of y-axis of every feature to log except contribution
if col != 'contribution':
log_y = True
fig = px.bar(top_col,
x='user_name',
y=col,
hover_data=[col],
log_y = log_y
)
fig.update_layout({'plot_bgcolor': 'rgba(36, 83, 97, 0.06)'}) #change background coor
fig.show()
figs.append(dp.Plot(fig))
```
Получается [вот так](https://datapane.com/u/khuyentran1401/reports/features-99dd6dfd/?utm_medium=embed&utm_content=viewfull).
Полученная картина очень близка к распределению по закону Ципфа. Речь идет об эмпирической закономерности распределения частоты слов естественного языка: если все слова языка упорядочить по убыванию частоты их использования. Похожая зависимость есть у нас и здесь.
**Корреляция**
Но что насчет зависимостей между ключевыми точками данных? И насколько эти зависимости сильны? Я использовал scatter\_matrix для того, чтобы это выяснить.
```
correlation = px.scatter_matrix(new_profile, dimensions=['forks', 'total_stars', 'followers',
'following', 'max_star','contribution'],
title='Correlation between datapoints',
width=800, height=800)
correlation.show()
corr = new_profile.corr()
figs.append(dp.Plot(correlation))
figs.append(dp.Table(corr))
corr
```
Получается [вот так](https://datapane.com/u/khuyentran1401/reports/correlation-plot/?utm_medium=embed&utm_content=viewfull) и [еще так](https://datapane.com/u/khuyentran1401/reports/correlation-1d8ab106/?utm_medium=embed&utm_content=viewfull).
Наиболее сильные положительные зависимости образуются между:
* Максимальным количеством звезд и общим их количеством (0.939)
* Количество форков и общим количеством звезд (0,929)
* Количеством форков и количеством фолловеров (0,774)
* Количеством фолловеров и общим количеством звезд (0,632)
### Языки программирования
Для того, чтобы выяснить наиболее распространенные среди владельцев профилей GitHub языки программирования, я провел дополнительный анализ.
```
# Collect languages from all repos of al users
languages = []
for language in list(new_profile['languages']):
try:
languages += language
except:
languages += ['None']
# Count the frequency of each language
from collections import Counter
occ = dict(Counter(languages))
# Remove languages below count of 10
top_languages = [(language, frequency) for language, frequency in occ.items() if frequency > 10]
top_languages = list(zip(*top_languages))
language_df = pd.DataFrame(data = {'languages': top_languages[0],
'frequency': top_languages[1]})
language_df.sort_values(by='frequency', axis=0, inplace=True, ascending=False)
language = px.bar(language_df, y='frequency', x='languages',
title='Frequency of languages')
figs.append(dp.Plot(language))
language.show()
```
Соответственно, в топ-10 языков входят:
* Python
* JavaScript
* HTML
* Jupyter Notebook
* Shell и т.п.
### Местонахождение
Для того, чтобы понять, в каких частях света находятся владельцы профилей, нужно выполнить следующую задачу — визуализировать местонахождение пользователей. Среди проанализированных профилей география указана для 31%. Для визуализации используем geopy.geocoders.Nominatim
```
from geopy.geocoders import Nominatim
import folium
geolocator = Nominatim(user_agent='my_app')
locations = list(new_profile['location'])
# Extract lats and lons
lats = []
lons = []
exceptions = []
for loc in locations:
try:
location = geolocator.geocode(loc)
lats.append(location.latitude)
lons.append(location.longitude)
print(location.address)
except:
print('exception', loc)
exceptions.append(loc)
print(len(exceptions)) # output: 17
# Remove the locations not found in map
location_df = new_profile[~new_profile.location.isin(exceptions)]
location_df['latitude'] = lats
location_df['longitude'] = lons
```
Ну а затем, для построения карты используем [Plotly’s scatter\_geo](https://plotly.com/python-api-reference/generated/plotly.express.scatter_geo.html)
```
# Visualize with Plotly's scatter_geo
m = px.scatter_geo(location_df, lat='latitude', lon='longitude',
color='total_stars', size='forks',
hover_data=['user_name','followers'],
title='Locations of Top Users')
m.show()
figs.append(dp.Plot(m))
```
По [этой ссылке](https://datapane.com/u/khuyentran1401/reports/locations-4dc3c34f/?utm_medium=embed&utm_content=viewfull) доступна оригинальная карта с зумом.
### Описание репо и био пользователей
Многие пользователи оставляют описание для своих репозиториев, а также предоставляют собственные био. Для того, чтобы все это визуализировать, используем W[ordCloud!](https://amueller.github.io/word_cloud/) для Python.
```
import string
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('wordnet')
def process_text(features):
'''Function to process texts'''
features = [row for row in features if row != None]
text = ' '.join(features)
# lowercase
text = text.lower()
#remove punctuation
text = text.translate(str.maketrans('', '', string.punctuation))
#remove stopwords
stop_words = set(stopwords.words('english'))
#tokenize
tokens = word_tokenize(text)
new_text = [i for i in tokens if not i in stop_words]
new_text = ' '.join(new_text)
return new_text
def make_wordcloud(new_text):
'''Function to make wordcloud'''
wordcloud = WordCloud(width = 800, height = 800,
background_color ='white',
min_font_size = 10).generate(new_text)
fig = plt.figure(figsize = (8, 8), facecolor = None)
plt.imshow(wordcloud)
plt.axis("off")
plt.tight_layout(pad = 0)
plt.show()
return fig
descriptions = []
for desc in new_profile['descriptions']:
try:
descriptions += desc
except:
pass
descriptions = process_text(descriptions)
cloud = make_wordcloud(descriptions)
figs.append(dp.Plot(cloud))
```
И то же самое для био
```
bios = []
for bio in new_profile['bio']:
try:
bios.append(bio)
except:
pass
text = process_text(bios)
cloud = make_wordcloud(text)
figs.append(dp.Plot(cloud))
```
Как видим, ключевые слова вполне соответствуют тому, чего можно ожидать от специалистов по машинному обучению.
### Выводы
Данные получены от пользователей и авторов 90 репозиториев с оптимальным соответствием ключу «machine learning». Но гарантии того, что в список попали все ведущие владельцы профилей, эксперты по машинному обучению нет.
Тем не менее статья — хороший пример того, как можно очистить собранные данные и визуализировать их. Скорее всего, результат вас удивит. И в этом нет ничего странного, поскольку data science помогает применить свои знания для анализа того, что вас окружает.
Ну и если нужно — можете форкать код этой статьи и делать с ним что угодно, [[вот репо
> ***Комментарий к статье Вячеслава Архипова, специалиста в области Data Science AR-стартапа Banuba и консультанта по учебной программе онлайн-университета Skillbox.***
>
>
>
> Интересное исследование, показывающее все шаги статистического анализа «рынка» github-профилей по машинному обучению. Аналогичным образом можно было бы проанализировать соцсети, спрос на товары, предпочтения кинозрителей и т.д.
>
>
>
> Хотелось бы обратить внимание на два факта:
>
>
>
> 1) несмотря на утверждение автора, что для визуализации показателей профиля используется логарифмическая шкала, на самом деле используются линейные шкалы. Это видно из приведенного листинга (из него следует, что логарифмическая шкала использовалась только для 'contribution'). Все графики выглядят, как построенные в линейной шкале.
>
>
>
> А вот само распределение показателя 'contribution' действительно похоже на распределение Парето, известное в применении к частотам встречаемости слов как распределение Ципфа. Графики других показателей мне не очень напоминают распределение Парето.
>
>
>
> Тут хотелось бы увидеть использование критерия Пирсона, для оценки правдоподобия того, что исследуемые данные имеют определенное распределение. Тем более, что есть даже готовая гипотеза о том, что это распределение Парето (Ципфа).
>
>
>
> 2) Мне кажется, было бы интересно поглубже раскрыть тему корреляции показателей. Автор отметил показатели, которые имеют очевидно высокую корреляцию. Но, коэффициент корреляции после небольшого преобразования можно превратить в величину, имеющую распределение Стьюдента. А значит, можно провести исследование на значимость коэффициента корреляции, приняв нуль-гипотезу о линейной независимости параметров. Учитывая большое количество исследованных данных (степеней свободы), порог для отвержения нуль-гипотезы будет довольно низким и станет очевидно, что еще многие параметры имеют хоть и небольшую по значению, но статистически значимую корреляцию.
>
>
>
> А следующим шагом можно попытаться оценить размерность: понять, сколькими параметрами можно описать одну точку данных. А также найти эти скрытые параметры методом главных компонент.
>
>](https://habr.com/ru/users/JamaGava/)](https://github.com/khuyentran1401/Data-science/tree/master/visualization/github) | https://habr.com/ru/post/541352/ | null | ru | null |
# Автоэнкодеры в Keras, Часть 5: GAN(Generative Adversarial Networks) и tensorflow
### Содержание
* Часть 1: [Введение](https://habrahabr.ru/post/331382/)
* Часть 2: [*Manifold learning* и скрытые (*latent*) переменные](https://habrahabr.ru/post/331500/)
* Часть 3: [Вариационные автоэнкодеры (*VAE*)](https://habrahabr.ru/post/331552/)
* Часть 4: [*Conditional VAE*](https://habrahabr.ru/post/331664/)
* **Часть 5: *GAN* (Generative Adversarial Networks) и tensorflow**
* Часть 6: [*VAE* + *GAN*](https://habrahabr.ru/post/332074/)
(Из-за вчерашнего бага с перезалитыми картинками на хабрасторейдж, случившегося не по моей вине, вчера был вынужден убрать эту статью сразу после публикации. Выкладываю заново.)
При всех преимуществах вариационных автоэнкодеров ***VAE***, которыми мы занимались в предыдущих постах, они обладают одним существенным недостатком: из-за плохого способа сравнения оригинальных и восстановленных объектов, сгенерированные ими объекты хоть и похожи на объекты из обучающей выборки, но легко от них отличимы (например, размыты).
Этот недостаток в куда меньшей степени проявляется у другого подхода, а именно у *генеративных состязающихся сетей* — ***GAN***’ов.
Формально *GAN’ы*, конечно, не относятся к автоэнкодерам, однако между ними и вариационными автоэнкодерами есть сходства, они также пригодятся для следующей части. Так что не будет лишним с ними тоже познакомиться.
### Коротко о *GAN*
***GAN***’ы впервые были предложены в статье ***[1, Generative Adversarial Nets, Goodfellow et al, 2014]*** и сейчас очень активно исследуются. Наиболее state-of-the-art генеративные модели так или иначе используют *adversarial*.
Схема ***GAN***:
***GAN***’ы состоят из 2 нейронных сетей:
* 1-ая — генератор сэмплит случайные числа из какого-то заданного распределения , например  и генерируют из них объекты , которые идут на вход второй сети,
* 2-ая — дискриминатор получает на вход объекты из выборки  и созданные генератором , и учится предсказывать вероятность того, что конкретный объект реальный, выдавая скаляр .
При этом генератор тренируется создавать объекты, который дискриминатор не отличит от реальных.
**Рассмотрим процесс обучения *GAN*.**
Генератор и дискриминатор обучаются отдельно, но в рамках одной сети.
Делаем k шагов обучения дискриминатора: за шаг обучения дискриминатора параметры  обновляются в сторону уменьшения кросс-энтропии:
Далее шаг обучения генератора: обновляем параметры генератора  в сторону увеличения логарифма вероятности дискриминатору присвоить сгенерированному объекту лейбл реального.
Схема обучения:
На левой картинке шаг обучения дискриминатора: градиент (красные стрелки) протекает от лосса только до дискриминатора, где обновляются  (зеленые) в сторону уменьшения лосса. На правой картинке градиент от правой части лосса (ошибка идентификации сгенерированного объекта) протекает до генератора, при этом обновляются только веса генератора  (зеленые) в сторону **увеличения** вероятности дискриминатора ошибиться.
Задача, которую решает *GAN* формулируется так:
![\min_G \max_D \mathbb{E}_{X \sim P}[ \log(D(X))] + \mathbb{E}_{Z \sim P_z}[ \log(1 - D(G(Z)))]](https://habrastorage.org/getpro/habr/post_images/7d9/04b/209/7d904b209f780191b4772cf61a59fa44.svg)
При заданном генераторе оптимальный дискриминатор выдает вероятность  что почти очевидно, предлагаю на секунду об этом задуматься.
В ***[1]*** показывается, что при достаточной мощности обеих сетей у данной задачи есть оптимум, в котором генератор научился генерировать распределение , совпадающее с , а везде на  дискриминатор выдает вероятность .
Иллюстрация из ***[1]***
Обозначения:
* черная точечная кривая — настоящее распределение ,
* зеленая — распределение генератора ,
* синяя — распределение вероятности  дискриминатора предсказать класс реального объекта,
* нижняя и верхняя прямые — множество всех  и множество всех , стрелочки олицетворяют отображение .
На картинке:
* (a)  и  довольно разные, но дискриминатор неуверенно отличает одно от другого,
* (b) дискриминатор после k шагов обучения уже отличает их увереннее,
* (с) это позволяет генератору , руководствуясь хорошим градиентом дискриминатора , на границе двух распределений подвинуть  ближе к ,
* (d) в результате многих повторений шагов (а), (b), (с)  совпало с , и дискриминатор более не способен отличать одно от другого: . Точка оптимума достигнута.
Conditional GAN
---------------
Точно как в прошлой части мы сделали *Conditional VAE*, просто передавая в энкодер и декодер лейбл цифры, здесь мы будем передавать его в генератор и дискриминатор ***[2]***
Код
---
В отличие от предыдущих частей, где получалось обходиться одним *keras’ом*, здесь с этим возникает проблема. А именно, нужно в одной и той же сети по очереди обновлять либо только параметры генератора, либо только дискриминатора. Если исхитриться, то можно сделать это и чисто в *keras’е*, но по мне проще и полезнее подключить сюда и *tensorflow*.
В блоге *keras’а* есть небольшой [туториал](https://blog.keras.io/keras-as-a-simplified-interface-to-tensorflow-tutorial.html) **[3]**, как это делать.
Благо *keras* легко сочетается с *tensorflow* — не даром он попал в *tensorflow.contrib*.
Начнем с импортирования нужных модулей и загрузки датасета.
```
from IPython.display import clear_output
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from keras.layers import Dropout, BatchNormalization, Reshape, Flatten, RepeatVector
from keras.layers import Lambda, Dense, Input, Conv2D, MaxPool2D, UpSampling2D, concatenate
from keras.layers.advanced_activations import LeakyReLU
from keras.models import Model, load_model
from keras.datasets import mnist
from keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test .astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
y_train_cat = to_categorical(y_train).astype(np.float32)
y_test_cat = to_categorical(y_test).astype(np.float32)
```
Для работы в *keras* и *tensorflow* одновременно надо зарегистрировать *tensorflow* сессию в *keras*, это нужно для того чтобы *keras* создавал все внутренние переменные в рамках используемой сессии.
```
from keras import backend as K
import tensorflow as tf
sess = tf.Session()
K.set_session(sess)
```
Определим основные глобальные константы:
```
batch_size = 256
batch_shape = (batch_size, 28, 28, 1)
latent_dim = 2
num_classes = 10
dropout_rate = 0.3
```
Обучать модель мы теперь будем не с помощью метода *.fit*, а напрямую из *tensorflow*, поэтому напишем итератор, возвращающий очередной батч:
```
def gen_batch(x, y):
n_batches = x.shape[0] // batch_size
while(True):
for i in range(n_batches):
yield x[batch_size*i: batch_size*(i+1)], y[batch_size*i: batch_size*(i+1)]
idxs = np.random.permutation(y.shape[0])
x = x[idxs]
y = y[idxs]
train_batches_it = gen_batch(x_train, y_train_cat)
test_batches_it = gen_batch(x_test, y_test_cat)
```
Оборачиваем *placeholder*’ы для картинок, лейблов и скрытых переменных во входящие слои для *keras* моделей:
```
x_ = tf.placeholder(tf.float32, shape=(None, 28, 28, 1), name='image')
y_ = tf.placeholder(tf.float32, shape=(None, num_classes), name='labels')
z_ = tf.placeholder(tf.float32, shape=(None, latent_dim), name='z')
img = Input(tensor=x_)
lbl = Input(tensor=y_)
z = Input(tensor=z_)
```
Реализовывать будем сразу ***CGAN***, так как он лишь минимально отличается от обычного.
Напишем модель генератора. *Keras* работает со *scope’ами*, а нам нужно разделить генератор и дискриминатор, чтобы потом обучать их по-отдельности
```
with tf.variable_scope('generator'):
x = concatenate([z, lbl])
x = Dense(7*7*64, activation='relu')(x)
x = Dropout(dropout_rate)(x)
x = Reshape((7, 7, 64))(x)
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(64, kernel_size=(5, 5), activation='relu', padding='same')(x)
x = Dropout(dropout_rate)(x)
x = Conv2D(32, kernel_size=(3, 3), activation='relu', padding='same')(x)
x = Dropout(dropout_rate)(x)
x = UpSampling2D(size=(2, 2))(x)
generated = Conv2D(1, kernel_size=(5, 5), activation='sigmoid', padding='same')(x)
generator = Model([z, lbl], generated, name='generator')
```
Далее модель дискриминатора. Здесь нам нужно добавить ко входящему изображению еще лейбл цифры. Для этого после применения первого сверточного слоя добавим к фильтрам лейблы. Сперва функция, которая это делает, потом модель дискриминатора.
```
def add_units_to_conv2d(conv2, units):
dim1 = int(conv2.shape[1])
dim2 = int(conv2.shape[2])
dimc = int(units.shape[1])
repeat_n = dim1*dim2
units_repeat = RepeatVector(repeat_n)(lbl)
units_repeat = Reshape((dim1, dim2, dimc))(units_repeat)
return concatenate([conv2, units_repeat])
with tf.variable_scope('discrim'):
x = Conv2D(128, kernel_size=(7, 7), strides=(2, 2), padding='same')(img)
x = add_units_to_conv2d(x, lbl)
x = LeakyReLU()(x)
x = Dropout(dropout_rate)(x)
x = MaxPool2D((2, 2), padding='same')(x)
l = Conv2D(128, kernel_size=(3, 3), padding='same')(x)
x = LeakyReLU()(l)
x = Dropout(dropout_rate)(x)
h = Flatten()(x)
d = Dense(1, activation='sigmoid')(h)
discrim = Model([img, lbl], d, name='Discriminator')
```
Определив модели, мы можем применять их напрямую к *placeholder’ам* как обычные *tensorflow* операции.
```
generated_z = generator([z, lbl])
discr_img = discrim([img, lbl])
discr_gen_z = discrim([generated_z, lbl])
gan_model = Model([z, lbl], discr_gen_z, name='GAN')
gan = gan_model([z, lbl])
```
Теперь лосс ошибки определения реального изображения, и лосс сгенерированного, а также на их основе лоссы генератора и дискриминатора.
```
log_dis_img = tf.reduce_mean(-tf.log(discr_img + 1e-10))
log_dis_gen_z = tf.reduce_mean(-tf.log(1. - discr_gen_z + 1e-10))
L_gen = -log_dis_gen_z
L_dis = 0.5*(log_dis_gen_z + log_dis_img)
```
Обычно в *tensorflow*, передавая в оптимизатор лосс, он будет пытаться минимизировать сразу все переменные, от которых он зависит. Нам сейчас этого не надо: при обучении генератора, ошибка не должна трогать дискриминатор, хотя должна сквозь него течь и наоборот.
Для этого дополнительно в оптимизатор надо передать список переменных, которые он будет оптимизировать. Достанем эти переменные из нужных *scope’ов* с помощью *tf.get\_collection*
```
optimizer_gen = tf.train.RMSPropOptimizer(0.0003)
optimizer_dis = tf.train.RMSPropOptimizer(0.0001)
# Переменные генератора и дискриминаторы (отдельно) для оптимизаторов
generator_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "generator")
discrim_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "discrim")
step_gen = optimizer_gen.minimize(L_gen, var_list=generator_vars)
step_dis = optimizer_dis.minimize(L_dis, var_list=discrim_vars)
```
Инициализируем переменные:
```
sess.run(tf.global_variables_initializer())
```
Отдельно напишем функции, которые будем вызывать для обучения генератора и дискриминатора:
```
# Шаг обучения генератора
def step(image, label, zp):
l_dis, _ = sess.run([L_dis, step_gen], feed_dict={z:zp, lbl:label, img:image, K.learning_phase():1})
return l_dis
# Шаг обучения дискриминатора
def step_d(image, label, zp):
l_dis, _ = sess.run([L_dis, step_dis], feed_dict={z:zp, lbl:label, img:image, K.learning_phase():1})
return l_dis
```
Код сохранения и визуализации картинок:
**Код**
```
# Массивы, в которые будем сохранять результаты, для последующей визуализации
figs = [[] for x in range(num_classes)]
periods = []
save_periods = list(range(100)) + list(range(100, 1000, 10))
n = 15 # Картинка с 15x15 цифр
from scipy.stats import norm
# Так как сэмплируем из N(0, I), то сетку узлов, в которых генерируем цифры, берем из обратной функции распределения
grid_x = norm.ppf(np.linspace(0.05, 0.95, n))
grid_y = norm.ppf(np.linspace(0.05, 0.95, n))
grid_y = norm.ppf(np.linspace(0.05, 0.95, n))
def draw_manifold(label, show=True):
# Рисование цифр из многообразия
figure = np.zeros((28 * n, 28 * n))
input_lbl = np.zeros((1, 10))
input_lbl[0, label] = 1.
for i, yi in enumerate(grid_x):
for j, xi in enumerate(grid_y):
z_sample = np.zeros((1, latent_dim))
z_sample[:, :2] = np.array([[xi, yi]])
x_generated = sess.run(generated_z, feed_dict={z:z_sample, lbl:input_lbl, K.learning_phase():0})
digit = x_generated[0].squeeze()
figure[i * 28: (i + 1) * 28,
j * 28: (j + 1) * 28] = digit
if show:
# Визуализация
plt.figure(figsize=(10, 10))
plt.imshow(figure, cmap='Greys')
plt.grid(False)
ax = plt.gca()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
return figure
n_compare = 10
def on_n_period(period):
clear_output() # Не захламляем output
# Рисование многообразия для рандомного y
draw_lbl = np.random.randint(0, num_classes)
print(draw_lbl)
for label in range(num_classes):
figs[label].append(draw_manifold(label, show=label==draw_lbl))
periods.append(period)
```
Обучим теперь наш *CGAN*.
Важно, чтобы в самом начале дискриминатор не слишком стал побеждать, иначе обучение остановится. Поэтому здесь добавлены внутренние циклы как для дискриминатора, так и для генератора, и выход из них, когда одна сеть почти догоняет другую.
Если дискриминатор сразу выигрывает у декодера, и обучение даже не успевает начаться, то можно попробовать замедлить обучение дискриминатора, либо несколько раз начинать заново.
```
batches_per_period = 20 # Как часто сохранять картинки
k_step = 5 # Количество шагов, которые могут делать дискриминатор и генератор во внутреннем цикле
for i in range(5000):
print('.', end='')
# Достанем новый батч
b0, b1 = next(train_batches_it)
zp = np.random.randn(batch_size, latent_dim)
# Шаги обучения дискриминатора
for j in range(k_step):
l_d = step_d(b0, b1, zp)
b0, b1 = next(train_batches_it)
zp = np.random.randn(batch_size, latent_dim)
if l_d < 1.0:
break
# Шаги обучения генератора
for j in range(k_step):
l_d = step(b0, b1, zp)
if l_d > 0.4:
break
b0, b1 = next(train_batches_it)
zp = np.random.randn(batch_size, latent_dim)
# Периодическое рисование результата
if not i % batches_per_period:
period = i // batches_per_period
if period in save_periods:
on_n_period(period)
print(l_d)
```
Код рисования гифок:
**Код**
```
from matplotlib.animation import FuncAnimation
from matplotlib import cm
import matplotlib
def make_2d_figs_gif(figs, periods, c, fname, fig, batches_per_period):
norm = matplotlib.colors.Normalize(vmin=0, vmax=1, clip=False)
im = plt.imshow(np.zeros((28,28)), cmap='Greys', norm=norm)
plt.grid(None)
plt.title("Label: {}\nBatch: {}".format(c, 0))
def update(i):
im.set_array(figs[i])
im.axes.set_title("Label: {}\nBatch: {}".format(c, periods[i]*batches_per_period))
im.axes.get_xaxis().set_visible(False)
im.axes.get_yaxis().set_visible(False)
return im
anim = FuncAnimation(fig, update, frames=range(len(figs)), interval=100)
anim.save(fname, dpi=80, writer='imagemagick')
for label in range(num_classes):
make_2d_figs_gif(figs[label], periods, label, "./figs4_5/manifold_{}.gif".format(label), plt.figure(figsize=(10,10)), batches_per_period)
```
Результаты:
-----------
### GAN
Многообразие цифр для обычного *GAN* (без передачи лейблов)
[](https://habrastorage.org/web/75e/902/348/75e9023483d843f6a51e3ae4b5c26adf.png)
Стоит отметить, что цифры получаются лучше, чем в *VAE* (без лейблов)
**Гифка обучения**[](https://habrastorage.org/web/cc9/d27/62b/cc9d2762b11c42d58d4bf769f73d773b.gif)
### CGAN
Многообразия цифр для каждого лейбла
[](https://habrastorage.org/web/40b/73e/d63/40b73ed635c242219701ba72e084b916.png)[](https://habrastorage.org/web/a95/94b/d76/a9594bd765ec4fe3ae3da7c072b675fb.png)[](https://habrastorage.org/web/f0f/551/fd3/f0f551fd375d4f50ad3fbb3b14d9da5d.png)[](https://habrastorage.org/web/d00/5b3/dd0/d005b3dd0dbf4f71afbc597f0d1086bb.png)[](https://habrastorage.org/web/a39/239/ef3/a39239ef3cfc4a26817e8c342d1254fe.png)[](https://habrastorage.org/web/517/2e1/940/5172e1940f9546c5b07c736fb9e805b9.png)[](https://habrastorage.org/web/325/6cc/90f/3256cc90fab148b485df821f500e3917.png)[](https://habrastorage.org/web/3dd/d82/71c/3ddd8271c57d40d7a23325f5bd173794.png)[](https://habrastorage.org/web/72a/058/f54/72a058f54ba9405b8d21622819eced43.png)[](https://habrastorage.org/web/ec3/aa0/db8/ec3aa0db82fe49c5b351c9086c409168.png)
**Тяжелые гифки**[](https://habrastorage.org/web/031/e8a/bb6/031e8abb6f914ea99523a2c32499fd3e.gif)[](https://habrastorage.org/web/3f3/88a/c73/3f388ac7387349409bc75e094171fd96.gif)
[](https://habrastorage.org/web/f1b/d04/4aa/f1bd044aa50e4156aeaf592aad858816.gif)[](https://habrastorage.org/web/813/ce5/a65/813ce5a659c544658c2eb596ad3fb16b.gif)[](https://habrastorage.org/web/a3b/35a/fbd/a3b35afbd2c44664b4e20e43aba02718.gif)[](https://habrastorage.org/web/b70/794/6f5/b707946f5d3445698486ec19396f554b.gif)[](https://habrastorage.org/web/da0/f00/45f/da0f0045f8204a11bc9e16618e83ed77.gif)[](https://habrastorage.org/web/a79/aaa/6b7/a79aaa6b7a564dbf929c362992a79004.gif)[](https://habrastorage.org/web/c5b/125/d83/c5b125d83fcf44a5a0cad598e748d4d7.gif)[](https://habrastorage.org/web/9cb/e1b/d21/9cbe1bd2125b44b3a611160e5ebcae21.gif)
Полезные ссылки и литература
----------------------------
Оригинальная статья:
[1] Generative Adversarial Nets, Goodfellow et al, 2014, <https://arxiv.org/abs/1406.2661>
Conditional GANs:
[2] Conditional Generative Adversarial Nets, Mirza, Osindero, 2014, <https://arxiv.org/abs/1411.1784>
Туториал про использование *keras* вместе с *tensorflow*:
[3] <https://blog.keras.io/keras-as-a-simplified-interface-to-tensorflow-tutorial.html> | https://habr.com/ru/post/332000/ | null | ru | null |
# Знакомьтесь: FreeCAD
[FreeCAD](https://sourceforge.net/apps/mediawiki/free-cad/index.php?title=Main_Page) — параметрический трехмерный редактор, позволяющий создавать объемные модели и чертежи их проекций.
Текущая версия FreeCAD — 0.12, но можно также скачать бета-версию 0.13 и попытаться ее скомпилировать.
FreeCAD поддерживает несколько различных форматов документов как на импорт, так и на экспорт, а также позволяет сохранять «снимки экрана» (в т.ч. в формате pdf).
Документация к FreeCAD довольно обильная, но все-таки не настолько полная, насколько бы хотелось. Вопросы по использованию этого продукта можно обсудить на [форуме FreeCAD](https://sourceforge.net/apps/phpbb/free-cad/index.php).
Для удобства рисования во FreeCAD есть возможность написания скриптов на питоне, а для мелких операций можно использовать консоль питона. Консоль, правда, элементарная: истории команд не имеет.
Я не буду переписывать многотомное руководство пользователя FreeCAD, а просто приведу пример того, что можно сделать с его помощью.
Но для начала поясню, как заставить FreeCAD «видеть» свои скрипты. Перед каждым запуском FreeCAD просматривает содержимое системных директорий, а также директории ~/.FreeCAD/Mod/. Находящиеся там скрипты он и будет использовать в дальнейшем.
Скрипты во FreeCAD делятся на две категории: скрипты, вызываемые из командной строки (для их запуска необходимо сначала подгрузить командой питона import содержащий их модуль), а также скрипты, запускающиеся из GUI. Первые вы всегда можете перезагрузить командой reload, а вот для перезагрузки вторых (если вы внесли какие-то изменения в исходники), необходимо будет перезапустить FreeCAD. Сначала рассмотрим работу с первыми.
Рисуем «колесо»
---------------
Создадим эскиз (sketch) в XY-плоскости, на нем нарисуем профиль «половинки» нашего колеса.
Для этого сначала «на глаз» нарисуем основные формы в виде ломаной линии.
Далее в нужных местах срежем фаски (инструмент «fillet»). А после этого — расставим привязки точек. Начальные точки привяжем абсолютно. Параллельные объекты ограничим параллельностью, зададим расстояния между частями профиля и радиусы скруглений.
Затем завершим редактирование эскиза, выберем его в списке объектов (слева) и нажмем кнопку «вращать выбранный эскиз». Получим такое колесо:
Теперь создадим в «диске» выемки. Для этого сделаем еще один эскиз в плоскости XZ. В нем из отрезков и дуг сделаем вырез. Чтобы наше отверстие было точно симметрично относительно центра, сделаем привязку к двум невидимым линиям.
Вытянем наш эскиз на 100 единиц (чтобы он уж наверняка пересекал колесо) и переместим его (Plasement.Position) на 50 единиц по оси Y:
Теперь нам нужно «размножить» полученную фигуру по окружности, чтобы затем сделать вырезы в «колесе». Для «размножения» напишем скрипт NCopy.py:
```
import FreeCAD, FreeCADGui, Part
from FreeCAD import Base
def CopyObj(obj):
name = obj.Name
shape = obj.Shape
newshape = shape.copy()
newobject = FreeCAD.ActiveDocument.addObject("Part::Feature",name)
newobject.Shape = newshape
return newobject
def copyCirc(C=Base.Vector(0,0,0), A=Base.Vector(0,0,1), Ang=90, N=4, rot=True, moveOriToGrp=False):
Ang %= 360
if (N > 360/Ang or N == 0):
N = int(360/Ang)
sel = FreeCADGui.Selection.getSelection()
if (not sel):
FreeCAD.Console.PrintError("Error: you should select some objects")
return None
doc = FreeCAD.activeDocument()
grp = doc.addObject("App::DocumentObjectGroup", "CircularCopy")
for Obj in sel:
A0 = Ang
for i in range (1, N):
newobject = CopyObj(Obj)
S = newobject.Shape
S.rotate(C, A, A0)
if (not rot):
S.rotate(S.Placement.Base, A, -A0)
grp.addObject(newobject)
A0 += Ang
if (moveOriToGrp):
grp.addObject(Obj)
return grp
```
Сохраним его в какой-нибудь поддиректории из ~/.FreeCAD/Mod/.
Функция CopyObj имеет вспомогательное значение (она нам пригодится в дальнейшем): эта функция просто создает копию данного объекта.
Функция copyCirc имеет шесть аргументов, для всех них назначены значения по умолчанию, поэтому вызывать его можно только указывая аргументы, имеющие другие значения. Ее аргументы:
* C — координаты центра окружности, по которой происходит копирование;
* A — нормаль к плоскости окружности;
* Ang — угол между копиями;
* N — количество копий (0 — если надо разместить объекты по всей окружности);
* rot — вращать ли сам объект при копировании: если этот параметр равен False, объект будет распределен по окружности параллельным переносом, а не вращением;
* moveOriToGrp — помещать ли копируемый оригинал в общую группу созданных объектов.
Радиус окружности нам не нужен — им мы считаем расстояние от объекта до центра окружности. Объект[ы] для копирования бер[е|у]тся из выделения. Если ничего не выделено, просто выдаем текст ошибки и завершаем функцию. Далее мы создаем в функции группу «CircularCopy» и начинаем перебирать все объекты из выделения. Каждый из них (N-1) раз копируется по окружности, а затем помещается в группу.
Теперь прикинем: нормаль к окружности, вдоль которой надо «размножать» объекты, имеет значение (0,1,0), угол между копиями сделаем равным 30 градусам, центр расположен по умолчанию (в начале координат), заполнить надо всю окружность. Таким образом, нам надо дать команды
```
import NCopy
NCopy.copyCirc(A=App.Vector(0,1,0), N=0, Ang=30, moveOriToGrp=True)
```
Раскрываем появившуюся группу «CircularCopy», выделяем все объекты в ней и выполняем их объединение, появится объект «Fusion». Теперь выделим наше «колесо» («Revolution») и это объединение, нажав клавишу Ctrl, и выберем операцию «пересечение». В итоге в нашем «колесе» появятся вырезы:
И вот так будет выглядеть «колесо», экспортированное в pdf:
Разное
------
Добавлю еще несколько функций для копирования объектов.
Копирование объекта в заданное расположение (mv — вектор сдвига, axe — ось поворота, rot — угол поворота):
```
def CopyObjAt(obj, mv=Base.Vector(0,0,0), axe=Base.Vector(0,0,0), rot=0):
obj = CopyObj(obj)
obj.Placement = FreeCAD.Placement(mv, axe, rot)
return obj
```
Копирование N раз на вектор V:
```
def copyVec(N=2, V=Base.Vector(0,0,1), moveOriToGrp=False):
sel = FreeCADGui.Selection.getSelection()
if sel:
doc = FreeCAD.activeDocument()
grp = doc.addObject("App::DocumentObjectGroup", "VectorCopy")
for Obj in sel:
R0 = V
for i in range (1, N):
newobject = CopyObj(Obj)
newobject.Shape.translate(R0)
grp.addObject(newobject)
R0 += V
if (moveOriToGrp):
grp.addObject(Obj)
else:
FreeCAD.Console.PrintError("Error: you should select some objects")
return grp
```
Копирование N раз по траектории — B-сплайну:
```
def copyByTrajectory(N=4):
sel = FreeCADGui.Selection.getSelection()
def prErr():
FreeCAD.Console.PrintError("Error: you should select a traectory and one object\n")
if (not sel):
prErr(); return None
L = len(sel)
if(L != 2):
prErr(); return None
if(N < 2):
FreeCAD.Console.PrintError("Error: N shold be more than 1\n"); return None
Traj = sel[0].Shape
#(a, b) = Traj.ParameterRange
Obj = sel[1]
TLen = Traj.Length / (N - 1)
curPos = 0
doc = FreeCAD.activeDocument()
grp = doc.addObject("App::DocumentObjectGroup", "BSplineCopy")
try:
for i in range(0, N):
v = Traj.valueAt(curPos); curPos += TLen
newobj = CopyObjAt(Obj, v)
grp.addObject(newobj)
except:
FreeCAD.Console.PrintError("Error: bad selection\n")
return None
```
Рисуем подшипник
----------------
Теперь аналогично «колесу» мы можем нарисовать простой подшипник без сепаратора.
Для начала нарисуем обечайки. Опять-таки, «на глаз» нарисуем сначала контуры из ломаных линий, затем между ними нарисуем окружность, которую сразу же сделаем неактивной. Далее — наложим на наши фигуры ограничения: положения точек, вертикальность и горизонтальность участков, равенство одинаковых линий, тангенциальное ограничение одной точки борозды в обечайках и поверхности шарика, внесем кое-какие размеры. В итоге получим такой эскиз:
Выйдем из режима редактирования эскиза, выделим его на общем виде и активируем операцию вращения эскиза. В результате у нас получится вот такая симпатичная штука:
Теперь нам надо добавить шарики. Для этого активируем значок «Нарисовать сферу», чтобы получить сферу по умолчанию. Выделим ее и исправим параметры: радиус сделаем равным 15 единицам, а в положении (Placement.Position) координату X сделаем равной 58 единиц. Для того, чтобы «размножить» шарики, нам еще надо бы вычислить угловой диаметр одного шарика. Проще всего это сделать, опять открыв наш эскиз (теперь он принадлежит объекту «Revolution»). Чтобы обечайка не мешалась, выделим ее и нажмем пробел — она станет невидимой. Теперь нарисуем отрезок из начала координат к нашему шарику. Сделаем ограничения: один конец отрезка строго привяжем к началу координат, а второй сделаем касательной к шарику. Выделив этот отрезок, активируем ограничение по углу (конечно, FreeCAD будет ругаться на чрезмерное количество ограничений, но нам надо только посмотреть). Итак, этот угол равен 14.9882 градуса, грубо говоря — 15 градусов. Сразу же удалим это ограничение, чтобы FreeCAD не ругался и вернемся к ~~нашим баранам~~ общему виду. Выделим шарик и распределим его копии по окружности через каждые 30 градусов. По счастливой случайности нам нужно будет ввести аналогичные предыдущему пункту команды:
```
import NCopy
NCopy.copyCirc(A=App.Vector(0,1,0), N=0, Ang=30, moveOriToGrp=True)
```
Теперь немного раскрасим наши объекты. Чтобы было проще раскрашивать шарики, объединим их в один объект. Для «красоты» сменим стиль отображения объектов с «Flat Lines» на «Shaded». Цвет шариков я сделал «золотым» (255, 214, 0), а цвет обечайки — «серебряным» (192, 192, 192). Можно цвет изменять не через GUI, а в командной строке (только RGB компоненты надо нормализовать на единицу). Если документ называется «bearing», то это будет выглядеть так:
```
FreeCADGui.getDocument("bearing").getObject("Fusion").ShapeColor = (1.00,0.84,0.00)
FreeCADGui.getDocument("bearing").getObject("Revolution").ShapeColor = (0.75,0.75,0.75)
```
Точно так же можно и изменить тип их отображения:
```
FreeCADGui.getDocument("bearing").getObject("Revolution").DisplayMode = "Shaded"
FreeCADGui.getDocument("bearing").getObject("Fusion").DisplayMode = "Shaded"
```
И можно сделать чертеж и экспортировать его в SVG:
Еще о скриптописании
--------------------
Как я уже говорил, для того, чтобы сделать возможным запуск своих команд из консоли FreeCAD, достаточно лишь файлы (модули питона) с этими командами разместить в директории ~/.FreeCAD/Mod/ или ее поддиректориях. Однако, чтобы сделать возможным запуск команд из GUI («кнопочки», «меню» и т.п.), необходимо сделать немного больше.
Во-первых, необходимо создать инициализирующий скрипт InitGui.py и поместить его в скриптовую поддиректорию. Этот скрипт FreeCAD запустит при просмотре содержимого нашей скриптовой директории.
Минимальное содержимое этого файла таково:
```
class MyWorkbench ( Workbench ):
import список файлов
Icon = путь к миниатюре инструментария (модуля)
MenuText = "Название модуля"
ToolTip = "Пояснения во всплывающей подсказке"
def Initialize(self):
# ToolBar
list = [Список предоставляемых пунктов для панели инструментов]
self.appendToolbar("Название панели инструментов",list)
# Menu
list = [Список предоставляемых пунктов для панели меню]
self.appendMenu("Название меню",list)
Gui.addWorkbench(MyWorkbench())
```
«Списки пунктов» list содержат строковые переменные — названия предоставляемых нашим инструментарием классов. Соответственно, для каждой строки из этих списков мы должны создать соответствующую команду или класс. При активации миниатюры на панели задач или пункта меню будет запущен конструктор этого класса, выполняющий какое-то действие. Минимальное содержимое этого класса таково:
```
class OneAction:
def Activated(self): #Initialize
import список файлов
функции, выполняемые при активации пункта меню или миниатюры
def GetResources(self):
import список файлов
IconPath = путь к миниатюре действия (для панели задач)
MenuText = "Текст пункта в меню"
ToolTip = "Подсказка"
return {'Pixmap' : IconPath, 'MenuText': MenuText, 'ToolTip': ToolTip}
FreeCADGui.addCommand('Название пункта', OneAction())
```
Последняя строка говорит FreeCAD'у, что нашему классу OneAction будет соответствовать строка «Название пункта» (соответственно, эту строку мы поместим в списки класса-инициализатора нашего инструментария).
Для того, чтобы создавать новые объекты, мы должны для этих объектов создать отдельный класс. Минимальное содержимое этого класса таково:
```
class MyObject:
def __init__(self, obj, значения):
''' Add new properties to partfeature '''
obj.addProperty("Тип свойства","Название свойства","Объект","Комментарий").свойство=значение
obj.Proxy = self
obj.Shape = функция построения объекта
Класс-провайдер(obj.ViewObject)
def onChanged(self, obj, prop):
действия, выполняемые при изменении свойства prop, obj - наш объект
Класс-провайдер(obj.ViewObject)
def execute(self, obj):
действия, выполняемые при "выполнении" объекта
Класс-провайдер(obj.ViewObject)
```
Класс-провайдер обеспечивает GUI ресурсами (значками и т.п.).
Примеры скриптов можно посмотреть в директориях ресурсов FreeCAD и в официальной документации.
Напоследок приведу примеры. Первый пример нарисован без использования командной консоли:
Второй пример — при помощи несложных скриптов, позволяющих рисовать линзы. Вот где, как говорится, «лучше день потерять, зато потом за час долететь». Вот такой код:
```
import Lens
a=[[8,6,1,6,3], [10,-15,2.5,8,5], [-16,10,0.5,6,7], [-8,-6,0.5,4,3], [3,3,0.2,2,1], [0,0,0.1,1,0.1], [0,3,.3,1]]
Lens.makeLensBench(a)
b=[[-10,8,0.1,6], [8,16,0.5,6], [16,-9,1,6]]
Lens.makeLensBench(b,App.Vector(0,10,0))
```
позволяет получить такое:
На [видео](https://dl.dropbox.com/u/78717568/Const_storage/freecad/Lens/lens.mkv) можно посмотреть, как выглядит эта модель.
Заинтересовавшимся советую зайти еще [сюда](http://freecad-tutorial.blogspot.com/) и посмотреть еще множество всяких разных примеров.
UPD: [вот пример](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg823.imageshack.us%2Fimg823%2F6783%2F20120627174611.png%22) реальной работы, выполненной во фрикаде (криостат). | https://habr.com/ru/post/145985/ | null | ru | null |
# Использование Razor за пределами ASP.NET
Итак, вчера [Microsoft выпустила ASP.NET MVC3 RTM](http://microgeek.ru/blogs/aspnet/1089/), который включает в себя новый движок представлений Razor. Как вы наверняка уже знаете, Razor не содержит каких-то компонентов, специфичных для web, а значит, его можно использовать и в других приложениях. Ну, а если вы этого еще не знаете – то самое время узнать!
В этом посте я покажу, как использовать Razor в качестве движка шаблонов для ваших нужд. Источником для него послужил блог-пост **Andrew Nurse** [«Hosting Razor outside of ASP.Net»](http://blog.andrewnurse.net/2010/11/16/HostingRazorOutsideOfASPNetRevisedForMVC3RC.aspx), но это не прямой перевод.
Для примера я создам текст письма, который содержит информацию о сделанном заказе.
Заказ описывается двумя классами, OrderModel и OrderItemModel:
```
public class OrderModel
{
public string FirstName { get; set; }
public string LastName { get; set; }
public List Items { get; set; }
}
public class OrderItemModel
{
public string ProductName { get; set; }
public Decimal Price { get; set; }
public int Qty { get; set; }
}
```
Шаблон, который я буду использовать для создания e-mail, показан ниже. Более подробную информацию о синтаксисе Razor вы можете получить, например, в блог-посте **Андрея Тарицына** [«Краткий справочник по синтаксису Razor [Перевод]»](http://www.gotdotnet.ru/blogs/taritsyn/9214/).
```
Здравствуйте, @Model.FirstName @Model.LastName!
# Продукт Цена Кол-во Итог
- ---------- ------ ------ ------
@for (var i = 0; i < Model.Items.Count; i++)
{
var item = Model.Items[i];
@String.Format(
"{0} {1,-10} {2,6} {3,6} {4,6}\r\n",
i + 1,
@item.ProductName,
@item.Price,
@item.Qty,
item.Price * item.Qty)
}
Всего: @(((OrderModel)Model).Items.Sum(x => x.Price * x.Qty))
WBR,
ACME team
```
Мне потребуется класс, который будет использоваться как базовый для моего шаблона:
```
public abstract class TemplateBase
{
public TextWriter Output { get; set; }
public dynamic Model { get; set; }
public abstract void Execute();
public virtual void Write(object value)
{
this.Output.Write(value);
}
public virtual void WriteLiteral(object value)
{
this.Output.Write(value);
}
}
```
Свойство Output задает TextWriter, который получает результат выполнения шаблона.
Свойство Model используется для передачи в шаблон параметров.
Метод Execute() в унаследованном классе будет содержать код шаблона.
Методы Write() и WriteLiteral() используются для вывода, соответственно, результатов вычисления выражений и текстовых строк. Т.к. мне не нужна дополнительная обработка ни для результатов вычислений, ни для строк, код этих методов совпадает.
*Примечание: имена Execute(), Write() и WriteLiteral() используются по умолчанию, при необходимости вы можете указать другие имена используя свойство GeneratedClassContext экземпляра класса RazorEngineHost.*
Теперь я создам хост для Razor, указав при этом, что в моем шаблоне используется C# (Razor поддерживает C# и VB, при необходимости вы можете использовать VB, передав к конструктор RazorEngineHost экземпляр VBRazorCodeLanguage):
```
var razorHost = new RazorEngineHost(new CSharpRazorCodeLanguage());
```
Далее я указываю имя базового класса, пространство имен, в котором будет находиться код шаблона, и имя класса-шаблона:
```
razorHost.DefaultBaseClass = typeof(TemplateBase).FullName;
razorHost.DefaultNamespace = "StandaloneRazorDemo";
razorHost.DefaultClassName = "Template";
```
Добавляю набор пространств имен, которые будут доступны в коде класса-шаблона:
```
razorHost.NamespaceImports.Add("System");
razorHost.NamespaceImports.Add("System.Collections.Generic");
razorHost.NamespaceImports.Add("System.Linq");
razorHost.NamespaceImports.Add("System.Text");
```
И, наконец, создаю движок шаблонов:
```
var razorEngine = new RazorTemplateEngine(razorHost);
```
Теперь я попробую разобрать свой шаблон:
```
var templateText = File.ReadAllText("template.txt");
GeneratorResults generatorResults = null;
using (var reader = new StringReader(templateText))
{
generatorResults = razorEngine.GenerateCode(reader);
}
```
Свойство Success класса GeneratorResults показывает, насколько успешно прошел разбор. Если при разборе возникли проблемы, я показываю список ошибок:
```
if (!generatorResults.Success)
{
foreach (var error in generatorResults.ParserErrors)
{
Console.WriteLine(
"Razor error: ({0}, {1}) {2}",
error.Location.LineIndex + 1,
error.Location.CharacterIndex + 1,
error.Message);
}
throw new ApplicationException();
}
```
Если разбор завершился успешно, свойство GeneratedCode содержит DOM tree, который далее можно использовать для генерации кода:
```
return generatorResults.GeneratedCode;
```
Теперь мне нужно скомпилировать шаблон:
```
private static string CompileTemplate(CodeCompileUnit generatedCode)
{
var codeProvider = new CSharpCodeProvider();
#if DEBUG
using (var writer = new StreamWriter("out.cs", false, Encoding.UTF8))
{
codeProvider.GenerateCodeFromCompileUnit(
generatedCode, writer, new CodeGeneratorOptions());
}
#endif
var outDirectory = "temp";
Directory.CreateDirectory(outDirectory);
var outAssemblyName = Path.Combine(outDirectory,
String.Format("{0}.dll", Guid.NewGuid().ToString("N")));
var refAssemblyNames = new List();
refAssemblyNames.Add(new Uri(typeof(TemplateBase).Assembly.CodeBase).AbsolutePath);
refAssemblyNames.Add("System.Core.dll");
refAssemblyNames.Add("Microsoft.CSharp.dll");
var compilerResults = codeProvider.CompileAssemblyFromDom(
new CompilerParameters(refAssemblyNames.ToArray(), outAssemblyName),
generatedCode);
if (compilerResults.Errors.HasErrors)
{
var errors = compilerResults
.Errors
.OfType()
.Where(x => !x.IsWarning);
foreach (var error in errors)
{
Console.WriteLine("Compiler error: ({0}, {1}) {2}",
error.Line, error.Column, error.ErrorText);
}
throw new ApplicationException();
}
return outAssemblyName;
}
```
Приведенный выше метод возвращает имя сборки, которая содержит скомпилированный шаблон.
Код, заключенный в #if DEBUG … #endif используется для отладки и позволяет посмотреть, во что же превратился шаблон после всех проведенных над ним манипуляций.
Все, что теперь мне нужно сделать, это загрузить сборку, создать экземпляр класса-шаблона и «выполнить» его:
```
var assembly = Assembly.LoadFrom(outAssemblyName);
var type = assembly.GetType("StandaloneRazorDemo.Template", true);
var template = Activator.CreateInstance(type) as TemplateBase;
using (var writer = new StringWriter())
{
template.Output = writer;
template.Model = GetModel();
template.Execute();
File.WriteAllText("out.txt", writer.ToString(), Encoding.UTF8);
}
```
Метод GetModel() определяется следующим образом:
```
private static OrderModel GetModel()
{
var model = new OrderModel { FirstName = "Джеймс", LastName = "Бонд" };
model.Items = new List();
model.Items.Add(new OrderItemModel { ProductName = "Apple", Price = 4.95m, Qty = 1 });
model.Items.Add(new OrderItemModel { ProductName = "Kiwi", Price = 9.95m, Qty = 2 });
return model;
}
```
Теперь в файле «out.txt» содержится результат «выполнения» шаблона:
```
Здравствуйте, Джеймс Бонд!
# Продукт Цена Кол-во Итог
- ---------- ------ ------ ------
1 Apple 4,95 1 4,95
2 Kiwi 9,95 2 19,90
Всего: 24,85
WBR,
ACME team
```
Вот и все!
Код примера:
[StandaloneRazorDemo.zip](http://sergeypopov.info/Files/StandaloneRazorDemo.zip) | https://habr.com/ru/post/111837/ | null | ru | null |
# Аналоги в Python и JavaScript. Часть первая
Привет, Хабр! Представляю вашему вниманию перевод статьи ["Equivalents in Python and JavaScript. Part 1"](https://djangotricks.blogspot.com/2018/06/equivalents-in-python-and-javascript-part-1.html).
Несмотря на то что Python и Javascript довольно сильно отличаются, существует много схожего, о чем должен знать любой фулстек разработчик. В [этой серии](https://djangotricks.blogspot.com/2018/06/equivalents-in-python-and-javascript-part-1.html) из 4-х статей мы увидим что есть общего в обоих языках, и рассмотрим ряд известных проблем а также способы их решения.
Это не справочник, здесь не будет базовой информация о типах переменных, if-ах и циклах.
Но мы рассмотрим более сложные структуры данных и операции с ними используя Python и Javascript.
Также я проиллюстрирую это примерами из практики.
Эта серия будет интересна бэкендерам, использующим Django, Flask или любой другой Python-фреймворк, которые хотят получше узнать о современном Javascript'е. С другой стороны, эти статьи будут полезны фронтендерам, которые желают лучше понять как работает бэкенд, или даже написать свой сайт на Django.
Остальные статьи в этой серии:
1. [Часть вторая](https://habr.com/post/417513/): JSON, регулярки, ошибки-исключения
2. [Часть третья](https://habr.com/post/418191/): современные Python и JS: строковые шаблоны (f-строки), распаковка списков, лямбда-функции, итерации по спискам, генераторы, множества.
3. [Четвертая часть](https://habr.com/post/419271/) — аргументы функций, создание и работа с классами, наследование, геттеры-сеттеры и свойства класса.
#### Приведение к типу
Начнем с приведения строки к целому. В Питоне все просто и прямолинейно:
```
number = int(text)
```
Но в JS вы должны объяснить к какой системе вы собираетесь приводить — к десятеричной, восьмеричной, шестнадцатеричной или двоичной:
```
number = parseInt(text, 10);
```
Для использования обычной десятеричной системы мы передаем 10 в виде второго аргумента функции parseInt(). 8 для восьмеричной, 16 для шестнадцатеричной или 2 — для двоичной. В случае если второй параметр опущен, число начинается с нуля и вы используете устаревший браузер, строка с текстом будет воспринята как восьмеричная система:
```
parseInt('012') == 10 // в некоторых старых браузерах
parseInt('012', 10) == 12
```
#### Условное присваивание
Хотя для этого Python и JS используют различный синтаксис, данная операция популярна в обоих языках. Популярна она потому, что в одном выражении можно присвоить различные значения как для True-, так и для False-случая.
Начиная с Python 2.7 условное присваивание выглядит так:
```
value = 'YES' if positive == True else 'NO'
```
В JavaScript условное присваивание производится с использованием тернарного оператора `?`, также как в C, C++, C#, Java, Ruby, PHP, Perl, Swift, and ActionScript:
```
value = positive === true? 'YES': 'NO';
```
#### Доступ к свойству объекта по имени свойства
Обычный способ доступа к свойству объекта и в Python и в JS одинаковый:
```
obj.color = 'YELLOW'
```
А как быть если название свойства заключено в строчную переменную? К примеру, название свойства может быть получено из списка свойств или название свойства составлено из двух строковых переменных: `"title" + land_code`.
В Питоне для этого существуют функции `getattr()` и `setattr()`:
```
attribute = 'color'
value = getattr(obj, attribute, 'GREEN')
setattr(obj, attribute, value)
```
В JS вы можете обращаться с объектом как со словарем и передавать имя свойства в квадратных скобках:
```
attribute = 'color';
value = obj[attribute] || 'GREEN';
obj[attribute] = value;
```
Чтобы получить значение по умолчанию в случае если свойства с таким именем не существует, в Питоне у функции `getattr()` есть для этого третий параметр. В JS, если запрашиваемое свойство отсутствует, функция вернет `undefined`. Его можно сравнить оператором `OR` со значением по дефолту – это стандартная практика в JS — такой способ можно встретить во многих фреймворках и библиотеках.
#### Доступ к словарю по ключу
Схоже с вышеизложенным. Ключ стандартно указывается в квадратных скобках в обоих языках:
```
dictionary = {}
dictionary['color'] = 'YELLOW'
```
Для доступа по ключу в Питоне используется стандартный синтаксис с квадратными скобками, однако в случае если такой ключ отсутствует это вызовет исключение с ошибкой `KeyError`.
Более гибким является метод `get()` который вернет `None` в случае отсутствия ключа. Также можно передать значение которое будет возвращено в случае отсутствия ключа:
```
key = 'color'
value = dictionary.get(key, 'GREEN')
```
В JS вы можете проделать такой же трюк как со свойством объекта – `OR` со значением по дефолту:
```
key = 'color';
value = dictionary[key] || 'GREEN';
```
#### Срезы: списки и строки
У Питона есть оператор `[:]` получения части списка, кортежа или схожих структур. Пример с объектом типа `Django QuerySets`:
```
items = [1, 2, 3, 4, 5]
first_two = items[:2] # [1, 2]
last_two = items[-2:] # [4, 5]
middle_three = items[1:4] # [2, 3, 4]
```
У JS есть метод `slice()` с тем же эффектом:
```
items = [1, 2, 3, 4, 5];
first_two = items.slice(0, 2); // [1, 2]
last_two = items.slice(-2); // [4, 5]
middle_three = items.slice(1, 4); // [2, 3, 4]
```
Но не путайте с методом `splice()` который изменяет исходный массив!
В Питоне оператор `[:]` также применим и к строкам:
```
text = 'ABCDE'
first_two = text[:2] # 'AB'
last_two = text[-2:] # 'DE'
middle_three = text[1:4] # 'BCD'
```
В JS у строк также есть метод `slice()`:
```
text = 'ABCDE';
first_two = text.slice(0, 2); // 'AB'
last_two = text.slice(-2); // 'DE'
middle_three = text.slice(1, 4); // 'BCD'
```
#### Операции со списками
В программировании часто приходится собирать и анализировать последовательность элементов. В Питоне для этого обычно используют списки, а в Javascript — массивы. У них схожий синтаксис и операции, но различаются методы добавления и удаления элементов.
Соединяем два списка, добавляем один элемент в конец, добавляем один элемент в начало, получаем и удаляем элемент в начале, получаем и удаляем элемент с конца и удаляем конкретный элемент по индексу.
Python:
```
items1 = ['A']
items2 = ['B']
items = items1 + items2 # items == ['A', 'B']
items.append('C') # ['A', 'B', 'C']
items.insert(0, 'D') # ['D', 'A', 'B', 'C']
first = items.pop(0) # ['A', 'B', 'C']
last = items.pop() # ['A', 'B']
items.delete(0) # ['B']
```
То же в Javascript:
```
items1 = ['A'];
items2 = ['B'];
items = items1.concat(items2); // items === ['A', 'B']
items.push('C'); // ['A', 'B', 'C']
items.unshift('D'); // ['D', 'A', 'B', 'C']
first = items.shift(); // ['A', 'B', 'C']
last = items.pop(); // ['A', 'B']
items.splice(0, 1); // ['B']
```
#### Соединяем наборы строк
Соединить набор строковых элементов в единую строку используя пробел, запятую или перевод строки в виде соединительного символа.
В Питоне для этого служит строковый метод `join()` который принимает в виде аргумента список или кортеж. Для непосвященного (в синтаксис Питона) может показаться странным начинать выражение с разделителя, но, после регулярного применения вы привыкнете к такой форме записи:
```
items = ['A', 'B', 'C']
text = ', '.join(items) # 'A, B, C'
```
В JS у массивов есть метод `join()` с разделителем в виде аргумента:
```
items = ['A', 'B', 'C'];
text = items.join(', '); // 'A, B, C'
```
#### Подытожим
* Списки (lists) и кортежи (tuples) в Python соответствуют массивам (arrays) в Javascript.
* Словари (dictionaries) в Python соответствуют объектам (objects) в Javascript.
* Строки в Питоне похожи на строки в Javascript.
* Приводить строку к числу в Javascript нужно с осторожностью, помня о системах счисления.
* Однострочные условные выражения существуют в ооих языках.
* Объединение последовательностей строк (`' '.join`) в Питоне обескураживает непосвященного в синтаксис, но к нему быстро привыкаешь.
В следующей серии мы посмотрим на создание и парсинг JSON, регулярные выражения и работу с ошибками и исключениями! | https://habr.com/ru/post/416617/ | null | ru | null |
# Сети для самых маленьких. Часть девятая. Мультикаст
**Все выпуски**
[8.1. Сети для самых маленьких. Микровыпуск №3. iBGP](http://linkmeup.ru/blog/65.html)
[8. Сети для самых маленьких. Часть восьмая. BGP и IP SLA](http://linkmeup.ru/blog/65.html)
[7. Сети для самых маленьких. Часть седьмая. VPN](http://linkmeup.ru/blog/50.html)
[6. Сети для самых маленьких. Часть шестая. Динамическая маршрутизация](http://linkmeup.ru/blog/33.html)
[5. Сети для самых маленьких: Часть пятая. NAT и ACL](http://linkmeup.ru/blog/16.html)
[4. Сети для самых маленьких: Часть четвёртая. STP](http://linkmeup.ru/blog/15.html)
[3. Сети для самых маленьких: Часть третья. Статическая маршрутизация](http://linkmeup.ru/blog/14.html)
[2. Сети для самых маленьких. Часть вторая. Коммутация](http://linkmeup.ru/blog/13.html)
[1. Сети для самых маленьких. Часть первая. Подключение к оборудованию cisco](http://linkmeup.ru/blog/12.html)
[0. Сети для самых маленьких. Часть нулевая. Планирование](http://linkmeup.ru/blog/11.html)
Наш умозрительный провайдер linkmeup взрослеет и обрастает по-тихоньку всеми услугами обычных операторов связи. Теперь мы доросли до IPTV.
Отсюда вытекает необходимость настройки мультикастовой маршрутизации и в первую очередь понимание того, что вообще такое мультикаст.
Это первое отклонение от привычных нам принципов работы IP-сетей. Всё-таки парадигма многоадресной рассылки в корне отличается от тёплого лампового юникаста.
Можно даже сказать, это в некоторой степени бросает вызов гибкости вашего разума в понимании новых подходов.
В этой статье сосредоточимся на следующем:
* [Общее понимание Multicast](#Multicast_Basics)
* [Протокол IGMP](#IGMP)
* [Протокол PIM](#PIM)
* >>>[PIM Dense Mode](#PIM-DM)
* >>>[Pim Sparse Mode](#PIM-SM)
* >>>[SPT Switchover — переключение RPT-SPT](#SPT_Switchover)
* >>>[DR, Assert, Forwarder](#DR_Assert_Forwarder)
* >>>[Автоматический выбор RP](#Bootstrap)
* >>>[SSM](#SSM)
* >>>[BIDIR PIM](#BIDIR_PIM)
* [Мультикаст на канальном уровне](#L2_Multicast)
* >>>[IGMP-Snooping](#IGMP_Snooping)
* >>>[MVR](#MVR)
[](http://img-fotki.yandex.ru/get/9810/83739833.39/0_de148_8fc00820_orig.jpg)
Традиционный видеоурок:
> На заре моего становления, как инженера, тема мультикаста меня неимоверно пугала, и я связываю это с психотравмой моего первого опыта с ним.
>
> «*Так, Марат, срочно, до полудня нужно пробросить видеопоток до нашего нового здания в центре города — провайдер отдаст его нам тут на втором этаже*» — услышал я одним чудесным утром. Всё, что я тогда знал о мультикасте, так это то, что отправитель один, получателей много, ну и, кажется, протокол IGMP там как-то задействован.
>
>
>
> В итоге до полудня мы пытались всё это дело запустить — я пробросил самый обычный VLAN от точки входа до точки выхода. Но сигнал был нестабильным — картинка замерзала, разваливалась, прерывалась. Я в панике пытался разобраться, что вообще можно сделать с IGMP, тыркался, тыркался, включал мультикаст роутинг, IGMP-snooping, проверял по тысяче раз задержки и потери — ничего не помогало. А потом вдруг всё заработало. Само собой, стабильно, безотказно.
>
>
>
> Это послужило мне прививкой против мультикаста, и долгое время я не проявлял к нему никакого интереса.
>
>
>
> Уже гораздо позже я пришёл в к следующему правилу:
>
> [](http://img-fotki.yandex.ru/get/9825/83739833.39/0_dd502_10ea996f_orig.png)
>
> И теперь с высоты оттраблшученных кейсов я понимаю, что там не могло быть никаких проблем с настройкой сетевой части — глючило конечное оборудование.
Сохраняйте спокойствие и доверьтесь мне. После этой статьи такие вещи вас пугать не будут.
Общее понимание Multicast
=========================
Как известно, существуют следующие типы трафика:
**Unicast** — одноадресная рассылка — один отправитель, один получатель. (*Пример: запрос HTTP-странички у WEB-сервера*).
**Broadcast** — широковещательная рассылка — один отправитель, получатели — все устройства в широковещательном сегменте. (*Пример: ARP-запрос*).
**Multicast** — многоадресная рассылка — один отправитель, много получателей. (*Пример: IPTV*).
**Anycast** — одноадресная рассылка ближайшему узлу — один отправитель, вообще получателей много, но фактически данные отправляются только одному. (*Пример: Anycast DNS*).
---
Раз уж мы решили поговорить о мультикасте, то, пожалуй, начнём этот параграф с вопроса, где и как он используется.
Первое, что приходит на ум, — это телевидение (IPTV) — один сервер-источник отправляет трафик, который хочет получать сразу много клиентов. Это и определяет сам термин — **multicast** — многоадресное вещание. То есть, если уже известный вам Broadcast означает вещание всем, мультикаст означает вещание определённой группе.
Второе применение — это, например, репликация операционной системы на множество компьютеров разом. Это подразумевает загрузку больших объёмов данных с одного сервера.
Возможные сценарии: аудио и видеоконференции (один говорит — все слушают), электронная коммерция, аукционы, биржи. Но это в теории, а на практике редко тут всё-таки используется мультикаст.
Ещё одно применение — это служебные сообщения протоколов. Например, OSPF в своём широковещательном домене рассылает свои сообщения на адреса 224.0.0.5 и 224.0.0.6. И обрабатывать их будут только те узлы, на которых запущен OSPF.
Сформулируем два основных принципа мультикастовой рассылки:
1. Отправитель посылает только одну копию трафика, независимо от количества получателей.
2. Трафик получают только те, кто действительно заинтересован в нём.
---
В данной статье для практики мы возьмём IPTV, как наиболее наглядный пример.
Пример I
--------
Начнём с самого простого случая:
На сервере-источнике настроено вещание в группу 224.2.2.4 — это означает, что сервер отправляет трафик на IP-адрес 224.2.2.4. На клиенте видеоплеер настроен принимать поток группы 224.2.2.4.
> При этом, заметьте, клиент и сервер не обязательно должны иметь адреса из одной подсети и пинговать друг друга — достаточно, чтобы они были в одном широковещательном домене.
Мультикастовый поток просто льётся с сервера, а клиент его просто принимает. Вы можете попробовать это прямо у себя на рабочем месте, соединив патчкордом два компьютера и запустив, например, VLC.
Надо заметить, что в мультикасте нет никакой сигнализации от источника, мол, *«Здрасьте, я Источник, не надо немного мультикаста?»*.
Сервер-источник просто начинает вещать в свой интерфейс мультикастовые пакеты. В нашем примере они напрямую попадают клиенту и тот, собственно, сразу же их и принимает.
Если на этом линке отловить пакеты, то вы увидите, что мультикастовый трафик — это ни что иное, как море UDP-пакетов.
Мультикаст не привязан к какому-то конкретному протоколу. По сути, всё, что его определяет — адреса. Однако, если говорить о его применении, то в абсолютном большинстве случаев используется именно UDP. Это легко объясняется тем, что обычно с помощью многоадресной рассылки передаются данные, которые нужны здесь и сейчас. Например, видео. Если кусочек кадра потеряется, и отправитель будет пытаться его послать повторно, как это происходит в TCP, то, скорее всего, этот кусочек опоздает, и где его тогда показывать? Поезд ушёл. Ровно то же самое со звуком.
Соответственно не нужно и устанавливать соединение, поэтому TCP здесь ни к чему.
Чем же так разительно отличается мультикаст от юникаста? Думаю, у вас есть уже предположение. И вы, наверняка, правы.
В обычной ситуации у нас 1 получатель и 1 отправитель — у каждого из них один уникальный IP-адрес. Отправитель точно знает, куда надо слать пакет и ставит этот адрес в заголовок IP. Каждый промежуточный узел благодаря своей таблице маршрутизации точно знает, куда переслать пакет. Юникастовый трафик между двумя узлами беспрепятственно проходит сквозь сеть. Но проблема в том, что в обычном пакете указывается только один IP-адрес получателя.
Что делать, если у одного и того же трафика несколько получателей? В принципе можно расширить одноадресный подход и на такую ситуацию — отправлять каждому клиенту свой экземпляр пакета. Клиенты не заметят разницы — хоть он один, хоть их тысяча, но разница будет отчётливо различима на ваших каналах передачи данных.
Предположим у нас идёт передача одного SD-канала с мультикаст-сервера. Пусть, он использует 2 Мб/с. Всего таких каналов 30, а смотрит каждый канал по 20 человек одновременно. Итого получается 2 Мб/с \* 30 каналов \* 20 человек = 1200 Мб/с или 1,2 Гб/с только на телевидение в случае одноадресной рассылки. А есть ведь ещё HD каналы, где можно смело умножать эту цифру на 2. И где тут место для торрентов?
Вот почему в IPv4 был заложен блок адресов **класса D: 224.0.0.0/4** (224.0.0.0-239.255.255.255). Адреса этого диапазона определяют мультикастовую группу. Один адрес — это одна группа, обычно она обозначается буквой «**G**».
То есть, говоря, что клиент подключен к группе 224.2.2.4, мы имеем ввиду, что он получает мультикастовый трафик с адресом назначения 224.2.2.4.
Пример II
---------
Добавим в схему коммутатор и ещё несколько клиентов:
Мультикастовый сервер по-прежнему вещает для группы 224.2.2.4. На коммутаторе все 4 порта должны быть в одном VLAN. Трафик приходит на коммутатор и по умолчанию рассылается во все порты одного VLAN'а. Значит все клиенты получают этот трафик. На них на всех в видеопроигрывателе так же указан групповой адрес 224.2.2.4.
Собственно, все эти устройства становятся членами данной мультикастовой группы. Членство в ней динамическое: кто угодно, в любой момент может войти и выйти из неё.
> В данной ситуации трафик будут получать даже те, кто этого в общем-то и не хотел, то есть на нём не запущен ни плеер, ни что бы то ни было другое. Но только, если он в том же VLAN'е. [Позже](#IGMP_Snooping) мы разберёмся, как с этим бороться.
Обратите внимание, что в данном случае от сервера-источника приходит только одна копия трафика на коммутатор, а не по отдельной копии на каждого клиента. И в нашем примере с SD каналами загрузка порта между источником и коммутатором будет не 1,2 Гб/с, а всего 60 Мб/с (2Мб/с \* 30 каналов).
Собственно говоря, весь этот огромный диапазон (224.0.0.0-239.255.255.255) можно использовать.
Ну, почти весь — первые адреса (диапазон 224.0.0.0/23) всё-таки зарезервированы под известные протоколы.
**Список зарезервированных IP-адресов**
| Адрес | Значение |
| --- | --- |
| 224.0.0.0 | Не используется |
| 224.0.0.1 | Все узлы данного сегмента |
| 224.0.0.2 | Все мультикастовые узлы данного сегмента |
| 224.0.0.4 | Данный адрес выделялся для покойного протокола DVMRP |
| 224.0.0.5 | Все OSPF-маршрутизаторы сегмента |
| 224.0.0.6 | Все DR маршрутизаторы сегмента |
| 224.0.0.9 | Все RIPv2-маршрутизаторы сегмента |
| 224.0.0.10 | Все EIGRP-маршрутизаторы сегмента |
| 224.0.0.13 | Все PIM-маршрутизаторы сегмента |
| 224.0.0.18 | Все VRRP-маршрутизаторы сегмента |
| 224.0.0.19-21 | Все IS-IS-маршрутизаторы сегмента |
| 224.0.0.22 | Все IGMP-маршрутизаторы сегмента (v2 и v3) |
| 224.0.0.102 | Все HSRPv2/GLBP-маршрутизаторы сегмента |
| 224.0.0.107 | PTPv2 — Precision Time Protocol |
| 224.0.0.251 | mDNS |
| 224.0.0.252 | LLMNR |
| 224.0.0.253 | Teredo |
| 224.0.1.1 | NTP |
| 224.0.1.39 | Cisco Auto-RP-Announce |
| 224.0.1.40 | Cisco Auto-RP-Discovery |
| 224.0.1.41 | H.323 Gatekeeper |
| 224.0.1.129-132 | PTPv1/PTPv2 |
| 239.255.255.250 | SSDP |
Диапазон 224.0.0.0/24 зарезервирован под [link-local](http://lookmeup.linkmeup.ru/#term42) коммуникации. Мультикастовые пакеты с такими адресами назначения не могут выходить за пределы одного широковещательного сегмента.
Диапазон 224.0.1.0/24 зарезервирован под протоколы, которым необходимо передавать мультикаст по всей сети, то есть проходить через маршрутизаторы.
---
Вот, собственно, самые базисные вещи касательно мультикаста.
Мы рассмотрели простую ситуацию, когда источник и получатель находятся в одном сегменте сети. Трафик, полученный коммутатором, просто рассылается им во все порты — никакой магии.
Но пока совсем непонятно, как трафик от сервера достигает клиентов, когда между ними огромная провайдерская сеть линкмиап? Да и откуда, собственно, будет известно, кто клиент? Мы же не можем вручную прописать маршруты, просто потому что не знаем, где могут оказаться клиенты. Не ответят на этот вопрос и обычные протоколы маршрутизации. Так мы приходим к пониманию, что доставка мультикаст — это нечто совершенно новое для нас.
Вообще, чтобы доставить мультикаст от источника до получателя на данный момент существует много протоколов — IGMP/MLD, PIM, MSDP, MBGP, MOSPF, DVMRP.
Мы остановимся на двух из них, которые используются в настоящее время: PIM и IGMP.
С помощью IGMP конечные получатели-клиенты сообщают ближайшим маршрутизаторам о том, что хотят получать трафик. А PIM строит путь движения мультикастового трафика от источника до получателей через маршрутизаторы.
---
IGMP
====
Снова вернёмся к дампу. Видите вот этот верхний пакет, после которого полился мультикастовый поток?
Это сообщение протокола IGMP, которое отправил клиент, когда мы на нём нажали Play. Именно так он сообщает о том, что хочет получать трафик для группы 224.2.2.4.
**IGMP — Internet Group Management Protocol** — это сетевой протокол взаимодействия клиентов мультикастового трафика и ближайшего к ним маршрутизатора.
> В IPv6 используется [MLD](http://lookmeup.linkmeup.ru/#term286) (Multicast Listener Discovery) вместо IGMP. Принцип работы у них абсолютно одинаковый, поэтому далее везде вы смело можете менять IGMP на MLD, а IP на IPv6.
Как же именно работает IGMP?
Пожалуй, начать нужно с того, что версий у протокола сейчас три: IGMPv1, IGMPv2, IGMPv3. Наиболее используемая — вторая, первая уже практически забыта, поэтому про неё говорить не будем, третья очень похожа на вторую.
Акцентируемся пока на второй, как на самой показательной, и рассмотрим все события от подключения клиента к группе до его выхода из неё.
Клиент будет также запрашивать группу 224.2.2.4 через проигрыватель VLC.
Роль IGMP очень проста: если клиентов нет — передавать мультикастовый трафик в сегмент не надо. Если появился клиент, он уведомляет маршрутизаторы с помощью IGMP о том, что хочет получать трафик.
Для того, чтобы понять, как всё происходит, возьмём такую сеть:
Предположим, что маршрутизатор уже настроен на получение и обработку мультикастового трафика.
**1.** Как только мы запустили приложение на клиенте и задали группу 224.2.2.4, в сеть будет отправлен пакет **IGMP Membership Report** — узел «рапортует» о том, что хочет получать трафик этой группы.
В IGMPv2 Report отправляется на адрес желаемой группы, и параллельно он же указывается в самом пакете. Данные сообщения должны жить только в пределах своего сегмента и не пересылаться никуда маршрутизаторами, поэтому и TTL у них 1.
> Часто в литературе вы можете встретить упоминание о **IGMP Join**. Не пугайтесь — это альтернативное название для IGMP Membership Report.
**2.** Маршрутизатор получает IGMP-Report и, понимая, что за данным интерфейсом теперь есть клиенты, заносит информацию в свои таблицы
Это вывод информации по IGMP. Первая группа запрошена клиентом. Третья и четвёртая — это служебные группы протокола [SSDP](http://lookmeup.linkmeup.ru/#term158), встроенного в Windows. Вторая — специальная группа, которая всегда присутствует на маршрутизаторах Cisco — она используется для протокола [Auto-RP](http://lookmeup.linkmeup.ru/#term306), который по умолчанию активирован на маршрутизаторах.
Интерфейс FE0/0 становится нисходящим для трафика группы 224.2.2.4 — в него нужно будет отправлять полученный трафик.
Наряду с обычной юникастовой таблицей маршрутизации существует ещё и мультикастовая:
О наличии клиентов говорит первая запись **(\*, 224.2.2.4)**. А запись **(172.16.0.5, 224.2.2.4)** означает, что маршрутизатор знает об источнике мультикастового потока для этой группы.
Из вывода видно, что трафик для группы 224.2.2.4 приходит через FE0/1, а передавать его надо на порт FE0/0.
Интерфейсы, в которые нужно передавать трафик, входят в список нисходящих интерфейсов — **OIL — Outbound Interface List**.
Более подробно вывод команды **show ip mroute** мы разберём позже.
Выше на дампе вы видите, что как только клиент отправил IGMP-Report, сразу после него полетели UDP — это видеопоток.
**3.** Клиент начал получать трафик. Теперь маршрутизатор должен иногда проверять, что получатели до сих пор у него есть, чтобы зазря не вещать, если вдруг клиентов не осталось. Для этого он периодически отправляет во все свои нисходящие интерфейсы запрос **IGMP Query**.
*\*Дамп отфильтрован по IGMP\**.
По умолчанию это происходит каждые 60 секунд. TTL таких пакетов тоже равен 1. Они отправляются на адрес 224.0.0.1 — все узлы в этом сегменте — без указания конкретной группы. Такие сообщений Query называются **General Query** — общие. Таким образом маршрутизатор спрашивает: «Ребят, а кто и что ещё хочет получать?».
Получив IGMP General Query, любой хост, который слушает любую группу, должен отправить IGMP Report, как он это делал при подключении. В Report, естественно, должен быть указан адрес интересующей его группы.
*\*Дамп отфильтрован по IGMP\**.
Если в ответ на Query на маршрутизатор пришёл хотя бы один Report для группы, значит есть ещё клиенты, он продолжает вещать в тот интерфейс, откуда пришёл этот Report, трафик этой самой группы.
Если на 3 подряд Query не было с интерфейса ответа для какой-то группы, маршрутизатор удаляет этот интерфейс из своей таблицы мультикастовой маршрутизации для данной группы — перестаёт туда посылать трафик.
По своей инициативе клиент обычно посылает Report только при подключении, потом — просто отвечает на Query от маршрутизатора.
> Интересная деталь в поведении клиента: получив Query, он не торопится сразу же ответить Report'ом. Узел берёт тайм-аут длиной от 0 до **Max Response Time**, который указан в пришедшем Query:
>
>
>
> 
>
>
>
> При отладке или в дампе, кстати, можно видеть, что между получением различных Report может пройти несколько секунд.
>
> Сделано это для того, чтобы сотни клиентов все скопом не наводнили сеть своими пакетам Report, получив General Query. Более того, только один клиент обычно отправляет Report.
>
> Дело в том, что Report отсылается на адрес группы, а следовательно доходит и до всех клиентов. Получив Report от другого клиента для этой же группы, узел не будет отправлять свой. Логика простая: маршрутизатор и так уже получил этот самый Report и знает, что клиенты есть, больше ему не надо.
>
> Этот механизм называется **Report Suppression**.
>
>
>
> **Далее в статье мы расскажем о том, почему этот механизм на деле очень редко реально работает**.
**4.** Так продолжается веками, пока клиент не захочет выйти из группы (например, выключит плеер/телевизор). В этом случае он отправляет **IGMP Leave** на адрес группы.
Маршрутизатор получает его и по идее должен отключить. Но он ведь не может отключить одного конкретного клиента — маршрутизатор их не различает — у него просто есть нисходящий интерфейс. А за интерфейсом может быть несколько клиентов. То есть, если маршрутизатор удалит этот интерфейс из своего списка OIL (Outgoing Interface List) для этой группы, видео выключится у всех.
Но и не удалять его совсем тоже нельзя — вдруг это был последний клиент — зачем тогда впустую вещать?
Если вы посмотрите в дамп, то увидите, что после получения Leave маршрутизатор ещё некоторое время продолжает слать поток. Дело в том, что маршрутизатор в ответ на Leave высылает IGMP Query на адрес группы, для которой этот Leave пришёл в тот интерфейс, откуда он пришёл. Такой пакет называется **Group Specific Query**. На него отвечают **только** те клиенты, которые подключены к данной конкретной группе.
Если маршрутизатор получил ответный Report для группы, он продолжает вещать в интерфейс, если не получил — удаляет по истечении таймера.
Всего после получения Leave отправляется два Group Specific Query — один обязательный, второй контрольный.
*\*Дамп отфильтрован по IGMP\**.
Далее маршрутизатор останавливает поток.
---
### Querier
Рассмотрим чуть более сложный случай:
В клиентский сегмент подключено два (или больше) маршрутизатора, которые могут вещать трафик. Если ничего не сделать, мультикастовый трафик будет дублироваться — оба маршрутизатора ведь будут получать Report от клиентов. Во избежание этого существует механизм выбора **Querier** — опрашивателя. Тот кто победит, будет посылать Query, мониторить Report и реагировать на Leave, ну и, соответственно, он будет отправлять и трафик в сегмент. Проигравший же будет только слушать Report и держать руку на пульсе.
Выборы происходят довольно просто и интуитивно понятно.
Рассмотрим ситуацию с момента включения маршрутизаторов R1 и R2.
**1)** Активировали IGMP на интерфейсах.
**2)** Сначала по умолчанию каждый из них считает себя Querier.
**3)** Каждый отправляет IGMP General Query в сеть. Главная цель — узнать, есть ли клиенты, а параллельно — заявить другим маршрутизаторам в сегменте, если они есть, о своём желании участвовать в выборах.
**4)** General Query получают все устройства в сегменте, в том числе и другие IGMP-маршрутизаторы.
**5)** Получив такое сообщение от соседа, каждый маршрутизатор оценивает, кто достойнее.
**6)** Побеждает маршрутизатор с **меньшим IP** (указан в поле Source IP пакета IGMP Query). Он становится Querier, все другие — Non-Querier.
**7)** Non-Querier запускает таймер, который обнуляется каждый раз, как приходит Query с меньшим IP-адресом. Если до истечения таймера (больше 100 секунд: 105-107) маршрутизатор не получит Query с меньшим адресом, он объявляет себя Querier и берёт на себя все соответствующие функции.
**8)** Если Querier получает Query с меньшим адресом, он складывает с себя эти обязанности. Querier'ом становится другой маршрутизатор, у которого IP меньше.
*Тот редкий случай, когда меряются, у кого меньше.*
Выборы Querier очень важная процедура в мультикасте, но некоторые коварные производители, не придерживающиеся RFC, могут вставить крепкую палку в колёса. Я сейчас говорю о IGMP Query с адресом источника 0.0.0.0, которые могут генерироваться коммутатором. Такие сообщения не должны участвовать в выборе Querier, но надо быть готовыми ко всему. [Вот пример](http://nag.ru/articles/article/25136/takie-raznyie-problemyi.html) весьма сложной долгоиграющей проблемы.
---
### Ещё пара слов о других версиях IGMP
Версия 1 отличается по сути только тем, что **в ней нет сообщения Leave**. Если клиент не хочет больше получать трафик данной группы, он просто перестаёт посылать Report в ответ на Query. Когда не останется ни одного клиента, маршрутизатор по таймауту перестанет слать трафик.
Кроме того, **не поддерживаются выборы Querier**. За избежание дублирования трафика отвечает вышестоящий протокол, например, PIM, о котором мы будем говорить [далее](#PIM).
Версия 3 поддерживает всё то, что поддерживает IGMPv2, но есть и ряд изменений. Во-первых, Report отправляется уже не на адрес группы, а на мультикастовый служебный адрес **224.0.0.22**. А адрес запрашиваемой группы указан только внутри пакета. Делается это для упрощения работы IGMP Snooping, о котором мы поговорим [дальше](#IGMP_Snooping).
Во-вторых, что более важно, IGMPv3 стал поддерживать SSM в чистом виде. Это так называемый [**Source Specific Multicast**](http://lookmeup.linkmeup.ru/#term284). В этом случае клиент может не просто запросить группу, но также указать список источников, от которых он хотел бы получать трафик или наоборот не хотел бы. В IGMPv2 клиент просто запрашивает и получает трафик группы, не заботясь об источнике.
Итак, IGMP предназначен для взаимодействия клиентов и маршрутизатора. Поэтому, возвращаясь к *Примеру II*, где нет маршрутизатора, мы можем авторитетно заявить — IGMP там — не более, чем формальность. Маршрутизатора нет, и клиенту не у кого запрашивать мультикастовый поток. А заработает видео по той простой причине, что поток и так льётся от коммутатора — надо только подхватить его.
Напомним, что IGMP не работает для IPv6. Там существует протокол [MLD](http://lookmeup.linkmeup.ru/#term286).
---
### Повторим ещё раз
*\*Дамп отфильтрован по IGMP\**.
**1.** Первым делом маршрутизатор отправил свой IGMP General Query после включения IGMP на его интерфейсе, чтобы узнать, есть ли получатели и заявить о своём желании быть Querier. На тот момент никого не было в этой группе.
**2.** Далее появился клиент, который захотел получать трафик группы 224.2.2.4 и он отправил свой IGMP Report. *После этого пошёл трафик на него, но он отфильтрован из дампа.*
**3.** Потом маршрутизатор решил зачем-то проверить — а нет ли ещё клиентов и отправил IGMP General Query ещё раз, на который клиент вынужден ответить (**4**).
**5.** Периодически (раз в минуту) маршрутизатор проверяет, что получатели по-прежнему есть, с помощью IGMP General Query, а узел подтверждает это с помощью IGMP Report.
**6.** Потом он передумал и отказался от группы, отправив IGMP Leave.
**7.** Маршрутизатор получил Leave и, желая убедиться, что больше никаких других получателей нет, посылает IGMP Group Specific Query… дважды. И по истечении таймера перестаёт передавать трафик сюда.
**8.** Однако передавать IGMP Query в сеть он по-прежнему продолжает. Например, на тот случай, если вы плеер не отключали, а просто где-то со связью проблемы. Потом связь восстанавливается, но клиент-то Report не посылает сам по себе. А вот на Query отвечает. Таким образом поток может восстановиться без участия человека.
---
### И ещё раз
**IGMP** — протокол, с помощью которого маршрутизатор узнаёт о наличии получателей мультикастового трафика и об их отключении.
**IGMP Report** — посылается клиентом при подключении и в ответ на IGMP Query. Означает, что клиент хочет получать трафик конкретной группы.
**IGMP General Query** — посылается маршрутизатором периодически, чтобы проверить какие группы сейчас нужны. В качестве адреса получателя указывается 224.0.0.1.
**IGMP Group Sepcific Query** — посылается маршрутизатором в ответ на сообщение Leave, чтобы узнать есть ли другие получатели в этой группе. В качестве адреса получателя указывается адрес мультикастовой группы.
**IGMP Leave** — посылается клиентом, когда тот хочет покинуть группу.
**Querier** — если в одном широковещательном сегменте несколько маршрутизаторов, который могут вещать, среди них выбирается один главный — Querier. Он и будет периодически рассылать Query и передавать трафик.
Подробное описание всех терминов [IGMP](http://lookmeup.linkmeup.ru/#term264).
---
PIM
===
Итак, мы разобрались, как клиенты сообщают ближайшему маршрутизатору о своих намерениях. Теперь неплохо было бы передать трафик от источника получателю через большую сеть.
Если вдуматься, то мы стоим перед довольной сложной проблемой — источник только вещает на группу, он ничего не знает о том, где находятся получатели и сколько их.
Получатели и ближайшие к ним маршрутизаторы знают только, что им нужен трафик конкретной группы, но понятия не имеют, где находится источник и какой у него адрес.
Как в такой ситуации доставить трафик?
Существует несколько протоколов маршрутизации мультикастового трафика: [DVMRP](http://lookmeup.linkmeup.ru/#term371), [MOSPF](http://lookmeup.linkmeup.ru/#term241), [CBT](http://lookmeup.linkmeup.ru/#term370) — все они по-разному решают такую задачу. Но стандартом де факто стал **PIM — Protocol Independent Multicast**.
Другие подходы настолько нежизнеспособны, что порой даже их разработчики практически признают это. Вот, например, выдержка из RFC по протоколу CBT:
*CBT version 2 is not, and was not, intended to be backwards compatible with version 1; we do not expect this to cause extensive compatibility problems because we do not believe CBT is at all widely deployed at this stage.*
PIM имеет две версии, которые можно даже назвать двумя различными протоколами в принципе, уж сильно они разные:
* PIM Dense Mode (DM)
* PIM Sparse Mode (SM)
Independent он потому, что не привязан к какому-то конкретному протоколу маршрутизации юникастового трафика, и позже вы увидите почему.
PIM Dense Mode
--------------
**PIM DM** пытается решить проблему доставки мультиакста в лоб. Он заведомо предполагает, что получатели есть везде, во всех уголках сети. Поэтому изначально он наводняет всю сеть мультикастовым трафиком, то есть рассылает его во все порты, кроме того, откуда он пришёл. Если потом оказывается, что где-то он не нужен, то эта ветка «отрезается» с помощью специального сообщения PIM Prune — трафик туда больше не отправляется.
Но через некоторое время в эту же ветку маршрутизатор снова пытается отправить мультикаст — вдруг там появились получатели. Если не появились, ветка снова отрезается на определённый период. Если клиент на маршрутизаторе появился в промежутке между этими двумя событиями, отправляется сообщение Graft — маршрутизатор запрашивает отрезанную ветку обратно, чтобы не ждать, пока ему что-то перепадёт.
Как видите, здесь не стоит вопрос определения пути к получателям — трафик достигнет их просто потому, что он везде.
После «обрезания» ненужных ветвей остаётся дерево, вдоль которого передаётся мультикастовый трафик. Это дерево называется **SPT — Shortest Path Tree**.
Оно лишено петель и использует кратчайший путь от получателя до источника. По сути оно очень похоже на Spanning Tree в [STP](http://linkmeup.ru/blog/15.html), где корнем является источник.
SPT — это конкретный вид дерева — дерево кратчайшего пути. А вообще любое мультикастовое дерево называется **MDT — Multicast Distribution Tree**.
Предполагается, что PIM DM должен использоваться в сетях с высокой плотностью мультикастовых клиентов, что и объясняет его название (Dense). Но реальность такова, что эта ситуация — скорее, исключение, и зачастую PIM DM нецелесообразен.
Что нам действительно важно сейчас — это механизм избежания петель.
Представим такую сеть:
Один источник, один получатель и простейшая IP-сеть между ними. На всех маршрутизаторах запущен PIM DM.
Что произошло бы, если бы не было специального механизма избежания петель?
Источник отправляет мультикастовый трафик. R1 его получает и в соответствии с принципами PIM DM отправляет во все интерфейсы, кроме того, откуда он пришёл — то есть на R2 и R3.
R2 поступает точно так же, то есть отправляет трафик в сторону R3. R3 не может определить, что это тот же самый трафик, который он уже получил от R1, поэтому пересылает его во все свои интерфейсы. R1 получит копию трафика от R3 и так далее. Вот она — петля.
Что же предлагает PIM в такой ситуации? **RPF — Reverse Path Forwarding**. Это главный принцип передачи мультикастового трафика в PIM (любого вида: и DM и SM) — трафик от источника должен приходить по кратчайшему пути.
То есть для каждого полученного мультикастового пакета производится проверка на основе таблицы маршрутизации, оттуда ли он пришёл.
1) Маршрутизатор смотрит на адрес источника мультикастового пакета.
2) Проверяет таблицу маршрутизации, через какой интерфейс доступен адрес источника.
3) Проверяет интерфейс, через который пришёл мультикастовый пакет.
4) Если интерфейсы совпадают — всё отлично, мультикастовый пакет пропускается, если же данные приходят с другого интерфейса — они будут отброшены.
В нашем примере R3 знает, что кратчайший путь до источника лежит через R1 (статический или динамический маршрут). Поэтому мультикастовые пакеты, пришедшие от R1, проходят проверку и принимаются R3, а те, что пришли от R2, отбрасываются.
Такая проверка называется **RPF-Check** и благодаря ей даже в более сложных сетях петли в MDT не возникнут.
Этот механизм важен нам, потому что он актуален и в PIM-SM и работает там точно также.
Как видите, PIM опирается на таблицу юникастовой маршрутизации, но, во-первых, сам не маршрутизирует трафик, во-вторых, ему не важно, кто и как наполнял таблицу.
Останавливаться здесь и подробно рассматривать работу PIM DM мы не будем — это устаревший протокол с массой недостатков (ну, как [RIP](http://lookmeup.linkmeup.ru/#term242)).
Однако PIM DM может применяться в некоторых случаях. Например, в совсем небольших сетях, где поток мультикаста небольшой.
---
PIM Sparse Mode
---------------
Совершенно другой подход применяет **PIM SM**. Несмотря на название (разреженный режим), он с успехом может применяться в любой сети с эффективностью как минимум не хуже, чем у PIM DM.
Здесь отказались от идеи безусловного наводнения мультикастом сети. Заинтересованные узлы самостоятельно запрашивают подключение к дереву с помощью сообщений **PIM Join**.
Если маршрутизатор не посылал Join, то и трафик ему отправляться не будет.
Для того, чтобы понять, как работает PIM, начнём с уже знакомой нам простой сети с одним PIM-маршрутизатором:
Из настроек на R1 надо включить возможность маршрутизации мультикаста, PIM SM на двух интерфейсах (в сторону источника и в сторону клиента) и IGMP в сторону клиента. *Помимо прочих базовых настроек, конечно (IP, IGP).*
С этого момента вы можете расчехлить GNS и собирать лабораторию. Достаточно подробно о том, как собрать стенд для мультикаста я рассказал в этой [статье](http://linkmeup.ru/blog/126.html).
```
R1(config)#ip multicast-routing
R1(config)#int fa0/0
R1(config-if)#ip pim sparse-mode
R1(config-if)#int fa1/0
R1(config-if)#ip pim sparse-mode
```
> Cisco тут как обычно отличается своим особенным подходом: при активации PIM на интерфейсе, автоматически активируется и IGMP. На всех интерфейсах, где активирован PIM, работает и IGMP.
>
> В то же время у других производителей два разных протокола включаются двумя разными командами: отдельно IGMP, отдельно PIM.
>
> Простим Cisco эту странность? Вместе со всеми остальными?
>
>
>
> Плюс, возможно, потребуется настроить адрес RP (**ip pim rp-address 172.16.0.1**, например). Об этом позже, пока примите как данность и смиритесь.
Проверим текущее состояние таблицы мультикастовой маршрутизации для группы 224.2.2.4:
После того, как на источнике вы запустите вещание, надо проверить таблицу ещё раз.
Давайте разберём этот немногословный вывод.
Запись вида **(\*, 225.0.1.1)** называется **(\*, G)**, /читается *старкомаджи*/ и сообщает нам о получателях. Причём не обязательно речь об одном клиенте-компьютере, вообще это может быть и, например, другой PIM-маршрутизатор. Важно то, в какие интерфейсы надо передавать трафик.
Если список нисходящих интерфейсов (OIL) пуст — **Null**, значит нет получателей — а мы их пока не запускали.
Запись **(172.16.0.5, 225.0.1.1)** называется **(S, G)**, /читается *эскомаджи*/ и говорит о том, что известен источник. В нашем случае источник с адресом 172.16.0.5 вещает трафик для группы 224.2.2.4. Мультикастовый трафик приходит на интерфейс FE0/1 — это **восходящий** (**Upstream**) интерфейс.
Итак, нет клиентов. Трафик от источника доходит до маршрутизатора и на этом его жизнь кончается. Давайте добавим теперь получателя — настроим приём мультикаста на ПК.
ПК отсылает IGMP Report, маршрутизатор понимает, что появились клиенты и обновляет таблицу мультикастовой маршрутизации.
Теперь она выглядит так:
Появился и нисходящий интерфейс: FE0/0, что вполне ожидаемо. Причём он появился как в (\*, G), так и в (S, G). Список нисходящих интерфейсов называется **OIL — Outgoing Interface List**.
Добавим ещё одного клиента на интерфейс FE1/0:
Если читать вывод дословно, то имеем:
(\*, G): Есть получатели мультикастового трафика для группы 224.2.2.4 за интерфейсами FE0/0, FE1/0. Причём совершенно неважно, кто отправитель, о чём и говорит знак «\*».
(S, G): Когда мультикастовый трафик с адресом назначения 224.2.2.4 от источника 172.16.0.5 приходит на интерфейс FE0/1, его копии нужно отправить в FE0/0 и FE1/0.
Но это был очень простой пример — один маршрутизатор сразу знает и адрес источника и где находятся получатели. Фактически даже деревьев тут никаких нет — разве что вырожденное. Но это помогло нам разобраться с тем, как взаимодействуют PIM и IGMP.
---
### Чтобы разобраться с тем, что такое PIM, обратимся к сети гораздо более сложной
Предположим, что уже настроены все IP-адреса в соответствии со схемой. На сети запущен IGP для обычной юникастовой маршрутизации.
*Клиент1*, например, может пинговать Сервер-источник.
Но пока не запущен PIM, IGMP, клиенты не запрашивают каналы.
[Файл начальной конфигурации](https://docs.google.com/document/d/1rtrifoyP4mwjnbVug8zW-nL0g5qm1405IaWpbasusog/pub).
Итак, момент времени 0.
Включаем мультикастовую маршрутизацию на всех пяти маршрутизаторах:
```
RX(config)#ip multicast-routing
```
PIM включается непосредственно на всех интерфейсах всех маршрутизаторов (в том числе на интерфейсе в сторону Сервера-источника и клиентов):
```
RX(config)#int FEX/X
RX(config-if)#ip pim sparse-mode
```
> IGMP, по идее должен включаться на интерфейсах в сторону клиентов, но, как мы уже отметили выше, на оборудовании Cisco он включается автоматически вместе с PIM.
---
Первое, что делает PIM — устанавливает соседство. Для этого используются сообщения **PIM Hello**. При активации PIM на интерфейсе с него отправляется PIM Hello на адрес **224.0.0.13** с TTL равным 1. Это означает, что соседями могут быть только маршрутизаторы, находящиеся в одном широковещательном домене.
Как только соседи получили приветствия друг от друга:
Теперь они готовы принимать заявки на мультикастовые группы.
Если мы сейчас запустим в вольер клиентов с одной стороны и включим мультикастовый поток с сервера с другой, то R1 получит поток трафика, а R4 получит IGMP Report при попытке клиента подключиться. В итоге R1 не будет знать ничего о получателях, а R4 об источнике.
Неплохо было бы если бы информация об источнике и о клиентах группы была собрана где-то в одном месте. Но в каком?
Такая точка встречи называется **Rendezvous Point — RP**. Это центральное понятие PIM SM. Без неё ничего бы не работало. Здесь встречаются источник и получатели.
Все PIM-маршрутизаторы должны знать, кто является RP в домене, то есть знать её IP-адрес.
Чтобы построить дерево MDT, в сети выбирается в качестве RP некая центральная точка, которая,
1. отвечает за изучение источника,
2. является точкой притяжения сообщений Join от всех заинтересованных.
Существует два способа задания RP: статический и динамический. Мы рассмотрим оба в этой статье, но начнём со статического, поскольку чего уж проще статики?
Пусть пока R2 будет выполнять роль RP.
Чтобы увеличить надёжность, обычно выбирается адрес Loopback-интерфейса. Поэтому **на всех** маршрутизаторах выполняется команда:
```
RX(config)#ip pim rp-address 2.2.2.2
```
Естественно, этот адрес должен быть доступен по таблице маршрутизации со всех точек.
Ну и поскольку адрес 2.2.2.2 является RP, на интерфейсе *Loopback 0* на R2 желательно тоже активировать PIM.
```
R2(config)#interface Loopback 0
RX(config-if)#ip pim sparse-mode
```
Сразу после этого R4 узнает об источнике трафика для группы 224.2.2.4:
и даже передаёт трафик:
На интерфейс FE0/1 приходит 362000 б/с, и через интерфейс FE0/0 они передаются.
Всё, что мы сделали:
Включили возможность маршрутизации мультикастового трафика (**ip multicast-routing**)
Активировали PIM на интерфейсах (**ip pim sparse-mode**)
Указали адрес RP (**ip pim rp-adress *X.X.X.X***)
Всё, это уже рабочая конфигурация и можно приступать к разбору, ведь за кулисами скрывается гораздо больше, чем видно на сцене.
[Полная конфигурация с PIM.](https://docs.google.com/document/d/1Dwi4wO6B_VGhxapE4dqfBacT4_N3tNRU-Q9JFoiaEj0/pub)
---
### Разбор полётов
Ну так и как же в итоге всё работает? Как RP узнаёт где источник, где клиенты и обеспечивает связь между ними?
Поскольку всё затевается ради наших любимых клиентов, то, начав с них, рассмотрим в деталях весь процесс.
**1)** Клиент 1 отправляет IGMP Report для группы 224.2.2.4
**2)** R4 получает этот запрос, понимает, что есть клиент за интерфейсом FE0/0, добавляет этот интерфейс в OIL и формирует запись (\*, G).
> Здесь видно восходящий интерфейс FE0/1, но это не значит, что R4 получает трафик для группы 224.2.2.4. Это говорит лишь о том, что единственное место, откуда сейчас он может получать — FE0/1, потому что именно там находится RP. Кстати, здесь же указан и сосед, который прошёл **RPF-Check** — R2: 10.0.2.24. Ожидаемо.
>
>
R4 называется — LHR (Last Hop Router) — последний маршрутизатор на пути мультикастового трафика, если считать от источника. Иными словами — это маршрутизатор, ближайший к получателю. Для *Клиента1* — это R4, для *Клиента2* — это R5.
**3)** Поскольку на R4 пока нет мультикастового потока (он его не запрашивал прежде), он формирует сообщение PIM Join и отправляет его в сторону RP (2.2.2.2).
PIM Join отправляется мультикастом на адрес 224.0.0.13. «В сторону RP» означает через интерфейс, который указан в таблице маршрутизации, как outbound для того адреса, который указан внутри пакета. В нашем случае это 2.2.2.2 — адрес RP. Такой Join обозначается ещё как **Join (\*,G)** и говорит: «Не важно, кто источник, мне нужен трафик группы 224.2.2.4».
То есть каждый маршрутизатор на пути должен обработать такой Join и при необходимости отправить новый Join в сторону RP. (Важно понимать, что если на маршрутизаторе уже есть эта группа, он не будет отправлять выше Join — он просто добавит интерфейс, с которого пришёл Join, в OIL и начнёт передавать трафик).
В нашем случае Join ушёл в FE0/1:
**4)** R2, получив Join, формирует запись (\*, G) и добавляет интерфейс FE0/0 в OIL. Но Join отсылать уже некуда — он сам уже RP, а про источник пока ничего не известно.
Таким образом RP узнаёт о том, где находятся клиенты.
Если *Клиент 2* тоже захочет получать мультикастовый трафик для той же группы, R5 отправит PIM Join в FE0/1, потому что за ним находится RP, R3, получив его, формирует новый PIM Join и отправляет в FE1/1 — туда, где находится RP.
То есть Join путешествует так узел за узлом, пока не доберётся до RP или до другого маршрутизатора, где уже есть клиенты этой группы.
Итак, R2 — наш RP — сейчас знает о том, что за FE0/0 и FE1/0 у него есть получатели для группы 224.2.2.4.
Причём неважно, сколько их там — по одному за каждым интерфейсом или по сто — поток трафика всё равно будет один на интерфейс.
Если изобразить графически то, что мы получили, то это будет выглядеть так:
Отдалённо напоминает дерево, не так ли? Поэтому оно так и называется — **RPT — Rendezvous Point Tree**. Это дерево с корнем в RP, а ветви которого простираются до клиентов.
Более общий термин, как мы упоминали выше, — **MDT — Multicast Distribution Tree** — дерево, вдоль которого распространяется мультикастовый поток. Позже вы увидите разницу между MDT и RPT.
**5)** Теперь врубаем сервер. Как мы уже выше обсуждали, он не волнуется о PIM, RP, IGMP — он просто вещает. А R1 получает этот поток. Его задача — доставить мультикаст до RP.
В PIM есть специальный тип сообщений — **Register**. Он нужен для того, чтобы зарегистрировать источник мультикаста на RP.
Итак, R1 получает мультикастовый поток группы 224.2.2.4:
R1 является **FHR (First Hop Router)** — первый маршрутизатор на пути мультикастового трафика или ближайший к источнику.
**6)** Далее он инкапсулирует каждый полученный от источника мультикастовый пакет в юникастовый PIM Register и отправляет его прямиком на RP.
Обратите внимание на стек протоколов. Поверх юникастового IP и заголовка PIM идёт изначальный мультикастовый IP, UDP и данные.
Теперь, в отличие от всех других, пока известных нам сообщений PIM, в адресе получателя указан 2.2.2.2, а не мультикастовый адрес.
Такой пакет доставляется до RP по стандартным правилам юникастовой маршрутизации и несёт в себе изначальный мультикастовый пакет, то есть это… это же туннелирование!
> =====================
>
> [**Задача № 1**](http://linkmeup.ru/blog/130.html)
>
>
>
> [Схема и начальная конфигурация](https://docs.google.com/document/d/1Dwi4wO6B_VGhxapE4dqfBacT4_N3tNRU-Q9JFoiaEj0/pub).
>
>
>
> 
>
>
>
> На сервере 172.16.0.5 работает приложение, которое может передавать пакеты только на широковещательный адрес 255.255.255.255, с портом получателя UDP 10999.
>
>
>
> Этот трафик надо доставить к клиентам 1 и 2:
>
> Клиенту 1 в виде мультикаст трафика с адресом группы 239.9.9.9.
>
> А в сегмент клиента 2, в виде широковещательных пакетов на адрес 255.255.255.255.
>
>
>
> Подробности задачи [тут](http://linkmeup.ru/blog/130.html).
>
> =====================
>
>
**7)** RP получает PIM Register, распаковывает его и обнаруживает под обёрткой трафик для группы 224.2.2.4.
Информацию об этом он сразу заносит в свою таблицу мультикастовой маршрутизации:
Появилась запись (S, G) — (172.16.0.5, 224.2.2.4).
Распакованные пакеты RP дальше отправляет в RPT в интерфейсы FE0/0 и FE1/0, по которому трафик доходит до клиентов.
В принципе, на этом можно было бы и остановиться. Всё работает — клиенты получают трафик. Но есть две проблемы:
1. Процессы инкапсуляции и декапсуляции — весьма затратные действия для маршрутизаторов. Кроме того, дополнительные заголовки увеличивают размер пакета, и он может просто не пролезть в MTU где-то на промежуточном узле (вспоминаем все проблемы [туннелирования](http://www.opennet.ru/base/cisco/gre_fragment.txt.html)).
2. Если вдруг где-то между источником и RP есть ещё получатели для группы, мультикастовому трафику придётся пройти один путь дважды.
Возьмём для примера вот такую топологию:
Трафик в сообщениях Register сначала дойдёт до RP по линии R1-R42-R2, затем чистый мультикаст вернётся по линии R2-R42. Таким образом на линии R42-R2 будет ходить две копии одного трафика, пусть и в противоположных направлениях.
Поэтому лучше от источника до RP тоже передавать чистый мультикаст, а для этого нужно построить дерево — **Source Tree**.
**8)** Поэтому RP отправляет на R1 сообщение PIM Join. Но теперь уже в нём указывается для группы адрес не RP, а источника, изученный из сообщения Register. Такое сообщение называется **Join (S, G) — Source Specific Join**.
Цель у него точно такая же, как у PIM Join (\*, G) — построить дерево, только на этот раз от источника до RP.
Join (S, G) распространяется также узел за узлом, как обычный Join (\*, G). Только Join (\*, G) стремится к RP, а Join (S, G) к S — источнику. В качестве адрес получателя также служебный адрес 224.0.0.13 и TTL=1.
> Если существуют промежуточные узлы, например, R42, они также формируют запись (S, G) и список нисходящих интерфейсов для данной группы и пересылают Join дальше к источнику.
Путь, по которому прошёл Join от RP до источника, превращается в **Source Tree** — дерево от источника. Но более распространённое название — **SPT — Shortest Path Tree** — ведь трафик от источника до RP пойдёт по кратчайшему пути.
**9)** R1 получив Join (S, G), добавляет интерфейс FE1/0, откуда пакет пришёл, в список нисходящих интерфейсов OIL и начинает туда вещать чистый мультикастовый трафик, незамутнённый инкапсуляцией. Запись (S, G) на R1 уже была, как только он получит первый мультикастовый пакет от Сервера-источник.
По построенному Source Tree мультикаст передаётся RP (и всем промежуточным клиентам, если они есть, например, R42).
Но надо иметь ввиду, что сообщения Register передавались всё это время и передаются до сих пор. То есть фактически R1 отправляет две копии трафика сейчас: один — чистый мультикаст по SPT, другой — инкапсулированный в юникастовый Register.
> Сначала R1 отправляет мультикаст в Register — **пакет 231**. Потом R2 (RP) хочет подключиться к дереву, отправляет Join — **пакет 232**. R1 ещё какое-то время, пока обрабатывает запрос от R2, отправляет мультикаст в Register (**пакеты с 233 по 238**). Далее, когда нисходящий интерфейс добавлен в OIL на R1, он начинает передавать чистый мультикаст — **пакеты 239 и 242**, но пока не прекращает и Register — **пакеты 241 и 243**. А **пакет 240** — это R2 не выдержал и ещё раз попросил построить дерево.
**10)** Итак, незамутнённый мультикаст достигает RP. Она понимает, что это тот же самый трафик, который приходит в Register, потому что одинаковый адрес группы, одинаковый адрес источника и с одного интерфейса. Чтобы не получать две копии, он отправляет на R1 юникастовый **PIM Register-Stop**.
Register-Stop не означает, что R2 отказывается от трафика или не признаёт больше этот источник, это говорит лишь о том, что надо прекратить посылать **инкапсулированный** трафик.
Далее идёт ожесточённая борьба — R1 продолжает передавать накопившийся в буфере трафик, пока обрабатывает Register-Stop, и обычным мультикастом и внутри сообщений Register:
Но, рано или поздно R1 начинает вещать только чистый мультикастовый трафик.
> При подготовке у меня возник, как мне казалось, закономерный вопрос: ну и к чему все эти туннелирования, PIM Register? Почему бы не поступать с мультикастовым трафиком, как с PIM Join — отправлять хоп за хопом с TTL=1 в сторону RP — рано или поздно ведь дойдёт? Так бы и дерево построилось бы заодно без лишних телодвижений.
>
> Тут возникает несколько нюансов.
>
> Во-первых, нарушается главный принцип PIM SM — трафик посылать только туда, откуда он был запрошен. **Нет Join — Нет дерева**!
>
> Во-вторых, если клиентов для данной группы нет, FHR не узнает об этом и будет продолжать слать трафик по «своему дереву». К чему такое бездумное использование полосы пропускания? В мире связи такой протокол просто не выжил бы, как не выжил PIM DM или DVMRP.
Таким образом мы имеем одно большое дерево MDT для группы 224.2.2.4 от *Cервера-источника* до *Клиента 1* и *Клиента 2*. И это MDT составлено из двух кусков, которые строились независимо друг от друга: **Source Tree** от источника до RP и **RPT** от RP до клиентов. Вот оно отличие MDT от RPT и SPT. MDT — это довольно общий термин, означающий дерево передачи мультикаста вообще, в то время, как RPT/SPT — это его очень конкретный вид.
А что делать, если сервер уже вещает, а клиентов всё нет и нет? Мультикаст так и будет засорять участок между отправителем и RP?
Нет, в этом случае также поможет PIM Register-Stop. Если на RP начали приходить сообщения Register для какой-то группы, а для неё ещё нет получателей, то RP не заинтересован в получении этого трафика, поэтому, **не отправляя** PIM Join (S, G), RP сразу посылает Register-Stop на R1.
R1, получив Register-Stop и видя, что дерева для этой группы пока нет (нет клиентов), начинает отбрасывать мультикастовый трафик от сервера.
То есть сам сервер по этому поводу совершенно не беспокоится и продолжает посылать поток, но, дойдя до интерфейса маршрутизатора, поток будет отброшен.
При этом RP продолжает хранить запись (S, G). То есть трафик он не получает, но где находится источник для группы знает. Если в группе появляются получатели, RP узнаёт о них и посылает на источник Join (S, G), который строит дерево.
Кроме того, каждые 3 минуты R1 будет пытаться повторно зарегистрировать источник на RP, то есть отправлять пакеты Register. Это нужно для того, чтобы уведомить RP о том, что этот источник ещё живой.
> У особо пытливых читателей обязан возникнуть вопрос — а как быть с RPF? Этот механизм ведь проверяет адрес отправителя мультикастового пакета и, если трафик идёт не с правильного интерфейса, он будет отброшен. При этом RP и источник могут находиться за разными интерфейсам. Вот и в нашем примере для R3 RP — за FE1/1, а источник — за FE1/0.
>
> Ответ предсказуем — в таком случае проверяется не адрес источника, а RP. То есть трафик должен придти с интерфейса в сторону RP.
>
> Но, как вы увидите далее, это тоже не нерушимое правило.
Важно понимать, что RP — это не универсальный магнит — для каждой группы может бытья своя RP. То есть в сети их может быть и две, и три, и сто — одна RP отвечает за один набор групп, другая — за другой. Более того, есть такое понятие, как [**Anycast RP**](http://lookmeup.linkmeup.ru/#term314) и тогда разные RP могут обслуживать одну и ту же группу.
> =====================
>
> [**Задача № 2**](http://linkmeup.ru/blog/131.html)
>
>
>
> [Схема и начальная конфигурация](https://docs.google.com/document/d/1Dwi4wO6B_VGhxapE4dqfBacT4_N3tNRU-Q9JFoiaEj0/pub).
>
>
>
> 
>
>
>
> **Замечание к топологии**: в этой задаче только маршрутизаторы R1, R2, R3 находятся под управлением администраторов нашей сети. То есть, конфигурацию изменять можно только на них.
>
>
>
> Сервер 172.16.0.5 передает мультикаст трафик на группы 239.1.1.1 и 239.2.2.2.
>
>
>
> Настроить сеть таким образом, чтобы трафик группы 239.1.1.1 не передавался в сегмент между R3 и R5, и во все сегменты ниже R5.
>
> Но при этом, трафик группы 239.2.2.2 должен передаваться без проблем.
>
>
>
> Подробности задачи [тут](http://linkmeup.ru/blog/131.html).
>
> =====================
>
>
---
### Бритва Оккама или отключение ненужных ветвей
После того, как последний клиент в сегменте отказался от подписки, PIM должен отрезать лишнюю ветку RPT.
Пусть, например, единственный клиент на R4 выключил компьютер. Маршрутизатор по сообщению IGMP Leave или после трёх безответных IGMP Query понимает, что клиентов за FE0/0 больше нет, и отправляет в сторону RP сообщение **PIM Prune**. По формату оно точно такое же, как Join, но выполняет противоположную функцию.
Адрес назначения также 224.0.0.13, и TTL равен 1.
Но маршрутизатор, получивший PIM Prune, перед тем, как удалить подписку, ждёт некоторое время (обычно 3 секунды — Join Delay Timer).
Это сделано вот для такой ситуации:
В одном широковещательном домене 3 маршрутизатора. Один из них стоит выше и именно он передаёт в сегмент мультикастовый трафик. Это R1. Для обоих маршрутизаторов (R2 и R3) его OIL содержит только одну запись.
Если теперь R2 решит отключиться и отправит PIM Prune, то он может подставить своего коллегу R3 — R1 ведь перестанет вещать в интерфейс вообще.
Так вот, чтобы этого не произошло, R1 и даёт таймаут в 3 секунды. За это время R3 должен успеть среагировать. Учитывая широковещательность сети, он тоже получит Prune от R2 и поэтому, если хочет продолжать получать трафик, он мгновенно отправляет обычный PIM Join в сегмент, уведомляя R1, что не надо удалять интерфейс.
Этот процесс называется — Prune Override. R2 как бы объегорил R1, перехватил инициативу.
---
### SPT Switchover — переключение RPT-SPT
До сих пор мы преимущественно рассматривали только *Клиента 1*. Теперь обратимся к *Клиенту 2*.
По началу всё для него идентично *Клиенту 1* — он пользуется RPT от RP, который мы рассматривали ранее. Кстати, поскольку оба — и *Клиент 1* и *Клиент 2* — используют одно дерево, такое дерево называется **Shared Tree** — это довольно общее название. Shared tree = RPT.
Вот как выглядит таблица мультикастовой маршрутизации на R5 в самом начале, сразу после построения дерева:
Здесь нет записи (S, G), но это не значит, что мультикастовый трафик не передаётся. Просто R5 не заботится о том, кто отправитель.
Обратите внимание по какому пути должен идти в этом случае трафик — R1-R2-R3-R5. Хотя ведь короче путь R1-R3-R5.
А если сеть посложнее?
Как-то неаккуратненько.
Дело в том, что пока мы привязаны к RP — она корень RPT, только она поначалу знает, где кто находится. Однако если вдуматься, то после первого же мультикастового пакета все маршрутизаторы по пути трафика будут знать адрес источника, ведь он указан в заголовке IP.
Почему бы кому-нибудь не отправить самому Join в сторону источника и оптимизировать маршрут?
Зрите в корень. Такое переключение может инициировать **LHR (Last Hop Router)** — R5. После получения первого мультикастового пакета от R3 R5 отправляет уже знакомый нам Source Specific Join (S, G) в интерфейс FE0/1, который указан в его таблице маршрутизации, как исходящий для сети 172.16.0.0/24.
Получив такой Join, R3 отправляет его не на RP, как делал это с обычным Join (\*, G), а в сторону источника (через интерфейс согласно таблице маршрутизации).
То есть в данном случае R3 отправляет Join (172.16.0.5, 224.2.2.4) в интерфейс FE1/0.
Далее этот Join попадает на R1. А R1 по большому счёту без разницы, кто его отправлял — RP или кто-то другой — он просто добавляет FE1/1 в свой OIL для группы 224.2.2.4.
В этот момент между источником и получателем два пути и R3 получает два потока.
Время сделать выбор, чтобы обрезать лишнее. Причём именно R3 его делает, потому что R5 уже не сможет различить эти два потока — они оба придут через один интерфейс.
Как только R3 зафиксировал два одинаковых потока с разных интерфейсов, он выбирает предпочтительный согласно таблице маршрутизации. В данном случае прямой, лучше, чем через RP. В этот момент R3 посылает Prune (S, G) в сторону RP, обрубая эту ветку RPT. И с этого момент остаётся только один поток напрямую от источника.
Таким образом PIM построил SPT — Shortest Path Tree. Оно же Source Tree. Это кратчайший путь от клиента до источника. Кстати, дерево от источника до RP, которое мы уже рассматривали выше, — по сути ровно то же самое SPT.
Оно характеризуется записью (S, G). Если маршрутизатор имеет такую запись, значит он знает, что S является источником для группы G и построено дерево SPT.
> Корнем дерева SPT является источник и очень хочется сказать «кратчайший путь от **источника до клиента**». Но это технически некорректно, поскольку пути от источника до клиента и от клиента до источника могут быть разными. А именно от клиента начинает строиться ветка дерева: маршрутизатор отправляет PIM Join в сторону источника/RP и RPF также проверяет правильность интерфейса при **получении** трафика.
*Вы помните, что вначале этого параграфа на R5 была только запись (\*, G), теперь после всех этих событий их станет две: (\*, G) и (S, G)*.
---
Между прочим, даже если вы посмотрите на мультикастовую таблицу маршрутизации R3 в ту же секунду, как нажали Play в VLC, то увидите, что он уже получает трафик от R1 напрямую, о чём говорит наличие записи (S, G).
То есть SPT Switchover уже произошёл — это действие по умолчанию на оборудовании многих производителей — инициировать переключение после получения первого же мультикастового пакета.
Вообще говоря, происходить такое переключение может в нескольких случаях:
* Не происходить вообще никогда (команда **ip pim spt-threshold infinity**).
* При достижении определённой утилизации полосы пропускания (команда **ip pim spt-threshold X**).
* Безусловно — сразу после получения первого пакета (действие по умолчанию или **no ip pim spt-threshold X**)
Как правило, решение о том, что «пора», принимает LHR.
> В этом случае во второй раз изменяется правило работы RPF — он снова проверяет местонахождение источника. То есть из двух потоков мультикаста — от RP и от источника — предпочтение отдаётся трафику от источника.
---
DR, Assert, Forwarder
---------------------
Ещё несколько важных моментов при рассмотрении PIM.
**DR — Designated Router**.
Это выделенный маршрутизатор, который ответственен за отправку служебных пакетов на RP.
**Source DR** — отвечает за принятие мультикастовых пакетов непосредственно от источника и его регистрацию на RP.
Вот пример топологии:
Здесь ни к чему, чтобы оба маршрутизатора передавали трафик на RP, пусть они резервируют друг друга, но ответственный должен быть только один.
Поскольку оба маршрутизатора подключены в одну широковещательную сеть, они получают друг от друга PIM-Hello. На основе него они и делают свой выбор.
PIM Hello несёт значение приоритета данного маршрутизатора на данном интерфейсе.
Чем больше значение, тем выше приоритет. Если они одинаковы, то выбирается узел с **наибольшим IP-адресом** (тоже из сообщения Hello).
Если другой маршрутизатор (не DR) в течение Holdtime (по умолчанию 105 с) не получал Hello от соседа, он автоматически берёт на себя роль DR.
По сути Source DR — это [**FHR — First Hop Router**](http://lookmeup.linkmeup.ru/#term322).
**Receiver DR** — то же, что Source DR, только для получателей мультикастового трафика — [**LHR (Last Hop Router)**](http://lookmeup.linkmeup.ru/#term323).
Пример топологии:
Receiver DR ответственен за отправку на RP PIM Join. В вышеприведённой топологии, если оба маршрутизатора отправят Join, то оба будут получать мультикастовый трафик, но в этом нет необходимости. Только DR отправляет Join. Второй просто мониторит доступность DR.
Поскольку DR отправляет Join, то он же и будет вещать трафик в LAN. Но тут возникает закономерный вопрос — а что, если PIM DR'ом стал один, а IGMP Querier'ом другой? А ситуация-то вполне возможна, ведь для Querier чем меньше IP, тем лучше, а для DR, наоборот.
В этом случае DR'ом выбирается тот маршрутизатор, который уже является Querier и такая проблема не возникает.
Правила выбора Receiver DR точно такие же, как и Source DR.
**Assert и PIM Forwarder**
Проблема двух одновременно передающих маршрутизаторов может возникнуть и в середине сети, где нет ни конечных клиентов, ни источников — только маршрутизаторы.
Очень остро этот вопрос стоял в PIM DM, где это была совершенно рядовая ситуация из-за механизма Flood and Prune.
Но и в PIM SM она не исключена.
Рассмотрим такую сеть:
Здесь три маршрутизатора находятся в одном сегменте сети и, соответственно, являются соседями по PIM. R1 выступает в роли RP.
R4 отправляет PIM Join в сторону RP. Поскольку этот пакет мультикастовый он попадает и на R2 и на R3, и оба они обработав его, добавляют нисходящий интерфейс в OIL.
Тут бы должен сработать механизм выбора DR, но и на R2 и на R3 есть другие клиенты этой группы, и обоим маршрутизаторам так или иначе придётся отправлять PIM Join.
Когда мультикастовый трафик приходит от источника на R2 и R3, в сегмент он передаётся обоими маршрутизаторами и задваивается там. PIM не пытается предотвратить такую ситуацию — тут он действует по факту свершившегося преступления — как только в свой нисходящий интерфейс для определённой группы (из списка OIL) маршрутизатор получает мультикастовый трафик этой самой группы, он понимает: что-то не так — другой отправитель уже есть в этом сегменте.
Тогда маршрутизатор отправляет специальное сообщение **PIM Assert**.
Такое сообщение помогает выбрать **PIM Forwarder** — тот маршрутизатор, который вправе вещать в данном сегменте.
Не надо его путать с PIM DR. Во-первых, PIM DR отвечает за отправку **сообщений PIM Join и Prune**, а PIM Forwarder — за отправку **трафика**. Второе отличие — PIM DR выбирается всегда и в любых сетях при установлении соседства, А PIM Forwrder только при необходимости — когда получен мультикастовый трафик с интерфейса из списка OIL.
---
Выбор RP
--------
Выше мы для простоты задавали RP вручную командой **ip pim rp-address *X.X.X.X***.
И вот как выглядела команда **show ip pim rp**:
Но представим совершенно невозможную в современных сетях ситуацию — R2 вышел из строя. Это всё — финиш. *Клиент 2* ещё будет работать, поскольку произошёл SPT Switchover, а вот всё новое и всё, что шло через RP сломается, даже если есть альтернативный путь.
Ну и нагрузка на администратора домена. Представьте себе: на 50 маршрутизаторах перебить вручную как минимум одну команду (а для разных групп ведь могут быть разные RP).
Динамический выбор RP позволяет и избежать ручной работы и обеспечить надёжность — если одна RP станет недоступна, в бой вступит сразу же другая.
В данный момент существует один общепризнанный протокол, позволяющий это сделать — **Bootstrap**. Циска в прежние времена продвигала несколько неуклюжий [Auto-RP](http://lookmeup.linkmeup.ru/#term306), но сейчас он почти не используется, хотя циска этого не признаёт, и в **show ip mroute** мы имеем раздражающий рудимент в виде группы 224.0.1.40.
> Надо на самом деле отдать должное протоколу Auto-RP. Он был спасением в прежние времена. Но с появлением открытого и гибкого Bootstrap, он закономерно уступил свои позиции.
Итак, предположим, что в нашей сети мы хотим, чтобы R3 подхватывал функции RP в случае выхода из строя R2.
R2 и R3 определяются как кандидаты на роль RP — так они и называются **C-RP**. На этих маршрутизаторах настраиваем:
```
RX(config)interface Loopback 0
RX(config-if)ip pim sparse-mode
RX(config-if)exit
RX(config)#ip pim rp-candidate loopback 0
```
Но пока ничего не происходит — кандидаты пока не знают, как уведомить всех о себе.
Чтобы информировать все мультикастовые маршрутизаторы домена о существующих RP вводится механизм **BSR — BootStrap Router**. Претендентов может быть несколько, как и C-RP. Они называются соответственно **C-BSR**. Настраиваются они похожим образом.
Пусть BSR у нас будет один и для теста (исключительно) это будет R1.
```
R1(config)interface Loopback 0
R1(config-if)ip pim sparse-mode
R1(config-if)exit
R1(config)#ip pim bsr-candidate loopback 0
```
Сначала из всех C-BSR выбирается один главный BSR, который и будет всем заправлять. Для этого каждый C-BSR отправляет в сеть мультикастовый **BootStrap Message (BSM)** на адрес 224.0.0.13 — это тоже пакет протокола PIM. Его должны принять и обработать все мультикастовые маршрутизаторы и после разослать во все порты, где активирован PIM. BSM передаётся не в сторону чего-то (RP или источника), в отличии, от PIM Join, а во все стороны. Такая веерная рассылка помогает достигнуть BSM всех уголков сети, в том числе всех C-BSR и всех C-RP. Для того, чтобы BSM не блуждали по сети бесконечно, применяется всё тот же механизм RPF — если BSM пришёл не с того интерфейса, за которым находится сеть отправителя этого сообщения, такое сообщение отбрасывается.
С помощью этих BSM все мультикастовые маршрутизаторы определяют самого достойного кандидата на основе приоритетов. Как только C-BSR получает BSM от другого маршрутизатора с бОльшим приоритетом, он прекращает рассылать свои сообщения. В результате все обладают одинаковой информацией.
На этом этапе, когда выбран BSR, благодаря тому, что его BSM разошлись уже по всей сети, C-RP знают его адрес и юникастом отправляют на него сообщения **Candidte-RP-Advertisement**, в которых они несут список групп, которые они обслуживают — это называется **group-to-RP mapping**. BSR все эти сообщения агрегирует и создаёт **RP-Set** — информационную таблицу: какие RP каждую группу обслуживают.
Далее BSR в прежней веерной манере рассылает те же BootStrap Message, которые на этот раз содержат RP-Set. Эти сообщения успешно достигают всех мультикастовых маршрутизаторов, каждый из которых **самостоятельно** делает выбор, какую RP нужно использовать для каждой конкретной группы.
BSR периодически делает такие рассылки, чтобы с одной стороны все знали, что информация по RP ещё актуальна, а с другой C-BSR были в курсе, что сам главный BSR ещё жив.
RP, кстати, тоже периодически шлют на BSR свои анонсы Candidate-RP-Advertisement.
Фактически всё, что нужно сделать для настройки автоматического выбора RP — указать C-RP и указать C-BSR — не так уж много работы, всё остальное за вас сделает PIM.
Как всегда, в целях повышения надёжности рекомендуется указывать интерфейсы Loopback в качестве кандидатов.
---
#### Завершая главу PIM SM, давайте ещё раз отметим важнейшие моменты
1. Должна быть обеспечена обычная юникастовая связность с помощью IGP или статических маршрутов. Это лежит в основе алгоритма RPF.
2. Дерево строится только после появления клиента. Именно клиент инициирует построение дерева. Нет клиента — нет дерева.
3. RPF помогает избежать петель.
4. Все маршрутизаторы должны знать о том, кто является RP — только с её помощью можно построить дерево.
5. Точка RP может быть указана статически, а может выбираться автоматически с помощью протокола BootStrap.
6. В первой фазе строится RPT — дерево от клиентов до RP — и Source Tree — дерево от источника до RP. Во второй фазе происходит переключение с построенного RPT на SPT — кратчайший путь от получателя до источника.
Ещё перечислим все типы деревьев и сообщений, которые нам теперь известны.
**MDT — Multicast Distribution Tree**. Общий термин, описывающий любое дерево передачи мультикаста.
**SPT — Shortest Path Tree**. Дерево с кратчайшим путём от клиента или RP до источника. В PIM DM есть только SPT. В PIM SM SPT может быть от источника до RP или от источника до получателя после того, как произошёл SPT Switchover. Обозначается записью **(S, G)** — известен источник для группы.
**Source Tree** — то же самое, что SPT.
**RPT — Rendezvous Point Tree**. Дерево от RP до получателей. Используется только в PIM SM. Обозначается записью **(\*, G)**.
**Shared Tree** — то же, что RPT. Называется так потому, что все клиенты подключены к одному общему дереву с корнем в RP.
Типы сообщений PIM Sparse Mode:
**Hello** — для установления соседства и поддержания этих отношений. Также необходимы для выбора DR.
**Join (\*, G)** — запрос на подключение к дереву группы G. Не важно кто источник. Отправляется в сторону RP. С их помощью строится дерево RPT.
**Join (S, G)** — Source Specific Join. Это запрос на подключение к дереву группы G с определённым источником — S. Отправляется в сторону источника — S. С их помощью строится дерево SPT.
**Prune (\*, G)** — запрос на отключение от дерева группы G, какие бы источники для неё не были. Отправляется в сторону RP. Так обрезается ветвь RPT.
**Prune (S, G)** — запрос на отключение от дерева группы G, корнем которого является источник S. Отправляется в сторону источника. Так обрезается ветвь SPT.
**Register** — специальное сообщение, внутри которого передаётся мультикаст на RP, пока не будет построено SPT от источника до RP. Передаётся юникастом от FHR на RP.
**Register-Stop** — отправляется юникастом с RP на FHR, приказывая прекратить посылать мультикастовый трафик, инкапсулированный в Register.
**Bootstrap** — пакеты механизма BSR, которые позволяют выбрать маршрутизатор на роль BSR, а также передают информацию о существующих RP и группах.
**Assert** — сообщение для выбора PIM Forwarder, чтобы в один сегмент не передавали трафик два маршрутизатора.
**Candidate-RP-Advertisement** — сообщение, в котором RP отсылает на BSR информацию о том, какие группы он обслуживает.
**RP-Reachable** — сообщение от RP, которым она уведомляет всех о своей доступности.
*\*Есть и другие типы сообщений в PIM, но это уже детали\**
---
А давайте теперь попытаемся абстрагироваться от деталей протокола? И тогда становится очевидной его сложность.
1) Определение RP,
2) Регистрация источника на RP,
3) Переключение на дерево SPT.
Много состояний протокола, много записей в таблице мультикастовой маршрутизации. Можно ли что-то с этим сделать?
На сегодняшний день существует два диаметрально противоположных подхода к упрощению PIM: SSM и BIDIR PIM.
SSM
---
Всё, что мы описывали до сих пор — это **ASM — Any Source Multicast**. Клиентам безразлично, кто является источником трафика для группы — главное, что они его получают. Как вы помните в сообщении IGMPv2 Report запрашивается просто подключение к группе.
**SSM — Source Specific Multicast** — альтернативный подход. В этом случае клиенты при подключении указывают группу и источник.
Что же это даёт? Ни много ни мало: возможность полностью избавиться от RP. LHR сразу знает адрес источника — нет необходимости слать Join на RP, маршрутизатор может сразу же отправить Join (S, G) в направлении источника и построить SPT.
Таким образом мы избавляемся от
* Поиска RP (протоколы Bootstrap и Auto-RP),
* Регистрации источника на мультикасте (а это лишнее время, двойное использование полосы пропускания и туннелирование)
* Переключения на SPT.
Поскольку нет RP, то нет и RPT, соответственно ни на одном маршрутизаторе уже не будет записей (\*, G) — только (S, G).
Ещё одна проблема, которая решается с помощью SSM — наличие нескольких источников. В ASM рекомендуется, чтобы адрес мультикастовой группы был уникален и только один источник вещал на него, поскольку в дереве RPT несколько потоков сольются, а клиент, получая два потока от разных источников, вероятно, не сможет их разобрать.
В SSM трафик от различных источников распространяется независимо, каждый по своему дереву SPT, и это уже становится не проблемой, а преимуществом — несколько серверов могут вещать одновременно. Если вдруг клиент начал фиксировать потери от основного источника, он может переключиться на резервный, даже не перезапрашивая его — он и так получал два потока.
Кроме того, возможный вектор атаки в сети с активированной мультикастовой маршрутизацией — подключение злоумышленником своего источника и генерирование большого объёма мультикастового трафика, который перегрузит сеть. В SSM такое практически исключено.
Для SSM выделен специальный диапазон IP-адресов: 232.0.0.0/8.
На маршрутизаторах для поддержки SSM включается режим PIM SSM.
```
Router(config)# ip pim ssm
```
IGMPv3 и MLDv2 поддерживают SSM в чистом виде.
При их использовании клиент может
* Запрашивать подключение к просто группе, без указания источников. То есть работает как типичный ASM.
* Запрашивать подключение к группе с определённым источником. Источников можно указать несколько — до каждого из них будет построено дерево.
* Запрашивать подключение к группе и указать список источников, от которых клиент **не хотел** бы получать трафик
IGMPv1/v2, MLDv1 не поддерживают SSM, но имеет место такое понятие, как **SSM Mapping**. На ближайшем к клиенту маршрутизаторе (LHR) каждой группе ставится в соответствие адрес источника (или несколько). Поэтому если в сети есть клиенты, не поддерживающие IGMPv3/MLDv2, для них также будет построено SPT, а не RPT, благодаря тому, что адрес источника всё равно известен.
SSM Mapping может быть реализован как статической настройкой на LHR, так и посредством обращения к DNS-серверу.
Проблема SSM в том, что клиенты должны заранее знать адреса источников — никакой сигнализацией они им не сообщаются.
Поэтому SSM хорош в тех ситуациях, когда в сети определённый набор источников, их адреса заведомо известны и не будут меняться. А клиентские терминалы или приложения жёстко привязаны к ним.
Иными словами IPTV — весьма пригодная среда для внедрения SSM. Это хорошо описывает концепцию **One-to-Many** — один источник, много получателей.
---
BIDIR PIM
---------
А что если в сети источники могут появляться спонтанно то там, то тут, вещать на одинаковые группы, быстро прекращать передачу и исчезать?
Например, такая ситуация возможна в сетевых играх или в ЦОД, где происходит репликация данных между различными серверами. Это концепция **Many-to-Many** — много источников, много клиентов.
Как на это смотрит обычный PIM SM? *Понятное дело, что инертный PIM SSM здесь совсем не подходит?*
Вы только подумайте, какой хаос начнётся: бесконечные регистрации источников, перестроение деревьев, огромное количество записей (S, G) живущих по несколько минут из-за таймеров протокола.
На выручку идёт двунаправленный PIM (**Bidirectional PIM, BIDIR PIM**). В отличие от SSM в нём напротив полностью отказываются от SPT и записей (S,G) — остаются только Shared Tree с корнем в RP.
И если в обычном PIM, дерево является односторонним — трафик всегда передаётся от источника вниз по SPT и от RP вниз по RPT — есть чёткое деление, где источник, где клиенты, то в двунаправленном от источника трафик к RP передаётся также вверх по Shared Tree — по тому же самому, по которому трафик течёт вниз к клиентам.
Это позволяет отказаться от регистрации источника на RP — трафик передаётся безусловно, без какой бы то ни было сигнализации и изменения состояний. Поскольку деревьев SPT нет вообще, то и SPT Switchover тоже не происходит.
Вот например:
*Источник1* начал передавать в сеть трафик группы 224.2.2.4 одновременно с *Источником2*. Потоки от них просто полились в сторону RP. Часть клиентов, которые находятся рядом начали получать трафик сразу, потому что на маршрутизаторах есть запись (\*, G) (есть клиенты). Другая часть получает трафик по Shared Tree от RP. Причём получают они трафик от обоих источников одновременно.
То есть, если взять для примера умозрительную сетевую игру, *Источник1* это первый игрок в стрелялке, который сделал выстрел, а *Источник2* — это другой игрок, который сделал шаг в сторону. Информация об этих двух событиях распространилась по всей сети. И **каждый** другой игрок (*Получатель*) должен узнать об обоих этих событиях.
> Если помните, то [чуть раньше](#PIM_Register) мы объяснили, зачем нужен процесс регистрации источника на RP — чтобы трафик не занимал канал, когда нет клиентов, то есть RP просто отказывался от него. Почему над этой проблемой мы не задумываемся сейчас? Причина проста: BIDIR PIM для ситуаций, когда источников много, но они вещают не постоянно, а периодически, относительно небольшими кусками данных. То есть канал от источника до RP не будет утилизироваться понапрасну.
Обратите внимание, что на изображении выше между R5 и R7 есть прямая линия, гораздо более короткая, чем путь через RP, но она не была использована, потому что Join идут в сторону RP согласно таблице маршрутизации, в которой данный путь не является оптимальным.
Выглядит довольно просто — нужно отправлять мультикастовые пакеты в направлении RP и всё, но есть один нюанс, который всё портит — RPF. В дереве RPT он требует, чтобы трафик приходил от RP и не иначе. А у нас он может приходить откуда угодно. Взять и отказаться от RPF мы, конечно, не можем — это единственный механизм, который позволяет избежать образования петель.
Поэтому в BIDIR PIM вводится понятие **DF — Designated Forwarder**. В каждом сегменте сети, на каждой линии на эту роль выбирается тот маршрутизатор, чей маршрут до RP лучше.
В том числе это делается и на тех линиях, куда непосредственно подключены клиенты. В BIDIR PIM DF автоматически является DR.
Список OIL формируется только из тех интерфейсов, на которых маршрутизатор был выбран на роль DF.
Правила довольно прозрачны:
* **Если запрос PIM Join/Leave приходит на тот интерфейс, который в данном сегменте является DF, он передаётся в сторону RP по стандартным правилам.**
Вот, например, R3. Если запросы пришли в DF интерфейсы, что помечены красным кругом, он их передаёт на RP (через R1 или R2, в зависимости от таблицы маршрутизации).
* **Если запрос PIM Join/Leave пришёл на не DF интерфейс, он будет проигнорирован.**
Допустим, что клиент, находящийся между R1 и R3, решил подключиться и отправил IGMP Report. R1 получает его через интерфейс, где он выбран DF (помечен красным кругом), и мы возвращаемся к предыдущему сценарию. А R3 получает запрос на интерфейс, который не является DF. R3 видит, что тут он не лучший, и игнорирует запрос.
* **Если мультикастовый трафик пришёл на DF интерфейс, он будет отправлен в интерфейсы из списка OIL и в сторону RP.**
Например, *Источник1* начал передавать трафик. R4 получает его в свой DF интерфейс и передаёт его и в другой DF-интерфейс — в сторону клиента и в сторону RP, — это важно, потому что трафик должен попасть на RP и распространиться по всем получателям. Также поступает и R3 — одна копия в интерфейсы из списка OIL — то есть на R5, где он будет отброшен из-за проверки RPF, и другая — в сторону RP.
* **Если мультикастовый трафик пришёл на не DF интерфейс, он должен быть отправлен в интерфейсы из списка OIL, но **не будет** отправлен в сторону RP.**
К примеру, *Источник2* начал вещать, трафик дошёл до RP и начал распространяться вниз по RPT. R3 получает трафик от R1, и он не передаст его на R2 — только вниз на R4 и на R5.
Таким образом DF гарантирует, что на RP в итоге будет отправлена только одна копия мультикастового пакета и образование петель исключено. При этом то общее дерево, в котором находится источник, естественно, получит этот трафик ещё до попадания на RP. RP, согласно обычным правилам разошлёт трафик во все порты OIL, кроме того, откуда пришёл трафик.
Кстати, нет нужды более и в сообщениях Assert, ведь DF выбирается в каждом сегменте. В отличие от DR он отвечает не только за отправку Join к RP, но и за передачу трафика в сегмент, то есть ситуация, когда два маршрутизатора передают в одну подсеть трафик, исключена в BIDIR PIM.
Пожалуй, последнее, что нужно сказать о двунаправленном PIM, это особенности работы RP. Если в PIM SM RP выполнял вполне конкретную функцию — регистрация источника, то в BIDIR PIM RP — это некая весьма условная точка, к которой стремится трафик с одной стороны и Join от клиентов с другой. Никто не должен выполнять декапсуляцию, запрашивать построение дерева SPT. Просто на каком-то маршрутизаторе вдруг трафик от источников начинает передаваться в Shared Tree. Почему я говорю «на каком-то»? Дело в том, что в BIDIR PIM RP — абстрактная точка, а не конкретный маршрутизатор, в качестве адреса RP вообще может выступать несуществующий IP-адрес — главное, чтобы он был маршрутизируемый (такая RP называется [Phantom RP](http://lookmeup.linkmeup.ru/#term346)).
Все термины, касающиеся PIM, можно найти в [глоссарии](http://lookmeup.linkmeup.ru/#term293).
---
Мультикаст на канальном уровне
==============================
Итак, позади долгая трудовая неделя с недосыпами, переработками, тестами — вы успешно внедрили мультикаст и удовлетворили клиентов, директора и отдел продаж.
Пятница — не самый плохой день, чтобы обозреть творение и позволить себе приятный отдых.
Но ваш послеобеденный сон вдруг потревожил звонок техподдержки, потом ещё один и ещё — ничего не работает, всё сломалось. Проверяете — идут потери, разрывы. Всё сходится на одном сегменте из нескольких коммутаторов.
Расчехлили SSH, проверили CPU, проверили утилизацию интерфейсов и волосы дыбом — загрузка почти под 100% на всех интерфейсах одного VLAN'а. Петля! Но откуда ей взяться, если никаких работ не проводилось? Минут 10 проверки и вы заметили, что на восходящем интерфейсе к ядру у вас много входящего трафика, а на всех нисходящих к клиентам — исходящего. Для петли это тоже характерно, но как-то подозрительно: внедрили мультикаст, никаких работ по переключению не делали и скачок только в одном направлении.
Проверили список мультикастовых групп на маршрутизаторе — а там подписка на все возможные каналы и все на один порт — естественно, тот, который ведёт в этот сегмент.
Дотошное расследование показало, что компьютер клиента заражён и рассылает IGMP Query на все мультикастовые адреса подряд.
Потери пакетов начались, потому что коммутаторам пришлось пропускать через себя огромный объём трафика. Это вызвало переполнение буферов интерфейсов.
Главный вопрос — почему трафик одного клиента начал копироваться во все порты?
Причина этого кроется в природе мультикастовых MAC-адресов. Дело в том, пространство мультикастовых IP-адресов специальным образом отображается в пространство мультикастовых MAC-адресов. И загвоздка в том, что они никогда не будут использоваться в качестве MAC-адреса источника, а следовательно, не будут изучены коммутатором и занесены в таблицу MAC-адресов. А как поступает коммутатор с кадрами, адрес назначения которых не изучен? Он их рассылает во все порты. Что и произошло.
Это действие по умолчанию.
Мультикастовые MAC-адреса
-------------------------
Так какие же MAC-адреса получателей подставляются в заголовок Ethernet таких пакетов? Широковещательные? Нет. Существует специальный диапазон MAC-адресов, в которые отображаются мультикастовые IP-адреса.
Эти специальные адреса начинаются так: **0x01005e и следующий 25-й бит должен быть 0** (*попробуйте ответить, почему так*). Остальные 23 бита (напомню, всего их в МАС-адресе 48) переносятся из IP-адреса.
Здесь кроется некоторая не очень серьёзная, но проблема. Диапазон мультикастовых адресов определяется маской 224.0.0.0/4, это означает, что первые 4 бита зарезервированы: 1110, а оставшиеся 28 бит могут меняться. То есть у нас 2^28 мультикастовых IP-адресов и только 2^23 MAC-адресов — для отображения 1 в 1 не хватает 5 бит. Поэтому берутся просто последние 23 бита IP-адреса и один в один переносятся в MAC-адрес, остальные 5 отбрасываются.
[](http://img-fotki.yandex.ru/get/9497/83739833.38/0_da344_9d589e31_XXL.png)
Фактически это означает, что в один мультикастовый MAC-адрес будет отображаться 2^5=32 IP-адреса. Например, группы 224.0.0.1, 224.128.0.1, 225.0.0.1 и так до 239.128.0.1 все будут отображаться в один MAC-адрес 0100:5e00:0001.
Если взять в пример дамп потокового видео, то можно увидеть:
IP адрес — 224.2.2.4, MAC-адрес: 01:00:5E:02:02:04.
Есть также другие мультикастовые MAC-адреса, которые никак не относятся к IPv4-мультикаст ([клик](https://en.wikipedia.org/wiki/Multicast_address#Ethernet)). Все они, кстати, характеризуются тем, что последний бит первого октета равен 1.
Естественно, ни на одной сетевой карте, не может быть настроен такой MAC-адрес, поэтому он никогда не будет в поле Source MAC Ethernet-кадра и никогда не попадёт в таблицу MAC-адресов. Значит такие кадры должны рассылаться как любой [Unknown Unicast](http://lookmeup.linkmeup.ru/#term430) во все порты VLAN'а.
Всего, что мы рассматривали прежде, вполне достаточно для полноценной передачи любого мультикастового трафика от потокового видео до биржевых котировок. Но неужели мы в своём почти совершенном мире будем мирится с таким безобразием, как широковещательная передача того, что можно было бы передать избранным?
Вовсе нет. *Специально для перфекционистов* придуман механизм **IGMP-Snooping**.
---
IGMP-Snooping
-------------
Идея очень простая — коммутатор «слушает» проходящие через него IGMP-пакеты.
Для каждой группы отдельно он ведёт таблицу восходящих и нисходящих портов.
Если с порта пришёл IGMP Report для группы, значит там клиент, коммутатор добавляет его в список нисходящих для этой группы.
Если с порта пришёл IGMP Query для группы, значит там маршрутизатор, коммутатор добавляет его в список восходящих.
Таким образом формируется таблица передачи мультикастового трафика на канальном уровне.
В итоге, когда сверху приходит мультикастовый поток, он копируется только в нисходящие интерфейсы. Если на 16-портовом коммутаторе только два клиента, только им и будет доставлен трафик.
Гениальность этой идеи заканчивается тогда, когда мы задумываемся о её природе. Механизм предполагает, что коммутатор должен прослушивать трафик на 3-м уровне.
Впрочем, IGMP-Snooping ни в какое сравнение не идёт с NAT по степени игнорирования принципов сетевого взаимодействия. Тем более, кроме экономии в ресурсах, он несёт в себе массу менее очевидных возможностей. Да и в общем-то в современном мире, коммутатор, который умеет заглядывать внутрь IP — явление не исключительное.
> =====================
>
> [**Задача № 3**](http://linkmeup.ru/blog/132.html)
>
>
>
> [Схема и начальная конфигурация](https://docs.google.com/document/d/1Dwi4wO6B_VGhxapE4dqfBacT4_N3tNRU-Q9JFoiaEj0/pub).
>
>
>
> 
>
>
>
> Сервер 172.16.0.5 передает мультикаст трафик на группы 239.1.1.1, 239.2.2.2 и 239.0.0.x.
>
> Настроить сеть таким образом, чтобы:
>
> — клиент 1 не мог присоединиться к группе 239.2.2.2. Но при этом мог присоединиться к группе 239.0.0.x.
>
> — клиент 2 не мог присоединиться к группе 239.1.1.1. Но при этом мог присоединиться к группе 239.0.0.x.
>
>
>
> Подробности задачи [тут](http://linkmeup.ru/blog/132.html).
>
> =====================
>
>
---
### IGMP Snooping Proxy
У пытливого читателя может возникнуть вопрос по тому, как IGMP Snooping узнаёт все клиентские порты, учитывая, что на IGMP Query отвечает только один самый быстрый клиент, как мы говорили выше. А очень просто: IGMP-Snooping не позволяет сообщениям Report ходить между клиентами. Они отправляются только в восходящие порты к маршрутизаторам. Не видя Report от других получателей этой группы, клиент обязан ответить на Query в течение Max Response Time, указанном в этом Query.
В итоге в сети на 1000 узлов на один IGMP Query в течение секунд 10 (обычное значение Max Response Time) придёт 1000 Report'ов маршрутизатору. Хотя ему достаточно было бы и одного для каждой группы.
И происходит это каждую минуту.
В этом случае можно настроить проксирование IGMP-запросов. Тогда коммутатор не просто «слушает» проходящие пакеты, он их перехватывает.
Правила работы IGMP-Snooping могут отличаться для разных производителей. Поэтому рассмотрим их концептуально:
1) Если на коммутатор приходит самый первый запрос Report на группу, он отправляется вверх к маршрутизатору, а интерфейс вносится в список нисходящих. Если же такая группа уже есть, интерфейс просто добавляется в список нисходящих, а Report уничтожается.
2) Если на коммутатор приходит самый последний Leave, то есть других клиентов нет, этот Leave будет отправлен на маршрутизатор, а интерфейс удаляется из списка нисходящих. В противном случае просто удаляется интерфейс, Leave уничтожается.
3) Если IGMP Query приходит от маршрутизатора, коммутатор перехватывает его, отправляет в ответ IGMP Report для всех групп, которые в данный момент имеют получателей.
А дальше, в зависимости от настроек и производителя, либо этот же самый Query рассылается во все клиентские порты, либо коммутатор блокирует запрос от маршрутизатора и сам выступает в роли Querier, периодически опрашивая всех получателей.
Таким образом снижается и доля лишнего служебного трафика в сети и нагрузка на маршрутизатор.
### Multicast VLAN Replication
Сокращённо **MVR**. Это механизм для тех провайдеров, кто практикует [VLAN-per-user](http://lookmeup.linkmeup.ru/#term230), например.
Вот типичный пример сети, где MVR жизненно необходим:
5 клиентов в разных VLAN'ах, и все хотят получать мультикастовый трафик одной группы 224.2.2.4. При этом клиенты должны оставаться изолированными друг от друга.
IGMP-Snooping учитывает, разумеется и VLAN'ы. Если пять клиентов в разных VLAN'ах запрашивают одну группу — это будет пять разных таблиц. Соответственно и к маршрутизатору идут 5 запросов на подключение к группе. И каждый сабинтерфейс из этих пяти на маршрутизаторе будет добавлен отдельно в OIL. То есть получив 1 поток для группы 224.2.2.4 он отправит 5 копий, несмотря на то, что все они идут в один сегмент.
Для решения этой проблемы и был разработан механизм Multicast VLAN Replication.
Вводится дополнительный VLAN — **Multicast VLAN** — в нём, соответственно, будет передаваться мультикастовый поток. Он «проброшен» непосредственно до последнего коммутатора, где трафик из него копируется во все клиентские интерфейсы, которые хотят получать этот трафик — это и есть репликация.
В зависимости от реализации репликация из Multicast VLAN может производиться в **User-VLAN** или в определённые физические интерфейсы.
А что с IGMP-сообщениями? Query от маршрутизатора, естественно, приходит по мультикастовому VLAN'у. Коммутатор их рассылает в клиентские порты. Когда Report или Leave приходит от клиента, коммутатор проверяет откуда именно (VLAN, интерфейс) и, если необходимо, перенаправляет в мультикастовый VLAN.
Таким образом обычный трафик изолирован и по-прежнему ходит до маршрутизатора в пользовательском VLAN'е. А мультикастовый трафик и IGMP-пакеты передаются в Multicast VLAN.
> На оборудовании Cisco MVR и IGMP-Snooping настраиваются независимо. То есть можно отключить один и второй будет работать. Вообще же MVR основан на IGMP-Snooping и на коммутаторах других производителей для работы MVR может быть обязательным включение IGMP-Snooping.
Кроме того, IGMP-Snooping позволяет осуществлять на коммутаторах фильтрацию трафика, ограничивать количество групп, доступных пользователю, включение IGMP Querier, статическую настройку восходящих портов, перманентное подключение к какой-либо группе (этот сценарий есть в сопутствующем [видео](http://www.youtube.com/watch?feature=player_embedded&v=7MqBF0wKNR0#t=60)), быструю реакцию на изменение топологии путём рассылки дополнительных Query, SSM-Mapping для IGMPv2 итд.
Заканчивая разговор об IGMP-Snooping, хочется повторить — это необязательный функционал — всё и без него будет работать. Но это сделает сеть более предсказуемой, а жизнь инженера спокойнее.
Однако все плюсы IGMP Snooping можно обернуть и против себя. Один такой выдающийся случай можно почитать по [ссылке](http://nag.ru/articles/article/25136/takie-raznyie-problemyi.html#Masochist).
К слову у той же Cisco есть протокол [CGMP](http://lookmeup.linkmeup.ru/#term352) — аналог IGMP, который не нарушает принципы работы коммутатора, но он проприетарный и не сказать, что широко распространённый.
---
Итак, мой неутомимый читатель, мы приближаемся к концу выпуска и напоследок хочется показать, как может быть реализована услуга IPTV на стороне клиента.
Самый простой способ, к которому мы уже не раз обращались в этой статье — запустить плеер, который может принять мультикастовый поток из сети. На нём можно вручную задать IP-адрес группы и наслаждаться видео.
Другой программный вариант, который часто используют провайдеры — специальное приложение, обычно весьма кастомное, в котором зашит набор каналов, используемых в сети провайдера. Нет необходимости что-то задавать вручную — нужно просто переключать каналы кнопками.
Оба эти способа дают возможность смотреть потоковое видео только на компьютере.
Третий же вариант позволяет использовать телевизор, причём как правило, любой. Для этого в доме клиента ставит так называемый Set-Top-Box (STB) — коробочка, устанавливаемая на телевизор. Это шелезяка, которая включается в абонентскую линию и разделяет трафик: обычный юникаст она отдаёт в Ethernet или WiFi, чтобы клиенты имели доступ в Интернет, а мультикастовый поток передаётся на телевизор через кабель (DVI, RGB, антенный итд.).
Часто вы, кстати, можете увидеть рекламу, где провайдер предлагает свои приставки для подключения телевидения — это и есть те самые STB
> =====================
>
> [**Задача № 4**](http://linkmeup.ru/blog/133.html)
>
>
>
> Напоследок нетривиальная задачка по мультикасту (авторы не мы, в ответах будет ссылка на оригинал).
>
>
>
> Самая простая схема:
>
>
>
> 
>
>
>
> С одной стороны сервер-источник, с дугой — компьютер, который готов принимать трафик.
>
>
>
> Адрес мультикастового потока вы можете устанавливать сами.
>
>
>
> И соответственно, два вопроса:
>
> **1.** Что нужно сделать, чтобы компьютер мог получать поток и при этом не прибегать к мультикастовой маршрутизации?
>
> **2.** Допустим, вы вообще не знаете, что такое мультикаст и не можете его настраивать, как передать поток от сервера к компьютеру?
>
>
>
> Задача легко ищется в поисковике, но попробуйте решить её сами.
>
>
>
> Подробности задачи [тут](http://linkmeup.ru/blog/133.html).
>
> =====================
>
>
---
Незатронутыми в статье остались междоменная маршрутизация мультикастового трафика ([MSDP](http://lookmeup.linkmeup.ru/#term349), [MBGP](http://lookmeup.linkmeup.ru/#term238), [BGMP](http://lookmeup.linkmeup.ru/#term237)), балансировка нагрузки между RP ([Anycast RP](http://lookmeup.linkmeup.ru/#term314)), [PGM](http://habrahabr.ru/post/148444/), проприетарные протоколы. Но, я думаю, имея как точку старта эту статью, разобраться в остальном не составит труда.
Все термины, касающиеся мультикаста, вы можете найти в телекоммуникационном глоссарии [lookmeup](http://lookmeup.linkmeup.ru/).
За помощь в подготовке статьи спасибо [JDima](https://habr.com/ru/users/jdima/)…
За техническую поддержку спасибо [Наташе Самойленко](http://xgu.ru/wiki/%D0%9A%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D1%8F:%D0%90%D0%B2%D1%82%D0%BE%D1%80_%D0%9D%D0%B0%D1%82%D0%B0%D1%88%D0%B0_%D0%A1%D0%B0%D0%BC%D0%BE%D0%B9%D0%BB%D0%B5%D0%BD%D0%BA%D0%BE).
КДПВ нарисована [Ниной Долгополовой](http://www.nina-dolgopolova.com/) — замечательным художником и другом проекта.
В пуле статей СДСМ ещё много интересного до окончания, поэтому не нужно хоронить цикл из-за долгого отсутствия выпуска — с каждой новой статьёй сложность значительно возрастает. Впереди почти весь MPLS, IPv6, QoS и дизайн сетей.
Как вы уже, наверно, заметили, у linkmeup появился новый проект — Глоссарий lookmeup (да, недалеко у нас ушла фантазия). Мы надеемся, что этот глоссарий станет самым полным справочником терминов в области связи, поэтому мы будем рады любой помощи в его заполнении. Пишите нам на [info@linkmeup.ru](mailto:info@linkmeup.ru)
Оставайтесь с [нами](http://linkmeup.ru). | https://habr.com/ru/post/217585/ | null | ru | null |
# Пока смерть не разлучит нас или всё о static в C++
Всем привет. На одном из код-ревью я столкнулся с мыслью, что многие, а чего скрывать и я сам, не то чтобы хорошо понимаем когда нужно использовать ключевое слова **static**. В данной статье я хотел бы поделиться своими знаниями и информацией по поводу ключевого слова **static**. Статья будет полезна как начинающим программистам, так и людям, работающим с языком С++. Для понимания статьи у вас должны быть знания о процессе сборки проектов и владение языком С/С++ на базовом уровне. *Кстати,* **static** используется не только в С++, но и в С. В этой статье я буду говорить о С++, но имейте в виду, что всё то, что не связано с объектами и классами, в основном применимо и к языку С.
### Что такое static?
**Static -** это ключевое слово в C++, используемое для придания элементу особых характеристик. Для статических элементов выделение памяти происходит только один раз и существуют эти элементы до завершения программы. Хранятся все эти элементы не в heap и не на stack, а в специальных сегментах памяти, которые называются *.data* и *.bss* (зависит от того инициализированы статические данные или нет). На картинке ниже показан типичный макет программной памяти.
### Где используется?
Ниже приведена схема, как и где используется **static** в программе.
А теперь я постараюсь детально описать все то, что изображено на схеме. Поехали!
### Статические переменные внутри функции
Статические переменные при использовании внутри функции инициализируются только один раз, а затем они сохраняют свое значение. Эти статические переменные хранятся в статической области памяти (*.data или .bss*), а не в стеке, что позволяет хранить и использовать значение переменной на протяжении всей жизни программы. Давайте рассмотрим две почти одинаковые программы и их поведение. Отличие в них только в том, что одна использует статическую переменную, а вторая нет.
Первая программа:
```
#include
void counter() {
static int count = 0; // строка 4
std::cout << count++;
}
int main() {
for (int i = 0; i < 10; ++i) {
counter();
}
return 0;
}
```
Вывод программы:
> 0123456789
Вторая программа:
```
#include
void counter() {
int count = 0; // строка 4
std::cout << count++;
}
int main() {
for (int i = 0; i < 10; ++i) {
counter();
}
return 0;
}
```
Вывод программы:
> 000000000
Если не использовать **static** в *строке 4*, выделение памяти и инициализация переменной count происходит при каждом вызове функции *counter()*, и уничтожается каждый раз, когда функция завершается. Но если мы сделаем переменную статической, после инициализации (при первом вызове функции *counter()*) область видимости *count* будет до конца функции *main()*, и переменная будет хранить свое значение между вызовами функции *counter()*.
### Статические объекты класса
Статический объект класса имеет такие же свойства как и обычная статическая переменная, описанная выше, т.е. хранится в *.data или .bss* сегменте памяти, создается на старте и уничтожается при завершении программы, и инициализируется только один раз. Инициализация объекта происходит, как и обычно — через конструктор класса. Рассмотрим пример со статическим объектом класса.
```
#include
class Base { // строка 3
public:
Base() { // строка 5
std::cout << "Constructor" << std::endl;
}
~Base() { // строка 8
std::cout << "Destructor" << std::endl;
}
};
void foo() {
static Base obj; // строка 14
} // строка 15
int main() {
foo(); // строка 18
std::cout << "End of main()" << std::endl;
return 0;
}
```
Вывод программы:
> Constructor
>
> End of main()
>
> Destructor
В *строке 3* мы создаем класс *Base* с конструктором (*строка 5*) и деструктором (*строка 8*). При вызове конструктора либо деструктора мы выводим название метода класса в консоль. В *строке 14* мы создаем статический объект *obj* класса *Base*. Создание этого статического объекта будет происходить только при первом вызове функции *foo() в строке 18*.
Из-за того, что объект статический, деструктор вызывается не при выходе из функции *foo() в строке 15*, а только при завершении программы, т.к. статический объект разрушается при завершении программы. Ниже приведен пример той же программы, за исключением того, что наш объект нестатический.
```
#include
class Base {
public:
Base() {
std::cout << "Constructor" << std::endl;
}
~Base() {
std::cout << "Destructor" << std::endl;
}
};
void foo() {
Base obj;
} // строка 15
int main() {
foo();
std::cout << "End of main()" << std::endl;
return 0;
}
```
Если мы уберем **static** при создании переменной в функции *foo()*, то разрушение объекта будет происходить в *строке 15* при каждом вызове функции. В таком случае вывод программы будет вполне ожидаемый для локальной переменной с выделенной памятью на стеке:
> Constructor
>
> Destructor
>
> End of main()
### Статические члены класса
В сравнении с предыдущими вариантами использования, статические члены класса немного сложнее для понимания. Давайте разберемся, почему. Предположим, у нас есть следующая программа:
```
#include
class A { // строка 3
public:
A() { std::cout << "Constructor A" << std::endl; }
~A() { std::cout << "Destructor A" << std::endl; }
};
class B { // строка 9
public:
B() { std::cout << "Constructor B" << std::endl; }
~B() { std::cout << "Destructor B" << std::endl; }
private:
static A a; // строка 15 (объявление)
};
int main() {
B b; // строка 19
return 0;
}
```
В нашем примере мы создали класс *А (строка 3)* и класс *В (строка 9)* со статическими членами класса (*строка 15*). Мы предполагаем, что при создании объекта *b* в *строке 19* будет создан объект *a* в *строке 15*. Так бы и произошло, если бы мы использовали нестатические члены класса. Но вывод программы будет следующим:
> Constructor B
>
> Destructor B
Причиной такого поведения является то, что статические члены класса не инициализируются с помощью конструктора, поскольку они не зависят от инициализации объекта. Т.е. в *строке 15* мы только объявляем объект, а не определяем его, так как определение должно происходить вне класса с помощью *оператора разрешения области видимости (::)*. Давайте определим *члены класса B*.
```
#include
class A {
public:
A() { std::cout << "Constructor A" << std::endl; }
~A() { std::cout << "Destructor A" << std::endl; }
};
class B {
public:
B() { std::cout << "Constructor B" << std::endl; }
~B() { std::cout << "Destructor B" << std::endl; }
private:
static A a; // строка 15 (объявление)
};
A B::a; // строка 18 (определение)
int main() {
B b;
return 0;
}
```
Теперь, после того как мы определили наш статический член класса в строке 18, мы можем увидеть следующий результат программы:
> Constructor A
>
> Constructor B
>
> Destructor B
>
> Destructor A
Нужно помнить, что член класса будет **один для всех экземпляров класса B**, т.е. если мы создали три объекта класса **B**, то конструктор статического члена класса будет вызван только один раз. Вот пример того, о чем я говорю:
```
#include
class A {
public:
A() { std::cout << "Constructor A" << std::endl; }
~A() { std::cout << "Destructor A" << std::endl; }
};
class B {
public:
B() { std::cout << "Constructor B" << count++ << std::endl; }
~B() { std::cout << "Destructor B" << --count << std::endl; }
private:
static A a; // объявление
static int count; // объявление
};
A B::a; // определение
int B::count = 1; // определение
int main() {
B b1, b2, b3;
return 0;
}
```
Вывод программы:
> Constructor A
>
> Constructor B1
>
> Constructor B2
>
> Constructor B3
>
> Destructor B3
>
> Destructor B2
>
> Destructor B1
>
> Destructor A
### Статические функции
Статические функции пришли в С++ из С. По умолчанию все функции в С глобальные и, если вы захотите создать две функции с одинаковым именем в двух разных .c(.cpp) файлах одного проекта, то получите ошибку о том, что данная функция уже определена (*fatal error LNK1169: one or more multiply defined symbols found*). Ниже приведен листинг трех файлов одной программы.
```
// extend_math.cpp
int sum(int a, int b) {
int some_coefficient = 1;
return a + b + some_coefficient;
}
```
```
// math.cpp
int sum(int a, int b) {
return a + b;
}
```
```
// main.cpp
int sum(int, int); // declaration
int main() {
int result = sum(1, 2);
return 0;
}
```
Для того чтобы исправить данную проблему, одну из функций мы объявим статической. Например эту:
```
// extend_math.cpp
static int sum(int a, int b) {
int some_coefficient = 1;
return a + b + some_coefficient;
}
```
В этом случае вы говорите компилятору, что доступ к статическим функциям ограничен файлом, в котором они объявлены. И он имеет доступ только к функции *sum()* из *math.cpp* файла. Таким образом, используя **static** для функции, мы можем ограничить область видимости этой функции, и данная функция не будет видна в других файлах, если, конечно, это не заголовочный файл (.h).
Как известно, мы не можем определить функцию в заголовочном файле не сделав ее **inline** или **static**, потому что при повторном включении этого заголовочного файла мы получим такую же ошибку, как и при использовании двух функций с одинаковым именем. При определении статической функции в заголовочном файле мы даем возможность каждому файлу (.cpp), который сделает #include нашего заголовочного файла, иметь свое собственное определение этой функции. Это решает проблему, но влечет за собой увеличение размера выполняемого файла, т.к. директива *include* просто копирует содержимое заголовочного файла в .cpp файл.
### Статические функции-члены класса (методы)
Статическую функцию-член вы можете использовать без создания объекта класса. Доступ к статическим функциям осуществляется с использованием имени класса и *оператора разрешения области видимости (::)*. При использовании статической функции-члена есть ограничения, такие как:
1. Внутри функции обращаться можно только к статическим членам данных, другим статическим функциям-членам и любым другим функциям извне класса.
2. Статические функции-члены имеют область видимости класса, в котором они находятся.
3. Вы не имеете доступа к указателю this класса, потому что мы не создаем никакого объекта для вызова этой функции.
Давайте рассмотрим следующий пример:
```
#include
class A {
public:
A() { std::cout << "Constructor A" << std::endl; }
~A() { std::cout << "Destructor A" << std::endl; }
static void foo() { // строка 8
std::cout << "static foo()" << std::endl;
}
};
int main() {
A::foo(); // строка 14
return 0;
}
```
В *классе A* в *строке 8* у нас есть статическая функция-член *foo()*. *В строке 14*, мы вызываем функцию используя имя класса и оператор разрешения области видимости и получаем следующий результат программы:
> static foo()
Из вывода видно, что никакого создания объекта нет и конструктор/деструктор не вызывается.
Если бы метод *foo()* был бы нестатическим, то компилятор выдал бы ошибку на выражение *в строке 14*, т.к. нужно создать объект для того, чтобы получить доступ к его нестатическим методам.
### Заключение
В одной статье в интернете я нашел совет от автора – *«Используйте static везде, где только можно»*. Я хотел бы написать, почему так делать не стоит, а стоит использовать только в случае необходимости.
Итоги:
* Статические переменные медленнее, чем нестатические переменные. Для того, чтобы обратиться к статической переменной, нам нужно сделать несколько дополнительных действий, таких как переход в другой сегмент памяти и проверка инициализации переменной. Чаще всего, быстрее выделить локальную переменную на стеке, чем делать дополнительные действия по использованию статической переменной.
* Если вы используете многопоточность, то здесь вы должны быть крайне осторожными, т.к. возможна ситуация, когда два и более потока захотят писать в одну статическую переменную. Если вы будете использовать нестатические переменные в функциях, то избежите подобного, т.к. для каждого потока будет создана собственная нестатическая переменная.
* Ключевое слово static является неотъемлемой частью порождающего шаблона проектирования Singleton, который гарантирует, что будет создан только один экземпляр этого класса. В реализации этого паттерна используется и статический объект, и статическая функция-член. На практике вы можете использовать Singleton для создания объекта трейсера, логгера или любого другого объекта, который должен быть один на всё ваше приложение.
* Иногда для того, чтобы функция отработала только один раз без хранения предыдущего состояния где-то в объекте, используют статические переменные. Пример вы можете посмотреть в разделе «Статические переменные внутри функции». Но это не очень хороший подход, и может привести к долгим часам поиска ошибки, если вы используете многопоточность.
* На практике, программисты C++ часто используют статические функции-члены как альтернативу обычным функциям, которые не требуют создания объекта для выполнения ее.
Надеюсь, вам понравилась моя статья о ключевом слове **static** в языке C++. Буду рад любой критике и советам. **Всем спасибо!** | https://habr.com/ru/post/527044/ | null | ru | null |
# Swift + VK.API, или история о SwiftyVK
Сегодня я хочу вам рассказать о том, как однажды познакомился с языком программирования Swift и решил написать на нем приложение для социальной сети ВКонтакте под OSX (которое, к сожалению, до сих пор не закончено). С какими подводными камнями мне пришлось столкнуться при обуздании, на тот момент, нового языка и скрещивании его с VK.API. Поделиться с общественностью результатом того, во что именно все это вылилось и попытаться обосновать, зачем нужно было придумывать очередной велосипед в виде библиотеки для работы с VK.API.
Если кому-то это интересно, то добро пожаловать под кат.
#### Часть первая: Hello, Swift!
Это был вечер 2го июня 2014 года. Являясь пользователем продукции Apple и начинающим objc разработчиком, я был прикован к экрану своего ноутбука, на котором мелькали друг за другом кадры презентации WWDC 2014. Проводить один вечер в году за просмотром трансляции уже стало стандартным обрядом. Этот раз не оказался исключением. Как и ожидалось, ничего сверхъестественного представлено не было, а новый интерфейс OSX даже оставил некий налет разочарования. Я уже всецело намеревался досмотреть оставшиеся 15 минут и отправиться по своим мирским делишкам. Но тут, под шумок очередного обновления Xcode, без знаменитого «one more thing», бесцеремонно, Крейг Федериги представляет новый язык программирования, имя которому Swift.
Это было именно то, чего я так ждал. Сколько я не пытался привыкнуть к синтаксису objc, но многие моменты доставляли большие неудобства. Это было похоже на неустранимый зуд, который переодически напоминал о себе в процессе написания кода. Я помню, что за пару недель до этого самого дня, мечтал о том, чтобы objc был человечнее и читабельнее. Даже набрел на [статью на хабре по этому поводу](http://habrahabr.ru/post/129993/), но счел решение костылем, который только будет больше мешать, чем приносить пользы. И вот, оно совершилось. Я не мог поверить. но оставшийся вечер точно был потерян. Все планы отодвинулись на второй план. На первый же выдвинулась задача скорее стянуть новый Xcode и узнать, что же из себя представляет эта диковинная птица. Я игрался с новинкой вплоть до того момента пока царство снов не поманило меня к себе, а сил сопротивляться больше уже не осталось. Но запасшись книжкой «The Swift Programming Language» зарекся, что с самого утра подойду вплотную к изучению всех тонкостей нововыпущенного на свет стрижа.
Сказано — сделано. Я с воодушевлением взялся за поставленное самому себе задание. Перечитал всю вышеупомянутую книгу и очень въедливо старался разобрать примеры кода из нее, дабы понять что же тут к чему. А когда с ней было покончено, успешно владел основными конструкциями и влюбился в этот язык. Упрощенный читабельный синтаксис, статическая типизация, опциональные значения, дженерики и многие другие вещи Swift не оставили меня равнодушным. Возвращаться обратно к старичку objc больше абсолютно не хотелось(хотя еще, наверное, долго придется).
#### Часть вторая: Вперед и с песней
Итак. Учебные материалы по языку были выучены, основы разобраны, а углубляться дальше в тонкости хотелось настолько, что было принято слегка опрометчивое решение писать приложение на языке, который еще находился в статусе бета.
Стоит сказать, что до этого я писал лишь небольшие программки для автоматизации рутинных действий. Не сказать, что это были прям какие-то скрипты. Нет, это были маленькие приложения на objc, с применением ООП, многопоточности, графическим интрефейсом и даже каких-то шаблонов проектирования, которые до сих пор успешно работают и повседневно упрощают жизнь. Только вот они решают специфические для меня задачи, и врядли по этой причине кому-то сильно пригодятся (хотя есть идея довести их до соответствующего состояния и выложить в стор. Вдруг я ошибаюсь).
Мотивацией для всех моих детищ была одна мысль — если этой вещи нет или реализовано не так, как хотелось бы, а я знаю, как хотел бы это видеть, то нужно делать самому. В этот раз я последовал той же логике. Уже какое-то время была в голове идея создать приложение для социальной сети вконтакте под OSX, так как аналоги меня никак не устраивали (не буду говорить, что за приложение, так как оно еще далеко от релиза. Да и суть статьи не в этом). Проект предстоял намного крупнее того, что я обычно делал и требовал больших трудо и мозгозатрат, чем обычно. Я подумал, что это хорошая возможность углубиться в разработку на Swift, в так же воплотить в жизнь отложенную идею. Тем более один мой друг уже был знаком с работой VK.API и тоже хотел изучить Swift. Это еще больше воодушевило меня.
И вот, я начал пытаться построить у себя в голове более четкую концепцию того, что хотелось бы видеть по прошествию работы. Только один, так как друг мой этой идеей, видимо, загорелся меньше. Но с API он мне все же помог, за что ему отдельное спасибо.
Первое, что пришло в голову — найти библиотеку для работы с VK.API для Objective-C (благо Swift позволяет использовать код на objc в своих проектах). Это должно было сильно упростить разработку, не пришлось бы заморачиваться с логикой запросов/ответов, а только получать данные, раскидывать их в модели и так же просто отправлять новые данные на сервера.
Копавшись в официальной документации VK я первым делом обратил внимание на [официальный SDK](https://github.com/VKCOM/vk-ios-sdk). Создан он для iOS, но может можно как-то прикрутить к OSX? Оказалось, что нет. Помимо самих запросов там очень многое завязано на UIKit, а перекручивать гайки под AppKit было почти нереально. Отчаянный поиск в гугле тоже ничего не дал. Все библиотеки были разработаны либо исключительно под iOS, либо являлись уже как несколько лет назад закинутыми автором на пыльную полку недоделками. Ни один вариант мне не подошел. Это, конечно, меня опечалило, но раз уж взялся за воплощение затеи, то останавливаться не стал. Нет библиотеки? Обойдемся без нее!
#### Часть третья: Мы свой, мы новый дом построим
Первое, что нужно было сделать — разобраться с процессом авторизации. Тут все оказалось просто потому, что он проходит по протоколу oAuth. По крайней мере авторизоваться и выдрать токен с определенными правами из адресной строки браузера, чтобы начать пытаться отправлять тестовые запросы к API получилось быстро. Потом, что немного сложнее, нужно было реализовать это в самом приложении. Был создан WebView, который загружал страницу авторизации а его WebFrameLoadDelegate смотрел на URL страницы и ловил токен. На первых порах было всего три варианта действий: Если в URL есть токен, то забираем его и убираем WebView. Если пользователь отклонил авторизацию, то вообще закрываем приложение, a если вдруг решил перейти на какую-то другую страницу, то не даем ему это сделать и возвращаем обратно к авторизации.
Запросы я отправлял с помощью NSURLConnection, причем синхронно. Ответы парсил с помощью NSJSONSerialization и в итоге получал вот такие конструкции:
```
(((jsonObject as? NSDictionary)?["phoneNumbers"] as? NSArray)?[0] as? NSDictionary)?["number"] as? NSString
```
Согласитесь, не самое приятное зрелище. В этом месте работа с опциональными превращается в ад. Подробнее о проблеме [здесь](http://habrahabr.ru/post/228949/).
Где-то здесь начало становиться понятно, что все происходящее не есть хорошо и удобно. Плюс от API могут вернуться ошибки, запросы на авторизацию, аутентификацию, ввод каптчи. Эти вещи нужно как-то предусмотреть и обработать. После недолгих размышлений было решено, что максимально логично абстрагировать всю логику работы с API в отдельную библиотеку. Во-первых это позволит не размазывать код общения с VK по приложению, а во-вторых его можно будет переиспользовать и устранять ошибки более локально. Так как библиотек для iOS и objc есть куча (хотя хватит и одного официального SDK), то я решил делать свою исключительно для Swift и OSX.
Вообще, стоит сказать что если бы я писал на iOS, то такой проблемы бы и не возникло, но так как я десктопный, точнее ноутбучный, пользователь и люблю OSX больше, чем iOS, то все вещи которые делаю для себя — делаю естественно под ту платформу, которой активнее пользуюсь. Да и возможностей у которой, по моему скромному мнению, больше. Но на вкус и цвет…
#### Часть четвертая: Разработка. Или беглый обзор SwiftyVK
Первой появилась структура под лаконичным названием VK — точка входа, авторизации, создания запросов и просто дирижер SwiftyVK. Сначала она имела только методы для авторизации и деавторизации + набросок протокола делегата, который нужно реализовать в классе использующего приложения.
Дальше нужно было реализовать полноценную авторизацию. За основу было взято уже имеющееся решение и доведено до ума. Приложение при авторизации должно передать права, которые оно хочет получить. В официальном SDK список прав передается, как массив строк. Я решил воспользоваться статической типизацией Swift и сделал перечисление(enum) из прав, что позволяет при авторизации передавать массив так:
```
[.messages,.offline,.friends,.wall,.photos,.audio,.video,.docs]
```
Раньше токен, полученный после авторизации, хранился как переменная до закрытия программы. Теперь точно нужно было позаботится о его хранении получше. Если сильно не вдаваться в подробности, то это объект класса Token, который хранит непосредственно строку с токеном, логику ее отдачи и проверки актуальности. Если токен устарел, то будет запрошен новый. Token поддерживает протокол NSCoding и может сохраняться в NSUserDefaults или любое другое место на выбор. Сам объект существует как синглтон, так как два токена нам, естественно, не нужно.
Авторизацию можно запустить как в любом окне в ввиде sheet, так и отдельным окном. После прохождения авторизации мы начинаем отправлять запросы API. Нужно было реализовать логику их отправки и получения ответа. Это сделано группой классов/структур Request, Connection, Response и NSURLFabric. Вне самой библиотеки видна только первая — Request и некоторые ее свойства/методы, которые позволяют настроить запрос и отправить его в дальние дали к серверам «ВКонтакте». Connection — логика отправки запроса, ожидания ответа, обработка ошибок и вызова калбэков. NSURLFabric — фабрика со статическими методами, которая собирает из Request настроенный и готовый к отправке NSURLRequest. Ну а Response — простая структура с полями request, error, success и логикой парсинга ответа от сервера в ошибку или успешный ответ.
Выше было показано как парсился JSON с помощью NSJSONSerialization. Чтобы получить более удобные и Swift-нативные методы получения значений сначала была использована библиотека из приведенной там же статьи с описанием этой проблемы, но так как она все равно оставляла много мест, где используется знаки вопросов при парсинге, позже совершен переход на [SwiftyJSON](https://github.com/SwiftyJSON/SwiftyJSON), как по мне, очень удобную библиотеку. С ее помощью проблема была решена полностью.
Ошибки реализуются в классе Error, который напоминает NSError. Объекты Error даже могут быть инициализированы с помощью NSError, но чаще это происходит из JSON. Обработка некоторых ошибок происходит прямо в SwiftyVK. Напрмер, если приложение отправило запрос который требует авторизации, но не мы не авторизованы, то вернется сообщение об ошибке, покажется окно авторизации, а после ее прохождения запрос будет переотправлен. Аналогично с каптчей. Чтобы отключить данную фичу нужно поставить параметр запроса catchErrors в false. Тогда даже в случае возвращения известной SwiftyVK ошибки будет выполнен блок обработки ошибки.
Долго же я мучился с синхронными и асинхронными запросами. Не в плане сложности многопоточности и асинхронности. Здесь ничего сложного. Проблемы были из-за отправки синхронных запросов в главном потоке. Могла получиться такая ситуация — приложение шлет синхронный запрос. Поток, из которого он отправлен, блокируется до момента вызова блока ответа или ошибки. API возвращает ошибку, которая говорит о необходимости авторизации/ввода каптчи до вызова блока ошибки. Окно нужно показать из main thread, а он уже заблокирован в ожидании ответа. В итоге взаимоблокировка и висим наглухо. Сколько я не пытался придумывать костыльные способы обхода этого — где-то что-то шло не так. Выход — на синхронные запросы с проверкой ошибок из главного потока сработает assert с описанием, что не стоит их слать. Конечно, не лучший способ, но всяко лучше, чем глухое зависание.
Так как Swift строго типизированный язык, то хотелось все строго типизировать, чтобы мест для совершения ошибок в будущем было как можно меньше. Самое, возможно, для кого-то спорное место — типизировать аргументы запросов. В официальном SDK они передаются в виде строки. Я же решил ввести пересечение Arg: String, в котором перечислил все на данный момент возможные аргументы запросов. По мимо минимизации ошибок, это позволяет пользоваться автодополнением в Xcode при задании аргументов.
Для еще большего удобства введена структура API, в котрой по группам-подструктурам содержатся методы для быстрого создания запроса к определенному методу API. В итоге создание запроса происходит как-то так:
```
let req = VK.API.Friends.get([
.count : "1",
.fields : "city,domain"
])
```
Как по мне, очень просто, читабельно и лаконично.
Помимо отправки простых запросов, есть возможность отправлять запросы с кастомным именем метода(передав его строкой), вызова execute или удаленных процедур. Плюс реализация загрузки файлов(чего в большинстве других библиотек нет) и LongPool клиента (этого нет нигде).
#### Часть пятая. Последняя
Впринципе, это все, из чего состоит SwiftyVK. Долгое время я его не выкладывал, так как тестировал и доводил до ума. Думаю, сейчас он готов к встрече с общественностью. Я старался сделать максимально простую и понятную библиотеку для работы с VK.API с использованием преимуществ нового языка. Хочется сказать, что в конце разработки я отступился от идеи делать ее только под OSX и добавил равноправную поддержку iOS. Хотелось еще сделать для tvOS, но там пока нет WebView и невозможно авторизоваться с помощью oAuth. Как только будет возможность — так сразу. Под watchOS решил не делать, ибо не знаю кому это может понадобиться. Я даже не уверен, что эта библиотека вообще может кому-то понадобиться, кроме меня. Но если я ошибаюсь и кто-то заинтересовался SwiftyVK, то боьлшое Вам спасибо и удачи в использовании. О всех пожеланиях обязательно пишите — будем делать.
Ознакомиться с документацией на кривом английском и исходным кодом можно [здесь](https://github.com/WE-St0r/SwiftyVK).
P.S.: Если Вы дочитали до этого места, то большое вам спасибо за уделенное время. | https://habr.com/ru/post/269741/ | null | ru | null |
# PHP и Temporal Coupling
Про архитектуру приложений на PHP было написано не один десяток статей, но на данной проблеме больше акцентируют внимание разработчики Java и C#. Суть ее заключается в жесткой зависимости одного свойства на другом.
Представим следующую ситуацию:
**Использование сеттера**
```
php
class Page
{
/**
* @var string
*/
private $content;
/**
* @param $content
*/
public function setContent($content)
{
$this-content = $content;
}
}
class PageBuilder
{
/**
* @var Page
*/
private $page;
/**
* @param $page
*/
public function setPage($page)
{
$this->page = $page;
}
/**
* @param $content
* @return $this
*/
public function setContent($content)
{
$this->page->setContent($content);
return $this;
}
/**
* @return Page
*/
public function build()
{
return $this->page;
}
}
```
```
$pageBuilder = new PageBuilder();
$pageBuilder->setPage(new Page());
$pageBuilder->setContent('Test content');
$pageBuilder->build();
```
В данном примере видно, что **$pageBuilder->build()** является потенциально опасным и может привести к фатальной ошибке если **$pageBuilder->setPage(new Page())** не был предварительно вызван. Другая часто встречающаяся ошибка — использование методов **init()** или **initialization()**:
**Использование инициализатора**
```
class Page
{
// Class
}
class PageBuilder
{
/**
* @var Page
*/
private $page;
/**
* Initialization
*/
public function init()
{
$this->page = new Page();
}
/**
* @param $content
* @return $this
*/
public function setContent($content)
{
$this->page->setContent($content);
return $this;
}
/**
* @return Page
*/
public function build()
{
return $this->page;
}
}
```
```
$pageBuilder = new PageBuilder();
$pageBuilder->init();
$pageBuilder->setContent('Test content');
$pageBuilder->build();
```
Если мы забудем вызвать метод **init()**, нас также ждут неприятности. Данный код является отличным примером плохой архитектуры приложения. Методы-инициализаторы пытаются вести себя как конструкторы, которыми не являются по определению.
Для избежания Temporal Coupling нужно всегда пользоваться правилами:
* экземпляр класса должен быть готов для использования сразу же после создания;
* конструкторы не должны выполнять никакой логики кроме инициализации свойств класса;
Инъекция зависимости через конструктор
--------------------------------------
Это решение является оптимальным и предпочтительным в большинстве случаев. Мы можем использовать механизмы Dependency Injection из Symfony, Laravel или других современных фреймворков.
**Инъекция через конструктор**
```
class Page
{
// Class
}
class PageBuilder
{
/**
* @var Page
*/
private $page;
/**
* PageBuilder constructor.
* @param Page $page
*/
public function __construct(Page $page)
{
$this->page = $page;
}
// Методы-сеттеры
}
$pageBuilder = new PageBuilder(new Page());
$pageBuilder->setContent('Test content');
$pageBuilder->build();
```
Абстрактная фабрика
-------------------
Немного модифицируем наш код, добавив абстрактную фабрику:
**Абстрактная фабрика**
```
php
class Page
{
// Class
}
class PageBuilder
{
/**
* @var Page
*/
private $page;
/**
* PageBuilder constructor.
* @param Page $page
*/
public function __construct(Page $page)
{
$this-page = $page;
}
/**
* @param $content
* @return $this
*/
public function setContent($content)
{
$this->page->setContent($content);
return $this;
}
/**
* @return Page
*/
public function build()
{
return $this->page;
}
}
class PageBuilderFactory implements FactoryInterface
{
/**
* @param Page|null $page
* @return PageBuilder
*/
public function create(Page $page = null)
{
if (null === $page) {
$page = new Page();
}
return new PageBuilder($page);
}
}
$pageBuilderFactory = new PageBuilderFactory();
$pageBuilder = $pageBuilderFactory->create();
$pageBuilder->setContent('Test content');
$pageBuilder->build();
```
Как видим, экземпляр класса **Page** создан без явного вызова и будет доступен нашему билдеру.
Заключение
----------
Temporal Coupling нужно всегда избегать, вне зависимости от сложности приложения, влияния code-review или других факторов. Также помните что конструкторы должны выполнять только логику, связанную с инъекциями. Иначе вы рискуете получить ухудшение быстродействия на этапе создания экземпляров класса.
Полезные ссылки
---------------
* [Design Smell: Temporal Coupling by Mark Seemann](http://blog.ploeh.dk/2011/05/24/DesignSmellTemporalCoupling/)
* [Temporal Coupling Between Method Calls](http://www.yegor256.com/2015/12/08/temporal-coupling-between-method-calls.html)
* [Symfony DI](http://symfony.com/doc/current/components/dependency_injection/introduction.html) | https://habr.com/ru/post/281330/ | null | ru | null |
# Домашний кластер на Dask
Я недавно проводил исследование, в рамках которого было необходимо обработать несколько сотен тысяч наборов входных данных. Для каждого набора — провести некоторые расчеты, результаты всех расчетов собрать вместе и выбрать "лучший" по некоторым критериям. По сути это bruteforce перебор. Тоже самое происходит при подборе параметров ML моделей с помощью `GridSearch`.
Однако, с некоторого момента размер вычислений может стать для одного компьютера великоват, даже если запускать ее в несколько процессов с помощью `joblib`. Или, если сказать точнее, он становится слишком долгим для нетерпеливого экспериментатора.
И поскольку в современной квартире сейчас можно найти больше одного "недогруженного" компьютера, а задача явно подходит для массового параллелизма — пора собрать свой домашний кластер и запускать такие задачи на нем.
Для построения "домашнего кластера" прекрасно подойдет библиотека Dask (<https://dask.org/>). Она проста в установке и не требовательна к узлам, что серьезно понижает "уровень входа" в кластерные вычисления.
Для настройки своего кластера нужно на всех компьютерах:
* установить интерпретатор python
* установить пакеты dask и прикладные пакеты вашего распределенного приложения
* сконфигурировать запуск планировщика (scheduler) на одном из компьютеров и работников (worker) на всех доступных
Также, возможно, прийдется немного поправить свое приложение — распределенные вычисления добавляют некоторые моменты, которые необходимо учитывать.
Развертывание кластера
======================
Официальная документация (<https://docs.dask.org/>) хорошо описывает процесс установки. Приведу ниже некоторые неочевидные аспекты, с которыми столкнулся сам.
Версии python
-------------
Поскольку Dask в своих операциях зависит от pickle, на клиенте, шедулере и рабочих узлах необходимо держать версии одинаковые или очень близкие версии python.
Версии 3.6 и 3.7 вместе работают, хотя и выдается предупреждение о различии версий. Узлы с 3.8 вместе с предыдущими работать не будут из-за новой версии pickle.
Если все ставится "с нуля", то, очевидно, лучше ставить везде одну версию.
Пакеты Dask
-----------
Dask и необходимые зависимости устанавливается как стандартные пакеты с помощью `pip` или `conda`
```
pip install dask distributed bokeh
```
В документации под dask, последний пакет `bokeh` упоминается как опциональный, но не говориться, что без него "по-тихому" не будет работать прекрасная функция dask dashboard.
Без нее проводить мониторинг кластера и наблюдать как задачки разбегаются по узлам будет невозможно. А это очень поможет при оптимизации приложения для работы в распределенной среде.
Для сборки необходим gcc, потому:
* на MacOS должен быть установлен xcode
* если собираете docker image для запуска docker-worker, то начать с "тонкого" имиджа, типа `python:3.6-slim-buster` может не получиться. Прийдется либо доставлять необходимые пакеты, либо взять полноразмерный исходный имидж `python:3.6`.
Запуск dask кластера
--------------------
Процесс-планировщик создается один на кластер. Запускать его можно на любой машине. Единственная очевидная рекомендация — машина должна быть максимально доступна.
```
$ dask-scheduler
```
Процессы-работники запускаются на всех компьютерах, ресусами которых вы планируете пользоваться.
```
$ dask-worker schedulerhost:8786 --nprocs 4 --nthreads 1 --memory-limit 1GB --death-timeout 120 -name MyWorker --local-directory /tmp/
```
* `nprocs` / `nthreads` — количество процессов, которые будут запущены, и количество потоков в каждом из них. Поскольку GIL присутствует и на стороне процессов-работников, запускать обработку на многих потоках имеет смысл только если распределенный процесс реализован на чем-то низкоуровневом, как numpy. В противном случае нужно масштабироваться за счет количества процессов.
* `memory-limit` — объем памяти, доступный каждому процессу. Ограничивать доступную память процесам нужно очень аккуратно — при достижении предела по памяти процесс-работник перестартовывает, что может вызвать остановку процесса обработки. Я сначала ставил ограничение, но потом убрал.
* `death-timeout` — время в секундах, в течении которого процессы-работники будут ждать, пока планировщик перезапустится. Это время нужно подбирать в соответствии с ожидаемым временем перезагрузки компьютера-планировщика. Как ни странно, похоже, этот параметр не всегда учитывается.
* `name` — префикс имени процесса-работника, как он будет отображаться в отчетах планировщика. Это удобно, чтобы видеть "человеческие" имена сервисов-работников.
* `local-directory` — директория, которая будет использоваться для создания временных файлов
### Запуск процессов-работников на Windows в виде сервиса
Понятно, что запуск dask-worker со всему параметрами делается в виде пакетного файла. Также, чтобы кластер поднимался сам, dask-worker должен запускаться как только компьютер стартовал.
Решений задачи "запустить батник как сервис" множество. Я в последнее время использую утилиту NSSM (<https://www.nssm.cc/>).
NSSM, в частности, позволяет настроить рестарт пакетного файла, в случае его завершения. Это удобно для обработки ситуации, когда планировщик недоступен в течение длительного времени, и процессы-работники завершаются и останавливаются. В этом случае NSSM просто будет их перезапускать.
Также NSSM позволяет перенаправить консольный вывод из пакетного файла в ротируемый файл журнала. Бывает удобно для "разбора полетов"
### Проверка Firewall
Также необходимо проверить правила firewall: планировщик должен иметь возможность достучаться до процесса-работника.
Неприятно, что если на узле, где запущен процесс-работник, блокируются входящие соединения — то об этом станет известно только при запуске приложения. В этом случае, если даже до одного узла не получится достучаться — весь клиентский процесс упадет. До этого будет казаться, что все в порядке, поскольку все узлы будут выглядеть как подключенные.
По умолчанию каждый процесс-работник открывает случайный порт. При запуске можно указать прослушиваемый порт, однако в этом случае будет запустить только один процесс.
Использование Dask в собственном приложении
===========================================
Подключение к кластеру
----------------------
Подключение к распределенному кластеру происходит очень просто:
```
from dask.distributed import Client
client = Client('scheduler_host:port')
```
Если не указать расположение планировщика — запустится "локальный" кластер в пределах одной машины, но это не то что нужно.
Общие прикладные пакеты
-----------------------
Важно иметь ввиду, что все пакеты, которые необходимы для работы распределенного приложения должны быть установлены и на рабочих узлах кластера. Это касается pandas, numpy, scikit-learn, tensorflow.
Особо критично совпадение версий пакетов на всех узлах кластера для объектов, которые сериализуются.
Что делать, если на узлах кластера отсутствует необходимый пакет? Можно воспользоваться стандартной функцией удаленного запуска функций — и запустить `pip`
```
def install_packages():
try:
import sys, subprocess
subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'mypackage'])
return (0)
except:
return (1)
from dask.distributed import Client
client = Client('scheduler:8786')
client.run(install_packages)
```
Понятно, что данный трюк не очень подходит, если рабочие узлы запускаются в контейнерах. В этом случае проще и правильнее собрать обновленный имидж. Но для "домашнего" кластера, собранного на обычных компьютерах, подойдет.
Пакеты и модули приложения
--------------------------
Если в состав приложения входят разработанные пакеты или модули, и вы хотите, чтобы программный код из них выполнялся распределенно — то эти пакеты и модули также должны быть распространены на все узлы кластера перед запуском приложения.
Это довольно серьезное неудобство, если вы все еще дорабатываете приложение и пытаетесь его структурировать, и попутно запуская его в распределенной среде Dask кластера.
Есть задокументированный трюк с передачей пакетов и модулей на узлы кластера во время исполнения. Класс Client предлагает метод передачи файлов на узлы `upload_file()`. После передачи, файл размещается в пути поиска и может быть импортирован процессом работником.
Файл-модуль можно передать непосредственно, а пакет прийдется предварительно запаковать в zip.
```
from dask.distributed import Client
import numpy as np
from my_module import foo
from my_package import bar
def zoo(x)
return (x**2 + 2*x + 1)
x = np.random.rand(1000000)
client = Client('scheduler:8786')
# Локально определенная функция будет передана и исполнена прозрачно.
# Ничего дополнительно не нужно делать
r3 = client.map(zoo, x)
# Если foo и bar должны выполняться на узлах кластера,
# то содержащие их модуль и пакет необходимо предварительно передать на узлы кластера
client.upload_file('my_module.py')
client.upload_file('my_package.zip')
# Теперь вызовы пройдут успешно
r1 = client.map(foo, x)
r2 = client.map(bar, x)
```
Масштабирование joblib
----------------------
Я использую библиотеку `joblib` для удобного параллельного выполнения операций в рамках одного компьютера. Поскольку `joblib` позволяет подменить движок — модификация кода получается довольно простой:
Версия с `joblib`
```
from joblib import Parallel, delayed
...
res = Parallel(n_jobs=-1)(delayed(my_proc)(c, ref_data) for c in candidates)
```
Версия с `joblib` + `dask`
```
# Стало
from joblib import Parallel, delayed, parallel_backend
from dask.distributed import Client
...
client = Client('scheduler:8786')
with parallel_backend('dask'): # просто "оборачиваем" вызов в модифицированный контекст
res = Parallel(n_jobs=-1)(delayed(my_proc)(c, ref_data) for c in candidates)
```
Хотя, конечно, на самом деле все немного сложнее. Если посмотреть на то, как проходят вычисления в базовом случае — кластер простаивает подавляющее большинство времени:
Работают только два из доступных 16 работников, огромные промежутки между интервалами загрузки.
Время на выполнение одного батча — 10-20 мс, а интервалы между работами может достигать 200мс.
Для достижения хорошей загрузки распределенных узлов модифицированная версия программы будет обрастать параметрами и настройками, призванными сократить простой узлов из-за передач данных по сети.
```
# Стало
from joblib import Parallel, delayed, parallel_backend
from dask.distributed import Client
...
client = Client('scheduler:8786')
with parallel_backend('dask', scatter = [ref_data]):
res = Parallel(n_jobs=-1, batch_size=, pre\_dispatch='3\*n\_jobs')(delayed(my\_proc)(c, ref\_data) for c in candidates)
```
Имеет смысл подбирать размер пакета параметром `batch_size`. Он должен быть не очень маленький — чтобы время обработки на узле кластера было значительно больше времени передачи пакета по сети, но и не очень большим, чтобы десериализация не занимала много времени.
Иногда также помогает подготовить чуть большее количество пакетов с помощью параметра `pre_dispatch`.
На картинке отмечены области, где процесс вычисления все еще неоптимален.
* Красные области — простой узла. Они остались, но доля простоя существенно сократилась.
* Синие области — десериализацию (большие объекты загружаются в память)
* Черные области — сброс части данных на диск
Теперь время выполнения вычислений для пакета работы занимает 3.5-4 сек, а время на простой измеряется десятками милисекунд. Стало гораздо лучше: видно, что увеличение размера батча и количества пред-запланированных задач увеличили время, выделенное на выполнение, и не добавили много оверхеда.
Этот простой эксперимент показывает, для достижения ожидаемой производительности вычислений параметры `batch_size` и `pre_dispatch`очень важны. Одна только их настройка может дать прирост пропускной способности в 8-10 раза за счет полной утилизации узлов кластера.
Если процедура, выполняемая на узле, требует помимо основного аргумента какие-либо вспомогательные блоки данных (которые, например, просматриваются в процессе обработки), их можно передать на все узлы параметром `scatter`. Это существенно снижает объем передаваемых данных по сети при кажом вызове и оставляет больше времени на расчеты.
В итоге, после подбора параметров на таких простых задачах можно достичь почти линейного роста производительности от роста количества узлов.
Масштабирование GridSearchCV
----------------------------
Поскольку `scikit-learn` также использует `joblib` для реализации параллельной работы, масштабирование обучения моделей достигается ровно также — подменой движка на `dask`
Например:
```
...
lr = LogisticRegression(C=1, solver="liblinear", penalty='l1', max_iter=300)
grid = {"C": 10.0 ** np.arange(-2, 3)}
cv = GridSearchCV(lr, param_grid=grid, n_jobs=-1, cv=3,
scoring='f1_weighted',
verbose=True, return_train_score=True )
client = Client('scheduler:8786')
with joblib.parallel_backend('dask'):
cv.fit(x1, y)
clf = cv.best_estimator_
print("Best params:", cv.best_params_)
print("Best score:", cv.best_score_)
```
В результате выполнения:
```
Fitting 3 folds for each of 5 candidates, totalling 15 fits
[Parallel(n_jobs=-1)]: Using backend DaskDistributedBackend with 12 concurrent workers.
[Parallel(n_jobs=-1)]: Done 8 out of 15 | elapsed: 2.0min remaining: 1.7min
[Parallel(n_jobs=-1)]: Done 15 out of 15 | elapsed: 16.1min finished
/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/linear_model/_logistic.py:1539: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 16.
" = {}.".format(effective_n_jobs(self.n_jobs)))
Best params: {'C': 10.0}
Best score: 0.9748830491726451
```
Каждый перебираемый вариант преобразуется в отдельную задачу для dask. Таким образом все варианты распределяется случайным образом по всем доступным процессам-работникам.
При наличии достаточного количества работников в кластере — все работы начинают выполняться параллельно.
К сожалению, в случае если модель с разными значениями гиперпараметров сходится за разное время (как в данном случае) — параллелизм не приводит к сокращению времени пропорционально количеству узлов кластера. Но длительность всего процесса подбора становится сравнима с самым долгим вариантом — уже очень неплохо.
Заключение
==========
Библиотека Dask — прекрасный инструмент для масштабирования для определенного класса задач. Даже если использовать только базовый dask.distributed и оставить в стороне специализированные расширения dask.dataframe, dask.array, dask.ml — можно существенно ускорить эксперименты. В некоторых случаях можно добиться почти линейного ускорения рассчетов.
И все это — на базе того, что у вас уже есть дома, и используется для просмотра видео, прокрутки бесконечной новостной ленты или игр. Используйте эти ресурсы на полную! | https://habr.com/ru/post/499086/ | null | ru | null |
# Создание игр для NES на ассемблере 6502: ветвление и циклы
**Оглавление**
Оглавление
----------
### Часть I: подготовка
* [Введение](https://habr.com/ru/post/596449/)
* [1. Краткая история NES](https://habr.com/ru/post/596449/)
* [2. Фундаментальные понятия](https://habr.com/ru/post/596475/)
* [3. Приступаем к разработке](https://habr.com/ru/post/596475/)
* [4. Оборудование NES](https://habr.com/ru/post/596583/)
* [5. Знакомство с языком ассемблера 6502](https://habr.com/ru/post/597837/)
* [6. Заголовки и векторы прерываний](https://habr.com/ru/post/597887/)
* [7. Зачем вообще этим заниматься?](https://habr.com/ru/post/597887/)
* [8. Рефакторинг](https://habr.com/ru/post/597997/)
### Часть II: графика
* [9. PPU](https://habr.com/ru/post/599107/)
* [10. Спрайтовая графика](https://habr.com/ru/post/599333/)
* [11. Язык ассемблера: ветвление и циклы](https://habr.com/ru/post/599369/)
* [12. Циклы на практике](#practice)
* [13. Графика фона](https://habr.com/ru/post/599413/)
* [14. Движение спрайтов](https://habr.com/ru/post/599433/)
* [15. Скроллинг фона](https://habr.com/ru/post/599695/)
11. Ветвление и циклы
---------------------
Содержание:
* Управление потоком в языке ассемблера
* Ветвление
* Обзор опкодов циклов и ветвления
* Ещё один пример ветвления
* Выполнение сравнений
* Использование сравнений в циклах
В конце предыдущей главы мы успешно отрисовали на экране один спрайт, но для этого потребовался большой объём кода. В этой главе мы узнаем ещё несколько новых опкодов языка ассемблера, которые помогут нам разделить данные и логику, а также сделать код гораздо более эффективным, удобным для чтения и обдумывания.
Управление потоком в языке ассемблера
-------------------------------------
За исключением `JMP`, весь рассмотренный нами ассемблерный код был совершенно линейным: процессор считывает байт из следующего адреса памяти и обрабатывает его, двигаясь от начала файла ROM к его концу. *Управление потоком* — это возможность написания кода, который может вычислять определённые условия и в зависимости от результата выбирать, какой код будет выполняться далее. У процессора 6502 есть два вида управления потоком. `JMP` — это «безусловный» *переход* в другую часть ROM (он не выполняет никаких проверок или вычислений). Второй вид управления потоком называется «ветвлением», поскольку он выполняет проверку, а затем двигается по одному из двух различных «ветвей» кода в зависимости от результата.
### Регистр состояния процессора
Важнейшим аспектом ветвления является элемент процессора 6502, называемый *регистром состояния процессора* (processor status register) и часто обозначаемый как `P`. Регистр состояния, как и все остальные регистры 6502, имеет размер восемь бит. В отличие от других регистров, регистр состояния недоступен программисту напрямую. Каждый раз, когда процессор выполняет операцию, регистр состояния изменяется, отражая результаты этой операции. Каждый бит регистра состояния сообщает информацию об отдельном аспекте последней операции.
*Восемь бит регистра состояния процессора (NV-BDIZC).*
Для нас двумя самыми важными битами (или «флагами») регистра состояния процессора являются биты `Z` («zero», флаг нуля) и `C` («carry», флаг переноса). Флаг нуля *установлен* (равен 1), если результат последней операции был равен нулю. Флаг нуля *сбрасывается* (равен 0), если результат последней операции был чем угодно, кроме нуля. Аналогично, флаг переноса устанавливается, если последняя операция вызвала «перенос» и сбрасывается в противоположном случае.
### Перенос
С флагом нуля всё понятно, а флаг переноса требует дополнительных объяснений. Подумаем, что происходит при сложении десятичных чисел 13 и 29. Если бы мы выполняли это сложение вручную, то мы бы сначала прибавили «3» из 13 к «9» из 29. Результат равен 12, то есть слишком велик, чтобы поместиться в одну десятичную цифру. Поэтому мы записываем «2» и *переносим* «1» на один столбец влево. В нём мы складываем «1» из 13, «2» из 29 и перенесённую «1». Результат равен 4, и мы записываем его в этот столбец, получив в итоге 42.
Флаг переноса процессора 6502 выполняет ту же функцию, но для байтов. При операции сложения флаг переноса устанавливается, если результат сложения больше того, что может поместиться в один байт (т. е. если результат больше 255). Обычно мы будем использовать опкод, принудительно сбрасывающий флаг переноса перед выполнением сложения, чтобы флаг переноса, установленный предыдущей операцией, сохранялся для текущего сложения.
[Зачем вообще нужно сохранять предыдущий флаг переноса перед выполнением сложения? Если *не* сбрасывать флаг переноса, то это позволяет складывать многобайтные числа, сначала сложив самые младшие байты двух чисел, а затем позволив сложению при необходимости установить флаг переноса. При сложении следующих по старшинству байтов двух чисел будет автоматически прибавлен флаг переноса.]
Вычитание работает похожим образом, только мы обычно *задаём* флаг переноса перед выполнением вычитания. При операции вычитания флаг переноса *сбрасывается*, если вычитаемое число больше того, из которого выполняется вычитание. Например, если мы вычитаем 17 из 15, в результате получится -2. Это число меньше нуля, поэтому чтобы выполнить вычитание, нам нужно «позаимствовать» из следующего по старшинству столбца, использовав флаг переноса, который мы установили перед началом вычитания.
Важно также заметить, что аналогично одноразрядным десятичным числам, байты «оборачиваются» при сложении выше 255 или вычитании ниже нуля. Если байт (или регистр, или значение в памяти) равен 253 и мы прибавляем 7, то результат будет не равен 260, он равен 4 с установленным флагом переноса. Аналогично, если байт равен 4 и мы вычитаем 7, то результат равен 253 со сброшенным флагом переноса, а не -3.
В одной из следующих глав мы узнаем, как выполнять сложение и вычитание, а пока вам достаточно знать, что выполняемые процессором команды изменяют значения флагов нуля и переноса в регистре состояния процессора.
Ветвление
---------
Теперь, когда мы знаем о регистре состояния процессора, можно использовать результаты операций для ветвления в различные части кода. Проще всего использовать ветвление, создав цикл, выполняющий какие-то действия 256 раз. В своём самом простейшем виде он выглядит вот так
Прежде чем переходить к изучению работы цикла, нам нужно рассказать о двух новых опкодах.
`INX` расшифровывается как «increment X» («инкремент X»); он прибавляет единицу к значению регистра X и сохраняет результат обратно в регистр X. `BNE` обозначает «Branch if Not Equal
to zero» («ветвление, если не равно нулю»), этот опкод изменяет обычный поток выполнения кода, если сброшен флаг нуля в регистре состояния процессора (т. е. если результат последней операции не был равен нулю).
Цикл начинается с загрузки непосредственного значения `$00` в регистр X. Далее идёт метка (`LoopStart`), которая будет использоваться командой ветвления в конце цикла. После метки мы делаем то, что должен выполнять наш цикл, а затем производим инкремент регистра X. Как и все математические операции, это обновит флаги в регистре состояния процессора. Последняя строка цикла проверяет значение флага нуля. Если флаг нуля установлен, не происходит ничего особенного — программа просто продолжает выполнение и далее происходит то, что идёт после `; end of loop`. Если флаг нуля сброшен, то `BNE LoopStart` приказывает процессору найти метку `LoopStart` и исполнить далее то, что расположено по ней — иными словами, выполнить следующую итерацию цикла.
При запуске программы цикл будет выполнен 256 раз. На первой итерации цикла значение регистра X равно нулю. После `INX` значение регистра X равно единице. Так как результат `INX` не равен нулю, флаг нуля сбрасывается. Когда мы добираемся до `BNE LoopStart`, поскольку флаг нуля сброшен, процессор вернётся к метке `LoopStart` и снова выполнит цикл. В этот раз регистр X будет равен двум, что тоже не равно нулю, и цикл запустится снова. Постепенно значение регистра X доберётся до 255. Когда мы запустим при этом `INX`, регистр X «перекинется» к нулю и будет задан флаг переноса.
[Стоит заметить, что в этом случае мы могли выполнять ветвление на основании или флага нуля, или флага переноса. Когда регистр X «перекинется» с 255 до 0, будут установлены и флаг нуля, и флаг переноса.]
Теперь, когда результатом последней операции стал ноль, `BNE LoopStart` больше не будет срабатывать, и процессор продолжит выполнение всего того, что идёт после цикла.
Прежде чем двигаться дальше, нужно упомянуть ещё один аспект. После обработки этого кода ассемблером и компоновщиком все метки (например, `LoopStart`) будут вырезаны и заменены настоящими адресами памяти. Чтобы ветвление не занимало ненадлежащее количество времени процессора, данные, следующие за командой ветвления, являются не адресом памяти, а однобайтовым числом со знаком, которое прибавляется к тому адресу памяти, который находится в счётчике программ. Поэтому код, к которому вы хотите выполнить ветвление, должен располагаться не более чем на 127 бит до или не более чем на 128 бит после команды ветвления. Если вам нужно выполнить ветвление к чему-то, что расположено дальше, то необходимо воспользоваться переходом к этой метке через `JMP`. Маловероятно, что такое будет встречаться часто, если только вы не пишете очень сложный код, но это интересная подробность реализации, которая может привести к сложно отслеживаемому багу.
Обзор опкодов циклов и ветвления
--------------------------------
Мы уже видели `INX` и `BNE`, но это лишь два из того набора опкодов, которые можно использовать для создания циклов. Давайте рассмотрим ещё десять новых опкодов, которые вам необходимо освоить.
### Опкоды инкремента и декремента
Эти опкоды позволяют прибавлять или вычитать единицу за один опкод. Перед использованием одного из этих опкодов нет необходимости явным образом устанавливать или сбрасывать флаг переноса.
`INX` и `INY` добавляют единицу («инкремент») к регистру X или Y. `DEX` и `DEY` выполняют обратную задачу — вычитают единицу («декремент») из регистра X или Y. Опкоды `INC` и `DEC` можно использовать для выполнения инкремента или декремента содержимого адреса памяти. Например, можно использовать `INC $05`, чтобы прибавить к содержимому адреса памяти `$05` единицу и сохранить результат обратно в `$05`.
Все опкоды инкремента/декремента обновляют значения флагов нуля и переноса в регистре состояния процессора.
### Опкоды ветвления
Существуют опкоды ветвления для каждого флага регистра состояния процессора. Каждому флагу соответствует два опкода — один выполняет ветвление, когда флаг установлен, второй — когда он сброшен. В нашем случае единственными опкодами ветвления, которые нам пригодятся, будут проверяющие значения флагов нуля и переноса.
`BEQ` («Branch if Equals zero», «ветвление, если равно нулю») и `BNE` («Branch if Not Equals zero», «ветвление, если не равно нулю») меняют поток программы в случае установленного или сброшенного флага нулы. `BCS` («Branch if Carry Set», «ветвление, если установлен перенос») и `BCC` («Branch if Carry Cleared», «ветвление, если сброшен перенос») делают то же самое для флага переноса. То, что следует за каждым опкодом, обычно должно являться меткой кода, который должен выполниться дальше, если условия опкода ветвления удовлетворены.
Ещё один пример ветвления
-------------------------
Хочу поделиться ещё одним примером ветвления. На этот раз цикл будет выполняться восемь раз, а не 256.
Как и в предыдущем примере цикла, здесь мы сначала устанавливаем предварительные условия цикла, присвоив регистру Y значение `$08`. Затем идёт метка, которую опкод ветвления использует позже. После завершения того, что должен делать цикл в каждой итерации, мы выполняем декремент регистра Y, а затем производим ветвление к началу цикла, если флаг нуля сброшен.
На более современных C-подобных языках программирования (например, JavaScript) весь этот цикл можно переписать следующим образом:
```
for (y = 8; y != 0; y--) {
// do something
}
```
Выполнение сравнений
--------------------
Рассмотренные нами ранее циклы полезны, но они требуют тщательной подготовки. Для завершения цикла счётчик цикла должен стать равным нулю. Чтобы создавать более гибкие и мощные циклы, нам нужна возможность выполнения произвольных сравнений. В языке ассемблера 6502 есть следующие опкоды сравнения: `CMP`, «Compare (with accumulator)» («сравнение с накопителем»), `CPX`, «Compare
with X register» («сравнение с регистром X») и `CPY`, «Compare with Y register» («сравнение с регистром Y»).
Каждый из этих опкодов выполняет вычитание, соответствующим образом задаёт флаги нуля и переноса, а затем отбрасывает результат вычитания. Помните, что при выполнении вычитания мы сначала устанавливаем флаг переноса. Это означает, что при сравнении может быть три возможных результата, зависящих от значения регистра и значения, с которым мы его сравниваем:
1. *Регистр больше сравниваемого значения*: флаг переноса установлен, флаг нуля сброшен.
2. *Регистр равен сравниваемому значению*: флаг переноса установлен, флаг нуля установлен.
3. *Регистр меньше сравниваемого значения*: флаг переноса сброшен, флаг нуля сброшен.
Можно использовать эту информацию для создания более сложной логики программ. Рассмотрим случай, в котором мы загружаем значение из памяти, а затем проверяем, больше ли оно, равно или меньше `$80`.
Подобное трёхстороннее ветвление встречается довольно часто. Обратите внимание на наличие метки, указывающей на конец всего кода ветвления, чтобы предыдущий код мог выполнить переход `JMP` через относящийся к ветвлению код, который не должен исполняться, если ветвление не выполнено.
Использование сравнений в циклах
--------------------------------
В заключение этой главы давайте рассмотрим, как можно использовать сравнения для создания более сложных циклов. Ниже представлен цикл, выполняющийся восемь раз, но производящий отсчёт с нуля вверх, а не с восьми вниз.
Здесь перед началом цикла мы присваиваем регистру X значение 0. После каждой итерации цикла мы выполняем инкремент регистра X, а затем сравниваем X с `$08`. Если регистр X не равен восьми, флаг нуля не будет установлен и мы вернёмся к `loop_start`. В противном случае `CPX` установит флаг нуля (потому что восемь минус восемь равно нулю) и цикл завершится.
Подведём итог: в этой главе мы изучили следующие опкоды:
* `INX`
* `INY`
* `INC`
* `DEX`
* `DEY`
* `DEC`
* `BNE`
* `BEQ`
* `BCC`
* `BCS`
* `CMP`
* `CPX`
* `CPY`
Ещё 13 новых опкодов, которые можно использовать!
В следующей главе мы выполним рефакторинг нашего кода, чтобы воспользоваться циклами и сравнениями, подготовившись к созданию графики фона.
13. Циклы на практике
---------------------
Содержание:
* Индексированный режим
* Загрузка палитр и спрайтов
* Домашняя работа
Научившись создавать циклы для различных целей, мы можем воспользоваться этим знанием для подчистки уже написанного кода. Использование циклов сделает ассемблерный код более чистым и читаемым, повысит удобство его расширения в будущем.
Чтобы воспользоваться циклами в полной мере, мы соединим изученные в прошлой главе опкоды циклов с новым *режимом адресации*. Когда мы впервые говорили об опкодах в Главе 5, было изучено два режима адресации: *абсолютный* режим (например, `LDA $8001`) и *непосредственный* режим (например, `LDA #$a0`). Теперь мы изучим третий режим адресации: *индексированный*.
Индексированный режим
---------------------
Индексированный режим сочетает фиксированный, абсолютный адрес памяти с переменным содержимым индексного регистра (отсюда и название «индексный регистр»). Для использования индексированного режима адресации записывается адрес памяти, точка, а затем имя регистра.
Показанный выше пример кода получает содержимое адреса памяти (`$8000` + значение регистра X). Если текущее значение регистра X равно `$05`, то команда `LDA $8000,X` получит содержимое адреса памяти `$8005`.
Использование индексированного режима позволяет нам с лёгкостью выполнять действия с диапазоном адресов памяти. Например, вот фрагмент кода, присваивающий 256 байтам памяти с `$3000` по `$30FF` значение `$00`.
Строка 1 присваивает накопителю значение 0 (`#$00`), а затем строка 2 копирует этот ноль в регистр X. Строка 4 сохраняет ноль из накопителя в адрес памяти (`$3000` плюс регистр X), который при первом проходе цикла будет равен `$3000`. В строке 5 выполняется инкремент регистра X, а строка 6 проверяет состояние флага нуля в регистре состояния процессора. Если результат последней операции не был равен нулю, мы возвращаемся к метке в строке 3. Затем выполняется инкремент регистра X с нуля до единицы, результат последней операции равен единице, поэтому флаг нуля не будет установлен и цикл повторится снова. При следующем выполнении цикла в строке 4 ноль из накопителя снова будет сохранён в адрес памяти (`$3000` плюс регистр X), который теперь будет адресом памяти `$3001`. Цикл будет повторяться, пока регистр X не будет равен `$ff`, а инкремент в строке 5 не сменит значение регистра X на `$00`.
Загрузка палитр и спрайтов
--------------------------
Разобравшись с индексированным режимом, давайте используем его для упрощения нашего кода загрузки палитр и спрайтов. В коде из Главы 10 загрузка палитр и спрайтов — это монотонный, повторяющийся и подверженный ошибкам процесс. В основном это вызвано тем, что код тесно связывает *данные* и *логику*. При помощи циклов и индексированной адресации можно отделить данные палитр и спрайтов от кода, передающего эти данные в PPU, что упростит обновление данных, снизив шанс что-то непреднамеренно испортить.
Код загрузки данных палитр из Главы 10 выглядит так:
Давайте отделим значения палитр и сохраним их в какое-нибудь другое место. Здесь значения палитр — это данные только для чтения, поэтому мы будем хранить их в сегменте `RODATA`, а не в текущем сегменте `CODE`. Это будет выглядеть примерно так:
Мы задаём метку (`palettes`), чтобы легко находить начало данных палитр, а затем используем директиву `.byte`, чтобы сообщить ассемблеру «далее следует последовательность простых байтов данных, не пытайся интерпретировать их как опкоды».
Далее нам нужно изменить код записи палитр, чтобы он обходил в цикле данные в `RODATA`. Мы оставим строки 21-26, присваивающие адресу PPU значение `$3f00`, но начиная со строки 27 мы используем цикл:
Вместо того, чтобы прописывать в коде каждое значение палитры, мы загрузим их как «адрес метки `palettes` плюс значение регистра X». Выполняя инкремент регистра X при каждом прохождении цикла (`INX`), мы можем последовательно получать доступ ко всем значениям палитр.
Обратите внимание, что в конце цикла мы выполняем сравнение с `#$04`. Это гарантирует, что цикл выполнится для четырёх, и только четырёх значений. Если задать операнду сравнения какое-то большее значение, то может оказаться, что мы считаем память за пределами того, что мы определили как хранилище палитр, что может привести к непредсказуемым результатам.
Теперь, когда палитры загружаются более чистым образом, давайте обратим внимание на спрайтовые данные. Как и в случае с палитрами, мы можем хранить спрайтовые данные в `RODATA` и считывать их в цикле. Сейчас код загрузки спрайтов выглядит так:
После повторения того же процесса, что и с палитрами, новый код загрузки спрайтов будет выглядеть так:
Этот код слегка отличается от кода загрузки палитр. Обратите внимание, что в строке 40 вместо записи в фиксированный адрес (`PPUDATA`) мы используем индексированный режим для инкремента адреса, в который *будет выполняться запись*, а также адреса, откуда *будет выполняться считывание*.
И ещё один шаг: нам нужно переместить спрайтовые данные в `RODATA`. Вот как выглядят спрайтовые данные в гораздо более читаемом формате «одна строка на спрайт»:
Домашняя работа
---------------
Теперь, когда вы знаете, как использовать циклы и ветвление для повышения читаемости и удобства поддержки ассемблерного кода, настало время попробовать их самостоятельно. Дополните существующий код так, чтобы он загружал четыре полных палитры (с цветами на ваш выбор) и отрисовывал на экране как минимум четыре спрайта. Вам нужно будет изменить данные палитр и спрайтов в `RODATA`, а также изменить счётчики циклов в циклах загрузки палитр и спрайтов. Не забудьте заново ассемблировать файлы исходников и скомпоновать их в новый файл .nes (напоминание о том, как это сделать, см. в конце Главы 8).
Весь код для этой главы можно скачать в [файле zip](https://famicom.party/book/projects/12-practicalloops.zip). | https://habr.com/ru/post/599369/ | null | ru | null |
# Пулы потоков: ускоряем NGINX в 9 и более раз
Как известно, для обработки соединений NGINX использует [асинхронный событийный подход](/post/260065/). Вместо того, чтобы выделять на каждый запрос отдельный поток или процесс (как это делают серверы с традиционной архитектурой), NGINX мультиплексирует обработку множества соединений и запросов в одном рабочем процессе. Для этого применяются сокеты в неблокирующем режиме и такие эффективные методы работы с событиями, как [epoll](http://man7.org/linux/man-pages/man7/epoll.7.html) и [kqueue](https://www.freebsd.org/cgi/man.cgi?query=kqueue).
За счет малого и постоянного количества полновесных потоков обработки (обычно по одному на ядро) достигается экономия памяти, а также ресурсов процессора на переключении контекстов. Все преимущества данного подхода вы можете хорошо наблюдать на примере самого NGINX, который способен обрабатывать миллионы запросов одновременно и хорошо масштабироваться.
*Каждый процесс расходует память и каждое переключение между ними требует дополнительных циклов процессора, а также приводит к вымыванию L-кэшей*
У медали есть и обратная сторона. Главной проблемой асинхронного подхода, а лучше даже сказать «врагом» — являются блокирующие операции. И, к сожалению, многие авторы сторонних модулей, не понимая принципов функционирования NGINX, пытаются выполнять блокирующие операции в своих модулях. Такие операции способны полностью убить производительность NGINX и их следует избегать любой ценой.
Но даже в текущей реализации NGINX не всегда возможно избежать блокировок. И для решения данной проблемы в NGINX версии 1.7.11 был представлен новый механизм «пулов потоков». Что это такое и как его применять разберем далее, а для начала познакомимся с нашим врагом в лицо.
Проблема
--------
Для лучшего понимания проблемы сперва разберемся подробнее в основных моментах относительно того, как работает NGINX.
По принципу работы NGINX из себя представляет такой обработчик событий, контроллер, который получает из ядра информацию обо всех событиях, произошедших в соединениях, а затем отдает команды операционной системе, что же ей делать. Фактически NGINX решает самую сложную задачу по манипулированию ресурсами системы, а операционная система занимается всей рутиной, чтением и отправкой байт информации. Так очень большое значение имеет то, насколько быстро и своевременно рабочий процесс NGINX будет реагировать на события.
*Рабочий процесс получает события из ядра и обрабатывает их.*
Такими событиями могут быть: события таймера, поступление новых данных или отправка ответа и освобождение места в буфере, уведомления об ошибках в соединении или его закрытие. NGINX получает пачку таких событий и начинает их по очереди обрабатывать, выполняя необходимые действия. Так вся обработка очереди событий происходит в простом цикле в одном потоке. NGINX извлекает из очереди события одно за другим и производит какие-то действия, например, пишет в сокет данные или читает. В большинстве случаев это происходит настолько быстро (чаще всего это просто копирования небольших объемов данных в памяти), что можно считать обработку всех событий мгновенной.
*Вся обработка происходит простым циклом в одном потоке.*
Но что произойдет, если попытаться выполнить какую-то долгую и тяжелую операцию? Весь цикл обработки событий остановится на ожидании завершения этой операции.
Так, под блокирующей операцией мы подразумеваем любую операцию, которая задерживает цикл обработки событий на существенное время. Операции можно назвать блокирующими по разным причинам. Например, NGINX может быть занят долгой ресурсоемкой вычислительной операцией, либо он может ожидать доступа к какому-то ресурсу (жесткому диску, мьютексу, библиотечному вызову, ожидающему ответа от базы данных в синхронном режиме, и т. д.). Ключевым моментом тут является то, что во время выполнения этих операций рабочий процесс не может делать более ничего полезного, не может обрабатывать другие события, хотя у нас зачастую есть еще свободные ресурсы, и события, ожидающие далее в очереди, могут их использовать.
Представьте себе продавца в магазине, к которому выстроилась огромная очередь из покупателей. И вот первый человек из очереди подходит к кассе и хочет купить товар, которого нет на витрине, но есть на дальнем складе. Продавец просит подождать пару часов и уезжает на склад за товаром. Можете себе вообразить реакцию остальных покупателей, стоящих в очереди? Теперь их время ожидания увеличилось на эти два часа, хотя для многих то, что им необходимо, лежит в нескольких метрах на прилавке.
*Вся очередь вынуждена ждать исполнения заказа для первого покупателя.*
Похожая ситуация происходит в NGINX, когда файл, который нужно отправить, находится не в памяти, а на жестком диске. Диски медленные (особенно те, что вращаются), а остальные запросы, которые ждут своей обработки в очереди, могут не требовать доступа к жестком диску, но все равно вынуждены ждать. В результате растут задержки и ресурсы системы могут не использоваться полностью.
*Всего одна блокирующая операция может существенно задержать обработку всех последующих.*
Некоторые операционные системы предоставляют интерфейсы для асинхронного чтения файлов и NGINX умеет эффективно использовать их (см. описание директивы [aio](http://nginx.org/r/aio/ru)). Хорошим примером такой системы является FreeBSD. К сожалению, нельзя сказать того же о Linux. Хотя в Linux и существует некий асинхронный интерфейс для чтения файлов, но он обладает рядом существенных недостатков. Одним из таких является требования к выравниванию чтений и буферов. С этим NGINX успешно с справляется, но вторая проблема хуже. Для асинхронного чтения требуется установка флага `O_DIRECT` на файловом дескрипторе. Это означает, что все данные будут читаться с диска минуя кэш страниц операционной системы (т. н. [page cache](https://en.wikipedia.org/wiki/Page_cache)), что во многих случаях не является оптимальным и существенно увеличивает нагрузку на дисковую подсистему.
В частности для решения данной проблемы в NGINX 1.7.11 и был представлен новый механизм пулов потоков. Они пока не включены в NGINX Plus, но вы можете [связаться с отделом продаж](http://nginx.com/contact/), если желаете испытать сборку NGINX Plus R6 с пулами потоков.
А теперь разберем подробнее, что же они из себя представляют и как функционируют.
Пулы потоков
------------
Вернемся к нашему незадачливому продавцу. Но на этот раз он оказался находчивее (или это после того, как его побили разъяренные покупатели?) и организовал курьерскую службу. Теперь, когда покупатель запрашивает товар, которого нет на прилавке, то вместо того, чтобы покидать прилавок, отправляясь за товаром самостоятельно и вынуждая всех остальных ждать, он отправляет запрос на доставку товара в курьерскую службу и продолжает обслуживать очередь покупателей. Таким образом только те покупатели, чьих заказов не оказалось в магазине, ожидают доставки, а продавец тем временем может без проблем обслуживать остальных.
*Обработка заказов курьерской службой не блокирует очередь.*
В случае NGINX роль курьерской службы выполняет пул потоков. Он состоит из очереди заданий и набора отдельных легковесных потоков, которые обрабатывают эту очередь. Когда рабочему процессу требует выполнить какую-то потенциально долгую операцию, то он вместо того, чтобы заниматься этим самостоятельно, помещает задание на обработку в очередь пула, откуда его сразу же может забрать любой свободный поток в обработку.
*Рабочий процесс отдает обработку блокирующих операций в пул потоков.*
Кажется, что тут у нас еще одна очередь образовалась. Так и есть. Но в данном случае эта очередь ограничена конкретным ресурсом. Мы не можем читать с диска быстрее, чем на это способен он сам, но по крайней мере ожидание чтения теперь не задерживает обработку других событий.
Чтение с диска взято, как наиболее частый пример блокирующей операции, но на самом деле пулы потоков в NGINX могут применяться и для любых других задач, которые нерационально выполнять внутри основного рабочего цикла.
В настоящий момент выгрузка операций в пул потоков реализована только для системного вызова read() на большинстве операционных систем, а также для sendfile() на Linux. Мы продолжим исследования данного вопроса и, вероятно, в будущем реализуем выполнение и других операций пулом потоков, если это даст выигрыш в производительности.
Тестируем производительность
----------------------------
Пора перейти от теории к практике. Для демонстрации эффекта от использования пулов потоков проведем небольшой эксперимент. А именно воссоздадим наиболее тяжелые условия, заставив NGINX выполнять смесь блокирующих и неблокирующих чтений, когда проблема блокировок на обращениях к диску проявит себя в полной мере.
Для это требуется набор данных, который гарантированно не поместится в кэш операционной системы. На машине с объемом оперативной памяти в 48 Гб было сгенерировано 256 Гб файлов по 4 Мб каждый, содержащих рандомные данные и запущен NGINX версии 1.9.0 для их раздачи.
Конфигурация достаточно проста:
```
worker_processes 16;
events {
accept_mutex off;
}
http {
include mime.types;
default_type application/octet-stream;
access_log off;
sendfile on;
sendfile_max_chunk 512k;
server {
listen 8000;
location / {
root /storage;
}
}
}
```
Как вы можете заметить, для получения лучших показателей произведен небольшой тюнинг: отключено логирование, отключен [accept\_mutex](http://nginx.org/r/accept_mutex/ru), включен [sendfile](http://nginx.org/r/sendfile/ru) и настроено значение [sendfile\_max\_chunk](http://nginx.org/r/sendfile_max_chunk/ru). Последнее позволяет сократить время блокировки на вызове `sendfile()`, поскольку в этом случае NGINX не станет пытаться прочесть и отправить весь файл за раз, а будет это делать частями по 512 килобайт.
Машина снабжена двумя процессорами Intel Xeon E5645 (всего 12 ядер, 24 HyperThreading потока) и сетевым интерфейсом 10 ГБит. Дисковая подсистема представляет из себя 4 жестких диска Western Digital WD1003FBYX объединенных в RAID10 массив. Все это управляется операционной системой Ubuntu Server 14.04.1 LTS.
*Конфигурация тестового стенда.*
В качестве клиентов выступают две аналогичные по характеристикам машины. На одной из них запущен [wrk](https://github.com/wg/wrk), создающий постоянную нагрузку Lua-скриптом. Скрипт запрашивает файлы из хранилища в случайном порядке используя 200 параллельных соединений. Назовем данную нагрузку паразитной.
С другой машины-клиента мы будем запускать `wrk`, который будет запрашивать один и тот же файл в 50 потоков. Поскольку к данному файлу идет постоянное обращение, то, в отличие от файлов, запрашиваемых в случайном порядке, он не будет успевать вымываться из кэша операционной системы и его чтение всегда будет происходить из памяти. Назовем такую нагрузку тестовой.
Производительность мы будем измерять по показателям `ifstat` на сервере и статистике `wrk` со второй машины-клиента.
Итак, первый запуск без использования пулов потоков показывает очень скромные результаты:
```
% ifstat -bi eth2
eth2
Kbps in Kbps out
5531.24 1.03e+06
4855.23 812922.7
5994.66 1.07e+06
5476.27 981529.3
6353.62 1.12e+06
5166.17 892770.3
5522.81 978540.8
6208.10 985466.7
6370.79 1.12e+06
6123.33 1.07e+06
```
Как видно с данной конфигурацией и под такой нагрузкой сервер способен выдавать порядка одного гигабита в секунду. При этом в top-е можно наблюдать, что все рабочие процессы NGINX находятся большую часть времени в состоянии блокировки на I/O (помечены буквой `D`):
```
top - 10:40:47 up 11 days, 1:32, 1 user, load average: 49.61, 45.77 62.89
Tasks: 375 total, 2 running, 373 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.3 sy, 0.0 ni, 67.7 id, 31.9 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem: 49453440 total, 49149308 used, 304132 free, 98780 buffers
KiB Swap: 10474236 total, 20124 used, 10454112 free, 46903412 cached Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
4639 vbart 20 0 47180 28152 496 D 0.7 0.1 0:00.17 nginx
4632 vbart 20 0 47180 28196 536 D 0.3 0.1 0:00.11 nginx
4633 vbart 20 0 47180 28324 540 D 0.3 0.1 0:00.11 nginx
4635 vbart 20 0 47180 28136 480 D 0.3 0.1 0:00.12 nginx
4636 vbart 20 0 47180 28208 536 D 0.3 0.1 0:00.14 nginx
4637 vbart 20 0 47180 28208 536 D 0.3 0.1 0:00.10 nginx
4638 vbart 20 0 47180 28204 536 D 0.3 0.1 0:00.12 nginx
4640 vbart 20 0 47180 28324 540 D 0.3 0.1 0:00.13 nginx
4641 vbart 20 0 47180 28324 540 D 0.3 0.1 0:00.13 nginx
4642 vbart 20 0 47180 28208 536 D 0.3 0.1 0:00.11 nginx
4643 vbart 20 0 47180 28276 536 D 0.3 0.1 0:00.29 nginx
4644 vbart 20 0 47180 28204 536 D 0.3 0.1 0:00.11 nginx
4645 vbart 20 0 47180 28204 536 D 0.3 0.1 0:00.17 nginx
4646 vbart 20 0 47180 28204 536 D 0.3 0.1 0:00.12 nginx
4647 vbart 20 0 47180 28208 532 D 0.3 0.1 0:00.17 nginx
4631 vbart 20 0 47180 756 252 S 0.0 0.1 0:00.00 nginx
4634 vbart 20 0 47180 28208 536 D 0.0 0.1 0:00.11 nginx
4648 vbart 20 0 25232 1956 1160 R 0.0 0.0 0:00.08 top
25921 vbart 20 0 121956 2232 1056 S 0.0 0.0 0:01.97 sshd
25923 vbart 20 0 40304 4160 2208 S 0.0 0.0 0:00.53 zsh
```
В данном случае все упирается в производительность дисковой подсистемы, при этом процессор большую часть времени простаивает. Результаты `wrk` также неутешительны:
```
Running 1m test @ http://192.0.2.1:8000/1/1/1
12 threads and 50 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 7.42s 5.31s 24.41s 74.73%
Req/Sec 0.15 0.36 1.00 84.62%
488 requests in 1.01m, 2.01GB read
Requests/sec: 8.08
Transfer/sec: 34.07MB
```
Достаточно существенные задержки даже на раздаче всего одного файла из памяти. Все рабочие процессы заняты чтением с диска для обслуживания 200 соединений с первой машины, создающей паразитную нагрузку, и не могут своевременно обработать данные тестовые запросы.
А теперь подключим пул потоков, для чего добавим директиву `aio threads` в блок `location` с хранилищем:
```
location / {
root /storage;
aio threads;
}
```
и попросим наш NGINX перезагрузить конфигурацию.
Повторим тест:
```
% ifstat -bi eth2
eth2
Kbps in Kbps out
60915.19 9.51e+06
59978.89 9.51e+06
60122.38 9.51e+06
61179.06 9.51e+06
61798.40 9.51e+06
57072.97 9.50e+06
56072.61 9.51e+06
61279.63 9.51e+06
61243.54 9.51e+06
59632.50 9.50e+06
```
Теперь наш сервер выдает 9,5 ГБит/сек (против ~1 ГБит/сек без пулов потоков)!
Вероятно он мог бы отдавать и больше, но это является практическим пределом для данного сетевого интерфейса и NGINX упирается в пропускную способность сети. Рабочие процессы большую часть времени спят в ожидании событий (находятся в состоянии `S`):
```
top - 10:43:17 up 11 days, 1:35, 1 user, load average: 172.71, 93.84, 77.90
Tasks: 376 total, 1 running, 375 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.2 us, 1.2 sy, 0.0 ni, 34.8 id, 61.5 wa, 0.0 hi, 2.3 si, 0.0 st
KiB Mem: 49453440 total, 49096836 used, 356604 free, 97236 buffers
KiB Swap: 10474236 total, 22860 used, 10451376 free, 46836580 cached Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
4654 vbart 20 0 309708 28844 596 S 9.0 0.1 0:08.65 nginx
4660 vbart 20 0 309748 28920 596 S 6.6 0.1 0:14.82 nginx
4658 vbart 20 0 309452 28424 520 S 4.3 0.1 0:01.40 nginx
4663 vbart 20 0 309452 28476 572 S 4.3 0.1 0:01.32 nginx
4667 vbart 20 0 309584 28712 588 S 3.7 0.1 0:05.19 nginx
4656 vbart 20 0 309452 28476 572 S 3.3 0.1 0:01.84 nginx
4664 vbart 20 0 309452 28428 524 S 3.3 0.1 0:01.29 nginx
4652 vbart 20 0 309452 28476 572 S 3.0 0.1 0:01.46 nginx
4662 vbart 20 0 309552 28700 596 S 2.7 0.1 0:05.92 nginx
4661 vbart 20 0 309464 28636 596 S 2.3 0.1 0:01.59 nginx
4653 vbart 20 0 309452 28476 572 S 1.7 0.1 0:01.70 nginx
4666 vbart 20 0 309452 28428 524 S 1.3 0.1 0:01.63 nginx
4657 vbart 20 0 309584 28696 592 S 1.0 0.1 0:00.64 nginx
4655 vbart 20 0 30958 28476 572 S 0.7 0.1 0:02.81 nginx
4659 vbart 20 0 309452 28468 564 S 0.3 0.1 0:01.20 nginx
4665 vbart 20 0 309452 28476 572 S 0.3 0.1 0:00.71 nginx
5180 vbart 20 0 25232 1952 1156 R 0.0 0.0 0:00.45 top
4651 vbart 20 0 20032 752 252 S 0.0 0.0 0:00.00 nginx
25921 vbart 20 0 121956 2176 1000 S 0.0 0.0 0:01.98 sshd
25923 vbart 20 0 40304 3840 2208 S 0.0 0.0 0:00.54 zsh
```
И у нас еще есть солидный запас по ресурсам процессора.
Результаты `wrk` со второй машины:
```
Running 1m test @ http://192.0.2.1:8000/1/1/1
12 threads and 50 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 226.32ms 392.76ms 1.72s 93.48%
Req/Sec 20.02 10.84 59.00 65.91%
15045 requests in 1.00m, 58.86GB read
Requests/sec: 250.57
Transfer/sec: 0.98GB
```
Среднее время отдачи 4 Мб файла сократилось с 7.42 секунд до 226.32 миллисекунд, т.е. в ~33 раза, а количество обрабатываемых запросов в секунду возросло в 31 раз (250 против 8)!
Объясняется все это тем, что теперь запросы более не ждут в очереди на обработку, пока рабочие процессы заблокированы на чтении с диска, а обслуживаются свободными потоками. И пока дисковая подсистема делает свою работу как может, обслуживая наш “паразитный” трафик с первой машины, NGINX использует оставшиеся ресурсы процессора и пропускную способность сети, чтобы обслужить второго клиента из памяти.
Серебряной пули не существует
-----------------------------
После всех страшилок про блокирующие операции и таких потрясающих результатов, многие из вас захотят скорее включит пулы потоков на своих серверах. Не спешите.
Правда в том, что, к счастью, в большинстве случаев операции с файлами не приводят к чтению с медленного жесткого диска. Если у вас хватает оперативной памяти, то современные операционные системы достаточно умны, чтобы закэшировать файлы, к которым часто происходит обращение в так называемом кэше страниц (page cache).
Кэш страниц справляется достаточно хорошо и это всегда позволяло NGINX демонстрировать высокую производительность в наиболее распространенных ситуациях. Чтения из кэша страниц происходят очень быстро и такую операцию нельзя назвать блокирующей. В то же время, взаимодействие с пулом потоков несет дополнительные издержки на синхронизацию.
Так что если у вас достаточно оперативной памяти и небольшой объем горячих данных, то у вас уже все хорошо и NGINX работает наиболее оптимальным образом без использования пулов потоков.
В действительности выгрузка операций чтения в отдельный пул потоков решает довольно узкий спектр задач. Он ограничен ситуациями, когда объем регулярно запрашиваемых данных не помещается в оперативной памяти, что делает кэш страниц операционной системы неэффективным. Таким примером может являться высоконагруженный сервис раздачи медиаданных. Данную ситуацию мы и симулировали в нашем тесте.
Выгрузку операций чтения в пулы потоков можно было бы сделать более универсальной для операций чтения и снизить задержки, если бы существовал эффективный способ узнать заранее, находятся ли необходимые данные в памяти или нет, и только в последнем случае выгружать операцию в отдельный поток.
Возвращаясь к аналогии с магазином и дальним складом, сейчас у продавца нет возможности узнать, что товар находится на витрине и он вынужден всегда работать посредством курьерской службы.
Дело в том, что отсутствует соответствующая поддержка со стороны ядра операционной системы. Первые попытки добавить такую возможность в Linux в виде системного вызова [fincore()](https://lwn.net/Articles/371538/) относятся к 2010 году, но «воз и ныне там». Позже были попытки в виде системного вызова `preadv2()` и флага `RWF_NONBLOCK` (подробности можно узнать из статей [Non-blocking buffered file read operations](https://lwn.net/Articles/612483/) и [Asynchronous buffered read operations](https://lwn.net/Articles/636967/) на LWN.net) — но судьба и этих патчей по прежнему под вопросом. Печально, что виной всему этому похоже является пресловутый [байкшединг](http://bikeshed.com/) (споры о том, какого цвета фломастеры лучше пахнут).
В то время, как пользователям FreeBSD не о чем беспокоиться, у них есть неплохо работающий механизм асинхронного чтения, реализованный в ядре. Именно его и рекомендуется использовать вместо пулов потоков.
Конфигурация
------------
Итак, если вы твердо уверены, что сможете извлечь выгоду из пула потоков для ваших задач, то непременно встает вопрос, как его включить и настроить.
Конфигурация достаточно простая и вместе с тем очень гибкая. Для начала вам потребуется NGINX версии 1.7.11 или выше, собранный с флагом `--with-threads`. В простейшим случае настройка выглядит элементарно. Все, что необходимо для включения выгрузки операций чтения и отправки файлов в пул потоков, это директива `aio` на уровне `http`, `server` или `location`, установленная в значение threads:
```
aio threads;
```
Это минимально возможный вариант настройки пулов потоков. На самом деле он является сокращенной версией такой конфигурации:
```
thread_pool default threads=32 max_queue=65536;
aio threads=default;
```
Она задает пул потоков `default`, в котором будут работать 32 потока и максимально допустимый размер очереди заданий составляет 65536. Если очередь заданий переполняется, то NGINX отклоняет запрос и логирует ошибку:
```
thread pool "NAME" queue overflow: N tasks waiting
```
Такое возможно, если ваши потоки не справляются с объемом работы и очередь заполняется быстрее, чем обрабатывается. В этом случае вы можете попробовать увеличить максимальной размер очереди и если это не помогает, то значит ваша система просто не в состоянии обработать такое большое количество запросов.
Как можно заметить, с помощью директивы [thread\_pool](http://nginx.org/r/thread_pool/ru) у вас есть возможность задавать количество потоков, максимальный размер очереди, а также имя данного пула потоков. Последнее предполагает возможность сконфигурировать несколько независимых пулов и использовать их в разных частях конфигурации для разных задач:
```
thread_pool one threads=128 max_queue=0;
thread_pool two threads=32;
http {
server {
location /one {
aio threads=one;
}
location /two {
aio threads=two;
}
}
…
}
```
Если параметр `max_queue` не указан явно, как в пуле two, то используется значение по умолчанию, равное 65536. Как видно из примера, можно задать нулевой размер очереди. Тогда пул сможет одновременно принимать в обработку только такое количество заданий, сколько у него имеется свободных потоков и не будет ожидающих в очереди заданий.
А теперь представьте, что у вас есть сервер с тремя жесткими дисками, который должен выполнять роль кеширующего прокси для ваших бэкендов. При этом предполагаемый размер кэша многократно превосходит объем доступной оперативной памяти. По сути это что-то вроде кэш-ноды в вашей личной сети раздачи контента (CDN). В этом случае основная нагрузка по отдачи кэшированных данных будет ложиться на дисковую подсистему. Разумеется вы хотите извлечь максимум производительности из тех трех дисков, что имеются в наличии.
Одним из решений тут может стать организация RAID массива. У такого подхода конечно же есть свои плюсы и минусы. Но сегодня NGINX готов предложить вам другой подход:
```
# В нашей системе каждый из жестких дисков примонтирован в одну из следующих директорий:
# /mnt/disk1, /mnt/disk2 или /mnt/disk3 соответственно
thread_pool pool_1 threads=16;
thread_pool pool_2 threads=16;
thread_pool pool_3 threads=16;
http {
proxy_cache_path /mnt/disk1 levels=1:2 keys_zone=cache_1:256m max_size=1024G use_temp_path=off;
proxy_cache_path /mnt/disk2 levels=1:2 keys_zone=cache_2:256m max_size=1024G use_temp_path=off;
proxy_cache_path /mnt/disk3 levels=1:2 keys_zone=cache_3:256m max_size=1024G use_temp_path=off;
split_clients $request_uri $disk {
33.3% 1;
33.3% 2;
* 3;
}
server {
…
location / {
proxy_pass http://backend;
proxy_cache_key $request_uri;
proxy_cache cache_$disk;
aio threads=pool_$disk;
sendfile on;
}
}
}
```
В данной конфигурации используется три независимых кэша — по одному на каждый жесткий диск, и три независимых пула потоков, также по одному на диск.
Для равномерного распределения нагрузки между кэшами (а соответственно и жесткими дисками) используется модуль [split\_clients](http://nginx.org/ru/docs/http/ngx_http_split_clients_module.html), который прекрасно для этого подходит.
Параметр `use_temp_path=off` у директивы [proxy\_cache\_path](http://nginx.org/r/proxy_cache_path) инструктирует NGINX сохранять временные файлы в той же директории, где находятся данные кэша. Это необходимо во избежание копирования данных с одного диска на другой при сохранении ответа в кэш.
Все это вместе позволяет выжать максимум производительности из данной дисковой подсистемы, поскольку NGINX посредством отдельных пулов потоков взаимодействует с каждым диском параллельно и независимо. Каждый диск обслуживают 16 независимых потоков и для него формируется отдельная очередь заданий на чтение и отправку файлов.
Ведь ваши клиенты любят индивидуальных подход? Будьте уверены ваши жесткие диски тоже. ;)
Данный пример является демонстрацией огромной гибкости NGINX в конфигурировании непосредственно под ваше железо. Вы как бы инструктируете NGINX, каким образом лучше всего взаимодействовать с дисковой подсистемой на данном сервере и вашими данными. И такая тонкая настройка, когда программное обеспечение вплоть до пользовательского уровня работает с оборудованием самым оптимальным образом, обеспечивает наиболее эффективное использование всех ресурсов конкретной системы.
Выводы
------
Пулы потоков — это замечательный механизм, который борется с основным и хорошо известным врагом асинхронного подхода — блокирующими операциями, и тем самым позволяет вывести NGINX на новый уровень производительности, особенно если мы говорим об очень больших объемах данных.
Как уже упоминалось ранее, пулы потоков могут быть использованы и для любых других операций и работы с библиотеками, не имеющими асинхронного интерфейса. Потенциально это открывает новые возможности для реализации модулей и функциональности, реализация которой без ущерба для производительности ранее была неосуществимой в разумные сроки. Можно потратить много усилий и времени на написание асинхронного варианта имеющийся библиотеки или в попытках добавить такой интерфейс, но возникал вопрос: «стоит ли игра свеч»? С пулами потоков данную задачу можно решить гораздо проще, создавая модули, работающие с блокирующими вызовами, и при этом не мешая NGINX выполнять свою основную задачу обрабатывая остальные запросы.
Так что много нового и интересного ждет NGINX в будущем. Оставайтесь с нами! | https://habr.com/ru/post/260669/ | null | ru | null |
# Автоматическая авторизация на карте Strava Heatmap
Данный пост является ответом на недавнюю [аналогичную статью](https://habr.com/ru/post/450124/). Попробую рассказать, как можно автоматизировать описанные в ней действия. И как подключить эту тепловую карту к навигатору смартфона.
В статье рассматривалось, чем полезны карты Strava Heatmap для туристов и велосипедистов и о том, как подключить к ним навигационное приложение на смартфоне на примере Osmand. Дело в том, что для загрузки каждого кусочка карты нужно указывать параметры с авторизационными данными. Примерно так:
```
GET https://heatmap-external-{abc}.strava.com/tiles-auth/all/hot/{z}/{x}/{y}.png?px=256&Signature={CloudFront-Signature}&Key-Pair-Id={CloudFront-Key-Pair-Id}&Policy={CloudFront-Policy}
```
Чтобы получить эти данные, предлагалось авторизироваться на сайте Strava с десктопного браузера. Как результат, в браузере должны появиться cookie файлы. Нужно найти в них требуемые строки и скопировать их в адрес запроса. А затем, вручную ввести запрос в Osmand, чтобы он смог скачивать с его помощью карту.
Однако этот способ он не очень удобен, ведь авторизационные данные быстро устаревают и приходится раз в несколько дней повторять вышеописанные действия. В этой статье я расскажу, как можно автоматизировать вышеописанный метод.
### Добавляем промежуточное звено
Чтобы пользователю не приходилось заменять в смартфоне URL запроса каждый раз, когда cookie-данные устаревают, нужно указать какой-нибудь неизменный URL. Я указал ссылку на свое серверное приложение. Это приложение будет редиректить пользователя на различные адреса в зависимости от указанных параметров.
```
https://anygis.herokuapp.com/Tracks_Strava_All/{x}/{y}/{z}
```
Чтобы быстрее перейти к сути, я не буду подробно останавливаться на описании этого серверного приложения. Расскажу лишь об основных его действиях.
Если запрашивается тайл с зумом до 12 (такие Stava отдает без авторизации), то пользователь сразу перенаправляется на публичный URL.
```
https://heatmap-external-a.strava.com/tiles/all/hot/10/619/318.png
```
Если же нет, то выполняется проверка. Для быстрого доступа приложение хранит в своей базе данных последнюю рабочую версию файла cookie. Когда оно получает запрос, оно парсит этот файл и создает URL со всеми подставленными параметрами.
**Получается что-то вроде этого**
```
https://heatmap-external-a.strava.com/tiles-auth/all/hot/10/619/318.png?px=256**&Signature**=Q47FWl1RX-5tLNK9fGfa7hdoxqwwjCLfrxwb~L3eke8h~glz5IBHmkLmu8ofh6eNWUM3usHTz4Z3rypbQGByC2jRhdzL2iJndIOu2TY9ZU34YUJV9QgMEf0L5cDHGjEsksYSVdkCqNRvOMnnzUc96wR9sktK2a0pcsI~E5eNvqjfsGbSWi6KCdfc1-~2D8t9YjbKftokhvMY20pM~PD6Y-fGYmpoTO5LOyMfIYboXnKGm29VnA9kA8LIxD-LzpADWO81i4pOMBvkVkJuLBGtO96a79P5D4tRP05DpI7y457LuKcuqRZaVQRB1L2AXgKvQgnx6nqr9T2jRAZNoy06ng__
**&Key-Pair-Id**=APKAIDPUN4QMG7VUQPSA
**&Policy**=eyJTdGF0ZW1lbnQiOiBbeyJSZXNvdXJjZSI6Imh0dHBzOi8vaGVhdG1hcC1leHRlcm5hbC0qLnN0cmF2YS5jb20vKiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTU1ODUwODc2Mn0sIkRhdGVHcmVhdGVyVGhhbiI6eyJBV1M6RXBvY2hUaW1lIjoxNTU3Mjg0NzYyfX19XX0_
```
После этого оно отправляет HEAD запрос на этот адрес, чтобы проверить, доступен он или нет. Если в ответ приходит статус код “200 Success”, значит cookie все еще рабочие. Приложение просто редиректит пользователя на этот адрес и у него прекрасно загружается карта.
А вот если приходит код “401 Unauthorized”, то значит cookie устарели и нужно заново их получить. В этом случае приложение запускает скрипт для получение авторизационных данных.
### Автоматическая авторизация
Первая мысль, которая приходит в голову, это пройти авторизацию с помощью Strava API. Увы, но мне так и не удалось вытянуть оттуда нужные параметры. Так что я решил пойти обходным путем.
Для этого я воспользовался браузером с дистанционным управлением Headless Chrome и написал для него скрипт, чтобы он “физически” загрузил странницу авторизации, ввел туда логин и пароль, а затем кликнул на кнопку.
Для этого существует библиотека Puppeteer, которая умеет управлять браузером с помощью Node.js скриптов. Синтаксис отлично описан в [этой статье](https://habr.com/ru/company/ruvds/blog/341348/). Предлагаю ознакомиться с ней самостоятельно.
После ее прочтения остается лишь вопрос, на чем запускать наши скрипты. Если вы уже опытный Node.js разработчик, то можете пропустить этот раздел. Для остальных могу предложить воспользоваться готовым сервисом от [Apify.com](https://apify.com/). Это избавит нас от необходимости создавать и настраивать свой сервер. Для наших задач вполне хватит бесплатного аккаунта.
**Настройки аккаунта Apify для запуска скрипта**Для начала вам потребуется зарегистрироваться на этом сервисе. После этого откройте радел со своим аккаунтом, перейдите в раздел Actors и создайте новый скрипт.
В поле Name укажите название, которое будет использоваться при запуске скрипта через Api. Нажмите Save и перейдите на страницу Source.
Для запуска Headless Chrome выберите образ сервера “Node.js 10 + Chrome on Debian” и нажмите Save.
Теперь перейдем в раздел Api и скопируем URL POST-запроса, с помощью которого мы будем запускать наш скрипт.
В тело этого запроса можно прикреплять JSON с данными для нашего скрипта. Я буду отправлять туда свой логин и пароль для авторизации на Strava.
```
{ "email": "your_nick@gmail.com" , "password": "Your_Password" }
```
**Скрипт для автоматического получения cookie данных со Strava**Теперь вернемся в раздел Source и перейдем в окошко с редактором кода. Наш скрипт будет выглядеть так:
```
const Apify = require('apify');
Apify.main(async () => {
// ПОДГОТОВКА
// Извлечь параметры из принятого JSON
const input = await Apify.getInput();
if (!input || !input.email || !input.password) throw new Error('Invalid input, must be a JSON object with the "email" and "password" field!');
// Запустить среду управления браузером
const browser = await Apify.launchPuppeteer();
// СТРАНИЦА 1 - Получаем базовую часть cookie
// Открыть новую вкладку
const page1 = await browser.newPage();
await page1.setViewport({width: 1280, height: 1024});
// Перейти на страницу авторизации
await page1.goto('https://www.strava.com/login', {waitUntil: 'networkidle2'});
// Найти на html-странице поля логин/пароль и заполнить их
await page1.waitForSelector('form');
await page1.type('input#email', input.email);
await page1.type('input#password', input.password);
// Немного подождать, чтобы выглядеть,
// как настоящий человек, которому требуется время на ввод данных
await page1.waitFor(200);
// Найти кнопку Войти и кликнуть на нее
await page1.evaluate(()=>document
.querySelector('button#login-button')
.click()
);
// Дождаться результатов и загрузить базовый cookie файл
await page1.waitForNavigation();
const sessionFourCookie = await page1.cookies();
// СТРАНИЦА 2 - получаем дополненный cookie с ключами для просмотра карты
// Открыть новую вкладку
const page2 = await browser.newPage();
// Перейти на страницу с просомотром карты, как залогиненный пользователь.
// То есть, указав при этом полученные в предыдущем шаге cookie
await page2.setCookie(...sessionFourCookie);
await page2.goto('https://heatmap-external-a.strava.com/auth');
// Получить новый дополненный файл cookie
const cloudfontCookie = await page2.cookies();
// ЗАВЕРШЕНИЕ
// Закрыть среду исполнения
await browser.close();
// Вернуть дополненный файл cookie в теле ответа
return cloudfontCookie;
});
```
Или же вот [ссылка](https://github.com/nnngrach/strava_auto_auth) на GitHub с этим скриптом.
### Финальный этап
Когда скрипт отработает, он вернет файл cookie с авторизационными данными. Серверное приложение сохранит его в свою базу данных и будет использовать для всех последующих запросов карты Strava. До тех пор, пока cookie не устареют и не потребуется еще раз повторить эту процедуру. Благо, теперь все происходит автоматически. Без лишних действий со стороны пользователя.
Увы, но не все так гладко. У этого метода есть слабое место – это скорость работы. Дело в том, что на запуск сервера, загрузку удаленного браузера, загрузку двух веб страниц и на авторизацию на каждой из них требуется некоторое время. По моим прикидкам, выходит более минуты.
За это время навигационное приложение попросту оборвет загрузку из-за превышения тайм-аута. Поэтому лучше сразу вернуть пользователь код ошибки 401, чтобы лишний раз не высаживать ему батарею.
Для этого серверное приложение будет устанавливать флаг, когда поймет, что cookie данные устарели. После этого этого оно отправит запрос на запуск скрипта, а пользователям будет сразу возвращать код ошибки. Иными словами, на протяжении минуты сервер будет недоступен.
И вот когда от нашего скрипта придет ответ с новыми cookie, приложение сохранит их в свою базу данных и снимет флаг. После этого сервер снова начнет работать в штатном режиме и моментально перенаправлять пользователя на страницы для скачивания карты.
### Результат
Результатом наших трудов стали неизменяющиеся URL-адреса, с помощью которых пользователи могут подключать свой навигатор к картам Strava.
```
https://anygis.ru/api/v1/Tracks_Strava_All/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Ride/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Run/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Water/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Winter/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_All_Bluered/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Ride_Bluered/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Run_Bluered/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Water_Bluered/{x}/{y}/{z}
https://anygis.ru/api/v1/Tracks_Strava_Winter_Bluered/{x}/{y}/{z}
```
Как вариант, можно сделать готовые пресеты с этими адресами для своего навигатора. Например, [на этой станице](https://nnngrach.github.io/AnyGIS_maps/Web/Html/DownloadPage_ru) я выложил такие пресеты в форматах для Osmand, Locus, GuruMaps и Orux. Ссылки на скачивание карты Strava находятся в разделе “Полный набор” в подразделах “Overlay” или “Глобальные — OSM – Ways”.
UDP: За время прошедшее с момента публикации статьи я добавил вариант этого скрипта, работающий через Docker контейнер. Инструкцию можно найти на моей страничке на [GitHub](https://github.com/nnngrach/strava_auto_auth). | https://habr.com/ru/post/451620/ | null | ru | null |
# OSINT в Telegram
[Протокол](https://core.telegram.org/api) Telegram известен своей доступностью и открытостью. У него есть множество публичных реализаций: [tdlib/td](https://github.com/tdlib/td), [rubenlagus/TelegramApi](https://github.com/rubenlagus/TelegramApi), [vysheng/tg](https://github.com/vysheng/tg), [LonamiWebs/Telethon](https://github.com/LonamiWebs/Telethon) и другие. Однако, даже имея в распоряжении столь богатый инструментарий и объемную документацию (<https://core.telegram.org/api>), решить прикладную задачу, собрав из многообразия методов API нужную цепочку – не так-то просто. Сможет, например, “неподготовленный ум“ сходу догадаться, как решить прикладную задачу а-ля “поиск по номеру в Telegram“? — Скорее всего, придется потратить какое-то время на изучение API.
Официальный клиент Telegram содержит в себе массу API-цепочек, реализующих определенные пользовательские сценарии. Если подумать, взаимодействие на основе сценариев — наиболее удобный и предпочтительный способ, поэтому мы решили пойти по пути упрощения взаимодействия с Telegram на основе реализации библиотеки сценариев. Так как наша деятельность тесно связана с направлением [OSINT](https://ru.wikipedia.org/wiki/OSINT), то в первую очередь мы решили реализовать ряд OSINT-сценариев, применимых в сети Telegram, о которых и хотим рассказать в этой статье.
Для решения задач OSINT мы еще давно начали работу над собственным клиентом для сети Telegram, который в последствии трансформировался в расширяемую библиотеку сценариев — [telegram-osint-lib](https://github.com/Postuf/telegram-osint-lib).
Почему пришлось делать собственный клиент?
------------------------------------------
Мы [разрабатываем](https://postuf.com/projects) программные системы для сбора данных из открытых источников. Об одном из наших сервисов — [Nuga](http://nuga.app/) — мы уже как-то [рассказывали](https://habr.com/ru/company/postuf/blog/479094/) ранее.
Здесь и далее под “клиентом” подразумевается не графическое приложение, а “бот” (не путать с внутренним [функционалом](https://core.telegram.org/bots) Telegram), управляемый из консоли, который решает определенную прикладную задачу в рамках сети Telegram с помощью предоставляемого API.
На момент первичной реализации клиента (~конец 2018 года) сторонние библиотеки-клиенты Telegram, которые мы рассматривали, обновлялись нерегулярно и не соответствовали требованиям из [документации по протоколу](https://core.telegram.org/methods), которая обновлялась с большой задержкой (полгода и более), как и официальные клиенты.
Часто в новоиспеченных версиях официальных клиентов можно было наблюдать кардинальные отличия от официальной документации, что сеяло зерна конспирологических сомнений. Например, [API Layer 105](https://core.telegram.org/schema) (выпущенный с огромным скачком от последней версии 23) наконец-то рассказал нам об опциональных полях и всех недостающих типах данных, устранив тем самым все подозрения на гипотетические закладки. Сейчас с этим стало лучше, документация обновлена, хотя некоторые детали все равно приходится определять экспериментально.
Сценарийная направленность
--------------------------
Занимаясь достаточно долгое время развитием собственного клиента, клиент оброс множеством оберток над группами API-вызовов. Стало понятно, что как простой набор API вызовов к Telegram он нас не особо интересует — в пределах сети Telegram гораздо интереснее выполнять комплексные операции, задействующие сразу множество API-вызовов. Таким образом был осуществлен переход от API-направленности к сценарийной направленности клиента.
Сценарий в [telegram-osint-lib](https://github.com/Postuf/telegram-osint-lib) – это “черный ящик”, реализованный в виде последовательности API-вызовов, позволяющей достичь определенной конечной цели (output) на основе входных параметров (input). Аргументы представляют из себя понятные сущности окружающего мира (например, ключевое слово для поиска). В результате использования аргументов внутри черного ящика на выходе получается запрошенная информация (например, сообщения с указанным ключевым словом). Вся рутина по взаимодействию с API Telegram при этом инкапсулирована в реализации сценария. Сценарии могут сочетаться друг с другом, формируя более комплексные сценарии.
Концепция сценария была разработана в процессе решения задач внутри компании, однако, схожие понятия встречаются много где, например, в литературе по анализу требований — [Scenario-based modeling and its applications](https://ieeexplore.ieee.org/document/1000060) — т.е идея “scenario-based“ сама по себе, конечно же, не нова.
Детали реализации
-----------------
Библиотека [telegram-osint-lib](https://github.com/Postuf/telegram-osint-lib) реализована по асинхронной модели и рассчитана на поддержку нескольких одновременных соединений ([пример](https://github.com/Postuf/telegram-osint-lib/blob/master/examples/runMultiClient.php)). Изначально при реализации мы следовали следующим принципам:
* **fail fast**: при работе с проприетарным протоколом (пусть и имеющим более-менее открытую документацию) необходимо реагировать на изменения оперативно
* **conformity**: библиотечная реализация максимально соответствует существующим клиентам и учитывает ограничения, заложенные в протокол
* **testability**: код должен быть доступен для тестирования, а именно: быть декомпозирован, иметь низкую связность
На этапе дизайна архитектуры библиотеки, были выделены следующие уровни абстракции (от низкого к высокому):
1. [Уровень Telegram API](https://github.com/Postuf/telegram-osint-lib/tree/master/src/TLMessage/TLMessage) ([TL nodes](https://core.telegram.org/mtproto/TL));
2. [Уровень клиента](https://github.com/Postuf/telegram-osint-lib/tree/master/src/Client), содержащего набор нужных методов API для выполнения класса операций
3. [Уровень сценария](https://github.com/Postuf/telegram-osint-lib/tree/master/src/Scenario), комбинируемого с соседями по уровню
4. [Уровень интерфейса](https://github.com/Postuf/telegram-osint-lib/tree/master/examples) пользователя (скрипт, вызывающий сценарии)
Так как клиент реализован по асинхронной модели, каждый вызов возвращает результат не напрямую, а через callback. Такой подход к реализации позволяет обрабатывать асинхронные ответы (что предусмотрено протоколом Telegram) и держать в одном потоке множество соединений.
### Поддержка мультиверсионности схемы данных
Как известно, Telegram протокол [описан](https://core.telegram.org/schema) в виде схемы на языке TL. Однако, на той же странице, мы можем получить схему и в формате JSON (которая на практике оказывается более применимой). В схеме два основных блока: `constructors` и `methods`. Первый описывает структуры данных, которые принимает на вход или возвращает Telegram сервер, а второй — описание методов: спецификацию типов входных параметров и тип ответа.
Несмотря на то, что сейчас протокол на сайте регулярно обновляется (в процессе написания статьи вышла новая версия TL-Schema 108, а за ней и 109), наблюдать за дельтой изменений между версиями по прежнему необходимо, для чего используется небольшой [сниппет](https://github.com/Postuf/telegram-osint-lib/commit/d81162b526939f274d6114ba42dfa5a7f22f49ea#diff-11358de2c80817ac99305df26687df34), принимающий на вход два json файла и выдающий на выходе конструкторы/методы, которые есть во втором файле, но нет в первом. На текущий момент в официальном API описано более 1100 дескрипторов (конструкторов/методов). Пользуясь такой json схемой нетрудно составить или декодировать любое сообщение.
Поддержка клиента, поддерживающего разные версии протокола, требует определенных плясок с бубном: недостаточно просто взять последнюю версию схемы с сайта. Надо поддерживать еще и старые сообщения (в обновлениях протокола бывает как удаление, так и модификация сообщений). Поэтому в нашей спецификации каждый слой (layer) мы сохраняем отдельно, чтобы прослеживать историю обновлений и чтобы бот-клиент, у которого, например, накопилась очередь сообщений на стороне сервера по старой версии протокола, мог корректно их обработать.
OSINT на примере некоторых сценариев
------------------------------------
Большинство описанных ниже сценариев появилось в ходе покрытия внутренних нужд, однако некоторые сценарии были реализованы спонтанно в связи с обнаружением интересных функций протокола и его неочевидных мест, не реализованных либо глубоко скрытых в официальных клиентах.
Пойдем от простого к сложному и попробуем разобрать некоторые из существующих сценариев на примере реальных кейсов. Для более удобного взаимодействия со сценариями библиотека telegram-osint-lib была завернута в Docker:
```
docker build -t telegram-osint-lib .
docker run -d -t --name tg-osint-lib telegram-osint-lib
```
### Преамбула: Генерируем бота-клиента
Перед тем как запустить содержимое Docker-контейнера и получить о пользователе первые данные, нам понадобится “зайти” в сеть Telegram. Для входа в сеть библиотека использует ботов (о которых уже было упомянуто выше), от имени которых производятся все действия.
Для генерации бота нам потребуется сценарий регистрации, реализующий связку [auth.sendCode](https://core.telegram.org/method/auth.sendCode) → [auth.signIn](https://core.telegram.org/method/auth.signIn) → [auth.signUp](https://core.telegram.org/method/auth.signUp):
```
docker exec -i tg-osint-lib php examples/registration.php
Number: 790612***31
SMS code: 123123
```
На выходе получаем бота, готового к задачам OpenSource Intelligence:
```
AuthKey: 790612***31:aabbccdd...
```
Этот ключ(AuthKey) будет использоваться во всех дальнейших примерах следующим образом:
```
docker exec --env BOT=... -i tg-osint-lib php ...
```
Ниже в примерах, для краткости, бот будет указываться так: `--env BOT=...`
### Собираем сведения о владельце номера
Начать мы решили с простого сценария — поиска пользователя Telegram по номеру телефона. Данный сценарий довольно очевидный и доступный для рядовых пользователей, однако его массовое применение несколько затруднительно “из коробки“.
Предположим, у вас есть ряд номеров, о владельцах которых вы хотели бы собрать информацию минимальными усилиями. Сеть Telegram в этом случае [позволит собрать](https://core.telegram.org/constructor/userFull) следующую информацию о телефонном номере:
1. Ник (который многие пользователей могут использовать и в других местах)
2. Фото
3. Общие чаты
4. Имя/Фамилия
5. “О себе”
6. Последнее время пребывания в Telegram
7. Предпочтительный язык
Этой информации уже достаточно для составления начального профиля владельца номера. Мы будем использовать [сценарий](https://github.com/Postuf/telegram-osint-lib/blob/master/src/Scenario/InfoClientScenario.php) из telegram-osint-lib, который будет получать на входе список телефонных номеров, пробегать по ним и запрашивать для каждого номера соответствующий аккаунт на сервере Telegram. Если аккаунт есть, мы получаем его данные. Если же аккаунт не найден, сохраняем номер телефона в отдельный список, которые будет обрабатываться в дальнейшем вручную.
Запускаем сценарий на группе номеров:
```
docker exec --env BOT=... -i tg-osint-lib php examples/parseNumbers.php 7985****294,7985****977,7986****777,7986****252,7988****417,7999****169,7999****869,7999****053,7999****364,7999****916,7999****475,7999****959,7985****025,7985****343,7989****207,7916****668,7926****802 > numbersInfo.txt
```
Всю основную работу в недрах библиотеки выполняет метод `InfoClient::getInfoByPhone()`, использующий связку API вызовов `import_contacts->get_user_full->delete_contacts->get_user_full`. А обработка результатов происходит в функции обратного вызова, которой в параметрах передаётся модель с данными пользователя. Если у пользователя установлено фото профиля, изображение будет загружено в папку со скриптом примера, а в поле `Photo` будет указано имя файла.
### Следим за присутствием пользователя
Развивая предыдущий сценарий, нетрудно догадаться, что запрашивать информацию об интересующем пользователе можно периодически и каждый раз сохранять его статус присутствия в сети Telegram. Это позволит спустя некоторое время накопить достаточно данных, чтобы составить карту активности.
Составив несколько таких карт по разным пользователям, мы сможем попробовать установить корреляцию между их заходами с целью определить возможность активного общения между ними.
Запускаем уже другой сценарий на группе номеров и наблюдаем за ними некоторое время:
```
docker exec --env BOT=... -i tg-osint-lib php examples/monitorNumbers.php 97155******9,...,798*****777 presence_map.txt
```
На выходе сценария мы получим ASCII-карту (где “+“ — состояние online в секунду времени) взаимоприсутствия интересующих пользователей в сети. Из карты видно, что вероятность активного общения между пользователями 2,4,5,9 более вероятна, чем между всеми остальными:
### Откуда HackerNews черпает свои новости?
В Telegram популярны каналы новостного типа — рассылающие анонсы новостей, статей и прочих тематических постов. Но многие ли обращают внимание, откуда популярные каналы черпают информацию?
Возьмём относительно популярный канал [HackerNews](https://t.me/HNews). Нас интересует список ресурсов, новости из которых чаще всего постились в группе за последний месяц.
В библиотеке реализовано два похожих метода для работы с сообщениями групп: `InfoClient::getChannelLinks()` и `InfoClient::getChannelMessages()`. Работают они практически одинаково, за исключением того, что первый метод фильтрует сообщения и отбирает только те, в которых были размещены ссылки.
Попробуем собрать все ссылки за последние несколько месяцев с целью определить основные источники информации канала:
```
docker exec --env BOT=... -i tg-osint-lib php examples/parseChannelLinks.php https://t.me/HNews "2019-12-01 00:00:00"
```
Спустя некоторое время сценарий соберет статистику по доменам и на выходе мы увидим примерно следующие результаты:
Итого, получили источники по убыванию частотности:
1. [habr.com](http://habr.com) (45%)
2. [xakep.ru](http://xakep.ru) (44%)
3. [threatpost.com](http://threatpost.com) (11%)
4. остальное (<1%)
Теперь тот, кто подписан на HackerNews, [Xakep.ru](http://Xakep.ru) и Habrahabr может задуматься, а не подписан ли он на что-то лишнее?
### Самый большой болтун
Кроме анализа информационных источников группы, немалый интерес может представлять выборка самых активных участников тематической группы. Не секрет, что 20% участников группы производят 80% активности этой группы. Получив такую информацию, можно определить наиболее приоритетных для группы людей и наладить контакт именно с ними.
Определять топ самых активных участников проще всего на промежутке времени или по числу последних сообщений (например, по последним 1000 сообщений). Собрать информацию о частоте сообщений участников группы нам поможет метод API [messages.getHistory](http://core.telegram.org/method/messages.getHistory), используемый сценарием с другим целевым предназначением (сбор сообщений в группе), но кастомизируемый внешними инструментами. Запускаем очередной сценарий на одной из популярных групп с пост-фильтрацией средствами командной строки:
```
docker exec --env BOT=... -i tg-osint-lib php parseGroupMessages.php https://t.me/vityapelevin -- 1570207168 1580207168 --info \
head -n 2000 | \
ggrep -oP 'from [a-zA-Z0-9_]+ at' | \
sort | uniq -c | sort -r -n -k1 | awk '{print $1 " " $3 }' | \
head -n10
```
Что на выходе позволяет получить самых больших болтунов группы:
```
355 289336351
237 710806664
226 Yuliya04
216 735896305
187 Retrovertigodor
187 971662085
175 Mahmud_Abas
141 VwVwVoid
94 nikol_pelevina
85 kotenok_gaff
```
### Общие интересы
Как можно расширить информацию о человеке, имея на руках его сетевой профиль, связанный с номером? Одной из примечательных функций Telegram является групповое тематическое общение. Все существующие чаты можно условно классифицировать по интересам (которых суммарно будет несколько сотен) и из каждого класса интересов выбрать несколько самых популярных чатов для поиска в них интересующего пользователя.
Ядром сценария, определяющего “карту интересов” пользователя, будет API-метод `get_common_chats`, возвращающий список чатов, которые являются общими для бота и пользователя из наших контактов.
Итоговый алгоритм определения интересов пользователя будет следующим:
1. Добавить пользователя к себе в контакты
2. Подписать бота на множество популярных чатов, используя `join_channel`
3. Получить информацию об общих с пользователем чатах, с помощью `get_common_chats`
4. Сопоставить общие чаты с классами интересов
Для исполнения этого алгоритма на конкретном номере будет использоваться очередной сценарий, использующий внутри себя другой, уже задействованный ранее, сценарий поиска информации по номеру телефона:
```
docker exec --env BOT=... -i tg-osint-lib php examples/commonChats.php 7926****802
```
Изучая исходник примененного сценария можно обратить внимание на то, как происходит комбинирование простых сценариев в более сложные:
```
public function getCommonChats(?callable $callback = null)
{
$client = new UserContactsScenario([$this->phone], function (UserInfoModel $user) use ($callback) {
$this->infoClient->getCommonChats($user->id, $user->accessHash, 100, 0, function (AnonymousMessage $message) use ($callback) {
if (!Chats::isIt($message)) return;
$updates = new Chats($message);
foreach ($updates->getChats() as $chat) {
$this->commonChats[] = strtolower($chat->username);
}
...
});
});
$client->startActions(false);
}
```
По полученным общим чатам “вычисляются” классы интересов, к которым они относятся, подсчитывается количество общих чатов в каждой из категорий, и на выходе сценария получаем список интересов пользователя, упорядоченный по количеству чатов, а значит можем сделать вывод, какие из интересов наиболее предпочтительны пользователем:
### Извлечение сообщений пользователя из публичных чатов и каналов
Продолжаем дальше искать новые источники открытой информации в Telegram. Какую информацию о пользователе мы смогли извлечь на данный момент:
1. Номер → Профиль пользователя
2. Профиль пользователя → Общие каналы с пользователем
Графические клиенты предоставляют возможность поиска по тексту сообщений, но также API поддерживает поиск сообщений конкретного пользователя. Самое время осуществить недостающий переход:
3. Общие каналы с пользователем → Сообщения пользователя в канале
Для этого нам поможет сценарий извлечения сообщений группы. В его основе лежит API-метод [messages.getHistory](http://core.telegram.org/method/messages.getHistory). Для примера, выгрузим последние сообщения уже известного нам пользователя `a_averyanova_m:`
```
docker exec --env BOT=... -i tg-osint-lib php parseGroupMessages.php https://t.me/phuketrusa a_averyanova_m --info | head -n10
30.01.2020 13:26:17 | parseGroupMessages.php: starting group resolver for username: phuketrusa
30.01.2020 13:26:18 | TelegramOSINT\Scenario\GroupMessagesScenario: resolved user a_averyanova_m to 272425703
30.01.2020 13:26:19 | TelegramOSINT\Scenario\GroupMessagesScenario: got message 'Учиться мопед водить ?)))) \\ Ну приеду , проверю информацию )' from a_averyanova_m at 2020-01-30 12:25:48
30.01.2020 13:26:19 | TelegramOSINT\Scenario\GroupMessagesScenario: loading more messages, starting with 26451
30.01.2020 13:26:20 | TelegramOSINT\Scenario\GroupMessagesScenario: loading more messages, starting with 26332
30.01.2020 13:26:21 | TelegramOSINT\Scenario\GroupMessagesScenario: loading more messages, starting with 26219
30.01.2020 13:26:22 | TelegramOSINT\Scenario\GroupMessagesScenario: got message 'Я так поняла , тут вариантов не много, или ты катаешься без прав (наши тут с кат.авто не прокатят) и лишаешься страховки (если вдруг что)+платить штраф 500-1000бат, или идёшь и получаешь права в Тае, по времени это пару дней (когда как) и по деньгам явно дешевле, чем на лапу давать) мы по прилету , будем делать их на месте' from a_averyanova_m at 2020-01-29 14:38:40
30.01.2020 13:26:22 | TelegramOSINT\Scenario\GroupMessagesScenario: loading more messages, starting with 26099
30.01.2020 13:26:22 | TelegramOSINT\Scenario\GroupMessagesScenario: got message 'Спасибо' from a_averyanova_m at 2020-01-29 10:55:06
30.01.2020 13:26:22 | TelegramOSINT\Scenario\GroupMessagesScenario: got message 'Добрый день , еду на 2 месяца в Тай, кто какую страховку делал , при условии того, что буду ездить на байке без открытой категории. \\ И ещё , слышала, что можно открыть категорию ( получить их права) на месте , кто этим занимался, платить каждый раз по 1000бат тоже не самый классный вариант' from a_averyanova_m at 2020-01-29 10:09:10
```
Помимо возможностей пост-фильтрации, есть возможность выборки по диапазону дат. Пример фильтра (~с 04.10.2019 до 27.01.2020):
```
docker exec --env BOT=... -i tg-osint-lib php parseGroupMessages.php https://t.me/vityapelevin -- 1570207168 1580207168 --info | grep сновидения
28.01.2020 10:45:22 | TelegramOSINT\Scenario\GroupMessagesScenario: got message 'Да, там про всякие сверхвозможности, в искусстве сновидения вроде' from 735896305 at 2020-01-27 21:02:01
```
На этом этапе проведем небольшую ретроспективу собранных данных по одному из исходных номеров:
1. Первым шагом в разделе “Собираем сведения о владельце номера“ мы сопоставили профиль пользователя `a_averyanova_m` с реальным человеком, владеющим номером `7926****802`
2. Далее в разделе “Общие интересы“ определили возможные интересы человека на основе анализа общих групп (путешествия)
3. И, наконец, в этом разделе извлекли публичную переписку в одной из обнаруженных общих групп с ботом
Вместе вся эта информация позволяет сформировать достаточно полное представление об исходном владельце номера и даже о его планах на будущее.
### Гео-разведка
Использование гео-позиции открывает интересные возможности для сбора информации, однако сама по себе гео-разведка является одним из тех направлений OSINT, разрушительный эффект от которых очевиден разработчикам по умолчанию и который они всяческими методами пытаются снижать. Разработчики Telegram здесь не стали исключением и так же постарались минимизировать возможные утечки, связанные с гео-локацией. В итоге весь потенциал направления сузился до нескольких API-методов: [geochats.getLocated](https://core.telegram.org/method/geochats.getLocated) и [contacts.getLocated](https://core.telegram.org/method/contacts.getLocated), но и их в некоторых случаях может хватить для извлечения дополнительной информации о пользователе — например, где он чаще всего появляется в городе?
Завершающий сценарий, который мы рассмотрим в этой статье, позволяет определять потенциальные “места обитания” пользователя на определенной локации на основе поля гео-точек. В основе сценария будет лежать API-метод [contacts.getLocated](https://core.telegram.org/method/contacts.getLocated), который возвращает гео-чаты и контакты, находящиеся в определенном радиусе (эмпирическая оценка ~1 километр) от заданной гео-точки. Метод возвращает структуру Updates, благодаря которой мы можем реализовать мониторинг изменений в отслеживаемой группе пользователей.
Запускаем сценарий на поле из двух точек для конкретного пользователя:
```
docker exec --env BOT=... -i tg-osint-lib php geoSearch.php 55.753930,37.615714,55.756390,37.661931 b00k1ng 30 --info
...
29.01.2020 16:00:06 | TelegramOSINT\Scenario\GeoSearchScenario: found group 'Эдвард юил' near (55.753930, 37.615714)
29.01.2020 16:00:06 | TelegramOSINT\Scenario\GroupMembersScenario: searching chat 1404414249 participants for b00k1ng
29.01.2020 16:00:06 | TelegramOSINT\Scenario\GeoSearchScenario: found group 'Френдовская' near (55.753930, 37.615714)
29.01.2020 16:00:06 | TelegramOSINT\Scenario\GroupMembersScenario: searching chat 1404180655 participants for b00k1ng
29.01.2020 16:00:06 | TelegramOSINT\Scenario\GroupMembersScenario: chat 1211826903 contains user 883904218 with username b00k1ng
```
На основе результата можно делать предположения о том, в каких локациях пользователь гипотетически может появляться, что позволит сделать определенные выводы о его интересах и деятельности в реальной жизни.
Внутри сценарий, также как и некоторые другие, из рассмотренных выше, организован по принципу композируемости: сам сценарий `GeoSearchScenario`, по сути, выполняет один запрос, а дальнейшая работа по проверке участников делегируется сценарию `GroupMembersScenario`:
```
$groupHandler = function (GeoChannelModel $model) use (&$generator, &$finders, $username) {
$membersFinder = new GroupMembersScenario(
$model->getGroupId(),
null,
$generator,
100,
$username
);
$membersFinder->startActions(false);
$finders[] = $membersFinder;
};
$search = new GeoSearchScenario($points, $groupHandler, $generator, $limit);
$search->startActions();
```
Заключение
----------
В этой статье на примере библиотеки сценариев telegram-osint-lib мы разобрали ряд сценариев OSINT-направленности в сети Telegram. Как можно было заметить, разобранные “утечки“ OSINT являются издержками исходных бизнес-требований к функционалу, а потому не могут быть устранены легко. Наверное, это одна из тех причин, по которой направление разведки по открытым источникам будет существовать постоянно в том или ином виде — это что-то вроде шума в электронных цепях, к которому все уже давно привыкли: ослабить эффект возможно, но устранить полностью экономически невыгодно.
Мы шли от более простых сценариев к более сложным, встраивая и комбинируя сценарии друг с другом. Структура библиотеки позволяет легко комбинировать как методы, так и сценарии между собой в нужную цепочку вызовов, получая на выходе необходимый сценарий. А асинхронный механизм работы уменьшает зависимость различных методов друг от друга и позволяет реализовать несколько одновременных соединений, позволяя масштабировать сценарии.
Мы рассмотрели ряд примеров, работающих автономно, без какого-либо “состояния” (State), однако добавление к сценариям состояния (до чего у нас пока не дошли руки), позволит вытворять еще более интересные штуки в сфере OSINT. Например обнаруженная в августе 2018 года “уязвимость“, [позволяющая определять номер телефона по никнейму пользователя](https://tjournal.ru/tech/74825-izvestiya-v-telegram-nashli-uyazvimost-kotoraya-pozvolyaet-opredelyat-nomer-telefona-po-nikneymu-polzovatelya) была не уязвимостью, а ничем иным, как OSINT-сценарием с наличием состояния: кто-то начал массово искать пользователей по номеру телефона, собирая базу данных (State) вида “пользователь->номер“, исходя из структуры которой определение телефона по никнейму являлось тривиальной операцией.
В завершение хотелось бы отметить, что Telegram API непрерывно развивается, открывая с каждым API Layer все новые возможности не только для OSINT-исследователя, поэтому любой желающий может присоединиться к разработке библиотеки сценариев и пополнять её новыми сценариями, скрывающими хитросплетения API-вызовов и решающими любые прикладные задачи в сети Telegram. | https://habr.com/ru/post/486322/ | null | ru | null |
# Jenkins Scripting Pipeline — генерация стадий выполнения
Всем привет! В интернете довольно много статей, связанных с Declarative Jenkins pipeline, и совсем немного о Jenkins Scripting Pipeline, хотелось бы восполнить этот пробел.
**Исторический экскурс**
В 2008 году Jenkins был ответвлен от проекта Hudson, принадлежащего компании Oracle, и стал самостоятельным продуктом с открытым кодом. В начале, как и его предок, Jenkins поддерживал только последовательное выполнение шелл скриптов (Windows cmd/linux bash). Многие проекты до сих пор с успехом пользуются классическим вариантом интерфейса для обеспечения процесса непрерывной интеграции и развертывания. Первым значительным улучшением стал переход на использование так называемого [Jenkins Pipeline](https://www.jenkins.io/doc/book/pipeline/). В качестве языка для написания Jenkins Pipeline скрипта был выбран Groovy в связи с тем, что весь остальной код Jenkins написан на Java, а Groovy и Java тесно взаимосвязаны. К сожалению, переход к использованию Jenkins Pipeline сильно усложнил процесс непрерывной интеграции и развертывания, так как требовал дополнительных навыков в написании Groovy скриптов, а также характеризовался сложным процессом отладки этого скрипта. В результате был разработан [Jenkins plugin Blue Ocean](https://plugins.jenkins.io/blueocean/) и [редактор Jenkins Pipeline](https://www.jenkins.io/doc/book/blueocean/pipeline-editor/). Но это была немного другая версия Jenkins Pipeline, которая получила название [Jenkins Declarative Pipeline](https://www.jenkins.io/doc/book/pipeline/syntax/#declarative-pipeline). Это был тоже своего рода прорыв, так как позволял людям без особых навыков программирования Groovy описывать довольно сложные процессы интеграции и развертывания.
В нашем проекте мы используем Jenkins для запуска интеграционных (E2E) тестов, которые проверяют функционал системы в целом.
К использованию Jenkins Scripting Pipeline мы пришли не сразу. В начале мы использовали классический Jenkins CI, но довольно быстро перешли на Jenkins Declarative Pipeline, так как выяснилось, что мы не можем запускать тесты одним куском, а должны исполнять их несколькими группами с немного различающимися параметрами запуска. Использование Jenkins Pipeline так же позволило нам запускать параллельно различные группы тестов, что также ускорило общее время выполнения. По мере разрастания функционала и тестов время выполнения полного пакета тестов стало увеличиваться и достигло на пике 40-50 минут. Кроме того, стало понятно, что имеющиеся UI-mock тесты часто не позволяют отловить ошибку, что приводит к потере времени на анализ ошибки в релизной версии. В результате было решено, что помимо UI-mock тестов мы должны выполнять интеграционные тесты прежде, чем осуществить процесс слияния поднятого PR в релизную ветку. Было решено перевести проект на [Multibranch Pipeline](https://www.jenkins.io/doc/book/pipeline/multibranch/#creating-a-multibranch-pipeline). За счет распараллеливания тестов удалось сократить время выполнения до 30-35 минут. Мы выделили специальную фазу с небольшим количеством тестов, которые выполнялись за 10 минут. Эта фаза стала использоваться для выполнения тестов на ветке кода перед процессом слияния с релизной веткой.
В результате перед нашей командой были поставлены две задачи, связанные с уменьшением общего времени прогона тестов и времени прогона тестов перед процессом слияния. Для этого мы решили действовать в двух направлениях:
1. Проанализировать существующие тесты, по возможности перенести перебор значений из интеграционных тестов в UI-mock или BackEnd-mock тесты (что выходит за рамки этой статьи).
2. Выделить из общего набора тестов те, которые покрывали бы 70-80 процентов функционала и при этом быстро выполнялись.
Для решения второй задачи пришлось перейти на использование Jenkins Scripting Pipeline по следующим причинам:
1. По соображениям безопасности поддержка Pipeline Editor отключена, поэтому даже Declarative Pipeline надо писать вручную.
2. Включение/исключение блока тестов из прогона перед слиянием превращалось в копирование большого количества кода из одного места в другое, что приводило к ошибкам в Jenkins-pipeline файле, которые сложно отлаживать, а также к увеличению размера Jenkins-pipeline файла.
Для решения второй причины мне показалось удобным осуществлять генерацию выполнения тестов в зависимости от конфигурации, прописанной в Jenkins Pipeline файле.
Информацией о том, что вышло в итоге и хочется поделиться, так как в процессе написания Jenkins-pipeline скрипта выяснилось, что в интернете достаточно информации про Declarative Jenkins Pipeline и довольно мало по Jenkins Scripting Pipeline.
Структура тестов
----------------
Прежде чем перейти к описанию получившегося Jenkins-pipeline скрипта, необходимо рассказать о структуре и запуске тестов, чтобы дать представление о том, почему стало возможным сделать генерацию выполнения групп тестов.
Все тесты разделены на группы исходя из функционала, который они тестируют, в свою очередь, группа может быть разделена на подгруппы.
Запуск тестов осуществляется командой:
```
jest --config=jest.server.config.js --reporters='default' --reporters='jest-allure'
```
Дополнительные параметры исполнения регулируются установкой переменных окружения. Одним из параметров окружения является PATH\_TO\_TESTS, в которую вносится путь до тестов относительно папки **server-tests**. То есть, например, если PATH\_TO\_TESTS=’stage1’, то выполняются все тесты из папки ‘stage1’, включая все тесты из поддиректорий: ‘sub-stage-11’ и ‘sub-stage-12’. А если PATH\_TO\_TESTS=’stage1/sub-stage-11’, то тесты только из этой папки.
Именно благодаря такой структуре тестов удалось создать Jenkins-pipeline файл, который в процессе исполнения создает фазы исполнения исходя из конфигурации этих этапов.
Конфигурация этапов выполнения
------------------------------
В качестве групп тестов использовали названия собранных по функционалу директорий, например, ‘stage1’. Для начала было решено выделить 3 больших пакета: Smoke Pack, Main Pack и Special Pack, в которые распределены имеющиеся группы тестов.
В результате выполнения должно было получиться следующее:
Выяснилось, что группа тестов в свою очередь может состоять из некоторых подгрупп, которые могут выполняться либо параллельно, либо последовательно. Для конфигурирования выполнения я стал использовать три map-коллекции:
1. В качестве ключа используется название пакета тестов, в качестве значения – список групп тестов, входящих в пакет.
2. В качестве ключа используется название группы тестов (он обязательно должен совпадать со значением из списка в коллекции 1), в качестве значения – список подгрупп тестов, которые выполняются параллельно
3. В качестве ключа используется название группы тестов (он обязательно должен совпадать со значением из списка в коллекции 1), в качестве значения – список подгрупп тестов, которые выполняются последовательно. В этом случае последовательность подгрупп тестов важна.
```
jobPacks = [
'Smoke Pack' : ["Stage1", "Stage2", "Stage3"],
'Main Pack' : ["Stage4", "Stage5", "Stage6", "Stage7"],
'Special Pack': ["Stage8", "Stage9"]
]
parallelSubStages = [
'Stage6': ["sub stage 61", "sub stage 62", "sub stage 63", "sub stage 64"],
'Stage5': ["sub stage 51", "sub stage 52", "sub stage 53"],
'Stage9': ["sub stage 91", "sub stage 92", "sub stage 93", "sub stage 94", "sub stage 95"]
]
multiStepsStages = [
'Stage7': ["sub stage 71", "sub stage 72", "sub stage 73"],
'Stage8': ["sub stage 81", "sub stage 82"]
]
```
Основная перегруппировка происходит в первой коллекции. Именно в ней я переставляю группы тестов по пакетам или переношу в новые группы.
Генерация этапов выполнения
---------------------------
Из-за особенностей Jenkins Scripting Pipeline пришлось выделить 2 обязательных этапа:
1. Подготовка: из репозитория проекта скачивается код и устанавливаются необходимые node-modules.
2. Завершение: выполняется создание allure-репорта прохождения тестов, очищается кэш прогона и удаляется Jenkins workspace.
Наконец, пишем основной скрипт генерации этапов выполнения.
Существует возможность запуска необходимых тестов вручную (пакетами, отдельными группами тестов), поэтому в переменной окружения STAGES\_TO\_BE\_EXECUTED находится список запускаемых пакетов/групп тестов. По умолчанию он установлен в “Smoke Pack”, таким образом, если запуск происходит в результате изменения ветки кода (commit), то выполняются тесты, входящие в пакет “Smoke Pack”.
Алгоритм генерации довольно простой:
Для каждого пакета из jobPacks:
1. На основании выбранных пакетов/групп тестов (“STAGES\_TO\_BE\_EXECUTED”) создается список групп тестов, которые будут выполнены для этого пакета.
2. Для каждого элемента из списка групп тестов создается Jenkins “stage” с необходимыми параметрами запуска.
Выглядит это следующим образом:
```
node {
stage('prepare test run') {
git branch: '$BRANCH_NAME', changelog: true, url: 'ssh://git@my-super-puper-repository.git'
nodejs(nodejsConfig) {
sh "yarn install"
}
}
//--------------------------------------------
// собственно ради этого все и затеивалось:
jobPacks.each {
packName, stages ->
List stagesToExecute = generateExecuteStagesList(packName)
if (!stagesToExecute.isEmpty()) {
stage(packName) {
// parallel в данном месте заставляет Jenkins выполнять stages параллельно
parallel stagesToExecute.collectEntries { ["${it}": generateStage([it, packName])] }
}
}
}
//--------------------------------------------
stage('Declarative: Post Actions') {
allure includeProperties: false, jdk: 'openjdk-linux-intel64-1.8.0\_211-1', reportBuildPolicy: 'ALWAYS', results: [[path: 'allure-results']]
nodejs(nodejsConfig) {
sh label: 'clear jest cache', script: "node\_modules/.bin/jest --clearCache || true"
}
cleanWs()
}
}
```
Алгоритм функции создания списка групп выполнения:
1. Если текущий пакет входит в STAGES\_TO\_BE\_EXECUTED, то все группы тестов, которые к нему относятся, попадают в список выполнения.
2. Все группы тестов, выбранные пользователем (содержащиеся в STAGES\_TO\_BE\_EXECUTED) и входящие в данный пакет выполнения на основании jobPack, также добавляются в список выполнения.
3. Если список выполнения содержит группы тестов, которые могут быть выполнены параллельно (входят в parallelSubStages), то они заменяются на входящие в него подгруппы.
```
def generateExecuteStagesList(String packName) {
List stagesToBeExecuted
if (env.STAGES\_TO\_BE\_EXECUTED.contains(packName) || env.STAGES\_TO\_BE\_EXECUTED.contains('Full Pack')) {
// if pack is selected add all stages in pack
stagesToBeExecuted = jobPacks[packName]
}
else {
def selectedStages = env.STAGES\_TO\_BE\_EXECUTED.split(', ')
stagesToBeExecuted = jobPacks[packName].findAll { selectedStages.contains(it) }
}
// now replace all stages with sub stages (from parallelSubStages) with related sub stages
parallelSubStages.each {
multiStage, stages ->
if (stagesToBeExecuted.contains(multiStage)) {
stagesToBeExecuted.remove(multiStage) // remove muliStage (for example "Stage5")
stagesToBeExecuted.addAll(stages.collect{ "${multiStage}/${it}" }) // add multi-stage sub stages (for examples "Stage5/sub stage 51")
}
}
return stagesToBeExecuted
}
```
Алгоритм функции генерации фазы выполнения (stage) в Jenkins:
1. Если группа тестов состоит из группы последовательных тестов (входит в multiStepsStages), то создается Jenkins-stage, в котором для каждой группы тестов запускается генерация шагов выполнения.
2. Если группа тестов не составная, то для нее создается Jenkins-stage с генерацией шага выполнения.
```
def generateStage(input) {
def (stageName, packName) = input
// multi-steps stage
if (multiStepsStages.containsKey(stageName)) {
return {
stage("${packName}: ${stageName}") {
// for example generateStep('stage5/sub-stage-51')
multiStepsStages.getAt(stageName).each { stepName -> generateStep(stageName + '/' + stepName) }
}
}
}
// single step stage
return {
stage("${packName}: ${stageName}") {
timeout(15) {
generateStep(stageName)
}
}
}
}
```
Шаги выполнения тестов одинаковые, благодаря чему получилось создать данный генератор:
```
def generateStep(stageName) {
return catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
withEnv(stageEnv(stageName.toLowerCase().replace(" ", "-"))) {
nodejs(nodejsConfig) {
sh "${jestCommand}"
}
}
}
}
```
В stageEnv устанавливаются дополнительные переменные окружения, с которыми должна выполнятся та или иная группа тестов. В основном это установка роли пользователя, от которого эти тесты выполняются, а также относительный путь к тестам из этой группы на основании имени фазы выполнения. Для этого в generateStage и в generateExecuteStagesList создавались имена с “/” типа “Stage5/sub stage 51”.
Итоги и выводы
--------------
Удалось сократить размер Jenkinsfile в 2 раза за счет удаления повторяющегося кода, который был написан в Declarative Jenkins pipeline.
Стало удобнее перемещать группы тестов между пакетами выполнения. Появилась возможность легко разделить группу тестов на несколько подгрупп с последующим параллельным выполнением.
Грамотно подобранная конфигурация позволила сократить время выполнения полного пакета тестов примерно в 2 раза (с 25-30 минут до 13-16 минут).
Было:
Стало:
Smoke пакет при этом выполняется от 2 до 5 минут (около половины тестов):
Ссылка на GitHub
----------------
[Полная версия Jenkinsfile](https://github.com/j8kin/habr-jenkinsfile.git) | https://habr.com/ru/post/508134/ | null | ru | null |
# Экономим свое время. Ускоряем создание отложенных постов в Telegram с помощью бота
**TL;DR:** Если у вас есть Telegram-канал и вы устали руками заполнять отложку, то такой бот здорово облегчит вам жизнь.
Видеть это окно каждый раз при создании отложенного поста очень утомляетСтандартный алгоритм создания отложенного поста выглядит так:
1. Открыть канал
2. Создать пост
3. Выбрать тип публикации "Отложенная"
4. Указать время поста
5. Отправить публикацию
При фиксированном интервале между постами алгоритм напрашивается на оптимизацию, в идеале хотелось бы оставить только пункты 1, 2, 5. Причем пункт 2 прокачать до "Создать посты".
Несмотря на обилие готовых решений, большинство их них перегружено функциями (зачастую платными) и работа с ними может, наоборот, увеличить время создания поста. Поэтому было решено реализовать собственного бота, которому можно просто отсылать фотографии (видео, документы, что угодно), а он бы сам уже добавлял их в отложенные публикации, основываясь на времени последнего поста.
Звучит здорово, но этот подход не сработал из-за того, что боту недоступно это самое время последнего поста в канале, а также из-за этого:
Дуров, почему?Получается без собственной реализации отложки не обойтись.
Идея
----
У любого файла, загруженного на сервера Telegram, есть уникальный fileId. Если мы отправим боту фотографию, то он сможет достать этот id из входящего сообщения и сохранить в базу:
В случае картинки на серверах создается несколько файлов в разном разрешенииДалее, когда настанет время, мы сможем использовать сохраненный fileId, чтобы отправить пост в канал.
Создаем проект
--------------
Бота будем писать на Java с использованием Spring Boot и библиотеки [TelegramBots](https://github.com/rubenlagus/TelegramBots),. В качестве БД используем PostgreSQL. На [Spring Initializr](https://start.spring.io/) сгенерируем наш проект с необходимыми зависимостями:
Откроем сгенерированный проект в IDE. В `build.gradle` в тег`dependencies` добавим библиотеку для работы с ботами:
```
implementation 'org.telegram:telegrambots-spring-boot-starter:5.5.0'
```
Далее настроим подключение к нашей локальной БД. Для этого в `application.yaml` пропишем:
```
spring:
datasource:
url: ${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/postgres}
```
И создадим класс конфигурации БД:
```
@Configuration
public class DatabaseConfig {
@Value("${spring.datasource.url}")
private String dbUrl;
@Bean
public DataSource dataSource() {
HikariConfig config = new HikariConfig();
config.setJdbcUrl(dbUrl);
return new HikariDataSource(config);
}
}
```
Создадим миграции:
```
databaseChangeLog:
- changeSet:
id: 1-add-record
author: ananac
changes:
- createTable:
tableName: record
columns:
- column:
name: id
type: bigint
constraints:
primaryKey: true
nullable: false
- column:
name: file_id
type: varchar(255)
constraints:
nullable: true
- column:
name: comment
type: text
constraints:
nullable: true
- column:
name: data_type
type: varchar(15)
constraints:
nullable: false
- column:
name: create_date_time
type: timestamp
constraints:
nullable: false
- column:
name: post_date_time
type: timestamp
constraints:
nullable: true
- column:
name: author
type: varchar(255)
constraints:
nullable: false
```
```
databaseChangeLog:
- include:
file: db/changelog/1-add-record.yaml
```
После этого можно запускать приложение, чтобы миграции накатились и в БД появилась наша таблица для хранения постов.
Создаем бота
------------
Идем к @BotFather, с помощью команды `/newbot` создаем нового бота и получаем API токен. Прописываем полученные данные в `application.yaml`, заодно укажем свой userId и chatId канала, в который мы будем постить. Все это можно узнать по адресу [https://api.telegram.org/bot<вставить\_токен\_бота>/getUpdates](https://api.telegram.org/bot1686968362:AAGCx-WDvkT_u720KvEeRZL9nyRbhtkIhG8/getUpdates). Там хранятся эвенты, такие как входящие сообщения, которые еще не были обработаны ботом.
```
telegram:
name: botname
token: 1793090787:AaaaAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaa
chatId: -1948372984327
adminId: 265765765
```
Пишем логику
------------
Реализуем сущность для созданной нами таблицы:
```
@Entity
@Table(name = "record")
@Data
@RequiredArgsConstructor
public class Record {
@Id
private long id;
private String fileId;
private String comment;
private String dataType;
private LocalDateTime createDateTime;
private LocalDateTime postDateTime;
private String author;
}
```
И JPA-репозиторий с необходимыми нам запросами:
```
@Repository
public interface RecordRepository extends JpaRepository {
@Query("select r from Record r where r.createDateTime = (select min(r1.createDateTime) from Record r1 where r1.postDateTime = null)")
Optional getFirstRecordInQueue();
@Query("select r from Record r where r.postDateTime = (select max(r1.postDateTime) from Record r1)")
Optional getLastPostedRecord();
@Query("select count(\*) from Record r where r.postDateTime = null")
long getNumberOfScheduledPosts();
@Transactional
@Modifying
@Query("delete from Record r where r.postDateTime = null")
void clear();
}
```
Займемся непосредственно обработчиком входящих сообщений. Создаем новый класс, отнаследованный от `TelegramLongPollingBot`. В нем определяем метод, который будет обрабатывать входящие события. Мы хотим, чтобы с ботом мог работать только пользователь указанный в конфиге, поэтому добавим проверку по userId:
```
@Component
@Getter
@RequiredArgsConstructor
public class TelegramBotHandler extends TelegramLongPollingBot {
private final RecordRepository recordRepository;
@Value("${telegram.name}")
private String name;
@Value("${telegram.token}")
private String token;
@Value("${telegram.chatId}")
private String chatId;
@Value("${telegram.adminId}")
private Set adminId;
@Override
public String getBotUsername() {
return name;
}
@Override
public String getBotToken() {
return token;
}
@Override
public void onUpdateReceived(Update update) {
if (update.getMessage() != null) {
Long userId = update.getMessage().getFrom().getId();
if (adminId.contains(userId)) {
processMessage(update.getMessage());
} else {
reply(userId, "Permission denied");
}
}
}
private void reply(Long chatId, String text) {
try {
SendMessage sendMessage = new SendMessage();
sendMessage.setChatId(String.valueOf(chatId));
sendMessage.setText(text);
execute(sendMessage);
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
```
Далее реализуем метод сохранения поста в БД. Пока делаем поддержку только для фото, но в будущем ничего не мешает расшириться на все типы вложений. Помним, что во входящем сообщении лежит несколько файлов в разном разрешении, нас интересует только самый большой:
```
private void processMessage(Message message) {
Long chatId = message.getChatId();
if (message.getPhoto() != null && !message.getPhoto().isEmpty()) {
Record record = buildRecord(message);
recordRepository.save(record);
reply(chatId, "Добавлено. Количество постов в отложке: " + recordRepository.getNumberOfScheduledPosts());
} else {
reply(chatId, "Принимаются только фото");
}
}
private Record buildRecord(Message message) {
Record record = new Record();
String fileId = getLargestFileId(message);
record.setFileId(fileId);
record.setComment(message.getCaption());
record.setDataType("PHOTO");
record.setId(message.getMessageId());
record.setCreateDateTime(LocalDateTime.now());
record.setAuthor(message.getFrom().getUserName());
return record;
}
private String getLargestFileId(Message message) {
return message.getPhoto().stream()
.max(Comparator.comparing(PhotoSize::getFileSize))
.orElse(null)
.getFileId();
}
```
Пост в базу мы добавили, перейдем к постингу. Создадим новый класс, внутри будет метод с аннотацией `@Scheduled(fixedDelayString = "60000")`, что означает, что он будет запускаться каждую минуту. Не забываем также повесить аннотацию `@EnableScheduling` на наш Application класс. Для интервала постинга в `application.yaml` укажем, например, 120 минут.
```
@Component
@RequiredArgsConstructor
public class RecordService {
private final RecordRepository recordRepository;
private final TelegramBotHandler botHandler;
@Value("${schedule.postingInterval}")
private long postingInterval;
@Scheduled(fixedDelayString = "60000")
private void run() {
Optional recordToPost = recordRepository.getFirstRecordInQueue();
if (recordToPost.isPresent()) {
Optional lastPostedRecordOptional = recordRepository.getLastPostedRecord();
if (lastPostedRecordOptional.isPresent()) {
Record lastPostedRecord = lastPostedRecordOptional.get();
Duration duration = Duration.between(lastPostedRecord.getPostDateTime(), LocalDateTime.now());
if (duration.toMinutes() >= postingInterval) {
Record record = recordToPost.get();
botHandler.sendPhoto(record);
}
} else {
Record record = recordToPost.get();
botHandler.sendPhoto(record);
}
}
}
}
```
Метод запускается раз в минуту и первым делаем проверяет есть ли в БД неопубликованные посты. Если посты есть, то проверяется не прошло ли 120 минут с момента публикации последнего поста и на основании этого принимается решении о постинге. Также учитываем, что при первом запуске у нас не будет опубликованных постов в БД.
Далее добавим пару команд, чтобы с ботом было удобнее работать:
И реализуем их в коде. Команду для очистки сделаем с подтверждением, чтобы избежать мискликов:
```
private void processMessage(Message message) {
Long chatId = message.getChatId();
if (message.getPhoto() != null && !message.getPhoto().isEmpty()) {
Record record = buildRecord(message);
recordRepository.save(record);
reply(chatId, "Добавлено. Количество постов в отложке: " + recordRepository.getNumberOfScheduledPosts());
} else if (message.getText() != null) {
switch (message.getText()) {
case "/info": {
reply(chatId, "Количество постов в отложке: " + recordRepository.getNumberOfScheduledPosts());
break;
}
case "/clear": {
reply(chatId, "Чтобы очистить напиши /delete");
break;
}
case "/delete": {
recordRepository.clear();
reply(chatId, "Очищено. Количество постов в отложке: " + recordRepository.getNumberOfScheduledPosts());
break;
}
default: {
break;
}
}
} else {
reply(chatId, "Принимаются только фото");
}
}
public void sendPhoto(Record record) {
try {
SendPhoto sendPhoto = new SendPhoto();
sendPhoto.setChatId(chatId);
sendPhoto.setPhoto(new InputFile(record.getFileId()));
execute(sendPhoto);
afterPost(record);
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
private void afterPost(Record record) {
record.setPostDateTime(LocalDateTime.now());
recordRepository.save(record);
}
```
Запуск и проверка
-----------------
Поднимаем приложение и проверяем:
Посты удаляются и добавляютсяВ дальнейшем приложение можно задеплоить в облако, например, на Heroku (что и было сделано с этим ботом) по [этому гайду](https://devcenter.heroku.com/articles/deploying-spring-boot-apps-to-heroku). С кодом можно ознакомиться [здесь](https://github.com/Ananac/otlojka-bot/). | https://habr.com/ru/post/596579/ | null | ru | null |
# Система сбора распределенной телеметрии на Cassandra и Kotlin Spring
Сердцем любого backend являются данные. Существует два сценария использования данных. В одном из них данные изменяются редко, но при этом активно используются в сыром или агрегированном виде и применяются для целей аналитики в реальном времени (такие системы принято называть OLAP). В других системах важно обеспечить сохранение с высокой скоростью большого количество неструктурированных или полуструктурированных объектов, поступающих от устройств Интернета вещей, из источников произвольных событий, наблюдений за активностью пользователя (такие системы называются OLTP - Online Transaction Processing, ориентированные на большое количество транзакций с минимальной задержкой обработки). Для таких систем важно обеспечить надежность хранения данных, поддержку распределенного хранения на нескольких серверах и/или дата-центрах и сохранение консистентности распределенного хранилища.
При этом сами объекты могут отличаться от привычной реляционной модели данных и представляться, например, в виде json-документов с произвольной схемой, объектов с полями со множественными значениями или графов. Разумеется это приводит к необходимости изучения новых подходов к поиску и добавлению данных, использованию специальных драйверов. Но что если соединить распределенное надежное хранилище и синтаксис запросов, близкий к SQL? В этой статье мы познакомимся с проектом Apache Cassandra и обсудим на примере разработки API на Kotlin для сбора телеметрии с датчиков, расположенных по всему миру (с поддержкой отказоустойчивости и управляемой репликации между дата-центрами).
Начнем с рассмотрения основной идеи Cassandra (мы говорим об актуальной версии 4.0.4). Согласно современным представлениям Cassandra можно отнести к категории NoSQL баз данных, основанных на идее автоматического шардирования гигантских таблиц. Основной единицей Cassandra является узел (node), который координируется с другими узлами и организует хранение и доступ к данным, сохраненным в виде записей в таблицах. Важно отметить, что для кластера Cassandra не используются выделенные управляющие узлы и все узлы являются основными и содержат информацию о топологии сети (как в пределах одного дата-центра, так и между дата-центрами), размещении хэшей по разделам, состоянию соседних узлов (replica node), содержащих реплики записей. Для Cassandra предусмотрены механизмы поддержки согласованности (начиная от hinted handoff, когда при временной недоступности одного из узлов, другие носители реплики создают отложенный лог действий для последующего воспроизведения после восстановления доступа для пропавшего узла, и заканчивая механизмами полной репликации и восстановления узла (даже из полностью очищенного состояния, на основании данных из других реплик).
Коллекции столбцов (таблица) описываются схемой, при этом таблица создается внутри пространства ключей (keyspace). В свою очередь keyspace может определять стратегию репликации (с возможностью задать количество реплик на дата-центры), а также настройки кэширования и буферов поиска. Важно отметить, что для каждой таблицы обязательно указывает ключ - одно или несколько полей, использующихся для размещения хэша (записи) в keyset, при этом поля могут определять как отнесение записи к разделу (partition), так и кластеризацию внутри раздела. При этом записи одного раздела хранятся на одних и тех же серверах и их расположение известно (что позволяет оптимизировать выполнение запроса, поскольку каждый узел знает о карте размещения записей по узлам). Cassandra может выполнять отбор записей и без использования keyspace, но это может быть неоптимально, поскольку из запроса будет непонятно, какие из серверов должны быть вовлечены в процесс поиска и обращение будет отправлено на все узлы кластера.
При создании таблицы могут использоваться не только примитивные [типы данных](https://cassandra.apache.org/doc/latest/cassandra/cql/types.html) (int, boolean, float, double), но и составные структуры (list для упорядоченных коллекций объектов указанного типа, map для словарей с типом ключа T и типом значения V, set для неупорядоченных множеств). Также поддерживаются типы данных для хранения времени (duration - продолжительность, timestamp - временная метка, date - дата, time - время без даты), text для хранения строки произвольной длины, blob для двоичных объектов, inet для хранения ip-адресов, uuid для уникальных идентификаторов, counter для хранения счетчика с атомарными функциями изменения, а также можно создать собственные типы данных через CREATE TYPE.
Cassandra хорошо подходит для хранения поточных событий, данных телеметрии, временных рядов (существует даже отдельная база данных [KairosDB](https://kairosdb.github.io/), работающая поверх Cassandra и ориентированная на хранение последовательности значений с привязкой ко времени), при этом близкие по времени записи могут интерпретироваться как единый набор, который должен быть помечен на удаление одновременно (задается через стратегию TimeWindowCompactionStrategy). Также для записей в Cassandra может быть извлечена дата последней модификации поля WRITETIME(name) и определено время до истечения TTL(name), при этом время существования записи определяется при добавлении или модификации. Также доступны методы сравнения для использования с полями типа timestamp, при этом можно использовать как временные метки, так и строковое представление ISO даты-времени и встроенные функции для преобразования представления.
Для выполнения запросов используется язык Cassandra Query Language (CQL), который синтаксически близок к SQL (SELECT, UPDATE, INSERT, DELETE) с возможностью отбора записей (WHERE), сортировки (ORDER BY), ограничения количества LIMIT, но при этом не поддерживает JOIN. Мы рассмотрим несколько подходов к использованию Cassandra в коде backend-приложения на Kotlin (начиная от использования низкоуровневого драйвера и до использования Spring Data). Но начнем мы с подготовки модели данных и развертывания демонстрационного кластера.
В нашем приложении предполагается сохранение данных о температуре и влажности от датчиков, расположенных по всему миру, а также сообщения об экологических проблемах, поступающие от пользователей системы. Информация от датчика будет иметь следующую структуру:
* дата-время замера (с точностью до секунды);
* местоположение (широта и долгота);
* серийный номер датчика (int);
* тип датчика (сама cassandra не поддерживает enum-типы, но их можно использовать на уровне драйвера);
* значение замера (число с плавающей точкой);
* организация-владелец датчика (uuid).
Для сохранения сообщений о проблемах будет использоваться структура:
* автор сообщения;
* текст сообщения;
* категория проблемы;
* местоположение (широта и долгота);
* тэги сообщения (список строк);
* статус обработки.
По описанию схемы видно, что здесь вполне можно было и обойтись обычной реляционной базой данных, но в действительности у нас есть еще одно важное требование - данные должны храниться в нескольких дата-центрах по всему миру и суммарный объем данных существенно превышает возможности хранения любого дата-центра.
Начнем с установки кластера из трех узлов Cassandra, для этого будем использовать официальный образ Docker-контейнера на [Docker Hub](https://hub.docker.com/_/cassandra). Для отладки также можно использовать бесплатный продукт [Datastax Desktop](https://downloads.datastax.com/#desktop) для запуска отладочного сервера и взаимодействия с ним. Также для развертывания кластеров поверх Kubernetes существует несколько операторов: [K8ssandra](https://k8ssandra.io/), [Casskop](https://orange-opensource.github.io/casskop/), [Sky Cassandra Operator](https://github.com/sky-uk/cassandra-operator) для автоматизации развертывания, сбора и визуализации метрик, резервного копирования и восстановления данных, а также иных операций по обслуживанию кластера. Также облачные провайдеры предлагают свои решения, основанные на Apache Cassandra: [Amazon Keyspaces](https://aws.amazon.com/ru/keyspaces/), [DataStax Astra DB](https://www.datastax.com/products/datastax-astra), [Azure Cosmos DB](https://docs.microsoft.com/ru-ru/azure/cosmos-db/) (совместима с API Cassandra и MongoDB).
Перед запуском кластера создадим файл конфигурации для поддержки ролевого доступа и управления учетными записями:
```
cassandra1.yaml
# название кластера
cluster_name: 'Demo Cluster'
num_tokens: 16
# allocate_tokens_for_local_replication_factor: 3
# конфигурация восстановления при сбое до 3 часов
hinted_handoff_enabled: true
max_hint_window_in_ms: 10800000 # 3 hours
# настройка ролевого доступа и управления пользователями
authenticator: PasswordAuthenticator
authorizer: CassandraAuthorizer
role_manager: CassandraRoleManager
network_authorizer: AllowAllNetworkAuthorizer
# механизм разделения по первичному ключу на разделы
partitioner: org.apache.cassandra.dht.Murmur3Partitioner
# сохранение лога транзакций в памяти и выгрузка в хранилище каждые 10 секунд
commitlog_sync: periodic
commitlog_sync_period_in_ms: 10000
# параметры seeds будут перезаписаны на реальный ip адрес после запуска сервера
seed_provider:
- class_name: org.apache.cassandra.locator.SimpleSeedProvider
parameters:
- seeds: "cassandra1"
# конфигурация публикации
storage_port: 7000
ssl_storage_port: 7001
listen_address: 0.0.0.0
broadcast_address: 0.0.0.0
start_native_transport: true
native_transport_port: 9042
native_transport_allow_older_protocols: true
rpc_address: 0.0.0.0
broadcast_rpc_address: 172.28.0.2
# время ожидания ответа и лимит для медленных запросов
request_timeout_in_ms: 10000
slow_query_log_timeout_in_ms: 500
# режим определения привязки к дата-центру (SimpleSnitch для одного дата-центра, может использоваться PropertyFileSnitch)
# и список ip-адресов и дата-центров
endpoint_snitch: SimpleSnitch
# разрешить добавление пользовательских функций в Cassandra
enable_user_defined_functions: true
enable_scripted_user_defined_functions: true
# разрешить подробное протоколирование запросов (с версии 4.0)
full_query_logging_options:
enabled: true
log_dir: /tmp/cassandrafullquerylog
roll_cycle: HOURLY
# разрешить аудит попыток входа (с версии 4.0)
audit_logging_options:
enabled: true
logger:
- class_name: BinAuditLogger
```
Дополнительно в конфигурации мы добавили автоматический аудит попыток входа (появилось в версии Cassandra 4.0) и выполненных запросов, а также разрешили добавление пользовательских функций на Java в базу данных Cassandra. Поскольку docker-контейнер модифицирует непосредственно conf-файл при запуске, создадим три копии этого файла и запустим наш кластер:
```
cp cassandra1.yaml cassandra2.yaml
cp cassandra1.yaml cassandra3.yaml
docker create network cassandra
docker run -itd --name cassandra1 --hostname cassandra1 --network=cassandra -p 9042:9042 -v ./cassandra1.yaml:/opt/cassandra/conf/cassandra.yaml cassandra
docker run -itd --name cassandra2 --hostname cassandra2 --network=cassandra -e CASSANDRA_SEEDS=cassandra1 -v ./cassandra2.yaml:/opt/cassandra/conf/cassandra.yaml cassandra
docker run -itd --name cassandra3 --hostname cassandra3 --network=cassandra -e CASSANDRA_SEEDS=cassandra1 -v ./cassandra3.yaml:/opt/cassandra/conf/cassandra.yaml cassandra
```
Для проверки состояния кластера (и выполнению работ по обслуживанию узлов) используется утилита nodetool, доступная внутри контейнера:
```
$ docker exec cassandra1 nodetool status
Datacenter: datacenter1
=======================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns (effective) Host ID Rack
UN 172.28.0.2 136.47 KiB 16 100.0% 0f42781b-79a8-46f0-9446-287f3b9bd2e5 rack1
UN 172.28.0.4 20.75 KiB 16 100.0% c831f85c-f64d-468e-9681-b19413a78f23 rack1
UN 172.28.0.3 91.83 KiB 16 100.0% 8bb65a75-7130-4d58-9a42-de112b44906c rack1
```
После запуска кластера мы можем установить утилиту [cqlsh](https://docs.datastax.com/en/install/6.8/install/installCqlsh.html) или использовать ее в одном из контейнеров. Поскольку мы разрешили контроль доступа, при подключении необходимо указать имя пользователя и пароль (по умолчанию cassandra / cassandra). Cqlsh подключается по умолчанию к localhost, но параметром командной строки может быть указан адрес или имя любого из доступных серверов.
```
$ docker exec -it cassandra1 bash
cqlsh -u cassandra -p cassandra
```
При успешном подключении будет отображен заголовок с версиями сервера и протокола и приглашение для ввода команд.
Успешное подключение к кластеру CassandraСоздадим новое keyspace с фактором репликации 3 (в этом случае для достижения консенсуса при чтении или записи в режиме кворум должно быть доступно (F+1)/2 серверов, т.е. выход при F=3, достаточно двух серверов для успешного завершения операции чтения или записи.
```
CREATE KEYSPACE IF NOT EXISTS ecology WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 } AND durable_writes = true;
```
Здесь используется класс для определения стратегии SimpleStrategy, который подразумевает единую политику репликации для всех дата-центров. Альтернативно может быть задан класс NetworkTopologyStrategy для которого задается соответствие между дата-центрами и политикой репликации создаваемого keyspace. Флаг durable\_writes гарантирует успешную запись данных в постоянное хранилище.
Следующим действием создадим необходимые таблицы, но прежде создадим пользовательский тип данных, на который мы будем ссылаться в определении таблицы (местоположение):
```
CREATE TYPE ecology.location (latitude float, longitude float);
CREATE TABLE ecology.problem (id uuid, author uuid, message text, place location, status int, tags list, PRIMARY KEY ((author), id));
```
Обратите внимание, что при создании типа и таблицы мы дополнительно указываем к какому keyspace относится данный объект. Определение таблицы создает схему данных для колонок: id (тип uuid), будет использоваться для уникальной идентификации сообщения, author (тип uuid) - идентификатор автора в сторонней системе (либо может быть создана дополнительная таблица с пользователями), message (текст произвольной длины) - сообщение от пользователя, place (пользовательский тип location), status (статус обращения, будет обновляться позднее). В определении первичного ключа можно увидеть, что поле author будет использоваться для partitioning (т.е. все сообщения от одного автора будут находиться на одних и тех же replica node), внутри которых выполняется кластеризация по id. Такой выбор первичного ключа обусловлен необходимостью его уникальности, а также возможностью быстрого поиска по автору и/или идентификатору сообщения.
Создадим также таблицу для хранения телеметрии с датчиков:
```
CREATE TABLE ecology.telemetry (datetime timestamp, place location, sensor_id uuid, sensor_type int, value double, sensor_owner uuid, PRIMARY KEY ((sensor_owner,sensor_id), sensor_type, datetime));
```
Здесь структура чуть более сложная, поскольку sensor\_serial (серийный номер датчика) может повторяться у разных владельцев (sensor\_owner), поэтому partition-ключ является составным. Также дополнительно мы делаем кластеризацию по типу датчика и дате-времени, что важно для возможности отбора значений в указанном временном промежутке для соответствующего измеренного значения. В остальном определение таблицы аналогично ранее созданному списку событий. Отдельный идентификатор для замера не создается, поскольку сочетание "владелец датчика" + "серийный номер датчика" + "дата-время" всегда является уникальным.
Давайте теперь наполним таблицу несколькими тестовыми записями:
```
insert into ecology.problem (id, author, message, place, tags, status) values
(uuid(), 00000000-0000-0000-0000-000000000000, 'На солнце появились пятна',
{longitude:30.3201503, latitude:60.03692}, ['bugs','sun'], 0);
insert into ecology.problem (id, author, message, place, tags) values
(uuid(), 00000000-0000-0000-0000-000000000000, 'Снова пропал корабль в бермудском треугольнике',
{longitude:-71.2112568, latitude:24.9391274}, ['shiplost']);
```
Как можно видеть, специальные типы данных (например, uuid) не являются строковыми литералами, поэтому указываются без кавычек. Для заполнения списка используется форма записи [набор значений], для множеств - {набор значений}, для словарей (map) - {'ключ':'значение',...}. Функция uuid() создает новое случайное значение уникального идентификатора. Запросим все данные из таблицы:
```
cassandra@cqlsh> select * from ecology.problem;
author | id | message | place | status | tags
--------------------------------------+--------------------------------------+------------------------------------------------+--------------------------------------------+--------+-----------------
00000000-0000-0000-0000-000000000000 | 643d58b1-37fc-4b18-8c46-b4744b17a938 | На солнце появились пятна | {latitude: 60.03692, longitude: 30.32015} | 0 | ['bugs', 'sun']
00000000-0000-0000-0000-000000000000 | 5c9e52e9-df34-42fe-b340-62a29a9d90c5 | Снова пропал корабль в бермудском треугольнике | {latitude: 24.93913, longitude: -71.21126} | null | ['shiplost']
(2 rows)
```
И теперь попробуем поискать все записи автора (это действие допустимо, поскольку автор указан как partition key):
```
select * from ecology.problem where author=00000000-0000-0000-0000-000000000000;
```
Аналогично можно получить отдельную запись автора (т.к. мы указали id записи как clustering key):
```
cassandra@cqlsh> select * from ecology.problem where author=00000000-0000-0000-0000-000000000000 and id=643d58b1-37fc-4b18-8c46-b4744b17a938
```
В то же время нам не получится непосредственно найти записи по статусу или по тэгу, поскольку из запроса нельзя получить информацию о расположении реплик (так как эти поля не входят в partition/clustering key). При попытке выполнить запрос по одному из полей будет выдана ошибка:
```
cassandra@cqlsh> select * from ecology.problem where author=00000000-0000-0000-0000-000000000000 AND status=0;
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING"
```
Можно добавить к запросу суффикс ALLOW FILTERING для явного указания, что мы готовы к непредсказуемому времени отклика (поскольку запрос будет отправлен на весь кластер):
```
select * from ecology.problem where author=00000000-0000-0000-0000-000000000000 AND status=0 ALLOW FILTERING;
author | id | message | place | status | tags
--------------------------------------+--------------------------------------+---------------------------+-------------------------------------------+--------+-----------------
00000000-0000-0000-0000-000000000000 | 643d58b1-37fc-4b18-8c46-b4744b17a938 | На солнце появились пятна | {latitude: 60.03692, longitude: 30.32015} | 0 | ['bugs', 'sun']
```
Аналогичная ситуация с поиском по списку (в этом случае используется предикат value contains tag):
```
select * from ecology.problem where author=00000000-0000-0000-0000-000000000000 AND tags contains 'sun' ALLOW FILTERING;
```
При сохранении данных датчиков мы можем указать срок актуальности (например, мы хотим сохранять только последнюю неделю):
```
insert into ecology.telemetry (sensor_owner,sensor_serial,sensor_type,datetime,value,place) VALUES (00000000-0000-0000-0000-000000000000,1,1,totimestamp(now()),25.1,{longitude:-95.5493073,latitude:44.8127629}) using ttl 604800;
```
Здесь мы использовали функцию now() для получения текущего времени и totimestamp(dt) для преобразования во временную метку. Дополнительно при вставке мы уточнили срок актуальности записи (604800 = 1 неделя в секундах). Проверим дату-время последнего обновления значения и время до истечения срока действия:
```
cassandra@cqlsh> select toDate(writetime(value)), ttl(value) from ecology.telemetry;
writetime(value) | ttl(value)
-----------------+------------
1653836623289664 | 604628
```
После истечения срока действия или при выполнении delete с подходящим условием where записи помечаются на удаление и будут очищены во время выполнения очередного действия по сжатию базу compaction (также может быть вызван вручную через `nodetool compact`).
Поля с типом timestamp могут использоваться при поиске для отбора записей, находящихся в указанном временном интервале. Но иногда нужно получить относительно время (от текущего), например извлечь записи, созданные за 15 минут. Здесь нам могут помочь возможности определения собственных функций в Cassandra:
```
CREATE FUNCTION IF NOT EXISTS timeAgo(minutes int)
CALLED ON NULL INPUT
RETURNS timestamp
LANGUAGE java AS '
long now = System.currentTimeMillis();
if (minutes == null)
return new Date(now);
return new Date(now - (minutes.intValue() * 60 * 1000));
';
```
Здесь мы создаем функцию на Java, которая использует метод из пакета java.lang.System для получения текущего времени и возвращает временную метку, отстоящую на указанное количество минут в прошлом. Теперь мы можем использовать этот результат в отборе записей:
```
select sensor_owner,sensor_serial,sensor_type,value FROM ecology.telemetry WHERE sensor_type=1 AND datetime>timeAgo(18) allow filtering;
sensor_owner | sensor_serial | sensor_type | value
--------------------------------------+---------------+-------------+-------
00000000-0000-0000-0000-000000000000 | 1 | 1 | 25.1
```
Здесь мы использовали allow filtering, поскольку в условиях отбора нет ни одного фильтра, который бы помог выбрать правильные узлы с репликами по partition-ключу.
Также данные могут быть извлечены как json-объект или обновлены/добавлены из json. Структура json должна соответствовать схеме таблицы. Например, для извлечения данных о датчиках в JSON можно использовать такой запрос:
```
select json sensor_owner,sensor_serial,datetime,place,sensor_type,value from ecolo
gy.telemetry;
[json]
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
{"sensor_owner": "00000000-0000-0000-0000-000000000000", "sensor_serial": 1, "datetime": "2022-05-29 15:03:03.253Z", "place": {"latitude": 44.812763, "longitude": -95.54931}, "sensor_type": 1, "value": 25.1}
```
Аналогично может быть выполнено добавление записи. Обратите внимание, что в случае полного совпадения ключей ошибка не будет выводиться, но будет обновлена (перезаписана) существующая запись:
```
insert into ecology.telemetry json '{"sensor_owner": "00000000-0000-0000-0000-000000000000", "sensor_serial": 1, "datetime": "2022-05-29 15:03:43.295Z", "place": {"latitude": 44.812
763, "longitude": -95.54931}, "sensor_type": 1, "value": 25.1}';
```
Для диагностики работы самого кластера можно использовать виртуальные таблицы, расположенные в keyspace [system\_views](https://cassandra.apache.org/doc/latest/cassandra/new/virtualtables.html#virtual-tables). Получить информацию о доступных ресурсах и их текущую конфигурацию можно также командами describe:
* **describe keyspaces** - вывести список доступных пространств ключей, **describe keyspace** - подробное описание состояния и настроек указанного keyspace;
* **describe tables** - вывести список доступных таблиц, **describe table .** - подробное описание состояния и настроек указанной таблицы;
* **describe cluster** - выводим информацию о конфигурации кластера;
* **describe types** - список пользовательских типов, **describe type .** - подробная информация об определении типа;
* **describe functions** - список пользовательских функций, **describe function .** - подробная информация об определении функции.
В целом мы посмотрели возможности Apache Cassandra по работе с данными и теперь самое время перейти к обсуждению методов программного взаимодействия с кластером Cassandra на Kotlin. Но перед этим добавим новую роль и назначим для нее права для работы с нашими таблицами:
```
CREATE ROLE ecology_user WITH PASSWORD = 'WaterIsLife!' AND LOGIN = true;
GRANT MODIFY ON ecology.problem TO ecology_user;
GRANT SELECT ON ecology.problem TO ecology_user;
GRANT MODIFY ON ecology.telemetry TO ecology_user;
```
Созданный пользователь будет иметь права на изменение и чтение таблицы ecology.problem и только на отправку телеметрии в ecology.telemetry. Следующим шагом мы добавим поддержку Cassandra в наше приложение и попробуем добавить и получить данные из нашего API.
### Драйвер Datastax для Cassandra
Для доступа к базе данных сообществом разработчиков и компанией, которая занимается коммерческой поддержкой развертываний Cassandra и Datastax Enterprise, был предоставлен свободный драйвер для использования в приложениях на JVM. По своему назначению его назначение максимально похоже на JDBC-драйверы к другим СУБД, но все же здесь используется свой нестандартный набор примитивов и концепций.
Добавим поддержку драйвера в наше приложение и подключим зависимости в build.gradle.kts dependencies:
```
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins {
kotlin("jvm") version "1.6.21"
}
group = "tech.dzolotov.cassandra"
version = "1.0-SNAPSHOT"
val cassandraDriverVersion by extra("4.14.1")
repositories {
mavenCentral()
}
dependencies {
testImplementation(kotlin("test"))
implementation("com.datastax.oss:java-driver-core:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-query-builder:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-mapper-runtime:$cassandraDriverVersion")
}
tasks.withType {
kotlinOptions.jvmTarget = "1.8"
}
```
Для установки подключения используется статический метод builder из класса CqlSession. При настройке builder может быть указаны следующие параметры конфигурации:
* **.addContactPoint(...)** - добавить адрес сервера Cassandra, например `.addContactPoint(InetSocketAddress("cassandra1.local.domain", 9042));`
* **addNodeStateListener(...)** - добавить обработчик для отслеживания изменения состояния узла;
* **addSchemaChangeListener(...)** - добавить обработчик для отслеживания изменения схемы данных;
* **.addTypeCodecs(...)** - добавить преобразователи для специальных типов данных;
* **.withAuthCredentials(login, pass)** - указать имя и пароль для подключения к сессии;
* **.withKeyspace(name)** - подключиться к указанному пространству ключей по умолчанию;
* **.withLocalDatacenter(name)** - указать предпочтительный ближайший дата-центр;
* **.withNodeDistanceEvaluator(profile, func)** - использовать нестандартный способ определения ближайших доступных узлов;
* **.withConfigLoader(...)** - загрузка конфигурации из внешнего ресурса (например, application.conf), может использоваться совместно с DriverConfigLoader.fromClasspath("<название\_файла\_конфигурации>").
После завершения настройки вызывается метод build() для получения объекта сессии, через который будут выполняться все последующие запросы.
Мы будем использовать файл конфигурации и дополнительно определим профили, которые помогут определить подходящие настройки для сетевого подключения и таймаутов (application.conf размещается в /src/resources):
```
datastax-java-driver {
basic {
contact-points = [ "127.0.0.1:9042" ]
load-balancing-policy.local-datacenter = datacenter1
request {
timeout = 2 seconds
consistency = LOCAL_QUORUM
}
profiles {
olap {
basic.request.timeout = 5 seconds
basic.request.consistency = QUORUM
}
}
}
advanced.auth-provider {
class = PlainTextAuthProvider
username = ecology_user
password = "WaterIsLife!"
}
}
```
Файл конфигурации определяет настройки запроса по умолчанию (таймаут 2 секунды, режим поддержки консистентности при чтении - локальный кворум, для которого достаточно иметь доступными более половины реплика-узлов в местном дата-центре). Для отдельных длительных аналитических запросов создан дополнительный профиль olap, который может быть указан при создании объекта запроса. Также здесь указываются адреса точек подключения для получения первоначальной информации о топологии (у нас localhost), название ближайшего дата-центра и дополнительные данные для аутентификации.
Установим подключение к кластеру с использованием файла конфигурации:
```
fun main() {
val session = CqlSession.builder()
.withConfigLoader(DriverConfigLoader.fromClasspath("application.conf"))
.build()
println(session)
}
```
Объект сессии может использоваться как для непосредственного вызова запросов - синхронным/блокирующим способом (execute) или асинхронным с использованием механизмов java.util.Concurrent (CompletionStage), так и для создания prepared-запросов (аналогично PreparedStatement в JDBC) и извлечения метрик и метаданных кластера. Начнем с выполнения простого запроса - получим все зарегистрированные обращения об экологических проблемах:
```
data class Problem(val author:UUID?, val message:String?)
fun getProblems(session: CqlSession):List {
return session.execute("SELECT author, message FROM ecology.problem").map {
Problem(it.getUuid("author"), it.getString("message"))
}.toList()
}
fun main() {
val session = CqlSession.builder().withConfigLoader(DriverConfigLoader.fromClasspath("application.conf")).build()
println(getProblems(session))
session.close()
}
```
Здесь мы использовали синхронный метод для выполнения запроса к базе данных и затем построчно преобразовали его в объекты дата-класса, используя типизованные get-методы от каждого объекта Row. Кроме get\*-методов есть возможность получить из поля произвольного класса через метод get, которому первым параметром передается порядковый номер или название поля в результате запроса, а вторым - Java-класс, который должен быть создан из исходных данных). Например, в нашей записи есть вложенный объект (пользовательский тип location) и мы бы тоже хотели его добавить к нашей информации о проблеме. Добавим новый тип и явно обозначим, что хотели бы получить объект этого типа:
```
data class Location(val longitude:Float, val latitude:Float)
data class Problem(val author:UUID?, val message:String?, val place:Location?)
fun getProblems(session: CqlSession):List {
return session.execute("SELECT author, message, place FROM ecology.problem").map {
Problem(it.getUuid("author"), it.getString("message"), it.get("place", Location::class.java))
}.toList()
}
```
Но, к сожалению, при запуске произойдет исключение CodecNotFoundException: Codec not found for requested operation: [UDT(ecology.location) <-> Location], поскольку драйвер не знает о способе отображения данных из Cassandra в наш новый класс. Здесь нам поможет создание и регистрация TypeCodec, который отвечает за преобразование сериализованного представления объекта в Kotlin-объект и обратно, а также за вывод форматированного JSON-представления. Для обработки JSON-представления добавим поддержку kotlinx.serialization для json-формата:
```
buildscript {
repositories { mavenCentral() }
dependencies {
val kotlinVersion by extra("1.6.21")
classpath(kotlin("gradle-plugin", version = kotlinVersion))
classpath(kotlin("serialization", version = kotlinVersion))
}
}
plugins {
kotlin("jvm") version "1.6.21"
kotlin("plugin.serialization") version "1.6.21"
}
group = "tech.dzolotov.cassandra"
version = "1.0-SNAPSHOT"
val cassandraDriverVersion by extra("4.14.1")
repositories {
mavenCentral()
}
dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.3")
implementation("com.datastax.oss:java-driver-core:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-query-builder:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-mapper-runtime:$cassandraDriverVersion")
}
```
При определении TypeCodec необходимо определить методы проверки обработки CQL и Java-типа, десериализации-сериализации decode/encode, форматирования и разбора JSON-представления format/parse. При обработке двоичного представления на вход поступает буфер байтов, где содержание записывается последовательностью из 4-байтовой длины и последовательности байт, кодирующих содержание (в случае с float используется 32-битовое представление).
```
class LocationTypeCodec : TypeCodec {
override fun accepts(javaClass: Class<\*>): Boolean {
return javaClass == Location::class.java //используется в update/insert/where
}
override fun accepts(cqlType: DataType): Boolean {
val type = cqlType.asCql(false, true) //используется в select
return type == "ecology.location"
}
override fun getJavaType(): GenericType = GenericType.of(Location::class.java) //Связанный java-тип
override fun getCqlType(): DataType = DataTypes.custom("ecology.location") //Связанный CQL-тип
override fun decode(bytes: ByteBuffer?, protocolVersion: ProtocolVersion): Location? {
if (bytes == null) return null
val arr = bytes.array()
//первые 4 байта - длина записи, затем с 4 по 7 - float-представление широты
val latBytes = ByteBuffer.wrap(ByteArray(4) { arr[4 + it] })
//следующие 4 байта - длина записи, затем с 12 по 15 - float-представление долготы
val longBytes = ByteBuffer.wrap(ByteArray(4) { arr[12 + it] })
//декодирование делегируем в кодек FLOAT
val latitudeValue = TypeCodecs.FLOAT.decode(latBytes, protocolVersion)
val longitudeValue = TypeCodecs.FLOAT.decode(longBytes, protocolVersion)
return Location(latitudeValue!!, longitudeValue!!)
}
override fun parse(value: String?): Location? {
if (value == null) return null
return Json.decodeFromString(value)
}
override fun format(value: Location?): String {
if (value == null) return "{}"
return Json.encodeToString(Location.serializer(), value)
}
override fun encode(value: Location?, protocolVersion: ProtocolVersion): ByteBuffer? {
if (value == null) return null
val latLen = TypeCodecs.INT.encodePrimitive(4, protocolVersion) //длина float - 4 байта
val longLen = TypeCodecs.INT.encodePrimitive(4, protocolVersion) //длина float - 4 байта
val latBuf = TypeCodecs.FLOAT.encodePrimitive(value.latitude, protocolVersion) //кодируем широту
val longBuf = TypeCodecs.FLOAT.encodePrimitive(value.longitude, protocolVersion) //кодируем долготу
return ByteBuffer.allocate(16).put(latLen).put(latBuf).put(longLen).put(longBuf) //собираем сериализацию
}
}
fun main() {
val session = CqlSession.builder().withConfigLoader(DriverConfigLoader.fromClasspath("application.conf"))
.addTypeCodecs(LocationTypeCodec()).build()
println(getProblems(session))
session.close()
}
[Problem(author=00000000-0000-0000-0000-000000000000, message=Снова пропал корабль в бермудском треугольнике, place=Location(latitude=24.939127, longitude=-71.21126)), Problem(author=00000000-0000-0000-0000-000000000000, message=На солнце появились пятна, place=Location(latitude=60.03692, longitude=30.32015))]
```
Хотелось бы также получить дату-время добавления записи, но к сожалению в структуре такого поля нет. Здесь мы можем использовать функцию WRITETIME для определения времени последней модификации поля, но она возвратит результат с типом BIGINT, а нам бы хотелось получить дату-время (например LocalDateTime). Создадим еще один кодек для выполнения этого преобразования:
```
class DateTimeCodec : TypeCodec {
override fun getJavaType(): GenericType {
return GenericType.LOCAL\_DATE\_TIME
}
override fun getCqlType(): DataType {
return DataTypes.BIGINT
}
override fun accepts(javaClass: Class<\*>): Boolean {
return javaClass == LocalDateTime::class.java
}
override fun accepts(cqlType: DataType): Boolean {
val type = cqlType.asCql(false, true)
return type == "bigint"
}
override fun decode(bytes: ByteBuffer?, protocolVersion: ProtocolVersion): LocalDateTime? {
val dateTime = TypeCodecs.BIGINT.decodePrimitive(bytes, protocolVersion)
return LocalDateTime.ofEpochSecond(dateTime/1000000, 0, ZoneOffset.UTC)
}
override fun parse(value: String?): LocalDateTime? {
if (value==null) return null
return LocalDateTime.parse(value)
}
override fun format(value: LocalDateTime?): String {
if (value==null) return "1900-01-01T00:00:00Z"
return value.format(DateTimeFormatter.ISO\_LOCAL\_DATE\_TIME)
}
override fun encode(value: LocalDateTime?, protocolVersion: ProtocolVersion): ByteBuffer? {
if (value == null) return null
val dtLen = TypeCodecs.INT.encodePrimitive(8, protocolVersion) //длина float - 4 байта
val dtBuf =
TypeCodecs.BIGINT.encodePrimitive(value.toInstant(ZoneOffset.UTC).epochSecond \* 1000000, protocolVersion)
return ByteBuffer.allocate(12).put(dtLen).put(dtBuf)
}
}
```
Добавим регистрацию кодека при создании сессии:
```
val session = CqlSession.builder().withConfigLoader(DriverConfigLoader.fromClasspath("application.conf"))
.addTypeCodecs(LocationTypeCodec(), DateTimeCodec()).build()
```
И добавим в запрос получение времени последнего обновления записи:
```
fun getProblems(session: CqlSession): List {
return session.execute("SELECT author, message, place, WRITETIME(message) as datetime FROM ecology.problem").map {
Problem(
it.getUuid("author"),
it.getString("message"),
it.get("place", Location::class.java),
it.get("datetime", LocalDateTime::class.java),
)
}.toList()
}
```
Теперь мы можем получить любые необходимые данные из Cassandra. Перейдем к рассмотрению методов создания запросов манипуляции данными. Одним из вариантов является использование метода execute с передачей SQL-запроса INSERT, но это в большинстве случаев неудобно из-за необходимости подстановки значений в корректном синтаксисе, несмотря на наличие метода format в кодеке типа данных. Чтобы избежать прямых подстановок значений можно использовать создание PreparedStatement, в котором значения аргументов подставляются в корректном синтаксисе в позиции вопросительных знаков в запросе после выполнения связывания bind. Созданный в bind объект класса BoundStatement может быть выполнен через уже известный execute:
```
val prepared = session.prepare("INSERT INTO ecology.problem (author,id,message) VALUES (?,?,?)")
session.execute(prepared.bind(testAuthor, UUID.randomUUID(), "Обнаружена шахта к центру Земли2"))
```
Однако, если в PreparedStatement поместить наш класс Location, то мы обнаружим, что он не обрабатывается через метод format и в запись не попадает (остается null). PreparedStatement ожидает, что значения полей, реализующих пользовательские типы, будут созданы как реализации интерфейса UdtValue, которую можно сделать вручную (реализовать методы в Location) или создать описание структуры данных через UserDefinedTypeBuilder:
```
val prepared2 = session.prepare("INSERT INTO ecology.problem (author,id,message,place) VALUES (?,?,?,?)")
val locationValue = UserDefinedTypeBuilder("ecology", "location").withField("latitude", DataTypes.FLOAT)
.withField("longitude", DataTypes.FLOAT).build()
session.execute(prepared2.bind(testAuthor, UUID.randomUUID(), "Обнаружена шахта к центру Земли", locationValue.newValue(0.0f, 0.0f)))
```
Теперь мы можем перенести это определение в data-класс и сделать генератор значения UdtValue для использования в запросах:
```
@Serializable
data class Location(val latitude: Float, val longitude: Float) {
fun value(): UdtValue = UserDefinedTypeBuilder("ecology", "location").withField("latitude", DataTypes.FLOAT)
.withField("longitude", DataTypes.FLOAT).build().newValue(latitude, longitude)
}
...
val prepared2 = session.prepare("INSERT INTO ecology.problem (author,id,message,place) VALUES (?,?,?,?)")
session.execute(prepared2.bind(testAuthor, UUID.randomUUID(), "Обнаружена шахта к центру Земли", Location(0.0f, 0.0f).value()))
...
```
Для диагностики ошибок и настройки запросов можно использовать builder-метод через класс SimpleStatement.builder("запрос") и далее использовать set-методы для конфигурации:
* setExecutionProfile("name") - применяет профиль с преднастроенными параметрами запроса (определяется в application.conf);
* setTracing(bool) - включает или отключает режим трассировки запроса (в лог вывод выполняется через log4j, поэтому требуется конфигурация log4j.xml);
* setTimeout(duration) - переопределяет таймаут для ожидания ответа;
* setKeyspace("name") - изменяет пространство ключей по умолчанию;
* setIdempotence(bool) - помечает запрос как идемпотентный;
* setSerialConsistencyLevel(level) - изменяет режим ожидания консистентности (может быть ANY, ONE, TWO, THREE, LOCAL\_QUORUM, QUORUM, ALL - расположены по увеличению надежности).
Кроме синхронных (блокирующих) методов драйвер предлагает варианты executeAsync (использует механизмы CompletableFuture из java.util.concurrent) и executeReactive/executeContinouslyReactive с моделью реактивной обработки, похожей на подход RxJava.
Для упрощения работы с запросами драйвер предлагает еще два компонента: QueryBuilder и Mapper. Начнем с рассмотрения QueryBuilder.
Основой запроса является функция selectFrom(table), к которой могут по цепочке добавляться модификаторы:
* `all()` - получить все записи;
* `countAll()` - получить количество записей;
* `limit(n)` - ограничить количество записей n;
* `ttl(name)` - получить значение времени жизни для колонки;
* `whereColumn("name").isEqualTo(value)` - добавить проверку равенства значения поля (предикат для сравнения может быть другим);
* `column("name")` - добавить колонку в ответ;
* `columns("name1", "name2", ...)` - добавить несколько колонок в ответ;
* `distinct()` - выбрать неповторяющиеся записи;
* `json()` - получить ответ в формате json;
* `as(alias)` - задать псевдоним для последнего выражения;
* `allowFiltering()` - разрешить поиск по полям, не входящим в первичный ключ (partitioning/clustering).
Объект запроса формируется после вызова метода build и может быть передан в вызов session.execute(). Так предыдущие запросы можно переписать с использованием QueryBuilder:
```
//запрос содержания проблем
return session.execute(
selectFrom("ecology", "problem").all().column("author").column("message").column("place").writeTime("message").`as`("datetime")
.build()
).map {
Problem(
it.getUuid("author"),
it.getString("message"),
it.get("place", Location::class.java),
it.get("datetime", LocalDateTime::class.java),
)
}.toList()
//добавление новой проблемы
session.execute(
session.prepare(
insertInto("ecology", "problem").value("author", literal(testAuthor)).value("id", bindMarker())
.value("message", literal("Аномальная гравитация"))
.value("place", literal(Location(34.98293f, 32.40596f).value())).build()
).bind(UUID.randomUUID())
)
```
Компонент Mapper позволяет выполнить автоматическое преобразование полей класса в структуру таблиц базы данных Cassandra. Для использования Mapper добавим аннотацию @Entity к классу Problem, дополнительную аннотацию @PartitionKey к полю author и аннотацию @ClusteringColumn к новому полю id. Теперь определение класса выглядит так:
```
@Entity
data class Problem(
@PartitionKey val author: UUID?,
@ClusteringColumn val id: UUID?,
val message: String?,
val place: Location?,
val tags: List?
)
```
Дальше создадим интерфейс для описания методов работы с базой данных и пометим его аннотацией @Dao, а его методы аннотациями:
* `@Select` - используется при поиске записей;
* `@GetEntity` - для получения одиночной записи;
* `@Insert` - описывает добавление записей;
* `@Delete` - применяется для удаления записей;
* `@Update` - для описания запросов изменения;
* `@Query` - произвольный запрос;
* `@QueryProvider` - делегировать запрос на разбор вложенного элемента коллекции указанному классу.
И дополнительно создадим интерфейс с аннотацией @Mapper:
```
@Dao
interface Problems {
@Query("SELECT * FROM ecology.problem")
fun getAllProblems():PagingIterable
}
@Mapper
interface InventoryMapper {
@DaoFactory
fun problemsDao():Problems
}
```
Для корректной обработки аннотаций подключим gradle plugin kapt и соответствующий процессор аннотаций от Mapper:
```
buildscript {
repositories { mavenCentral() }
dependencies {
val kotlinVersion by extra("1.6.21")
classpath(kotlin("gradle-plugin", version = kotlinVersion))
classpath(kotlin("serialization", version = kotlinVersion))
}
}
plugins {
kotlin("jvm") version "1.6.21"
kotlin("plugin.serialization") version "1.6.21"
kotlin("kapt") version "1.6.21"
}
group = "tech.dzolotov.cassandra"
version = "1.0-SNAPSHOT"
val cassandraDriverVersion by extra("4.14.1")
repositories {
mavenCentral()
}
dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.3")
implementation("com.datastax.oss:java-driver-core:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-query-builder:$cassandraDriverVersion")
implementation("com.datastax.oss:java-driver-mapper-runtime:$cassandraDriverVersion")
implementation("org.slf4j:slf4j-log4j12:1.7.36")
kapt("com.datastax.oss:java-driver-mapper-processor:$cassandraDriverVersion")
}
```
Выполним сборку приложения (на этом этапе будет запущена кодогенерация) и заменим реализацию функции getProblems:
```
fun getProblems(session: CqlSession): List = InventoryMapperBuilder(session)
.build()
.problemsDao()
.getAllProblems()
.toList()
```
Мы рассмотрели все основные вопросы по использованию драйвера для Cassandra для Kotlin и теперь готовы к созданию простого REST API на Spring Data и удобных привязках, которые упрощают использование Cassandra для backend-приложений.
### Spring Data
Над драйвером DataStax в Spring Data реализована удобная обертка, которая позволяет генерировать автоматически запросы к базе данных для CRUD REST-сервисов и выполнять конфигурацию с использованием общих механизмов Spring.
Создадим проект с использованием конструктора [Spring Initializr](https://start.spring.io/) и добавим поддержку Spring Web (или Spring Web Reactive для использования webflux) и Spring Data for Apache Cassandra (может быть также добавлен реактивный вариант). Добавим конфигурацию запуска в src/resources/application.properties:
```
spring.data.cassandra.keyspace-name=ecology
spring.data.cassandra.port=9042
spring.data.cassandra.contact-points=127.0.0.1
spring.data.cassandra.username=cassandra
spring.data.cassandra.password=cassandra
spring.data.cassandra.local-datacenter=datacenter1
```
И зарегистрируем data-классы для наших записей в таблицах. Обратите внимание, что для определения записи используется аннотация @Table, а ключи помечаются @PrimaryKey с уточением типа ключа (type=PrimaryKeyType.Partitioned для ключа разделения на разделы, type=PrimaryKeyType.Clustered для ключа кластеризации внутри раздела).
```
@Table
data class TelemetryData(
val sensorType: Int,
@PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) val sensorOwner: UUID,
@PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED) val sensorSerial: Int,
val value: Double
)
@Table
data class ProblemData(
@PrimaryKeyColumn(type=PrimaryKeyType.PARTITIONED)
val author:UUID,
@PrimaryKeyColumn(type=PrimaryKeyType.CLUSTERED)
val id:UUID,
val message:String,
val tags:List,
)
```
Для использования специальных типов данных (например, Location) используются классы, реализующие интерфейс Converter для двухстороннего преобразования значений в формат базы данных и в java-объект. Для корректного связывания объекты преобразования должны быть маркированы аннотации @WritingConverter и @ReadingConverter, а также конверторы необходимо зарегистрировать в классе конфигурации Cassandra. Также добавим поддержку kotlinx.serialization.
```
@Serializable
data class Location(val latitude:Float, val longitude:Float)
@Component
@WritingConverter
class LocationWritingConvertor : Converter {
override fun convert(source: String): Location? {
return Json.decodeFromString(Location.serializer(), source)
}
}
@Component
@ReadingConverter
class LocationReadingConvertor : Converter {
override fun convert(source: Location): String? {
return Json.encodeToString(Location.serializer(), source)
}
}
@Table
data class TelemetryData(
val sensorType: Int?,
@PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) val sensorOwner: UUID,
@PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED) val sensorSerial: Int,
val value: Double?,
val place: Location?
)
@Table
data class ProblemData(
@PrimaryKeyColumn(type=PrimaryKeyType.PARTITIONED)
val author:UUID?,
@PrimaryKeyColumn(type=PrimaryKeyType.CLUSTERED)
val id:UUID?,
val message:String?,
val tags:List?,
val place: Location?
)
```
Для взаимодействия с Cassandra используются репозитории - интерфейсы, помеченные как @Repository и унаследованные от CrudRepository<класс\_данных, класс\_ключа> или от CassandraRepository<класс\_данных, класс\_ключа>.
Конфигурация Cassandra должна перечислить используемые репозитории и необходимые настройки для драйвера (альтернативно настройки могут быть указаны в properties-файле):
```
@Repository
interface TelemetryRepository : CassandraRepository
@Repository
interface ProblemRepository : CassandraRepository
@Configuration
@EnableCassandraRepositories(basePackageClasses = [TelemetryRepository::class, ProblemRepository::class])
class CassandraConfig : AbstractCassandraConfiguration() {
override fun getKeyspaceName() = "ecology"
override fun customConversions(): CassandraCustomConversions {
return CassandraCustomConversions(mutableListOf(LocationWritingConvertor::class, LocationReadingConvertor::class) )
}
}
```
Репозиторий предлагает набор методов для получения коллекции объектов, поиска отдельного объекта, создании новых объектов (а также можно создать свои методы в определении интерфейсы). Эти методы можно непосредственно использовать в реализации методов обработки REST-запросов:
```
@RestController
@RequestMapping("telemetry")
class Telemetry {
@Autowired
lateinit var repository: ProblemRepository
@GetMapping("/")
suspend fun getAll(): List {
return repository.findAll()
}
@GetMapping("/{id}")
suspend fun getProblem(id:String): ProblemData? {
return repository.findByIdOrNull(UUID.fromString(id))
}
@PostMapping()
suspend fun addProblem(problemData: ProblemData) {
repository.insert(problemData)
}
}
```
Таким образом, Spring Data представляет удобные интерфейсы для доступа к Cassandra и, в сочетании с Spring Web, позволяет быстро создавать REST-интерфейсы для манипуляции данными из распределенного хранилища. Конечно, рассмотренный подход в production-системах вызовет проблемы из-за блокирующих вызовов и нужно либо использовать ThreadPoolExecutor, либо применять реактивную модель вызовов (в Spring Data или в драйвере Datastax) и использовать их совместно с корутинами, но это уже тема для следующей статьи.
*Все разработчики знают, что код очень часто превращается со временем в "большой комок грязи" (Big Ball of Mud), поддерживать который очень тяжело и дорого. Хочу пригласить всех, кто дочитал до этого момента на* [*бесплатный вебинар*](https://otus.pw/ApID/)*, который проведет мой коллега Сергей Окатов. На вебинаре обсудим как поддерживать чистую архитектуру приложения и контролируемо внедрять изменения. Также мы исследуем библиотеку для реализации бизнес-процессов, написанную на Kotlin. В завершении посмотрим пример модуля бизнес-логики, в котором сконцентрированы все требования заказчика.*
[Зарегистрироваться на вебинар](https://otus.pw/ApID/) | https://habr.com/ru/post/668524/ | null | ru | null |
# Разновидности объектно-ориентированного программирования (ОПП) в JavaScript. Часть 2
> **Для будущих студентов курса "**[**JavaScript Developer. Basic"**](https://otus.pw/pZGk/)**и всех желающих подготовили перевод полезной статьи.**
>
> **Приглашаем также посмотреть открытый урок на тему**[**"Прототипное наследование в JavaScript".**](https://otus.pw/1SnH/)
>
>
---
[В первой части](https://habr.com/ru/company/otus/blog/532944/) мы рассмотрели четыре различных разновидности Объектно-ориентированного программирования. Два из них — Классы и Фабричные функции — проще в использовании по сравнению с остальными.
Но вопросы остаются: Какую из них использовать? И почему?
Чтобы продолжить обсуждение функций Классов и Фабричных функций, необходимо понять три понятия, которые тесно связаны с Объектно-ориентированным программированием:
1. Наследование
2. Инкапсуляция
3. `this`
Мы только что говорили о наследстве. Теперь давайте поговорим об инкапсуляции.
### Инкапсуляция
Инкапсуляция — это большое слово, но оно имеет простое значение. Инкапсуляция — это акт помещения одной вещи внутрь другой, чтобы вещь внутри не просочилась наружу. Подумайте о том, чтобы хранить воду в бутылке. Бутылка предотвращает утечку воды.
В JavaScript мы заинтересованы в том, чтобы ограничить область видимости (которые могут включать в себя функции), чтобы эти переменные не просочились во внешнюю область видимости. Это означает, что для понимания инкапсуляции необходимо понимать границы видимости. Мы рассмотрим объяснение, но вы также можете использовать эту [статью](https://css-tricks.com/javascript-scope-closures/), чтобы подкрепить свои знания о диапазонах.
### Простая инкапсуляция
Самая простая форма инкапсуляции — блочная сфера применения.
```
{
// Variables declared here won't leak out
}
```
Когда вы находитесь в блоке, вы можете получить доступ к переменным, которые декларируются вне блока.
```
const food = 'Hamburger'
{
console.log(food)
}
```
**Замечание:** Переменные декларированные с `var` соблюдают область видимого блока. Поэтому [я рекомендую использовать let or const](https://zellwk.com/blog/es6/#let-and-const) для декларирования переменных.
### Инкапсулирование с функциями
Функции ведут себя как блок области. Когда вы декларируете переменную внутри функции, они не могут утечь из этой функции. Это работает для всех переменных, даже для тех, которые декларированы с помощью функции.
```
function sayFood () {
const food = 'Hamburger'
}
sayFood()
console.log(food)
```
Аналогично, когда вы находитесь внутри функции, вы можете получить доступ к переменным, которые декларируются вне этой функции.
```
const food = 'Hamburger'
function sayFood () {
console.log(food)
}
sayFood()
```
Функции могут возвращать значение. Это возвращаемое значение может быть использовано позже, вне функции.
```
function sayFood () {
return 'Hamburger'
}
console.log(sayFood())
```
#### Функции-замыкания
Функции-замыкания — это усовершенствованная форма инкапсуляции. Это просто функции, завернутые в функции.
```
// Here's a closure
function outsideFunction () {
function insideFunction () { /* ...*/ }
}
```
Переменные декларированные в `outsideFunction` могут быть использованы в `insideFunction`.
```
function outsideFunction () {
const food = 'Hamburger'
console.log('Called outside')
return function insideFunction () {
console.log('Called inside')
console.log(food)
}
}
// Calls `outsideFunction`, which returns `insideFunction`
// Stores `insideFunction` as variable `fn`
const fn = outsideFunction()
// Calls `insideFunction`
fn()
```
### Инкапсулирование и объектно-ориентированное программирование
Когда вы строите объекты, вы хотите сделать некоторые свойства общедоступными (чтобы люди могли их использовать). Но вы также хотите сохранить некоторые свойства приватными (чтобы другие не могли нарушить Вашу реализацию).
Давайте проработаем это на примере, чтобы сделать вещи более понятными. Допустим, у нас есть `a Car` blueprint. Когда мы производим новые автомобили, мы заправляем каждый автомобиль 50 литрами топлива.
```
class Car {
constructor () {
this.fuel = 50
}
}
```
Здесь мы раскрыли `fuel` свойство. Пользователи могут использовать `fuel`, чтобы получить количество топлива, оставшегося в их машинах.
```
const car = new Car()
console.log(car.fuel) // 50
```
Пользователи также могут использовать `fuel` свойство для установки любого количества топлива.
```
const car = new Car()
car.fuel = 3000
console.log(car.fuel) // 3000
```
Добавим условие и скажем, что каждый автомобиль имеет максимальную вместимость 100 литров. При таком условии мы не хотим, чтобы пользователи свободно устанавливали свойство топлива, потому что они могут сломать автомобиль.
Есть два способа запретить пользователям устанавливать `fuel` свойство:
1. Приватные по соглашению
2. Действительные приватные члены класса
### Приватные по соглашению
В JavaScript существует практика добавления подчеркивания**.** Это означает, что переменная является приватной и не должна использоваться.
```
class Car {
constructor () {
// Denotes that `_fuel` is private. Don't use it!
this._fuel = 50
}
}
```
Мы часто создаем методы, чтобы получить и установить переменную `fuel` "приватной”.
```
class Car {
constructor () {
// Denotes that `_fuel` is private. Don't use it!
this._fuel = 50
}
getFuel () {
return this._fuel
}
setFuel (value) {
this._fuel = value
// Caps fuel at 100 liters
if (value > 100) this._fuel = 100
}
}
```
Пользователи должны использовать методы `getFuel` и `setFuel` для получения и установки `fuel`.
```
const car = new Car()
console.log(car.getFuel()) // 50
car.setFuel(3000)
console.log(car.getFuel()) // 100
```
Но `fuel` на самом деле не приватный. Это все еще открытая переменная. Вы все еще можете получить к ней доступ, вы все еще можете использовать ее, и вы все еще можете злоупотреблять ею (даже если злоупотребление является случайностью).
```
const car = new Car()
console.log(car.getFuel()) // 50
car._fuel = 3000
console.log(car.getFuel()) // 3000
```
Нам нужно использовать действительные приватные переменные, если мы хотим полностью запретить пользователям доступ к ним.
### Действительные приватные члены класса
Здесь участники ссылаются на переменные, функции и методы. Это коллективный термин.
#### Приватные члены с классами
Классы позволяют создавать приватные члены класса, добавляя `#` к переменной.
```
class Car {
constructor () {
this.#fuel = 50
}
}
```
К сожалению, вы не можете использовать `#` напрямую в функции `constructor`
Сначала необходимо декларировать приватную переменную вне конструктора.
```
class Car {
// Declares private variable
#fuel
constructor () {
// Use private variable
this.#fuel = 50
}
}
```
В этом случае мы можем использовать сокращение и объявить `#fuel` заранее, так как мы установили fuel на 50.
```
class Car {
#fuel = 50
}
```
Вы не можете получить доступ к `#fuel` из `Car`. У вас будет ошибка.
```
const car = new Car()
console.log(car.#fuel)
```
Вам понадобятся методы (такие как `getFuel` или `setFuel`) чтобы использовать переменную `#fuel`.
```
class Car {
#fuel = 50
getFuel () {
return this.#fuel
}
setFuel (value) {
this.#fuel = value
if (value > 100) this.#fuel = 100
}
}
const car = new Car()
console.log(car.getFuel()) // 50
car.setFuel(3000)
console.log(car.getFuel()) // 100
```
> Примечание: Я предпочитаю `Getters` and `Setters` вместо `getFuel` и `setFuel`. [Синтакс легче читать.](https://zellwk.com/blog/why-use-getter-and-setter-functions/)
>
>
```
class Car {
#fuel = 50
get fuel () {
return this.#fuel
}
set fuel (value) {
this.#fuel = value
if (value > 100) this.#fuel = 100
}
}
const car = new Car()
console.log(car.fuel) // 50
car.fuel = 3000
console.log(car.fuel) // 100
```
### Приватные члены класса с фабричными функциями
Фабричные функции создают Приватных членов автоматически. Вам просто нужно декларировать переменную, как обычно. Пользователи не смогут получить эту переменную нигде больше. Причина в том, что переменные находятся в функции и, следовательно, инкапсулируются по умолчанию.
```
function Car () {
const fuel = 50
}
const car = new Car()
console.log(car.fuel) // undefined
console.log(fuel) // Error: `fuel` is not defined
```
Мы можем создать функции `getter` and `setter` чтобы использовать приватную переменную `fuel`.
```
function Car () {
const fuel = 50
return {
get fuel () {
return fuel
},
set fuel (value) {
fuel = value
if (value > 100) fuel = 100
}
}
}
const car = new Car()
console.log(car.fuel) // 50
car.fuel = 3000
console.log(car.fuel) // 100
```
Вот так! Просто и легко!
### Вердикт об инкапсуляции
Инкапсуляция с фабричными функциями проще и понятнее. Они опираются на сферы применения, которые составляют большую часть языка JavaScript.
Инкапсуляция с классами, с другой стороны, требует добавления `#` к приватной переменной. Это может сделать вещи неуклюжими.
Мы рассмотрим финальную концепцию — это для завершения сравнения между Классами и Фабричными функциями — в следующем разделе.
---
Классы в сравнении с Фабричными функциями — this переменная
-----------------------------------------------------------
`this` — один из основных аргументов против использования классов для объектно-ориентированного программирования. Почему? Потому что `this` значение изменяется в зависимости от того, как оно используется. Это может сбить с толку многих разработчиков (как новых, так и опытных).
Но концепция `this` относительно проста в реальности. Существует только шесть контекстов, в которых вы можете использовать `this`. Если вы освоите эти шесть контекстов, у вас не будет проблем с использованием `this`.
Шесть контекстов:
1. В глобальном контексте
2. В создании объекта
3. В свойстве объекта / метода
4. В простой функции
5. В стрелочной функции
6. В слушателе событий
[Я затронул эти 6 контекстов в деталях.](https://zellwk.com/blog/this/) Прочитайте, если вам нужно понять `this`.
> **Замечание:** [Не стесняйтесь изучить](https://zellwk.com/blog/should-you-use-this/) this. Это важная концепция, которую вам необходимо понять, если вы намерены овладеть JavaScript.
>
>
Возвращайся к этой статье после того, как закрепишь свои знания об `this`. Мы более подробно обсудим использование `this` в классах и фабричных функциях.
Уже вернулись? Хорошо. Поехали!
### Использование this в классах
`This` в случае использования в классе. (Он использует контекст "В свойстве/методе объекта".) Вот почему свойства и методы можно устанавливать на экземпляре внутри функции `constructor`.
```
class Human {
constructor (firstName, lastName) {
this.firstName = firstName
this.lastName = lastName
console.log(this)
}
}
const chris = new Human('Chris', 'Coyier')
```
### Использование This в функции Конструктора
Если вы используете `this` в функции и `new` чтобы создать экземпляр, `this` будет ссылаться на экземпляр. Так создается функция Конструктора.
```
function Human (firstName, lastName) {
this.firstName = firstName
this.lastName = lastName
console.log(this)
}
const chris = new Human('Chris', 'Coyier')
```
Я упомянул о функциях конструктора, потому что вы можете использовать `this` внутри фабричных функций. Но `this` указывает на Window (или `undefined` если вы используете ES6 Модули, или пакеты такие как webpack).
```
// NOT a Constructor function because we did not create instances with the `new` keyword
function Human (firstName, lastName) {
this.firstName = firstName
this.lastName = lastName
console.log(this)
}
const chris = Human('Chris', 'Coyier')
```
По существу, когда вы создаете фабричную функцию, вы не должны использовать `this` как будто это функция Конструктора. Это одна маленькая заминка, которую люди испытывают с `this`. Я хотел осветить проблему и прояснить ее.
### Использование This в фабричной функции
Правильным способом использования `this` в фабричные функции является его использование в контексте "свойство/метод объекта".
```
function Human (firstName, lastName) {
return {
firstName,
lastName,
sayThis () {
console.log(this)
}
}
}
const chris = Human('Chris', 'Coyier')
chris.sayThis()
```
Несмотря на то, что вы можете использовать `this` в фабричных функциях, вам не нужно их использовать. Вы можете создать переменную, указывающую на экземпляр. Как только вы это сделаете, вы можете использовать эту переменную вместо `this`. Вот пример в работе.
```
function Human (firstName, lastName) {
const human = {
firstName,
lastName,
sayHello() {
console.log(`Hi, I'm ${human.firstName}`)
}
}
return human
}
const chris = Human('Chris', 'Coyier')
chris.sayHello()
```
`human.firstName` ясней чем `this.firstName` потому что `human` бесконечно указывает на экземпляр. Ты знаешь, когда видишь код.
Если вы привыкли к JavaScript, вы также можете заметить, что нет необходимости даже писать `human.firstName` изначально! Достаточно только `firstName` потому что `firstName` находится в лексическом диапазоне. (Прочитайте [эту статью](https://css-tricks.com/javascript-scope-closures/) если вам необходима помощь с областью применения.)
```
function Human (firstName, lastName) {
const human = {
firstName,
lastName,
sayHello() {
console.log(`Hi, I'm ${firstName}`)
}
}
return human
}
const chris = Human('Chris', 'Coyier')
chris.sayHello()
```
То, что мы пока охватили, очень просто. Нелегко решить, действительно ли `this` необходимо, пока мы не создадим достаточно сложный пример. Так что давайте сделаем это.
### Детальный пример
Вот и схема. Допустим, у нас есть `Human blueprint`. У `Human` есть свойства `firstName` и `lastName`, и метод `sayHello`.
У нас есть Developer `blueprint`, который выходит из `Human`. Разработчики могут программировать, так что у них будет метод `code`. Разработчики также хотят декларировать, что они разработчики, так что нам нужно перезаписать `sayHello` и добавить `I'm a Developer` к консоли.
Мы создадим этот пример с Классами и Фабричными функциями. (Приведем пример с `this` и пример без `this` для фабричных функций).
### Пример с Классами
Для начала у на есть `Human blueprint`. У `Human` есть свойства `firstName` и `lastName`, а также метод `sayHello`.
```
class Human {
constructor (firstName, lastName) {
this.firstName = firstName
this.lastname = lastName
}
sayHello () {
console.log(`Hello, I'm ${this.firstName}`)
}
}
```
У нас есть `Developer blueprint` который выходит из `Human`. Разработчики могут кодить, так что у них будет метод `code`.
```
class Developer extends Human {
code (thing) {
console.log(`${this.firstName} coded ${thing}`)
}
}
```
Разработчики также хотят заявить, что они разработчики. Нам нужно переписать `sayHello` и добавить `I'm a Developer` в консоль. Мы это делаем вызывая метод `Human‘s sayHello`. Мы делаем это используя `super`.
```
class Developer extends Human {
code (thing) {
console.log(`${this.firstName} coded ${thing}`)
}
sayHello () {
super.sayHello()
console.log(`I'm a developer`)
}
}
```
### Пример фабричных функций (с this)
Также, во-первых, у нас есть `Human blueprint`. У `Human` есть свойства `firstName` и `lastName`, а также метод `sayHello`.
```
function Human () {
return {
firstName,
lastName,
sayHello () {
console.log(`Hello, I'm ${this.firstName}`)
}
}
}
```
Следующее, у нас есть `Developer blueprint` который выходит из `Human`. Разработчики могут программировать, так что у них будут метод `code`.
```
function Developer (firstName, lastName) {
const human = Human(firstName, lastName)
return Object.assign({}, human, {
code (thing) {
console.log(`${this.firstName} coded ${thing}`)
}
})
}
```
Разработчики также хотят заявить, что они разработчики. Нам нужно переписать `sayHello` и добавить `I'm a Developer` в консоль. Мы это делаем вызывая метод `Human‘s sayHello`. Мы делаем это используя экземпляр `human`.
```
function Developer (firstName, lastName) {
const human = Human(firstName, lastName)
return Object.assign({}, human, {
code (thing) {
console.log(`${this.firstName} coded ${thing}`)
},
sayHello () {
human.sayHello()
console.log('I\'m a developer')
}
})
}
```
### Пример фабричных функций (без this)
Вот полный код, использующий фабричные функции (с `this`):
```
function Human (firstName, lastName) {
return {
firstName,
lastName,
sayHello () {
console.log(`Hello, I'm ${this.firstName}`)
}
}
}
function Developer (firstName, lastName) {
const human = Human(firstName, lastName)
return Object.assign({}, human, {
code (thing) {
console.log(`${this.firstName} coded ${thing}`)
},
sayHello () {
human.sayHello()
console.log('I\'m a developer')
}
})
}
```
Вы заметили, что `firstName` доступен в области лексики у обоих `Human` и `Developer`? Это значит, что мы можем пропустить `this` и использовать `firstName` напрямую в обоих `blueprints`
```
function Human (firstName, lastName) {
return {
// ...
sayHello () {
console.log(`Hello, I'm ${firstName}`)
}
}
}
function Developer (firstName, lastName) {
// ...
return Object.assign({}, human, {
code (thing) {
console.log(`${firstName} coded ${thing}`)
},
sayHello () { /* ... */ }
})
}
```
Видите? Это означает, что вы можете безопасно пропустить `this` из своего кода при использовании фабричных функций.
### Вердикт для this
Проще говоря, Классы требуют `this`, а Фабричные функции — нет. Я предпочитаю фабричные функции здесь, потому что:
• Контекст this может измениться (что может сбить с толку).
• Код, написанный с помощью фабричных функций, короче и чище (так как мы можем использовать инкапсулированные переменные без написания `this.#variable`).
Далее следует последний раздел, где мы строим простой компонент вместе с Классами и фабричными функциями. Вы увидите, чем они отличаются и как использовать слушателей событий с каждой особенностью
### Классы против Фабричных функций — Слушатели событий
Большинство статей по объектно-ориентированному программированию показывают примеры без слушателей событий. Эти примеры может быть проще понять, но они не отражают работу, которую мы выполняем как фронтенд-разработчики. Работа, которую мы выполняем, требует наличия слушателей событий — по простой причине — потому что нам нужно строить вещи, которые полагаются на пользовательский ввод.
Так как [слушатели событий меняют контекст](https://zellwk.com/blog/this/) `this`, они могут сделать классы неудобными в работе. В то же время они делают фабричные функции более привлекательными.
Но на самом деле это не так.
Изменение в `this` не имеет значения, если вы знаете, как справиться с `this` как в Классах, так и в Фабричных функциях. Мало статей на эту тему, так что я подумал, что было бы неплохо дополнить эту статью простым компонентом, использующим разнообразие по объектно-ориентированному программированию.
### Построение счетчика
В этой статье мы построим простой счетчик. Мы будем использовать все, что вы узнали в этой статье — включая приватные переменные.
Допустим, счетчик содержит две вещи:
1. Сам счетчик
2. Кнопку для увеличения количества
Вот самый простой HTML для счетчика:
```
Count: 0
Increase Count
```
Построение счетчика с Классами
Для простоты мы попросим пользователей найти и передать HTML счетчика в класс `Counter`.
```
class Counter () {
constructor (counter) {
// Do stuff
}
}
// Usage
const counter = new Counter(document.querySelector('.counter'))
```
Нам нужно получить два элемента в классе Счетчик:
1. , который содержит счетчик — нам нужно обновить этот элемент, когда счетчик увеличится.
2. Кнопка `> — нам нужно добавить слушателя событий в этот класс элементов.`
```
Counter () {
constructor (counter) {
this.countElement = counter.querySelector('span')
this.buttonElement = counter.querySelector('button')
}
}
```
Мы инициализируем `count` и устанавливаем ее в то, что показывает элемент `countElement`. Мы будем использовать приватную `#count`, так как счетчик не должен быть выставлен в другом месте.
```
class Counter () {
#count
constructor (counter) {
// ...
this.#count = parseInt(countElement.textContent)
}
}
```
Когда пользователь нажимает кнопку , мы хотим увеличить `#count`. Мы можем сделать это с помощью другого метода. Мы назовем этот метод `increaseCount`.
```
class Counter () {
#count
constructor (counter) { /* ... */ }
increaseCount () {
this.#count = this.#count + 1
}
}
```
Далее, нам нужно обновить DOM новым `#count`. Для этого создадим метод под названием `updateCount`. Мы будем называть `updateCount` из `increaseCount`
```
class Counter () {
#count
constructor (counter) { /* ... */ }
increaseCount () {
this.#count = this.#count + 1
this.updateCount()
}
updateCount () {
this.countElement.textContent = this.#count
}
}
```
Теперь мы готовы добавить слушателя событий.
### Добавление слушателя событий
Мы добавим слушателя событий в `this.buttonElement`. К сожалению, мы не можем сразу использовать `increaseCount` в качестве обратного вызова. Вы получите ошибку, если попробуете.
```
class Counter () {
// ...
constructor (counter) {
// ...
this.buttonElement.addEventListener('click', this.increaseCount)
}
// Methods
}
```
Вы получаете ошибку, потому что `this` указывает на `buttonElement`. (Это контекст слушателя событий.) Вы увидите `buttonElement`, если войдете в консоль.
Нам нужно изменить значение `this` обратно в экземпляр для `increaseCount`, чтобы все заработало. Есть два способа сделать это:
1. Использовать `bind`
2. Использовать стрелочные функции
Большинство людей используют первый метод (но второй проще).
### Добавление слушателя событий с bind
`Bind` возвращает новую функцию. Она позволяет изменить `this` на первый переданный аргумент. Обычно люди создают слушателей событий, вызывая `bind(this)`.
```
class Counter () {
// ...
constructor (counter) {
// ...
this.buttonElement.addEventListener('click', this.increaseCount.bind(this))
}
// ...
}
```
Это работает, но не очень приятно читать. Он также неудобен для начинающих, потому что `bind` рассматривается как продвинутая функция JavaScript.
#### Стрелочные функции
Второй способ — использование стрелочных функций. Стрелочные функции работают, так как они сохраняют значение `this` в лексическом контексте.
Большинство людей пишут методы внутри обратного вызова стрелочных функций, как это:
```
class Counter () {
// ...
constructor (counter) {
// ...
this.buttonElement.addEventListener('click', _ => {
this.increaseCount()
})
}
// Methods
}
```
Это работает, но это долгий путь. Вообще-то, есть короткий путь.
Вы можете создать `increaseCount` с помощью функций со стрелками. Если вы сделаете это, то это значение для `increaseCount` будет привязано к значению экземпляра сразу.
Итак, вот код, который вам нужен:
```
class Counter () {
// ...
constructor (counter) {
// ...
this.buttonElement.addEventListener('click', this.increaseCount)
}
increaseCount = () => {
this.#count = this.#count + 1
this.updateCounter()
}
// ...
}
```
Код
---
Вот полная версия кода на основе классов (с использованием стрелочных функций).
**HTML**
```
Count: 0
Increase Count
```
**CSS**
```
html {
font: 1em sans-serif;
}
body {
padding: 1em;
}
p {
font-size: 2em;
line-height: 1;
margin: 1rem 0;
}
button {
font: inherit;
padding: 0.5em 0.75em;
background-color: #eee;
border: 1px solid #222;
color: black;
}
```
**Babel**
```
class Counter {
#count = 0
constructor (counter) {
this.countElement = counter.querySelector('span')
this.buttonElement = counter.querySelector('button')
// Initializes count
this.#count = parseInt(this.countElement.textContent)
// Adds event listener
this.buttonElement.addEventListener('click', this.increaseCount)
}
updateCounter () {
this.countElement.textContent = this.#count
}
increaseCount = () => {
this.#count = this.#count + 1
this.updateCounter()
}
}
const counter = new Counter(document.querySelector('.counter'))
```
Результат:
### Создание счетчика с фабричными функциями
Мы сделаем то же самое здесь. Мы заставим пользователей передать HTML счетчика на фабричный `Counter`.
```
function Counter (counter) {
// ...
}
const counter = Counter(document.querySelector('.counter'))
```
Нам нужно получить два элемента из `counter` — и . Здесь мы можем использовать обычные переменные (без `this`), потому что они уже являются приватными. Мы не будем их раскрывать.
```
function Counter (counter) {
const countElement = counter.querySelector('span')
const buttonElement = counter.querySelector('button')
}
```
Мы инициализируем переменную счетчика значением, присутствующим в HTML.
```
function Counter (counter) {
const countElement = counter.querySelector('span')
const buttonElement = counter.querySelector('button')
let count = parseInt(countElement.textContext)
}
```
Мы увеличим переменную `count` методом `increaseCount`. Здесь можно выбрать обычную функцию, но мне нравится создавать метод, чтобы все было аккуратно и аккуратно.
```
function Counter (counter) {
// ...
const counter = {
increaseCount () {
count = count + 1
}
}
}
```
Наконец, мы обновим счет методом `updateCount`. Мы также вызовем `updateCount` из метода `increaseCount`.
```
function Counter (counter) {
// ...
const counter = {
increaseCount () {
count = count + 1
counter.updateCount()
}
updateCount () {
increaseCount()
}
}
}
```
Обратите внимание, что я использовал `counter.updateCount` вместо `this.updateCount`? Мне это нравится, потому что `counter` более понятен по сравнению с `this`. Я также делаю это, потому что новички могут также сделать ошибку с `this` внутри фабричных функций (о которых я расскажу позже).
### Добавление слушателей событий
Мы можем добавить слушателей событий в `buttonElement`. Когда мы это сделаем, то сразу же сможем использовать `counter.increaseCount` в качестве обратного вызова.
Мы можем сделать это, потому что мы не использовали `this`, так что это не имеет значения, даже если слушатели события изменят значение `this`.
```
function Counter (counterElement) {
// Variables
// Methods
const counter = { /* ... */ }
// Event Listeners
buttonElement.addEventListener('click', counter.increaseCount)
}
```
### Понимание this
`this` можно использовать в фабричных функциях. Но вы должны использовать `this` в контексте метода.
В следующем примере, если вы вызываете `counter.increaseCount`, JavaScript также вызовет `counter.updateCount`. `this` работает, так как указывает на переменную `counter`.
```
function Counter (counterElement) {
// Variables
// Methods
const counter = {
increaseCount() {
count = count + 1
this.updateCount()
}
}
// Event Listeners
buttonElement.addEventListener('click', counter.increaseCount)
}
```
К сожалению, слушатель событий не смог бы работать, так как `this` значение было изменено. Вам понадобится то же самое, что и к классам — с функциями `bind` или стрелками, чтобы заставить слушателя событий снова работать.
И это приводит меня ко второму пониманию.
### Второе понимание this
Если вы используете синтаксис фабричной функции, вы не можете создавать методы с помощью стрелочных функций. Это связано с тем, что методы создаются [в контексте простой функции.](https://zellwk.com/blog/this/#this-in-a-simple-function)
```
function Counter (counterElement) {
// ...
const counter = {
// Do not do this.
// Doesn't work because `this` is `Window`
increaseCount: () => {
count = count + 1
this.updateCount()
}
}
// ...
}
```
Так что я настоятельно рекомендую полностью пропустить `this`, если вы используете фабричные функции. Так намного проще.
Код
---
**HTML**
```
Count: 0
Increase Count
```
**CSS**
```
html {
font: 1em sans-serif;
}
body {
padding: 1em;
}
p {
font-size: 2em;
line-height: 1;
margin: 1rem 0;
}
button {
font: inherit;
padding: 0.5em 0.75em;
background-color: #eee;
border: 1px solid #222;
color: black;
}
```
**Babel**
```
function Counter (counterElement) {
const countElement = counterElement.querySelector('span')
const buttonElement = counterElement.querySelector('button')
let count = parseInt(countElement.textContent) || 0
const counter = {
updateCounter () {
countElement.textContent = count
},
increaseCount: (event) => {
count = count + 1
counter.updateCounter()
}
}
buttonElement.addEventListener('click', counter.increaseCount)
}
const counter = Counter(document.querySelector('.counter'))
```
### Вердикт для слушателей события
Слушатели событий изменяют `this` значение, поэтому мы должны быть очень осторожны в использовании значения `this`. Если вы используете Классы, я рекомендую создавать обратные вызовы слушателей событий с стрелочными функциями, так что вам не придется использовать `bind`.
Если вы используете фабричные функции, я рекомендую пропустить `this` полностью, потому что это может сбить вас с толку. Вот и все!
### Заключение
Мы говорили о четырех разновидностях Объектно-ориентированного программирования таких как:
1. Функции конструктора
2. Классы
3. OLOO
4. Фабричные функции
* Во-первых, мы пришли к выводу, что Классы и фабричные функции легче использовать с точки зрения кода.
* Во-вторых, мы сравнили, как использовать Подклассы с Классами и Фабричными функциями. Здесь мы видим, что создание Подклассов проще с Классами, но Состав проще с Фабричными функциями.
* В-третьих, мы сравнили Инкапсуляцию с Классами и Фабричными функциями. Здесь мы видим, что инкапсуляция с фабричными функциями естественна, как и в JavaScript, в то время как инкапсуляция с классами требует добавления переменной `#` перед переменными.
* В-четвертых, мы сравнили использование `this` в Классах и Фабричных функциях. Я чувствую, что Фабричные функции здесь выигрывают, потому что `this` может быть неоднозначно. Написание `this.#privateVariable` также создает более длинный код по сравнению с использованием самой `privateVariable`.
Наконец, в этой статье мы построили простой Счетчик с Классами и Фабричными функциями. Вы научились добавлять слушателей событий в обе особенности Объектно-ориентированного программирования. Здесь обе особенности работают. Нужно просто быть осторожным, используете вы это или нет.
Вот и все!
Надеюсь, это прольет свет на объектно-ориентированное программирование на JavaScript для вас.
Если у вас есть вопросы по JavaScript или передовым разработкам в целом, не стесняйтесь [обращаться ко мне](https://zellwk.com/contact). Посмотрим, чем я могу помочь!
---
> [**Узнать подробнее о курсе**](https://otus.pw/pZGk/)**"JavaScript Developer. Basic".**
>
> [**Посмотреть открытый урок на тему**](https://otus.pw/1SnH/)**"Прототипное наследование в JavaScript"**[**.**](https://otus.pw/1SnH/)
>
>
**Рекомендуем обратить внимание на смежные курсы:**
* [**JavaScript**Developer. Professional](https://otus.pw/Egx4/)
* [**React.js**Developer](https://otus.pw/rOcE/)
* [**Node.js**Developer](https://otus.pw/c2u8/) | https://habr.com/ru/post/532946/ | null | ru | null |
# Автоматизация SSH-доступа к нодам Kubernetes с помощью Fabric и интеграции от CoreOS
Несмотря на то, что Kubernetes представляет мир, в котором SSH не так нужен в повседневном использовании для деплоя и управления приложениями, по-прежнему бывают случаи, когда SSH полезен для сбора статистики, отладки и исправления конфигураций. Пусть через несколько лет SSH и запуск разовых отладочных сессий может уже не понадобиться, описанные ниже инструменты могут пригодиться сейчас для быстрого SSH-подключения к машинам из кластера Kubernetes.
Kubernetes хранит базу данных нод кластера, просмотреть которую можно командой `kubectl get nodes`. Это мощный фундамент для автоматизации и интеграции с существующими инструментами. Одним из таких инструментов является SSH-утилита [Fabric](http://www.fabfile.org/), известная ещё как `fabfile.py`.
> **Прим. перев.**: Fabric — написанная на Python библиотека и командная утилита, упрощающая SSH-доступ при деплое приложений и системном администрировании. Она обеспечивает как простейшее выполнение shell-команд, так и более сложные операции: загрузку/скачивание файлов, запрос пользовательского ввода, прерывание исполнения процесса. Типичное использование fabfile — создание модуля на Python, реализующего одну или несколько функций, после чего они вызываются посредством консольной утилиты `fab`. Подробнее о возможностях Fabric можно прочитать в [официальной документации](http://docs.fabfile.org/en/1.13/tutorial.html).
Начало работы
-------------
Установите SSH-утилиту Fabric и проверьте её наличие:
```
$ fab --version
Fabric 1.13.1
```
> **Прим. перев.**: В случае Ubuntu достаточно установить пакет `fabric`, который [доступен](http://packages.ubuntu.com/xenial/fabric) в основных репозиториях.
Склонируйте этот Git-репозиторий *(с наработками по интеграции от CoreOS — прим. перев.)* и перейдите в каталог с ним:
```
git clone https://github.com/coreos/fabric-kubernetes-nodes
cd fabric-kubernetes-nodes
```
Fabric будет использовать `fabfile.py` из корня этой директории. Поэтому теперь узлы и лейблы Kubernetes доступны в Fabric. Вот пример сессии, использующей эту интеграцию:
```
$ kubectl get nodes
NAME STATUS AGE
ip-10-0-0-50.us-west-2.compute.internal Ready 22d
ip-10-0-60-201.us-west-2.compute.internal Ready 22d
ip-10-0-95-156.us-west-2.compute.internal Ready 22d
$ kubectl label node ip-10-0-0-50.us-west-2.compute.internal fab-admin=true
node "ip-10-0-0-50.us-west-2.compute.internal" labeled
$ fab -u core -R fab-admin=true -- date
[52.26.54.211] Executing task ''
[52.26.54.211] run: date
[52.26.54.211] out: Wed Feb 15 22:42:47 UTC 2017
[52.26.54.211] out:
Done.
Disconnecting from 52.26.54.211... done.
```
Узел-бастион или шлюз
---------------------
Многие конфигурации Kubernetes, такие как CoreOS Tectonic, не включают прямой SSH-доступ к машинам в кластере — вместо этого пользователям необходимо сначала подключиться к шлюзу или узлу-бастиону (bastion host). Если кластер Kubernetes настроен таким образом, добавьте к команде флаг `--gateway` и измените тип адреса на `InternalIP`.
```
$ export FAB_KUBE_NODE_ADDRESS_TYPE=InternalIP
$ fab --gateway=W.X.Y.Z -u core -R failure-domain.beta.kubernetes.io/zone=us-west-2a -- date
[10.0.3.24] Executing task ''
[10.0.3.24] run: date
[10.0.3.24] out: Mon May 1 02:50:13 UTC 2017
[10.0.3.24] out:
[10.0.60.15] Executing task ''
[10.0.60.15] run: date
[10.0.60.15] out: Mon May 1 02:50:16 UTC 2017
[10.0.60.15] out:
Done.
Disconnect
```
По умолчанию fabfile будет использовать внешние IP (`ExternalIP`) нод. Однако его можно настроить на любые IP-адреса, которые есть у ноды. Пример выше использует общее поле `InternalIP`, а чтобы изменить его на произвольный `SpecialIP`, экспортируйте переменную окружению соответствующим образом (`FAB_KUBE_NODE_ADDRESS_TYPE=SpecialIP`).
Больше информации об интеграции Fabric с Kubernetes можно почерпнуть из [репозитория GitHub](https://github.com/coreos/fabric-kubernetes-nodes).
***Послесловие переводчика**: в репозитории на самом деле просто продублирован этот tutorial, так что дополнительных сведений вы не найдёте (по крайней мере — по состоянию на сейчас). Зато можно изучить очень лаконичный [fabfile.py](https://github.com/coreos/fabric-kubernetes-nodes/blob/master/fabfile.py), который легко расширить под свои нужды (тем более, что распространяется он на условиях свободной Apache License 2.0).* | https://habr.com/ru/post/328648/ | null | ru | null |
# Как победить на собеседовании. Несколько крайне полезных советов для разработчиков
*От автора: я разработал и провёл десятки собеседований по программированию. Здесь я расскажу, как меня обыграть*
Будем честными, большинство программистов не любят писать код на собеседовании. Некоторые даже [угрожают уйти из профессии](https://medium.com/@evnowandforever/f-you-i-quit-hiring-is-broken-bb8f3a48d324) по этой причине. Но в ближайшее время ничего не изменится. Так что если вы действительно хотите получить работу, то придётся понять, как можно добиться успеха на этих собеседованиях. Я помогу вам. Мы изучим процесс, и я объясню, что именно я хочу добиться от собеседования, так что у вас сложится довольно чёткое представление, как его пройти.
Прежде чем начать, сразу хочу сказать, что если компания собирается нанять разработчика ***только*** и ***исключительно*** на основе фрагмента кода, который он написал на собеседовании, то вероятно, вы не захотите работать в такой компании.
*Ты больше, чем просто машина для кодинга*
Часть 1. Программирование на доске
----------------------------------
Кто вообще в этом мире программирует на доске? В самом деле, серьёзно. Тем не менее, я попрошу вас сделать это. Не волнуйтесь, я не сошёл с ума. Я знаю о Google и что доска плохо справляется с автодополнением. Меня это не волнует. Я проверяю не то, насколько красивый код вы пишете на доске, а кое-что другое.
Когда вы получите работу, вам ***никогда*** не придётся программировать на доске. Но я гарантирую, что наступит момент, когда мы все будем ломать головы над проблемой перед самым дедлайном, когда мы вымотаны в край, на нас все злятся, а на кону стоит наша работа и репутация. Когда наступит такой момент, мы пойдём в переговорную, столпимся возле доски и будем выяснять, что делать. Быстро.
### *«Я проверяю не то, насколько красивый код вы пишете на доске»*
Хотя мне не нужен программист, который пишет красивый код на доске, но мне нужен тот, кто способен быстро думать на ходу, под давлением, в одной комнате с другими. Проблема в том, что если вы не понимаете, что именно я проверяю, то всё сделаете неправильно. Вы собираетесь доказать, что вы настоящий ниндзя в программировании на доске. Это глупо. Никому не нужен ниндзя в программировании на доске. Вот как меня победить:
#### 1. Вербализуйте свои допущения и постарайтесь их подтвердить
**Лучшие разработчики знают, что в фундаментальном смысле каждый баг — это результат неверного допущения**. Так что перед тем, как начать писать код, подумайте о необходимых допущениях и спросите меня о них.
#### 2. Думайте вслух
Я хочу получить некоторое представление о вашем мыслительном процессе. Для меня гораздо ценнее ваши размышления о проблеме, чем знание наизусть названия какой-то встроенной функции. Так что думайте вслух. Произносите всё, что приходит в голову.
#### 3. Не бойтесь попросить помощи
Если вы застряли или чего-то не знаете, спросите меня. Вы представить не можете, насколько фантастически дорого компании обходится разработчик, который отказывается просить о помощи, когда где-то застрял. У меня нет времени на программиста, который не даёт результат, потому что делает вид, что у него всё под контролем, а сам бессильно барахтается в одиночестве.
#### 4. Честно покажите свои способности и опыт
Не хочу вас обманывать предыдущим советом. Есть определённый уровень для вопросов и комментариев. Если вы спрашиваете о том, что должно быть очевидно человеку с соответствующими записями в резюме, то это красный флаг. Так что перед началом программирования на доске убедитесь в том, что вы честны со мной в репрезентации своих способностей и опыта.
Часть 2. Программирование на компьютере
---------------------------------------
В отличие от доски, если я приглашаю вас за компьютер и прошу написать код, то я ***действительно*** проверяю, как хорошо вы программируете. Точнее, я проверяю ваше умение ***соблюдать правила***.
Лучше всего понять это, если посмотреть на реальный пример. Один из моих любимых вопросов такой:
> Палиндром — это число, буквосочетание, слово или текст, одинаково читающееся в обоих направлениях. Разрешаются корректировки к прописным буквам, пунктуации и пробелам. Некоторые примеры на английском: “A man, a plan, a canal, Panama!”, “Amor, Roma”, “race car”, “stack cats”, “step on no pets”, “taco cat”, “put it up”, “Was it a car or a cat I saw?” и “No ‘x’ in Nixon”.
>
>
>
> Напишите самую эффективную функцию, какую сможете найти, чтобы определить, является ли данная строка палиндромом.
>
>
>
> Ваша функция должна принимать строку как параметр и возвращать булево значение (*true*, если строка является палиндромом, и *false*, если не является).
>
>
>
> Предполагайте, что этот код будет поставлен в реальную систему на рабочем сервере, и пишите соответственно с этим.
Когда я предлагаю такую задачу на собеседовании, первым делом я смотрю, зададите вы мне дополнительные вопросы или нет. Как я уже говорил раньше, лучшие программисты понимают, что допущения — это именно то, что убивает вас в этом бизнесе. Мой совет каждому, кто получил инструкции для написания кода, — сделать паузу и подумать, какие допущения следует сделать для того, чтобы выполнить задание (они всегда есть) и найти способ подтвердить или прояснить эти допущения. Я понимаю, что во время выполнения задачи люди уходят в «тестовый режим» и думают, что им запрещено говорить. Я же полагаю, что вы начнёте с вопроса интервьюеру: «Мне разрешено задать вам один или два вопроса, чтобы прояснить некоторые допущения?» (Я всегда отвечаю «да»), и тогда вы получите ОГРОМНОЕ преимущество.
Хорошие вопросы для этой конкретной задачи:
* Здесь клиентский JavaScript или на стороне сервера?
* В контексте данной задачи может ли считаться пустая строка валидной строкой на входе?
* Нужно ли обрабатывать символы Unicode?
Далее я смотрю, насколько хорошо вы следуете инструкциям. Например, я определил строку как параметр и булево значение как результат. Это то, что выдаёт программа?
Затем я хочу посмотреть, как вы интерпретируете фразу «Предполагайте, что этот код будет поставлен в реальную систему на рабочем сервере, и пишите соответственно с этим». Если вы раньше разрабатывали рабочий софт, то понимаете, что эта фраза означает несколько вещей:
* В коде должны быть комментарии.
* Нужно предусмотреть обработку ошибок или хотя бы ведение логов.
* Программу следует обложить тестами.
* Программа не должна сбоить ни в коем случае.
* Код должен быть легко читаем и говорить сам за себя (легко понятные имена переменных, хорошее форматирование, в идеале — без сложных конструкций и дефектов (“lint free”)
Если вы раньше видели код только в учебниках и руководствах, то не знаете, что означают вышеперечисленные вещи. Мой совет: посмотрите на код популярных open source проектов. Особенно тех проектов, которые развиваются уже давно и стабильны. Для JavaScript вполне хорошим примером будет код jQuery на GitHub.
Далее, мне интересно посмотреть, как вы понимаете слово «эффективный» в сочетании с «продакшн системой». Если у вас есть опыт, то вы понимаете, что понятие «эффективный» для программы в продакшне означает три вещи:
1. Быстро работает.
2. Не занимает память, когда она ей не нужна.
3. Стабильна и легко поддерживается.
Вы должны понимать, что пункт № 3 иногда означает некоторый ущерб для пунктов № 1 и № 2.
В этой конкретной задаче я предполагаю, что многие будут применять здесь регулярные выражения. Они универсально подходят для многих языков, быстры и исключительно удобны (***правка***: регулярные выражения не ***всегда*** работают быстро, в том числе с палиндромом, спасибо *AlexDenisov* в комментариях). Будет вполне обоснованным предположить, что вы знаете основы регулярных выражений, но вы всё равно можете написать код и без них.
Насчёт тестов я хочу увидеть, что вы предусмотрите много тестов, но все они будут проверять действительно разные сценарии. Проверка “mom”, “dad” и “racecar” избыточна, это всё один и тот же тест. Я также ожидаю увидеть, что вы включите тесты на прочность (краш-тесты); тесты каких-нибудь строк, которые не являются палиндромами. Рассматривайте пограничные случаи, проверяйте нуль или число. Проверяйте пустую строку или набор специальных символов.
Я задаю эту задачу разработчикам всех уровней, но чем опытнее специалисты, тем более строгие критерии.
Если джуниор выдаёт работоспособное и достаточно простое решение, и всё остальное собеседование проходит нормально, этого достаточно для начала работы и повышения своих навыков.
Для разработчиков среднего уровня хочется видеть какие-то комментарии и хороший стиль программирования. Хочется видеть эффективное решение и, возможно, какой-то тест.
Для ведущих программистов хотелось бы видеть оптимальное решение, чистый и поддерживаемый код, обработку ошибок, комментарии, полный набор тестов. Например, если вы применяете *console.log()* в JavaScript на стороне клиента, то добавьте комментарий, который даёт понять, что вы знаете о необходимости поддержки логгирования также на стороне сервера.
Вот [пример хорошего кода](https://gist.github.com/anonymous/b35341f959261faeb0bf476e050eeacd), написанного на JavaScript.
```
'use strict'; // avoid ambiguity and sloppy errors
/**
* Tests wether or not a given string is a Palindrome
* @param {string} stringToTest - the string to test.
*/
function isPalindrome(stringToTest) {
var start = 0,
end;
// make sure we have a string.
if (typeof stringToTest !== "string") {
// throw if we didn't get a string
throw new TypeError("isPalindrome() expected a string, but got " +
Object.prototype.toString.call(stringToTest) + " instead!");
}
// normalize string by lowercasing and removing non-word characters
stringToTest = stringToTest
.toLowerCase()
.replace(/[^a-z0–9]/ig, '');
if (stringToTest.length === 0) {
// warn if we have no valid characters to test
console.log("No valid characters to test, treated as empty string" +
"\nStack: \n" + new Error().stack);
return true; // an empty string is a palindrome.
}
end = stringToTest.length - 1;
// compare characters from outside in. stop when we get to the middle.
while (start < end) {
if (stringToTest[start] !== stringToTest[end]) {
return false;
} else {
start++;
end--;
}
}
// if we get here, it's a palindrome
return true;
}
// tests (should be in a seperate file using a test framework)
console.log(isPalindrome("something that is not a palindrome") + " = false");
console.log(isPalindrome("something that is \n not a palindrome") + " = false");
console.log(isPalindrome("race \n car") + " = true");
console.log(isPalindrome("") + " = true + warn");
console.log(isPalindrome(" ") + " = true + warn");
console.log(isPalindrome("1221") + " = true");
console.log(isPalindrome("0") + " = true");
console.log(isPalindrome("racecar") + " = true");
console.log(isPalindrome("No 'x' in Nixon!") + " = true");
console.log(isPalindrome("~~!~!~") + " = true + warn");
console.log(isPalindrome("Momsie") + " = false");
console.log(isPalindrome(12)); // blow up
console.log(isPalindrome(undefined)); // blow up
console.log(isPalindrome(null)); // blow up
```
Очевидно, есть другие способы написать подходящую программу, но это даёт представление, о чём я говорю.
Если я даю задание на дом, то ожидания ещё выше.
Часть 3. Алгоритмы
------------------
Некоторые интервьюеры будут просить написать реализацию конкретного алгоритма. Лично я считаю это гигантской потерей времени. Гораздо более важно для меня, чтобы вы понимали, какой алгоритм применить для какой задачи. Реализацию всегда можно найти в Google.
Тем не менее, поскольку интервьюеры попросят это, лучше освежить знания в памяти перед собеседованием. На Khan Academy есть отличный [бесплатный курс](https://www.khanacademy.org/computing/computer-science/algorithms).
Часть 4. Не сдаваться без борьбы
--------------------------------
Если вы не способны решить предложенную задачу, всегда есть некоторые вещи, которые можно сделать, чтобы сохранить шансы получить должность.
#### 1. Не сдавайтесь слишком легко
Убедитесь, что я заметил ваши усилия. Если вы из тех, кто сдаётся, когда становится трудно, я не будут тратить на вас время.
#### 2. Псевдокод
Когда проблема возникла из-за того, что вы не можете вспомнить точное название функции или другое синтаксическое правило, используйте комментарии для объяснения, что вы хотите сделать, в псевдокоде. Если у меня возникнет ощущение, что вам достаточно одного запроса в Google, чтобы решить задачу, это не повлияет на положительный результат. Особенно если вы отлично показали себя на остальном собеседовании.
#### 3. Назовите известные неизвестные
Если вы застряли полностью, то остаётся последний вариант: назовите мне всё, что вам нужно знать для решения задачи, и скажите, как в реальном мире вы получите эту информацию. Расскажите максимально подробно. Если вы говорите, что вам понадобится помощь, то скажите, к кому конкретно обратитесь (должность) и что конкретно спросите (максимально конкретный вопрос, если возможно). Если вы говорите, что поищете в интернете, то назовите конкретные поисковые запросы, по которым будете искать. В этом сценарии вам требуется убедить меня, что вы действительно можете решить проблему в реальных условиях, если будете работать на меня.
Часть 5. Практика, практика, практика
-------------------------------------
Пожалуй, самое важное для успешного собеседования по программированию — хорошая подготовка. Лучше всего практиковаться со стандартными вопросами снова и снова, пока вы не выучите их назубок. Если много тренироваться, то вы сможете отвечать на вопросы, которые не встречали ранее. У вас появится уверенность и вы сможете связать любой вопрос с чем-то другим, что встречали раньше.
Я составил большой список онлайн-ресурсов с примерами вопросов и советами по программированию для 50+ различных языков программирования и технологий, включая C#, JavaScript, Mongo, Node и так далее…
Список [здесь](https://devmastery.com/signup/interview/index.html) (подписка на рассылку) и в [pdf](http://www.slideshare.net/anatolalizar/c-62580031). | https://habr.com/ru/post/302364/ | null | ru | null |
# Как начать программировать в Adobe Illustrator. Часть вторая
Этот пост — продолжение [первой части](https://habr.com/ru/post/452586/), где был представлен скрипт Expand Clipping Mask и детально описано, что и как он делает, а также попутно рассмотрены основные принципы создания подобных программ в целом. В этой части я продолжу рассказ о том, как добавить в программу новый функционал, чтобы из "заготовки" получить на выходе "готовое изделие". Здесь не обойтись без более глубокого погружения в предметную область, что является одним из необходимых условий создания полноценного продукта. Итак, начинаем погружение!
В качестве контура маски в Adobe Illustrator могут быть использованы следующие графические примитивы: простой контур (Path), составной контур (Compound Path), составная форма (Compound Shape) и текстовые объекты (Point Text и Text on the Path). На данный момент скрипт работает только с простыми контурами, что видно из приведенного ниже кода, где `PathItem` — это обращение к элементу Path.
```
var clipGroup = sel[0].pageItems.length;
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'PathItem' &&
sel[0].pageItems[i].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
```
Перед этим мы объявили переменную `clipPath`, но не присваили ей значение.
```
var clipPath;
```
Это значит, что ее значение пока не определено, т.е. оно `undefined`. Если сейчас выделить маску, контуром которой будет, скажем, Compound Path и запустить скрипт, то программа выдаст ошибку на последней строчке функциональной части скрипта,
```
clipPath.remove();
```
так как условие в цикле не будет выполнено, переменная `clipPath` так и останется `undefined`, а применить метод `remove()` к чему-то неопределенному невозможно. Чтобы не допустить такой ситуации, мы сделаем следующее — присвоим `clipPath` значение `null`, которое, в отличии от `undefined`, уже что-то более определенное, что можно хотя-бы проверить.
> Давайте подумаем, как определить, что какой-то Compound Path является контуром нашей маски? Когда я говорю "давайте подумаем", это значит, что я предлагаю заглянуть в [документацию](https://www.adobe.com/content/dam/acom/en/devnet/illustrator/pdf/Illustrator_Scriptin_Reference_JavaScript_cc.pdf) и найти нужное нам свойство. По аналогии с `PathItem` ищем свойство `clipping`. Оказывается, что у объекта `CompoundPathItem` нет такого свойства, зато есть свойство `pathItems`, через которое можно добраться до простых контуров `PathItem`, у которых свойство `clipping` имеется.
Теперь можно превратить наши размышления/поиски в код. Первым делом проверяем, что `clipPath` в предыдущей итерации не был определен, а дальше копируем уже написанный блок кода и вносим в него небольшие изменения.
```
if (clipPath == null) {
var clipGroup = sel[0].pageItems.length;
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'CompoundPathItem' &&
sel[0].pageItems[i].pathItems[0].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
};
```
Собственно, изменения коснутся только одной строки. Как мы здесь видим, 'PathItem' поменялся на 'CompoundPathItem', а также добавилась новая конструкция 'pathItems[0]', с помощью который мы обращаемся к элементу составного контура.
```
if (sel[0].pageItems[i].typename == 'CompoundPathItem' && sel[0].pageItems[i].pathItems[0].clipping == true) {
```
Ниже приведен функциональный блок кода, созданный на данный момент.
```
var clipGroup = sel[0].pageItems.length;
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'PathItem' &&
sel[0].pageItems[i].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'CompoundPathItem' &&
sel[0].pageItems[i].pathItems[0].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
};
```
Следующий на очереди "пациент" — это Compound Shape (составная форма). Вот здесь становиться совсем интересно! В документации мы вообще не находим такого объекта. Что делать? Для начала давайте определим к какому классу объектов он относится. Чтобы выяснить это, напишем небольшой вспомогательный код, который потом выкинем. Как было сказано в [первой части](https://habr.com/ru/post/452586/), мы не касаемся вопроса используемых инструментов для написания/отладки кода. Поэтому предположим, что это будет отдельный файл, которой потом просто отправится в корзину. Код будет следующим:
```
var obj = app.activeDocument.selection[0];
alert(obj.typename);
```
В первой строке мы создаем ссылку на выделенный объект, во второй — выводим сообщение о том, каким типом он является. Выделяем в Adobe Illustrator контур маски, т.е. тот самый объект Compound Shape и запускаем скрипт. В окне сообщения мы видим, что Compound Shape представляет из себя PluginItem. Избавляемся от вспомогательного кода, снова возвращаемся к документации, но не находим у PluginItem ни свойства clipping, ни pathItems. Вообще ничего, что помогло бы нам однозначно указать, что этот объект является контуром маски. Из скрипта даже нельзя определить, что это за plugin. Какой-то внешний модуль и всё тут!
> Вот ведь засада! — восклицаете в сердцах вы. А мозг лихорадочно работает, в надежде решить нерешаемую задачу. И тогда, перебрав все возможные и невозможные варианты, вы в отчаянии нажимаете `Del` и удаляете ненавистный Compound Shape. И тут краем глаза на палитре `Layers` вы замечаете, что после этого действия, контейнер маски, который был `Clip Group`, стал просто `Group`. Что бы это могло значит? А то, что свойство `clipped` объекта-маски из `true` стало `false`. Вот оно, решение, которое может сработать! Конечно это, по-большому счету, hack, но какая разница, если он поможет определить искомый контур.
Алгоритм определения контура маски, представленный объектом Compound Shape, тогда будет следующим: перебираем в цикле все объекты маски и, когда обнаруживаем PluginItem, то удаляем его и проверяем изменилось ли свойство `clipped` у контейнера маски. Если оно стало `false`, значит это и есть наш контур. Единственное, чтобы этот hack сработал, надо после удаления объекта обновить DOM Illustrator, что можно сделать методом `app.redraw()`. Потом еще надо не забыть вернуть удаленный объект, что делается методом `app.undo()`.
Ниже приведен код для контура Compound Shape:
```
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'PluginItem') {
sel[0].pageItems[i].remove();
app.redraw();
if (sel[0].clipped == false) {
app.undo();
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
```
Теперь из всех возможных вариантов типа объектов, которые могут быть контуром маски, остался только текст (или `TextFrameItem`, в терминологии [illustrator scripting references](https://www.adobe.com/content/dam/acom/en/devnet/illustrator/pdf/Illustrator_Scriptin_Reference_JavaScript_cc.pdf)). Снова обращаемся к документации и опять не находим там свойства `clipping`. Но на этот раз мы уже не переживаем так сильно по этому поводу и спокойно выясняем, что у `TextFrameItem` есть свойство `kind`, которое определяет тип текстового объекта (`TextType`). Выясняем, что таких типов может быть три: AREATEXT, POINTTEXT и PATHTEXT. Первый тип нам не интересен, так как его нельзя использовать в качестве контура маски, а другие два еще как интересны. Остается только найти hack, который поможет нам определить теперь уже не контур, а текстовый объект, являющийся контуром маски. И этим hack-ом станет команда, Convert To Area Type, которая конвертирует POINTTEXT в AREATEXT. Как и в случае с Compound Shape, при этом происходит неявное изменение свойства `clipped`.
Соответственно, код для TextFrameItem типа POINTTEXT будет следующим:
```
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'TextFrame' &&
sel[0].pageItems[i].kind == 'TextType.POINTTEXT') {
sel[0].pageItems[i].convertPointObjectToAreaObject();
app.redraw();
if (sel[0].clipped == false) {
app.undo();
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
```
Остался только `TextFrameItem` типа PATHTEXT. К сожалению, при конвертировании PATHTEXT в AREATEXT, свойство `clipped` не изменяется. Но так как это последний из возможных претендентов на звание "контур маски", то можно использовать именно такое его поведение. То есть проверяем, что после выполнения команды `Convert To Area Type` свойство `clipped` осталось `true`. Ниже приведен код для TextFrameItem типа PATHTEXT.
```
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'TextFrame' &&
sel[0].pageItems[i].kind == 'TextType.PATHTEXT') {
sel[0].pageItems[i].convertPointObjectToAreaObject();
app.redraw();
if (sel[0].clipped == true) {
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
```
Таким образом, если собрать вместе последовательно написанные части кода, включая блок проверок, то мы получим такой код, выполнение которого, как было заявлено еще в [первой части](https://habr.com/ru/post/452586/) поста, будет реализовывать действие новой команды Expand Clipping Mask в Adobe Illustrator.
```
#target illustrator
if (app.documents.length > 0) {
var doc = app.activeDocument;
var sel = doc.selection;
var clipPath = null;
if (sel.length > 0) {
if (sel[0].typename == 'GroupItem' && sel[0].clipped == true) {
var clipGroup = sel[0].pageItems.length;
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'PathItem' &&
sel[0].pageItems[i].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'CompoundPathItem' &&
sel[0].pageItems[i].pathItems[0].clipping == true) {
clipPath = sel[0].pageItems[i];
break;
};
};
};
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'PluginItem') {
sel[0].pageItems[i].remove();
app.redraw();
if (sel[0].clipped == false) {
app.undo();
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'TextFrame' &&
sel[0].pageItems[i].kind == 'TextType.POINTTEXT') {
sel[0].pageItems[i].convertPointObjectToAreaObject();
app.redraw();
if (sel[0].clipped == false) {
app.undo();
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
if (clipPath == null) {
for (var i = 0; i < clipGroup; i++) {
if (sel[0].pageItems[i].typename == 'TextFrame' &&
sel[0].pageItems[i].kind == 'TextType.PATHTEXT') {
sel[0].pageItems[i].convertPointObjectToAreaObject();
app.redraw();
if (sel[0].clipped == true) {
clipPath = sel[0].pageItems[i];
break;
}
else {
app.undo();
}
};
};
};
app.executeMenuCommand('releaseMask');
clipPath.remove();
}
else {
alert ('Выделение не является объектом-маской!');
};
}
else {
alert ('Нет выделенных объектов!');
};
}
else {
alert ('Нет открытых документов!');
};
```
Здесь можно поставить точку. Нет, лучше точку с запятой.
Надеюсь, этими постами я помог вам стать немного ближе к своей цели — начать программировать в Adobe Illustrator. Спасибо за внимание! | https://habr.com/ru/post/452614/ | null | ru | null |
# Сохранение данных для ESP32/Arduino в удаленной базе MySQL и не только
Любой любительский проект имеет дело с теми или иными данными, которые могут модифицироваться, генерироваться и, соответственно, требуют некоего хранения. В этой статье мы попробуем обзорно рассмотреть основные способы, с помощью которых можно организовать хранение данных для любительских проектов.
Одним из самых известных способов является отправка данных на некий сервер, где соответствующий веб-скрипт получает их и помещает в базу. Например, скрипт на основе PHP.
Показанный ниже способ является частью более широкого решения, которое используется для сохранения на сервере данных с датчиков температуры, влажности и давления. В оригинале база данных является всего лишь частью системы, где сохранённые данные затем могут быть отображены по запросу и являются доступными через браузер.
В этой статье мне хотелось больше остановиться на способах работы с базой данных, чем с фронтендом, и поэтому этот момент я оставлю «за скобками». Однако, тем кто-то заинтересовался темой, оставляю [ссылку](https://randomnerdtutorials.com/esp32-esp8266-mysql-database-php/) для более подробного ознакомления.<
[*Источник картинки*](http://www.randomnerdtutorials.com)
>
> **php-скрипт для помещения данных в базу MySQL**
>
> ```
> php
>
> /*
> Rui Santos
> Complete project details at https://RandomNerdTutorials.com/esp32-esp8266-mysql-database-php/
>
> Permission is hereby granted, free of charge, to any person obtaining a copy
> of this software and associated documentation files.
>
> The above copyright notice and this permission notice shall be included in all
> copies or substantial portions of the Software.
> */
>
> $servername = "localhost";
>
> // REPLACE with your Database name
> $dbname = "REPLACE_WITH_YOUR_DATABASE_NAME";
> // REPLACE with Database user
> $username = "REPLACE_WITH_YOUR_USERNAME";
> // REPLACE with Database user password
> $password = "REPLACE_WITH_YOUR_PASSWORD";
>
> // Keep this API Key value to be compatible with the ESP32 code provided in the project page.
> // If you change this value, the ESP32 sketch needs to match
> $api_key_value = "tPmAT5Ab3j7F9";
>
> $api_key= $sensor = $location = $value1 = $value2 = $value3 = "";
>
> if ($_SERVER["REQUEST_METHOD"] == "POST") {
> $api_key = test_input($_POST["api_key"]);
> if($api_key == $api_key_value) {
> $sensor = test_input($_POST["sensor"]);
> $location = test_input($_POST["location"]);
> $value1 = test_input($_POST["value1"]);
> $value2 = test_input($_POST["value2"]);
> $value3 = test_input($_POST["value3"]);
>
> // Create connection
> $conn = new mysqli($servername, $username, $password, $dbname);
> // Check connection
> if ($conn-connect_error) {
> die("Connection failed: " . $conn->connect_error);
> }
>
> $sql = "INSERT INTO SensorData (sensor, location, value1, value2, value3)
> VALUES ('" . $sensor . "', '" . $location . "', '" . $value1 . "', '" . $value2 . "', '" . $value3 . "')";
>
> if ($conn->query($sql) === TRUE) {
> echo "New record created successfully";
> }
> else {
> echo "Error: " . $sql . "
> " . $conn->error;
> }
>
> $conn->close();
> }
> else {
> echo "Wrong API Key provided.";
> }
>
> }
> else {
> echo "No data posted with HTTP POST.";
> }
>
> function test_input($data) {
> $data = trim($data);
> $data = stripslashes($data);
> $data = htmlspecialchars($data);
> return $data;
> }
> ```
>
>
>
Перед использованием этого скрипта в рамках нашего проекта требуется предварительно:
1. Создать базу данных на сервере.
2. После чего ввести её реквизиты в соответствующие строки скрипта:
```
// REPLACE with your Database name
$dbname = "REPLACE_WITH_YOUR_DATABASE_NAME";
// REPLACE with Database user
$username = "REPLACE_WITH_YOUR_USERNAME";
// REPLACE with Database user password
$password = "REPLACE_WITH_YOUR_PASSWORD";
```
*Примечание: этот способ позволяет только помещать данные в базу. Для извлечения их из базы – требуется либо дописать этот, либо найти соответствующий готовый скрипт.*
Казалось бы, вот он способ для работы с базой! Однако, существует гораздо более красивое решение, которое позволяет микроконтроллеру напрямую обращаться к базе данных на сервере.
Для этого следует использовать библиотеку [MySQL\_Connector\_Arduino](https://github.com/ChuckBell/MySQL_Connector_Arduino).
Библиотека позволяет вашему микроконтроллеру напрямую работать с базой, что даёт возможность сохранять собранные данные, извлекать их и использовать для определённых событий в рамках вашего скетча.
Это позволит вам использовать MySQL-сервер как находящийся в интернете, так и локального типа (позволяющий хранить ваши данные локально, даже без подключения к сети интернет).
Однако следует сделать оговорку: я не считаю, что такой способ прямого подключения (без серверного скрипта) является наиболее предпочтительным, — у серверного варианта могут быть свои плюсы, среди которых можно назвать его большую гибкость, так как к нему могут обращаться абсолютно разные устройства, на основе разных операционных систем и т. д.
Подытоживая — я хотел сказать, что если вы работаете предпочтительно только с Arduino или esp32 и «лень — ваше второе имя» (как и у меня, кстати, хе-хе), то можно просто использовать библиотеку коннектора — это будет более элегантным решением в данном случае.
Чтобы проверить работу с базой и с использованием этой библиотеки, можно воспользоваться рядом вариантов.
Просто подключение к базе — этот вариант можно назвать самым базовым (если он заработает, то значит, и дальше у вас всё будет хорошо):
>
> **Базовый скетч**
>
> ```
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> // You would add your code here to run a query once on startup.
> }
> else
> Serial.println("Connection failed.");
> conn.close();
> }
>
> void loop() {
> }
> ```
>
>
>
>
Следующий пример показывает, как подключиться к серверу MySQL, используя вместо адреса — имя хоста:
>
> **Подключение по имени хоста**
>
> ```
> #include
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> char hostname[] = "www.google.com"; // change to your server's hostname/URL
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> IPAddress server\_ip;
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
> DNSClient dns\_client; // DNS instance
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> // Begin DNS lookup
> dns\_client.begin(Ethernet.dnsServerIP());
> dns\_client.getHostByName(hostname, server\_ip);
> Serial.println(server\_ip);
> // End DNS lookup
> Serial.println("Connecting...");
> if (conn.connect(server\_ip, 3306, user, password)) {
> delay(1000);
> // You would add your code here to run a query once on startup.
> }
> else
> Serial.println("Connection failed.");
> conn.close();
> }
>
> void loop() {
> }
> ```
>
>
>
>
В качестве базового примера для вставки данных в базу можно воспользоваться следующим ходом. Он вставляет одну строку в таблицу MySQL каждые 2 секунды:
>
> **Базовая вставка**
>
> ```
> #include
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> // Sample query
> char INSERT\_SQL[] = "INSERT INTO test\_arduino.hello\_arduino (message) VALUES ('Hello, Arduino!')";
>
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> }
> else
> Serial.println("Connection failed.");
> }
>
> void loop() {
> delay(2000);
>
> Serial.println("Recording data.");
>
> // Initiate the query class instance
> MySQL\_Cursor \*cur\_mem = new MySQL\_Cursor(&conn);
> // Execute the query
> cur\_mem->execute(INSERT\_SQL);
> // Note: since there are no results, we do not need to read any data
> // Deleting the cursor also frees up memory used
> delete cur\_mem;
> }
> ```
>
>
>
>
Ниже показано использование переменных для формирования строки, для вставки в таблицу:
>
> **Сложная вставка**
>
> ```
> #include
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> // Sample query
> char INSERT\_DATA[] = "INSERT INTO test\_arduino.hello\_sensor (message, sensor\_num, value) VALUES ('%s',%d,%s)";
> char query[128];
> char temperature[10];
>
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> // Initiate the query class instance
> MySQL\_Cursor \*cur\_mem = new MySQL\_Cursor(&conn);
> // Save
> dtostrf(50.125, 1, 1, temperature);
> sprintf(query, INSERT\_DATA, "test sensor", 24, temperature);
> // Execute the query
> cur\_mem->execute(query);
> // Note: since there are no results, we do not need to read any data
> // Deleting the cursor also frees up memory used
> delete cur\_mem;
> Serial.println("Data recorded.");
> }
> else
> Serial.println("Connection failed.");
> conn.close();
> }
>
> void loop() {
> }
> ```
>
>
>
>
Далее посмотрим на то, как можно «наосуществлять» SELECT-запросы, то есть запросы, которые возвращают определённые результаты. Пример ниже показывает, как можно использовать запрос SELECT для извлечения строки из таблицы и сохранить его результат в переменной. Чтобы этот пример заработал, вам необходимо загрузить и установить образец «World»-базы данных сайта документации Oracle MySQL:
>
> **Базовый SELECT-запрос**
>
> ```
> #include
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> // Sample query
> char query[] = "SELECT population FROM world.city WHERE name = 'New York'";
>
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
> // Create an instance of the cursor passing in the connection
> MySQL\_Cursor cur = MySQL\_Cursor(&conn);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> }
> else
> Serial.println("Connection failed.");
> }
>
>
> void loop() {
> row\_values \*row = NULL;
> long head\_count = 0;
>
> delay(1000);
>
> Serial.println("1) Demonstrating using a cursor dynamically allocated.");
> // Initiate the query class instance
> MySQL\_Cursor \*cur\_mem = new MySQL\_Cursor(&conn);
> // Execute the query
> cur\_mem->execute(query);
> // Fetch the columns (required) but we don't use them.
> column\_names \*columns = cur\_mem->get\_columns();
>
> // Read the row (we are only expecting the one)
> do {
> row = cur\_mem->get\_next\_row();
> if (row != NULL) {
> head\_count = atol(row->values[0]);
> }
> } while (row != NULL);
> // Deleting the cursor also frees up memory used
> delete cur\_mem;
>
> // Show the result
> Serial.print(" NYC pop = ");
> Serial.println(head\_count);
>
> delay(500);
>
> Serial.println("2) Demonstrating using a local, global cursor.");
> // Execute the query
> cur.execute(query);
> // Fetch the columns (required) but we don't use them.
> cur.get\_columns();
> // Read the row (we are only expecting the one)
> do {
> row = cur.get\_next\_row();
> if (row != NULL) {
> head\_count = atol(row->values[0]);
> }
> } while (row != NULL);
> // Now we close the cursor to free any memory
> cur.close();
>
> // Show the result but this time do some math on it
> Serial.print(" NYC pop = ");
> Serial.println(head\_count);
> Serial.print(" NYC pop increased by 12 = ");
> Serial.println(head\_count+12);
> }
> ```
>
>
>
>
Для осуществления сложного выбора из таблицы можно воспользоваться следующим примером, который позволяет использовать концепцию заполнителей:
>
> **Сложный запрос**
>
> ```
> #include
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> // Sample query
> //
> // Notice the "%lu" - that's a placeholder for the parameter we will
> // supply. See sprintf() documentation for more formatting specifier
> // options
> const char QUERY\_POP[] = "SELECT name, population FROM world.city WHERE population > %lu ORDER BY population DESC;";
> char query[128];
>
> EthernetClient client;
> MySQL\_Connection conn((Client \*)&client);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect
> Ethernet.begin(mac\_addr);
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> }
> else
> Serial.println("Connection failed.");
> }
>
>
> void loop() {
> delay(1000);
>
> Serial.println("> Running SELECT with dynamically supplied parameter");
>
> // Initiate the query class instance
> MySQL\_Cursor \*cur\_mem = new MySQL\_Cursor(&conn);
> // Supply the parameter for the query
> // Here we use the QUERY\_POP as the format string and query as the
> // destination. This uses twice the memory so another option would be
> // to allocate one buffer for all formatted queries or allocate the
> // memory as needed (just make sure you allocate enough memory and
> // free it when you're done!).
> sprintf(query, QUERY\_POP, 9000000);
> // Execute the query
> cur\_mem->execute(query);
> // Fetch the columns and print them
> column\_names \*cols = cur\_mem->get\_columns();
> for (int f = 0; f < cols->num\_fields; f++) {
> Serial.print(cols->fields[f]->name);
> if (f < cols->num\_fields-1) {
> Serial.print(',');
> }
> }
> Serial.println();
> // Read the rows and print them
> row\_values \*row = NULL;
> do {
> row = cur\_mem->get\_next\_row();
> if (row != NULL) {
> for (int f = 0; f < cols->num\_fields; f++) {
> Serial.print(row->values[f]);
> if (f < cols->num\_fields-1) {
> Serial.print(',');
> }
> }
> free\_row\_buffer();
> Serial.println();
> }
> } while (row != NULL);
> free\_columns\_buffer();
> // Deleting the cursor also frees up memory used
> delete cur\_mem;
> }
> ```
>
>
>
>
Как вы могли увидеть выше, все примеры построены на использовании сети Ethernet (например, для случая, если в качестве вашего микроконтроллера вы используете плату Arduino Ethernet), однако, что же делать, если в нашем случае есть esp32, которая использует для подключения сеть wi-fi?
Для этого во все приведённые выше примеры следует внести изменения, которые позволят плате подключаться к базе с использованием беспроводного подключения:
>
> **Код wi-fi-подключения к базе данных MySQL**
>
> ```
> #include // Use this for WiFi instead of Ethernet.h
> #include
> #include
>
> byte mac\_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
>
> IPAddress server\_addr(10,0,1,35); // IP of the MySQL \*server\* here
> char user[] = "root"; // MySQL user login username
> char password[] = "secret"; // MySQL user login password
>
> // WiFi card example
> char ssid[] = "horse\_pen"; // your SSID
> char pass[] = "noname"; // your SSID Password
>
> WiFiClient client; // Use this for WiFi instead of EthernetClient
> MySQL\_Connection conn((Client \*)&client);
>
> void setup() {
> Serial.begin(115200);
> while (!Serial); // wait for serial port to connect. Needed for Leonardo only
>
> // Begin WiFi section
> int status = WiFi.begin(ssid, pass);
> if ( status != WL\_CONNECTED) {
> Serial.println("Couldn't get a wifi connection");
> while(true);
> }
> // print out info about the connection:
> else {
> Serial.println("Connected to network");
> IPAddress ip = WiFi.localIP();
> Serial.print("My IP address is: ");
> Serial.println(ip);
> }
> // End WiFi section
>
> Serial.println("Connecting...");
> if (conn.connect(server\_addr, 3306, user, password)) {
> delay(1000);
> }
> else
> Serial.println("Connection failed.");
> conn.close();
> }
>
> void loop() {
> }
> ```
>
>
>
>
Все приведённые выше примеры могут использоваться для достаточно серьёзных задач, но как же быть, если наши задачи достаточно скромные и использование «микроскопа для забивания гвоздей» нам не требуется?
Для этого мы просто можем воспользоваться энергонезависимой памятью микроконтроллера. Это возможно осуществить с использованием библиотеки Preferences. **Она входит в комплект встроенных библиотек для esp32, поэтому её спецаильно скачивать её не нужно**.
Её можно использовать, чтобы:
* запомнить последнее состояние переменной;
* сохранить настройки;
* сохранить, сколько раз устройство было включено;
* закрепить какие-то другие данные, которые необходимо хранить на постоянной основе.
Данные, сохранённые с применением этой библиотеки, имеют такую структуру:
```
namespace {
key:value
}
```
Можно хранить разные ключи в одном и том же пространстве имён, например:
```
namespace {
key1: value1
key2: value2
}
```
Также можно создать ряд пространств имён с одним и тем же ключом (но каждый ключ — со своим значением):
```
namespace1{
key:value1
}
namespace2{
key:value2
}
```
Использование библиотеки стандартное — сначала она включается в скетч:
```
#include
```
Затем создаётся объект:
```
Preferences preferences;
```
И у объекта вызывается метод, который создаёт и открывает доступ к именованному пространству (внимание: длина имени пространства ограничена 15 символами). Аргумент false означает, что мы будем использовать это пространство для чтения/записи. Если поставить true — это будет означать использование только для чтения:
```
preferences.begin("my-app", false);
```
Для работы с библиотекой можно использовать ряд методов.
Поместить значение (ниже показаны разные методы — выберите свой в зависимости от типа сохраняемой переменной):
```
putChar(const char* key, int8_t value) // Char
putUChar(const char* key, int8_t value) // Unsigned Char
putShort(const char* key, int16_t value) // Short
putUShort(const char* key, uint16_t value) // Unsigned Short
putInt(const char* key, int32_t value) // Int
putUInt(const char* key, uint32_t value) // Unsigned Int
putLong(const char* key, int32_t value) // Long
putULong(const char* key, uint32_t value) // Unsigned Long
putLong64(const char* key, int64_t value) // Long64
putULong64(const char* key, uint64_t value) // Unsigned Long64
putFloat(const char* key, const float_t value) // Float
putDouble(const char* key, const double_t value) // Double
putBool(const char* key, const bool value) // Bool
putString(const char* key, const String value) // String
putBytes(const char* key, const void* value, size_t len) // Bytes
```
Аналогично показанному выше выберите свой метод (в зависимости от типа переменной) для получения сохранённой ранее переменной:
```
getChar(const char* key, const int8_t defaultValue) // Char
getUChar(const char* key, const uint8_t defaultValue) // Unsigned Char
getShort(const char* key, const int16_t defaultValue) // Short
getUShort(const char* key, const uint16_t defaultValue) // Unsigned Short
getInt(const char* key, const int32_t defaultValue) // Int
getUInt(const char* key, const uint32_t defaultValue) // Unsigned Int
getLong(const char* key, const int32_t defaultValue) // Long
getULong(const char* key, const uint32_t defaultValue) // Unsigned Long
getLong64(const char* key, const int64_t defaultValue) // Long64
gettULong64(const char* key, const uint64_t defaultValue) // Unsigned Long64
getFloat(const char* key, const float_t defaultValue) // Float
getDouble(const char* key, const double_t defaultValue) // Double
getBool(const char* key, const bool defaultValue) // Bool
getString(const char* key, const String defaultValue) // String
getString(const char* key, char* value, const size_t maxLen) // String
getBytes(const char* key, void * buf, size_t maxLen) // Bytes
```
Очистка всех значений из именованного пространства (само пространство не удаляется при этом):
```
preferences.clear();
```
Удаление ключа:
```
preferences.remove(key);
```
Закрытие открытого именованного пространства (после окончания работы с ним):
```
preferences.end();
```
Если вам необходимо полностью удалить пространство/ства имён (например, вы забыли, как называются старые пространства из предыдущих скетчей, или в целом произошло переполнение), надо запустить следующий скетч, который полностью переформатирует область энергонезависимой памяти, отведённой под Preferences:
```
#include
void setup() {
nvs\_flash\_erase(); // erase the NVS partition and...
nvs\_flash\_init(); // initialize the NVS partition.
while(true);
}
void loop() {
}
```
Подытоживая статью, хочется отметить, что я не ставил перед собой целью рассмотреть абсолютно все возможные варианты сохранения данных. Так как это вышло бы далеко за пределы этой статьи и сюда надо было бы включить ещё и сохранение на флеш-карту, передачу по сотовому каналу с использованием sim-карты и чуть ли не «выцарапывание этих данных на восковом барабане» — так как при желании способ сохранения может быть абсолютно любым и ограничивается только вашей фантазией. Я же постарался рассмотреть наиболее применимые и гибкие способы, которые позволят вам получить новые возможности по работе с вашими массивами данных.
Успехов всем в творчестве!
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/655537/ | null | ru | null |
# IoT и хакатон Azure Machine Learning: как мы делали проект вне конкурса
Не так давно состоялся очередной [хакатон](https://events.techdays.ru/machine-learning/2015-11/) от Microsoft. На этот раз, он был посвящен [машинному обучению](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5). Тема очень актуальная и перспективная, однако, для меня достаточно туманная. На момент начала хакатона я имел только общее представление о том, что это такое, зачем оно нужно и пару раз видел результаты работы обученных моделей. Узнав, что анонс обещал множество экспертов в помощь новичкам, я решил объединить приятное с полезным и попробовать использовать машинное обучение при работе с каким нибудь [IoT](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%BD%D0%B5%D1%82_%D0%B2%D0%B5%D1%89%D0%B5%D0%B9) решением. Далее я расскажу что из этого получилось.
Я достаточно давно [занимаюсь](http://habrahabr.ru/company/microsoft/blog/272657/) системами охраны периметра, основанными на анализе вибраций забора, так что сразу возникла идея поработать с акселерометром. Идея была проста: научить систему отличать виброзвонки нескольких телефонов, основываясь на данных акселерометра. Похожие эксперименты были уже с успехом проведены моими коллегами, по этому я не сомневался что это возможно.
Изначально, я хотел сделать все на [Raspberry Pi 2](https://www.raspberrypi.org/products/raspberry-pi-2-model-b/) и [Windows IoT](https://dev.windows.com/ru-ru/iot). Была заготовлена специальная плата (на фото ниже) с цифровым и аналоговым акселерометрами, но попробовать ее в деле я не успел, решив все сделать на хакатоне. На всякий случай я захватил еще наш [датчик](http://sesmick.ru/), который так же позволяет поучать “сырые” данные о колебаниях.
На хакатоне всем участниками предлагалось разделиться на команды и решить одну из 3х задач, используя заранее заготовленные данные. Моя же задача получилась “вне конкурса”, однако команда собралась достаточно быстро:
Опыта использования Azure Machine learning ни у кого из нас не было, так что сделать предстояло очень много! Спасибо коллегам, среди которых был и [psfinaki](https://geektimes.ru/users/psfinaki/), за их труды!
Решено было разделиться на 3 направления:
* подготовка данных для анализа
* загрузка данных в облако
* работа с Azure Machine Learning
Подготовка данных заключалась в том, чтобы получить их из акселерометра, а затем представить в виде, доступном для загрузки в облако. Загружать в облако планировалось через [Event Hub](https://azure.microsoft.com/en-us/services/event-hubs/). Ну а дальше нужно было понять как использовать эти данные в Azure Machine Learning.
Проблемы начались по всем трем пунктам.
Много времени ушло на настройку Windows IoT на Raspberry. Она никак не выдавала картинку на монитор. Решить это удалось только, внеся следующие строчки в config.txt:
`hdmi_ignore_edid=0xa5000080`
`hdmi_drive=2`
`hdmi_group=2`
`hdmi_mode=16`
Это настраивало видеодрайвер на нужный формат, разрешение и частоту.
Однако, время, потраченное на это занятие, давало понять, что можно просто не успеть организовать получение данных из акселерометра. Поэтому было принято решение использовать датчик, захваченный мной про запас.
Для датчика было уже написано множество приложений. Одно из них выводило на экран график “сырых” данных:
Нужно было немного его доделать, чтобы подготовить данные к отправке в облако.
Event Hub тоже заработал не сразу. Для начала, мы пытались отправить туда просто случайную последовательность. Но данные никак не хотели появляться в отчетах. Проблем было несколько, и, как оказалось, все они были “детскими”: где-то не так настроили, где-то использовали не тот ключ и так далее. Работа на этом направлении была трудна и отняла много сил:
Но, к вечеру первого дня мы смогли отправлять и получать данные из датчика на лету… Правда, в финальном решении это оказалось не нужно. О причинах скажу чуть позже.
С Machine Learning было вообще ничего не понятно. Сначала мы дружно изучали прекрасную [статью](https://onedrive.live.com/view.aspx?resid=76345D79FF08AF0D!17893&ithint=file%2cDOCX&app=Word&authkey=!ABJSGQ5Y4v0hPJU) с примером использования мобильного приложения как клиента. Затем выясняли формат данных и как с ними работать. Потом думали как же создать обучающие последовательности.
В Azure Mashine Learning есть множество алгоритмов для различной классификации. Эти алгоритмы должны быть обучены на тестовом наборе данных. Затем, те, которые дают лучший результат, можно опубликовать как web-сервис и подключаться к ним из приложения.
Обучение алгоритма называется “экспериментом”. Все действия ведутся в визуальном редакторе:
Перетаскивая элементы из списка слева можно получать данные, изменять и преобразовывать их, обучать модели и оценивать их работу.
Вот так выглядит типичный эксперимент:
Самыми важными оказались Train Model, Score Model и Evaluate Model.
Первая, используя входные данные, обучает алгоритм, вторая тестирует обученный алгоритм на наборе данных, третья дает оценку результату тестирования.
Исходные данные в нашем случае представляют собой csv файл. Но что в нем должно содержаться?
Чувствительный элемент нашего датчика опрашивается 1024 раза в секунду. Каждый опрос представляет собой двухбайтовое значение, соответствующее амплитуде текущего колебания. Причем амплитуда отсчитывается не от нуля, а от опорного числа, соответствующего неподвижному датчику.
Поразмыслив, мы решили использовать временные срезы. Например, все опросы датчика за 256 мс давали нам одну строчку в csv таблице. Эти данные, в дополнительном столбце, можно было пометить тем или иным образом, в зависимости от происходящего с датчиком. Например, мы использовали 0 для обозначения шума (тряска датчика руками, постукивания и т.д.) и 1 для обозначения сигнала (на датчике лежит вибрирующий телефон).
Вот так мы записывали тестовые последовательности:
Получив данные, и поняв, что с ними нужно делать, мы начали учить первую модель:
Первый блин получился комом:
На тот момент даже смысл этих показателей был не понятен. Нас спас представитель команды поддержки, Евгений Григоренко, рассказав о ROC кривых. Главным оказалось то, что если график ниже средней линии в некотором месте, то модель работает даже хуже, чем если бы она давала результат случайным образом! Евгений и дальше помогал нам чем мог, за что ему большое спасибо!
Дальше мы долго переписывали обучающую последовательность и смотрели результаты:
Оказалось, что более менее оптимальной является работа с 2х секундной записью (2048 опросов датчика). Это позволяло делать строки csv таблицы более осмысленными. Но результат все же был далек от хорошего.
На этом закончился первый день.
Ночь я потратил на изучение материала. Очень помогла [статья](http://habrahabr.ru/post/228963/) про бинарную классификацию. А еще внимательно перечитал [статью](http://habrahabr.ru/post/271697/) с советами для этого хакатона. В общем, к началу работы я был полон новых идей.
Всю первую половину второго дня мы потратили на изучение разных моделей. Результатом работы стала вот такая “простыня”:
К этому моменту стало уже понятно, что различить два виброзвонка мы просто не успеем, так как качество данных для обучения оставляло желать лучшего, а записывать новые времени не хватало. По этому мы сосредоточились на разделении данных на “сигнал” и “шум”.
Для работы мы использовали 3 набора данных:
1. Набор для обучения, в котором были и сигнал (строки csv файла, помеченные 1), и шум (строки, помеченные 0)
2. Набор, содержащий только шум (строки с 0)
3. Набор, содержащий только сигнал (строки с 1)
Модели сначала обучались, потом проверялись и оценивались на каждом из наборов данных. Результаты обнадеживали:
В итоге, из девяти моделей бинарной классификации, мы выбрали пять.
Как оказалось, использовать модель как Web-сервис гораздо проще, чем прикручивать ее к Event hub. По этому мы решили опубликовать все 5 моделей и поработать с ними через REQUEST/RESPONSE, который сопровождается очень хорошим примером.
Запрос представляет собой входной массив из 2048 значений, снятых с датчика. Ответ выглядит так:
Scored labels — это 0 или 1. То есть результат классификации. Scored Probabilities — десятичное число, отражающее правильность оценки. Насколько я понял, первое значение — это округление второго. То есть, чем ближе второе значение к 0 тем оценка 0 более вероятная, и наоборот. Чем ближе значение к 1 тем оценка 1 более вероятная.
Доработав программу, выводящую график “сырых данных” на экран, мы смогли параллельно, из нескольких потоков, получать данные со всех пяти web-сервисов. Далее, немного понаблюдав за оценками, мы исключили один, так как он давал результат, совсем не похожий на остальные и портил всю картину.
В итоге получилось следующее:
Тут сразу вылезли все проблемы обучающей последовательности. Хотя мы и пытались отделить виброзвонок от всего остального (шума и покоя), состояние покоя получилось очень близким к звонку, по этому определялось далеко не всегда. Разницу между звонком и покоем мы определяли по среднему числу probabilities для каждой модели. Значение ближе к 1 означает звонок, значение около 0.5 при score равной 1 — это покой. Ну а если score равен 0 — это однозначно шум.
На этом время хакатона подошло к концу. Мы даже толком не успели показать экспертам результата, так как они были заняты оценками конкурсных работ.
Но это все уже не имело особой важности. Самое главное, что мы добились вполне вменяемого результата и при этом узнали много нового!
За два дня напряженной работы мы выполнили, хотя и частично, поставленную задачу. Спасибо коллегам из команды и экспертам, помогавшим нам!
Сейчас можно отметить пути развития нашего проекта. Мы использовали временные характеристики для разделения событий. Однако, если перейти в частотную область, эффективность работы алгоритмов должна быть выше. Шум, покой и звонок имеют заметно отличающиеся спектральные характеристики.
Кроме того, опытные люди подсказали, что данные лучше нормализовать. То есть числа входной последовательности должны лежать в пределах от -1 до +1. С такими данными алгоритмы работают эффективнее.
Ну и еще, нужно поработать над формированием обучающих последовательностей, чтобы более четко разделять сигнал от шума.
Эти доработки должны существенно увеличить точность определения состояний, что я и хочу проверить в будущем. | https://habr.com/ru/post/387857/ | null | ru | null |
# Использование преимуществ TypeScript в JavaScript разработке
Язык программирования [TypeScript](https://www.typescriptlang.org/) от Microsoft привносит многие преимущества статической типизации в JavaScript. Несмотря на то, что он не проверяет типы во время исполнения, он позволяет производить более точный статический анализ, повышает безопасность и открывает возможности для лучшей интеграции с IDE. Код на TypeScript обычно транспилируется в стандартный JavaScript, который выполняется в браузерах или Node.js. Учитывая привлекательность TypeScript, не удивительно, что его популярность [быстро растёт](https://thenewstack.io/typescript-getting-popular/).
Конечно, использование нестандартного диалекта языка не лишено объективных недостатков. Использование TypeScript в вашем проекте потребует дополнительного шага при сборке проекта, исключается возможность использования широкого набора инструментов, которые рассчитаны только на JavaScript. Так же, всем членам команды придется изучить нестандартные для JS функции. Так же, принимая во внимание скорость развития JavaScript, есть некоторый риск получить зависимость от нестандартного функционала. Разработчики TypeScript [спроектировали](https://medium.com/@tomdale/glimmer-js-whats-the-deal-with-typescript-f666d1a3aad0) язык с учётом некоторых потенциальных проблем, но, тем не менее, это не "ванильный" JavaScript.
К счастью, JavaScript разработчики могут получить некоторые из преимуществ используя привычный инструмент. В версии TypeScript 2.3, которая вышла в Апреле 2017 года, появилась поддержка анализа обычного JavaScript кода с указанием типов в комментариях. Вы можете использовать JSDoc подобный синтаксис для описания сигнатуры функций и добавления информации о типах. Инструменты TypeScript читают аннотации в комментариях и используют их практически так же как и в собственной системе типов.
JavaScript код с аннотациями в комментариях более многословен чем TypeScript, но он работает везде, не требует транспайлинга и позволяет избирательно использовать типизацию там, где это необходимо. Пока что он не покрывает все возможности TypeScript, но уже достаточно функционален, чтоб быть полезным.
Рабочий пример
--------------
Для того чтоб включить анализ JavaScript кода с помощью TypeScript просто добавьте комментарий с текстом `@ts-check` в начало файла. Потом вы можете добавить аннотации с указанием типов в пределах этого файла. Следующий пример показывает описание сигнатуры функции с двумя параметрами и определённым типом возвращаемого значения.
```
// @ts-check
/**
* @param {number} a
* @param {number} b
* @return {number}
*/
function example(a, b) {
return a + b;
}
```
Visual Studio Code, который поддерживает TypeScript из коробки, автоматически находит такие комментарии и включает режим проверки. Это не потребует абсолютно никакой настройки. Вам даже не надо создавать конфигурационный файл для TypeScript. Просто добавьте комментарии в любой JavaScript код. Если вы после этого попробуете вызвать функцию с неправильными аргументами, редактор покажет предупреждение.
Редактор так же будет использовать аннотации чтоб улучшить другие функции, такие как автодополнение. Кроме того, информация о типах успешно используется между файлами благодаря тому, что TypeScript понимает ES6 импорты и `require` в Node.js.
Вы так же можете использовать аннотации для указания структуры обычного объекта. Это может оказаться полезным когда вы хотите получить автодополнение свойств объекта и проверку их наличия для JSON данных полученных от какого-либо API. Следующий пример показывает как вы можете описать структуру объекта используя аннотации.
```
/**
* @typedef {Object} Issue
* @property {string} url
* @property {string} repository_url
* @property {id} number
* @property {string} title
* @property {string} state
* @property {bool} open
*/
const url = "https://api.github.com/repos/microsoft/typescript/issues";
(async () => {
let response = await got(url, {json: true});
/** @type {Issue[]} */
let issues = response.body;
for (let issue of issues)
console.log(issue.title);
})();
```
В этом примере используется специальная аннотация `@typedef` для определения типа объекта `Issue`. Далее в функции получения данных, мы указываем с помощью `@type` что полученный ответ представляет собой массив объектов `Issue`.
Вы можете найти больше [примеров](https://github.com/Microsoft/TypeScript/wiki/JSDoc-support-in-JavaScript) использования аннотаций в TypeScript wiki.
Поддержка библиотек
-------------------
TypeScript уже имеет указания типов для стандартной библиотеки Node.js, так что вы можете пользоваться проверками и дополнением практически всех её функций из коробки. Некоторые сторонние библиотеки также имеют файл с указанием типов(как правило — это файл с расширением `d.ts`) в своих npm пакетах. Добавление `@ts-check` для вашего проекта будет так же учитывать типы импортированных из таких библиотек функций и объектов.
Заключение
----------
Весь прошлый год я старался упростить свои инструменты JavaScript разработки и уйти от нарастающей сложности и избыточности, поражающей современную веб разработку. Использование аннотаций в комментариях неплохо позволяет придерживаться этой стратегии. Я получаю преимущества TypeScript не добавляя лишний шаг при сборке проекта во время разработки. Это похоже на использование TypeScript в качестве умного линтера, а не языка программирования. Мне даже не надо добавлять его в зависимости своего проекта. Я просто включаю проверку типов как простую функцию редактора и это позволяет мне лучше писать код. | https://habr.com/ru/post/340036/ | null | ru | null |
# Hardening на практике
> В преддверии старта курса ["**Administrator Linux. Professional**"](https://otus.pw/SUPl/) подготовили статью, автором которой является Александр Колесников. Если вам интересно узнать подробнее об обучении на курсе, приходите на [демо-день курса.](https://otus.pw/bojm/)
>
>
---
В предыдущей [статье](https://habr.com/ru/company/otus/blog/550838/) рассматривался пример уязвимых машин, которые создавались для того чтобы их использовать в практике тестирования систем на наличие уязвимостей. Эта статья расскажет как нестандартно можно обнаружить уязвимости в системах, если мы, к примеру, получили их уже в работоспособном состоянии и их ни в коем случае нельзя выводить из строя, а продолжать поддерживать.
### Hardening
Процесс закрытия возможных уязвимостей на совершенно неизвестной машине это достаточно серьезный вызов. Во-первых, никогда не знаешь какой сервис перестанет работать если изменить отдельную настройку файрволла или всей операционной системы.
Проблема достаточно не нова, и естественно есть руководства на 100500 страниц, которые, если правильно им следовать должны спасти от неминуемых проблем. Примеры таких руководств можно найти [тут](https://github.com/trimstray/the-practical-linux-hardening-guide), [тут](https://madaidans-insecurities.github.io/guides/linux-hardening.html) и [тут](https://www.cisecurity.org/cis-benchmarks/). Список далеко не полный, представлены лишь самые интересные с точки зрения автора.
Но это статья не о том как пройтись по списку формально описанных действий и придумать как их реализовать. Давайте попробуем сделать немного иначе. Что если прибегнуть к помощи не администраторских инструментов, а пентестерских?
В наборе любого энтузиаста или профессионального пентестера есть проект или скрипт, который должен проверять стандартные отклонения от безопасной конфигурации для различных систем. Обычно концентрируются на самых популярных: Windows, Linux, macOS. И именно в этой последовательности, потому что они настолько популярны в энтерпрайз среде.
Для закрытия всех векторов атак разобьем их группы:
1. Атаки, которые работают в приложениях доступных во внешний мир
2. Атаки, которые работают внутри ОС и их цель повышение привилегий
Для первого вида атак можно использовать сканеры безопасности. Мы будем использовать набор инструментов машины Kali Linux. Это nmap, Burp Suite и т.д.
Для второго типа атак предлагаем ознакомиться с вот этим [проектом](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). Так как процедура поиска неверных конфигураций в большинстве случаев детерминирована, то это просто автоматизировать. Запускаем команду для получения данных конфигурации и парсим результат — готово. Использовать скрипы достаточно просто, необходимо выбрать нужный для платформы и скопировать его в рабочую директорию уязвимой машины. Скрипты не запускают никаких атак, единственная их задача это показать, что уязвимость может присутствовать в системе и предложить ссылку на статью с атакой. Скрипт это автоматизация и поэтому следует ожидать, что он может давать ложные срабатывания на вероятные уязвимости. Каждый отдельный случай придётся рассматривать отдельно.
### Уязвимые стенды
Чтобы сделать процесс еще более непредсказуемее. Пронумеруем создаваемые машины и будем генерировать номер машины по следующей команде:
```
echo $RANDOM % 5 + 1 | bc
```
Скрипт подразумевает, что на каждый его запуск будет создана рандомная уязвимая машина, которую и нужно поправить, чтобы нельзя было её взломать тем способом, который был заложен в нее при сборке. Дополнительное условие на вмешательство — каким бы простым и бесполезным не выглядел сервис внутри этой машины, он должен продолжить функционировать после внесения изменений.
В сравнении с прошлым нашим экспериментом, теперь все машины будут иметь разные классы уязвимостей. С помощью них можно будет не только повысить привилегии, но и просто выполнить команды от имени пользователя.
### Эксперимент
Для первого эксперимента будем использовать вот этот [box](https://app.vagrantup.com/3ndG4me/boxes/cf7_5.3.1_research). Проведем эксперимент в 2 этапа.
Этап 1 — поиск уязвимых конфигураций и сервисов работающих снаружи сервера. Первые команды для запуска:
```
nmap -n -A -p- --max-rate=1000 machine.ip.address
```
В результате вот такой список сервисов, которые видны извне сервера:
У нас есть доступ к пользователю внутри машины, поэтому еще попробуем узнать какие порты открыты:
```
netstat -tulpn
```
Получается, что единственный сервис на 80м порту. Проведем сбор данных о структуре веб-приложений, которые могут там работать:
```
dirb http://machine.ip.address
```
Итог работы инструмента:
Похоже, что это wordpress. в директориях сервера лежит версия WordPress 5.6 и плагин "contact-form". Для этого набора данных очень хорошо подходит CVE-2020-35489. Тестовый скрипт можно найти [тут](https://github.com/dn9uy3n/Check-WP-CVE-2020-35489). Попробуем протестировать сервис. Скрипт так и не захотел работать, но по сути их него функциональна только одна строка, которая отправляет запрос на адрес "/wp-content/plugins/contact-form-7/readme.txt". Если его выполнить, то можно увидеть, что используемый плагин может быть уязвим для атаки.
Мы точно не знаем как работает данный сервис и нужен ли уязвимый плагин для того чтобы он по прежнему предоставлял свои услуги. Попробуем его оставить как есть. Добавим только дополнительный плагин на сервер - WAF. Можно использовать вот [этот](https://github.com/SpiderLabs/ModSecurity). Он будет оборонять уязвимый плагин на нашем сервере, а как только появится возможность, установим обновления и закроем эту уязвимость.
Второй этап тестирования. Запускаем скрипт, который описывали выше и ждем результата. Ниже приведем выводы скрипта:
Первая конфигурационная уязвимость. Как видно из снимка, нас интересуют те записи, которые выделены красным цветом. На самом деле это единственная уязвимость, не считая наличие пользователя vagrant в системе.
Таким образом можно получить информацию о уязвимостях на незнакомом сервере. Дальнейшие исправления зависят от функциональности сервера. Читателю предлагается так же пройти эксперимент самостоятельно, но использовать вот этот [box](https://app.vagrantup.com/chattm/boxes/CVE-2018-18955).
---
> Узнать подробнее о курсе ["**Administrator Linux. Professional**"](https://otus.pw/SUPl/)
>
> | https://habr.com/ru/post/552634/ | null | ru | null |
# Интернационализация и локализация приложения на Kotlin/Native
こんにちは, или добрый день по-японски.
Как бы не был популярен английский язык, всё же пользователям комфортнее и привычнее в родной языковой среде.
Поэтому далее мы пошагово рассмотрим процесс адаптации консольного приложения для Linux на [Kotlin/Native](https://kotlinlang.org/docs/native-overview.html) к русской и английской локали.
Поможет нам в этом старый-добрый [GNU gettext](https://www.gnu.org/software/gettext/manual/gettext.html).
В итоге убедимся, что это совсем не страшно.
Заодно посмотрим интеграцию с библиотеками на C, которая значительно расширяет возможности Kotlin/Native.
Что напишем: переводчик количественных числительных на японский язык.
Что ожидается от читателя: знание языков программирования Kotlin, C, базовый уровень знакомства с ОС Linux (в частности Bash).
Что понадобится в процессе: любой дистрибутив Linux, любая версия IntelliJ IDEA, установленный пакет *gettext-devel* или аналогичный.
Мотивация
---------
Собственно почему Kotlin/Native и причём тут японскийГде-то полгода медленно и печально изучаю японский язык по учебнику “Minna no Nihongo”: частью ради перевода текста песен, частью просто из интереса к культуре.
Позже решил перейти с системной разработки на прикладную, с десктопа на мобильные платформы, соответственно с C++/Qt/STL на Kotlin/JVM/Android SDK.
Теперь хочу два этих занятия совместить, написав для себя программы для помощи в изучении японского. Конечно, уже много готовых, но [NIH](https://en.wikipedia.org/wiki/Not_invented_here)-синдром ведь не что-то плохое, правда?
Раньше я не задумываюсь использовал бы связку Qt/QML/C++: она позволяет быстро и эффективно решать в общем-то любые задачи и на любой платформе.
Однако Qt всё больше поворачивается [спиной](https://habr.com/ru/post/501798/) к Open Source, вот и решил ~~пора валить~~ попробовать что-то другое.
И тут в процессе изучения Kotlin узнал про Kotlin/Native.
Соответственно, первая программа-помощник будет именно на нём.
Что такое Kotlin/Native
-----------------------
Изначально Kotlin выступал в качестве "более лучшей" (С) Java, и целиком опирался на платформу JVM.
Однако затем компания JetBrains, разработчик Kotlin, решила адаптировать набирающий популярность язык и под другие платформы.
В частности, под веб (Kotlin/JS) и под "натив" (Kotlin/Native).
Kotlin/Native появился в марте 2017 года, кстати ровно [четыре года назад](https://github.com/JetBrains/kotlin-native/blob/master/CHANGELOG.md).
Он позволяет компилировать код на Kotlin в нативный код с помощью LLVM, без зависимости от виртуальной машины JVM и других библиотек.
Далее мои субъективные впечатления по опыту разработки демонстрационного приложения, так что буду рад исправлениям и дополнениям.
Из плюсов:
* исходный код под пермиссивной открытой лицензией (Apache-2.0 license)
* работа на всех поддерживаемых LLVM платформах, в частности iOS и десктопы
* генерирует единственный исполняемый файл без сторонних зависимостей
* низкое потребление системных ресурсов
* доступны все базовые "вкусности" Kotlin вроде коллекций и функционального программирования
* есть прозрачный interop с языком C
* как следствие: доступны low-level функции платформы, в частности POSIX
Из минусов:
* стандартная библиотека весьма бедная по сравнению с огромной JVM, многое придётся писать с нуля (пример: оставьте только пункт Native [тут](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io))
* нет стабильной библиотеки для GUI, хотя есть некоторые привязки через C interop ([GTK](https://github.com/JetBrains/kotlin-native/tree/master/samples/gtk), [libui](https://github.com/msink/kotlin-libui))
* слабый инструментарий по сравнению с той же Android Studio, например нет той же локализации
* относительно долгое время сборки
Больше о Kotlin/Native можно почитать [тут](https://kotlinlang.org/docs/native-overview.html), а примеры доступны на [Github](https://github.com/JetBrains/kotlin-native/tree/master/samples).
Терминология
------------
*Интернационализация* (i18n): подготовка приложения к локализации, обычно выполняется разработчиками.
*Локализация* (l18n): Процесс перевода и адаптации контента приложения для конкретных языков, обычно выполняется переводчиками.
**Важно**: "контент" тут это не только строки, но и направление текста, формат даты, чисел и так далее. В данной статье ограничусь только строками.
Что такое GNU gettext
---------------------
Этот пакет из нескольких утилит, библиотек и регламентов.
Является частью [GNU Translation Project](http://translationproject.org/html/welcome.html).
Состоит из:
* правила оформления исходного кода для последующей интернационализации
* утилиты для генерации текстовых файлов с локализуемыми строками
* кроссплатформенная нативная библиотека для извлечения переводов в runtime
* правила дистрибуции бинарных файлов с переводами
Почему GNU gettext
------------------
Интернационализация в Kotlin/JVM для Android использует средства Android SDK, в частности строковые ресурсы, и завязана на JVM.
Поэтому для Kotlin/Native эти средства недоступны.
В Qt есть собственный инструментарий, но его не получится использовать вне Qt, тем более с отличным от C++ языком.
Поэтому остаётся GNU gettext:
* универсальный (поддерживается множество языков программирования)
* кроссплатформенный (Win/Mac/Linux, есть Android/iOS [версия](https://github.com/androidports/gettext))
* стабильный в силу почтенного возраста
* с подробной [документацией](https://www.gnu.org/software/gettext/manual/gettext.html)
* со вспомогательными [приложениями](https://www.gnu.org/software/trans-coord/manual/web-trans/html_node/PO-Editors.html)
Демонстрационный проект
-----------------------
Суть: консольная программа пока только под Linux, чтобы не переусложнять код.
Функционал: читает натуральное число из аргумента командной строки или stdin, и переводит его в количественное числительное на японском.
Число может содержать специфичные для локали разделители тысяч, которая программа выводит при запуске.
Скачать проект можно на [Github](https://github.com/eraxillan/JapaneseNumeralTranslator) и затем открыть в IntelliJ IDEA.
Характеристики исполняемых файлов
---------------------------------
Для начала время полной сборки: ~18 сек на конфигурации Ryzen 3900X + 32GB DDR4-3600 + NVM-E SSD. На мой взгляд многовато для такого маленького проекта и такой конфигурации.
Тут можно вспомнить о преимуществах скриптовых языков, которые компилировать не надо.
Теперь посмотрим свойства исполняемого файла для отладочной и релизной конфигураций:
Размеры скомпилированных исполняемых файлов
```
$ file build/bin/native/debugExecutable/JapaneseNumeralTranslator.kexe
build/bin/native/debugExecutable/JapaneseNumeralTranslator.kexe: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.16, BuildID[xxHash]=a0971dbf76e9db60, with debug_info, not stripped
$ ldd build/bin/native/debugExecutable/JapaneseNumeralTranslator.kexe
linux-vdso.so.1 (0x00007fff890d7000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007f348e47a000)
libm.so.6 => /lib64/libm.so.6 (0x00007f348e334000)
libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f348e312000)
libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007f348e2f7000)
libc.so.6 => /lib64/libc.so.6 (0x00007f348e12c000)
/lib64/ld-linux-x86-64.so.2 (0x00007f348e4a0000)
libresolv.so.2 => /lib64/libresolv.so.2 (0x00007f348e112000)
libutil.so.1 => /lib64/libutil.so.1 (0x00007f348e10b000)
libcrypt.so.1 => /lib64/libcrypt.so.1 (0x00007f348e0d1000)
librt.so.1 => /lib64/librt.so.1 (0x00007f348e0c6000)
$ file build/bin/native/releaseExecutable/JapaneseNumeralTranslator.kexe
build/bin/native/releaseExecutable/JapaneseNumeralTranslator.kexe: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.16, BuildID[xxHash]=c76aff5e0db3fdae, not stripped
$ ldd build/bin/native/releaseExecutable/JapaneseNumeralTranslator.kexe
linux-vdso.so.1 (0x00007ffff69c2000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007f41ad9dd000)
libm.so.6 => /lib64/libm.so.6 (0x00007f41ad897000)
libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f41ad875000)
libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007f41ad85a000)
libc.so.6 => /lib64/libc.so.6 (0x00007f41ad68f000)
/lib64/ld-linux-x86-64.so.2 (0x00007f41ada03000)
libresolv.so.2 => /lib64/libresolv.so.2 (0x00007f41ad675000)
libutil.so.1 => /lib64/libutil.so.1 (0x00007f41ad66e000)
libcrypt.so.1 => /lib64/libcrypt.so.1 (0x00007f41ad634000)
librt.so.1 => /lib64/librt.so.1 (0x00007f41ad629000)
$ ls -lh build/bin/native/debugExecutable/JapaneseNumeralTranslator.kexe
-rwxr-xr-x. 1 eraxillan eraxillan 1.8M Mar 7 13:24 build/bin/native/debugExecutable/JapaneseNumeralTranslator.kexe
$ ls -lh build/bin/native/releaseExecutable/JapaneseNumeralTranslator.kexe
-rwxr-xr-x. 1 eraxillan eraxillan 529K Mar 7 13:24 build/bin/native/releaseExecutable/JapaneseNumeralTranslator.kexe
```
Тут всё в порядке, бинарники скромные по размеру и без каких-либо сторонних зависимостей.
Отладка проекта
---------------
Она не работает, по крайней мере в Community Edition.
Просто игнорируются точки останова, хотя судя по выводу команды *file* отладочные символы в исполняемом файле есть.
Насколько я понял, соответствующий плагин доступен только в платной редакции IDE, которая пока для меня избыточна.
Прошу поправить, если ошибаюсь.
Так что для написания демо пришлось обходиться printf-driven отладкой, ну мне не привыкать после Android AOSP.
Интернационализация
-------------------
В случае нашего проекта нужно лишь все локализуемые строки "обернуть" в вызов функции *gettext()*.
Для краткости можно сделать синоним этой функции, например *tr()*, это общепринятая практика.
```
import kotlinx.cinterop.*
import platform.linux.*
import platform.posix.*
fun tr(key: String): String = gettext(key)?.toKString() ?: ""
```
Понадобится ещё служебный код для работы с POSIX-локалями, он находится в файле [Locale.kt](https://github.com/eraxillan/JapaneseNumeralTranslator/blob/master/src/nativeMain/kotlin/Locale.kt).
Также мы должны заранее определиться с количеством поддерживаемых языков: для демо это будут только английский и русский, плюс числительные на японском для любого языка.
Кстати, посмотреть названия локалей можно с помощью команды *locale -a*.
Перевод локализуемых строк
--------------------------
Я написал Bash-скрипты для генерации с нуля и обновления файлов gettext:
* [create\_localization.sh](https://github.com/eraxillan/JapaneseNumeralTranslator/blob/master/scripts/create_localization.sh)
* [update\_localization.sh](https://github.com/eraxillan/JapaneseNumeralTranslator/blob/master/scripts/update_localization.sh)
Далее вкратце опишу основные шаги, которые они выполняют.
Генерируем pot-файл ("шаблон"), который содержит базовую информацию о программе и собственно строки нуждающиеся в переводе.
```
# Extract all tr() wrapped strings to po/jnt.pot file
xgettext --keyword=tr --language=java \
--add-comments --sort-output \
--copyright-holder='Alexander Kamyshnikov ' \
--package-name='Japanese numeral translator' \
--package-version='1.0' \
--msgid-bugs-address='axill777@gmail.com' \
-o po/jnt.pot --files-from=KT\_FILES
```
Генерируем po-файл (текстовый перевод):
```
# Generate locale sources
# NOTE: --no-translator option is a workaround to supress email input request
msginit --no-translator --input=po/jnt.pot --locale=en_US.UTF-8 --output po/en_US/jnt.po
msginit --no-translator --input=po/jnt.pot --locale=ru_RU.UTF-8 --output po/ru_RU/jnt.po
```
Генерируем mo-файл (бинарный перевод):
```
# Generate locale binary files
msgfmt --output-file=po/en_US/jnt.mo po/en_US/jnt.po
msgfmt --output-file=po/ru_RU/jnt.mo po/ru_RU/jnt.po
```
Развертывание бинарных файлов с переводами
------------------------------------------
К сожалению, Kotlin/Native не поддерживает ресурсы, так что "упаковать" *mo*-файлы в исполняемый файл пока не выйдет.
На это есть соответствующий [баг](https://youtrack.jetbrains.com/issue/KT-39194).
Думаю, функционал ресурсов можно реализовать и вручную дополнительной задачей в Gradle, это пожалуй тема для отдельной статьи.
Для тестового проекта положим mo-файлы рядом с приложением, где не нужны права суперпользователя и где gettext сможет их найти.
Для релиза приложение следует упаковать в RPM/DEB-пакет, а mo-файлы установить в директорию `/usr/share/locale`.
Итог
----
Как видите, процесс несложен, по крайней мере при наличии готового кода и скриптов.
В процессе разработки нужно лишь периодически вызывать [update\_localization.sh](https://github.com/eraxillan/JapaneseNumeralTranslator/blob/master/scripts/update_localization.sh), переводить новые строки, и снова вызывать этот скрипт для генерации mo-файлов.
ありがとう ございます, или спасибо за внимание!
Источники
---------
Определения взяты из [документации Django](https://docs.djangoproject.com/en/3.0/topics/i18n/#definitions)
[Почему интернационализация и локализация имеют значение](https://habr.com/ru/company/otus/blog/523112)
[Kotlin Native: следите за файлами](https://habr.com/ru/post/435220)
[DxGetText — GNU Gettext for Delphi and C++ Builder](https://habr.com/ru/post/264693)
**P.S.**: дальше планирую использовать Kotlin/Native уже в рамках кроссплатформенных библиотек. Если будет интерес, могу доработать демо, например портировать на Windows. | https://habr.com/ru/post/548362/ | null | ru | null |
# Как собирать статистику по pytest-прогонам в Test IT
Как известно, основной проблемой в тестировании является отчетность по прогонам. Некоторые компании собирают данные в отдельном хранилище. Вместо того, чтобы вручную организовывать хранение, было решено сохранять их в `Test IT`. Такие данные как: исход, время выполнения и количество автоматизированных кейсов позволяют разделить тесты на выборки и дать оценку покрытия автотестами.
Это практично, поскольку в `Test IT` всё сделали до нас и не придется заново изобретать велосипед. Объединив `Test IT` и `pytest` мы сможем выборочно запускать авто тесты. В итоге должна получиться мастер система, из которой будут запускаться тестовые выборки и собираться статистика.
Несмотря на то, что существует множество СУТ (`Allure TestOps`, `TestLink` и т.п.), решили остановится на `Test IT`, поскольку это быстро растущий проект по доступной цене с поддержкой на русском языке, а лицензия на `TestRail` уже закончилась.
Техническое задание
-------------------
В рамках задачи следует:
* Настроить проект в `Test IT`
* Настроить прохождение pytest-тестов в `GitLab CI`
* Написать плагин для `pytest` который:
+ создает автоматизированный кейс в `Test IT`
+ связывает автоматизированный и ручной кейс
+ запускает только те автоматизированные кейсы, которые были выбраны в прогоне
+ отмечает результаты в режиме реального времени
Замечания
---------
* Для работы с [Test IT Swagger API](https://docs.testit.software/user-guide/swagger-api) следует создать `API-secret-key`
Реализация
----------
### 1. Создание и связывание автоматизированных кейсов в Test IT
В `Test IT` существует два вида кейсов: ручной и автоматизированный
Для того чтобы в прогоне появилась кнопка `Launch Autotests` автоматизированный кейс должны быть создан и привязан к ручному
В таком случае напротив ручного кейса появится символ ракеты
Создание и связывание автоматизированного кейса происходит через endpoint [AutoTests](https://docs.testit.software/user-guide/avtotesty/sozdanie-avtotestov), в который следует передать два параметра:
* testit\_case\_title — название автоматизированного кейса;
* testit\_case\_id — идентификатор ручного кейса для привязки.
```
@pytest.mark.testit_case_id(29035)
@putest.mark.testit_case_title("Проверка первой успешной загрузки файла")
def test_download_first(test_it_configuration):
"""
Автотест прилинкованный к ручному тесту
"""
from pprint import pprint
pprint(test_it_configuration)
sleep(randint(a=0, b=8))
```
Для запуска GitLab CI агента через Test IT следует создать WebHook со следующими параметрами:
Параметры для GitLab CI:
* URL — ссылка на trigger от GIT-проекта;
* ref — ветка, в которой запускаются тесты;
* token — токин от GitLab CI триггера.
Параметры для запуска PYTEST:
* TEST\_IT — флаг сообщающий, что тесты запущены из Test IT;
* TESTIT\_URL — ссылка на Test IT;
* API\_KEY — ключ для [Test IT Swagger API](https://docs.testit.software/user-guide/swagger-api);
* PROJECT\_ID — идентификатор проекта в котором вы работаете;
* TEST\_IT\_MODE — режим работы с Test IT.
TEST\_IT\_MODE принимает следующие значения:
* DELETE\_AUTOTESTS
* CREAT\_AUTOTESTS
* LINK\_AUTOTESTS
* RUN
Эти параметры будут переданы в GitLab CI и сохранены в переменных окружения агента
Тесты получают значения из переменных окружения агента при помощи модуля getenv
```
from os import getenv
class TestItParams:
"""
Параметры из Test IT
"""
is_test_it = getenv('TEST_IT', 'False').lower().capitalize() == 'True'
mode = getenv('TEST_IT_MODE', 'RUN')
url = getenv('TESTIT_URL', 'http://tmslt-1.video.rt.ru/')
key = getenv('API_KEY', None)
project_id = getenv('PROJECT_ID', None)
run_id = getenv('TEST_RUN_ID', None)
configuration_id = getenv('CONFIG_ID', None)
```
Класс TestItParams следует сохранить в объекте [session](https://docs.pytest.org/en/7.1.x/reference/reference.html#session)
```
def pytest_sessionstart(session):
"""
SetUP тестовый сессии: собрать env-параметры из TestIT
"""
session.test_it = TestItParams
```
Для создания автоматизированного кейса во время запуска pytest, нам нужно достать два параметра testit\_case\_title и testit\_case\_id.
Эти параметры можно получить из [pytest\_collection\_modifyitems](https://docs.pytest.org/en/7.1.x/reference/reference.html#collection-hooks), поскольку он вызывается во время составления списка на запуск.
Для этого напишем [plugin](https://docs.pytest.org/en/6.2.x/writing_plugins.html) в файле conftest.py
```
def pytest_collection_modifyitems(session, items):
"""
Перехват состояния перед публикацией списка кейсов
"""
if session.test_it.is_test_it is True:
print('Тесты запущены для TEST_IT')
if 'DELETE_AUTOTESTS' in session.test_it.mode:
delete_all_auto_test_from_project(pytest_session=session)
if 'CREAT_AUTOTESTS' in session.test_it.mode:
create_autotest_in_project(pytest_session=session, pytest_items=items)
if 'LINK_AUTOTESTS' in session.test_it.mode:
link_autotests_to_testcases(pytest_session=session, pytest_items=items)
if 'RUN' in session.test_it.mode:
select_autotest_from_testrun_only(pytest_session=session)
else:
print('\nПроходит штатный запуск')
```
Функции create\_autotest\_in\_project и link\_autotests\_to\_testcases это обычные API запросы через endpoint [AutoTests](https://docs.testit.software/user-guide/avtotesty/sozdanie-avtotestov).
Параметр test\_it\_mode используется для разделения задач: создание, привязка, удаление или запуск.
### 2. Выборочный запуск pytest-тестов
При создании тестового плана возникает потребность в запуске только выбранных автоматизированных кейсов.
Поскольку `pytest` ничего не знает о тестовом плане, то он должен запрашивать его самостоятельно.
Для этого по значению параметра TEST\_RUN\_ID через endpoint [TestRunes](https://docs.testit.software/user-guide/avtotesty/istoriya-zapuskov) мы получаем список тестов в текущем прогоне.
Далее выбираем только те тесты, которые есть в прогоне и удаляем остальные.
```
def pytest_collection_modifyitems(session, items):
"""
Перехват состояния перед публикацией списка кейсов: создание, удаление, линковка, выборка
"""
if session.test_it.is_test_it is True:
print('Тесты запущены для TEST_IT')
if 'DELETE_AUTOTESTS' in session.test_it.mode:
delete_all_auto_test_from_project(pytest_session=session)
if 'CREAT_AUTOTESTS' in session.test_it.mode:
create_autotest_in_project(pytest_session=session, pytest_items=items)
if 'LINK_AUTOTESTS' in session.test_it.mode:
link_autotests_to_testcases(pytest_session=session, pytest_items=items)
if 'RUN' in session.test_it.mode:
select_autotest_from_testrun_only(pytest_session=session)
else:
print('\nПроходит штатный запуск')
```
Фильтрация происходит в объекте [session.items](https://docs.pytest.org/en/7.1.x/reference/reference.html#item) в момент составления списка на запуск.
```
def select_autotest_from_testrun_only(pytest_session):
"""
Выбрать для запуска только те кейсы, которые содержатся в тестовом прогоне
"""
run_api = TestRunes(pytest_session.test_it.url, pytest_session.test_it.key)
current_test_run = run_api.get_testrun_by_id(pytest_session.test_it.run_id)
external_ids = []
for case in current_test_run['testResults']:
if case['startedOn'] is None:
external_ids.append((case['autoTest']['externalId'],
case['configuration']))
edited_session_items = []
for case in pytest_session.items:
for external_id in external_ids:
if case.name in external_id[0]:
case.test_it_configuration = external_id[1]
edited_session_items.append(case)
pytest_session.items = edited_session_items
```
### 3. Возврат результата прохождения pytest-тестов
Каждый автоматизированный кейс должен получать результат прохождения в режиме реального времени а не постфактум.
Для возвращения статуса в реальном времени нам следует воспользоваться хуком [pytest\_runtest\_makereport](https://docs.pytest.org/en/7.1.x/reference/reference.html#test-running-runtest-hooks) с декоратором [@pytest.hookimpl(hookwrapper=True)](https://docs.pytest.org/en/7.1.x/how-to/writing_hook_functions.html#hookwrapper-executing-around-other-hooks).
Он позволяет перехватывать выполнение ОДНОГО теста ДО и ПОСЛЕ прохождения.
```
@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item):
"""
Перехватывает состояние каждого теста во время: setup и done
"""
outcome = yield
if 'RUN' in item.session.test_it.mode:
provide_test_results_into_run(pytest_session=item.session,
pytest_outcome=outcome,
pytest_item=item)
```
Этот хук возвращает объект outcome, в котором содержится информация о прогоне текущего теста.
Передача результатов прогона в Test IT происходит через endpoint [TestRunes](https://docs.testit.software/user-guide/avtotesty/istoriya-zapuskov).
```
def provide_test_results_into_run(pytest_session, pytest_outcome, pytest_item):
"""
Предоставить результат выполнения теста в TestIT
"""
test_run_api = TestRunes(pytest_session.test_it.url, pytest_session.test_it.key)
res = pytest_outcome.get_result()
if res.when == "call":
autotest_id = pytest_item.name
outcome = res.outcome
duration = res.duration
message = ''
traceback = ''
if res.outcome == 'failed':
message = res.longrepr.reprcrash.message
traceback = res.longreprtext
test_run_api.set_auto_test_results_for_test_run(run_id=pytest_session.test_it.run_id,
autoTestExternalId=autotest_id,
outcome=humanize(outcome),
message=message,
traces=traceback,
duration=duration,
configurationId=pytest_item.test_it_configuration['id'])
```
Вывод
-----
Объединив Test IT и pytest мы собрали мастер систему которая умеет:
* запускать автотесты в GitLab CI;
* получать результат в режиме реального времени;
* собирать статистику по запускам;
* запускать выборки тестов.
Test IT имеет красивый интерфейс, предоставляющий кольцевые-диаграммы, различные таблицы и графики. Можно узнать, в каком прогоне упал конкретный тест и сколько времени он выполнялся.
Демонстрация
------------
Ссылки
------
* [Александр Волков — Pytest Plugins: Как расширить функционал тестового фреймворка через плагины](https://www.youtube.com/watch?v=p3XUv8C8FKo)
* [Test IT Swagger API](https://docs.testit.software/user-guide/swagger-api)
* [pytest](https://docs.pytest.org/) | https://habr.com/ru/post/695814/ | null | ru | null |
# Top 10 Bugs Found in C++ Projects in 2019
Another year is drawing to an end, and it's a perfect time to make yourself a cup of coffee and reread the reviews of bugs collected across open-source projects over this year. This would take quite a while, of course, so we prepared this article to make it easier for you. Today we'll be recalling the most interesting dark spots that we came across in open-source C/C++ projects in 2019.
No. 10. What operating system are we running on?
------------------------------------------------
[V1040](https://www.viva64.com/en/w/v1040/) Possible typo in the spelling of a pre-defined macro name. The '\_\_MINGW32\_' macro is similar to '\_\_MINGW32\_\_'. winapi.h 4112
```
#if !defined(__UNICODE_STRING_DEFINED) && defined(__MINGW32_)
#define __UNICODE_STRING_DEFINED
#endif
```
There is a typo in the name of the *\_\_MINGW32*\_ macro (MINGW32 is actually declared by \_\_MINGW32\_\_). Elsewhere in the project, the check is written correctly:
By the way, this bug was not only the first to be described in the article "[CMake: the Case when the Project's Quality is Unforgivable](https://www.viva64.com/en/b/0658/)" but the very first genuine bug found by the V1040 diagnostic in a real open-source project (August 19, 2019).
No. 9. Who's first?
-------------------
[V502](https://www.viva64.com/en/w/v502/) Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '==' operator. mir\_parser.cpp 884
```
enum Opcode : uint8 {
kOpUndef,
....
OP_intrinsiccall,
OP_intrinsiccallassigned,
....
kOpLast,
};
bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned) {
Opcode o = !isAssigned ? (....)
: (....);
auto *intrnCallNode = mod.CurFuncCodeMemPool()->New(....);
lexer.NextToken();
if (o == !isAssigned ? OP\_intrinsiccall : OP\_intrinsiccallassigned) {
intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
} else {
intrnCallNode->SetIntrinsic(static\_cast(....));
}
....
}
```
We are interested in the following part:
```
if (o == !isAssigned ? OP_intrinsiccall : OP_intrinsiccallassigned) {
....
}
```
The precedence of the '==' operator is higher than that of the ternary operator (?:). Therefore, the conditional expression is evaluated in the wrong order and is equivalent to the following code:
```
if ((o == !isAssigned) ? OP_intrinsiccall : OP_intrinsiccallassigned) {
....
}
```
Since the constants *OP\_intrinsiccall* and *OP\_intrinsiccallassigned* are non-null, the condition will be returning *true* all the time, which means the body of the *else* branch is unreachable code.
This bug was described in the article "[Checking the Ark Compiler Recently Made Open-Source by Huawei](https://www.viva64.com/en/b/0690/)".
No. 8. Dangerous bitwise operations
-----------------------------------
[V1046](https://www.viva64.com/en/w/v1046/) Unsafe usage of the bool' and 'int' types together in the operation '&='. GSLMultiRootFinder.h 175
```
int AddFunction(const ROOT::Math::IMultiGenFunction & func) {
ROOT::Math::IMultiGenFunction * f = func.Clone();
if (!f) return 0;
fFunctions.push_back(f);
return fFunctions.size();
}
template
bool SetFunctionList( FuncIterator begin, FuncIterator end) {
bool ret = true;
for (FuncIterator itr = begin; itr != end; ++itr) {
const ROOT::Math::IMultiGenFunction \* f = \*itr;
ret &= AddFunction(\*f);
}
return ret;
}
```
The code suggests that the *SetFunctionList* function traverses an iterator list. If at least one iterator is invalid, the function returns *false*, or *true* otherwise.
However, the *SetFunctionList* function can return *false* even for valid iterators. Let's figure out why.The *AddFunction* function returns the number of valid iterators on the *fFunctions* list. That is, adding non-null iterators will cause the list to incrementally grow in size: 1, 2, 3, 4, and so on. This is where the bug comes into play:
```
ret &= AddFunction(*f);
```
Since the function returns a value of type *int* rather than *bool*, the '&=' operation will return *false* for even values because the least significant bit of an even number is always set to zero. This is how one subtle bug can break the return value of *SetFunctionsList* even when its arguments are valid.
If you were reading the snippet carefully (and you were, weren't you?), you could have noticed that it came from the project ROOT. Yes, we checked it too: "[Analyzing the Code of ROOT, Scientific Data Analysis Framework](https://www.viva64.com/en/b/0682/)".
No. 7. Variables mixed up
-------------------------
[V1001](https://www.viva64.com/en/w/v1001/) [CWE-563] The 'Mode' variable is assigned but is not used by the end of the function. SIModeRegister.cpp 48
```
struct Status {
unsigned Mask;
unsigned Mode;
Status() : Mask(0), Mode(0){};
Status(unsigned Mask, unsigned Mode) : Mask(Mask), Mode(Mode) {
Mode &= Mask;
};
....
};
```
It's very dangerous to use the same names for function arguments as for class members because you risk mixing them up. And that's exactly what happened here. The following expression doesn't make sense:
```
Mode &= Mask;
```
The function's argument changes, and that's it. This argument is not used in any way after that. What the programmer really wanted to write was probably the following:
```
Status(unsigned Mask, unsigned Mode) : Mask(Mask), Mode(Mode) {
this->Mode &= Mask;
};
```
This bug was found in [LLVM](http://llvm.org/). We have a tradition to check this project every now and then. This year we [checked](https://www.viva64.com/en/b/0629/) it one more time.
No. 6. C++ has its own laws
---------------------------
This bug stems from the fact that C++ rules don't always follow mathematical rules or «common sense». Look at the small snippet below and try to find the bug yourself.
[V709](https://www.viva64.com/en/w/v709/) Suspicious comparison found: 'f0 == f1 == m\_fractureBodies.size()'. Remember that 'a == b == c' is not equal to 'a == b && b == c'. btFractureDynamicsWorld.cpp 483
```
btAlignedObjectArray m\_fractureBodies;
void btFractureDynamicsWorld::fractureCallback()
{
for (int i = 0; i < numManifolds; i++)
{
....
int f0 = m\_fractureBodies.findLinearSearch(....);
int f1 = m\_fractureBodies.findLinearSearch(....);
if (f0 == f1 == m\_fractureBodies.size())
continue;
....
}
....
}
```
The condition seems to be checking that *f0* is equal to *f1* and is equal to the number of elements in *m\_fractureBodies*. It was probably meant to check if *f0* and *f1* are located at the end of the *m\_fractureBodies* array since they contain an object position found by the *findLinearSearch()* method. But in reality, this conditional expression checks if *f0* is equal to *f1* and then if *m\_fractureBodies.size()* is equal to the result of the expression *f0 == f1*. That is, the third operand here is checked against 0 or 1.
That's a nice bug! And, fortunately, a pretty rare one. So far we have [seen](https://www.viva64.com/en/examples/v709/) it only in three open-source projects, and, interestingly, all the three were game engines. This is not the only bug found in Bullet; the most interesting ones were described in the article "[PVS-Studio Looked into the Red Dead Redemption's Bullet Engine](https://www.viva64.com/en/b/0647/)".
No. 5. What's at the end of the line?
-------------------------------------
This one is easy if you know one tricky detail.
[V739](https://www.viva64.com/en/w/v739/) EOF should not be compared with a value of the 'char' type. The 'ch' should be of the 'int' type. json.cpp 762
```
void JsonIn::skip_separator()
{
signed char ch;
....
if (ch == ',') {
if( ate_separator ) {
....
}
....
} else if (ch == EOF) {
....
}
```
This is one of those bugs that you can't easily spot if you don't know that *EOF* is defined as -1. So, if you try to compare it with a variable of type *signed char*, the condition will almost always be *false*. The only exception is the character encoded as 0xFF (255). When compared with *EOF*, this character will turn into -1, thus making the condition true.
A lot of bugs in this year's Top 10 were found in computer gaming software: engines or open-source games. As you already guessed, this one came from that area too. More errors are described in the article "[Cataclysm Dark Days Ahead: Static Analysis and Roguelike Games](https://www.viva64.com/en/b/0628/)".
No. 4. The magic constant Pi
----------------------------
[V624](https://www.viva64.com/en/w/v624/) There is probably a misprint in '3.141592538' constant. Consider using the M\_PI constant from . PhysicsClientC\_API.cpp 4109
```
B3_SHARED_API void b3ComputeProjectionMatrixFOV(float fov, ....)
{
float yScale = 1.0 / tan((3.141592538 / 180.0) * fov / 2);
....
}
```
There's a tiny typo in the Pi number (3,141592653...): the number «6» is missing at the 7th decimal place.
An incorrect one-millionth decimal digit would hardly cause any noticeable harm, but it's still better to use existing constants from libraries, whose correctness is guaranteed. The Pi number, for instance, is represented by the constant M\_PI from the header math.h.
You already read about this bug in the article "[PVS-Studio Looked into the Red Dead Redemption's Bullet Engine](https://www.viva64.com/en/b/0647/)", where it was placed sixth. If you haven't read it yet, this is your last chance.
A small diversion
-----------------
We are approaching the Top 3 most interesting bugs. As you have probably noticed, I'm sorting the bugs not by their impact but by the effort it takes a human reviewer to find them. After all, the advantage of static analysis over code reviews is basically the inability of software tools to get tired or forget things. :)
Now, let's see what we have in our Top 3.
No. 3. An elusive exception
---------------------------
[V702](https://www.viva64.com/en/w/v702/) Classes should always be derived from std::exception (and alike) as 'public' (no keyword was specified, so compiler defaults it to 'private'). CalcManager CalcException.h 4
```
class CalcException : std::exception
{
public:
CalcException(HRESULT hr)
{
m_hr = hr;
}
HRESULT GetException()
{
return m_hr;
}
private:
HRESULT m_hr;
};
```
The analyzer has detected a class derived from the *std::exception* class using the *private* modifier (which is used by default if not specified otherwise). The problem with this code is that an attempt to catch a generic *std::exception* will cause the program to miss an exception of type *CalcException*. This behavior stems from the fact that private inheritance forbids implicit type conversion.
You definitely wouldn't like to see your program crash because of a missed *public* modifier. By the way, I bet you have used this application at least once in your life because it's the good old [Windows Calculator](https://github.com/Microsoft/calculator), which we also [checked](https://www.viva64.com/en/b/0615/) earlier this year.
No. 2. Unclosed HTML tags
-------------------------
[V735](https://www.viva64.com/en/w/v735/) Possibly an incorrect HTML. The "" closing tag was encountered, while the "" tag was expected. book.cpp 127
```
static QString makeAlgebraLogBaseConversionPage() {
return
BEGIN
INDEX_LINK
TITLE(Book::tr("Logarithmic Base Conversion"))
FORMULA(y = log(x) / log(a), logax = log(x) / log(a))
END;
}
```
As it often happens, C/C++ source code doesn't say much by itself, so let's take a look at the preprocessed code generated from the snippet above:
The analyzer has found an unclosed tag. There are many html-code fragments here, so the authors need to revise it.
Surprised we can diagnose this kind of bugs? I was impressed too when I saw that for the first time. So, yes, we do know something about analyzing html code. Well, only if it's within C++ code. :)
Not only is this bug placed second but it's a second calculator on our Top 10 list. To learn what other bugs we found in this project, see the article "[Following in the Footsteps of Calculators: SpeedCrunch](https://www.viva64.com/en/b/0618/)".
No. 1. Elusive standard functions
---------------------------------
Here's the bug placed first. This one is an impressively weird bug, which managed to make it through the code review.
Try to find it yourself:
```
static int
EatWhitespace (FILE * InFile)
/* ----------------------------------------------------------------------- **
* Scan past whitespace (see ctype(3C)) and return the first non-whitespace
* character, or newline, or EOF.
*
* Input: InFile - Input source.
*
* Output: The next non-whitespace character in the input stream.
*
* Notes: Because the config files use a line-oriented grammar, we
* explicitly exclude the newline character from the list of
* whitespace characters.
* - Note that both EOF (-1) and the nul character ('\0') are
* considered end-of-file markers.
*
* ----------------------------------------------------------------------- **
*/
{
int c;
for (c = getc (InFile); isspace (c) && ('\n' != c); c = getc (InFile))
;
return (c);
} /* EatWhitespace */
```
Now let's see what the analyzer has to say:
[V560](https://www.viva64.com/en/w/v560/) A part of conditional expression is always true: ('\n' != c). params.c 136.
Weird, isn't it? Let's take a look at some other curious spot but in a different file (charset.h):
```
#ifdef isspace
#undef isspace
#endif
....
#define isspace(c) ((c)==' ' || (c) == '\t')
```
Hm, this is strange indeed… So, if the *c* variableis equal to *'\n',* then the seemingly harmless function *isspace( c )* willreturn *false*,thus preventing the second part of the check from executing due to short-circuit evaluation. And if *isspace( c )* executes, the *c* variablewill be equal either to *' '* or *'\t',* which is obviously not being equal to *'\n'*.
You could argue that this macro is similar to *#define true false* and code like that would never make it through a code review. But this particular snippet did – and was sitting in the repository waiting to be discovered.
For more detailed commentary on this bug, see the article "[Wanna Play a Detective? Find the Bug in a Function from Midnight Commander](https://www.viva64.com/en/b/0610/)".
Conclusion
----------
We have found tons of bugs over this year. Those were common copy-paste mistakes, inaccurate constants, unclosed tags, and lots of other defects. But our analyzer is evolving and [learning](https://www.viva64.com/en/b/0632/) to diagnose more and more types of issues, so we are certainly not going to slow down and will be publishing new articles about bugs found in projects just as regularly as before.
Just in case you haven't read our articles before, all these bugs were found using our PVS-Studio static analyzer, which you are welcome to [download](https://www.viva64.com/en/pvs-studio-download/) and try on your own projects. It detects bugs in programs written in C, C++, C#, and Java.
You've finally got to the finish line! If you missed the first two levels, I suggest that you seize the opportunity and complete these levels with us: [C#](https://habr.com/en/company/pvs-studio/blog/481174/) and [Java](https://habr.com/en/company/pvs-studio/blog/481184/). | https://habr.com/ru/post/481188/ | null | en | null |
# Mikrotik RouterOS + PHP скрипт на сайте. Расширение возможностей
Во времена ROS 5.x была потребность поднимать туннель к роутеру с белым динамическим адресом. В ROS 5 мы задавали не имя, а IP-адрес. Варианта 2: сервис DDNS, реализацию которого рассмотрим вкратце и второй о котором и будет рассказ.
Появилась идея сделать центр куда бы роутеры рапортовали свои адреса, и считывали адреса других. Решено было пойти путем наименьшего сопротивления – сайт на РНР.
На данный момент реализовано пару несложных вещей.
#### Оглашение своего адреса
Реализовано через запрос к скрипту с указанием своего (роутера) имени и пароля:
```
:local number "ROUTER_NUMBER";
:local pass "PASSWORD";
/tool fetch url="http://whoami.ho.ua/adr.php\?i=$number&p=$pass" mode=http
```
Имя и пароль нужны что бы никто не мог замаскироваться под вас и не инициировал подключение вашего роутера к своему или не мог считать адрес вашего роутера. Через утилиту fetch мы открываем нужный скрипт на сервере и через GET передаем имя и пароль. Скрипт же через $\_SERVER['REMOTE\_ADDR'] получает внешний адрес роутера и записывает его в БД.
#### Считывание чужого адреса
Опять же через ту же утилиту вызываем веб-скрипт:
```
:local number "ROUTER_NUMBER";
:local pass "PASSWORD";
/tool fetch url="http://whoami.ho.ua/getadr.php\?i=$number&p=$pass" mode=http dst-path="adr.txt"
:global routeradr [/file get adr.txt contents]
```
dst-path=«adr.txt» – указываем что полученные данные сохранять в файл. На самой веб-странице у нас сугубо текст с адресом запрашиваемого роутера:
$query=«SELECT address FROM table\_routers WHERE ((id='$\_GET[i]') AND (password='$\_GET[p]'))»;
$adr=mysql\_query($query) or die (mysql\_error());
$router=mysql\_fetch\_assoc($adr);
echo $router[address];
:global routeradr [/file get adr.txt contents] – глобальной переменной присваиваем значение содержимого файла. Потом эту переменную можно при менять по потребности и желанию.
#### Считывание скрипта из БД
```
:local number "ROUTER_NUMBER";
:local pass "PASSWORD";
/tool fetch url="http://whoami.ho.ua/getscript.php\?i=$number&p=$pass" mode=http dst-path="script.rsc"
import file-name=script.rsc
/file remove script.rsc
```
Всё так же как в предыдущем скрипте, но файл мы импортируем в конфиг роутера, а потом удаляем этот файл.
Для чего это необходимо? Например, Вы по невнимательности обрезали себе доступ к роутеру в фаерволе. Тогда можно добавить на сайте скрипт для этого роутера с котором указываете исправленные правила фаервола. Роутер следуя расписанию конектится к сайту, там РНР смотрит есть ли в БД непереданные скрипты для этого роутера:
```
SELECT id FROM table_routers WHERE ((id='$_GET[i]') AND (password='$_GET[p]'))
$adr=mysql_query($query) or die (mysql_error());
$router=mysql_fetch_assoc($adr);
$query="SELECT script, id FROM table_scripts WHERE ((router='$router[id]') AND (executed='N')) ORDER BY id ASC LIMIT 1";
```
Сначала мы проверяем верно ли заданы пароль и номер роутера (чтобы никто другой не мог считать ваш скрипт, может вы там пароли в конфиге меняете), а потом смотрим какой скрипт стоит в очереди не переданных для этого роутера.
Этот метод не решает ВОЗНИКШИЕ проблемы, он помогает их предотвратить. То есть необходимо предварительно «подстелить соломки» и забить в scheduler раз в Х минут/часов проверку роутером наличия новых скриптов для него.
Так же этот метод хорош, когда роутер имеет серую айпишку, а доступ к нему надо получить из вне. Забиваем скрипт поднятия ВПН-туннеля к своей белой айпишке и через заданное время имеем доступ к устройству даже за 10-ю НАТами.
Вот такая вот коротенькая история. Буду раз замечаниям и идеям что еще можно прикрутить к такому сервису. В планах еще небольшая статистика – что бы роутер сливал в БД пару своих параметров, например температуру, загрузку процессора и прочие.
Как бонус кусок готовых скриптов, о которых я писал в начале, получения ip с имени хоста и добавления его в политику IPsec.
Плюс в том что работает в связке Mikrotik + мыльницы которые поддерживают ddns и ipsec (Dlink 804 на пример). Скрипт который достает из дднс имени удаленного пира IP адрес и вставляет его в нужную политику:
```
:local nname RHost1;
:log info "start $nname";
:local newip [:resolve "rmotehost1.zapto.org"];
:local curip [/ip ipsec policy get [/ip ipsec policy find comment=$nname] sa-dst-address];
:log info "newip = $newip";
:log info "currentip = $curip";
:if ($newip != $curip) do={
:log info "ip $nname is $curip not $newip";
/ip ipsec policy set [/ip ipsec policy find comment=$nname] sa-dst-address=$newip;
:log info "end $nname";
}
```
И скрипт который подставляет на удаленной стороне текущий ip в политику ipsec:
```
:global lastip
:local wanip
:local wanif "pppoe-out1"
:if ([ :typeof $lastip ] = nil ) do={ :global lastip "0" }
:local wanip [ /ip address get [/ip address find interface=$wanif ] address ]
:if ([ :typeof $wanip ] = nil ) do={
:log info ("WANIP: no ip address on $wanif .")
} else= {
:for i from=( [:len $wanip] - 1) to=0 do={
:if ( [:pick $wanip $i] = "/") do={
:set wanip [:pick $wanip 0 $i];
:log info ("wan ip now is $wanip")
}
}
:if ($wanip != $lastip) do={
:log info ("Renew ipsec Policy: $wanif -> $wanip")
#Подставляем в политику ipsec
/ip ipsec policy set 0 sa-src-address=$wanip
:global lastip $wanip
}
}
``` | https://habr.com/ru/post/267293/ | null | ru | null |
# Alice — REST Мониторинг RabbitMQ
Собственно столкнулся с проблемой, что при использовании [RabbitMQ](http://rabbitmq.com) необходимо мониторить сервер. Системную утилиту rabbitmqctl можно запускать из командной строки, но запустить ее из приложения не получилось. Что-то связанное с окружением эрланга.
После небольшого гугления и общения в целевых форумал получил [заветную ссылку](http://willcodeforfoo.com/2009/07/13/announcing-alice/ "Проект alice")
Данный инструмент позволит автоматизировать администрирование сервера:
мониторинг и удаление старых очередей, связей и обменов и кол-во одновременных коннекций.
далее кр описание…
Сервер очередей RabbitMQ не имеет АПИ для его мониторинга и статистики. Модуль Alice позволяет осуществлять весь набор REST операций мониторинга:
/conn — Current connection information
/exchanges — Current exchanges information
/queues — Current queues
/users — Current users
/bindings — Current bindings
/control — Access to the RabbitMQ control
/permissions — Current permissions
/vhosts — Current vhosts
**старт**
`git clone git://github.com/auser/alice.git
cd alice
./start.sh`
**Получить список пользователей**
`# List users
curl -i localhost:9999/users
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 07:08:20 GMT
Content-Type: text/json
Content-Length: 19
{"users":["guest"]}
# Viewing a specific user
curl -i localhost:9999/users/guest
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 08:01:01 GMT
Content-Type: text/json
Content-Length: 17
{"users":"guest"}`
**Получить список коннекций**
`# List connections
curl -i localhost:9999/conn
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 07:30:52 GMT
Content-Type: text/json
Content-Length: 287
{"conn":[{"pid":"...","ip":"127.0.0.1","port":"5672","peer_address":"127.0.0.1" ...}]}`
**Получить список обменов**
`Exchanges
# List the current exchanges
curl -i localhost:9999/exchanges
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 07:34:14 GMT
Content-Type: text/json
Content-Length: 654
{"exchanges":[{"name":"amq.rabbitmq.log","type":"topic","durable":"true","auto_delete":...}`
**Получить список очередей**
`# List the current queues
curl -i localhost:9999/queues
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 07:35:42 GMT
Content-Type: text/json
Content-Length: 60
{"queues":[{"memory":"212988","name":"noises","vhost":"/"}]}`
**Получить список связей**
`# List the current bindings
curl -i localhost:9999/bindings
HTTP/1.1 200 OK
Server: MochiWeb/1.0 (Any of you quaids got a smint?)
Date: Tue, 04 Aug 2009 07:36:13 GMT
Content-Type: text/json
Content-Length: 69
{"bindings":[{"queue":"noises","exchange":"","from_queue":"noises"}]}`
есть возможность управление сервером: start/stop
get/put данные в очередь но это я пока не использовал. | https://habr.com/ru/post/71328/ | null | ru | null |
# Автоматизация HTTP запросов в контексте Spring
### Предыстория
Несколько месяцев назад поступила задача по написанию HTTP API работы с продуктом компании, а именно обернуть все запросы с помощью RestTemplate и последующим перехватом информации от приложения и модификации ответа. Примерная реализация сервиса по работе с приложением была таковая:
```
if (headers == null) {
headers = new HttpHeaders();
}
if (headers.getFirst("Content-Type") == null) {
headers.add("Content-Type", MediaType.APPLICATION_JSON_VALUE);
}
HttpEntity entity;
if (body == null) {
entity = new HttpEntity<>(headers);
} else {
entity = new HttpEntity<>(body, headers);
}
final String uri = String.format("%s%s/%s", workingUrl, apiPath, request.info());
final Class type = (Class) request.type();
final O response = (O)restTemplate.exchange(uri, request.method(), entity, type);
```
… простенький метод, принимающий тип, тело и заголовки запроса. И все бы хорошо, но выглядело как костыль и не особо юзабельно в контексте Spring.
И пока товарищи коллеги писали на старом механизме функционал в своих ветках, мне пришла в голову гениальнейшая идея — а почему бы не писать эти запросы "в одну строчку" (like Feign).
### Идея
У нас в руках имеется мощный DI контейнер Spring, так почему бы не использовать его функционал в полной мере? В частности инициализации Data репозиториев на примере Jpa. Предо мной стояла задача инициализация класса типа интерфейс в контексте Spring и три варианта решения перехвата вызова метода, как типичной реализации — Aspect, PostProcess и BeanDefinitionRegistrar.
### Кодовая база
Первым делом — аннотации, куда же без них, иначе как конфигурировать запросы.
1) Mapping — аннотация, идентифицирующая интерфейс как компонент HTTP вызовов.
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Mapping {
/**
* Registered service application name, need for config
*/
String alias();
}
```
Параметр alias отвечает за присваивание корневого роутинга сервиса, будь то <https://habr.com>, <https://github.com>, etc.
2) ServiceMapping — аннотация, идентифицирующая метод интерфейса, который должен быть вызван как стандартный HTTP запрос к приложению, откуда мы хотим получить ответ либо выполнить какое-либо действие.
```
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface ServiceMapping {
/**
* Registered service application route
*/
String path();
/**
* Registered service application route http-method
*/
HttpMethod method();
Header[] defaultHeaders() default {};
Class fallbackClass() default Object.class;
String fallbackMethod() default "";
}
```
**Параметры:**
* **path** — путь запроса, пример alias + /ru/hub/${hub\_name};
* **method** — метод HTTP запроса (GET, POST, PUT, etc.);
* **defaultHeaders** — статические заголовки запроса, которые неизменяемые для удаленного ресурса (Content-Type, Accept, etc.);
* **fallbackClass** — класс отбраковки запроса, который обработался с ошибкой (Exception);
* **fallbackMethod** — наименование метода класса, который должен вернуть корректный результат, если произошла ошибка (Exception).
3) Header — аннотация, идентифицирующая статические заголовки в настройках запроса
```
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})
@Documented
public @interface Header {
String name();
String value();
}
```
**Параметры:**
* **name** — наименование заголовка;
* **value** — значение заголовка.
Следующий этап — реализация своего FactoryBean для перехвата вызова методов интерфейса.
**MappingFactoryBean.java**
```
package org.restclient.factory;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.restclient.annotations.RestInterceptor;
import org.restclient.annotations.ServiceMapping;
import org.restclient.annotations.Type;
import org.restclient.config.ServicesConfiguration;
import org.restclient.config.ServicesConfiguration.RouteSettings;
import org.restclient.interceptor.Interceptor;
import org.restclient.model.MappingMetadata;
import org.restclient.model.Pair;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.jmx.access.InvocationFailureException;
import org.springframework.lang.NonNull;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.client.RestClientResponseException;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import javax.naming.ConfigurationException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.*;
/**
* @author: GenCloud
* @created: 2019/08
*/
@Slf4j
@ToString
public class MappingFactoryBean implements BeanFactoryAware, FactoryBean, ApplicationContextAware {
private static final Collection ignoredMethods = Arrays.asList("equals", "hashCode", "toString");
private Class type;
private List fallbackInstances;
private List metadatas;
private String alias;
private ApplicationContext applicationContext;
private BeanFactory beanFactory;
@Override
public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
@Override
public Class getObjectType() {
return type;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public Object getObject() {
return Enhancer.create(type, (MethodInterceptor) (instance, method, args, methodProxy) -> {
final boolean skip = ignoredMethods.stream().anyMatch(ignore -> method.getName().equals(ignore));
final ServiceMapping annotation = method.getAnnotation(ServiceMapping.class);
if (!skip && annotation != null) {
return invokeMethod(annotation, method, args);
}
return null;
});
}
/\*\*
\* It determines the meta-information of the executing method, calling an HTTP request based on the
\* meta-information found; interceptors are also called.
\*
\* @param annotation - main annotation that defines the path, type, standard request parameters.
\* @param method - callable method
\* @param args - method arguments
\* @return if the request is executed without errors, returns a clean server response in wrappers Mono/Flux.
\* @throws Throwable
\*/
private Object invokeMethod(ServiceMapping annotation, Method method, Object[] args) throws Throwable {
final MappingMetadata metadata = findMetadataByMethodName(method.getName());
if (metadata == null) {
throw new NoSuchMethodException(String.format("Cant find metadata for method %s. Check your mapping configuration!", method.getName()));
}
final RouteSettings routeSettings = findSettingsByAlias(alias);
final String host = routeSettings.getHost();
String url = metadata.getUrl().replace(String.format("${%s}", alias), host);
final HttpMethod httpMethod = metadata.getHttpMethod();
final HttpHeaders httpHeaders = metadata.getHttpHeaders();
final List> foundVars = new ArrayList<>();
final List> foundParams = new ArrayList<>();
final List> foundHeaders = new ArrayList<>();
final Parameter[] parameters = method.getParameters();
final Object body = initHttpVariables(args, parameters, foundVars, foundParams, foundHeaders);
url = replaceHttpVariables(url, foundVars, foundParams, foundHeaders, httpHeaders);
preHandle(args, body, httpHeaders);
if (log.isDebugEnabled()) {
log.debug("Execute Service Mapping request");
log.debug("Url: {}", url);
log.debug("Headers: {}", httpHeaders);
if (body != null) {
log.debug("Body: {}", body);
}
}
final Object call = handleHttpCall(annotation, args, url, httpMethod, body, httpHeaders, metadata);
postHandle(ResponseEntity.ok(call));
return call;
}
private Object handleHttpCall(ServiceMapping annotation, Object[] args, String url, HttpMethod httpMethod, Object body, HttpHeaders httpHeaders, MappingMetadata metadata) throws Throwable {
final WebClient webClient = WebClient.create(url);
ResponseSpec responseSpec;
final Class returnType = metadata.getReturnType();
try {
if (body != null) {
responseSpec = webClient
.method(httpMethod)
.headers(c -> c.addAll(httpHeaders))
.body(BodyInserters.fromPublisher(Mono.just(body), Object.class))
.retrieve();
} else {
responseSpec = webClient
.method(httpMethod)
.headers(c -> c.addAll(httpHeaders))
.retrieve();
}
} catch (RestClientResponseException ex) {
if (log.isDebugEnabled()) {
log.debug("Error on execute route request - Code: {}, Error: {}, Route: {}", ex.getRawStatusCode(), ex.getResponseBodyAsString(), url);
}
final String fallbackMethod = metadata.getFallbackMethod();
final Object target = fallbackInstances.stream()
.filter(o ->
o.getClass().getSimpleName().equals(annotation.fallbackClass().getSimpleName()))
.findFirst().orElse(null);
Method fallback = null;
if (target != null) {
fallback = Arrays.stream(target.getClass().getMethods())
.filter(m -> m.getName().equals(fallbackMethod))
.findFirst()
.orElse(null);
}
if (fallback != null) {
args = Arrays.copyOf(args, args.length + 1);
args[args.length - 1] = ex;
final Object result = fallback.invoke(target, args);
return Mono.just(result);
} else if (returnType == Mono.class) {
return Mono.just(ResponseEntity.status(ex.getRawStatusCode()).body(ex.getResponseBodyAsString()));
} else if (returnType == Flux.class) {
return Flux.just(ResponseEntity.status(ex.getRawStatusCode()).body(ex.getResponseBodyAsString()));
} else {
return Mono.empty();
}
}
final Method method = metadata.getMethod();
final Type classType = method.getDeclaredAnnotation(Type.class);
final Class type = classType == null ? Object.class : classType.type();
if (returnType == Mono.class) {
return responseSpec.bodyToMono(type);
} else if (returnType == Flux.class) {
return responseSpec.bodyToFlux(type);
}
return null;
}
private String replaceHttpVariables(String url, final List> foundVars, final List> foundParams,
final List> foundHeaders, final HttpHeaders httpHeaders) {
for (Pair pair : foundVars) {
url = url.replace(String.format("${%s}", pair.getKey()), String.valueOf(pair.getValue()));
}
for (Pair pair : foundParams) {
url = url.replace(String.format("${%s}", pair.getKey()), String.valueOf(pair.getValue()));
}
foundHeaders.forEach(pair -> {
final String headerName = pair.getKey();
if (httpHeaders.getFirst(headerName) != null) {
httpHeaders.set(headerName, String.valueOf(pair.getValue()));
} else {
log.warn("Undefined request header name '{}'! Check mapping configuration!", headerName);
}
});
return url;
}
private Object initHttpVariables(final Object[] args, final Parameter[] parameters, final List> foundVars,
final List> foundParams, final List> foundHeaders) {
Object body = null;
for (int i = 0; i < parameters.length; i++) {
final Object value = args[i];
final Parameter parameter = parameters[i];
final PathVariable pv = parameter.getDeclaredAnnotation(PathVariable.class);
final RequestParam rp = parameter.getDeclaredAnnotation(RequestParam.class);
final RequestHeader rh = parameter.getDeclaredAnnotation(RequestHeader.class);
final RequestBody rb = parameter.getDeclaredAnnotation(RequestBody.class);
if (rb != null) {
body = value;
}
if (rh != null) {
foundHeaders.add(new Pair<>(rh.value(), value));
}
if (pv != null) {
final String name = pv.value();
foundVars.add(new Pair<>(name, value));
}
if (rp != null) {
final String name = rp.value();
foundParams.add(new Pair<>(name, value));
}
}
return body;
}
private void preHandle(Object[] args, Object body, HttpHeaders httpHeaders) {
final Map beansOfType = applicationContext.getBeansOfType(Interceptor.class);
beansOfType.values()
.stream()
.filter(i ->
i.getClass().isAnnotationPresent(RestInterceptor.class)
&& ArrayUtils.contains(i.getClass().getDeclaredAnnotation(RestInterceptor.class).aliases(), alias))
.forEach(i -> i.preHandle(args, body, httpHeaders));
}
private void postHandle(ResponseEntity responseEntity) {
final Map beansOfType = applicationContext.getBeansOfType(Interceptor.class);
beansOfType.values()
.stream()
.filter(i ->
i.getClass().isAnnotationPresent(RestInterceptor.class)
&& ArrayUtils.contains(i.getClass().getDeclaredAnnotation(RestInterceptor.class).aliases(), alias))
.forEach(i -> i.postHandle(responseEntity));
}
private MappingMetadata findMetadataByMethodName(String methodName) {
return metadatas
.stream()
.filter(m -> m.getMethodName().equals(methodName)).findFirst()
.orElseThrow(() -> new InvocationFailureException(""));
}
private RouteSettings findSettingsByAlias(String alias) throws ConfigurationException {
final ServicesConfiguration servicesConfiguration = applicationContext.getAutowireCapableBeanFactory().getBean(ServicesConfiguration.class);
return servicesConfiguration.getRoutes()
.stream()
.filter(r ->
r.getAlias().equals(alias))
.findFirst()
.orElseThrow(() -> new ConfigurationException(String.format("Cant find service host! Check configuration. Alias: %s", alias)));
}
@SuppressWarnings("unused")
public Class getType() {
return type;
}
@SuppressWarnings("unused")
public void setType(Class type) {
this.type = type;
}
@SuppressWarnings("unused")
public List getMetadatas() {
return metadatas;
}
@SuppressWarnings("unused")
public void setMetadatas(List metadatas) {
this.metadatas = metadatas;
}
@SuppressWarnings("unused")
public String getAlias() {
return alias;
}
@SuppressWarnings("unused")
public void setAlias(String alias) {
this.alias = alias;
}
@SuppressWarnings("unused")
public List getFallbackInstances() {
return fallbackInstances;
}
@SuppressWarnings("unused")
public void setFallbackInstances(List fallbackInstances) {
this.fallbackInstances = fallbackInstances;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MappingFactoryBean that = (MappingFactoryBean) o;
return Objects.equals(type, that.type);
}
@Override
public int hashCode() {
return Objects.hash(type);
}
}
```
Вкратце объясню, что делает эта реализация объекта бина:
* обеспечивает хранение мета-информации методов интерфейса с настройками запросов к ресурсу, таких как сами методы идентифицированные аннотациями, классы отбраковки, коллекция моделей настроек роутинга;
* обеспечивает перехват вызова метода в контексте приложения с помощью CGlib (MappingFactoryBean#getObject()), т.е. формально реализации вызываемого метода нет, но физически срабатывает перехват метода и в зависимости от параметров аннотация и аргументов метода, происходит обработка HTTP запроса.
Третьим этапом является реализация низкоуровнего компонента DI контейнера Spring, а конкретно интерфейса ImportBeanDefinitionRegistrar.
**ServiceMappingRegistrator.java**
```
package org.restclient.factory;
import lombok.extern.slf4j.Slf4j;
import org.restclient.annotations.Header;
import org.restclient.annotations.Mapping;
import org.restclient.annotations.ServiceMapping;
import org.restclient.model.MappingMetadata;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.lang.NonNull;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import javax.naming.ConfigurationException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author: GenCloud
* @created: 2019/08
*/
@Slf4j
public class ServiceMappingRegistrator implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
private ResourceLoader resourceLoader;
private Environment environment;
@Override
public void setEnvironment(@NonNull Environment environment) {
this.environment = environment;
}
@Override
public void setResourceLoader(@NonNull ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
@Override
public void registerBeanDefinitions(@NonNull AnnotationMetadata metadata, @NonNull BeanDefinitionRegistry registry) {
registerMappings(metadata, registry);
}
private void registerMappings(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
final ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(resourceLoader);
final Set basePackages = getBasePackages(metadata);
final AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(Mapping.class);
scanner.addIncludeFilter(annotationTypeFilter);
basePackages
.stream()
.map(scanner::findCandidateComponents)
.flatMap(Collection::stream)
.filter(candidateComponent -> candidateComponent instanceof AnnotatedBeanDefinition)
.map(candidateComponent -> (AnnotatedBeanDefinition) candidateComponent)
.map(AnnotatedBeanDefinition::getMetadata)
.map(ClassMetadata::getClassName)
.forEach(className -> buildGateway(className, registry));
}
private void buildGateway(String className, BeanDefinitionRegistry registry) {
try {
final Class type = Class.forName(className);
final List methods = Arrays
.stream(type.getMethods())
.filter(method ->
method.isAnnotationPresent(ServiceMapping.class))
.collect(Collectors.toList());
final String alias = type.getDeclaredAnnotation(Mapping.class).alias();
final List metadatas = new ArrayList<>();
final List fallbackInstances = new ArrayList<>();
for (Method method : methods) {
final ServiceMapping serviceMapping = method.getDeclaredAnnotation(ServiceMapping.class);
final Class[] args = method.getParameterTypes();
final Header[] defaultHeaders = serviceMapping.defaultHeaders();
final String path = serviceMapping.path();
final HttpMethod httpMethod = serviceMapping.method();
final HttpHeaders httpHeaders = new HttpHeaders();
final StringBuilder url = new StringBuilder();
url.append("${").append(alias).append("}").append(path);
final Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
final Parameter parameter = parameters[i];
for (Annotation annotation : parameter.getAnnotations()) {
if (!checkValidParams(annotation, args)) {
break;
}
if (annotation instanceof RequestParam) {
final String argName = ((RequestParam) annotation).value();
if (argName.isEmpty()) {
throw new ConfigurationException("Configuration error: defined RequestParam annotation dont have value! Api method: " + method.getName() + ", Api Class: " + type);
}
final String toString = url.toString();
if (toString.endsWith("&") && i + 1 == args.length) {
url.append(argName).append("=").append("${").append(argName).append("}");
} else if (!toString.endsWith("&") && i + 1 == args.length) {
url.append("?").append(argName).append("=").append("${").append(argName).append("}");
} else if (!toString.endsWith("&")) {
url.append("?").append(argName).append("=").append("${").append(argName).append("}").append("&");
} else {
url.append(argName).append("=").append("${").append(argName).append("}").append("&");
}
} else if (annotation instanceof PathVariable) {
final String argName = ((PathVariable) annotation).value();
if (argName.isEmpty()) {
throw new ConfigurationException("Configuration error: defined PathVariable annotation dont have value! Api method: " + method.getName() + ", Api Class: " + type);
}
final String toString = url.toString();
final String argStr = String.format("${%s}", argName);
if (!toString.contains(argStr)) {
if (toString.endsWith("/")) {
url.append(argStr);
} else {
url.append("/").append(argStr);
}
}
} else if (annotation instanceof RequestHeader) {
final String argName = ((RequestHeader) annotation).value();
if (argName.isEmpty()) {
throw new ConfigurationException("Configuration error: defined RequestHeader annotation dont have value! Api method: " + method.getName() + ", Api Class: " + type);
}
httpHeaders.add(argName, String.format("${%s}", argName));
}
}
}
if (defaultHeaders.length > 0) {
Arrays.stream(defaultHeaders)
.forEach(header -> httpHeaders.add(header.name(), header.value()));
}
final Object instance = serviceMapping.fallbackClass().newInstance();
fallbackInstances.add(instance);
final String fallbackName = serviceMapping.fallbackMethod();
final String buildedUrl = url.toString();
final MappingMetadata mappingMetadata = new MappingMetadata(method, httpMethod, buildedUrl, httpHeaders, fallbackName);
metadatas.add(mappingMetadata);
log.info("Bind api path - alias: {}, url: {}", alias, buildedUrl);
}
final BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(MappingFactoryBean.class);
beanDefinitionBuilder.addPropertyValue("type", className);
beanDefinitionBuilder.addPropertyValue("alias", alias);
beanDefinitionBuilder.addPropertyValue("metadatas", metadatas);
beanDefinitionBuilder.addPropertyValue("fallbackInstances", fallbackInstances);
final AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
final BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[]{type.getSimpleName()});
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
} catch (IllegalAccessException | InstantiationException | ClassNotFoundException | ConfigurationException e) {
e.printStackTrace();
}
}
private boolean checkValidParams(Annotation annotation, Object[] args) {
Arrays
.stream(args)
.map(Object::getClass)
.forEach(type -> {
if (annotation instanceof RequestParam) {
if (type.isAnnotationPresent(PathVariable.class)) {
throw new IllegalArgumentException("Annotation RequestParam cannot be used with PathVariable");
}
} else if (annotation instanceof PathVariable) {
if (type.isAnnotationPresent(RequestParam.class)) {
throw new IllegalArgumentException("Annotation PathVariable cannot be used with RequestParam");
}
}
});
return true;
}
private Set getBasePackages(AnnotationMetadata importingClassMetadata) {
Map attributes = importingClassMetadata.getAnnotationAttributes(SpringBootApplication.class.getCanonicalName());
if (attributes == null) {
attributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getCanonicalName());
}
Set basePackages = new HashSet<>();
if (attributes != null) {
basePackages = Arrays.stream((String[]) attributes.get("scanBasePackages")).filter(StringUtils::hasText).collect(Collectors.toSet());
Arrays.stream((Class[]) attributes.get("scanBasePackageClasses")).map(ClassUtils::getPackageName).forEach(basePackages::add);
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
}
return basePackages;
}
private ClassPathScanningCandidateComponentProvider getScanner() {
return new ClassPathScanningCandidateComponentProvider(false, environment) {
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
boolean isCandidate = false;
if (beanDefinition.getMetadata().isIndependent()) {
if (!beanDefinition.getMetadata().isAnnotation()) {
isCandidate = true;
}
}
return isCandidate;
}
};
}
}
```
Т.е. что происходит в начале старта приложения — когда срабатывает событие контекста Spring REFRESH, будут задействованы все реализации интерфейса ImportBeanDefinitionRegistrar, которые импортированы в контекст приложения, и будет вызван метод registerBeanDefinitions в который поступает информация о аннотированных конфигурационных классах и фабрика-регистратор/хранилище бинов (компонентов, сервисов, репозиториев, etc.), и прямо в этом методе можно получить информацию о базовых пакетах приложения и "в какую сторону копать" для поиска наших интерфейсов и их инициализации с помощью BeanDefinitionBulder и нашей реализацией MappingFactoryBean. Для импортирования регистратора достаточно использовать аннотацию [Import](https://habr.com/ru/users/import/) с именем этого класса (в текущей реализации модуля используется конфигурационный класс RestClientAutoConfiguration, где и прописаны необходимые аннотации для работы модуля).
### Как использовать
Кейс — мы хотим получить список информации некоего репозитория GitHub пользователя.
1) Написание конфигурации для работы с сервисом (application.yml)
```
services:
routes:
- host: https://api.github.com # корневой роутинг АПИ GitHub
alias: github-service # наименование сервиса, использующееся в аннотации Mapping
```
1) Реализация интерфейса по взаимодействию с сервисом
```
@Mapping(alias = "github-service") // алиас сервиса указанный в конфигурации
public interface RestGateway {
/**
* Метод получения информации всех репозиториев конкретного пользователя.
*
* @param userName - пользователь GitHub
* @return массив объектов LinkedHashMap
*/
@ServiceMapping(path = "/users/${userName}/repos", method = GET)
@Type(type = ArrayList.class) // тип возвращаемого объекта при сериализации в обертке Mono/Flux
Mono getRepos(@PathVariable("userName") String userName);
}
```
2) Вызов сервиса
```
@SprinBootApplication
public class RestApp {
public static void main(String... args) {
final ConfigurableApplicationContext context = SpringApplication.run(RestApp.class, args);
final RestGateway restGateway = context.getType(RestGateway.class);
final Mono response = restGateway.getRepos("gencloud");
response.doOnSuccess(list ->
log.info("Received response: {}", list)).subscribe();
}
}
```
Как результат выполнения в дебаге можно увидеть это (для удобства можно подложить за место типа ArrayList объектную обертку результирующего json ответа; код отличается, потому что использовал юнит тест в купе с reactor-test библиотекой, но принцип от этого не изменился):
### Заключение
Не всем конечно по душе такой подход, сложный дебаг, не там ткнул аннотацию — получил оплеуху от ConfigurationException, еще и какие-то конфиги писать, ой...
Приму конструктивные пожелания и предложения по развитию API, надеюсь, что статья была полезной к прочтению. Спасибо за внимание.
[Весь код доступен по ссылке](https://github.com/GenCloud/rest_client) | https://habr.com/ru/post/464089/ | null | ru | null |
# Тестирование PostgreSQL с HugePages в Linux
Ядро Linux предоставляет широкий спектр параметров конфигурации, которые могут повлиять на производительность. Главное — выбрать правильную конфигурацию для вашего приложения и рабочей нагрузки. Как и любой другой базе данных, PostgreSQL необходима оптимальная настройка ядра Linux. Неправильные настройки могут привести к снижению производительности. Важно проводить сравнительный анализ производительности базы данных после каждого сеанса настройки. В одном из своих предыдущих постов под названием ["Tune Linux Kernel Parameters For PostgreSQL Optimization"](https://www.percona.com/blog/2018/08/29/tune-linux-kernel-parameters-for-postgresql-optimization/) я описал некоторые из наиболее полезных параметров ядра Linux и то, как они помогают повысить производительность базы данных. Теперь я поделюсь результатами сравнительного тестирования после настройки HugePages в Linux под различными нагрузками PostgreSQL. Я провел полный набор тестов под множеством различных нагрузок PostgreSQL с различным числом параллельных клиентов.
### ПК, на котором выполнялось тестирование
* Сервер Supermicro:
1. Intel® Xeon® CPU E5-2683 v3 @ 2,00 ГГц
2. 2 сокета / 28 ядер / 56 потоков
3. Память: ОЗУ 256 ГБ
4. Накопитель: SAMSUNG SM863 1,9 ТБ Enterprise SSD
5. Файловая система: ext4/xfs
* ОС: Ubuntu 16.04.4, ядро 4.13.0-36-generic
* PostgreSQL: версия 11
### Настройки ядра Linux
Я использовал параметры ядра по умолчанию без какой-либо оптимизации/настройки, только отключил Transparent HugePages. Эта технология включена по умолчанию и выделяет страницы такого размера, который не рекомендуется использовать для баз данных. В общем случае базам данных нужны HugePages фиксированного размера, но Transparent HugePages не могут их предоставить. Поэтому всегда рекомендуется отключать эту функцию и по умолчанию устанавливать классические HugePages.
### Настройки PostgreSQL
Я использовал одинаковые настройки PostgreSQL для всех тестов, чтобы записывать различные рабочие нагрузки PostgreSQL с различными настройками Linux HugePages. Для всех тестов применялись следующие настройки PostgreSQL:
```
shared_buffers = '64GB'
work_mem = '1GB'
random_page_cost = '1'
maintenance_work_mem = '2GB'
synchronous_commit = 'on'
seq_page_cost = '1'
max_wal_size = '100GB'
checkpoint_timeout = '10min'
synchronous_commit = 'on'
checkpoint_completion_target = '0.9'
autovacuum_vacuum_scale_factor = '0.4'
effective_cache_size = '200GB'
min_wal_size = '1GB'
wal_compression = 'ON'
```
### Схема тестирования
Схема тестирования играет важную роль. Все тесты выполняются три раза, продолжительность каждого запуска — 30 минут. По итогам этих 3-х тестов я вывел среднее значение. Тестирование проводились с помощью инструмента PostgreSQL [pgbench](https://www.postgresql.org/docs/current/pgbench.html), он работает с коэффициентом масштабирования с шагом в примерно 16 МБ нагрузки.
### HugePages
По умолчанию в Linux используются страницы памяти размером 4K, а также технология HugePages. В BSD применяется технология Super Pages, а в Windows — Large Pages. PostgreSQL поддерживает только технологию HugePages (Linux). В случаях, когда объем используемой памяти велик, страницы меньшего размера снижают производительность. Используя HugePages, вы увеличиваете выделенную память для приложения и, следовательно, уменьшаете «накладные расходы», которые возникают в процессе выделения/подкачки. Таким образом, HugePages повышают производительность.
Здесь представлены настройки для HugePages размером 1 ГБ. Эта информация доступна в любой момент, с помощью /proc.
```
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 100
HugePages_Free: 97
HugePages_Rsvd: 63
HugePages_Surp: 0
Hugepagesize: 1048576 kB
```
Подробнее о HugePages я писал в предыдущем посте.
<https://www.percona.com/blog/2018/08/29/tune-linux-kernel-parameters-for-postgresql-optimization/>
В общем случае HugePages имеют размеры 2 МБ и 1 ГБ, поэтому имеет смысл использовать 1 ГБ.
<https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/performance_tuning_guide/s-memory-transhuge>
<https://kerneltalks.com/services/what-is-huge-pages-in-linux/>
### Результаты тестирования
Этот тест показывает общий эффект от использования HugePages различного размера. Первый набор тестов был создан с размером страницы 4K — используется в Linux по умолчанию — и без активации HugePages. Напомню: опцию Transparent HugePages я отключил на все время тестов.
Затем второй набор тестов был выполнен для HugePages размером 2 МБ. Наконец, третий набор тестов выполнялся для HugePages размером 1 ГБ.
Для всех сравнительных тестов использовалась СУБД PostgreSQL версии 11. Наборы включают комбинации различных размеров баз данных и различных клиентов. На графике ниже показаны результаты сравнения производительности с помощью этих тестов: TPS (число транзакций в секунду) — по оси Y, а размер базы данных и количество клиентов для базы данных определенного размера — по оси X.
[](https://habrastorage.org/webt/1k/pu/1r/1kpu1rufj-fpl3iszxtzvnjxfgg.png)
Из приведенного выше графика видно, что, от использования HugePages, выигрыш растет по мере того, как увеличивается число клиентов и размер базы данных — до тех пор, пока этот размер остается в рамках предварительно выделенного общего буфера.
В этом тесте сопоставлялись показатели TPS и количество клиентов. В данном случае размер базы данных — 48 ГБ. На оси Y показано TPS, а на оси X — количество подключенных клиентов. Размер базы данных достаточно мал, чтобы она могла поместиться в общий буфер с установленным размером 64 ГБ.
[](https://habrastorage.org/webt/fc/j_/kn/fcj_knw5ujqg-vvyzcxnl2wkclu.png)
Когда размер HugePages равен 1 ГБ, сравнительный выигрыш в производительности растет с увеличением числа клиентов.
Следующий график такой же, как и предыдущий, но размер базы данных — 96 ГБ. Это больше установленного размера общего буфера, равного 64 ГБ.
[](https://habrastorage.org/webt/z8/6r/je/z86rjeljjqfr_nyaylzzpv7xf9q.png)
Главное, что здесь необходимо отметить: производительность с HugePages размером 1 ГБ повышается по мере увеличения числа клиентов и в конечном итоге обеспечивает лучшие показатели, чем при использовании HugePages размером 2 МБ или стандартных страниц размером 4 КБ.
Этот тест показывает соотношение TPS и размера базы данных. В данном случае число подключенных клиентов равно 32. На оси Y показано TPS, а на оси X — размеры базы данных.
[](https://habrastorage.org/webt/z8/6r/je/z86rjeljjqfr_nyaylzzpv7xf9q.png)
Как и ожидалось, когда размер базы данных превышает размер заранее выделенных HugePages, производительность значительно снижается.
### Заключение
Одна из моих основных рекомендаций — отключать Transparent HugePages. Вы получите наибольший прирост производительности, если база данных помещается в общий буфер с включенными HugePages. Определение оптимального размера HugePages проводится методом проб и ошибок, но потенциально такой подход может привести к значительному выигрышу в TPS, когда размер базы данных достаточно велик, но при этом позволяет ей поместиться в общем буфере. | https://habr.com/ru/post/435558/ | null | ru | null |
# Добавляем ORM в проект за четыре шага
Представим, что вашему проекту срочно понадобился ORM, и вы хотите внедрить его как можно быстрее. В этой статье я хочу рассказать, как это можно сделать всего за четыре шага на примере использования open source проекта [Apache Cayenne](https://cayenne.apache.org).
Для начала вкратце опишу механизм работы с данной библиотекой. Схема базы данных и модели описывается в xml файле, который может быть сгенерирован через GUI приложение или через консоль. Затем на основе xml файла генерируются java объекты, которые являются соответствующим отображением таблиц в базе. Последним шагом создается `ServerRuntime` — объект, который инкапсулирует в себе весь стек Apache Cayenne.
Итак, перейдем к примеру. Что необходимо сделать:
* Создать схему базы данных
* Импортировать схему в проект, то есть получить xml файлы с описанием схемы
* Создать объектную модель, то есть сгенерировать java классы
* Проинициализировать `ServerRuntime` для доступа к базе данных из приложения
Что потребуется для начала? Уже существующий maven или gradle проект, Java 1.8+ и база данных. Мой тестовый проект использует maven, java 14 и самую свежую версию Apache Cayenne 4.2.M1. В качестве базы я использую mysql. Вы для своих проектов можете использовать стабильную версию 4.1 и любую из известных реляционных баз на ваш выбор.
Для наглядности я прикреплю ссылку на [пример](https://github.com/aarrsseni/cayenne-note-project).
### Создание схемы
Для примера создадим простейшую схему, состоящую из трех сущностей: марка авто, модель авто, отзыв на модель авто.
```
CREATE SCHEMA IF NOT EXISTS cars_demo; USE cars_demo;
CREATE TABLE car_brand (ID INT NOT NULL AUTO_INCREMENT, NAME VARCHAR(200) NULL, COUNTRY VARCHAR(200) NULL, PRIMARY KEY (ID)) ENGINE=InnoDB;
CREATE TABLE car_model (ID INT NOT NULL AUTO_INCREMENT, NAME VARCHAR(200) NULL, CAR_BRAND_ID INT NULL, PRIMARY KEY (ID)) ENGINE=InnoDB;
CREATE TABLE feedback (CAR_MODEL_ID INT NULL, ID INT NOT NULL AUTO_INCREMENT, FEEDBACK VARCHAR(200) NULL, PRIMARY KEY (ID)) ENGINE=InnoDB;
ALTER TABLE car_model ADD FOREIGN KEY (CAR_BRAND_ID) REFERENCES car_brand (ID) ON DELETE CASCADE;
ALTER TABLE feedback ADD FOREIGN KEY (CAR_MODEL_ID) REFERENCES car_model (ID) ON DELETE CASCADE;
```
Первый шаг пройден, двигаемся ко второму.
### Импорт схемы
Здесь уже начинается непосредственное использование библиотеки. Для начала подключим необходимый плагин к проекту:
```
org.apache.cayenne.plugins
cayenne-maven-plugin
${cayenne.version}
com.mysql.jdbc.Driver
jdbc:mysql://127.0.0.1:3306/cars\_demo
root
root
${project.basedir}/src/main/resources/cayenne/cayenne-project.xml
${project.basedir}/src/main/resources/cayenne/datamap.map.xml
cayenne.note.project.model
cars\_demo
mysql
mysql-connector-java
${mysql.version}
```
* (1) DataSource, для подключения к базе
* (2) Путь, где будет лежать сгенерированный xml, который необходим для запуска Cayenne
* (3) Путь, где будет лежать xml с описанием модели и базы
* (4) Базовый пакет, где позже будут находиться сгенерированные классы
* (5) Зависимость от mysql-connector для работы с mysql
Далее в консоли запускаем импорт модели:
```
mvn cayenne:cdbimport
```
После выполнения этой команды должны появится два файла, указанные в (2) и (3). Как я уже говорил, файл cayenne-project.xml является служебным файлом, необходимым для работы библиотеки. Файл datamap.map.xml — это описание модели базы данных и ее объектного отображения, а также всех связей.
Пару слов о процессе `cdbimport`: по умолчанию он импортирует всю схему, включая все связи. Данная команда может быть кастомизирована. Вы можете указать, какие сущности стоит включить в импорт, какие исключить, есть возможность указать паттерн для импорта таблиц. Более подробно с этим можно ознакомиться в [документации](https://cayenne.apache.org/docs/4.1/cayenne-guide/#re-introduction).
### Генерация классов
В предыдущем пункте мы сгенерировали описание модели, теперь же нам необходимо сгенерировать java классы, которые можно будет использовать в проекте. Сделать это очень просто, достаточно просто запустить в консоли команду:
```
mvn cayenne:cgen
```
После успешной генерации в пакете, который был указан в настройке плагина, будет находиться набор сгенерированных сущностей. Стоит обратить внимание, что сгенерировалось два набора классов. Первый находится в пакете `auto` и является служебным. Не стоит модифицировать эти классы, так как все изменения исчезнут при следующей генерации. Для пользовательских изменений существуют классы без нижнего подчеркивания, которые наследуются от классов из пакета `auto`. Именно они предназначаются для прямого использования и кастомизации.
### Пример использования
Мы на финишной прямой, осталось только привести пример использования Apache Cayenne.
Создадим `ServerRuntime` — это основной стэк Cayenne, который создается один раз для всего проекта.
Из рантайма всегда можно получить `ObjectContext` — объект, который используется для работы с базой данных.
```
ServerRuntime cayenneRuntime = ServerRuntime.builder()
.dataSource(DataSourceBuilder
.url("jdbc:mysql://127.0.0.1:3306/cars_demo")
.driver("com.mysql.cj.jdbc.Driver")
.userName("root") // Need to change to your username
.password("root") // Need to change to your password
.build())
.addConfig("cayenne/cayenne-project.xml")
.build();
ObjectContext context = cayenneRuntime.newContext();
```
Создадим несколько сущностей и отправим их в базу:
```
CarBrand carBrand = context.newObject(CarBrand.class);
carBrand.setName("BMW");
carBrand.setCountry("Germany");
CarModel carModel = context.newObject(CarModel.class);
carModel.setName("i3");
carModel.setCarBrand(carBrand);
Feedback feedback = context.newObject(Feedback.class);
feedback.setFeedback("Like");
feedback.setCarModel(carModel);
context.commitChanges();
```
Как видно, мы создаем объекты при помощи `ObjectContext`, затем модифицируем их и фиксируем изменения при помощи `context.commitChanges()`.
Для выборки сущностей можно использовать API на любой вкус от чистого sql и ejbql до хорошо читаемого API. Полное описание можно найти в [документации](https://cayenne.apache.org/docs/4.1/cayenne-guide/#queries).
Небольшой пример обычного селекта из базы с использованием Apache Cayenne:
```
List carBrans = ObjectSelect.query(CarBrand.class).select(context);
```
На этом у меня все. Как видно из этого примера, за несколько шагов можно получить боевой ORM, который полностью готов к работе. Надеюсь статья оказалась полезной. С полным примером можно ознакомиться [здесь](https://github.com/aarrsseni/cayenne-note-project). | https://habr.com/ru/post/519470/ | null | ru | null |
# Создаём королевскую форму для приёма банковских карт
В этой статье я дам рекомендации по созданию платёжных форм, которые будут выгодно отличаться от форм ваших конкурентов. Каждый пункт рекомендаций будет сопровождаться примером кода. Полный пример кода, включающий адаптивную вёрстку, реализацию валидационных тултипов, и прочих мелочей опущенных для краткости в самой статье вы можете [посмотреть здесь](http://jsfiddle.net/iserdmi/9sj53x01/).
В рамках этой статьи мы не рассматриваем привязку формы к какому-то конкретному мерчант, мы лишь делаем её более отзывчивой.
Для создания формы мы будем использовать следующие инструменты:
1. Нативный JS
2. BinKing — вспомогательный сервис для создания платёжных форм: <https://github.com/sdandteam/binking>
3. IMask — инструмент для создания масок полей ввода: <https://imask.js.org/>
4. Tippy — инструмент для создания тултипов: <https://atomiks.github.io/tippyjs/>
Определение логотипа банка
--------------------------
Вы наверное замечали, что существуют такие формы для приёма банковских карт, в которых, по мере ввода номера карты, появляется логотип банка, которому принадлежит банковская карта?
Такое поведение помогает реализовать JS плагин BinKing:
```
function initBinking () {
binking.setDefaultOptions({
strategy: 'api',
apiKey: 'cbc67c2bdcead308498918a694bb8d77' // Replace it with your API key
})
}
function cardNumberChangeHandler () {
binking($cardNumberField.value, function (result) {
// …
if (result.formBankLogoBigSvg) {
$bankLogo.src = result.formBankLogoBigSvg
$bankLogo.classList.remove('binking__hide')
} else {
$bankLogo.classList.add('binking__hide')
}
// …
})
}
```
Определение цветов банка
------------------------
Для красоты картины предлагаю вам также перекрашивать саму форму в цвета банка. Разумеется важно также не забыть и перекрасить цвет текста. Здесь нам опять же поможет BinKing.
```
function cardNumberChangeHandler () {
binking($cardNumberField.value, function (result) {
// …
$frontPanel.style.background = result.formBackgroundColor
$frontPanel.style.color = result.formTextColor
// …
})
}
```
Определение логотипа платёжной системы
--------------------------------------
Традиционно формы оплаты отображают логотип платёжной системы выпустившей карту. Для этого опять же используем функционал BinKing. BinKing, в отличие от других плагинов для определения платёжной системы, предоставляет и сами логотипы.
```
function cardNumberChangeHandler () {
binking($cardNumberField.value, function (result) {
// …
if (result.formBrandLogoSvg) {
$brandLogo.src = result.formBrandLogoSvg
$brandLogo.classList.remove('binking__hide')
} else {
$brandLogo.classList.add('binking__hide')
}
// …
})
}
```
Определение банка привязанных карт
----------------------------------
При вводе данных новой карты, записывайте себе в базу данных кроме токена карты ещё и `alias` банка в системе BinKing. Тогда при выводе привязанных карт вы сможете вывести кроме последних 4 цифр и логотипа платёжной системы ещё и логотип банка, что сильно упростит жизнь пользователю. Причём BinKing выдаёт как полноразмерные логотипы банков, так и эмблемы банков отдельно.
```
function showSavedCards () {
if (savedCards.length) {
var banksAliases = savedCards.map(function (card) {
return card.bankAlias
})
binking.getBanks(banksAliases, function (result) {
savedCardsBanks = result
var savedCardsListHtml = savedCards.reduce(function (acc, card, i) {
if (result[i]) {
return acc += '' +
'' +
' + ')' +
'...' + card.last4 + '' +
'' + card.expMonth + '/' + card.expYear + '' +
''
}
return acc += '' +
' + ')' +
'... ' + card.last4 + '' +
'' + card.expMonth + '/' + card.expYear + '' +
''
}, '') // вывод карты, для которой не был найден банк
$сardsList.innerHTML = savedCardsListHtml + $сardsList.innerHTML
})
}
}
```
Автоматический фокус первого поля
---------------------------------
Удобно, когда курсор уже установлен в первое поле, то есть в поле для ввода банковской карты. Это легко, достаточно пары строк кода:
```
var $cardNumberField = document.querySelector('.binking__number-field')
$cardNumberField.focus()
```
Автоматически перевод курсора
-----------------------------
Пользователю удобно, когда курсор автоматически перемещается между полями по мере ввода данных. Самая большая хитрость состоит в том, чтобы своевременно перевести курсор из поля для ввода карты. Беда в том, что не все номера карт состоят из 16 цифр. Переводить курсор следует тогда и только тогда, когда введено символов не меньше минимальной длины карты, и когда в номере карты нету ошибок согласно алгоритму Луна (алгоритм позволяющий определить содержатся ли в номере карты опечатки).
```
function cardNumberChangeHandler () {
binking($cardNumberField.value, function (result) {
// …
var validationResult = validate()
var isFulfilled = result.cardNumberNormalized.length >= result.cardNumberMinLength
var isChanged = prevNumberValue !== $cardNumberField.value
if (isChanged && isFulfilled) {
if (validationResult.errors.cardNumber) {
cardNumberTouched = true
validate()
} else {
$monthField.focus()
}
}
prevNumberValue = $cardNumberField.value
})
}
function monthChangeHandler () {
var validationResult = validate()
if (prevMonthValue !== $monthField.value && $monthField.value.length >= 2) {
if (validationResult.errors.month) {
monthTouched = true
validate()
} else {
$yearField.focus()
}
}
prevMonthValue = $monthField.value
}
function yearChangeHandler () {
var validationResult = validate()
if (prevYearValue !== $yearField.value && $yearField.value.length >= 2) {
if (validationResult.errors.year) {
yearTouched = true
validate()
} else {
$codeField.focus()
}
}
prevYearValue = $yearField.value
}
```
Валидация полей формы
---------------------
Для валидация полей формы мы используем метод validate от BinKing. Валидатор позаботится о том, чтобы в номере карты не было опечаток, чтобы дата срока истечения карты была в будущем, а не в прошлом, проверит заполненность полей и прочее: <https://github.com/union-1/binking#%D0%B2%D0%B0%D0%BB%D0%B8%D0%B4%D0%B0%D1%86%D0%B8%D1%8F>
```
function validate () {
var validationResult = binking.validate($cardNumberField.value, $monthField.value, $yearField.value, $codeField.value)
if (validationResult.errors.cardNumber && cardNumberTouched) {
cardNumberTip.setContent(validationResult.errors.cardNumber.message)
cardNumberTip.show()
} else {
cardNumberTip.hide()
}
var monthHasError = validationResult.errors.month && monthTouched
if (monthHasError) {
monthTip.setContent(validationResult.errors.month.message)
monthTip.show()
} else {
monthTip.hide()
}
if (!monthHasError && validationResult.errors.year && yearTouched) {
yearTip.setContent(validationResult.errors.year.message)
yearTip.show()
} else {
yearTip.hide()
}
if (validationResult.errors.code && codeTouched) {
codeTip.setContent(validationResult.errors.code.message)
codeTip.show()
} else {
codeTip.hide()
}
return validationResult
}
```
Маски полей формы
-----------------
Давайте сделаем так, чтобы в наши поля можно было вводить только цифры, номер карты аккуратно разделялся пробелами, а в поле месяца нельзя было ввести число большее 12.
```
function initMasks () {
cardNumberMask = IMask($cardNumberField, {
mask: binking.defaultResult.cardNumberMask
})
monthMask = IMask($monthField, {
mask: IMask.MaskedRange,
from: 1,
to: 12,
maxLength: 2,
autofix: true
})
yearMask = IMask($yearField, {
mask: '00'
})
codeMask = IMask($codeField, {
mask: '0000'
})
}
```
Показ телефона банка в случае отклонения платежа
------------------------------------------------
Если платёж отклоняется банком, то есть ошибка перевода не наш вашей стороне, то с целью снижения нагрузки на ваш отдел поддержки, покажите пользователю понятно сообщение, указав название банка и номер телефона банка. Всё это опять же можно сделать благодаря BinKing.
```
function cardNumberChangeHandler () {
binking($cardNumberField.value, function (result) {
newCardInfo = result
// …
})
}
function formSubmitHandler (e) {
// …
var bankInfo = selectedCardIndex !== null ? savedCardsBanks[selectedCardIndex] : newCardInfo || null
$error.innerHTML = bankInfo && bankInfo.bankPhone
? 'Ваш банк отклонил операцию по указанной карте. Позвоните в ' + bankInfo.bankLocalName + ' по номеру ' + bankInfo.bankPhone + ', чтобы устранить причину.'
: 'Ваш банк отклонил операцию по указанной карте.'
// …
```
Логотипы вызывающие доверие
---------------------------
Принято размещать рядом с формой логотипы вызывающие доверия. Чтобы вам самостоятельно не пришлось их искать, вот вам эти логотипы в формате svg.
```
```
Правильная раскладка клавиатуры
-------------------------------
На мобильных телефонах возможно указать то, какой будет отображаемая клавиатура при фокусе на том или ином поле. Давайте сделаем так, чтобы выпадала клавиатура для ввода чисел. Для этого необходимо указать атрибуты `inputmode="numeric" pattern="[0-9]*"`
Распознавание полей для ввода карты
-----------------------------------
У некоторых пользователей сохранены данные платёжных карт в браузере. Чтобы в вашей форме работало автоматическое распознавание полей необходимо указать правильные атрибуты `name` и `autocomplete`
```
![]()
![]()
Действует до
Код
на обратной
стороне
``` | https://habr.com/ru/post/527796/ | null | ru | null |
# Дорога в ад JavaScript-зависимостей
Каждый JavaScript-проект начинается с благих намерений, заключающихся в том, что его создатели обещают себе не использовать слишком много NPM-пакетов в ходе его разработки. Но даже если разработчики прилагают немалые усилия к тому, чтобы сдержать это обещание, NPM-пакеты постепенно проникают в их проекты. Размер файла `package.json` со временем растёт. А с `package-lock.json` после установки зависимостей происходит настоящий ужас, выражающийся в добавлениях и удалениях пакетов, особенно заметных при очередном PR…
[](https://habr.com/ru/company/ruvds/blog/499668/)
«Всё нормально», — говорит тимлид. Остальные члены команды согласно кивают. А что ещё делать-то? Нам всем хорошо от того, что экосистема JavaScript жива и здорова. Нам не надо каждый раз изобретать колесо и пытаться решать задачи, уже решённые сообществом опенсорса.
Предположим, вы собираетесь сделать блог и хотите воспользоваться Gatsby.js. Попытайтесь добавить этот генератор сайтов в зависимости своего проекта. А теперь — принимайте поздравления. Только что в вашем проекте оказалось 19000 дополнительных зависимостей. Это нормально? Насколько сложным может стать дерево JavaScript-зависимостей? Как дерево зависимостей превращается в ад? Давайте с этим разберёмся.
Что такое JavaScript-пакет?
---------------------------
В NPM (Node Package Manager, менеджер пакетов Node) хранится самый большой реестр пакетов в мире. Это — JavaScript-пакеты. NPM больше, чем RubyGems, PyPi и Maven вместе взятые. Этот вывод можно сделать на основе анализа данных проекта [Module Counts](http://www.modulecounts.com), на котором отслеживается количество пакетов в популярных реестрах.
*Данные о количестве пакетов в популярных реестрах*
Можно, подумать, что на этом графике представлены очень большие объёмы кода. Так оно и есть. Для того чтобы превратить некий проект в NPM-пакет, у этого пакета должен быть файл `package.json`. Такой пакет можно отправить в реестр NPM.
Что такое package.json?
-----------------------
Вот какие задачи решает `package.json`:
* В нём перечислены пакеты, от которых зависит ваш проект (это — список зависимостей проекта).
* В нём, с использованием правил семантического версионирования, задаются версии пакетов-зависимостей, которыми может пользоваться ваш проект.
* Он позволяет воспроизвести среду, необходимую для работы пакета, и, в результате, упрощает передачу проекта другим разработчикам.
Файл `package.json` можно представить себе как файл `README`, накачанный стероидами. Здесь можно описать зависимости своего пакета, тут можно писать скрипты, выполняющиеся при сборке и тестировании проекта. В этом же файле находятся сведения о версии проекта, задаваемые его разработчиком, и описание проекта. Нас особенно интересует возможность `package.json` по указанию зависимостей проекта.
Пожалуй, то, что в этом файле указывают зависимости проекта, выглядит несколько настораживающе. Представьте, что имеется пакет, зависящий от другого пакета, а этот другой пакет зависит от ещё одного пакета. Такая цепочка зависимостей может быть сколько угодно длинной. Именно по этой причине установка единственного пакета, Gatsby.js, означает оснащение проекта 19000 дополнительных зависимостей.
Типы зависимостей в package.json
--------------------------------
Для того чтобы лучше понять то, как со временем разрастаются списки зависимостей проектов, поговорим о разных типах зависимостей, которые может иметь проект. А именно, в `package.json` можно встретить следующие разделы, описывающие различные зависимости:
* `dependencies` — это обычные зависимости, функционал которых используется в проекте, и к которым обращаются из его кода.
* `devDependencies` — это зависимости разработки. Например — библиотека [prettier](https://prettier.io/), используемая для форматирования кода.
* `peerDependencies` — если зависимости записываются в этот раздел, разработчик пакета тем самым сообщает тому, кто будет его устанавливать, о том, что ему понадобится конкретная версия указанного в этом разделе пакета.
* `optionalDependencies` — тут перечисляют необязательные зависимости, такие, невозможность установки которых не нарушит процесс установки пакета.
* `bundledDependencies` — тут даётся перечень зависимостей, которые встроены в пакет. Встраивание применяется для сторонних библиотек, которых нет в NPM, или в тех случаях, когда разработчик хочет включить в проект некоторые другие свои проекты в виде модулей.
Цель существования файла package-lock.json
------------------------------------------
Все мы знаем о том, что файл `package-lock.json`, в ходе работы над проектом, постоянно претерпевает изменения. Что-то из него удаляется, что-то в него добавляется. Особенно это заметно при просмотре PR, содержащих обновлённую версию этого файла. Мы часто принимаем это как данность. Файл `package-lock.json` автоматически генерируется каждый раз, когда меняется файл `package.json` или папка `node_modules`. Это позволяет поддерживать содержимое дерева зависимостей в точности таким, каким оно было при установке зависимостей проекта. Это позволяет, при установке проекта, воспроизвести дерево зависимостей. Это решает проблему наличия разных версий одного и того же пакета у разных разработчиков.
Рассмотрим проект, в составе зависимостей которого есть React. Соответствующая запись имеется в `package.json`. Если взглянуть в файл `package-lock.json` этого проекта, то там можно увидеть примерно следующее:
```
"react": {
"version": "16.13.0",
"resolved": "https://registry.npmjs.org/react/-/react-16.13.0.tgz",
"integrity": "sha512-TSavZz2iSLkq5/oiE7gnFzmURKZMltmi193rm5HEoUDAXpzT9Kzw6oNZnGoai/4+fUnm7FqS5dwgUL34TujcWQ==",
"requires": {
"loose-envify": "^1.1.0",
"object-assign": "^4.1.1",
"prop-types": "^15.6.2"
}
}
```
Файл `package-lock.json` — это большой список зависимостей проекта. Здесь перечислены версии зависимостей, пути (URI) к модулям, хеши, используемые для проверки целостности модуля и пакетов, нужных этому модулю. Если почитать этот файл, там можно найти записи обо всех пакетах, которые нужны React. Именно здесь и находится настоящий ад зависимостей. Здесь описано всё, в чём нуждается проект.
Разбираемся с зависимостями Gatsby.js
-------------------------------------
Как же получается так, что, установив всего одну зависимость, мы добавляем в проект целых 19000 зависимостей? Всё дело в зависимостях зависимостей. Именно поэтому у нас есть то, что есть:
```
$ npm install --save gatsby
...
+ gatsby@2.19.28
added 1 package from 1 contributor, removed 9 packages, updated 10 packages and audited 19001 packages in 40.382s
```
Если взглянуть в `package.json`, там можно найти лишь одну зависимость. Но если посмотреть на `package-lock.json`, то окажется, что перед нами — почти 14-килобайтный монстр. Более подробный ответ о том, что значат все те строки кода, которые попадают в `package-lock.json`, можно найти в файле `package.json` в [репозитории Gatsby.js](https://github.com/gatsbyjs/gatsby/blob/master/package.json). Тут имеется очень много прямых зависимостей, а именно, [по подсчётам npm](https://www.npmjs.com/package/gatsby), 132. Если у каждой из этих зависимостей будет хотя бы ещё одна зависимость, то общее количество зависимостей проекта удвоится — и у него окажется 264 зависимости. Конечно, в реальном мире всё не так. У каждой прямой зависимости проекта есть больше, чем 1 собственная зависимость. В результате список зависимостей проекта оказывается очень длинным.
Например — поинтересуемся тем, сколько раз в качестве зависимости для других пакетов используется библиотека [lodash](https://lodash.com/):
```
$ npm ls lodash
example-js-package@1.0.0
└─┬ gatsby@2.19.28
├─┬ @babel/core@7.8.6
│ ├─┬ @babel/generator@7.8.6
│ │ └── lodash@4.17.15 deduped
│ ├─┬ @babel/types@7.8.6
│ │ └── lodash@4.17.15 deduped
│ └── lodash@4.17.15 deduped
├─┬ @babel/traverse@7.8.6
│ └── lodash@4.17.15 deduped
├─┬ @typescript-eslint/parser@2.22.0
│ └─┬ @typescript-eslint/typescript-estree@2.22.0
│ └── lodash@4.17.15 deduped
├─┬ babel-preset-gatsby@0.2.29
│ └─┬ @babel/preset-env@7.8.6
│ ├─┬ @babel/plugin-transform-block-scoping@7.8.3
│ │ └── lodash@4.17.15 deduped
│ ├─┬ @babel/plugin-transform-classes@7.8.6
│ │ └─┬ @babel/helper-define-map@7.8.3
│ │ └── lodash@4.17.15 deduped
│ ├─┬ @babel/plugin-transform-modules-amd@7.8.3
│ │ └─┬ @babel/helper-module-transforms@7.8.6
│ │ └── lodash@4.17.15 deduped
│ └─┬ @babel/plugin-transform-sticky-regex@7.8.3
│ └─┬ @babel/helper-regex@7.8.3
│ └── lodash@4.17.15 deduped
...
```
К нашему счастью, большинство этих зависимостей представлены одной и той же версией lodash. А при таком подходе в `node_modules` будет лишь одна папка библиотеки lodash. Правда, обычно всё не совсем так. Иногда разным пакетам нужны разные версии одного и того же пакета. Именно поэтому и появилось много шуток об огромных размерах папки `node_modules`. В нашем случае, правда, всё не так уж и плохо:
```
$ du -sh node_modules
200M node_modules
```
200 мегабайт — это не так уж и плохо. Я видел, как размер этой папки легко доходит до 700 Мб. Если вам интересно узнать о том, какие модули занимают больше всего места — можете выполнить следующую команду:
```
$ du -sh ./node_modules/* | sort -nr | grep '\dM.*'
17M ./node_modules/rxjs
8.4M ./node_modules/@types
7.4M ./node_modules/core-js
6.8M ./node_modules/@babel
5.4M ./node_modules/gatsby
5.2M ./node_modules/eslint
4.8M ./node_modules/lodash
3.6M ./node_modules/graphql-compose
3.6M ./node_modules/@typescript-eslint
3.5M ./node_modules/webpack
3.4M ./node_modules/moment
3.3M ./node_modules/webpack-dev-server
3.2M ./node_modules/caniuse-lite
3.1M ./node_modules/graphql
...
```
Да, [rxjs](https://github.com/ReactiveX/rxjs) — коварный пакет.
Вот простая команда, которая помогает уменьшить размер папки `node_modules` и упростить её структуру:
```
$ npm dedup
moved 1 package and audited 18701 packages in 4.622s
51 packages are looking for funding
run `npm fund` for details
found 0 vulnerabilities
```
В ходе [дедупликации](https://docs.npmjs.com/cli/dedupe) npm пытается упростить структуру дерева зависимостей, находя зависимости, используемые другими зависимостями, и перемещая их так, чтобы организовать их совместное использование. Это относится к нашему примеру с lodash. Множество пакетов используют `lodash @4.17.15`, в результате для обеспечения их работоспособности достаточно установить эту версию библиотеки лишь один раз. Конечно, это — та ситуация, в которую мы попадаем с самого начала, только установив зависимости. Если в процессе работы над проектом в `package.json` добавляют новые зависимости, рекомендуется иногда вспоминать о команде `npm dedup`. Если вы используете менеджер пакетов yarn, там аналогичная команда выглядит как [yarn dedupe](https://classic.yarnpkg.com/en/docs/cli/dedupe/). Но в ней, на самом деле, необходимости нет, так как оптимизация зависимостей выполняется автоматически, при выполнении команды `yarn install`.
Визуализация зависимостей
-------------------------
Интересовались графическим представлением зависимостей своего проекта? Если так — сформировать такое представление можно с помощью специальных инструментов. Рассмотрим некоторые из них.
Ниже показан результат визуализации зависимостей, полученный с помощью [npm.anvaka.com/](https://npm.anvaka.com/).
*Визуализация зависимостей, выполняемая с помощью npm.anvaka.com*
Тут можно видеть взаимосвязи пакетов-зависимостей проекта Gatsby.js. Результат получается похожим на огромную паутину. У проекта Gatsby.js так много зависимостей, что эта «паутина» чуть не «подвесила» мой браузер. [Вот](https://npm.anvaka.com/#/view/2d/gatsby), если интересно, ссылка на эту схему. Она может быть представлена и в 3D-виде.
Вот визуализация, сделанная с помощью [npm.broofa.com](http://npm.broofa.com).
*Фрагмент визуализации зависимостей, выполненной с помощью npm.broofa.com*
Это похоже на блок-схему. Она, для Gatsby.js, получается очень сложной. Взглянуть на неё можно [здесь](http://npm.broofa.com/?q=gatsby). Элементы схемы можно раскрасить, основываясь на оценках с [npms.io](https://github.com/npms-io/npms-analyzer). На сайт можно загрузить собственный файл `package.json`.
Средство [Package Phobia](https://github.com/styfle/packagephobia) позволяет, до установки пакета, узнать о том, сколько места ему требуется.
*Сведения о пакете, полученные с помощью Package Phobia*
Здесь можно узнать о размере опубликованного пакета, и о том, какое место на диске он займёт после установки.
Итоги: с большой силой приходит большая ответственность
-------------------------------------------------------
В итоге хочется сказать, что JavaScript и NPM — это замечательные инструменты. Очень хорошо то, что у современных разработчиков есть возможность пользоваться огромным набором зависимостей. Выполнить команду `npm install` для того чтобы избавить себя от написания пары строчек кода — это так легко, что иногда мы забываем о последствиях.
Сейчас, когда вы дочитали до этого места, у вас должно сложиться более полное понимание особенностей устройства деревьев зависимостей npm-проектов. Если вы добавляете в проект библиотеку, которая очень велика, или если вы просто исследуете зависимости своего проекта, вы всегда можете воспользоваться тем, что мы тут обсудили, и проанализировать зависимости.
**Уважаемые читатели!** Стремитесь ли вы к тому, чтобы пользоваться как можно меньшим количеством зависимостей в своих npm-проектах?
[](https://ruvds.com/ru-rub/?utm_source=habr&utm_medium=perevod&utm_campaign=dorogavad#order) | https://habr.com/ru/post/499668/ | null | ru | null |
# Jii: Active Record для Node.js с API от Yii 2
Вступление
==========
Привет всем хабровчанам, любителям Yii и Node.js.
Это вторая статья про фреймворк [Jii](http://www.jiiframework.ru/) ([GitHub](https://github.com/jiisoft)), в [предыдущей статье](http://habrahabr.ru/post/260295/) мы рассматривали Объекты доступа к данным и конструктор запросов (Query Builder).
Как и обещал, в этой статье я расскажу про использовании Active Record.
Active Record
=============
[Active Record](http://en.wikipedia.org/wiki/Active_record_pattern) обеспечивает объектно-ориентированный интерфейс для доступа и манипуляции данными, хранящихся в базах данных. Класс Active Record связан с таблицей базы данных, экземпляр класса соответствует строке этой таблицы, а атрибуты представляют собой значения определенного столбца в этой строке. Вместо того чтобы писать SQL запросы в явном виде, Вы имеете доступ к атрибутам Active Record и методам, манипулирующие данными.
Предположим, что у нас есть Active Record класс `app.models.Customer`, который связан с таблице `customer` и `name` это имя колонки в таблице `customer`. Вы можете написать следующий код для добавления новой строки в таблицу `customer`:
```
var customer = new app.models.Customer();
customer.name = 'Vladimir';
customer.save();
```
Это эквивалентно следующему коду, в котором Вы можете допустить больше ошибок при написании и где могут быть несовместимости при различных видах данных:
```
db.createCommand('INSERT INTO `customer` (`name`) VALUES (:name)', {
':name': 'Vladimir',
}).execute();
```
Объявление классов Active Record
--------------------------------
Для начала, объявите класс Active Record, унаследовав *Jii.sql.ActiveRecord*. Каждый Active Record класс связан с таблицей базы данных, поэтому в этом классе необходимо переопределить статический метод *Jii.sql.ActiveRecord.tableName()* для указания с какой таблицей связан класс.
В следующем примере, мы объявляем класс с именем `app.models.Customer` для таблицы `customer`.
```
var Jii = require('jii');
/**
* @class app.models.Customer
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{
__extends: Jii.sql.ActiveRecord,
__static: /** @lends app.models.Customer */{
tableName: function() {
return 'customer';
}
}
});
```
Класс Active Record является моделью, поэтому обычно мы кладем Active Record классы в пространство имен `models`.
Класс *Jii.sql.ActiveRecord* наследует *Jii.base.Model*, это значит, что он наследует \*все\* возможности моделей, такие как аттрибуты, правила валидации, серелиализация данных и т.д.
Создание соединения с БД
------------------------
По-умолчанию, Active Record использует [компонент приложения](http://www.jiiframework.ru/guide/structure-application-components) `db`, который содержит экземпляр *Jii.sql.BaseConnection* для чтения и изменения данных в БД. Как описано в предыдущей [статье](http://habrahabr.ru/post/260295/), в разделе «Объекты доступа к базе данных», вы можете сконфигурировать компонент приложения `db` следующим образом:
```
return {
components: {
db: {
className: 'Jii.sql.mysql.Connection',
host: '127.0.0.1',
database: 'testdb',
username: 'demo',
password: 'demo',
charset: 'utf8',
}
}
};
```
Если вы хотите использовать другое соединение с базой данных, вы должны переопределить метод *Jii.sql.ActiveRecord.getDb()*:
```
/**
* @class app.models.Customer
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{
__extends: Jii.sql.ActiveRecord,
__static: /** @lends app.models.Customer */{
STATUS_INACTIVE: 0,
STATUS_ACTIVE: 1,
// ...
getDb: function() {
// use the "db2" application component
return Jii.app.db2;
}
}
});
```
Выборка данных
--------------
После объявления класса Active Record, вы можете использовать его для запроса данных из соответствующей таблицы БД.
Для этого необходимо выполнить три действия:
1. Создать новый объект запроса путем вызова метода *Jii.sql.ActiveRecord.find()*;
2. Сгенерировать объект запроса, вызывая методы создания запросов;
3. Вызвать один из методов запроса для получения данных в виде записей Active Record.
Эти действия очень схожи с действиями при работе с конструктором запросов. Разница только в том, что для создания объекта запроса необходимо вызвать метод *Jii.sql.ActiveRecord.find()*, а не создавать экземпляр через `new`.
Рассмотрим несколько примеров, показывающие, как использовать Active Query для получения данных:
```
// Возвращает клиента с ID 123
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer.find()
.where({id: 123})
.one()
.then(function(customer) {
// ...
});
// Возвращает всех активных клиентов, отсортированных по ID
// SELECT * FROM `customer` WHERE `status` = 1 ORDER BY `id`
app.models.Customer.find()
.where({status: app.models.Customer.STATUS_ACTIVE})
.orderBy('id')
.all()
.then(function(customers) {
// ...
});
// Возвращает количество активных клиентов
// SELECT COUNT(*) FROM `customer` WHERE `status` = 1
app.models.Customer.find()
.where({status': app.models.Customer.STATUS_ACTIVE})
.count()
.then(function(count) {
// ...
});
// Возвращает всех клиентов в виде объекта, где ключами являются ID клиентов
// SELECT * FROM `customer`
app.models.Customer.find()
.indexBy('id')
.all()
.then(function(customers) {
// ...
});
```
Для упрощения получения моделей по ID созданы методы:
* *Jii.sql.ActiveRecord.findOne()*: Возвращает экземпляр Active Record, соответствующий первой строке результата апроса.
* *Jii.sql.ActiveRecord.findAll()*: Возвращает массив или объект нескольких Active Record, соответствующие строкам результата запроса.
Оба метода принимают первый агрумент следующего формата:
* Скалярное значение: значение рассматривается как значение первичного ключа, по которому идет поиск. Первичный ключ определяется автоматически из схемы БД.
* Массив скалярных значений: массив рассматривается как значения первичного ключа, по которым идет поиск. — Объект, ключами которого являются имена столбцов, а значения соответствуют значениям столбцов, по которым идет поиск.
Следующие примеры показывают как эти методы могут быть использованы:
```
// Возвращает клиента с ID 123
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer
.findOne(123)
.then(function(customer) {
// ...
});
// Возвращает клиентовс ID 100, 101, 123 или 124
// SELECT * FROM `customer` WHERE `id` IN (100, 101, 123, 124)
app.models.Customer
.findAll([100, 101, 123, 124])
.then(function(customers) {
// ...
});
// Возвращает активного клиента с ID 123
// SELECT * FROM `customer` WHERE `id` = 123 AND `status` = 1
app.models.Customer
.findOne({
id: 123,
status: app.models.Customer.STATUS_ACTIVE
})
.then(function(customer) {
// ...
});
// Возвращает всех неактивных клиентов
// SELECT * FROM `customer` WHERE `status` = 0
app.models.Customer
.findAll({
status: app.models.Customer.STATUS_INACTIVE
})
.then(function(customers) {
// ...
});
```
> Примечание: Ни *Jii.sql.ActiveRecord.findOne()*, ни *Jii.sql.ActiveQuery.one()* не добавят `LIMIT 1` в SQL выражение. Если Ваш запрос действительно может вернуть множество данных, то необходимо вызвать `limit(1)` для установки предела, например `app.models.Customer.find().limit(1).one()`.
Вы можете так же использовать обычные SQL запросы для получения данных и заполнениях их в Active Record. Для этого необходимо использовать метод *Jii.sql.ActiveRecord.findBySql()*:
```
// Возвращает всех неактивных клиентов
var sql = 'SELECT * FROM customer WHERE status=:status';
app.models.Customer
.findBySql(sql, {':status': app.models.Customer.STATUS_INACTIVE})
.all()
.then(function(customers) {
// ...
});
```
Не вызывайте методы создания запроса после вызова *Jii.sql.ActiveRecord.findBySql()*, они будут игнорироваться.
Доступ к данным
---------------
Как упоминалось выше, экземпляры Active Record заполняются данными из результатов SQL запроса, и каждая строка результата запроса соответствует одному экземпляру Active Record. Вы можете получить доступ к значениям столбцов через атрибуты Active Record, например,
```
// Имена столбцов "id" и "email" из таблицы "customer"
app.models.Customer
.findOne(123)
.then(function(customer) {
var id = customer.get('id');
var email = customer.get('email');
});
```
### Получение данные в объектах
Получение данные как Active Record удобно, но иногда это может быть неоптимально из-за большого потребления памяти, которое расходуется на создание экземпляров Active Record. В этом случае вы можете получить их как обычные объекты, для этого нужно вызвать метод *Jii.sql.ActiveQuery.asArray()*.
> По факту, в JavaScript вы получите массив, наполненный объектами. Поэтому правильней было бы назвать метод *asObject()*, и такой метод (синоним) есть. Но для сохранения API Yii 2 оставлен метод *asArray()*.
```
// Возвращает всех клиентов, каждый из которых
// представлен как объект
app.models.Customer.find()
.asArray() // alias is asObject()
.all()
.then(function(customers) {
// ...
});
```
Сохранение данных
-----------------
Изпользуя Active Record, Вы можете сохранять данные в БД выполнив следующие шаги:
1. Получите или создайте экземпляр Active Record;
2. Задайте новые значение атрибутам
3. Вызовите метод *Jii.sql.ActiveRecord.save()* для сохранение данных.
Например,
```
// Добавление новой строки в таблицу
var customer = new app.models.Customer();
customer.set('name', 'James');
customer.set('email', 'james@example.com');
customer.save().then(function(success) {
return app.models.Customer.findOne(123);
}).then(function(customer) {
// Обновление данных
customer.set('email', 'james@newexample.com');
return customer.save();
}).then(function(success) {
// ...
});
```
Метод *Jii.sql.ActiveRecord.save()* может либо добавить, либо обновить данные строки, в зависимости от состояния Active Record. Если экземплер был создан с помощью оператора `new`, то метод добавит новую строку. Если экземпляр получен через метод *find()* и ему подобные или уже был вызван метод *save()* ранее, то метод *save()*
обновит данные.
### Валидация данных
Класс *Jii.sql.ActiveRecord* наследуется от *Jii.base.Model*, поэтому в нем доступна валидация данных. Вы можете задать правила вализации через переопределение метода *Jii.sql.ActiveRecord.rules()* и проверить на правильность значений через метод *Jii.sql.ActiveRecord.validate()*.
Когда вы вызываете метод *Jii.sql.ActiveRecord.save()*, по-умолчанию, автоматически будет вызван метод *Jii.sql.ActiveRecord.validate()*. Только проверенные данные должны сохраняться в БД; Если данные не верны, то метод вернет `false` и Вы можете получить ошибку через метод *Jii.sql.ActiveRecord.getErrors()* или ему подобные.
### Изменение множества атрибутов
Как и обычные модели, экземпляр Active Record так же поддерживает изменение атрибутов через передачу объекта. Используя это способ, вы можете присвоить значения нескольких атрибутов Active Record через вызов одного метода. Помните, что только безопасные атрибуты могут быть массово присвоены.
```
var values = {
name: 'James',
email: 'james@example.com'
};
var customer = new app.models.Customer();
customer.setAttributes(values);
customer.save();
```
### Измененные атрибуты
Когда вы вызываете метод *Jii.sql.ActiveRecord.save()*, происходит сохранение только измененных аттрибутов Active Record. Атрибут считается измененным, если было изменено его значение. Обратите внимание, что проверка данных будет выполняться независимо от существования измененных атрибутов.
Active Record автоматически сохраняет список измененных атрибутов. Она сохраняет старые версии атрибутов и сравнивает их с последней версией. Вы можете получить измененные атрибуты через метод *Jii.sql.ActiveRecord.getDirtyAttributes()*.
Для получения старых значений атрибутов, вызывайте метод *Jii.sql.ActiveRecord.getOldAttributes()* или *Jii.sql.ActiveRecord.getOldAttribute()*.
### Значения по-умолчанию
Некоторые из ваших столбцов в таблице могут иметь значения по умолчанию, определенные в базе данных. Вы можете предварительно заполнить Active Record этими значениями, вызвав метод *Jii.sql.ActiveRecord.loadDefaultValues()*. Этот метод синхронный, т.к. схема БД заранее подгружается при открытии соединения.
```
var customer = new app.models.Customer();
customer.loadDefaultValues();
// customer.get('xyz') Значение атрибута `xyz` будет соответсвовать значению по-умолчанию для столбца `xyz`.
```
### Обновление нескольких строк
Описанные выше методы работают с экземплярамм Active Record. Чтобы обновить несколько строк одновременно, вы можете вызвать статический метод *Jii.sql.ActiveRecord.updateAll()*:
```
// UPDATE `customer` SET `status` = 1 WHERE `email` LIKE `%@example.com%`
app.models.Customer.updateAll({status: app.models.Customer.STATUS_ACTIVE}, {'like', 'email', '@example.com'});
```
Удаление данных
---------------
Для удаления строки из таблицы, необходимо у эксемпляра Active Record, соответствующей этой строке, вызвать метод *Jii.sql.ActiveRecord.delete()*.
```
app.models.Customer
.findOne(123)
.then(function(customer) {
customer.delete();
});
```
Вы можете вызвать статический метод *Jii.sql.ActiveRecord.deleteAll()* для удаления множества строк по условию.
Например,
```
app.models.Customer.deleteAll({status: app.models.Customer.STATUS_INACTIVE});
```
Работа с связанными данными
---------------------------
Помимо работы с отдельными таблицами базы данных, Active Record способен связать данные через первичные данные. Например, данные о клиентах могут быть связанны с заказами. При объявлении соответствующей связи в Active Record, Вы можете получить информацию о заказе клиента, используя выражение `customer.load('orders')`, при этом на выходе вы получите массив экземпляров `app.models.Order`.
### Объявление зависимостей
Для работы с реляционными данными при помощи Active Record, сначала нужно объявить отношение в классе Active Record. Например,
```
/**
* @class app.models.Customer
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{
// ...
getOrders: function() {
return this.hasMany(app.models.Order.className(), {customer_id: 'id'});
}
});
/**
* @class app.models.Order
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{
// ...
getCustomer: function() {
return this.hasOne(app.models.Customer.className(), {id: 'customer_id'});
}
});
```
В приведенном выше коде, мы объявили соотношение `orders` для класса `app.models.Customer`, и отношение `customer` для класса `app.models.Order`.
Каждый метод отношение должен быть назван как `getXyz` (get + имя отношения с первой буквой в нижнем регистре). Обратите внимание, что имена отношений являются \*чувствительными к регистру\*.
В отношении, вы должны указать следующую информацию:
* Кратность связи: указывается при вызове методов *Jii.sql.ActiveRecord.hasMany()* или *Jii.sql.ActiveRecord.hasOne()*. В приведенном выше примере у клиента много заказов, а у заказа только один клиент.
* Название связанного класса Active Record: указывается в качестве первого параметра у выше названных методов. Рекомендуется получать имя класса через `Xyz.className()`, чтобы, во-первых, проверить существование класса еще на этапе конструирования отношения, а во-вторых, чтобы IDE подсказывала Вам имя класса при написании.
* Связь между двумя схемами таблиц: определяет столбец (ы), через который связаны два типа данных. Значениями объекта являются столбцы первичных данных, а ключами — столбцы связанных данных.
### Доступ к связанным данным
После объявления отношения, вы можете получить доступ к связанным данным через имя отношеня. Если Вы уверены, что связанные данные уже подгружены в Active Record, то можно получить связанные Active Record аналогично доступу к [свойствам](http://www.jiiframework.ru/guide/concept-properties) объекта через метод *get()*. Иначе, лучше использовать метод *Jii.sql.ActiveRecord.load()* для загрузки связанных данных, который будет всегда возвращать объект `Promise`, но не будет слать лишний запрос в БД, если связь уже была подгружена ранее.
```
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer
.findOne(123)
.then(function(customer) {
// SELECT * FROM `order` WHERE `customer_id` = 123
return customer.load('orders');
})
.then(function(orders) {
// orders - массив экземпляров класса `app.models.Order`
});
```
Если отношение объявлено методом *Jii.sql.ActiveRecord.hasMany()*, то данные отношения будут представлены массивом экземпляров Active Record (или пустым массивом). Если методом *Jii.sql.ActiveRecord.hasOne()*, то данные отношения будут представлены экземпляром Active Record или `null`, если данные отсутствуют.
При доступе к отношению в первый раз, будет выполнен SQL запрос в БД, как показано в примере выше. При повторном обращении, запрос выполняться не будет.
### Отношения через дополнительную таблицу (Junction Table)
При моделировании баз данных, когда связь между двумя таблицами Many-Many, то обычно добавляется дополнительная таблица — [Junction Table](https://en.wikipedia.org/wiki/Junction_table). Например, таблица `order` и таблица `item` могут быть связаны с помощью таблицы `order\_item`.
При объявлении таких отношений, Вам нужно вызвать методы *Jii.sql.ActiveQuery.via()* или *Jii.sql.ActiveQuery.viaTable()* с указанием дополнительный таблицы. Разница между этими методами в том, что первый указывает таблицу перехода с точки зрения текущего имени отношения, в то время как последний непосредственно дополнительную таблицу. Например,
```
/**
* @class app.models.Order
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{
// ...
getItems: function() {
return this.hasMany(app.models.Item.className(), {id: 'item_id'})
.viaTable('order_item', {order_id: 'id'});
}
});
```
или альтернативно,
```
/**
* @class app.models.Order
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{
// ...
getOrderItems: function() {
return this.hasMany(app.models.OrderItem.className(), {order_id: 'id'});
},
getItems: function() {
return this.hasMany(app.models.Item.className(), {id: 'item_id'})
.via('orderItems');
}
});
```
Использование отношений, объявленных с дополнительной таблицей, аналогично обычным отношениям. Например,
```
// SELECT * FROM `order` WHERE `id` = 100
app.models.Order
.findOne(100)
.then(function(order) {
// SELECT * FROM `order_item` WHERE `order_id` = 100
// SELECT * FROM `item` WHERE `item_id` IN (...)
return order.load('items');
})
.then(function(items) {
// items - массив экземпляров `app.models.Item`
});
```
### Ленивая Загрузка и жадная загрузка
В разделе доступа к связанным данным, мы рассказывали, что вы можете получить доступ к отношению из Active Record через методы *get()* или *load()*. SQL запрос будет отправлять в БД только при первом обращении к связанным данным. Такие способы загрузки данных назваются ленивыми (lazy loading).
Например,
```
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer
.findOne(123)
.then(function(customer) {
// SELECT * FROM `order` WHERE `customer_id` = 123
customer.load('orders').then(function(orders) {
// SQL запрос не отправляется
return customer.load('orders');
}).then(function(orders2) {
// После подгрузки связей, они доступны также через метод *get()*.
var orders3 = customer.get('orders');
});
});
```
Ленивый нагрузка очень удобна в использовании. Тем не менее, это может вызывать проблемы с производительностью, когда вам нужно получить доступ к связанным занным для множества экземпляров Active Record. Рассмотрим следующий пример кода, сколько SQL запросов будет выполнено?
```
// SELECT * FROM `customer` LIMIT 100
app.models.Customer.find()
.limit(100)
.all()
.then(function(customers) {
return Promise.all(customers.map(function(customer) {
// SELECT * FROM `order` WHERE `customer_id` = ...
return customer.load('orders');
}));
}).then(function(result) {
var firstOrder = result[0][0];
// ...
});
```
В данном примере выполнится 101 SQL запрос! Потому что для каждого клиента будут получены заявки через отдельный запрос. Чтобы решить эту проблему производительности, можно использовать подход \*жадной загрузки\*, как показано ниже,
```
// SELECT * FROM `customer` LIMIT 100;
// SELECT * FROM `orders` WHERE `customer_id` IN (...)
app.models.Customer.find()
.with('orders')
.limit(100)
.all()
.then(function(customers) {
customers.forEach(function(customer) {
// без SQL запроса
var orders = customer.get('orders');
});
});
```
Вы можете загрузить вместе с основной записью одно или несколько отношений. Вы даже можете загрузить сразу и вложенные отношения. Например, если `app.models.Customer` связан с` app.models.Order` через отношение `orders`, а `app.models.Order` связан с `Item` через `items`. При запросе `app.models.Customer`, вы можете сразу загрузить отношение `items` указав в методе *with()* `orders.items`.
Следующий код показывает различные использование *Jii.sql.ActiveQuery.with()*. Мы предполагаем, что класс `app.models.Customer` имеет два отношения: `orders` и `country`, в то время как класс `app.models.Order` имеет одно соотношение — `items`.
```
// Принудительная загрузка отношений "orders" и "country"
app.models.Customer.find()
.with('orders', 'country')
.all()
.then(function(customers) {
// ...
});
// это эквивалентно записе через массив
app.models.Customer.find()
.with(['orders', 'country'])
.all()
.then(function(customers) {
// без SQL запроса
var orders = customers[0].get('orders');
var country = customers[0].get('country');
});
// Принудительная загрузка отношения "orders" и вложенного отношения "orders.items"
app.models.Customer.find()
.with('orders.items')
.all()
.then(function(customers) {
// Получение пунктов из первого заказа для первого клиента
// без SQL запроса
var items = customers[0].get('orders')[0].get('items');
});
```
Вы можете загрузить принудительно глубоко вложенные отношения, такие как `a.b.c.d`. Все родительские отношения будут принудительно загружены.
При жадной загрузке отношений, вы можете настроить соответствующий запрос, передав анонимную функцию. Например,
```
// Поиск клиентов вместе с их странами а активными заказами
// SELECT * FROM `customer`
// SELECT * FROM `country` WHERE `id` IN (...)
// SELECT * FROM `order` WHERE `customer_id` IN (...) AND `status` = 1
app.models.Customer.find()
.with({
country: 'country',
orders: function (query) {
query.andWhere({'status': app.models.Order.STATUS_ACTIVE});
}
})
.all()
.then(function(customers) {
// ...
});
```
При настройке реляционного запроса для связи, вы должны указать имя отношения в качестве ключа объекта и использовать анонимную функцию как значение соответствующего объекта. Первым агрументом нонимной функции будет параметр `query`, который представляет собой объект *Jii.sql.ActiveQuery*. В примере выше, мы изменяем запроса путем добавления дополнительного условия о статусе заказа.
### Обратные отношения
Отношения между классами Active Record зачастую обратно связаны друг с другом. Например, класс `app.models.Customer` связан с `app.models.Order` через отношение `orders`, а класс `app.models.Order` обратно связан с классом `app.models.Customer` через отношение `customer`.
```
/**
* @class app.models.Customer
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{
// ...
getOrders: function() {
return this.hasMany(app.models.Order.className(), {customer_id: 'id'});
}
});
/**
* @class app.models.Order
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{
// ...
getCustomer: function() {
return this.hasOne(app.models.Customer.className(), {id: 'customer_id'});
}
});
```
Теперь рассмотрим следующий фрагмент кода:
```
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer
.findOne(123)
.then(function(customer) {
// SELECT * FROM `order` WHERE `customer_id` = 123
return customer.load('orders');
}).then(function(orders) {
var order = orders[0];
// SELECT * FROM `customer` WHERE `id` = 123
return order.load('customer');
}).then(function(customer2) {
// Отображает "not the same"
console.log(customer2 === customer ? 'same' : 'not the same');
});
```
Мы предполагаем, что объекты `customer` и `customer2` являются одинаковыми, но на самом деле это не так. Они содержат одинаковые данные на являются разными экземплярами. При доступе к `order.customer` выполняется дополнительный SQL запрос для получения нового объекта `customer2`.
Чтобы избежать избыточного выполнения последнего SQL запроса в приведенном выше примере, мы должны указать, что `customer` является \*обратной зависимостью\* от `orders` с помощью метода *Jii.sql.ActiveQuery.inverseOf()*.
```
/**
* @class app.models.Customer
* @extends Jii.sql.ActiveRecord
*/
Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{
// ...
getOrders: function() {
return this.hasMany(app.models.Order.className(), {customer_id: 'id'}).inverseOf('customer');
}
});
```
После этих изменений мы получим:
```
// SELECT * FROM `customer` WHERE `id` = 123
app.models.Customer
.findOne(123)
.then(function(customer) {
// SELECT * FROM `order` WHERE `customer_id` = 123
return customer.load('orders');
}).then(function(orders) {
var order = orders[0];
// SELECT * FROM `customer` WHERE `id` = 123
return order.load('customer');
}).then(function(customer2) {
// Отображает "same"
console.log(customer2 === customer ? 'same' : 'not the same');
});
```
> Замечание: Обратные отношения не работают для отношений Many-Many, объявленные с дополнительной таблцей (Junction Table).
Сохранение зависимостей
-----------------------
При работе с реляционными данными, часто необходимо добавить отношения между различными данными или удалить существующие отношения. Для этого нужно установить правильные значения для столбцов, которые определяют отношения. С применением Active Record Вы можете сделать это примерно так:
```
app.models.Customer
.findOne(123)
.then(function(customer) {
var order = new app.models.Order();
order.subtotal = 100;
// ...
// Устанавливаем значение, определяющее отношение "customer" для `app.models.Order` и сохраняем.
order.customer_id = customer.id;
order.save();
});
```
Active Record предоставляет метод *Jii.sql.ActiveRecord.link()*, который позволяет сделать это более изящно:
```
app.models.Customer
.findOne(123)
.then(function(customer) {
var order = new app.models.Order();
order.subtotal = 100;
// ...
order.link('customer', customer);
});
```
Метод *Jii.sql.ActiveRecord.link()* ожидает имя отношения и экзепмляр Active Record, с которым должно соединена запись. Метод соединит два экземпляра Active Record и сохранит их в БД. В приведенном выше примере, он установит атрибут `customer\_id` в `app.models.Order`.
> Примечание: Вы не можете связать два только что созданных экземпляров Active Record.
Выгода от использования метода *Jii.sql.ActiveRecord.link()* еще более очевидна, когда отношение определяется с помощью дополнительной таблицей. Например, вы можете использовать следующий код, чтобы связать экземпляр `app.models.Order` с `app.models.Item`:
```
order.link('items', item);
```
Этот код автоматически добавит строку в таблицу `order\_item` для создания связи.
Для удаления связи между двумя экземплярами Active Record, используйте метод *Jii.sql.ActiveRecord.unlink()|unlink()*.
Например,
```
app.models.Customer.find()
.with('orders')
.all()
.then(function(customer) {
customer.unlink('orders', customer.get('orders')[0]);
});
```
По умолчанию, метод *Jii.sql.ActiveRecord.unlink()* метод устанавливает значения ключа, определяющего отношение, в `null`. Однако, вы можете передать параметр `isDelete` как `true`, чтобы удалить строки с таблицы.
В заключении
============
На данный момент в Active Record от Jii не реализованы транзакции, вещь нужная и поэтому в будущем она появится.
Как я уже говорил в [предыдущей статье](http://habrahabr.ru/post/260295/), Jii — опенсорсный проект, поэтому я буду очень рад, если кто-то присоединится к разработке Jii. Пишите на affka@affka.ru.
Сайт фреймворка — [jiiframework.ru](http://www.jiiframework.ru/)
GitHub — [github.com/jiisoft](https://github.com/jiisoft)
**Навигация по статьям** * [Jii: конфигурация и масштабирование](http://habrahabr.ru/post/266929/)
* [Jii — JavaScript фреймворк с архитектурой от Yii 2](http://habrahabr.ru/post/260931/)
* [Jii: Active Record для Node.js с API от Yii 2](http://habrahabr.ru/post/260569/)
* [Jii: Полноценный Query Builder для Node.js с API от Yii 2](http://habrahabr.ru/post/260295/) | https://habr.com/ru/post/260569/ | null | ru | null |
# Построение орбит небесных тел средствами Python
### Системы отсчёта для определения орбиты
Для нахождения траекторий относительных движений в классической механике используется предположение об абсолютности времени во всех системах отсчета (как инерциальных, так и неинерциальных).
Используя данное предположение, рассмотрим движение одной и той же точки в двух различных системах отсчета  и , из которых вторая движется относительно первой с произвольной скоростью , где  радиус-вектор, описывающий положение точки начала системы координат  относительно системы отсчета ).
Будем описывать движение точки в системе  радиус-вектором , направленным из начала координат системы  в текущее положение точки. Тогда движение рассматриваемой точки относительно системы отсчета  описывается радиус-вектором :
, (1)
а относительная скорость 
,(2)
где  — скорость точки относительно системы ;-скорость движения системы отсчета относительно системы отсчета .
Таким образом, для нахождения закона движения точки в произвольной системе отсчета  необходимо:
1) задать закон движения точки —  относительно системы отсчета ;
2) задать закон движения —  системы отсчета  относительно системы отсчета 
3) определить закон движения точки —  относительно системы отсчета .
### Построение орбиты Луны в гелиоцентрической системе отсчета
В **гелиоцентрической системе отсчета** (система ) Земля движется по окружности радиуса
 км (период обращения  с.). Луна, в свою очередь, движется вокруг Земли (система К') по окружности радиуса  км. (период обращения  с. Как известно [1,2], при движении материальной точки по окружности радиуса  с постоянной угловой скоростью  координаты радиус-вектора, проведенного из начала координат к текущему положению точки, меняются по закону:
где  — начальная фаза, характеризующая положение частицы в момент времени , которую в дальнейшем мы будем полагать равной нулю. Заменяя в (3)  на  и  и подставляя в (1), получаем зависимость радиус-вектора Луны в гелиоцентрической системе координат от времени:
Выражение (4) задает орбиту Луны () в параметрической форме, где параметром является время. Для построения искомой орбиты средствами Python, зададим радиусы орбит и периоды вращения Земли и Луны.
Земля движется в гелиоцентрической системе координат () её радиус орбиты и период обращения соответственно равны .Луна движется вокруг земли в системе координат () её радиус орбиты и период обращения соответственно равны .
С учётом (4) определим функции зависимости координат от времени:
Используя (5), получим пару координат для орбиты Луны:
Зададим число точек, в которых вычисляются координаты N=1000 и дискретное время на интервале периода вращения Земли . Напишем программу и построим график для положительной области изменения координат:
**Определение орбит Земли и Луны**
```
from numpy import*
from matplotlib.pyplot import*
R1=1.496*10**8#Числовые данные для расчётов взяты из публикации [6]
T1=3.156*10**7
R2=3.844*10**5
T2=2.36*10**6
N=1000.0
def X(t):
return R1*cos(2*pi*t/T1)
def Y(t):
return R1*sin(2*pi*t/T1)
def x(t):
return R2*cos(2*pi*t/T2)
def y(t):
return R2*sin(2*pi*t/T2)
k=100
t=[T1*i/N for i in arange(0,k,1)]
X=array([X(w) for w in t])
Y=array([Y(w) for w in t])
x=array([x(w) for w in t])
y=array([y(w) for w in t])
XG=X+x
YG=Y+y
figure()
title("Траектория орбит Земли и Луны.\n Для положительных значений координат")
xlabel('$X(t_{k})$,$X_{g}(t_{k})$')
ylabel('$Y(t_{k})$,$Y_{g}(t_{k})$')
axis([1.2*10**8,1.5*10**8,0,1*10**8])
plot(X,Y,label='Орбита Земли')
plot(XG,YG,label='Орбита Луны')
legend(loc='best')
grid(True)
show()
```
Получим:
*Рис.1*
Созданный график позволяет расширить учебную задачу и посмотреть какой будет орбита луны, если радиус орбиты Луны будет равен .**. Читателю, даже не имеющему специальных знаний по астрономии, понятно что Луна не может иметь такую орбиту в не поля тяготения Земли а гипотетический радиус используется для изучения условий возникновения петель**. Внесём соответствующие изменения в программу:
**Определение орбит Земли и Луны** изучения
```
from numpy import*
from matplotlib.pyplot import*
R1=1.496*10**8#Числовые данные для расчётов взяты из публикации [6]
T1=3.156*10**7
R2=3.844*10**7
T2=2.36*10**6
N=1000.0
def X(t):
return R1*cos(2*pi*t/T1)
def Y(t):
return R1*sin(2*pi*t/T1)
def x(t):
return R2*cos(2*pi*t/T2)
def y(t):
return R2*sin(2*pi*t/T2)
t=[T1*i/N for i in arange(0,N,1)]
X=array([X(w) for w in t])
Y=array([Y(w) for w in t])
x=array([x(w) for w in t])
y=array([y(w) for w in t])
XG=X+x
YG=Y+y
figure()
title("Гелиоцентрическая орбита Земли и Луны")
xlabel('$X(t_{k})$,$X_{g}(t_{k})$')
ylabel('$Y(t_{k})$,$Y_{g}(t_{k})$')
axis([-2.0*10**8,2.0*10**8,-2.0*10**8,2.0*10**8])
plot(X,Y,label='Орбита Земли')
plot(XG,YG,label='Орбита Луны')
legend(loc='best')
grid(True)
show()
```
Получим:
*Рис.2*
Сравнивая орбиты Луны, представленные на рис. 1 и 2, обнаруживаем их существенные отличия. Для объяснения причины этих отличий необходимо сравнить линейные скорости движения Луны в первом и во втором случае и линейную скорость движения Земли.
Так как направление линейной скорости движения Земли относительно Солнца, как и направление линейной скорости движения Луны относительно Земли, меняется во времени, а скорость остается постоянной по величине.
В качестве количественной характеристики соотношения линейных скоростей движения Луны и Земли в гелиоцентрической системе координат следует выбрать разность между модулем линейной скорости движения Земли и проекцией линейной скорости Луны на направление вектора линейной скорости Земли:
Определим функции, описывающие законы изменения составляющих скорости Земли и Луны:
Чтобы определить результирующую скорость с учётом проекции, воспользуемся соотношением:
Напишем программу с учётом(5), (8), (9) и радиуса орбиты Луны  км.:
**Луна и Земля движутся в одном направлении**
```
from numpy import*
from matplotlib.pyplot import*
R1=1.496*10**8#Числовые данные для расчётов взяты из публикации [6]
T1=3.156*10**7
R2=3.844*10**5
T2=2.36*10**6
N=1000.0
k1=2*pi/T1
k2=2*pi/T2
def Vx(t):
return -k1*R1*sin(k1*t)
def Vy(t):
return k1*R1*cos(k1*t)
def vx(t):
return -k2*R2*sin(k2*t)
def vy(t):
return k2*R2*cos(k2*t)
def D(t):
return sqrt(Vx(t)**2+Vy(t)**2)-sqrt(vx(t)**2+vy(t)**2)*(Vx(t)*vx(t)+Vy(t)*vy(t))/((sqrt(Vx(t)**2+Vy(t)**2))*(sqrt(vx(t)**2+vy(t)**2)))
x=[T1*i/N for i in arange(0,N,1)]
y=[D(t) for t in x]
title("Луна движется в одном направлении с Землёй \n Радиус орбиты Луны R2=3.844*10**5 км.")
xlabel('t')
ylabel('D(t)')
plot(x,y)
show()
```
Получим:
*Рис.3.*
Напишем программу с учётом (5), (8), (9) и радиуса орбиты Луны R2=3.844\*10\*\*7 км:
**Луна периодически движется в противоположном к Земле направлению**
```
from matplotlib.pyplot import*
R1=1.496*10**8#Числовые данные для расчётов взяты из публикации [6]
T1=3.156*10**7
R2=3.844*10**7
T2=2.36*10**6
N=1000.0
k1=2*pi/T1
k2=2*pi/T2
def Vx(t):
return -k1*R1*sin(k1*t)
def Vy(t):
return k1*R1*cos(k1*t)
def vx(t):
return -k2*R2*sin(k2*t)
def vy(t):
return k2*R2*cos(k2*t)
def D(t):
return sqrt(Vx(t)**2+Vy(t)**2)-sqrt(vx(t)**2+vy(t)**2)*(Vx(t)*vx(t)+Vy(t)*vy(t))/((sqrt(Vx(t)**2+Vy(t)**2))*(sqrt(vx(t)**2+vy(t)**2)))
x=[T1*i/N for i in arange(0,N,1)]
y=[D(t) for t in x]
title(" Периодически Луна движется в противоположном к Земле \n направлению. Радиус орбиты Луны R2=3.844*10**7 км.")
xlabel('t')
ylabel('D(t)')
plot(x,y)
show()
```
Получим:
*Рис.4.*
Анализ зависимостей позволяет объяснить причину отличий орбит. Функция D(t) при  км всегда положительна, т. е. Луна всегда движется в направлении движения Земли и петли не образуются. При  км величина  принимает отрицательные значения, и существуют моменты времени, в которые Луна движется в направлении, противоположном направлению движения Земли, а потому орбита имеет петли.**В этом и состоял смысл использования в расчётах не существующей орбиты Луны.**
### Построение орбиты Марса в системе отсчета, связанной с Землей
.
В гелиоцентрической системе отсчета (система К) Земля движется по окружности радиуса  км, период обращения  сут, Марс двигается по эллипсу, большая полуось которого км, период обращения Марса  сут., эксцентриситет орбиты  [3]. Движение Земли описывается радиус-вектором R(t), задаваемым выражением (3). В связи с тем, что орбита Марса является эллипсом, зависимости от времени задаются параметрически [4]:
, (10)
, (11)
, (12)
Полному обороту по эллипсу соответствует изменение параметра  от 0 до . Для построения орбиты Марса необходимо вычислить в одни и те же моменты времени координаты радиус-векторов, описывающих положение Земли и Марса в гелиоцентрической системе отсчета, затем в соответствии с соотношением  вычислить координаты Марса в системе отсчета, связанной с Землей.
Для построения орбиты Марса в системе отсчёта связанной с Землёй воспользуемся ранее приведенными параметрами орбит Земли и Марса, соотношениями (10)-(12), а также соотношениями для координат Земли:
, (13)
 ,(14)
Следует учесть, что число периодов обращения Марса вокруг Солнца равно , тогда количество точек, в которых следует произвести расчёт и расстояние между ними, будут определяться из соотношений:
 (15)
**Орбита Марса в системе отсчёта Земли**
```
from numpy import*
from matplotlib.pyplot import*
R1=1.496*10e8#Числовые данные для расчётов взяты из публикации [4]
T1=365.24
am=2.28*10e8
Tm=689.98
ee=0.093
N=36000
def x(g):
return am*(cos(g)-ee)
def y(g):
return am*sqrt(1-ee**2)*sin(g)
def t(g):
return Tm*(g-ee*sin(g))/2*pi
def X(g):
return R1*cos(2*pi*t(g)/T1)
def Y(g):
return R1*sin(2*pi*t(g)/T1)
y=array([y(2*pi*i/N) for i in arange(0,N,1)])
x=array([x(2*pi*i/N) for i in arange(0,N,1)])
X=array([X(2*pi*i/N) for i in arange(0,N,1)])
Y=array([Y(2*pi*i/N) for i in arange(0,N,1)])
t=array([t(2*pi*i/N) for i in arange(0,N,1)])
figure()
title("Гелиоцентрические орбиты Земли и Марса")
xlabel('x(g),X(g)')
ylabel('y(g),Y(g)')
plot(x,y,label='Орбита Марса')
plot(X,Y,label='Орбита Земли')
legend(loc='best')
figure()
title("Положение Марса в системе отсчёта связанной с Землёй")
xlabel('x1/10e8')
ylabel('y1(g/10e8')
x1=(x-X)
y1=(y-Y)
plot(x1/10e8,y1/10e8)
figure()
title("Зависимость расстояния между Землёй и Марсом \n от времени в годах")
xlabel('t/365.24')
ylabel('sqrt(x1**2+y1**2)/10e8')
y2=sqrt(x1**2+y1**2)/10e8
x2=t/365.24
plot(x2,y2)
show()
```
Получим:
*Рис.5*
Вычислим координаты радиус-вектора, описывающего положение Марса в системе отсчета связанной с Землей, и построим орбиты (Рис.6), используя соотношение:
 (16)
*Рис.6*
Еще одной важной характеристикой движения Марса (в первую очередь для межпланетных космических полетов) является расстояние между Землей и Марсом s(t), которое определяется модулем радиус-вектора, описывающего положение Марса в системе отсчета, связанной с Землей. Зависимость расстояния между Землей и Марсом от времени, измеряемого в земных годах, представлена на рис.7.
*Рис.7*
Анализ зависимости, представленной на рис.7, показывает, что расстояние между Землей и Марсом является сложной периодической функцией времени. Если воспользоваться терминологией теории сигналов [5], то о зависимости s(t) можно сказать, что она представляет собой амплитудно-модулированный сигнал, который принято представлять в виде произведения двух функций высокочастотной (несущей) и низкочастотной функции, задающей амплитудную модуляцию (огибающей):
 (17)
где  — постоянная составляющая функции ;  — амплитуда сигнала;  — частота несущей;  — амплитуда функции, задающая глубину амплитудной модуляции; — частота модулирующей функции.
Из рис.7 видно, что период несущей составляет примерно 2 года, период модулирующей функции примерно 17 лет]6].
### Построение гелиоцентрической орбиты кометы Галлея
В последний раз комета Галлея проходила через свой перигелий (ближайшая к Солнцу точка орбиты) 9 февраля 1986 года. (Само Солнце считается расположенным в начале координат.)
Координаты и компоненты скорости кометы Галлея в тот момент были равны  и соответственно, причем расстояние здесь выражено в астрономических единицах длины – а.е.д., или просто а.е. (астрономическая единица, т. е. длина большой главной полуоси земной орбиты), а время – в годах. В этих единицах измерения трехмерные уравнения движения кометы имеют вид:
(18)
где:
**Построение гелиоцентрической орбиты кометы Галлея**
```
from numpy import*
from scipy.integrate import odeint
import matplotlib.pyplot as plt
from matplotlib.patches import Circle
def f(y, t):
y1, y2, y3, y4,y5,y6 = y
return [y2, -(4*pi*pi*y1)/(y1**2+y3**2 +y5**2)**(3/2),y4,-(4*pi*pi*y3)/(y1**2+y3**2 +y5**2)**(3/2),y6,-(4*pi*pi*y5)/(y1**2+y3**2 +y5**2)**(3/2)]
t = linspace(0,300,10001)
y0 = [0.325514,-9.096111, -0.459460,-6.916686,0.166229,-1.305721]
[y1,y2, y3, y4,y5,y6]=odeint(f, y0, t, full_output=False).T
fig, ax = plt.subplots()
plt.title("Орбита кометы Галлея(расстояние в а.е., время в годах) \n Солнце в центре координат")
plt.xlabel('x(t)')
plt.ylabel('y(t)')
fig.set_facecolor('white')
ax.plot(y1,y3,linewidth=1)
circle = Circle((0, 0), 0.2, facecolor='orange')
ax.add_patch(circle)
plt.axis([1,-21,-1,29])
plt.grid(True)
fig, ax = plt.subplots()
plt.title("Орбита кометы Галлея \n Солнце в центре координат")
plt.xlabel('x(t)')
plt.ylabel('z(t)')
fig.set_facecolor('white')
ax.plot(y1,y5,linewidth=1)
circle = Circle((0, 0), 0.1, facecolor='orange')
ax.add_patch(circle)
plt.axis([1,-21,1,-11])
plt.grid(True)
fig, ax = plt.subplots()
plt.title("Орбита кометы Галлея \n Солнце в центре координат")
plt.xlabel('y(t)')
plt.ylabel('z(t)')
fig.set_facecolor('white')
ax.plot(y3,y5,linewidth=1)
circle = Circle((0, 0), 0.2, facecolor='orange')
ax.add_patch(circle)
plt.axis([-1,29,1,-11])
plt.grid(True)
fig, ax = plt.subplots()
plt.title("Проекция скорости движения кометы Галлея \n на плоскости ZOX и ZOY ")
ax.plot(t,y1,linewidth=1)
ax.plot(t,y3,linewidth=1)
plt.show()
```
Получим:
**Ваша собственная комета**
Попробуйте провести эксперимент. В ночь вы установите свой телескоп на вершине, недалеко расположенной от вашего дома возвышенности. Ночь должна быть ясной, безоблачной, звездной и, если вам улыбнулась фортуна: в 0 часов 30 минут ночи вы заметите новую комету.
После повторных наблюдений в следующие ночи вам удастся вычислить ее координаты в ту первую ночь. Координаты в гелиоцентрической системе координат: P0= (x0, y0, z0) и и вектор скорости v0 = (vx0, vy0, vz0).
Используя эти данные, определите:
* расстояние кометы от Солнца в перигелии (самая близкая к Солнцу точка орбиты) и в афелии (самая дальняя от Солнца точка орбиты);
* скорости кометы при прохождении через перигелий и через афелий;
* период обращения кометы вокруг Солнца;
* следующие две даты прохождения кометы через перигелий.
Если измерять расстояние в астрономических единицах, а время — в годах, то уравнение движения кометы примут вид (18). Для вашей собственной кометы выберите произвольные начальные координаты и скорости того же порядка, что и у кометы Галлея.
В случае необходимости, повторно осуществляйте произвольный выбор начального положения и вектора скорости до тех пор, пока не получите правдоподобную эксцентрическую орбиту, выходящую за пределы орбиты Земли (как у большинства настоящих комет).
### Ссылки:
1. Фейнман Р., Лейтон Р., Сэндс М. Фейнмановские лекции по физике. 3-е изд. Т. 1.-2. М.: Мир, 1977.
2. Матвеев А. Н. Механики и теория относительности. М.: Высш. шк., 1986.
3. Физическая энциклопедия. Т. 3. М.: Большая российская энциклопедия, 1992.
4. Ландау Л. Д., Лифшиц Е. М. Курс теоретической физики. Механика. М.: Фю-матгиз, 1958.
5. Баскаков С. И. Радиотехнические цепи и сигналы. М.: Высш. шк., 1988.
6. Поршнев C.В. Компьютерное моделирование физических процессов с использованием пакета [mathcad](http://publ.lib.ru/ARCHIVES/P/PORSHNEV_Sergey_Vladimirovich/_Porshnev_S.V..html). | https://habr.com/ru/post/419911/ | null | ru | null |
# Читаем ключевой контейнер КриптоПро
Речь пойдет о PFX, который можно экспортировать из КриптоПро, как бы все хорошо, но данный контейнер нельзя использовать в OpenSSL и в других криптографических средствах из-за некой PBE с OID 1.2.840.113549.1.12.1.80.
Также есть известная утилита [P12FromGostCSP](http://soft.lissi.ru/downloads/), она действительно работает, но у нее есть минусы, а именно:
* Иногда стоит больше чем сам сертификат
* Работает напрямую через Microsoft CryptoAPI соответственно не принимая на вход PFX
* Отсутствие кроссплатформенности, что особенно огорчило меня
* И как уже говорил [@shukan](/users/shukan) в демоверсии не дает сохранить результат, зачем тогда демоверсия вообще
### Транспортная кодировка (Та самая PBE)
Является шифром ГОСТ 28147-89 (он же "Магма") в CFB режиме, и функцией хэширования ГОСТ 34.11-94 с перестановочными значениями (SBOX) от КриптоПро. В ASN1 структуре идет соль, количество итераций хэширования, и шифрованная структура ключа. После расшифровки получаем ключевой блоб.
### Ключевой блоб
Содержит заголовок и ASN структуру шифрованного приватного ключа.
Пример заголовка: `0720000042AA00004D41473140000000`. Из него можно получить следующую информацию
* `07` - Приватный ключ
* `42АА` - Ключ по ГОСТ 2012 года, 512 бит (46АА - 256 бит)
* `4D414731` - признак ГОСТ 28147-89, в чем суть я так и не понял
Следом идет структура экспортного шифрования.
### Экспортное шифрование
Экспортное шифрование или же алгоритм `CALG_PRO12_EXPORT` - последний рубеж к значению приватного ключа. Состоит из наборов значений, таких как: UKM (8 байт) - вектор инициализации Магмы, CEK\_ENC (64 байта в 512 бит, 32 байта в 256 бит) - шифрованное значение ключа, CEK\_MAC (4 байта) - имитовставка для проверки правильности расшифровки. А также параметры шифра, и алгоритм хэширования.
### Читаем контейнер
[Программа на Github.](https://github.com/li0ard/cpfx)
Небольшое пояснение.
Основная работа разделена на 5 этапов
1. Снятие транспортной кодировки посредством вычисления хэша по комбинации (пароль/результат прошлого раунда + соль + четырех значный номер раунда) и дешифровки по ГОСТ 28147-89 с указанием IV полученной ранее
2. Определение алгоритма ключа по заголовку блоба
3. Деривация ранее полученного хэша через функцию `KDF_GOSTR3411_2012_256`
4. Снятие экспортного шифрования, посредством указания результата функции в качестве ключа
5. Конвертирование в PEM
Всем спасибо за внимание. Это моя первая статья на Хабре! | https://habr.com/ru/post/693600/ | null | ru | null |
# Альтернатива mysql_pconnect для драйвера mysqli в php 5.3
В качестве драйвера для соединения с базой я использовал mysqli. Проблема началась, когда я добавил на свой тестовый сервер > 500 000 записей в одну таблицу. Соединение с базой стало занимать от 1 до 10 секунд, несмотря на то, что в настройках стояло:
```
$db['default']['pconnect'] = TRUE;
```
что должно было означать, что подключение происходит через постоянное соединение.
### Немного теории
mysql\_pconnect делает все тоже самое, что и mysql\_connect, за двумя важными исключениями:
* При соединении функция пытается найти указатель на соединение к тому же хосту, с таким же логином и паролем. Если такое соединение найдено, то возвращается указатель на него, новое соединение не открывается.
* Соединение с сервером не будет закрыто по завершению работы скрипта. В этом случае mysql\_close() не закрывает соединение, открытое через mysql\_pconnect.
### Решение
Дело оказалось вот в чем. Файл /system/database/drivers/mysqli/mysqli\_driver.php. Скрипт игнорирует «флажок» постоянного соединения и производит соединение через обычную функцию mysqli\_connect:
```
function db_pconnect(){
$this->db_connect();
}
```
У mysqli нет функции mysqli\_pconnect. Постоянные соединения там организуются другим способом. Ответ с php.net:
```
To open a persistent connection you must prepend p: to the hostname when connecting.
```
Надо всего лишь добавить «p:» перед названием хоста. Переписываем функцию db\_pconnect()
```
function db_pconnect(){
$this->hostname = 'p:'.$this->hostname;
$this->db_connect();
}
```
### Замечание
Это решение будет работать не ниже PHP 5.3.
Переписывать функции в ядре фреймворка не благодарное дело, но решение очень быстрое и простое. Если есть более изящное решение с возможностью расширить этот класс драйвера, то прошу в комментарии.
### Ссылки
[The mysqli Extension and Persistent Connections](http://www.php.net/manual/en/mysqli.persistconns.php) | https://habr.com/ru/post/129482/ | null | ru | null |
# HTML-формы. Взгляд бэкенд-разработчика
При подготовке материала по Symfony Form я решил уделить некоторое внимание теоретической части по работе с формами со стороны клиента – что они из себя представляют, как ведут себя браузеры при отправке, в каком формате путешествуют, в каком виде поступают на сервер.
Вводная часть несколько растянулась и в итоге вылилась в отдельную небольшую статью, которая, по моему мнению, может быть интересна и другим бэкенд-разработчикам (не только PHP или Symfony).
В тексте будут использоваться два похожих термина: поле формы и элемент формы. Оба в большинстве случаев взаимозаменяемы и обозначают некоторую часть формы. Но для удобства и порядка полями чаще будут называться части, которые содержат непосредственно значения и, вероятно, будут отправлены на сервер, а элементами – декоративные части формы.
Раньше работа с формами была в каком-то смысле проще: в том виде, в котором форма приходила к пользователю, в том же она отправлялась и обратно, но уже с заполненными полями. Бэкенд-разработчики точно знали какой набор данных им следует ожидать, всё было легко и предсказуемо. С широким распространением JS всё изменилось: сегодня уже никого не удивляет поведение приложения, при котором форма приходит с одним набором полей, а отправляется с совершенно иным, когда громоздкие формы имеют в своём составе небольшие динамические подформы, которые независимо от основной могут отправляться на сервер для обработки, когда выбранные файлы загружаются в фоновом режиме, в то время как пользователь заполняет остальную часть формы. Таким образом, всё большее количество логики переносится на сторону клиента, и это отлично, в первую очередь, конечно же, для пользователя. Для разработчика процесс работы с формами несколько усложнился. Но как бы тяжело ему не было, игнорировать развитие технологий сегодня невозможно, поэтому необходимо уметь эффективно их использовать.
### Бэкенд против Фронтенда
Мы постоянно стремимся к автоматизации всего, с чем нам приходится работать, особенно рутинных задач, при этом пытаемся привнести в эти процессы некий порядок. Поэтому многих разработчиков несколько пугает динамичность на клиентский стороне, которая часто воспринимается ими как неконтролируемый хаос. Можно подумать, что у фронтенд-разработчиков развязаны руки, и они могут творить подобно художникам и скульпторам, их действия ничем не ограничены, а нам потом разбирать на сервере полёты их фантазии. Нередко так и случается, но это ошибочный, тупиковый путь. Это можно сравнить со schemaless-хранилищами данных: никто вас не ограничивает жёсткой структурой хранения данных, каждый из разработчиков в рамках одного проекта может придумать свой формат хранения, потом поменять его в зависимости от настроения, что в конечном счёте, скорее всего, приведёт к печальным последствиям. Если же вы ожидаете от своего продукта гибкости, легкой расширяемости и динамичного развития, вам необходимо будет придерживаться определённых правил, которые помогут поддерживать порядок в вашем приложении. То же самое вы в праве требовать и от фронтенд-разработчиков – *творите, но придерживайтесь правил*.
Итак, что вам, как **бэкенд-разработчику**, необходимо понять и принять:
1. *Перестаньте бояться динамики на серверной стороне.*
Мир и технологии не стоят на месте, и если вы не будете успевать под них подстраиваться, вы проиграете. Сегодня динамичность — это неотъемлемая часть нашей жизни, и вам придётся с этим смириться, хотите вы этого или нет. Теперь при работе с формами необходимо ориентироваться не только и не столько на заранее определенную разработчиком жёсткую структуру полей, сколько на пришедшие от пользователей данные.
2. *Не вините во всём фронтенд-разработчиков.*
Установите в компании, команде, проекте правила, и тогда у фронтенд-разработчиков будет не меньшая ответственность при работе с формами чем у вас. А ещё лучше, если кроме правил между всеми разработчиками будут доверительные отношения, а все решения будут приниматься в сотрудничестве.
### Отправляем форму
Отлично, мы каким-то образом сгенерировали HTML для некоторой формы и отправили её пользователю. Заполнив поля и, возможно, изменив структуру формы, пользователю необходимо отправить её на сервер для обработки. Каким образом он может это сделать? Есть разные способы, большинство из которых потребует выполнения скриптов. Рассмотрим основные:
1. Нажатие на кнопку отправки формы.
2. Вызов метода submit() у объекта формы.
3. Сериализация полей формы.
4. Создание и формирование произвольного запроса.
Способы в списке расположены в порядке возрастания прикладываемых фронтенд-разработчиком усилий, необходимых для отправки формы на сервер. Также можно условно разделить их на две группы: первые два способа составляют группу, в которой формированием и отправкой запроса занимается браузер, вторая группа включает последние два способа, при которых эти действия выполняет JS.
#### Пусть работает браузер
Для начала рассмотрим первую группу, оба способа которой мало чем отличаются друг от друга. В этом случае всю работу и ответственность на себя берёт браузер пользователя, причем действует он достаточно прямолинейно:
1. Определяет форму, поля которой необходимо отправить.
2. Определяет набор полей, которые подлежат отправке. В этот набор входят следующие элементы формы: button, input, keygen, object, select, textarea.
3. Генерирует пары ключ=значение, где ключом является имя поля (атрибут name), а значением – содержимое данного поля.
4. Создает и формирует запрос, который будет выполнен методом, указанным в атрибуте тега формы method и тело которого будет закодировано в зависимости от значения атрибута enctype.
5. Отправляет запрос на сервер по адресу, указанному в атрибуте тега формы action.
Определение отправляемой формы зависит от рассматриваемых нами способов. Если это нажатие на кнопку, форма определяется атрибутом form нажимаемой кнопки, а при его отсутствии – родительским для кнопки тегом form. Если же это вызов метода submit(), отправляемой является форма, связанная с объектом, для которого вызывается данный метод.
Атрибуты formmethod, formenctype и formaction нажимаемой кнопки переопределяют соответственно значения атрибутов method, enctype и action родительской формы.
Это очень простой процесс, но важно в нём разобраться, чтобы однозначно понимать, какие данные и в каком виде мы получаем на сервере.
Из всего списка наиболее интересен третий пункт – генерация пар ключ=значение. Каждый элемент формы должен иметь атрибут name, который будет использован браузером в качестве ключа. Рассмотрим на примере. Имеется следующая форма:
```
```
В этом случае браузер сформирует две пары ключ=значение: nickname=ghost и password=123456. При отправке они будут склеены с помощью символа амперсанда (&), и в результате на сервер будет отправлен запрос, тело которого содержит строку:
```
nickname=ghost&password=123456
```
Получив такой запрос, PHP начнёт его разбор, примерный алгоритм которого можно посмотреть в описании функции [parse\_str](http://php.net/parse_str). В результате разбора будут определены два поля и их значения, они будут помещены в суперглобальный массив $\_POST, который примет следующий вид:
```
$_POST = [
'nickname' => 'ghost',
'password' => '123456',
]
```
На что в этом процессе следует обратить внимание:
1. **Вся поступающая к вам информация будет представлена в виде текстовых значений.**
Какой бы сложной ни была клиентская часть работы с формой, вы в любом случае получите всю информацию в текстовом (строковом) виде. Если это работа с картографическими сервисами, результатом будут координаты. Если это WYSIWYG-редактор, то в зависимости от типа редактора результатом будет либо HTML-код, либо текст в markdown-разметке, либо текст в любом другом заранее известном вам формате. Это важный пункт, осознание которого поможет побороть страх перед громоздкими сложными формами. Разумеется, это не относится к загружаемым файлам.
2. **Не все поля, которые содержатся в форме, будут отправлены в запросе.**
Например, есть типы полей, которые не будут включены в запрос, если они не были выбраны или не имеют введённого значения. Такими являются, например, следующие:
* radio
* checkbox
* select с атрибутом multipleНа данном правиле основан известный хак с полем типа hidden, которое размещается вместе с полем типа checkbox, для корректного определения его состояния при отправке формы. К концу данного списка станет понятно, где надо размещать скрытое поле и почему этот хак работает.
Также в запрос не будут включены значения кнопок, как обычных, так и submit, которые не участвуют в отправке формы, т.е. те кнопки, по которым не было совершено нажатие. Таким образом, если отправка выполняется методом submit(), в запрос не будет включена ни одна кнопка.
Не будут отправлены также поля, находящиеся в отключённом состоянии (имеющие атрибут disabled).
3. **Браузер никак не изменяет имена полей формы при генерации пар ключ=значение.**
Значение ключа в паре зависит исключительно от самого поля, а точнее от его атрибута name, и никакие родительские теги на нёго никак не влияют. Таким образом, не имеет значения, содержит ваш тег form атрибут name или нет. Это также важно для понимания.
4. **Браузер никак не разрешает конфликты имён у нескольких полей внутри формы.**
И это важный пункт, о котором многие не знают или думают, что знают, но ошибаются.
Представим, что у нас есть такая форма:
```
```
Многие предполагают, что браузер каким-то образом должен решить, какое одно из двух полей необходимо отправлять в запросе. Логика подсказывает, что отправлять необходимо последнее (в данном случае второе), которое перекрывает все предшествующие поля с тем же именем. *Это предположение неверно!*
Браузер вообще не волнует, есть в форме какие-то конфликты имён или их нет. Непустое имя поля не является критерием исключения данного поля из отправляемого запроса. Другими словами, для браузера оба поля являются корректными и оба будут включены в набор отправляемых полей, причем в том порядке, в котором они представлены в форме.
Таким образом, приведённая выше форма при отправке на сервер примет следующий вид:
```
fullname=John+Doe&fullname=Mike+Ross
```
Именно такой запрос и придёт на наш сервер. Вы можете проверить это, прочитав значение php://input. Что же с этим запросом будет делать PHP? Всё как обычно – разбирает строку и формирует массив $\_POST. Но, как мы знаем, ключи в массивах уникальны, поэтому первоначальное значение «John Doe» будет перезаписано значением «Mike Ross». В итоге мы получим следующий результат:
```
$_POST = [
'fullname' => 'Mike Ross',
]
```
Теперь должно стать понятно, как работает хак со скрытым полем для checkbox. Посмотрим на следующую форму:
```
```
Видим два поля с одинаковыми именами. Если checkbox будет выбран, в запрос будут добавлены оба поля в том порядке, в котором они представлены в форме, а значит значение «0» поля hidden будет перезаписано значением «1» поля checkbox. Если же checkbox выбран не будет, то согласно пункту 2 его значение не отправляется, а значит в запросе будет только поле hidden со значением «0», которое и будет получено на сервере и помещено в массив $\_POST.
5. **Разрешать конфликты имён полей должен разработчик.**
Этот пункт вытекает из предыдущего. Взглянем еще раз на рассмотренный нами пример формы с двумя полями fullname. Представим, что первое поле – это имя менеджера, второе – разработчика. На сервере нам нужны оба значения, но так как PHP перезаписывает одно значение другим, нам необходимо каким-то образом ему помочь корректно разобрать пришедшие данные. Логика подсказывает, что надо менять имена полей. Есть несколько вариантов:
* *manager\_fullname* и *developer\_fullname* – самый простой и очевидный. Имена полей теперь уникальны и не вызовут конфликта при записи в массив $\_POST.
* *manager[fullname]* и *developer[fullname]* – в этом случае имена также уникальны, но разбор подобных ключей в PHP будет отличаться от первого варианта: если PHP встречает в ключе парные квадратные скобки, он интерпретирует их как массив.
После разбора $\_POST будет выглядеть следующим образом:
```
$_POST = [
'manager' = [
'fullname' => 'John Doe',
],
'developer' = [
'fullname' => 'Mike Ross',
],
]
```
Этот вариант удобно использовать для создания динамических форм, или, например, если необходимо выделить некоторые поля в логическую подформу.
* *fullname[]* – интересный вариант: имена полей будут одинаковы, но так как в них содержатся квадратные скобки, PHP поймёт, что перед ним массив значений, и в этом случае поместит все значения в массив $\_POST.
Запрос в этом случае будет выглядеть так:
```
fullname[]=John+Doe&fullname[]=Mike+Ross
```
Примерный алгоритм разбора такого запроса в PHP:
```
$_POST = [];
$_POST['fullname'][] = 'John Doe';
$_POST['fullname'][] = 'Mike Ross';
```
Таким образом, массив $\_POST будет содержать следующие значения:
```
$_POST = [
'fullname' = [
'John Doe',
'Mike Ross',
],
]
```
Этот вариант удобно использовать для набора значений неопределенного размера. Например, набор полей типа checkbox.
6. **Поле с атрибутом multiple передается в запросе как N отдельных полей с одинаковыми именами, где N – количество выбранных значений данного поля.**
Предположим, что у нас имеется следующая форма:
```
Movies
Music
Cooking
Photography
Painting
Golf
```
Форма содержит список, в котором мы можем выбрать несколько вариантов. Допустим, мы выбирали Movies, Cooking и Golf. Можно предположить, что при отправке поля будет использован некий разделитель значений. На самом же деле запрос будет выглядеть следующим образом:
```
hobbies=movies&hobbies=cooking&hobbies=golf
```
Т.е. в браузере мы отправляем одно поле с тремя значениями, но серверная сторона видит это как отправку трех полей, которые содержат по одному значению. Очевидно, что согласно пункту 4 массив $\_POST будет содержать только одно последнее значение golf, которое перезапишет первые два. Для решения этой проблемы необходимо воспользоваться советом из пункта 5 и изменить имя тега select на «hobbies[]».
7. **Поля типа radio с одинаковым именем (атрибутом name) в пределах одной формы будут объединены в группу.**
В этом случае никаких конфликтов имён не будет, т.к. в группе можно выбрать/отметить только одно поле, значение которого и будет отправлено в запросе в паре с именем группы (атрибутом name выбранного поля). Все остальные поля данной группы отмечены не будут, а значит согласно пункту 2 не включаются в отправляемый запрос.
#### За всё ответит разработчик
Кратко также рассмотрим вторую группу способов отправки форм. Эта группа отличается от первой тем, что созданием, формированием и отправкой запроса занимается непосредственно разработчик. Данная группа имеет лишь отдалённое отношение к рассматриваемой нами теме, так как не имеет жёсткой привязки к HTML-формам: разработчик может включать в запрос и исключать из него любые данные. Способ сериализации полей отличается от полностью произвольного запроса наличием в широко распространённых JS-фреймворках готовых алгоритмов, которые берут на себя большую часть работы. Эти способы удобны при отправке данных форм с использованием Ajax.
Рассмотрим небольшой пример использования JS-библиотеки jQuery для формирования и отправки формы таким способом.
Форма:
```
```
JS-код:
```
var postbody = $("#userform").serialize();
$.ajax({
url: "server.php",
type: "POST",
data: postbody,
success: function(data) {
// ...
},
error: function(data) {
// ...
}
});
```
Всю основную работу выполняет метод serialize(), который, используя имена и значения полей формы, генерирует следующую строку:
```
fullname=John+Doe&accept=1
```
Почему из пяти полей формы в запрос включаются только два? Поле email не включается, т.к. находится в отключённом состоянии (атрибут disabled), а поля photo и submit – т.к. метод serialize() данной JS-библиотеки не включает файлы и кнопки в набор полей при формировании строки запроса.
Далее создаём Ajax-запрос с определёнными параметрами и отправляем нашу форму в виде полученной ранее строки. Тут важно понять, что при использовании данного способа от HTML-формы требуется только набор полей с их именами и значениями, все остальные параметры запроса определяет непосредственно разработчик. Таким образом, атрибуты action, method и enctype тега form игнорируются: при вызове метода ajax() мы явно указываем, что данные будут переданы методом POST в обработчик «server.php», а кодирование полей в данном методе по умолчанию – «application/x-www-form-urlencoded».
На стороне сервера такой запрос будет почти идентичен обычному, и только благодаря дополнительным заголовкам мы можем определить, что он был выполнен с использованием технологии Ajax. На основании этой информации формат и содержание ответа в большинстве случаев будет отлично от обычных запросов.
При использовании этой группы способов формирования и отправки запросов фронтенд-разработчик практически ничем не ограничен. Клиентская часть приложения может, например, передать в запросе лишь некоторую часть формы или передать эту форму в формате JSON, серверная же часть должна уметь корректно обрабатывать такие данные, поэтому для решения подобных задач взаимодействие и координация работы бэкенд и фронтенд-разработчиков должны быть усилены.
### К чему вся эта статья?
Работа с формами считается одной из самых сложных задач в веб-разработке. Но если чётко понимать, как работают формы, найти удобные, функциональные и гибкие инструменты как для клиентской, так и для серверной части, наладить взаимодействие между бэкенд и фронтенд-разработчиками, задача намного упрощается.
Эта статья не отвечает на все существующие вопросы, многие не без оснований отметят, что всё описанное — это общеизвестные факты, но надеюсь, что предоставленная информация покажется кому-то полезной и заставит пересмотреть своё отношение к работе с формами, а возможно даже поможет побороть фобию перед ними. | https://habr.com/ru/post/236837/ | null | ru | null |
# Написание современного JavaScript кода
JavaScript-разработчик из Франции, Себастьян Кастель, поделился мыслями о том, как на его взгляд должен выглядеть JavaScript код в 2017 году.
А вы помните те времена, когда JavaScript был языком, который использовали только для оживления страниц сайта? Это время уже прошло, так как, языки программирования развиваются вместе с методами их использования. Посмотрите на код, который вы написали один, два года назад: он вас смущает? Если да, этот пост для вас.
[](http://reddit-marketing.pro)
Ниже вы найдете мой список из хороших практик, которые помогут сделать ваш JavaScript код проще в написании, чтении и поддержке.
### Используйте линтер для форматирования вашего кода
Первый совет, который я вам дам это использование линтера. Он создан для проверки, соблюдения единого стиля в вашем коде. Это позволит сделать код консистентным во всех .js файлах. Очень полезно использовать линтер в командной работе — это позволит сделать стиль кода единым среди всех разработчиков одного проекта.
Что более важно, линтер делает исправления в вашем коде, когда это возможно. [ESLint](http://eslint.org/), например, делает довольно таки хорошо (используйте опцию --fix) и он отлично интегрируется с популярными IDE.
Вы также можете использовать [Prettier](https://github.com/prettier/prettier), если сравнивать с ESLint, он больше сфокусирован на форматировании кода. Разница между ними небольшая.
Следующие пункты помогут вам выбрать какие правила использовать с линтером:
### Используйте современные правила для линтера
Если вы в замешательстве и не можете решить, какой набор правил использовать для кода, выбирайте [StandardJS](https://standardjs.com). Это очень строгий линтер, который не даст вам отступить от правил. Несколько примеров:
* Используйте 2 пробела для табуляции
* Не используйте точки с запятой (мне это показалось очень странным, но через несколько дней я привык)
* Пробелы после ключевых слов (например if) и фигурных скобок
* И [другие](https://standardjs.com/rules.html)
StandardJS может устанавливаться в виде отдельного Node модуля. Но если вы хотите использовать его в большом проекте с существующей кодовой базой и отключить некоторые правила, используйте [ESLint predefined config](https://github.com/feross/eslint-config-standard). Я например отключил [no-mixed-operators](http://eslint.org/docs/rules/no-mixed-operators) и [import/no-webpack-loader-syntax](https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-webpack-loader-syntax.md).
### Используйте новые фишки ES2015+
Вы скорее всего, слышали об изменениях в ES2015+ (или ES6, ES7…). Вот несколько, без которых я больше не могу жить:
* Arrow functions: написание функций типа x => x\*2 очень полезно в функциональном программировании
* Классы: перестаньте использовать прототипы, классы гораздо круче
* Операции с массивами и объектами:
```
function doSomething() {
const a = doSomethingElse()
const b = doSomethingWithA(a)
const otherResults = { c: '', d: '' }
return { a, b, ...otherResults } // equivalent to { a: a, b: b }
}
const { a, c, ...rest } = doSomething() // Also works with arrays!
// `rest` looks like { b: ..., d: '' }
```
* Создание промисов становится легче с async/await:
```
// Please try to write the same code with classic promises ;)
async function doSomething() {
const a = await getValueForA()
const b = await getValueForBFromA(a)
const [c, d] = await Promise.all([
// parallel execution
getValueForC(), getValueForDFromB(b)
])
const total = await calculateTotal(a, b, c, d)
return total / 1000
}
```
### [Используйте](http://reddit-marketing.pro) функциональное программирование
Вокруг данной темы точится много споров. Но не смотря на это, функциональное программирование набирает популярность и не только в JavaScript. В чем причина? Оно делает код более предсказуемым, безопасным и гораздо более поддерживаемым. Вот вам несколько простых советов:
Для начала перестаньте использовать for для циклов. В большинстве случаев они вам не нужны. Доказательство:
```
const arr = [{ name: 'first', value: 13 }, { name: 'second', value: 7 }]
// Instead of:
const res = {}
for (let i = 0; i < arr.length; i++) {
const calculatedValue = arr[i].value * 10
if (calculatedValue > 100) {
res[arr[i].name] = calculatedValue
}
}
// Prefer:
const res = arr
.map(elem => ({ name: elem.name, calculatedValue: elem.value * 10 }))
.filter(elem => elem.calculatedValue > 100)
.reduce((acc, elem) => ({
[elem.name]: calculatedValue,
...acc
}), {})
```
Хорошо, я признаю, что это довольно таки экстремальный пример и если вы не привыкли к функциональному программированию, это может показаться сложным. Давайте упростим код:
```
const enrichElementWithCalculatedValue =
elem => ({ name: elem.name, calculatedValue: elem.value * 10 })
const filterElementsByValue = value =>
elem => elem.calculatedValue > value
const aggregateElementInObject = (acc, elem) => ({
[elem.name]: calculatedValue,
...acc
})
const res = arr
.map(enrichElementWithCalculatedValue)
.filter(filterElementsByValue(100))
.reduce(aggregateElementInObject, {})
```
Здесь мы определили три функции, названия которых указывают на то, что эти функции делают.
Второй совет: создавайте локальные функции (даже в существующих функциях) подобрав для них грамотные названия, вы можете документировать код без комментариев!
Обратите внимание, что три локальные функции не изменяют контекст, в котором они выполняются. Не меняют внешние переменные, не обращаются к внешним сервисам… В функциональном программировании они называются pure (чистыми) функциями. У них есть большие преимущества:
* Их легко тестировать, поскольку из заданных параметров возможен только один возможный результат, даже если мы вызываем функцию несколько раз;
* Они гарантированно дают одинаковый результат независимо от фактического состояния приложения;
* Состояние приложения остается прежним до и после вызова функции.
Исходя из вышесказанного, мой третий совет: используйте такие функции как можно чаще!
### Несколько советов в завершение
* Привыкайте работать с асинхронным кодом, как можно чаще используйте промисы, посмотрите на observales в [RxJS](http://reactivex.io/rxjs/) (вот [отличный туториал по функциональному реактивному программированию](http://reactivex.io/learnrx/))
* Пишите тесты! Возможно вам это покажется очевидным, но я знаю кучу проектов с непроверенным кодом. Хотя тестирование на JavaScript (front или backend) не так сложно, как кажется.
* Используйте последние возможности языка: например, прекратите писать arr.indexOf(elem) !== -1. Замените это на arr.includes(elem).
* Читайте много технических статей: subreddit JavaScript — очень хороший источник черпания информации о самых крутых практиках в экосистеме.
И в заключение самый важный совет, который я могу вам дать: всегда занимайтесь рефакторингом! Попробуйте улучшить модуль, который вы написали год назад. Попробуйте заменить var на const, используйте стрелочные функции или async / await чтобы упростить код… Всегда приятно работать с простым и понятным кодом.
— Первый сервис по продвижению на Реддит:[Buy Reddit Upvotes](http://reddit-marketing.pro) | https://habr.com/ru/post/330534/ | null | ru | null |
# Авто-регистрация тестов на С средствами языка
Сравнительно недавно была статья [«Полуавтоматическая регистрация юнит-тестов на чистом С»](http://habrahabr.ru/post/240565/), в которой автор продемонстрировал решение задачи с использованием счётчиков из Boost. Следуя этому же принципу, была предпринята (успешная) попытка повторить данный опыт уже без использования Boost из соображения нелогичности наличия в проекте на C зависимости от Boost, да ещё и в таком небольшом объёме. При этом в тестах присутствовали вспомогательные директивы препроцессора в большом количестве. И всё бы так и осталось, но практически на завершающей стадии был найден альтернативный способ регистрации, который позволяет полностью избавится от дополнительных действий. Это C89-решение для регистрации тестов и чуть более требовательное к системе сборке решение для регистрации наборов тестов.
Мотивация всего этого простая и понятная, но для полноты стоит её кратко обозначить. В отсутствии авто-регистрации приходится иметь дело либо с набором/вставкой повторяющегося кода, либо с внешними по отношению к компилятору генераторами. Первое делать неохотно плюс само это занятие подвержено ошибкам, второе добавляет лишние зависимости и усложняет процесс сборки. Идея же использовать C++ в тестах только ради этой возможности, когда всё остальное написано на C, вызывает чувство стрельбы из пушки по воробьям. К всему этому, в принципе, интересно решить задачу на том же уровне, на котором она возникла.
Определим конечную цель как нечто похожее на код ниже с дополнительным условием, что имена тестов не повторяются нигде кроме места их определения, т.е. они набираются один и только один раз и далее не копируются никаким автогенератором.
```
TEST(test1) { /* Do the test. */ }
TEST(test2) { /* Do the test. */ }
```
После небольшого отступления для внесения определённости в терминологию, можно будет приступить к поиску решения.
### Терминология и предполагаемая структура тестов
Различные тестовые фреймворки несогласовано используют слова для обозначения отдельных тестов или их групп. Поэтому определим некоторые слова явно, а заодно покажем их значение на примере довольно распространённой структуры тестов.
Под *коллекцией тестов* («suite») будет пониматься группа *наборов тестов* («fixture»). Это наибольшая структурная единица иерархии. Наборы в свою очередь группируют тесты внутри коллекции. Тесты уже сами по себе. Количество элементов каждого типа произвольное.
Это же графически:
Каждый больший уровень объединяет элементы меньших и опционально добавляет процедуры подготовки («setup») и завершения («teardown») тестов.
### Регистрация тестов в наборах
> *Never let your sense of morals prevent you from doing what is right.*
>
> — ISAAC ASIMOV, *Foundation*
Отдельные тесты добавляются чаще чем целые наборы, поэтому и авто-регистрация для них более актуальна. Также все они располагаются в пределах одной единицы трансляции, что упрощает решение задачи.
Итак, необходимо организовать хранилище списка тестов средствами языка, не используя при этом препроцессор как главный управляющий элемент. Отказ от препроцессора означает, что мы остаёмся без явных счётчиков. Но наличие счётчика практически обязательно, если необходимо уникально идентифицировать тесты и, вообще, как-то к ним обращаться, а не только объявлять. При этом под рукой всегда есть встроенный макрос `__LINE__`, на надо ещё придумать как его можно применить в данной ситуации. Есть и ещё одно ограничение: какие-то явные присваивания элементам глобального массива на подобие
```
test_type tests[];
static void test(void) { /* Do the test. */ }
tests[__LINE__] = &test
```
не подходят, так как вне функций такие операции просто не поддерживаются на уровне языка. Исходная ситуация выглядит не очень радужно:
1. Нет возможности хранить ни промежуточное ни конечное состояния.
2. Нет возможности определить несвязные элементы, а потом собрать их вместе.
3. Как результат, отсутствует возможность определить связную структуру (в основном массив, но список тоже подойдёт, был бы способ), по причине невозможности сослаться на предыдущую сущность.
Но не всё так безнадёжно, как может показаться. Представим идеальный вариант, как будто у нас есть то, чего не хватает. В этом случае код после разворачивания вспомогательных макросов мог бы выглядеть примерно следующим образом:
```
MagicDataStructure MDS;
static void test1(void) { /* Do the test. */ }
MDS[__LINE__] = &test1
static void test2(void) { /* Do the test. */ }
MDS[__LINE__] = &test2
static void fixture(void)
{
int i;
for (i = 0; i < MDS.length; ++i) {
MDS.func[i]();
}
}
```
Дело за малым: реализовать «магическую» структуру, которая, между прочим, подозрительно похожа на массив предопределённого размера. Имеет смысл подумать, как бы мы работали будь это массивом на самом деле:
1. Определили бы массив проинициализировав все элементы `NULL`.
2. Присвоили бы значения отдельным элементам.
3. Обошли бы весь массив и вызвали каждый не-`NULL` элемент.
Данный набор операций — это всё, что нам нужно и не выглядит слишком уж нереальным, возможно, массивы действительно здесь пригодятся. По определению, массив — это набор однотипных элементов. Обычно это какая-то одна сущность с поддержкой операции индексирования, но имеет смысл рассматривать тот же массив как группу из отдельных элементов. Скажем, то ли это
```
int arr[4];
```
то ли
```
int arr0, arr1, arr2, arr3;
```
На данный момент и в свете наличия упоминания макроса `__LINE__` выше, уже должно быть понятно куда клонит автор. Осталось понять, как можно реализовать псевдо-массив с поддержкой присваивания на этапе компиляции. Это представляется занятным упражнением, поэтому стоит ещё немного повременить с демонстрацией готового решения и задаться следующими вопросами:
1. Какая сущность в C может появляться больше одного раза и не вызвать при этом ошибку компиляции?
2. Что может трактоваться компилятором по разному в зависимости от контекста?
Подумайте о заголовочных файлах. Ведь то, что в них, обычно присутствует ещё где-то в коде. Например:
```
/* file.h */
int a;
/* file.c */
#include "file.h"
int a = 4;
/* ... */
```
При этом всё прекрасно работает. Вот более близкий к задаче пример:
```
static void run(void);
int main(int argc, char *argv[])
{
run();
return 0;
}
static void run(void) { /* ... */ }
```
Вполне себе заурядный код, который можно немного расширить для получения желаемой функциональности:
```
#include
static void (\*run\_func)(void);
int main(int argc, char \*argv[])
{
if (run\_func) run\_func();
return 0;
}
static void run(void) { puts("Run!"); }
static void (\*run\_func)(void) = &run
```
Читателю предлагается самостоятельно убедится, что изменение порядка или комментирование последнего упоминания `run_func` согласуется с ожиданиями, т.е. если `run_func` не переприсвоили, то единственный элемент «одно-элементного массива» (`run_func`) равен `NULL`, в противном случае он указывает на функцию `run()`. Отсутствие зависимости от порядке важное свойство, которое позволяет скрыть всю «магию» в заголовочном файле.
Из примера выше легко сделать макрос для авторегистрации, который объявляет функцию и сохраняет указатель на неё в переменной пронумерованной с помощью значения макроса `__LINE__`. Кроме самого макроса необходимо перечислить все возможные имена переменных-указателей и вызывать их по одному. Вот практически полное решение не считая наличие «лишнего» кода, который должен быть скрыт в заголовочном файле, но это уже детали:
```
/* test.h */
#define CAT(X, Y) CAT_(X, Y)
#define CAT_(X, Y) X##Y
typedef void test_func_type(void);
#define TEST(name) \
static test_func_type CAT(name, __LINE__); \
static test_func_type *CAT(test_at_, __LINE__) = &CAT(name, __LINE__); \
static void CAT(name, __LINE__)(void)
/* test.c */
#include "test.h"
#include
TEST(A) { puts("Test1"); }
TEST(B) { puts("Test2"); }
TEST(C) { puts("Test3"); }
typedef test\_func\_type \*test\_func\_pointer;
static test\_func\_pointer test\_at\_1, test\_at\_2, test\_at\_3, test\_at\_4, test\_at\_5, test\_at\_6;
int main(int argc, char \*argv[])
{
/\* Это упрошённая версия для наглядности, на самом деле указатели стоит
\* поместить в массив. \*/
if (test\_at\_1) test\_at\_1();
if (test\_at\_2) test\_at\_2();
if (test\_at\_3) test\_at\_3();
if (test\_at\_4) test\_at\_4();
if (test\_at\_5) test\_at\_5();
if (test\_at\_6) test\_at\_6();
return 0;
}
```
Для ясности может быть полезно посмотреть результат макро-подстановки, из которой вытекает факт невозможности размещения больше одного теста в строке, что, впрочем, более чем приемлемо.
```
static test_func_type A4; static test_func_type *test_at_4 = &A4 static void A4(void) { puts("Test1"); }
static test_func_type B5; static test_func_type *test_at_5 = &B5 static void B5(void) { puts("Test2"); }
static test_func_type C6; static test_func_type *test_at_6 = &C6 static void C6(void) { puts("Test3"); }
```
Ссылка на полную реализацию будет приведена ниже.
#### Почему это работает
Теперь пришла пора разобраться в том, что тут происходит, более детально и ответить на вопрос, почему это работает.
Если вспомнить пример с заголовками, то можно выделить несколько возможных варианта того, как члены данных могут быть представлены в коде:
```
int data = 0; /* (1) */
extern int data; /* (2) */
int data; /* (3) */
```
`(1)` однозначно является определением (а значит и объявлением тоже) из-за присутствия инициализатора.
`(2)` является исключительно объявлением.
`(3)` (наш случай) является объявлением и, `возможно`, определением. Отсутствие ключевого слова `extern` и инициализатора не оставляет компилятору иного выбора кроме как отложить принятие решения на счёт того, чем же является этот оператор («statement»). Именно это «колебание» компилятора и эксплуатируется для эмуляции авто-регистрации.
На всякий случай несколько примеров с комментариями, чтобы окончательно прояснить ситуацию:
```
int data1; /* Определение, так как больше нигде не встречается. */
int data2 = 1; /* Определение, из-за инициализатора. */
int data2; /* Объявление, так как определение уже было. */
int data3; /* Изначально, неизвестно, но после обработки следующей строки
* становится понятно, что объявление. */
int data3 = 1; /* Определение, из-за инициализатора. */
/* Ключевое слово static ничего в этом плане не меняет. */
static int data4; /* Изначально, неизвестно, но после обработки следующей
* строки становится понятно, что объявление. */
static int data4 = 1; /* Определение, из-за инициализатора. */
static int data4; /* Объявление, так как определение уже было. */
int data5; /* Неизвестно, но в отсутствии определений считается определением. */
int data5; /* Аналогично, эти два "неизвестно" считаются за одно. */
int data6 = 0; /* Определение, из-за инициализатора. */
int data6 = 0; /* Ошибка, повторное определение. */
```
Для нас важными являются два случая:
* Есть только объявления. В этом случае переменная инициализируется нулями, по которым можно определить отсутствие теста в соответствующей строке.
* Есть минимум одно объявление и ровно одно определение. В соответствующую переменную заносится адрес функции с тестом.
Вот, собственно, и всё, что необходимо для реализации требуемых операций и получения рабочей автоматической регистрации. Эта двойственность некоторых операторов в тексте позволяет развернуть массив по-элементно и «присвоить» значения части массива.
#### Особенности и недостатки
Понятно, что если мы не хотим вставлять макрос в конце каждого файла с тестами, который бы служил маркером последней строки, то необходимо изначально закладываться на какое-то максимальное количество строк. Не самый лучший вариант, но и не самый худший. Скажем, один тестовый файл вряд ли будет вмещать в себя более тысячи строк и можно остановить свой выбор на этой верхней границе. Тут есть один не очень приятным момент: если в таком случае тесты будут определены на строке с номером большим 1000, то они будут лежать мёртвым грузом и никогда не вызовутся. К счастью, есть простой вариант «решения»: достаточно компилировать тесты с флагом `-Werror` (менее жёсткий вариант: с `-Werror=unused-function`) и подобные файлы не скомпилируются. (**UPD2:** [в комментариях подсказали](http://habrahabr.ru/post/252439/#comment_8321885) как решить этот вопрос проще и с автоматическим прерыванием компиляции используя `STATIC_ASSERT`. Достаточно в каждый макрос `TEST` вставить проверку на допустимое значение `__LINE__`.)
Достаточность подхода с фиксированным массивом в общем случае не единственная причина, по которой лучше заранее зафиксировать максимальное количество строк. Если этого не сделать, то соответствующие объявления (в месте вызова тестов) необходимо генерировать во время компиляции, что может её ощутимо замедлить (это не догадка, а результат попыток). Тут проще не усложнять, выгода от получения возможности компилировать файлы произвольного размера, кажется, не стоит того.
В примере с макросом `TEST()` выше видно использование указателя на функцию, это всего лишь одна запись о тесте, но скорее всего захочется добавить больше. Неправильный способ это сделать: добавлять параллельные псевдо-массивы. Это только увеличит время компиляции. Правильный способ: использовать структуру, в этом случае добавление новых полей обходится практически бесплатно.
Для реальной обработки (не копированием кода) элементов псевдо-массива необходимо сформировать настоящий массив. Не лучшим решением будет помещать в этот массив значения тех же указателей на функции (или копировать структуры с информацией о тестах), так как это сделает инициализатор не константным. А вот помещение указателей на указатели позволит сделать массив статическим, что освободит компилятор от необходимости генерировать код для присваивания значений на стеке во время исполнения, а также сократит время компиляции.
Изначально это решение родилось для реализации прозрачной регистрации `setup()`/`teardown()` функций и только потом было применено к самим тестам. В принципе это годится для любой функциональности, которую можно переопределить. Достаточно вставить объявление указателя и предоставить макрос для его переопределения, если макрос не использовался, указатель будет равным нулю, в противном случае — определённому пользователем значению.
Сообщения компилятора об ошибках верхнего уровня в тестах могут удивить своим объёмом, но это произойдёт в довольно редких случаях отсутствия завершающей точки с запятой и подобных синтаксических ошибках.
Наконец можно оценить результат стараний:
| | |
| --- | --- |
| Набор тестов до:
```
static void
teardown(void)
{
/* ... */
}
static void
test_adds_fine_first_time(void)
{
/* ... */
}
static void
test_errors_on_second_addition(void)
{
/* ... */
}
void
addition_tests(void)
{
test_fixture_start();
fixture_teardown(teardown);
run_test(test_adds_fine_first_time);
run_test(test_errors_on_second_addition);
test_fixture_end();
}
```
| Набор тестов после:
```
TEARDOWN()
{
/* ... */
}
TEST(adds_fine_first_time)
{
/* ... */
}
TEST(errors_on_second_addition)
{
/* ... */
}
```
|
### Регистрация наборов тестов в коллекциях
> *A trick is a clever idea that can be used once, while a technique is a trick that can be used at least twice.*
>
> — D. KNUTH, *The Art Of Computer Programming 4A*
Близкая в чем-то к предыдущей задача, но есть пара существенных отличий:
1. Интересные символы (функции/данные) определены в различных единицах компиляции.
2. И, как следствие, отсутствует счётчик аналогичный `__LINE__`.
В силу первого пункта трюк из предыдущей секции в чистом виде тут не сработает, но основная идея останется прежней, в то время как средства её реализации немного поменяются.
Как упоминалось вначале, в этой части выдвигаются некоторые дополнительное требование к среде, а именно к системе сборки, которая должна быть в состоянии присваивать файлам идентификаторы в диапазоне `[0, N)`, где `N` представляет собой максимальное количество наборов тестов. Опять же, граница сверху, но, скажем, сто наборов в каждой коллекции тестов должно хватить многим.
Если прошлый раз всю «грязную работу» за нас выполнял компилятор, то на этот раз настал черёд поработать компоновщику (он же «linker»). В каждой единице трансляции необходимо определять точку входа, используя тот самый идентификатор файла, а в главном файле коллекции тестов проверять символы на наличие и вызывать их.
Одним из возможных вариантов является использование [«слабых символов»](https://en.wikipedia.org/wiki/Weak_symbol). В этом случае функции почти везде определяются как обычно, но в главном файле они помечаются атрибутом [`weak`](http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bweak_007d-attribute-3192) (как-то так: `__attribute__((weak))`). Очевидным недостатком является требование наличия поддержки слабых символов со стороны компилятора и компоновщика.
Если немного подумать о структуре слабых символов, то становится заметна их схожесть с указателями на функции: неопределённые слабые символы равны нулю. Получается, что можно и вовсе обойтись без них: достаточно определить указатели на функции как и ранее, но без ключевого слова `static`. Использование указателей в явной форме приносит также дополнительную выгоду в виде отсутствия автоматически сгенерированного имени в списке фреймов стека.
На этом первое отличие от наборов тестов можно считать сведенным к уже известному решению. Остаётся определение отношения порядка между единицами трансляции. В самом файле недостаточно информации для выполнения этой задачи, поэтому необходима информация извне. Здесь для каждой системы сборки будут свои детали реализации, ниже же будет приведён пример для [GNU/Make](https://www.gnu.org/software/make/).
Определение самого порядка достаточно тривиально, пусть это будет позиция имени файла в отсортированном списке всех файлов, составляющих коллекцию тестов. Не стоит переживать о вспомогательных файлах без тестов, они не помешают, как максимум, создадут пропуски в нумерации, что несущественно. Передаваться же эта информация будет через макро-определение с помощью флага компилятора (`-D` в данном случае).
Собственно, функция определения идентификатора:
```
pos = $(strip $(eval T := ) \
$(eval i := 0) \
$(foreach elem, $1, \
$(if $(filter $2,$(elem)), \
$(eval i := $(words $T)), \
$(eval T := $T $(elem)))) \
$i)
```
Первым аргументом ожидается список всех имён файлов, а вторым имя текущего файла. Возвращает индекс. Функция не самая тривиальная на вид, но работу свою она выполняет исправно.
Добавление идентификатора `TESTID` (здесь `$(OBJ)` хранит список объектный файлов):
```
%.o: %.c
$(CC) -DTESTID=$(call pos, $(OBJ), $@) -c -o $@ $<
```
На этом практически все трудности преодолены и остаётся только использовать идентификатор в коде, например, так:
```
#define FIXTURE() \
static void fixture_body(void); \
void (*CAT(fixture_number_, TESTID))(void) = &fixture_body; \
static void fixture_body(void)
```
В главном файле коллекции тестов должны быть соответствующие объявления и их обход.
#### Оставшиеся трудности
При увеличении количества файлов выше установленного предела, некоторые из них могут «выпасть» из нашего поля зрения как это могло случится с тестами. На этот раз для решения потребуется дополнительная проверка времени компиляции. При заранее известном количестве файлов в коллекции легко проверить не будут ли они лишними. По сути, достаточно предоставить каждой единице трансляции доступ к этой информации с помощью ещё одного макроса:
```
... -DMAXTESTID=$(words $(OBJ)) ...
```
Останется только добавить проверку наличия достаточного количества объявлений с помощью чего-то вроде:
```
#define STATIC_ASSERT(msg, cond) \
typedef int msg[(cond) ? 1 : -1]; \
/* Fake use to suppress "Unused local variable" warning. */ \
enum { CAT(msg, _use) = (size_t)(msg *)0 }
```
Присутствует несколько менее очевидная проблема конфликта (двойного определения) функций при добавлении/удалении файлов наборов тестов. Подобные изменения вызывают смещение индексов и требуют перекомпиляции всех файлов, которые были этим затронуты. Тут стоит вспомнить проверку дат модификации файлов системами сборки и обновление даты каталога при изменении его состава, т.е. фактически к каждому компилируемому файлу необходимо добавить зависимость от директории, в которой он расположен.
В итоге, правило компиляции файла с тестами принимает подобный вид:
```
%.o: %.c $(dir %.c)/.
$(CC) -DTESTID=$(call pos, $(OBJ), $@) -DMAXTESTID=$(words $(OBJ)) -c -o $@ $<
```
Собрав всё вместе, можно наблюдать следующее преображение определения коллекции тестов:
| | |
| --- | --- |
| Коллекция тестов до:
```
void addition_tests(void);
void deletion_tests(void);
void expansion_tests(void);
static void
setup(void)
{
/* ... */
}
static void
all_tests(void)
{
addition_tests();
deletion_tests();
expansion_tests();
}
int
main(int argc, char *argv[])
{
suite_setup(setup);
return run_tests(all_tests) == 0;
}
```
| Коллекция тестов после:
```
DEFINE_SUITE();
SETUP()
{
/* ... */
}
```
|
### Дополнительные оптимизации
Необходимость в периодической перекомпиляции и некоторое замедление обработки каждого файла заставляют задуматься о способах компенсации этих издержек. Напомним некоторые из имеющихся возможностей.
*Предкомпилированный заголовок.* Раз сложный код долго обрабатывается компилятором, будет логично подготовить результат обработки один раз и переиспользовать его.
*Использование [ccache](https://en.wikipedia.org/wiki/Ccache) для ускорения повторной компиляции.* Хорошая идея сама по себе, например, позволяет переключаться между ветками репозиториев неограниченное количество раз и не ждать полной перекомпиляции: суммарное время будет определятся в первую очередь скоростью вытаскивания данных из кеша.
*-pipe флаг компилятора* (если поддерживается). Уменьшит количество файловых операций за счёт использования дополнительной оперативной памяти.
*Отключение оптимизации и исключение отладочной информации.* В обычной ситуации это не должно никак сказаться на работе тестов, кроме некоторого ускорения процесса компиляции.
К чему это всё здесь? Возможное ухудшение производительности компиляции упоминалось выше несколько раз и хочется предоставить средства борьбы с этим, а также несколько сгладить эффект парой замечаний:
* Падение производительности в первую очередь заметно при полной пересборке тестов и в штатной ситуации не настолько критично.
* До применения описанного выше подхода к тестам, время полной пересборки тестов (с последующим запуском) в случае автора составляло 6,5 сек. После — увеличилось до 13 сек., но оптимизации как кода объявления тестов так и процесса их сборки исправили ситуацию, улучшив показатель до 5,5 сек. Ускорение процесса сборки прежней версии тестов улучшило время до 5,7 сек., что (на удивление) даже немного больше времени компиляции текущего варианта.
### Ссылки
Изначально для написания тестов использовался [seatest](https://code.google.com/p/seatest/), в котором устраивало практически всё, но недоставало авто-регистрации. По результатам вышеописанной деятельности на основе seatest был сделан [stic](https://github.com/xaizek/stic) (там используется немного C99, но это не является обязательным в общем случае), добавляющий недостающее с точки зрения автора. Именно там можно посмотреть опущенные здесь детали реализации, а именно в заголовочном файле [stic.h](https://github.com/xaizek/stic/blob/master/src/stic.h). Избранные промежуточные зарисовки доступны в [отдельном репозитории](https://github.com/xaizek/c-test-auto-reg). Пример интеграции можно найти вот в этом [Makefile](https://github.com/vifm/vifm/blob/839e21393a04035e014bd3343a3162404e98de60/tests/Makefile) (для его понимания требуется знание синтаксиса).
### Итоги
Судя по [списку в Wikipedia](https://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C), stic может быть первой успешной попыткой реализации авто-регистрации средствами C (естественно, с оглядкой на описанные ограничения). Все проверенные альтернативы включают внешние генераторы списка тестов (**UPD:** в [комментариях](http://habrahabr.ru/post/252439/#comment_8321601) подсказывают о способе регистрации тестов близком к реализации вызова статических конструкторов в C++, что, впрочем, требует наличия соответствующей поддержки со стороны компилятора и компоновщика, но сам подход определённо заслуживает внимания). Достоинство данного способа не только в отсутствии дополнительных зависимостей, но ещё и универсальности (компилятор не сделает ошибку из-за `#ifdef`, в отличии от стороннего скрипта) и относительной простоте сбора дополнительных данных о тестах. Например, было довольно просто добавить предикат запуска теста в виде:
```
TEST(os_independent)
{
/* ... */
}
TEST(unix_only, IF(not_windows))
{
/* ... */
}
```
Пусть каждый решает для себя сам, но автору однозначно понравился способ, процесс и результат, который теперь заменил собой seatest, упростил процесс добавления тестов и сократил объём тестов аж на 3911 строк, что составляет примерно 16% от их прежнего размера. | https://habr.com/ru/post/252439/ | null | ru | null |
# Реализация простейшей стратегии инвестирования на базе API MOEX (Московской биржи)
### Введение
В это горячее время криптовалют стоит помнить не только о высоких мгновенных спекулятивных доходах, но и о том, что ваши деньги могут работать и зарабатывать всю вашу жизнь. Являясь приверженцем фундаментального анализа при выборе объектов инвестирования я уже несколько лет предпочитаю хранить деньги в ценных бумагах. Я прошел через несколько этапов формирования инвестиционного портфеля, подходящего моей психологической устойчивости, несколько раз пересматривал состав портфеля, и постепенно пришел к тому, что имею сейчас.
**Сущность стратегии:** с помощью простейшего технического анализа в виде слежения за простыми скользящими средними вы находите точку смены тренда и продаете или покупаете актив. Я ни в коем случае не агитирую за то, чтобы вы сразу бросались и начинали торговать на бирже, потому что это 100% работает. Это работает только(!) в комплексе с пониманием фундаментальных процессов происходящих в компании.
### Два варианта применения стратегии
***Первый вариант***
Не буду вдаваться сейчас в интереснейшие дебри теории формирования правильного инвестиционного портфеля, расскажу лишь о такой вещи, как ребалансировка. **Ребалансировка** — периодическое выравнивание пропорций активов в портфеле с помощью продажи подорожавших и покупки подешевевших активов. Есть некоторые споры насчет эффективности этого действия, но я придерживаюсь позиции, что это хорошая практика. Остается вопрос — как проводить и в какое время.
Некоторые считают, что ребалансировать нужно в определенный месяц и весь портфель, другие считают, что надо ловить удобные моменты (к сожалению это не всегда удается). Поэтому я стараюсь комбинировать эти два подхода при реализации ребалансировки.
***Второй вариант***
Также, у каждого инвестора есть подавленный спекулянт, и эта спекулятивная жилка периодически просыпается в каждом из нас. Конечно, лучше всего, если она просыпается в спокойное время, а не во время коррекции, когда мозг упорно убеждает «Продавай-продавай-продавай». Чтобы накормить нашего внутреннего спекулянта, мы можем пользоваться простейшей стратегией, которой пользуются очень многие трейдеры и в то же время она является достаточно простой и надежной. Стратегия **«следования тренду»** ([описание](http://stocktrainer.ru/skolzyashhie-srednie-ma/)). Может быть вы встречались ранее с этими терминами, например на рынке форекс или на других около рыночных ресурсах, но с точки зрения комбинации спекуляции + инвестирование есть существенное отличие, которое заставляет посмотреть на эту стратегию с другой стороны.
Приведу в пример парочку компаний за которыми я слежу и считаю их достаточно хорошими в фундаментальном смысле (хороший бизнес, отчетность, наличие дивидендов):
**Пример 1:** Enel
**Пример 2:** Аэрофлот
Красными кружками отмечены точки пересечения двух скользящих средних с разными периодами, что является сигналом к тому, что тренд достаточно крепкий и можно принимать решение о действии(покупки\продажи), в соответствии с фундаментальной обстановкой. Например, аэрофлот можно было бы продать на квартал, именно из за его последнего квартального отчета. Многим спекулянтам достаточно этого фактора, чтобы начать продажу. Для долгосрочного же инвестора это является сигналом к тому, что можно хорошо усреднить среднюю стоимость покупки(докупить бумагу по меньшей цене) или сделать ребалансировку.
### Техническая часть
Так как я не любитель просиживать штаны за терминалом, а мой брокер не предоставляет функций слежения за трендами, то я решил изучить доступное описание [API Московской биржи](http://www.moex.com/a2193), [справочник запросов](http://iss.moex.com/iss/reference/) и написать скрипт, который будет информировать меня о смене тренда для интересующих меня инструментов(читать «всех ценных бумаг из которых состоит портфель») по почте.
Для начала был написан небольшой класс:
**Код класса**
```
class emitent {
public $name;
public $cost; //текущая цена
public $trand; //направление тренда
public $closeCost; //цена закрытия
public $average50; //значение скользящей средней 50 дней
public $average15; //значение скользящей средней 15 дней
public function getPrice($emitent,$format){
$uri = 'https://iss.moex.com/iss/engines/stock/markets/shares/securities/'.$emitent.$format;
$result = file_get_contents($uri);
$resultObject = json_decode($result,true);
/* @var $resultObject type */
$this->cost = $resultObject['marketdata']['data'][2][12];
return $this->cost;
}
public function getAverage50($emitent,$format){
$historyPrice = [];
$historydata = [];
$date1 = date("y-m-d",strtotime("-1 days"));
$date2 = date("y-m-d",strtotime("-100 days"));
$uri = 'https://iss.moex.com/iss/history/engines/stock/markets/shares/boards/TQBR/securities/'.$emitent.$format.'?from='.$date2.'&till='.$date1;
$result = file_get_contents($uri);
$resultObject = json_decode($result,true);
$historydata = $resultObject['history']['data'];
$historydata_reverse = array_reverse($historydata);
for ($i=0;$i<50;$i++){
array_push($historyPrice,$historydata_reverse[$i][11]);
}
$average50 = array_sum($historyPrice)/count($historyPrice);
return $average50;
}
public function getAverage15($emitent,$format){
$historyPrice = [];
$historydata = [];
$date1 = date("y-m-d",strtotime("-1 days"));
$date2 = date("y-m-d",strtotime("-50 days"));
$uri = 'https://iss.moex.com/iss/history/engines/stock/markets/shares/boards/TQBR/securities/'.$emitent.$format.'?from='.$date2.'&till='.$date1;
$result = file_get_contents($uri);
$resultObject = json_decode($result,true);
$historydata = $resultObject['history']['data'];
$historydata_reverse = array_reverse($historydata);
for ($i=0;$i<15;$i++){
array_push($historyPrice,$historydata_reverse[$i][11]);
}
$average15 = array_sum($historyPrice)/count($historyPrice);
return $average15;
}
}
```
Из тонких моментов, которые я взял из справочника:
```
https://iss.moex.com/iss/history/engines/stock/markets/shares/boards/TQBR/securities/
```
**History** — запрос цен из нужного периода времени
**Stock** — торговая система(engines) «Фондовый рынок и рынок депозитов»
**Shares** — конкретный рынок(markets) «Рынок акций»
**TQBR** — конкретный режим торгов(boards) «Т+ Акции и ДР»
Ответ сервера или json или xml. Вы получаете массив с данными. Данные в массиве могут варьироваться в зависимости от запроса, который вы посылаете. Описание полей массивов хранятся в тех же данных в блоке «COLUMNS». Значения — в блоке «DATA».
Полное описание всех полей, относящимся, например, к рынку акций, можно посмотреть на [этой странице](http://www.micex.ru/iss/engines/stock/markets/shares).(Кстати, нашел я это описание только при подготовке статьи).
> **Замечание.** Если вы берете промежуток больше 100 дней, то там надо делать несколько запросов, перемещая указатель массива. Ситуация описана на последней странице Руководства Moex API
После этого был написан сам скрипт (*за качество кода палками прошу не бить*):
**Код скрипта**
```
require_once ($_SERVER["DOCUMENT_ROOT"].'/classes.php');
$file = 'portfolio.json'; //Сохраненные данные по прошлым трендам
$portfolio = json_decode(file_get_contents($file), true);
foreach ($portfolio as &$emitent) {
$sending_mail = false;
$emitentMoex = new emitent();
$emitentMoex->name = $emitent[0];
$emitentMoex->trand = $emitent[1];
$format = '.json';
$price = $emitentMoex ->getPrice($emitentMoex->name, $format);
$history15 = $emitentMoex ->getAverage15($emitentMoex->name, $format);
$history50 = $emitentMoex ->getAverage50($emitentMoex->name, $format);
if ($history15<$history50){
$trend_course = "Тренд вниз";
$trand_course_bool = false;
} else {
$trend_course = "Тренд вверх";
$trand_course_bool = true;
}
if ($trand_course_bool != $emitentMoex->trand){
$sending_mail = true;
$trend_course .='. Тренд изменился';
(boolean)$emitent[1] = $trand_course_bool;
}
if ($sending_mail){
$date = date("y-m-d");
$headers = "Content-type: text/html; charset=UTF-8 \r\n";
$headers .= "From: Change trands alert \r\n";
$message = "Эмитент: ".$emitentMoex->name."
"."Цена сейчас: ".$price. "
"."Средняя на 15: ".$history15."
"."Средняя на 50: ".$history50."
".$trend\_course;
mail("yourmail@box.com", 'test'.$date , $message,$headers);
}
}
file\_put\_contents($file, json\_encode($portfolio,true));
?>
``` | https://habr.com/ru/post/343688/ | null | ru | null |
# Приостанавливаем выполнение приложения, если пропало соединение с сетью
Под катом, небольшая заметка о том, как приостановить выполнение вашего приложения при обрыве связи с интернетом и продолжить — когда она будет восстановлена.
Представим, что ваше, гипотетическое приложение, должно выполнить очередь http запросов. При чем каждый следующий зависит от результата предыдущего.
```
async function main () {
let url = ' ... '
while (url) {
const resp = await fetch(url)
const json = await resp.json()
url = json.url
}
}
```
Но если посреди этого процесса пропадёт связь с интернетом, то очередь прервётся. Давайте исправим это.
Для начала напишем функцию, которая будет возвращать промис, который будет решатся, в момент, когда клиент возобновит соединение:
```
function awaitOnline () {
return new Promise(resolve => {
// Если клиент уже online — немедленно возвращаем результат
if (navigator.onLine) {
resolve()
return
}
// Регистрируем обработчик и решаем промис как только клиет будет online
window.addEventListener(
'online',
() => resolve(),
{once: true} // Автоматически удаляем обработчик после первого события
)
})
}
```
Теперь добавим её в наш основной код
```
async function main () {
let url = ' ... '
while (url) {
await awaitOnline() // Выполнение приостановится в этом месте до момента возобновления сети
const resp = await fetch(url)
const json = await resp.json()
url = json.url
}
}
```
Таким простым образом, при каждой итерации наш алгоритм будет проверять статус сети, и встанет на паузу если соединения не будет. И автоматически продолжит выполнение с того же места, как только связь будет восстановлена.
Конечно, это не панацея. Но такой, небольшой хак, сделает ваше приложение чуть более отказоустойчивым. | https://habr.com/ru/post/436426/ | null | ru | null |
# React hooks, как не выстрелить себе в ноги. Часть 1: работа с состоянием
Статья поможет новичкам понять как работать с хуками, а также будет полезна и опытным разработчикам. Этой статьей открываю серию статей про хуки.
Использование хуков с одной стороны позволяет использовать методы жизненного цикла в функциональных компонентах и призваны улучшать производительность, что делает функциональные компоненты полноценным конкурентом классовых компонентов. С другой стороны, неправильное использование хуков приводит к лишним операциям и может свести на нет все преимущества функциональных компонентов.
В этой серии статей разберем основные хуки реакта и как их **правильно** использовать.
В серии статей поговорим про:
* useState, как работать с состоянием компонента, что такое "бетчинг" (batching) и для чего в качестве аргумента можно передать функцию;
* useEffect и как использовать cleanup и useLayoutEffect;
* useMemo, useCallback и почему они напрямую касаются hoc memo. Разберем ситуации когда их нужно и не нужно использовать;
* Context, useContext, когда использовать и улучшать производительность;
* useRef, использование в качестве ссылки и безопасной переменной, forwardRef и useImperativeHandle;
* useReducer как альтернатива useState и признаки, что пора его использовать. Также разберем нестандартных 2 случая использования useReducer;
В этой статье поговорим про:
* Что из себя представляют хуки.
* Базовое использование useState,
* Асинхронность функции setState,
* Что происходит когда новое состояние равно предыдущему,
* В качестве начального состояния используем функцию,
### Понятие хуков
Хук или по-русски крючок - это функция, которая вызывается в теле **функционального** компонента.
Как и любая функция, хук может принимать аргументы и возвращать значение.
**Пример хука, который возвращает значение:**
```
const [state, setState] = useState();
```
**Пример хука, который принимает аргументы:**
```
useEffect(() => {}, []);
```
**Пример хука, который, и принимает аргументы, и возвращает значение:**
```
const [state, setState] = useState(initialValue);
```
Реакт под капотом регистрирует все хуки, потому они должны находиться строго до любых условий (if, switch), и все хуки должны начинаться с префикса use: **use**State, **use**Effect, **use**MyCustomHook.
### Базовое использование useState
Для работы с состоянием компонента используется useState.
```
const [state, setState] = useState(initialValue);
// StateType - это тип состояния, можно использовать как примитивы:
// boolean, string, number
// так и объекты { test: number }, массивы Array
// и вообще любые типы данных
```
Этот хук возвращает массив из двух элементов: **состояния** и **функции изменения состояния** `[state, setState]`, принимает начальное состояние: `useState(initialValue)`.
Внутри компонента используется так:
```
import React, { useState, FC } from "react";
export const ExampleFuncComponent: FC = () => {
const [state, setState] = useState(true);
return (
{state.toString()}
setState(true)}> {/\* 1 \*/}
установить true
setState(false)}> {/\* 2 \*/}
установить false
setState(prevState => !prevState)}> {/\* 3 \*/}
изменить состояние на противоположное
);
};
```
`state` - это обычная переменная, с нем можно работать, как и с любой другой переменной: `state.toString()`Может быть любым типом данных. Не пытайтесь изменять состояние вручную `state = newState`, это нарушит работу вашего приложения. Единственный правильный путь - использовать функцию `setState`.
`setState` - это функция, которая принимает **новое** **состояние** (метка 1 и 2), либо **функцию**, которая принимает **предыдущее состояние** и возвращает **новое состояние** (метка 3). Главное - вызов функции запускает весь код функционального компонента повторно. В примере выше весь код, начиная с 3 по 16 строку будет вызван еще раз.
Кстати, как считаете можно ли использовать другие названия переменных, кроме `state` и `setState`? Например `value` и `setValue`?
```
const [state, setState] = useState(true);
const [value, setValue] = useState(true);
```
Даю 3 секунды подумать.
3
2
1
Названия может быть любыми, более того часто в одном компоненте используется несколько `useState` и потому необходимо давать им разные названия.
### Асинхронность setState
`setState` - асинхронная функция. Под капотом реакт объединяет все мутации состояний, благодаря чему код функционального компонента будет вызван 1 раз, это называется "batching". Есть хорошая [статья](https://dev.to/shivamjjha/batching-in-react-4pp3) на эту тему.
```
import React, { useState, FC } from "react";
export const ExampleFuncComponent: FC = () => {
const [visible, setVisible] = useState(true);
const [count, setCount] = useState(0);
const onClick = () => {
setVisible((v) => !v);
setCount((v) => v + 1);
// уже обратили внимание,
// что необязательно называть переменную prevState?
};
console.log("update");
return (
{visible.toString()}
test
);
};
```
Консоль на строке 12 будет вызвана при монтировании компонента 1 раз и только 1 раз после нажатия на кнопку.
У этой особенности есть следствие. Как считаете, на сколько изменится счетчик при нажатии на кнопку `test 0` и `test 1`?
```
import React, { useState, FC } from "react";
export const ExampleFuncComponent: FC = () => {
const [count, setCount] = useState(0);
const onClick0 = () => {
setCount(count + 1);
setCount(count + 1);
setCount(count + 1);
};
const onClick1 = () => {
setCount((v) => v + 1);
setCount((v) => v + 1);
setCount((v) => v + 1);
};
return (
{count.toString()}
test 0
test 1
);
};
```
При нажатии на `test 1` счетчик увеличится на 3, а при нажатии на `test 0` только на 1. Почему это происходит:
```
// Например count = 0
const onClick0 = () => {
// count + 1 = 0 + 1;
setCount(count + 1);
// Здесь можем ожидать, что count уже 1, но т.к. вызов setState асинхронный
// состояние еще не изменено, поэтому count по-прежнему 0
// count + 1 = 0 + 1;
setCount(count + 1);
// count + 1 = 0 + 1;
setCount(count + 1);
};
```
Поэтому если новое состояние опирается на предыдущее состояние, используйте функцию:
```
const onClick1 = () => {
setCount(v => v + 1);
setCount(v => v + 1);
setCount(v => v + 1);
};
```
### Новое состояние равно предыдущему
Взгляните еще раз на этот код:
```
import React, { useState, FC } from "react";
export const ExampleFuncComponent: FC = () => {
const [state, setState] = useState(true);
return (
{state.toString()}
setState(true)}>
установить true
setState(false)}>
установить false
setState(prevState => !prevState)}>
изменить состояние на противоположное
);
};
```
Нажмем кнопку `установить false` 3 раза, как думаете сколько раз обновится компонент?
Даю 3 секунды подумать:
3
2
1
Компонент обновится только 1 раз. Под капотом происходит сравнение предыдущего состояние и нового `prevState === newState`, если результатом будет `true`, компонент не будет обновляться.
Теперь вопрос, если новое состояние объект, будет обновляться компонент или нет? `setState({});`
3
2
1
Замените `prevState === newState` на `{} === {}` и станет очевидно, что обновление будет происходить, потому что объекты, массивы и функции - это ссылочные типы данных: даже когда они выглядят одинаково, они ссылаются на разные ячейки памяти, поэтому они не равны.
Если мы не хотим обновлять состояние когда объекты равны по содержимому, можно сравнить предыдущее состояние с текущим и если они равны, использовать предыдущее.
```
import React, { useState, FC } from "react";
export const SetSameLink: FC = () => {
const [state, setState] = useState({ test: "some" });
const mutate = (obj) => {
setState((prevState) => {
// Нужно проверить все свойства объектов, в нашем случае
// это свойство test
if (prevState.test === obj.test) return prevState;
return obj;
});
};
return (
{JSON.stringify(state)}
mutate({ test: "some" })}>
set state
);
};
```
Обратите внимание, если хотим чтобы не произошло обновления компонента, нужно вернуть предыдущее состояние `return prevState`, а не его копию `return { ...prevState }`.
Сравнивать по отдельности каждое свойство объектов неудобно, для этих целей рекомендую библиотеку [fast-deep-equal](https://www.npmjs.com/package/fast-deep-equal).
### Начальное значение - функция
В качестве начального значения useState может принимать не только само значение, но и функцию, которая вернет начальное значение.
**Типы useState:**
```
function useState~~(initialState: S | (() => S)):
[S, Dispatch>];~~
```
Один из вариантов, когда хотим переиспользовать некоторую функцию, которая возвращает состояние. Например, когда берем начальное состояние из локального хранилища браузера:
```
const getStoredState = () => {
return localStorage.getItem('my-saved-state');
};
// Где-то в функциональном компоненте
const [state, setState] = useState(getStoredState);
// Где-то в другом месте
getStoredState();
```
Обратите внимание, необязательно в useState передавать результат вызова функции, достаточно передать функции и он сам ее вызовет: `useState(getStoredState())` → `useState(getStoredState)`.
Второй вариант - когда обрабатываем какие-то данные перед тем, как записать их в качестве начального состояния. Например, компонент принимает в качестве пропсов какие-то данные, но внутри себя, преобразовывает их в другую структуру.
```
import React, { useState, FC } from "react";
type TestComponentProps = {
data: object;
}
const prepareData = (data: object): OtherData => {
console.log('prepareData'); /* 1. как часто будет вызываться prepareData? */
return otherData; // какие-то другие данные (не рабочий код)
}
export const TestComponent: FC = ({ data }) => {
const [state, setState] = useState(prepareData(data));
return (
{JSON.stringify(state)}
setState(['some key'])}>
set state
);
};
```
Важно понимать, что при любом обновлении компонента, выполняется весь код этого компонента, в том числе и `prepareData`. Однако начальное значение состояние принимается только при монтировании компонента, при других обновлениях компонента - игнорируется. Потому функция `prepareData` будет выполняться всегда, хотя ее результат будет использован только 1 раз. Это ухудшает производительность. Что нужно сделать?
```
import React, { useState, FC } from "react";
type TestComponentProps = {
data: object;
}
const prepareData = (data: object): OtherData => {
console.log('prepareData');
return otherData; // какие-то другие данные (не рабочий код)
}
export const TestComponent: FC = ({ data }) => {
// достаточно в качестве initialState передавать не prepareData(data)
// а функцию, которая вернет prepareData(data)
const [state, setState] = useState(() => prepareData(data));
return (
{JSON.stringify(state)}
setState(...)}>
set state
);
};
```
Достаточно в качестве initialState передавать не `prepareData(data)`, а функцию, которая вернет `prepareData(data)`.
### Заключение
Хук (по-русски крючок) - это функция. Как и любая функция, он может принимать аргументы и возвращать значение. Реакт регистрирует все хуки компонента, потому они должны быть до любых условий (if, switch) и начинаться с префикса **use**.
Хук useState возвращает массив из двух элементов (состояние, функция изменения состояние), а принимает начальное состояние.
Состояние - может быть чем угодно: строкой, числом, массивом и т.д. и с ним можно работать как с любой другой переменной, но изменять только с помощью функции изменения состояния.
Функция изменения состояния, принимает как новое значение `setState(newState)`, так и функцию, которая получает предыдущее состояние, а результат ее вызова будет новым состоянием: `setState(previosState => newState)`.
Функция изменения состояния - асинхронна, реакт объединяет несколько изменений состояния в один цикл обновления компонента. Потому любые счетчики `setState(prevCount => prevCount + 1)`, переключатели `setState(prevValue => !prevValue)` должны опираться на предыдущее состояние, иначе это может привести к непредсказуемым ошибкам.
Хук useState обновляет компонент только если новое состояние не равно предыдущему. Проверка осуществляется по строгому равенству `prevState === newState`.
В качестве начального состояния можно передавать функцию, которая вернет начальное состояние `useState(getStoredState)`. Это удобно, когда нам нужно переиспользовать эту функцию.
Если статья показалась полезной и интересной, ставьте палец вверх. Если есть вопросы - пишите в комментариях.
Также хочу пригласить всех желающих на бесплатный урок, который проведет мой коллега на платформе OTUS. В рамках урока вы узнаете для чего разработчику на React.js умение писать тесты и как применять React Testing Library в процессе разработки.
[Зарегистрироваться на урок.](https://otus.pw/nhnE/) | https://habr.com/ru/post/667706/ | null | ru | null |
# Кидхак Prehistorik 2: анлочим уровни
#### Любителям этой замечательной игры посвящается...
[](http://plewick.deviantart.com/art/Prehistorik-2-282430653)
… Если таковые еще есть. Впрочем, я уверен, что не все так плохо и Crysis не поглотил мозг человечества целиком и окончательно.
Так вот, вышеупомянутые любители старых игр и в частности одной замечательной игры 92 года могут помнить, что система сохранений в игре сделана в несколько приставочном духе: по уровням разбросаны (иногда в довольно неожиданных и труднодоступных местах) коды, которые во времена MS-DOS старательно записывались на бумажечку и хранились, как сокровище. Код, введенный в главном меню, позволял начать соответствующий уровень со стартовой позиции.
*Soshite*, в наше время появилась, в некотором роде, проблема для тех, кто хотел бы поиграть в Prehistorik 2. А именно — необходимость эмулировать игру в Dosbox: далеко не у всех есть возможность найти на свалке или, что еще гораздо реже, вытащить с антресолей заботливо хранящийся там 486-й.
Дело в том, что при генерации кодов игра использует переменные окружения BIOS. Как это эмулируется в Dosbox, я не разбирался, знаю достоверно, что при каждом новом запуске эмулятора коды в игре другие. Соответственно, бумажка с кодами становится бесполезной, а возможность приятного и ненапрягающего прохождения игры сводится практически на нет: полностью игру можно пройти только за один присест. Возможно, это решается детальной настройкой Dosbox. Но это менее интересно, чем небольшое копание в исполняемом файле игры.
#### Постановка задачи
Реализовать небольшой хак, в результате которого олдгеймер ~~вроде меня~~ мог бы вместо кода ввести просто номер желаемого уровня. [Перейти сразу к результатам.](#results)
#### Решение
Больше всего времени у меня отняла распаковка файла игры. К изначально запакованному коду игры было добавлено интро команды, взломавшей когда-то защиту от копирования, и затем все это было снова запаковано другим алгоритмом. За помощью в распаковке я обратился к статье г-на Гречникова: [habrahabr.ru/post/187072](http://habrahabr.ru/post/187072/), в которой меня заинтересовал раздел под заголовком «Распаковка», а конкретно следующий абзац:
> То есть, остаток процедуры loc\_19960 не вызывается, если передать в командной строке параметр /ni. Пробуем, видим, что с этим параметром игра пропускает напоминание о доблестной команде Hybrid и сразу переходит к собственно игре. Делаем вывод, что весь seg002 — ненужная для игры заставка, навешенная на рабочий exe'шник. Переписываем в заголовке cs:ip на 0000:0003, ss:sp на 1681:0080, обрезаем последние 5E90h байт, соответственно скорректировав поля размера и дополнительной памяти в заголовке.
*(Дальше было неинтересно, т.к. готовое решение — это не то, чего мне хотелось.)*
После того, как я последовал данному совету, я обнаружил яйцо в утке, извлеченной ранее из зайца… или как там в старинных русских сказках обычно бывало? Проще сравнить это с матрешкой:
После распаковки diet программа выросла до 90 Кб и уже ничто не мешало запустить в нее грязные лапы. Чем я и занялся, открыв Hiew и сразу же найдя интересующую меня строку:
Уточню для таких же, как я, набирающихся опыта (хотя учиться стоит всегда), что поиск строки в Hiew — это сразу после запуска F4 — Hex, F7 — ASCII -> «Интересующая нас строка».
Адрес строки — **15401**. Теперь мне нужно узнать, в каком месте программы происходит обращение к этой строке. Естественно, что такие обращения с высокой долей вероятности будут близки к той части, которую я вознамерился ломать.
Как это можно узнать? Путей, на самом деле, множество. Можно открыть файл в Ida Pro и изучить перекрестные ссылки. Правда, вначале настроив Ida так, чтобы она дружила с используемым типом строк. Но поскольку Id'у я не смог подружить с Dosbox'ом на таком уровне, чтобы можно было спокойно и без раздражающих факторов отлаживать 16-битные файлы (Dosbox постоянно забывал, что он отладчик и пытался жить своей жизнью, несмотря на патч и плагин), то я решил вообще не использовать такую тяжелую артиллерию там, где нужно, скорее всего, просто подправить несколько байт.
Поэтому поступим проще. Чтобы выяснить, где используется смещение на эту строку в программе, нужно сначала выяснить само смещение. Для этого нужно узнать базу сегмента данных. В Hiew это более чем просто. Жмем F8 и смотрим заголовок файла.
Итак, для начала откроем калькулятор, переключимся в шестнадцатиричную систему и введем в него значение Paragraphs in header: 86, после чего умножим на 10. Скопируем это значение в буфер и вернемся в Hiew, где все еще не закрыто окошко заголовка. Не выходя, нажмем F5 для перехода в точку входа. И вот тут уже перейдем в режиме decode (F4 — decode). Перед нами такой листинг:
листинг 1.
```
00000468: FA cli
00000469: FC cld
0000046A: BAFFFF mov dx,0FFFF ;" "
0000046D: BE8000 mov si,00080 ;" А"
00000470: AC lodsb
00000471: 98 cbw
00000472: 8BC8 mov cx,ax
00000474: E35E jcxz 0000004D4 ---↓ (1)
00000476: AC lodsb
00000477: 3C2F cmp al,02F ;"/"
00000479: 7404 je 00000047F ---↓ (2)
0000047B: E2F9 loop 000000476 ---↑ (3)
0000047D: EB55 jmps 0000004D4 ---↓ (4)
0000047F: AC lodsb
00000480: 24DF and al,0DF ;"▀"
00000482: 3C46 cmp al,046 ;"F"
00000484: 7506 jne 00000048C ---↓ (5)
00000486: 2E83260300FE and w,cs:[0003],0FFFE ;"■"
0000048C: 3C4D cmp al,04D ;"M"
```
Все это нам неинтересно. Нам интересно присвоение значения регистру ds. Даже не прибегая к поиску, мы прокручиваем экран совсем немного вниз и находим искомое:
листинг 2.
```
000004D4: B8030A mov ax,00A03 ;"◙"
000004D7: 8ED8 mov ds,ax
```
Вытаскиваем 00А03 и запихиваем в калькулятор, где тоже умножаем на 10 и прибавляем к сохраненному ранее в буфере значению. Получаем **А290**. А теперь вычтем А290 из 15401: **В171**. Это смещение строки, которое будет использоваться внутри программы. Теперь переходим в гекс-отображение (F4 — Hex) и жмем F7, куда в строку, поименованную басурманским словом «Нех», введем 71 В1 (байты идут в обратном порядке, помним ведь?). Выходим на следующий листинг:
листинг 3.
```
00009E23: E85801 call 000009F7E ---↓ (1)
00009E26: C606A7B103 mov b,[0B1A7],003 ;""
00009E2B: BB71B1 mov bx,0B171 ;"▒q"
00009E2E: C706A2B1F20A mov w,[0B1A2],00AF2 ;"◙Є"
00009E34: E8EDFE call 000009D24 ---↑ (2)
00009E37: C606A7B104 mov b,[0B1A7],004 ;""
00009E3C: BB6CB1 mov bx,0B16C ;"▒l"
00009E3F: C706A2B1C912 mov w,[0B1A2],012C9 ;"╔"
00009E45: E8DCFE call 000009D24 ---↑ (3)
00009E48: 803EA6B101 cmp b,[0B1A6],001 ;""
00009E4D: 7503 jne 000009E52 ---↓ (4)
00009E4F: E90001 jmp 000009F52 ---↓ (5)
00009E52: 803EA6B102 cmp b,[0B1A6],002 ;"☻"
00009E57: 7503 jne 000009E5C ---↓ (6)
00009E59: E90601 jmp 000009F62 ---↓ (7)
00009E5C: 8A1E7028 mov bl,[2870]
00009E60: F6C380 test bl,-080 ;"А"
00009E63: 7403 je 000009E68 ---↓ (8)
00009E65: E91501 jmp 000009F7D ---↓ (9)
00009E68: A02928 mov al,[2829]
00009E6B: 0A060C28 or al,[280C]
```
В начале этого листинга происходят действия с интересующей нас строкой, а затем те же действия — с соседствующей строкой "[[[[". Пожалуй, статическим наблюдением дальше не обойдешься. Нужно прибегнуть к помощи отладчика. Чтобы не нарушать атмосферу консольности, прибегну к специальному выпуску Dosboх 0.74, содержащему в себе дебаггер. Кроме того, этот вариант гораздо стабильнее, чем костыль Ida + Dosbox plugin.
Итак, открываю Dosbox-74-debug (предварительно настроив conf-файл, где просто указаны команды монтирования директории игры и директивы ее запуска с префиксом debug). Не мудрствуя лукаво, запускаем игру в режиме трассировки и вскоре узнаем, что вот в этом месте:
листинг 4.
```
022E:014C 7B00 jpo 0000014E ($+0)
022E:014E C606A46C00 mov byte [6CA4],00
022E:0153 B80300 mov ax,0003
022E:0156 E86701 call 000002C0 ($+167)
022E:0159 E8138D call FFFF8E6F ($-72ed)
022E:015C 803E862D08 cmp byte [2D86],08
022E:0161 7234 jc 00000197 ($+34)
```
После вызова второй подфункции запускается главное меню, которое «крутится» внутри этой подфункции. Ставим бряк на входе в первую подфункцию и запускаем игру заново, отправляя поначалу в свободный полет.
Вскоре выясняется, что…
… отрисовка главного меню заканчивается на этой команде. А сразу за ней следует такой листинг:
листинг 5.
```
022E:8E99 8ED8 mov ds,ax
022E:8E9B 33C0 xor ax,ax
022E:8E9D A3EC27 mov [27EC],ax
022E:8EA0 A3EE27 mov [27EE],ax
022E:8EA3 32C0 xor al,al
022E:8EA5 3806F227 cmp [27F2],al
022E:8EA9 7548 jne 00008EF3 ($+48)
022E:8EAB 3806F327 cmp [27F3],al
022E:8EAF 7557 jne 00008F08 ($+57)
022E:8EB1 A02928 mov al,[2829]
022E:8EB4 0A060C28 or al,[280C]
022E:8EB8 7539 jne 00008EF3 ($+39)
022E:8EBA 813EEC270E01 cmp word [27EC],010E
022E:8EC0 72E3 jc 00008EA5 ($-1d)
```
Главное меню, напомню, предлагает нажать либо 1, либо 2. В листинге два перехода. В этом месте игра зацикливается между 022E:8EA5 и 022E:8EC0. Все очевидно. Установим брейкпоинты на оба варианта: **ВР 022Е:8EF3** и **ВР 022Е:8F08**, «отпустим» игру в свободный режим, нажав F5 и нажмем 2 — пункт меню, предлагающий ввести password.
Спустя некоторое время трассировки приходим к листингу 3. Строка "[[[[", отрисовывающаяся вместе с «ENTER CODE» — может быть либо строкой "\_ \_ \_ \_", которая отображается таким образом из-за хитрого шрифта, либо зарезервированным местом под код. Допустим, что верно последнее и установим брейкпойнт на обращение к памяти по смещениям подозрительных 4 байт: ВРМ 0С11: В16С, ВРМ 0С11: В16D, ВРМ 0С11: В16E и ВРМ 0С11: В16F (текущую базу сегмента данных видим в отладчике). Запускаем опять игру, в меню ввода кода нажимаем клавишу, вводя символ предполагаемого кода, и программа стопорится на листинге:
листинг 6.
```
022E:9A57 FF06A4B1 inc word [B1A4]
022E:9A5B FEC3 inc bl
022E:9A5D 80FB04 cmp bl,04
022E:9A60 7303 jnc 00009A65 ($+3)
022E:9A62 E9B800 jmp 00009B1D ($+b8)
```
> DEBUG: Memory breakpoint: 0C11:B16C — 5B -> 38
Инкрементируется какая-то переменная, затем происходит инкремент регистра и проверка, видимо, на превышение 0004, это логично связуется с необходимостью ввода 4 символов. По результатам проверки происходит переход либо на ret, либо на некую дополнительную последовательность команд. В том числе такую:
Переменная 0С11:B1B5 хранит введенный только что мною код «4789» в виде числа. Затем следует интересный участок:
листинг 7.
```
022E:9AAC 33D2 xor dx,dx
022E:9AAE 8BC2 mov ax,dx
022E:9AB0 E8A6F8 call 00009359 ($-75a)
022E:9AB3 3906B5B1 cmp [B1B5],ax
022E:9AB7 7420 je 00009AD9 ($+20)
022E:9AB9 42 inc dx
022E:9ABA 83FA14 cmp dx,0014
022E:9ABD 76EF jbe 00009AAE ($-11)
```
Обнуляются dx и ax; вызывается подфункция, после чего недавно очищенный регистр ах сравнивается с введенным кодом (в численном виде). Если они идентичны, то происходит переход куда-то вдаль, иначе dx увеличивается на единицу, и, если не превышает 14, то операции повторяются.
Логично предположить, что происходит перебор четырнадцати правильных паролей и сравнение с введенным (первые 9 уровней для сложности Beginner, остальные — для Expert, хотя эксклюзивных уровней для этой сложности только 2: Замок и Минотавр, чем отличаются другие уровни, не знаю. к примеру, по номеру 10 грузится Ледяной). Все факты подтверждают, что мы на правильном пути.
Собственно… все. Дальше идти некуда; достаточно изменить условный переход на безусловный. В принципе, было бы красиво изменить также количество вводимых символов, так как если оставить это без изменения, то придется вводить номер седьмого уровня как 0007 — ведь все же удобней будет вводить его как 07. Для этого изменим листинг 6 на следующий:
листинг 6\_1.
```
022E:9A57 FF06A4B1 inc word [B1A4]
022E:9A5B FEC3 inc bl
022E:9A5D 80FB02 cmp bl,02
022E:9A60 7303 jnc 00009A65 ($+3)
022E:9A62 E9B800 jmp 00009B1D ($+b8)
```
Искать, где и как рисуется строка из четырех черточек, чтобы заменить их на две, мне было уже лень. При том, что для отрисовки восклицательного знака из ресурса шрифтов Змиро использовал символ **<**, а для запятой — **>**, поиск «того, не знаю чего» мог оказаться весьма трудоемким. Потратив еще некоторое время на пошаговое исполнение в отладчике, можно было локализовать это место, но я не настолько перфекционист.
#### Выводы. Что сделано
[Новый исполняемый файл игры prel.exe. Не забудьте проверить на вирусы. ;)](https://www.dropbox.com/s/a1cd372lgu9x1rg/prel.exe?dl=1)
Упразднена необходимость собирать пароли по уровням. Сделан возможным выбор уровня из главного меню посредством ввода его порядкового номера из двух разрядов вместо пароля из четырех. За ненадобностью убраны из маски вводимых символов буквы латинского алфавита (A-F), оставлены возможными только цифры; добавлена проверка диапазона вводимых номеров уровней (01-14). В самом деле, зачем игрокам по ошибке или от излишнего любопытства наблюдать вылет в "*Insert disk with levelFF.sqz*" вместо загрузки уровня. Пригласительная надпись в режиме ввода пароля с «ENTER CODE» изменена на «SELECT LVL». В самом начале из игры вырезано интро Hybrids. Изменено первое интро разработчика («Yeaaa… My game is still working in...»), — дополнено информацией о Hybrids и этой модификации. Изменены строки названий сложностей.
Миниатюры кликабельны. На последней картинке: перешакаленные фотографии разработчиков игры из конца восьмидесятых и начала девяностых, появляющиеся после успешного прохождения игры на сложном уровне.
[](http://pp.vk.me/c616125/v616125788/8eae/uUH0G-1QN58.jpg)[](http://pp.vk.me/c616125/v616125788/a030/Q0GvzNs2heE.jpg)[](http://pp.vk.me/c616125/v616125788/a028/wsbePXAd9IA.jpg)[](http://pp.vk.me/c616124/v616124788/7ffd/uovRwwuM6iA.jpg) | https://habr.com/ru/post/220167/ | null | ru | null |
# Как легко запустить свой сайт-сообщество с помощью платформы Flarum
В этой статье хочу рассказать почему мне понадобилась платформа для сообщества, какие варианты реализации я нашел и за что выбрал именно Flarum. Также в статье есть пошаговая инструкция для новичков по установке данной платформы на свой хостинг.
### Зачем нужна площадка для сообщества
Сначала появился Telegram-канал [Пароль от вайфая](https://t.me/parol_ot_wifi) — канал о стиле жизни диджитал номадов и в целом об идеологии географической независимости. Затем был создан сайт [pronomad.ru](https://pronomad.ru/), агрегирующий всё полезное с канала в удобном формате. Сайт сделан в виде блога на стеке: [Eleventy](https://www.11ty.dev/) + [Netlify](https://www.netlify.com/) + [Forestry](https://forestry.io/) + [Github](https://github.com/). [Jamstack](https://jamstack.org/what-is-jamstack/) сайты работают довольно быстро и хорошо оптимизированы под SEO, поэтому хотелось чего-то подобного и для платформы для сообщества.
Со временем появилась явная нужда в обсуждениях, вопросах, обмене опытом и поддержке. И казалось очевидным решением просто создать чат в Телеграме, и ровно половина людей из канала даже проголосовали за него. Это лишний раз подтвердило необходимость создания места, где люди могут коммуницировать между собой на тему иммиграции, налогов, быта в другой стране и прочего из топика жизни за рубежом.
Но чаты в Телеграме имеют множество минусов, и главный из них это банальное неудобство. Поэтому было решено создать данное сообщество в виде сайта с настраиваемой лентой постов и с возможностью создавать аккаунт, писать свои посты и лайкать понравившийся контент. К тому же UGC (user-generated content) это очень эффективная и малозатратная функция для SEO-продвижения.
### Критерии отбора и список конкурсантов
Я начал поиск существующих решений и у меня был список критериев отбора:
* Бесплатно
* Большое сообщество вокруг платформы
* Гибкость, расширяемость, кастомизация
* Минимальный кодинг
* Кастомный домен
* Хранение на своем хостинге
* Минималистично
* Создание аккаунтов пользователей
* Поиск по сайту
* Гибкая настройка разрешений
С помощью довольно придирчивого гугления я нашел следующие платформы:
* <https://www.mobilize.io/>
* <https://peerboard.com/>
* <https://flarum.org/>
* <https://github.com/vas3k/vas3k.club>
* <https://join-lemmy.org/>
* <https://circle.so/>
* <https://www.habitate.io/>
### Почему выиграл Flarum
Мой выбор сузился до Flarum и платформы Вастрика. Платформа Вастрика хороша, но без кодинга пришлось бы ограничиваться тем, что есть. В то же время на Flarum без кодинга и на одних лишь доступных расширениях я смог добавить:
* Использование тегов
* Систему лайков
* Модерацию регистраций\постов
* Локализацию
* Счетчик просмотров
* Систему жалоб
За счет встроенной системы разрешений можно сделать сообщество еще гибче:
* Распределение пользователей на группы с разными правами
* Теги с ограниченным доступом по группам
* Полностью закрытое сообщество только для авторизованных пользователей
* Настройка модерации контента и т.д.
Полный список настроек прав доступа выглядит так:
Конечно есть вещи, которых не хватает данной платформе, но их можно добавить, написав расширение. Например, я бы не отказался от следующих функций:
* Древовидные комментарии
* Гибкая настройка полей регистрации
* Ачивки для конкретных постов
* Фильтр по двум и более тегам
* Автоматическая рассылка на основе вышедших постов
* Разные типы постов: ивент, вакансия и тп.
Возможно что-то из этого уже реализовано в составе какого-то из расширений, но их слишком много чтобы перепробовать все.
### Как установить Flarum
У Flarum есть очень подробная [инструкция](https://docs.flarum.org/install) по установке платформы, но для человека, который на Вы с программированием, она может показаться отпугивающей и доступной только опытным разработчикам. Поэтому я решил создать свою пошаговую инструкцию и показать, что Flarum может запросто установить кто угодно.
Итак, что я сделал:
1. Купил хостинг, проверил, что соответствует требованиям: версии PHP, MySQL, присутствуют модули (curl, dom, gd and etc) и что есть есть доступ по SSH
2. Создал на хостинге заготовку под сайт и выбрал для него версию PHP 7.3
3. Подключился к серверу по SSH через PuTTY (доступы взял из личного кабинета хостинга)
4. Подготовил переменные до файла php:
```
PHP_PATH=/opt/php/*ваша_версия*/bin
PHP=$PHP_PATH/php
```
5. Создал папку bin в корне, в которую буду устанавливать [Composer](https://getcomposer.org/), и перешел в нее:
```
mkdir -p bin
cd bin
```
6. Дальше скачал и установил Composer:
```
curl -sS > composer-setup.php
cd ~
$PHP bin/composer-setup.php --install-dir=bin --filename=composer
```
7. Создал файл .profile, чтобы запускать нужную версию php и установленный composer из командной строки по команде php:
```
echo "PATH=\\"$PHP_PATH:\\$PATH\\"" >> ~/.profile
echo "alias composer='$PHP ваш_каталог/bin/composer'" >> ~/.profile
```
8. Для корректного запуска утилиты по команде composer при следующем подключении к серверу добавил строки:
```
echo 'source ~/.profile' >> ~/.bashrc
source ~/.profile
```
9. Чтобы проверить правильность установки, ввожу `composer`. Если все сделали правильно, то видим следующее сообщение:
Готово, Composer установлен на вашем хостинге.
10. Дальше я убедился, что используется нужная версия PHP (7.3+):
```
php -v
```
11. Затем я запустил установку Flarum в корень своего каталога:
```
composer create-project flarum/flarum
```
Успешная установка завершилась следующим сообщением:
12. Перешел в основной каталог flarum и установил пакет с русской локализацией:
```
cd flarum
composer require flarum-lang/russian
```
13. Затем я установил нужные мне расширения, представленные [здесь](https://discuss.flarum.org/t/extensions). Общая команда для их установки следующая:
```
composer require COMPOSER_PACKAGE_NAME
```
14. Следующим шагом будет подключение почтового сервера для отправки писем с сайта, например, для подтверждения регистрации. Для этого я создал почту на домене на своем хостинг-провайдере и узнал адрес SMTP-сервера.
15. Ввел данные сервера и новой почты на панели администратора, в разделе E-mail:
Отправил тестовый email — убедился, что все работает.
16. Сделал некоторые правки внешнего вида через редактирование CSS:
17. Настроил разрешения для пользователей:
18. И получил удобную и функциональную площадку для сообщества!
Если вам на ум приходят другие стоящие площадки для создания сообществ, пишите их в комментариях!
**А если интересно вписаться в тусовку экспатов и диджитал номадов, то добро пожаловать в Пароль от вайфая:** [**Telegram**](https://t.me/parol_ot_wifi) **или** [**сообщество**](https://community.pronomad.ru/)**.** | https://habr.com/ru/post/656761/ | null | ru | null |
# Алгоритм обратного распространения ошибки с регуляризацией на c#
Привет. Я хочу продолжить [тему реализации методов машинного обучения](http://habrahabr.ru/users/mephistopheies/topics/) на c#, и в этой статье я расскажу про [алгоритм обратного распространения ошибки](http://ru.wikipedia.org/wiki/Метод_обратного_распространения_ошибки) для обучения [нейронной сети](http://ru.wikipedia.org/wiki/Искусственная_нейронная_сеть) прямого распространения, а также приведу его реализацию на языке C#. Особенность данной реализации в том, что реализация алгоритма абстрагирована от реализаций целевой функции (той, которую нейросеть пытается минимизировать) и функции активации нейронов. В итоге получится некий конструктор, с помощью которого можно поиграться с различными параметрами сети и алгоритма обучения, посмотреть и сравнить результат. Предполагается, что вы уже знакомы с тем, что такое искусственная нейросеть (если нет, то настоятельно рекомендую для начала изучить [википедию](http://ru.wikipedia.org/wiki/Искусственный_нейрон) или [одну из подобных статей](http://habrahabr.ru/post/40137/)). Интересно? Лезем под кат.
#### Обозначения
Для начала рассмотрим обозначения, которые я буду использовать в статье, а за одно вспомним основные понятия, я не буду приводить картинок с нейронами и слоями, этого всего полно в [википедии](http://ru.wikipedia.org/wiki/Искусственный_нейрон) и здесь, на хабре. Итак, сразу в бой, индуцированное локальное поле нейрона (или просто сумматор) выглядит следующим образом:
*  — значение линейной комбинации вектора весов и вектора входных значений, j-ого нейрона слоя n
* b — сдвиг или смещение нейрона; если условиться, что в нулевом значении входного вектора находится всегда единица , то сдвиг можно обозначить как вес с нулевым индексом, и формулу можно будет упростить
*  — количество нейронов слоя n
Функция активации нейрона, или передаточная функция от значения сумматора:
* у каждого нейрона сети может быть своя функция активации
* для всех слоев кроме первого, входным вектором будет являться выходной вектор предыдущего слоя, так что 
От нейрона перейдем к самой сети. Нейросеть — это модель, она обладает параметрами, и задача алгоритма обучения заключается в подборе таких параметров сети, чтобы минимизоровать значение функции ошибки. Функцию ошибки будем обозначать через ***E***. Параметрами модели являются веса нейронов:  — вес j-ого нейрона слоя n, который берет свое начало в i-ом нейроне слоя (n — 1).
Греческой *эта*  обозначим гиперпараметр алгоритма обучения — скорость обучения.
Изменение веса обозначим через *дельта*:
* направление градиента показывает нам в сторону роста значения функции, но нам для минимизации необходимо двигаться в обратном направлении
Таким образом, новый вес нейрона выглядит следующим образом: 
Стоит упомянуть, что к изменению веса еще можно (или, скорее, нужно) добавить регуляризацию. Функция регуляризации ***R*** — это функция от параметров модели, в нашем случае это веса нейронов. Таким образом, новая функция ошибки выглядит как ***E + R***, а формула изменения веса преобразуется в следующую:
* лямбда — гиперпараметр обучения, коэффициент регуляризации (похож на скорость обучения)
* m — размер обучающей выборки
Вообще говоря, реализацию регуляризации тоже можно абстрагировать от алгоритма обучения, но я пока этого делать не буду, поскольку текущая реализация алгоритма обучения и так не самая быстрая, поскольку в противному случае на каждой эпохе обучения (прогон всех обучающих примеров) придется в одном цикле считать аккумулированную ошибку, а в другом — регуляризацию.Еще одна причина заключается в том, что существует не так много видов регуляризации (я, например, знаю только L1 и L2), которые применяются при обучении нейросетей. В данной реализации я буду использовать L2 норму, и она будет неотъемлемой частью алгоритма обучения.
* 
* 
#### Алгоритм обратного распространения ошибки
Для начала остановимся на режимах обучения. Изменять веса можно несколькими способами:
* либо после каждого обучающего примера (обучение в реальном режиме времени, online обучение, batchSize = 1)
* либо накопить изменения для всей обучающей выборки, а затем изменить все веса (full-batch, batchSize = trainingSet.Length)
* либо после прогона некоторого количества обучающих примеров (mini-batch, batchSize = any\_number < trainingSet.Length)
Рассмотрим ситуацию с онлайн-обучением, так будет проще. Итак, на вход сети пришел импульс , сеть выдала отклик , хотя правильной реакцией на ***x***, является .
Рассмотрим частную производную функции ошибки ***E***:
* 
+ но так как функцию ошибки можно выразить только через сумматор, а сумматор зависит от веса, то мы можем переписать эту запись следующим образом
* 
* 
+ так вычисляется частная производная сумматора по весу, тогда можно переписать выражение частной производной целевой функции по весу; в итоге получаем
* 
Дальнейшее рассуждение разделяется на две ветки: для последнего слоя и для остальных слоев.
##### Выходной слой
Для выходного слоя все просто, для коррекции ошибки нам достаточно вычислить производную целевой функции по одному из весов и вычислить значение дельты. Учтем, что целевая функция полностью зависит только от выходного значения нейрона, или значения функции активации, а сама функция активации зависит только от сумматора
* 
Тут видно, что для вычисления ошибки выходного слоя нужно вычислить значение частных производных в точках, независимо от того, какая у нас целевая функция или же функция активации нейрона.
##### Любой скрытый слой
Но если слой не выходной, то нам нужно аккумулировать значения ошибок всех последующих слоев.
* 
+ далее учтем, что сумматор следующего слоя зависит только от выходов текущего слоя, а выходы текущего зависят только от сумматоров текущего слоя
* 
* 
+ производная сумматора по выходам предыдущего слоя выдаст нам просто вес между нейронами, учитывая это перепишем основной вывод
* 
*PS: я заметил, что в верхних индексах забыл ставить скобки, чтобы обозначить, что это не степень, а индекс слоя; учтите это, пока степеней нигде не было.*
Что же мы имеем:
* вычисление производной некой функции активации — это как раз то что нужно
* вычисление частной производной целевой функции по значению сумматора следующего слоя; тут тоже все просто, мы ведь находимся не на последнем слое, и вычисление изменений весов ведем от последнего к первому, так что это значение уже вычислено на предыдущем шаге
+ 
+ в случае, если следующий слой последний, то мы вычислим это значение для текущего слоя, и таким образом распространим решение на всю сеть
#### Реализация
##### Функция ошибки
С формулами покончили, давайте перейдем к реализации, и начнем с понятия функции ошибки. У меня это представлено в виде метрики (по сути, это так и есть). Метод **CalculatePartialDerivaitveByV2Index** вычисляет значение частной производной функции для входных векторов по индексу переменное из v2.
```
public interface IMetrics
{
double Calculate(T[] v1, T[] v2);
///
/// Calculate value of partial derivative by v2[v2Index]
///
T CalculatePartialDerivaitveByV2Index(T[] v1, T[] v2, int v2Index);
}
```
Таким образом, мы можем вычислить значение частной производной функции ошибки для последнего слоя по реальному выходу сети .
Для примера давайте напишем несколько реализаций.
**Минимизация половины квадрата Евклидова расстояния**
А производная будет выглядеть следующим образом:
```
internal class HalfSquaredEuclidianDistance : IMetrics
{
public override double Calculate(double[] v1, double[] v2)
{
double d = 0;
for (int i = 0; i < v1.Length; i++)
{
d += (v1[i] - v2[i]) \* (v1[i] - v2[i]);
}
return 0.5 \* d;
}
public override double CalculatePartialDerivaitveByV2Index(double[] v1, double[] v2, int v2Index)
{
return v2[v2Index] - v1[v2Index];
}
}
```
**Минимизация логарифмического правдоподобия**
```
internal class Loglikelihood : IMetrics
{
public override double Calculate(double[] v1, double[] v2)
{
double d = 0;
for (int i = 0; i < v1.Length; i++)
{
d += v1[i]\*Math.Log(v2[i]) + (1 - v1[i])\*Math.Log(1 - v2[i]);
}
return -d;
}
public override double CalculatePartialDerivaitveByV2Index(double[] v1, double[] v2, int v2Index)
{
return -(v1[v2Index]/v2[v2Index] - (1 - v1[v2Index])/(1 - v2[v2Index]));
}
}
```
Здесь главное не забыть, что логарифмическое правдоподобие вычисляется со знаком минус в начале, и производная тоже будет с минусом. Я не заостряю внимания на проверках или избегания случаев деления на ноль, или логарифма от нуля.
##### Функция активации нейрона
Аналогичным способом опишем функцию активации нейрона.
```
public interface IFunction
{
double Compute(double x);
double ComputeFirstDerivative(double x);
}
```
И примеры.
**Сигмоид**
```
internal class SigmoidFunction : IFunction
{
private double _alpha = 1;
internal SigmoidFunction(double alpha)
{
_alpha = alpha;
}
public double Compute(double x)
{
double r = (1 / (1 + Math.Exp(-1 * _alpha * x)));
//return r == 1f ? 0.9999999f : r;
return r;
}
public double ComputeFirstDerivative(double x)
{
return _alpha * this.Compute(x) * (1 - this.Compute(x));
}
}
```
**Гиперболический тангенс**
```
internal class HyperbolicTangensFunction : IFunction
{
private double _alpha = 1;
internal HyperbolicTangensFunction(double alpha)
{
_alpha = alpha;
}
public double Compute(double x)
{
return (Math.Tanh(_alpha * x));
}
public double ComputeFirstDerivative(double x)
{
double t = Math.Tanh(_alpha*x);
return _alpha*(1 - t*t);
}
}
```
##### Нейрон, слой и сеть
В данном разделе рассмотрим представление основных элементов сети, реализацию их я приводить не буду, т.к. она очевидно. Алгоритм будет приведен для полносвязной «слоеной» сети, так что и реализацию сети нужно будет делать соответствующую.
Итак, нейрон выглядит следующим образом.
```
public interface INeuron
{
///
/// Weights of the neuron
///
double[] Weights { get; }
///
/// Offset/bias of neuron (default is 0)
///
double Bias { get; set; }
///
/// Compute NET of the neuron by input vector
///
/// Input vector (must be the same dimension as was set in SetDimension)
/// NET of neuron
double NET(double[] inputVector);
///
/// Compute state of neuron
///
/// Input vector (must be the same dimension as was set in SetDimension)
/// State of neuron
double Activate(double[] inputVector);
///
/// Last calculated state in Activate
///
double LastState { get; set; }
///
/// Last calculated NET in NET
///
double LastNET { get; set; }
IList Childs { get; }
IList Parents { get; }
IFunction ActivationFunction { get; set; }
double dEdz { get; set; }
}
```
Т.к. мы рассматриваем полносвязную «слоеную» сеть, то Childs и Parents можно не имплементировать, но если делать общий алгоритм, то придется. Рассмотрим поля, которые особо важны для алгоритма обучения:
* **LastNET** — сумматор нейрона, тут хранится последнее вычисленное значение
* **LastState** — выход нейрона, тут хранится последнее вычисленное значение
* **dEdz** — это то самое dE/dz нейрона, что упоминается выше, и вычисляется в зависимости от того на каком слое находится текущий нейрон; частная производная функции ошибки по сумматору нейрона
Слой сети выглядит проще:
```
public interface ILayer
{
///
/// Compute output of the layer
///
/// Input vector
/// Output vector
double[] Compute(double[] inputVector);
///
/// Get last output of the layer
///
double[] LastOutput { get; }
///
/// Get neurons of the layer
///
INeuron[] Neurons { get; }
///
/// Get input dimension of neurons
///
int InputDimension { get; }
}
```
И представление сети:
```
public interface INeuralNetwork
{
///
/// Compute output vector by input vector
///
/// Input vector (double[])
/// Output vector (double[])
double[] ComputeOutput(double[] inputVector);
Stream Save();
///
/// Train network with given inputs and outputs
///
/// Set of input vectors
/// Set if output vectors
void Train(IList> data);
}
```
Но мы рассматриваем многослойную нейросеть, так что будет использоваться особое представление:
```
public interface IMultilayerNeuralNetwork : INeuralNetwork
{
///
/// Get array of layers of network
///
ILayer[] Layers { get; }
}
```
##### Алгоритм обучения
Алгоритм обучения будет реализован через [паттерн стратегия](http://ru.wikipedia.org/wiki/Стратегия_(шаблон_проектирования)):
```
public interface ILearningStrategy
{
///
/// Train neural network
///
/// Neural network for training
/// Set of input vectors
/// Set of output vectors
void Train(T network, IList> data);
}
```
Для более наглядного понимания приведу типичную функцию Train любой нейросети в контексте данной реализации:
```
public void Train(IList> data)
{
\_learningStrategy.Train(this, data);
}
```
##### Формат входных данных
Я использую следующий формат входных данных:
```
public class DataItem
{
private T[] \_input = null;
private T[] \_output = null;
public DataItem()
{
}
public DataItem(T[] input, T[] output)
{
\_input = input;
\_output = output;
}
public T[] Input
{
get { return \_input; }
set { \_input = value; }
}
public T[] Output
{
get { return \_output; }
set { \_output = value; }
}
}
```
Как видно из кода в предыдущих частях, нейросеть работает с ````
DataItem.
##### Параметры алгоритма обучения
Данным классом описываются параметры алгоритма обучения, я думаю названия полей говорят сами за себя (и комментарии), так что не буду дублировать текстом:
public class LearningAlgorithmConfig
{
public double LearningRate { get; set; }
///
/// Size of the butch. -1 means fullbutch size.
///
public int BatchSize { get; set; }
public double RegularizationFactor { get; set; }
public int MaxEpoches { get; set; }
///
/// If cumulative error for all training examples is less then MinError, then algorithm stops
///
public double MinError { get; set; }
///
/// If cumulative error change for all training examples is less then MinErrorChange, then algorithm stops
///
public double MinErrorChange { get; set; }
///
/// Function to minimize
///
public IMetrics ErrorFunction { get; set; }
}
```
##### Алгоритм
Ну и наконец, показав весь контекст, можно перейти к собственно реализации алгоритма обучения нейросети `````
internal class BackpropagationFCNLearningAlgorithm : ILearningStrategy, функция public void Train(IMultilayerNeuralNetwork network, IList data).
Для начала подготавливаем некоторые переменные (общие для всех эпох обучения) для работы алгоритма:
if (\_config.BatchSize < 1 || \_config.BatchSize > data.Count)
{
\_config.BatchSize = data.Count;
}
double currentError = Single.MaxValue;
double lastError = 0;
int epochNumber = 0;
Logger.Instance.Log("Start learning...");
```
Затем запустится основной цикл работы алгоритма, в котором происходит прямой и обратный прогон всего массива данных, один прогон называется эпохой:
```
do
{
//...
} while (epochNumber < _config.MaxEpoches &&
currentError > _config.MinError &&
Math.Abs(currentError - lastError) > _config.MinErrorChange);
```
Заходим в цикл, и перед тем как пройтись по всем примерам, инициализируем вспомогательные переменные важные только для текущей эпохи. В случае, если batch не полный, то перемешиваем данные.
```
lastError = currentError;
DateTime dtStart = DateTime.Now;
//preparation for epoche
int[] trainingIndices = new int[data.Count];
for (int i = 0; i < data.Count; i++)
{
trainingIndices[i] = i;
}
if (_config.BatchSize > 0)
{
trainingIndices = Shuffle(trainingIndices);
}
```
Далее наступает процесс обработки данных, в зависимости от размера пачки, и изменение весов, это выглядит так:
```
//process data set
int currentIndex = 0;
do
{
#region initialize accumulated error for batch, for weights and biases
double[][][] nablaWeights = new double[network.Layers.Length][][];
double[][] nablaBiases = new double[network.Layers.Length][];
for (int i = 0; i < network.Layers.Length; i++)
{
nablaBiases[i] = new double[network.Layers[i].Neurons.Length];
nablaWeights[i] = new double[network.Layers[i].Neurons.Length][];
for (int j = 0; j < network.Layers[i].Neurons.Length; j++)
{
nablaBiases[i][j] = 0;
nablaWeights[i][j] = new double[network.Layers[i].Neurons[j].Weights.Length];
for (int k = 0; k < network.Layers[i].Neurons[j].Weights.Length; k++)
{
nablaWeights[i][j][k] = 0;
}
}
}
#endregion
//process one batch
for (int inBatchIndex = currentIndex; inBatchIndex < currentIndex + _config.BatchSize && inBatchIndex < data.Count; inBatchIndex++)
{
//forward pass
double[] realOutput = network.ComputeOutput(data[trainingIndices[inBatchIndex]].Input);
//backward pass, error propagation
//last layer
//.......................................ОБРАБОТКА ПОСЛЕДНЕГО СЛОЯ
//hidden layers
//.......................................ОБРАБОТКА СКРЫТЫХ СЛОЕВ
}
//update weights and bias
for (int layerIndex = 0; layerIndex < network.Layers.Length; layerIndex++)
{
for (int neuronIndex = 0; neuronIndex < network.Layers[layerIndex].Neurons.Length; neuronIndex++)
{
network.Layers[layerIndex].Neurons[neuronIndex].Bias -= nablaBiases[layerIndex][neuronIndex];
for (int weightIndex = 0; weightIndex < network.Layers[layerIndex].Neurons[neuronIndex].Weights.Length; weightIndex++)
{
network.Layers[layerIndex].Neurons[neuronIndex].Weights[weightIndex] -=
nablaWeights[layerIndex][neuronIndex][weightIndex];
}
}
}
currentIndex += _config.BatchSize;
} while (currentIndex < data.Count);
```
Рассмотрим обработку последнего слоя:
* инициализировали "наблЫ", там мы храним аккумулированное значение градиента для пачки входных данных (при онлайн обучении, там окажется просто градиент по одному примеру)
* пробегаемся по всем нейронам последнего слоя
* вычисляем dE/dz
* а затем вычисляем значение градиента для весов и смещения
```
//last layer
for (int j = 0; j < network.Layers[network.Layers.Length - 1].Neurons.Length; j++)
{
network.Layers[network.Layers.Length - 1].Neurons[j].dEdz =
_config.ErrorFunction.CalculatePartialDerivaitveByV2Index(data[inBatchIndex].Output,
realOutput, j) *
network.Layers[network.Layers.Length - 1].Neurons[j].ActivationFunction.
ComputeFirstDerivative(network.Layers[network.Layers.Length - 1].Neurons[j].LastNET);
nablaBiases[network.Layers.Length - 1][j] += _config.LearningRate *
network.Layers[network.Layers.Length - 1].Neurons[j].dEdz;
for (int i = 0; i < network.Layers[network.Layers.Length - 1].Neurons[j].Weights.Length; i++)
{
nablaWeights[network.Layers.Length - 1][j][i] +=
_config.LearningRate*(network.Layers[network.Layers.Length - 1].Neurons[j].dEdz*
(network.Layers.Length > 1 ?
network.Layers[network.Layers.Length - 1 - 1].Neurons[i].LastState :
data[inBatchIndex].Input[i])
+
_config.RegularizationFactor *
network.Layers[network.Layers.Length - 1].Neurons[j].Weights[i]
/ data.Count);
}
}
```
Очень похоже на последний слой выглядит обработка всех скрытых слоев сети:
* пробегаемся по всем скрытым слоям
* инициализировали "наблЫ", там мы храним аккумулированное значение градиента для пачки входных данных (при онлайн обучении, там окажется просто градиент по одному примеру)
* пробегаемся по всем нейронам последнего слоя
* вычисляем dE/dz, но уже для этого мы используем значения вычисленные, на слое старше текущего
* а затем вычисляем значение градиента для весов и смещения
```
//hidden layers
for (int hiddenLayerIndex = network.Layers.Length - 2; hiddenLayerIndex >= 0; hiddenLayerIndex--)
{
for (int j = 0; j < network.Layers[hiddenLayerIndex].Neurons.Length; j++)
{
network.Layers[hiddenLayerIndex].Neurons[j].dEdz = 0;
for (int k = 0; k < network.Layers[hiddenLayerIndex + 1].Neurons.Length; k++)
{
network.Layers[hiddenLayerIndex].Neurons[j].dEdz +=
network.Layers[hiddenLayerIndex + 1].Neurons[k].Weights[j]*
network.Layers[hiddenLayerIndex + 1].Neurons[k].dEdz;
}
network.Layers[hiddenLayerIndex].Neurons[j].dEdz *=
network.Layers[hiddenLayerIndex].Neurons[j].ActivationFunction.
ComputeFirstDerivative(
network.Layers[hiddenLayerIndex].Neurons[j].LastNET
);
nablaBiases[hiddenLayerIndex][j] += _config.LearningRate*
network.Layers[hiddenLayerIndex].Neurons[j].dEdz;
for (int i = 0; i < network.Layers[hiddenLayerIndex].Neurons[j].Weights.Length; i++)
{
nablaWeights[hiddenLayerIndex][j][i] += _config.LearningRate * (
network.Layers[hiddenLayerIndex].Neurons[j].dEdz *
(hiddenLayerIndex > 0 ? network.Layers[hiddenLayerIndex - 1].Neurons[i].LastState : data[inBatchIndex].Input[i])
+
_config.RegularizationFactor * network.Layers[hiddenLayerIndex].Neurons[j].Weights[i] / data.Count
);
}
}
}
```
Тут основной код заканчивается, и остается сделать пару штрихов в виде вычисления средней ошибки сети на массиве данных (с учетом регуляризации), и логирование:
```
//recalculating error on all data
//real error
currentError = 0;
for (int i = 0; i < data.Count; i++)
{
double[] realOutput = network.ComputeOutput(data[i].Input);
currentError += _config.ErrorFunction.Calculate(data[i].Output, realOutput);
}
currentError *= 1d/data.Count;
//regularization term
if (Math.Abs(_config.RegularizationFactor - 0d) > Double.Epsilon)
{
double reg = 0;
for (int layerIndex = 0; layerIndex < network.Layers.Length; layerIndex++)
{
for (int neuronIndex = 0; neuronIndex < network.Layers[layerIndex].Neurons.Length; neuronIndex++)
{
for (int weightIndex = 0; weightIndex < network.Layers[layerIndex].Neurons[neuronIndex].Weights.Length; weightIndex++)
{
reg += network.Layers[layerIndex].Neurons[neuronIndex].Weights[weightIndex] *
network.Layers[layerIndex].Neurons[neuronIndex].Weights[weightIndex];
}
}
}
currentError += _config.RegularizationFactor * reg / (2 * data.Count);
}
epochNumber++;
Logger.Instance.Log("Eposh #" + epochNumber.ToString() +
" finished; current error is " + currentError.ToString() +
"; it takes: " +
(DateTime.Now - dtStart).Duration().ToString());
```
Этот блок находится прямиком перед выходом из основного цикла, продублирую код для наглядности:
```
} while (epochNumber < _config.MaxEpoches &&
currentError > _config.MinError &&
Math.Abs(currentError - lastError) > _config.MinErrorChange);
```
#### Итог
Собственно все. От себя хочу вот что добавить, данный текст я привел примерно в том виде, в каком я его хотел бы видеть, когда первый раз читал про алгоритм обратного распространения. Обычно в литературе авторы заранее говорят что будет использоваться такая то функция ошибки и активации нейрона. И в процессе вывода формул с частными производными они вставляют эти производные в вывод, и в итоге получается примерно так же, как, например, в википедии, где рассматривается алгоритм для минимизации квадрата Евклидова расстояния.
Вот формула для последнего слоя:
и для остальных:
.
Конечно, если вы очень умны, то вам не составит труда понять что тут от какого дифференциала, но я смог понять это только когда взял в руки ручку и бумагу, и написал весь вывод. Потом то же самое сделал для другой функции ошибки и только потом обобщил и осознал -)``` | https://habr.com/ru/post/154369/ | null | ru | null |
# Трюки CSS и JavaScript, которые вдохнут жизнь в ваш статический сайт
Последние несколько недель я работал над своим сайтом и хотел придать ему некоторый динамизм. Эта статья не о создании веб-страницы. Я покажу готовые сниппеты с объяснениями.
[](https://habr.com/ru/company/skillfactory/blog/533636/)
---
3D-анимация на JS
-----------------
Первый трюк — замечательный трёхмерный эффект на JS.
*Как видите, когда указатель мыши проходит по этой «карточке», элементы внутри нее обретают трёхмерность.*
**Как это делается**
Сначала создаётся HTML div:
```
[Hackerone](https://hackerone.com/hensis)
=========================================
### Started on 6/20 Signal : 5.67 Reputation : 360 Impact : 26.25
```
Здесь у нас есть основной класс (card) и два других класса внутри card (header and info). Header будет классом, содержащим изображение (в нашем примере — логотип Medium), а info будет содержать текст в карточке. Теперь давайте добавим CSS, чтобы карта выглядела лучше.
```
.card {
transform-style: preserve-3d;
min-height: 64vh;
width: 20vw;
border-radius: 30px;
padding: 0rem 5rem;
box-shadow: 0 20px 20px rgba(0, 0, 0, 0.2), 0px 0px 50px rgba(0, 0, 0, 0.2);
}
```
Здесь я объявил высоту, ширину, границу, отступ и тень. Обновите страницу, и вы увидите результаты. Последний шаг — добиться 3D-эффекта при наведении курсора мыши на карту. Для этого я воспользовался JS:
```
// declaring variables
const card = document.querySelector(".card");
const title = document.querySelector(".title");
const header = document.querySelector(".header img");
const description = document.querySelector(".info h3");
// Animate In
card.addEventListener("mouseenter", (e) => {
card.style.transition = "none";
title.style.transform = "translateZ(3px)";
header.style.transform = "translateZ(3px) rotateZ(0deg)";
description.style.transform = "translateZ(3px)";
});
// Animate Out
card.addEventListener("mouseleave", (e) => {
card.style.transition = "all 0.5s ease";
card.style.transform = `rotateY(0deg) rotateX(0deg)`;
title.style.transform = "translateZ(0px)";
header.style.transform = "translateZ(0px) rotateZ(0deg)";
description.style.transform = "translateZ(0px)";
});
```
1. Объявите переменные.
2. Создайте два прослушивателя событий для card.
3. В mouseenter переведите Z на 3 пикселя для title, header и description. Вы также можете решить, вращать эти элементы или нет (rotateZ).
4. По событию mouseleave верните всё в нормальное состояние.
Вот и все: у вас есть красивая трёхмерная анимация. Конечно, сейчас она сырая. Можно везде добавить CSS, чтобы изменить ширину, цвет и т. д.
Откройте для себя Vanta.js для анимации фона
--------------------------------------------
Устали от статичных цветов и изображений на фоне веб-страницы? [VantaJs](https://www.vantajs.com/) разработана, чтобы оживить фон:
**Как это делается**
Это довольно просто. Добавьте в HTML такой код:
```
VANTA.GLOBE({
el: "#htmlid",
mouseControls: true,
touchControls: true,
gyroControls: true,
minHeight: 200.00,
minWidth: 200.00,
scale: 1.00,
scaleMobile: 1.00
})
```
Это установит фон [Vanta.js Globe](https://www.vantajs.com/?effect=globe) для идентификатора htmlid.
**В Vanta.js есть 13 готовых фонов**
* [Birds](https://www.vantajs.com/?effect=birds)
* [Fog](https://www.vantajs.com/?effect=fog)
* [Waves](https://www.vantajs.com/?effect=waves)
* [Clouds](https://www.vantajs.com/?effect=clouds)
* [Clouds2](https://www.vantajs.com/?effect=clouds2)
* [Globe](https://www.vantajs.com/?effect=globe)
* [Net](https://www.vantajs.com/?effect=net)
* [Cells](https://www.vantajs.com/?effect=cells)
* [Trunk](https://www.vantajs.com/?effect=trunk)
* [Topology](https://www.vantajs.com/?effect=topology)
* [Dots](https://www.vantajs.com/?effect=dots)
* [Rings](https://www.vantajs.com/?effect=rings)
* [Halo](https://www.vantajs.com/?effect=halo)
Чтобы переключаться между ними, измените VANTA.GLOBE на VANTA.[Backgroundname]. Конечно, перед этим нужно добавить соответствующий [cdn.jsdelivr.net/npm/vanta@latest/dist/vanta](https://cdn.jsdelivr.net/npm/vanta@latest/dist/vanta).[backgroundname].min.js.
ScrollReveal
------------
Для тех, кто не знал об этой фантастической библиотеке JS, [ScrollReveal](https://scrollrevealjs.org/) может отображать элементы при прокрутке веб-страницы:
**Как это делается**
1. Добавьте в заголовок вашего HTML.
2. В файле JS напишите:
```
ScrollReveal().reveal('.htmlclass',{ delay: 400 })
```
Код отобразит элемент с классом .htmlclass с задержкой 400мс при прокрутке страницы.
Изменение размера и цвета букв
------------------------------
Этот небольшой трюк с CSS действительно впечатляет при правильном использовании:
**Как это делается**
Создайте несколько новых HTML-элементов span и укажите их класс:
```
Test
```
3. Применяя CSS :hover, мы изменяем размер букв и их цвет:
```
.blast:hover {
color:#08fdd8;
font-size: 30px;
}
```
Теперь, когда вы наведёте указатель на буквы, вы увидите, как они меняют размер и цвет. Чтобы добиться еще более динамичного эффекта, я предлагаю создать отдельный класс для каждой буквы с разными размерами и цветами. Кроме того, вы можете применить CSS :hover к каждому типу элемента в HTML. Например, я тоже применил его к своей контактной форме:
Свойство animation
------------------
Дополнили материал описанием свойства из [статьи](https://css-tricks.com/almanac/properties/a/animation/) Криса Койера.
Свойство animation в CSS можно использовать для анимации многих других свойств CSS, таких как [color](https://css-tricks.com/almanac/properties/c/color/), [background-color](https://css-tricks.com/almanac/properties/b/background-color/), [height](https://css-tricks.com/almanac/properties/h/height/), или [width](https://css-tricks.com/almanac/properties/w/width/). Каждая анимация должна быть определена с помощью @keyframes, которое затем вызывается с помощью свойства animation, например:
```
.element {
animation: pulse 5s infinite;
}
@keyframes pulse {
0% {
background-color: #001F3F;
}
100% {
background-color: #FF4136;
}
}
```
Каждое правило @keyframes определяет, что должно происходить в определённые моменты анимации. Например, 0 % — это начало анимации, а 100 % — её конец. Этими ключевыми кадрами можно управлять либо с помощью сокращённого свойства animation, либо с помощью его восьми подсвойств, чтобы обеспечить больший контроль над ключевыми кадрами.
### Подсвойства
* animation-name: объявляет имя правила @keyframes, которым нужно управлять.
* animation-duration: продолжительность одного цикла анимации.
* animation-time-function: устанавливает предустановленные кривые ускорения, такие как ease или linear.
* animation-delay: время между загрузкой элемента и началом анимационной последовательности ([интересные примеры](https://twitter.com/jh3yy/status/1246533538884845568)).
* animation-direction: устанавливает направление анимации после цикла. Его значение по умолчанию сбрасывается в каждом цикле.
* animation-iteration-count: сколько раз должна быть выполнена анимация.
* animation-fill-mode: устанавливает, какие значения применяются до/после анимации.
Например, вы можете установить последнее состояние анимации так, чтобы оно оставалось на экране, или можете настроить его на переключение назад, когда анимация началась.
* animation-play-state: приостановить/воспроизвести анимацию.
Затем эти подсвойства можно применять так:
```
@keyframes stretch {
/* declare animation actions here */
}
.element {
animation-name: stretch;
animation-duration: 1.5s;
animation-timing-function: ease-out;
animation-delay: 0s;
animation-direction: alternate;
animation-iteration-count: infinite;
animation-fill-mode: none;
animation-play-state: running;
}
/*
is the same as:
*/
.element {
animation:
stretch
1.5s
ease-out
0s
alternate
infinite
none
running;
}
```
Вот полный список значений, которые может принимать каждое из этих вложенных свойств:
| | |
| --- | --- |
| `animation-timing-function` | ease, ease-out, ease-in, ease-in-out, linear, cubic-bezier(x1, y1, x2, y2) (e.g. cubic-bezier(0.5, 0.2, 0.3, 1.0)) |
| `animation-duration` | Xs или Xms |
| `animation-delay` | Xs или Xms |
| `animation-iteration-count` | X |
| `animation-fill-mode` | forwards, backwards, both, none |
| `animation-direction` | normal, alternate |
| `animation-play-state` | paused, running, running |
### Несколько шагов
Если анимация имеет одинаковые начальные и конечные свойства, полезно разделять запятыми значения 0 и 100 % внутри @keyframes:
```
@keyframes pulse {
0%, 100% {
background-color: yellow;
}
50% {
background-color: red;
}
}
```
### Несколько анимаций
Вы можете разделить значения запятыми, чтобы также объявить несколько анимаций в селекторе. В приведённом ниже примере мы хотим изменить цвет круга в @keyframe, одновременно перемещая его из стороны в сторону с помощью другого свойства.
```
.element {
animation:
pulse 3s ease infinite alternate,
nudge 5s linear infinite alternate;
}
```
### Производительность
Анимация большинства свойств [является проблемой производительности](https://www.html5rocks.com/en/tutorials/speed/high-performance-animations/), поэтому мы должны соблюдать осторожность перед анимацией любого свойства. Однако есть определённые комбинации, которые можно безопасно анимировать:
* transform: translate()
* transform: scale()
* transform: rotate()
* opacity
### Какие свойства можно анимировать?
На MDN есть [список свойств CSS, которые могут быть анимированы](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties). Они имеют тенденцию быть цветами и числами. Пример неанимируемого свойства - background-image.
**Больше информации**
* [Анимация на MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/animation).
* [Использование анимации CSS](https://developer.mozilla.org/en/css/css_animations).
* [Анимация на W3C](https://dev.w3.org/csswg/css-animations-1/).
* [Jank busting для повышения производительности рендеринга](https://www.html5rocks.com/en/tutorials/speed/rendering/).
* [Веб-анимация в действии](http://alistapart.com/article/web-animation-at-work).
* [Пять способов анимировать отзывчиво](https://24ways.org/2014/five-ways-to-animate-responsible/).
* [Скачки состояния, отрицательные задержки, анимация источника и многое другое](https://css-tricks.com/css-animation-tricks/).
* [Запуск анимации CSS на полпути](https://css-tricks.com/starting-css-animations-mid-way/).
[Анимация высокого качества](https://www.html5rocks.com/en/tutorials/speed/high-performance-animations/).
### Поддержка браузерами
Эти данные о поддержке браузера взяты с сайта [Caniuse](https://caniuse.com/#feat=css-animation), где имеется более подробная информация. Число означает, что браузер поддерживает функцию в этой версии и выше.
**Настольные**
| | | | | |
| --- | --- | --- | --- | --- |
| Chrome | Firefox | IE | Edge | Safari |
| 4\* | 5\* | 10 | 12 | 5.1\* |
**Мобильные**
| | | | |
| --- | --- | --- | --- |
| Android Chrome | Android Firefox | Android | iOS Safari |
| 87 | 83 | 4\* | 6.0-6.1\* |
### Префиксы
Хотя поддержка этого свойства в современных браузерах достаточно хороша, мы, возможно, захотим поддерживать как можно больше старых браузеров. В этом случае нужно использовать префиксы поставщиков:
```
.element {
-webkit-animation: KEYFRAME-NAME 5s infinite;
-moz-animation: KEYFRAME-NAME 5s infinite;
-o-animation: KEYFRAME-NAME 5s infinite;
animation: KEYFRAME-NAME 5s infinite;
}
@-webkit-keyframes KEYFRAME-NAME {
0% { opacity: 0; }
100% { opacity: 1; }
}
@-moz-keyframes KEYFRAME-NAME {
0% { opacity: 0; }
100% { opacity: 1; }
}
@-o-keyframes KEYFRAME-NAME {
0% { opacity: 0; }
100% { opacity: 1; }
}
@keyframes KEYFRAME-NAME {
0% { opacity: 0; }
100% { opacity: 1; }
}
```
Такие трюки подойдут для того, чтобы вдохнуть жизнь в ваш сайт-визитку или сайт пет-проекта, над которым вы работаете. Если у вас есть какие-то свои трюки — призываю делиться ими в комментах. И не забывайте о промокоде **HABR**, который дает дополнительную скидку 10% к той, что указана на баннере.
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=171220)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=171220)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=171220)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=171220)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=171220)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=171220)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=171220)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=171220)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=171220)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=171220)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=171220)
---
**КУРСЫ**
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=171220)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=171220)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=171220)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=171220)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=171220)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=171220) | https://habr.com/ru/post/533636/ | null | ru | null |
# Экспорт фотоальбомов из ВКонтакта
#### Преамбула
Дело было вечером, делать было нечего и тут мне в голову пришла мысль: «Как же мне выгрузить все фотографии из ВКонтакта на компьютер?» Недолго думая, я написал утилиту для этого и решил поделиться с общественностью, возможно я не один такой.
#### Поехали
В качестве инструмента для работы с API, путём кратких поисков, была выбрана библиотека [vk\_api](https://github.com/python273/vk_api). Для работы с сетью она использует [Requests](http://python-requests.org), поэтому и эта библиотека требуется для запуска.
#### Пощупать
[GitHub Pages проекта](http://meamka.me/VKPorter/)
Само приложение получилось крайне простым и небольшим, но с задачей своей справляется. Весь код уместился в одном единственном файле.
**Исходный код**
```
#!/usr/bin/env python
"""
:mod:`vkporter`
~~~~~~~~~~~~~~~
A micro tool for export photo albums from `vk.com `\_.
It's based on `VK\_API `\_
by Kirill Python ,
`Requests `\_
and `ProgressBar `\_.
:copyright: (c) 2013 by Andrey Maksimov.
:license: BSD, see LICENSE for more details.
"""
\_\_author\_\_ = 'Andrey Maksimov '
\_\_date\_\_ = '09.03.13'
\_\_version\_\_ = '0.1.1'
import argparse
import datetime
from getpass import getpass
import os
import time
import sys
try:
import requests
except ImportError:
print("Cannot find 'requests' module. Please install it and try again.")
sys.exit(0)
try:
from vk\_api import VkApi
except ImportError:
print("Cannot find 'vk\_api' module. Please install it and try again.")
sys.exit(0)
def connect(login, password):
"""Initialize connection with `vk.com `\_ and try to authorize user with given credentials.
:param login: user login e. g. email, phone number
:type login: str
:param password: user password
:type password: str
:return: :mod:`vk\_api.vk\_api.VkApi` connection
:rtype: :mod:`VkApi`
"""
return VkApi(login, password)
def get\_albums(connection):
"""Get albums list for currently authorized user.
:param connection: :class:`vk\_api.vk\_api.VkApi` connection
:type connection: :class:`vk\_api.vk\_api.VkApi`
:return: list of photo albums or ``None``
:rtype: list
"""
try:
return connection.method('photos.getAlbums')
except Exception as e:
print(e)
return None
def get\_photos(connection, album\_id):
"""Get photos list for selected album.
:param connection: :class:`vk\_api.vk\_api.VkApi` connection
:type connection: :class:`vk\_api.vk\_api.VkApi`
:param album\_id: album identifier returned by :func:`get\_albums`
:type album\_id: int
:return: list of photo albums or ``None``
:rtype: list
"""
try:
return connection.method('photos.get', {'aid': album\_id})
except Exception as e:
print(e)
return None
def download(photo, output):
"""Download photo
:param photo:
"""
url = photo.get('src\_xxxbig') or photo.get('src\_xxbig') or photo.get('src\_xbig') or photo.get('src\_big')
r = requests.get(url)
title = photo['pid']
with open(os.path.join(output, '%s.jpg' % title), 'wb') as f:
for buf in r.iter\_content(1024):
if buf:
f.write(buf)
def sizeof\_fmt(num):
"""Small function to format numbered size to human readable string
:param num: bytes to format
:type num: int
:return: human readable size
"""
for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
if num < 1024.0:
return "%3.1f %s" % (num, x)
num /= 1024.0
if \_\_name\_\_ == '\_\_main\_\_':
parser = argparse.ArgumentParser(description='', version='%(prog)s ' + \_\_version\_\_)
parser.add\_argument('username', help='vk.com username')
# parser.add\_argument('password', help='vk.com username password')
parser.add\_argument('-o', '--output', help='output path to store photos',
default=os.path.abspath(os.path.join(os.path.dirname(\_\_file\_\_), 'exported')))
args = parser.parse\_args()
# expand user path if necessary
if args.output.startswith('~'):
args.output = os.path.expanduser(args.output)
start\_time = datetime.datetime.now()
try:
password = getpass("Password: ")
# Initialize vk.com connection
connection = connect(args.username, password)
# Request list of photo albums
albums = get\_albums(connection)
print("Found %s album%s:" % (len(albums), 's' if len(albums) > 1 else ''))
ix = 0
for album in albums:
print('%3d. %-40s %4s item%s' % (
ix + 1, album['title'], album['size'], 's' if int(album['size']) > 1 else ''))
ix += 1
# Sleep to prevent max request count
time.sleep(1)
if not os.path.exists(args.output):
os.makedirs(args.output)
for album in albums:
response = get\_photos(connection, album['aid'])
output = os.path.join(args.output, album['title'])
if not os.path.exists(output):
os.makedirs(output)
processed = 0
for photo in response:
percent = round(float(processed) / float(len(response)) \* 100, 2)
sys.stdout.write(
"\rExporting %s... %s of %s (%2d%%)" % (album['title'], processed, len(response), percent))
sys.stdout.flush()
download(photo, output)
processed += 1
except Exception as e:
print(e)
sys.exit(1)
except KeyboardInterrupt:
print('VKPorter exporting stopped by keyboard')
sys.exit(0)
finally:
print("Done in %s" % (datetime.datetime.now() - start\_time))
```
#### Примеры
По умолчанию экспорт происходит в папку `./exported`
```
$ ./vkporter.py username@vk.com
```
Путь для экспорта можно указать при запуске
```
$ ./vkporter.py -o ~/Documents/Exported username@vk.com
```
Выглядит это примерно так:
#### Общение
Буду благодарен на репорты о багах на [github.com/amka/VKPorter/issues](https://github.com/amka/VKPorter/issues/) | https://habr.com/ru/post/172131/ | null | ru | null |
# Релиз языка программрования NewLang
**NewLang** — это язык программирования высокого уровня, в котором можно сочетать стандартные алгоритмические конструкции с декларативным программированием и тензорными вычислениями для задач машинного обучения.
Основной особенностью языка является простой, логичный и не противоречивый синтаксис, который основан не на использовании зарезервированных ключевых слов, а на строгой системе грамматических правил с использованием знаков препинания (в список которых входят и операторы языка).
Новое по сравнению с [прошлым выпуском](https://habr.com/ru/company/timeweb/blog/651999/):
* Реализованы все основные алгоритмические конструкции: проверка условий, различные варианты циклов, сравнение по образцу, прерывание последовательности команд и возврат данных, обработка ошибок и т.д.
* Переработан основной синтаксис для отдельных языковых конструкций.
* Реализованы большинство операций с переменными, включая операторы раскрытие списков и тензоров.
* Серьезно переработана система встроенных типов, реализованы функции для их преобразования и для определения данных (последнее можно назвать data comprehensions).
* Добавлены новые тесты и пр.
Зачем нужен *NewLang*?
======================
У всех современных языков программирования происходит постоянное развитие (читай усложнение) синтаксиса по мере выхода новых версий. Это является своего рода, платой за появление новых возможностей и воспринимается пользователями как естественное явление.
Но одновременно является и серьезной проблемой, т.к. с выходом новых версий добавляются новые ключевые слова и синтаксические конструкции, что неизбежно повышает порог входа для новых пользователей. Еще одним следствием этого процесса становится постоянное повышение сложности разработки и трудоемкости поддержки уже созданных программных продуктов, когда старый код дорабатывается с применением уже новых стандартов.
У *NewLang* сложность языковых конструкций естественно ограничена за счет разделения синтаксиса языка на две части, что упрощает его изучение и использование.
*Основной синтаксис* — для написания программ в объектно-ориентированном (императивном) и декларативном стилях, который основан не на зарезервированных ключевых словах, а на строгих грамматических правилах и *Расширенный синтаксис* — когда основного синтаксиса становится недостаточно, или требуется использовать языковую конструкцию языка реализации.
Еще одно неудобство современных мейнстримовых языков, большинство из них были созданы до начала эпохи машинного обучения, поэтому тензорные вычисления у них выполнены в виде отдельных библиотек, а не встроены в основной синтаксис языка и систему базовых типов.
У *NewLang* тензорные вычисления доступны «из коробки» (используется библиотека [libtorch](https://pytorch.org/)), а обычные числа являются скалярами (тензорами нулевой размерности).
Синтаксис NewLang
=================
При разработке синтаксиса я старался придерживаться уже сложившихся в IT индустрии правил, чтобы не генерировать множественных смыслов, которые будут зависеть от контекста.
**Основы**
* Операторы разделяются точкой с запятой «;».
* Отступы и переводы строк игнорируются (очень хотелось иметь возможность автоматического форматирование кода).
* Многострочные комментарии в исходном коде соответствуют стилю С/С++ и должны располагаться между символами /\* и \*/. Вложенность многострочных комментариев не поддерживается.
* Однострочные комментарии начинаются с символа «#» до перевода строки, что соответствует комментариям в стиле Python и Bash.
* Последовательность команд, которая должна выполняться как единое целое, заключается в фигурные скобки «{}».
* Программные вставки расширенного синтаксиса на языке реализации заключается в фигурные скобки со знаком процента %{ /\* тут может быть любой код на C/C++\*/ %}, как в лексерах lex и flex.
Создания объектов и присвоения новых значений
=============================================
Для создания объектов и присвоения им новых значений в NewLang используется сразу три разных оператора:
* **::=** используется только для создания новых объектов, а если объект с таким именем уже существует, то генерируется ошибка.
* **:=** используется для тех же целей, но если объект с таким именем уже существует, то ошибки не происходит, а новое значение присваивается уже существующему объекту.
* **=** применяется только для присвоения значения уже существующим объектам, и если объект с указанным именем отсутствует, то тоже происходит ошибка выполнения.
Использование трех разных операторов для создания/изменения объектов позволяет более гибко контролировать подобные операции и выявлять логические ошибки в коде на более раннем этапе.
```
var ::= 1.0; # Создать новую переменную var без указания типа
var = 100; # Присвоить новое значение уже существующей переменной
printf := @import('printf(format:Format, ...):Int'); /* Создать новый или переопределить объект printf, который будет результатом выполнения глобальной функции @import */
```
Идентификаторы объектов и модификаторы
======================================
В качестве идентификаторов можно использовать буквы, цифры и знаки подчеркивания в любых комбинациях, при условии, что первый символ идентификатора не является цифрой.
В NewLang существует возможность указания области видимости и времени жизни объекта с помощью модификатора — специального символа перед именем переменной. Это может показаться немного похожим на венгерскую нотацию, но в отличие от нее, модификатор не имеет отношения к типу объекта и не является частью имени идентификатора. К тому же в качестве модификаторов используется строго определённые символы, назначение которых определено заранее.
* **$** — в начале имени обозначает локальную переменную, время жизни которой ограничено текущей областью видимости и при её завершении локальная переменная уничтожается.
* **@** — обозначает глобальную переменную, а сам объект сохраняет свое состояние даже после выхода из текущей области видимости.
* **:** — двоеточие вначале имени используется в качестве модификатора для указания типа.
Семантика обращения к аргументам функций очень похоже на работу с аргументами в bash скриптах, где $1 или $arg — порядковый номер или имя аргумента (происходит обращение к локальным переменным в текущей области видимости).
### Использование модификаторов является обязательным только в двух случаях:
* При создании нового типа данных, так как типы всегда создаются в глобальной области видимости, а их символьные имена должны быть уникальными.
* При обращении к объектам NewLang внутри программных вставок кода на языке реализации, так как они используется как маркеры при поиске идентификаторов NewLang в коде С/С++.
В остальных случаях, для обращения к переменным указывать их модификаторы необязательно. И если при обращении к объекту модификатор не указан, то сперва ищется локальная переменная, а потом глобальная с таким же именем. Причем, локальная переменная будет перекрывать глобальную.
Так же следует иметь в виду, что компилятор может генерировать код для прямого обращения к локальным объектам уже на этапе компиляции, тогда как для обращения к глобальным объектам, или если модификатор области видимости отсутствует, компилятор вынужден каждый раз встраивать runtime вызов функции поиска объекта в глобальной таблице символов.
Система типов
=============
Так как система типов языка динамическая, то явное указание типа не влияет на размер переменной и является только своего рода логическим ограничением на возможность присвоения переменной значения другого типа.
Информация о типах используется при проверке их совместимости, когда существующему объекту присваивается значение другого типа. Такая операция возможна только когда типы совместимы между собой и допускают автоматическое приведение. Это справедливо как во время парсинга/компиляции исходного теста, так и во время выполнения в режимах интерпретатора и/или скомпилированного файла.
Простые типы
------------
### Арифметические значения
Арифметические типы данных являются тензорами — массивами чисел одного типа с произвольным количеством измерений и одинаковым размером столбцов в каждом. Единичное число тоже тензор нулевого размера.
Поддерживаются только знаковые целые числа, т.к. в беззнаковых числах особая нужда отсутствует, а проблем с ними можно найти очень много на ровном месте.
Проблемы беззнаковых чисел (из интернета):
> Во-первых, вычитание двух беззнаковых чисел, например 3 и 5. 3 минус 5 равно 4294967294, т.к. -2 не может быть представлено как беззнаковое число. Во-вторых, непредвиденное поведение может возникнуть при смешивании целочисленных значений со знаком и без знака. С++ может свободно преобразовывать числа со знаком и без знака, но не проверяет диапазон, чтобы убедиться, что вы не переполняете свой тип данных.
>
> В C++ всё же есть несколько случаев, когда можно (или необходимо) использовать беззнаковые числа. Во-первых, числа без знака предпочтительнее при работе с битами. Во-вторых, использование беззнаковых чисел связанных с индексацией массивов.
Но это не мой случай, так как индекс может быть отрицательным и даже не числом, а диапазоном или многоточием.
З.Ы. И даже зная об этом, все равно умудрился недавно словить баг с отрицательными индексами у словарей!
Имена встроенных арифметических типов говорят сами за себя: Char, Short, Int, Long, Float, Double, ComplexFloat, ComplexDouble. Отдельным типом идет логический тип Bool, который может принимать значения только 0 или 1 (false/true соответственно), и в зависимости от выполняемой операции может быть отнесен к целочисленным типам, так и не входить в их состав (данный подход интерпретации логического типа данных был взят из библиотеки Torch).
```
// Treat bool as a distinct "category," to be consistent with type promotion
// rules (e.g. `bool_tensor + 5 -> int64_tensor`). If `5` was in the same
// category as `bool_tensor`, we would not promote. Differing categories
// implies `bool_tensor += 5` is disallowed.
//
// NB: numpy distinguishes "unsigned" as a category to get the desired
// `bool_tensor + 5 -> int64_tensor` behavior. We don't, because:
// * We don't want the performance hit of checking the runtime sign of Scalars.
// * `uint8_tensor + 5 -> int64_tensor` would be undesirable.
```
В будущем планируется добавить классы чисел для длинной арифметики и дробей, для чего зарезервированы названия типов BigNum, Currency и Fraction.
Доступ к элементам тензора происходит по целочисленному индексу, который начинается с 0. Для многомерного тензора, индексы элемента перечисляются в квадратных скобках через запятую. Поддерживается доступ к элементам через отрицательный индекс, который обрабатывается точно так же, как в Python (-1 последний элемент, -2 предпоследний и т.д.).
Литерал тензор в тексте программы записывается в квадратных скобках с обязательной завершающей запятой, т.е. [1, 2,] — это литерал одномерный тензор из двух чисел. После закрывающей скобки тип тензора может быть указан в явном виде. Если тип не указан, то он выводится автоматически на основании указанных данных и выбирается минимально возможный байтовый размер, который позволяет сохранить все значения без потери точности.
*Примеры:*
```
$var_char := 123; # Тип Char выводится автоматически
$var_short := 1000; # Тип Short выводится автоматически
$var_bool := [0, 1, 0, 1,]; # Тензор из 4 элементов. Тип Bool выводится автоматически
$tensor[10,10]:Int := 1; # Тензор Int размером 2x2 инициализированный 1
$scalar := $tensor[5,5]; # Присвоить скаляру значение указанного элемента тензора
```
Строки
------
Поддерживаются два типа строк, StrWide — символьные (широкие) и StrChar — байтовые. Различия между ними заключается в типе единичного элемента. У символьных строк единичным элементом является широкий символ *wchar\_t*, а у байтовой строки единичным элементом является один байт (точнее *char*, т.е. байт со знаком). Символьные строки литералы в исходном тексте записывается в «двойных кавычках», а байтовые строки в 'одинарных кавычках'.
Количество элементов символьной строки возвращается в широких символах, а размер байтовой строки в байтах, поэтому и обращение к элементу строки по индексу происходит соответственно либо к символу, либо к байту.
Важный момент. К любой переменной можно обратиться так же, как к функции (записав после её имени круглые скобки). Результатом этой операции будет создание копии/клона объекта. Причем некоторые типы (словари, классы и символьные строки) можно использовать в качестве шаблона при создании копии объекта с модифицированными свойствами, если новые и/или изменяемые значения указать в скобках, как аргументы при вызовах функций. Так, если при создании копии в скобках указать набор новых данных, то результирующая копия будет содержать уже измененные данные.
*Например:*
```
$template := "${name} $1"; # Обычная строка
$result := $template("шаблон", name = "Строка"); # result = "Строка шаблон"
```
Системные
---------
### :Pointer — указатель на системную область памяти
Так как любой программе приходится взаимодействовать с внешним миром, то по неволе приходится закладывать возможность использования других библиотек и системы типов данных, и для этих целей служит тип *Pointer*. Он создается при импорте функций из внешних библиотек и вручную его создать нельзя. Но можно вывести его значение, например для отладки.
### :Plain — указатель на представление данных в бинарном виде
Для взаимодействия с внешними библиотеками требуется еще и обмен данными. И для этих целей служит тип данных *Plain* — который также является указателем, но на двоичное представление данных в единой области памяти. Конечно, если их можно представить в виде единого фрагмента.
Составные типы данных:
----------------------
### Словарь
Словарь (:Dictionary) — набор данных произвольного типа с доступом к отдельным элементам по целочисленному индексу или по имени элемента при его наличии (он похож и на tuple и на структуру одновременно). Словари от тензоров отличаются тем, что являются только одномерными массивами, но каждый элемент может содержать произвольное количество элементов любого типа, в том числе и другие словари.
Доступ к элементам словарей происходит по имени элемента, которое записывается через точку от имени переменной, либо по целочисленному индексу. Индекс также начинается с 0 и как у тензоров и тоже может быть отрицательным.
Литерал с типом «словарь» в тексте программы записывается в круглых скобках с обязательной завершающей запятой, т. е. (,) — пустой словарь, (1, 2= «2», name=3,).
### Перечисление, структура и объединение
*:Enum*, *:Struct* и *:Union* — это такие же словари, только на их элементы накладываются определённые ограничения. Каждый элемент должен иметь уникальное имя, а его тип данных должен быть простым, т.е. числом или строкой фиксированного размера.
### Классы
Класс (реализован частично) — тип данных, с помощью которого реализуется один из принципов ООП — наследование. При создании экземпляра класса создается новая переменная, у которой сохраняется информацию о своем родителе и которая наследует от него свойства и методы. Тип данных *:Class* аналогичен словарю, но все свойства обязаны иметь имена (хотя доступ к свойствам класса по индексу так же возможен).
Функции
-------
Синтаксис NewLang поддерживать несколько типов функций (а в будущем и методов классов): обычные функции, чистые функции и простые чистые функции.
Для всех типов функций поддерживаются аргументы по умолчанию. При создании функции, её аргументы указываются как в Python, т.е. вначале идут обязательные аргументы, потом аргументы со значениями по умолчанию, где имя аргумента отделяется от его значения по умолчанию знаком равно **=**. Если функция допускает обработку произвольного количества аргументов, то последним в списке параметров указывается многоточие **...** (три точки подряд) .
### Обычная функция
Обычная функция — такие функции являются именно обычными функциями в понимании С/С++. Внутри них можно писать совершенно любой код, включая проверки условий, циклы, вызовы других функций и т.д.
Внутри обычной функции можно обращаться к локальным и глобальным объектам, и они могут содержаться вставки на языке реализации\*, например, для вызова функций из внешних библиотек.
Вставки на языке реализации оформляются в виде %{ %} и могут содержать любой текст на С/С++, а прямо из него можно обращаться к локальным и глобальным объектам NewLang так же, как и в обычном синтаксисе, указывая первым символом имени соответствующий модификатор (*$* для локальных объектов и *@* для глобальных).
Технически, такая программная вставка просто переносится трансплайтером непосредственно в исходный текст генерируемого файла, а все идентификаторы NewLang специальным образом декорируются (добавляются специальные маркеры для их идентификации), после этого исходный текст подается на вход обычному компилятору С++. Для локальных объектов трансплайтер может генерировать код для прямого доступа к объекту на этапе компиляции, а для работы с глобальными объектами вынужден использовать runtime вызовы функции поиска в таблице символов.
---
\*) — Программные вставки на языке реализации обрабатываются только во время компиляции
*Например:*
```
print(str) := {
%{
printf("%s", static_cast($str)); /\* Прямой вызов С функции \*/
%}
};
```
### Чистые функции
Чистая функция — это тоже обычная функция, только в том смысле, какой в него вкладывает функциональное программирование. Создания чистой функции происходит с помощью оператора **:-**, а сам оператор заимствован из языка Пролог. У чистой функции отсутствует доступ к контексту и глобальным переменным, поэтому она может обрабатывать только те данные, которые были ей переданы в качестве аргументов.
Программные вставки на языке реализации внутри чистых функций не запрещены и могут использоваться, например, для отладки. Но делается это на страх и риск разработчика. Именно он отвечает за их «чистоту», например при вызове функций из внешних библиотек.
```
Sum(arg1, arg2) :- {$arg1+$arg2;}; # Вернуть сумму аргументов
```
### Простые чистые функции
Простые чистые функции — отдельный класс чистых функций, которые предназначены только для вычисления логического результата (т.е. они являются предикатами) и их отличает упрощенная формой записи. Тело простой чистой функции состоит из последовательности операторов, которые разделяются запятыми и заканчиваются, как и любое выражение, точкой с запятой. Все операторы простой чистой функции всегда приводятся к булевому значению, а итоговый результат функции вычисляется по одной из возможных логических операций: И, ИЛИ и исключающее ИЛИ.
*Например:*
```
func_and(arg1, arg2) :&&= arg1==3, arg2 > 0; # Простая чистая функция Логическое И
func_or(arg1, arg2) :||= arg1==3, arg2 > 0; # Простая чистая функция Логическое ИЛИ
func_xor(arg1, arg2) :^^= arg1==3, arg2 > 0; # Простая чистая функция Исключающее ИЛИ
```
Специальные типы данных:
------------------------
### Пусто (:None)
**:None** (пусто) — не содержит значения (точнее имеет одно значение None) и совместим с любым другим типом данных. Указывается в тексте программы как один подчерк «\_». None имеют не инициализированные переменные и при попытке чтения из такой переменной возникает ошибка.
Тип переменной может быть явно указан или выведен автоматически из присваиваемого значения. Присвоить новое значение уже инициализированной переменной можно только для совместимого типа, так как неявное преобразование типов не допускаются.
```
$var := _; # Создать не инициализированную переменную
$var2 := var; # Ошибка!!! Нельзя прочитать неинициализированную переменную var
$var = 1000; # У переменной будет тип Short (минимальный размер для хранения значения)
$var = 0,5; # Ошибка!!! Short ← Float не совместимы
$var = _; # Очистить значение переменной
$var = 0,5; # Теперь можно, т. к. None совместим с любым типом
```
### Диапазон (:Range)
Диапазон — специальный тип данных, являющейся приблизительным аналогом типа «генератор» в Python. К диапазону можно обращаться как к итератору и он будет поочередно выдавать элементы в указанном интервале с заданным шагом. Диапазон в тексте программы указывается как два или три элемента через две точки, например 1..5 — диапазон от единицы до пяти с шагом по умолчанию 1. В качестве параметров диапазона можно указывать не только литералы, но и имена переменных. Например, *0,1..$stop..0,1* — диапазон от 0,1 до значения, указанного в переменной $stop с шагом 0,1.
Диапазон для целых чисел можно использовать в качестве индекса у тензоров (точнее, у любых объектов, которые допускают доступ к своим элементам по индексу, т.е. тензоры, словари и текстовые строки). Фактический, это поведение аналогично *slice* в языке Python и *array[1:5]* в Python означает тоже самое, что и *array[1..5]* в NewLang.
В качестве индекса у тензоров еще можно указать произвольное количество измерений с помощью многоточия, т.е.
```
$tensor[…, 0] = 0; # Обнулить все первые элементы в каждом измерении.
```
Преобразование типов
--------------------
### Явное приведение типов
Несмотря на динамическую типизацию языка, если тип переменной указан явно, то автоматическое приведение типов не выполняется, и чтобы присвоить переменой значение не совместимого типа, требуется явное преобразование.
Так как символьные названия типов относятся к деталям реализации, то явное преобразование в конкретный тип данных производится с помощью вызова функции с именем типа, т.е. :Bool(), :StrWide(), :Long() и т.д.
Для преобразования любого типа данных в строку ещё можно использовать оператор конкатенации строк, которой преобразует любой тип данных в строковое представление. Но, так как строковых типов два (байтовые и широкие строки), то тип строки определяется первым аргументом в операторе конкатенации/сцепления **++**. Также преобразовать любое значение в строковое можно с помощью строки-шаблона.
```
"" ++ 123; # "123" - Строка широких символов
'' ++ 123; # '123' - Байтовая строка
val := 12345; # Число
"$1"(val); # Будет строка "12345"
```
Так как тензоры могут иметь больше одного значения, то и в качестве аргументов могут принимать их произвольное количество, а итоговым результатом будет тензор, в котором все переданные данные преобразованы к требуемому типу автоматически.
*Примеры:*
```
> tstr := :Tensor("Тест"); # Создать тензор из строки широких символов
[1058, 1077, 1089, 1090,]:Int
> t2 := :Tensor[2,2]("Тест"); # Тоже самое, но тензор указанной размерности
[
[1058, 1077,], [1089, 1090,],
]:Int
> :StrWide(tstr) # Создать символьную строку из тензора
Тест
> :Double(t2) # Изменить тип данных тезора без изменения размерности
[
[1058, 1077,], [1089, 1090,],
]:Double
> t3 := :Char[4]( t2 ) # Изменить размерность тензора и его тип (в данном случае с частичной потерей данных)
[34, 53, 65, 66,]:Char
>:Tensor( (1,2,3,) ); # Тензор из словаря
[1, 2, 3,]:Char
>:Tensor( 'first second' ) # Байтовая строка в тензор
[102, 105, 114, 115, 116, 32, 115, 101, 99, 111, 110, 100,]:Char
>:Tensor( (first='first', space=32, second='second',) ) # Получаем тензор из словаря с такими же данными
[102, 105, 114, 115, 116, 32, 115, 101, 99, 111, 110, 100,]:Char
>:Double[10,2]( 0, ...) # Тензор заданного формата с нулями, где многоточие повторяет последние указанные данные до получения тензора требуемого размера
[
[0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,],
]:Double
>:Int[3,2]( ... rand() ...) # Тензор со случайными данными, где между многоточиями указана функция, которую следует вызывать каждый раз при получении нового элемента тензора
# Пришлось придумывать новую конструкцию, т.к. многоточие перед именем, это оператор раскрытия словаря, а многоточие после имени, это повторение последнего значения до конца заданной размерности.
[
[1804289383, 846930886,], [1681692777, 1714636915,], [1957747793, 424238335,],
]:Int
>:Int[5,2]( 0..10 ); # Создание тензора из диапазона
[
[0, 1,], [2, 3,], [4, 5,], [6, 7,], [8, 9,],
]:Int
>:Tensor( 0..0.99..0.1 ); # Или даже так
[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,]:Double
```
Операторы и управляющие конструкции
===================================
Операторы:
----------
Все операторы имеют парный аналог с присвоением значения:
* **+** и **+=** — сложение арифметических типов данных;
* **-** и **-=** — вычитание арифметических типов данных;
* **/** и **/=** — деление (результат число с плавающей точкой);
* **//** и **//=** — целочисленное деление с округлением к меньшему числу (как в Python);
* *\** и *\*=* — умножение;
* *\*\** и **\*\*=** — возведение в степень (он же используется и для повторения текстовых строк);
* **++** и **++=** — конкатенация строк с автоматическим приведением аргументов к стоковому типу (символ инкремента специально используется вместо одиночного плюса для того, чтобы в явном виде разделить конкатенацию строк и операторы арифметического сложения).
Операторы сравнения:
--------------------
* **<**, **>**, **<=**, **>=** — классические для сравнения скаляров
* **==** и **!=** — операторы сравнения с автоматическим приведением совместимых типов для любых объектов
* **===** и **!==** — оператор точного сравнения для любых объектов (автоматического приведения типов не выполняется)
Проверки типа (имени класса объекта):
-------------------------------------
Для оператора проверки имени класса объекта используется символ тильда **~**. Он немного похож на оператор *instanceof* в Java. Левым операндом должен быть проверяемый объект, а правым — проверяемый тип, который можно указать строкой литералом, переменной строкового типа или именем проверяемого класса непосредственно. Результатом операции будет истина, если правый операнд содержит название класса проверяемого объекта или он присутствует в иерархии наследования.
```
name := "class"; # Строковая переменная с именем класса
var ~ name;
var ~ :class; # Имя типа
var ~ "class"; # Строка литерал с именем типа
```
Утиная типизация
----------------
Оператор утиной типизации, два символа тильны **~~** — приблизительный аналог функции isinstance() в Python, который для простых типов сравнивает непосредственную совместимость типа левого операнда по отношению к правому. А для словарей и классов в левом операнде проверяется наличие всех имен полей, присутствующих у правого операнда, т.е.:
```
(field1=«value», field2=2,) ~~ (); # Истина (т. е. левый операнд словарь)
(field1=«value», field2=2,) ~~ (field1=_); # Тоже истина (т. к. поле field1 присутствует у левого операнда)
(field1=«value», field2=2,) ~~ (not_found=_); # Ложь, т.к. поле not_found у левого операнда отсутствует
```
Строгая утиная типизация **~~~** — для простых типов сравнивается идентичности типов без учета совместимости, а для составных типов происходит сравнение всех свойств с помощью оператора строгого равенства. Для данной операции, пустой тип совместим только с другим пустим типом.
Управляющие конструкции
=======================
К управляющим конструкциям языка NewLang относятся условный оператор, два вида циклов, оператор оценки выражения, оператор прерывания последовательности выполнения команд и перехват прерывания. Операторы проверки условий всегда указываются в квадратных скобках, а последовательность команд для выполнения — в фигурных.
Условный оператор
-----------------
В качестве оператора проверки условия используется синтаксическая конструкция, соответствующая по смыслу термину «следует», т.е. тире и угловая скобка **->** или с двумя тире для большей наглядности **-->**. Такая запись условного оператора очень похожа на математическую и легко объединяется в последовательности для проверки множественных условий вида «else if».
В общем случае условный оператор имеет вид: `[ условие ] -> действие;` или `[ условие ] -> {действие};` или `[ условие1 || условие2 ] --> {действие}, [_] --> {действие иначе};`
Для наглядности записанный с отступами:
```
[ условие1 ] -> { действие1 },
[ условие2 ] -> действие2,
[ условие3 ] -> действие3,
[_] -> {действие_иначе};
```
Оценка выражения
----------------
Синтаксическая конструкция с помощью которой реализуется аналог оператора switch выглядит следующим образом:
```
[ $var ] ==> {
[1] -> { code }; # Выполнится проверка условия $var == 1
[1, 2] -> { code }; # Выполнится проверка условия ($var == 1 || $var == 2)
[_] -> { code default }; # Ветка условия иначе
};
```
Причем в качестве оператора для оценки могут быть использован любые имеющиеся операторы сравнения на равенство:
* **==>** — проверка на равенство с приведением типов;
* **===>** — проверка на точное равенство;
* **~>** — проверка типа (имени класса);
* **~~>** — утиная типизация;
* **~~~>** — строгая утиная типизация.
И если в качестве оператора сравнения использовать оператор утиной типизации, то оценка выражения превращается в классический Pattern Matching:
```
$value := (f1=1, f2="2",);
[ $value ] ~~~> {
[ (f1=_, ), (f1=_, f2=0, ) ] -> { code }; # Поле f2 отсутствует или число
[(f1=_, f2="",), (f1=_, f2='',)] -> { code }; # Поле f2 строка
[_] -> { code default }; # Код по умолчанию
};
```
Операторы циклов
----------------
Для указания операторов циклов используются управляющие **->>** или **-->>** (с двумя стрелками по направлению от проверки условия к телу цикла). И в зависимости от расположения условия и тела цикла, он может быть с предусловием (*while*) или постусловием (*do while*). Хотя пока эти синтаксические конструкции не "отлежались" и их можно считать временными из-за того, что их легко перепутать с условным оператором, и, возможно, имеет смысл заменить разные операторы цикла одной единственной конструкцией вида: **<-->** или **<<->>**, которая сильнее отличается от оператора следования.
Но в настоящий момент циклы реализованы вот так:
```
[условие while] ->> {
тело цикла while
};
{
тело цикла do while
} <<-- [условие do while];
```
Реализация цикла foreach на примере суммирования всех элементов словаря (или одномерного тензора):
```
summa := 0;
dict := (1,2,3,4,5,);
[ dict ] -->> { # Условие цикла, пока есть данные
item, dict := ... dict; # Результат оператора раскрытия словаря - первый его элемент перемещается в item
summa += item; # Вычисление суммы всех элементов словаря
};
```
Операторы прерывания (возврата)
-------------------------------
В качестве оператора прерывания/возврата используется два символа минус **--**. Оператор позволяет прервать выполнение последовательности команд и/или вернуть данные из текущей функции/блока кода и является самым близким аналогом оператора **return** и **throw** одновременно. Для того чтобы вернуть данные, их необходимо указать между двумя операторами прерывания, т.е. `--100--; # Вернуть указанное значение`. Если возвращаемое значение не указано явно, то будет возвращено значение *None*.
Следование (блок кода/лямбда функция)
-------------------------------------
Алгоритмическая конструкция, которая отвечает последовательное выполнение нескольких команд/операторов и возвращающая результат выполнения последнего из них. Также, результатом выполнения может быть значение, которое возвращается с помощью оператора прерывания (возврата). Это очень похоже на классическую лямбда функцию, только она выполняется сразу во время определения, а в переменную сохраняется уже результат её выполнения.
Следование без перехвата прерывания оформляется в виде последовательности обычных и фигурных скобок, т.е. `(){ run code };` или тоже самое, но сохраняет результата выполнения в переменной: `$result := (){ run(); code() };`. Но если внутри такой функции будет выполнен оператор прерывания, то она никогда вернет управления и не сохранит возвращаемое значение в переменой *$result*!
Чтобы перехватывать прерывания, в том числе и возвращаемые значения, необходимо использовать конструкция следования с перехватом прерываний, которая оформляется в виде последовательности обычных и **двойных** фигурных скобок, т.е. `$error := (){{ run(); error();code() }};`. Такая конструкция перехватывает все возвраты и прерывания, если они возникают во время выполнения последовательности команд. В этом случае любой результат будет сохранен в переменной *$error* как при нормальном завершении, так и в случае возникновения ошибки.
Для более тонкой настройки перехвата прерываний следует использовать типизированную конструкцию, когда в явном виде указывается, какие типы прерываний следует перехватывать. `$runtime := (){{ run(); error(); code() }}:ErrorRuntime;`. Такая конструкция вернет результат только в случае успешного завершения (когда с помощью оператора прерывания возвращается не типизированное значение, например, `--"Строка"--;`), или при создании прерывания с указанием конкретного типа **--:ErrorRuntime("Описание ошибки")--;**. А вот при возникновении любого другого типизированного прерывания, значение перехвачено не будет и все отработает как самый первый вариант, т.е. без перехвата прерывания и без сохранения возвращаемого значения в переменную.
Стратегия обработки ошибок
--------------------------
Обработка ошибок состоит из комбинации двух элементов: оператора прерывания выполнения с указанием типа возвращаемого значения и алгоритмической конструкции следование с возможностью перехвата прерывания заданного типа.
Это немного отличается от классического варианта обработки исключений, который в обычных языках программирования обычно оформляется ключевыми словами try… catch… finally с различными вариациями. Ведь основная цель подобных синтаксических конструкций — выделить участок кода, где возможно возникновение ошибки, перехватить и обработать правильный тип данных (исключений), т.к. **NewLang** не делает различий между операторами возврата и генерации исключения.
### Подход к обработке исключений следующий:
Программный код, который может привести к ошибке, заключается в двойные фигурные скобки, а результат выполнения такого блока кода присваивается переменной. После этого анализируется возвращенное значение, например, оператором сравнения по образцу:
```
$result := (){{ # начало аналога блока try
$value := call_or_exception1();
[условие1] -> { -- :Error -- };
[условие2] -> { -- $value -- };
$value := call_or_exception2();
}}; # конец аналога блока try
[$result] ~> { # Для сравнения по образцу использовать оператор проверки типа (имени класса)
[:ErrorParser] -> {Код обработки ошибок парсера};
[:ErrorRunTime] -> {Код обработки ошибок времени выполнения};
[:Error] -> { Код обработки остальных ошибок };
[_] -> { Обработка нормальных данных $value без ошибок };
};
```
Сборка REPL из исходников (пока только под Linux)
-------------------------------------------------
### Подготовка репозитория
* [Скачать исходники](https://github.com/rsashka/newlang)
* Скачать и развернуть архив [libtorch](https://pytorch.org/) в каталоге *contrib* (PyTorch Build: Stable (1.10.\*) -> Your OS: Linux -> Package: LibTorch -> Language: C++ / Java -> Compute Platform: CPU -> Download here (cxx11 ABI):
[libtorch-cxx11-abi-shared-with-deps-1.10.2+cpu.zip](https://download.pytorch.org/libtorch/cpu/libtorch-cxx11-abi-shared-with-deps-1.10.2%2Bcpu.zip))
* Активировать и скачать исходники субмодулей (`git submodule init && git submodule update`)
* В каталоге *contrib* запустить файл `build.sh` для сборки библиотеки libffi
* В каталоге *core* запустить файл `compile_syntax.sh` для генерации файлов парсера и лексического анализатора. Также может потребоваться установка утилит *flex* и *bison*. Если что, у меня установлены flex 2.6.4 и bison (GNU Bison) 3.7.4
### Собрать
* Юнит-тесты (newlang\_test): в каталоге *core* выполнить команду `make CONF=UnitTest`\*
* Интерпретатор (nlc): в каталоге *core* выполнить команду `make CONF=Debug`\*
---
\*) — Сборка проекта выполняется обычной утилитой make, но сборочные файлы генерируются автоматически в давно устаревшей версии NetBeans 8.2, т.к. это единственная универсальная среда разработки с поддержкой Makefile "из коробки", тогда как в текущей версии Apache NetBeans полноценная поддержка разработки на С/С++ вообще отсутствует. Начал постепенный переход на использование редактора VSCodium (аналога VSCode, в котором вычищена телеметрия от Microsoft) и генерацию скриптов сборки с помощью сmake, но этот процесс пока не завершен.
Планы на будущее
================
Текущая версия языка значительно обогатилась возможностями, но все еще является тестовой платформой для проверки декларируемых концепций и основного синтаксиса. Если говорить о планах, то в настоящий момент роадмап развития NewLang следующий:
* Реализовать макросы для более привычного использования языка (за счет использования DSL);
* Добавить в арифметические типы длинные числа и дроби;
* Сделать какую-нибудь логическую игру (крестики нолики, судоку или что-то похожее) с алгоритмическим выбором следующего хода и его вычислением с помощью машинного обучения;
* Написать еще больше разных примеров для оценки синтаксиса;
* Зафиксировать синтаксис с учетом полученного опыта и обратной связи;
* Восстановить работоспособность компилятора для генерации исполняемых файлов;
* Сделать очередную большую чистку кода;
* Переработать и задокументировать получившуюся семантику языка с учетом всех возможностей и выпустить первую полнофункциональную версию NewLang.
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/673176/ | null | ru | null |
# Получаем кривую плотности распределения вероятности… быстрее и точнее
Недавно на Хабре вышла [статья](https://habr.com/ru/post/585232/) за авторством [MilashchenkoEA](https://habr.com/ru/users/MilashchenkoEA/) , в которой автор восполняет обнаруженный им пробел в доступных материалах по методам построения кривых плотности распределения вероятности по имеющемуся набору числовых данных. Акцент в статье сделан на методическую сторону получения (оценки) плотности вероятности случайной величины, поэтому автор не преследует цели получения оптимального, с вычислительной точки зрения, алгоритма. Что ж, в данной заметке попытаемся исправить эту ситуацию, а также взглянем под другим углом на способ решения данной задачи.
Постановка задачи
-----------------
Дан набор **значений случайной величины **,** сэмплированный из некоторого непрерывного распределения. Необходимо оценить функцию плотности распределения вероятности случайной величины по заданной выборке. Для решения задачи можно использовать только нативные функции python; для построения графиков используется matplotlib; Pandas DataFrame используется как контейнер данных в соответствие с оригинальной статьей (хотя в общем-то можно обойтись и без него).
Подготовка данных
-----------------
Тестировать методы будем с использованием данных, сгенерированных для 4-х распределений, для которых известны аналитические выражения плотности, как в оригинальной статье: Релея, гамма, Вейбулла и экспоненциального. Для этого используем код [MilashchenkoEA](https://habr.com/ru/users/MilashchenkoEA/) с небольшими изменениями (для удобства дальнейшего использования изменены сигнатуры функций, возвращающих значения аналитической функции плотности вероятности на заданном массиве значений случайной переменной):
Код
```
import random
import math
import matplotlib.pyplot as plt
import pandas
import pandas as pd
import numpy as np # Понадобится для расчета метрик
from time import perf_counter # Понадобится для определения времени выполнения
def rel_pdf(rel_sigma: float, X: list) -> pandas.DataFrame:
"""
Вычисляет Релеевскую кривую плотности распределения вероятности по известной формуле
:param rel_sigma: среднеквадратическое отклонение
:param X: координаты по оси абсцисс
:return: pandas.DataFrame
"""
pdf_y = [] # Координаты по оси ординат
for x in X:
pdf_y.append(((2 * x) / rel_sigma) * math.exp((-x ** 2) / rel_sigma))
return pd.DataFrame({'x': X, 'y': pdf_y})
def rel_rand(n: int, rel_sigma: float) -> list:
"""
Генерирует случайные числа с Релеевской плотностью распределения вероятности
:param n: количество отсчетов
:param rel_sigma: среднеквадратическое отклонение
:return: list
"""
rel_list = []
for i in range(n):
rel_list.append((rel_sigma / math.sqrt(2)) * math.sqrt(-2 * math.log(random.uniform(0, 1))))
return rel_list
def gam_pdf(v: float, b: float, X: list) -> pandas.DataFrame:
"""
Вычисляет кривую плотности Гамма распределения вероятности по известной формуле
:param v: параметр формы
:param b: масштабный коэффициент
:param X: координаты по оси абсцисс
:return: pandas.DataFrame
"""
pdf_y = [] # Координаты по оси ординат
for x in X:
pdf_y.append(((b ** v) / math.gamma(v) * (x ** (v - 1)) * math.exp(-b * x)))
return pd.DataFrame({'x': X, 'y': pdf_y})
def gam_rand(n: int, v: float, b: float) -> list:
"""
Генерирует случайные числа с гамма распределением плотности вероятности
:param n: количество отсчетов
:param v: параметр формы
:param b: масштабный коэффициент
:return: list
"""
gam_list = [random.gammavariate(v, 1 / b) for i in range(n)]
return gam_list
def weib_pdf(a: float, b: float, X: list) -> pandas.DataFrame:
"""
Вычисляет кривую плотности распределения вероятности Вейбулла по известной формуле
:param a: масштабный коэффициент
:param b: параметр формы
:param X: координаты по оси абсцисс
:return: pandas.DataFrame
"""
pdf_y = [] # Координаты по оси ординат
for x in X:
pdf_y.append((b / a) * ((x / a) ** (b - 1)) * math.exp(-(x / a) ** b))
return pd.DataFrame({'x': X, 'y': pdf_y})
def weib_rand(n: int, a: float, b: float) -> list:
"""
Генерирует случайные числа с распределением плотности вероятности Вейбулла
:param n: количество отсчетов
:param a: масштабный коэффициент
:param b: параметр формы
:return: list
"""
wei_list = [random.weibullvariate(a, b) for i in range(n)]
return wei_list
def exp_pdf(l: float, X: list) -> pandas.DataFrame:
"""
Вычисляет кривую экспоненциальной плотности распределения вероятности по известной формуле
:param l: обратный коэффициент масштаба
:param n: количество рассчитанных точех
:param X: координаты по оси абсцисс
:return: pandas.DataFrame
"""
pdf_y = [] # Координаты по оси ординат
for x in X:
pdf_y.append(l * math.exp(-l * x))
return pd.DataFrame({'x': X, 'y': pdf_y})
def exp_rand(n: int, l: float) -> list:
"""
Генерирует случайные числа с экспоненциальным распределением плотности вероятности
:param n: количество отсчетов
:param l: обратный коэффициент масштаба
:return: list
"""
exp_list = [random.expovariate(l) for i in range(n)]
return exp_list
```
Сгенерируем для каждого распределения наборы случайных величин, и организуем их в словарь:
```
random_series = {
'rrand': rel_rand(100000, 1), # генерируем случайные числа с распределением Релея
'grand': gam_rand(100000, 0.5, 0.5), # генерируем случайные числа с гамма распределением
'wrand': weib_rand(100000, 1, 5), # генерируем случайные числа с распределением Вейбулла
'exprand': exp_rand(100000, 1.5) # генерируем случайные числа с экспоненциальным распределением
}
```
Далее, эти наборы данных будут использованы для тестирования целиком, либо срезами, содержащими **значений случайной величины.
Оптимизируем алгоритм, основанный на бинаризации данных
-------------------------------------------------------
В качестве алгоритма нахождения плотности распределения автор предлагает довольно широко распространенный метод, основанный на разбиении интервала значений переменной ****на заданное число бинов равной ширины и подсчет числа вхождений значений переменной в каждый бин, реализованный в ряде библиотек [numpy, scipy, pandas], а также собственную реализацию в соответствии с условиями (оригинальные комментарии сохранены):
```
def pdf_original(k: int, rnd_list: list) -> pandas.DataFrame:
"""
Получает кривую плотности распределения вероятности
:param k: количечиво интервалов разбиения гистограммы
:param rnd_list: случайный процесс
:return: pandas.DataFrame
"""
pdf_x = [] # Координаты по оси абсцисс
pdf_y = [] # Координаты по оси ординат
n = len(rnd_list) # количество элементов в рассматриваемой выборке
h = (max(rnd_list) - min(rnd_list)) / k # ширина одного интервала
a = min(rnd_list) # минимальное значение в рассматриваемой выборке
for i in range(0, k): # проход по интервалам
count = 0
for j in rnd_list: # подсчет количества вхождений значений из выборки в данный интервал
if (a + i * h) < j < (a + (i * h) + h):
count = count + 1
pdf_x.append(a + i * h + h / 2) # координата по оси абсцисс полученной кривой плотности распределения
# вероятности
pdf_y.append(count / (n * h)) # координата по оси ординат полученной кривой плотности распределения
# вероятности
d = {'x': pdf_x, 'y': pdf_y}
return pd.DataFrame(d)
```
Можно заметить, что сложность данного алгоритма составляет , т.к. внешний цикл пробегает **значений, внутренний же, в худшем случае, пробегает **значений. Грубо оценим время выполнения функции при различных значениях **и **
```
for k in [100, 1000, 10000]:
tic = perf_counter()
_ = pdf_original(k, rrand)
print('%.3f s' % (perf_counter() - tic))
for N in [10000, 20000, 30000]:
tic = perf_counter()
_ = pdf_original(1000, rrand[:N])
print('%.3f s' % (perf_counter() - tic))
```
Вывод:
```
0.726 s
7.006 s
69.418 s
0.783 s
1.429 s
2.145 s
```
Разумеется, столь удручающие результаты не позволяют использовать данную реализацию метода, благо есть готовые реализации. Однако, можно добиться линейной сложности алгоритма подсчета значений в бинах по и константной по , существенно, тем самым, снизив вычислительное время, всего лишь добавив предварительную сортировку значений и заменив внутренний цикл по всем значениям случайной величины на цикл лишь по тем значениям, которые попадают в бин:
```
def pdf_optimized(k: int, rnd_list: list) -> pandas.DataFrame:
"""
Получает кривую плотности распределения вероятности
:param k: количечиво интервалов разбиения гистограммы
:param rnd_list: случайный процесс
:return: pandas.DataFrame
"""
pdf_x = [] # Координаты по оси абсцисс
pdf_y = [] # Координаты по оси ординат
n = len(rnd_list) # количество элементов в рассматриваемой выборке
h = (max(rnd_list) - min(rnd_list)) / k # ширина одного интервала
a = min(rnd_list) # минимальное значение в рассматриваемой выборке
rnd_list = sorted(rnd_list) # сортируем значения
j = 0 # индекс значения левой границы интервала
for i in range(0, k): # проход по интервалам
count = 0
while j < n and (a + i * h) <= rnd_list[j] < (a + (i * h) + h): # подсчитываем количество значений в k-м интервале
count = count + 1
j += 1
pdf_x.append(a + i * h + h / 2) # координата по оси абсцисс полученной кривой плотности распределения
# вероятности
pdf_y.append(count / (n * h)) # координата по оси ординат полученной кривой плотности распределения
# вероятности
d = {'x': pdf_x, 'y': pdf_y}
return pd.DataFrame(d)
```
Выполним аналогичное тестирование времени выполнения оптимизированной функции при различных значениях и добавив некоторое число повторений:
```
N_repeats = 100
for k in [100, 1000, 10000]:
tic = perf_counter()
for _ in range(N_repeats):
_ = pdf_optimized(k, random_series['rrand'])
print('%.3f s' % ((perf_counter() - tic) / N_repeats))
for N in [25000, 50000, 100000]:
tic = perf_counter()
for _ in range(N_repeats):
_ = pdf_optimized(10000, random_series['rrand'][:N])
print('%.3f s' % ((perf_counter() - tic) / N_repeats))
```
Вывод:
```
0.035 s
0.034 s
0.039 s
0.013 s
0.021 s
0.038 s
```
С такими результатами гораздо приятнее иметь дело и такую нативную реализацию можно использовать в условиях, когда нет возможности устанавливать дополнительные пакеты. Следует, однако, заметить, что ассимптотическая сложность метода определяется алгоритмом сортировки, и в данном случае составляет .
*Примечание:
Представленные выше реализации используют нестрогое равенство для сравнения действительных чисел, что, вообще говоря, некорректно. Вследствие этого могут возникать граничные эффекты, поскольку вхождения минимального/максимального значений случайной величины в первый/последний бины не гарантировано. Следует немного модифицировать реализацию, добавив учет по умолчанию минимального и максимального значений случайной величины в первом и последнем бинах, соответственно, и пробегать в цикле по оставшимся значениям.*
Считаем плотность распределения через функцию распределения
-----------------------------------------------------------
Далее рассмотрим несколько иной подход к получению оценки плотности распределения случайной величины. Вспомним, что плотность распределения случайной величины представляет собой первую производную от функции распределения, которая, в свою очередь, является вероятностью обнаружить значение случайной величины меньше либо равное заданному. Для того, чтобы получить оценку функции распределения вероятности, а из нее, в свою очередь, плотность распределения, предлагается выполнить следующие шаги:
1. сортируем значения переменной по возрастанию, получаем набор отсортированных значений ;
2. ставим в соответствие каждому значению в массиве отсортированных значений его порядковый номер начиная с нуля — с точностью до множителя, представляет собой оценку функции распределения случайной величины (Рисунок 1, синяя кривая);
3. строим равномерную шкалу из значений на интервале от до где  — желаемое число точек кривой плотности распределения () — аналог числа бинов в гистограмме;
4. интерполируем значения номеров переменных из шкалы упорядоченного массива значений переменной в равномерную шкалу, полученную в п. 3 (Рисунок 1, оранжевая кривая);
5. численно берем производную от интерполированной функции по соседним точкам (для этого и было нужно значений) и делим на — получаем, таким образом, искомую оценку плотности вероятности.
Рисунок 1. Синяя кривая - оценка функции распределения случайной величины, заданная на исходном множестве наблюдений X, содержащем N = 100 точек; оранжевая кривая - оценка функции распределения случайной величины, полученная путем интерполяции в равномерную шкалу, содержащую k = 21 точек. Ниже представлена реализация метода:
```
def pdf_custom(k: int, rnd_list: list):
"""
Получает кривую плотности распределения вероятности
:param k: количечиво интервалов разбиения гистограммы
:param rnd_list: случайный процесс
:return: pandas.DataFrame
"""
X = sorted(rnd_list) # сортируем значения случайной переменной
N = len(X)
i = 0
dx = (X[-1] - X[0]) / (k + 2) # находим шаг по аргументу в равномерной шкале
result = []
result_x = []
for j in range(k + 2): # пробегаем по точкам
x = X[0] + j * dx # находим соответствующее значение аргумента в равномерной шкале
result_x.append(x)
while True: # с помощью данного цикла находим индекс i такой,
# что x лежит в пределах от X[i] до X[i+1]
if x > X[i + 1]:
i += 1
else:
break
result.append(i + (x - X[i]) / (X[i + 1] - X[i]))
norm = 0.5 / dx / N
d = {
'x': result_x[1:-1],
'y': [(right - left) * norm for right, left in zip(result[2:], result[:-2])]}
return pd.DataFrame(d)
```
Сложность представленного алгоритма также составляет . В результате тестирования времени выполнения получим следующие значения для  = [100, 1000, 10000] при  = 100 000 и  = [25000, 50000, 100000] при  = 10 000:
```
0.020 s
0.020 s
0.024 s
0.009 s
0.014 s
0.024 s
```
Новый метод оказался несколько быстрее, при той же алгоритмической сложности.
Сравниваем точность представленных методов
------------------------------------------
Для сравнения точности представленных методов будем использовать расстояние Кульбака-Лейблера от априорной функции плотности распределения  до получаемой оценки :
![KL=\mathbb{E}[P \cdot \ln(\frac P Q)]](https://habrastorage.org/getpro/habr/upload_files/902/4ea/9bd/9024ea9bdc811cd74a76e79019e3f405.svg)Для вычисления метрики уже, не мудрствуя лукаво, будем использовать numpy:
```
def KL_dist(P: list, Q: list):
assert len(P) == len(Q)
eps = 1e-9
P = np.asarray(P)
Q = np.asarray(Q)
return np.mean(P * (np.log(P + eps) - np.log(Q + eps)))
```
Получим оценки плотности распределения случайной величины для разных априорных распределений при разных соотношениях  и сравним значений KL-дивергенции:
```
from functools import partial
pdf_function = {
'rrand': partial(rel_pdf, 1),
'grand': partial(gam_pdf, 0.5, 0.5),
'wrand': partial(weib_pdf, 1, 5),
'exprand': partial(exp_pdf, 1.5)
}
N = 10000
k_values = np.logspace(2, 4, 10, dtype=np.int)
metrics_optimized = {}
for key, val in random_series.items():
for k in k_values:
estimated_pdf = pdf_optimized(k, val[:N])
theoretical_pdf = pdf_function[key](estimated_pdf['x'])
metrics_optimized.setdefault(key, []).append(
KL_dist(theoretical_pdf['y'], estimated_pdf['y']))
metrics_custom = {}
for key, val in random_series.items():
for k in k_values:
estimated_pdf = pdf_custom(k, val[:N])
theoretical_pdf = pdf_function[key](estimated_pdf['x'])
metrics_custom.setdefault(key, []).append(
KL_dist(theoretical_pdf['y'], estimated_pdf['y']))
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
for key, val in metrics_optimized.items():
plt.scatter(k_values / N, val)
plt.legend(metrics_optimized.keys())
plt.xlabel('k / N')
plt.ylabel('KL-divergency')
plt.title('Метод на основе гистограмм')
plt.subplot(1, 2, 2)
for key, val in metrics_custom.items():
plt.scatter(k_values / N, val)
plt.legend(metrics_custom.keys())
plt.xlabel('k / N')
plt.ylabel('KL-divergency')
plt.title('Метод на основе функции распределения')
```
В результате ожидаемо в обоих случаях получаются монотонно возрастающие зависимости метрики от соотношения  (Рисунок 2), однако, метод, основанный на численном дифференцировании функции распределения случайной величины дает на порядок меньшее расхождение кривой оценки плотности распределения с теоретической кривой, чем метод, основанный на построении гистограммы, что особенно заметно при больших значениях .
Рисунок 2. Зависимость значения диверегенции Кульбака-Лейблера между априорным распределением и его оценкой от соотношения k / N для метода, основанного на бинаризации данных (слева) и метода, основанного на взятии произвоной от оценки функции распределения (справа).Заключение
----------
Предложенный альтернативный метод построения оценок плотности распределения случайной величины по заданному набору наблюдений отличается более высокой точностью, по сравнению с методом, основанным на получении гистограмм.
Выражаю благодарность [MilashchenkoEA](https://habr.com/ru/users/MilashchenkoEA/) за обсуждение данных проблем и за то, что убедил написать эту небольшую заметку :) | https://habr.com/ru/post/587372/ | null | ru | null |
# Dive into pyTorch
Всем привет. Меня зовут Артур Кадурин, я руковожу исследованиями в области глубокого обучения для разработки новых лекарственных препаратов в компании [Insilico Medicine](http://insilico.com/). В Insilico мы используем самые современные методы машинного обучения, а также сами разрабатываем и публикуем множество статей для того чтобы вылечить такие заболевания как рак или болезнь Альцгеймера, а возможно и старение как таковое.
В рамках подготовки [своего курса](https://otus.ru/lessons/deep-learning-engineer/) по глубокому обучению я собираюсь опубликовать серию статей на тему Состязательных(Adversarial) сетей с разбором того что же это такое и как этим пользоваться. Эта серия статей не будет очередным обзором GANов([Generative Adversarial Networks](https://arxiv.org/abs/1406.2661)), но позволит глубже заглянуть под капот нейронных сетей и охватит более широкий спектр архитектур. Хотя GANы мы конечно тоже разберем.
Для того чтобы дальше беспрепятственно обсуждать состязательные сети я решил сначала сделать небольшое введение в [pyTorch](https://pytorch.org/). Хочу сразу заметить, что это не введение в нейронные сети, поэтому я исхожу из того, что вы уже знаете такие слова как "слой", "батч", "бэкпроп" и т.д. Помимо базовых знаний о нейросетях, вам, конечно, понадобится понимание языка python.
Для того чтобы было удобно пользоваться pyTorch я подготовил [докер](https://www.docker.com/)-контейнер с [jupyter'ом](http://jupyter.org/) и кодом в ноутбуках. Если вы захотите запускать обучение на видеокарте, то для видеокарт от NVIDIA вам потребуется nvidia-docker, думаю с этой частью у большинства из вас проблем не будет, поэтому остальное я оставляю вам.
Все необходимое для этого поста доступно в моем репозитории **spoilt333/adversarial** с тегом **intro** на [Docker Hub](https://hub.docker.com/), или в моем репозитории на [GitHub](https://github.com/spoilt333/adversarial).
После установки докера запустить контейнер можно например с помощью такой команды:
```
docker run -id --name intro -p 8765:8765 spoilt333/adversarial:intro
```
В контейнере автоматически запустится сервер jupyter'а, который будет доступен по <http://127.0.0.1:8765> с паролем "password"(без кавычек). Если вы не хотите запускать чужой контейнер у себя на машине(правильно!), то собрать свой такой же, предварительно проверив что там все ок, можно из докерфайла который есть в репозитории на GitHub.
Если у вас все запустилось и вы смогли подключиться к jupyter, то давайте перейдем к тому что же из себя представляет pyTorch. pyTorch — это большой фреймворк позволяющий создавать динамические графы вычислений и автоматически вычислять градиенты по этим графам. Для машинного обучения это как раз то что нужно. Но, помимо самой возможности обучать модели, pyTorch это еще и огромная библиотека включающая датасеты, готовые модели, современные слои и комьюнити вокруг всего этого.
В Deep Learning, довольно продолжительное время, было практически стандартом тестировать все новые модели на задаче распознавания рукописных цифр. Датасет [MNIST](http://yann.lecun.com/exdb/mnist/) представляет из себя 70.000 размеченных рукописных цифр примерно поровну распределенных между классами. Он сразу же разбит на тренировочное и тестовое множества для того чтобы обеспечить одинаковые условия всем кто тестируется на этом датасете. В pyTorch, естественно, для него есть простые интерфейсы. Несмотря на то что сравнивать между собой state-of-the-art модели на этом датасете уже не имеет большого смысла, для демонстрационных целей он нам подойдет идеально.
Каждый пример в MNIST представляет из себя изображение размером 28х28 пикселей в оттенках серого. И, как нетрудно заметить, далеко не все цифры легко может "распознать" даже человек. В ноутбуке mnist.ipynb вы можете посмотреть на пример загрузки и отображения датасета, а несколько полезных функций вынесены в файл utils.py. Но давайте перейдем к основному "блюду".
В ноутбуке mnist-basic.ipynb реализована двухслойная полносвязная нейронная сеть решающая задачу классификации. Один из способов сделать нейронную сеть с помощью pyTorch — это наследоваться от класса *nn.Module* и реализовать свои функции инициализации и *forward*
```
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 100)
self.fc2 = nn.Linear(100, 10)
```
Внутри функции \_\_init\_\_ мы объявляем слои будущей нейронной сети. В нашем случае это линейные слои *nn.Linear* которые имеют вид **W'x+b**, где W — матрица весов размером *(input, output)* и b — вектор смещения размером *output*. Эти самые веса и будут "обучаться" в процессе тренировки нейронной сети.
```
def forward(self, x):
x = x.view(-1, 28*28)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = F.softmax(x, dim=1)
return x
```
Метод *forward* используется непосредственно для преобразования входных данных с помощью заданной нейройнной сети в ее выходы. Для простоты примера мы будем работать с примерами из MNIST не как с изображениями, а как с векторами каждая размерность которых соответствует одному из пикселей. Функция *view()* это аналог *numpy.reshape()*, она переиндексирует тензор с данными заданным образом. "*-1*" в качестве первого аргумента функции означает, что количество элементов в первой размерности будет вычислено автоматически. Если исходный тензор **x** имеет размерность *(N, 28, 28)*, то после
```
x = x.view(-1, 28*28)
```
его размерность станет равна *(N, 784)*.
```
x = F.relu(self.fc1(x))
```
Применение слоев к данным в pyTorch реализовано максимально просто, вы можете "вызвать" слой передав ему в качестве аргумента батч данных и получить на выходе результат преобразования. Аналогичным образом устроены и функции активации. В данном случае я использую *relu*, так как это наиболее популярная функция активации в задачах компьютерного зрения, однако вы легко можете поэкспериментировать с другими реализованными в pyTorch функциями, благо их там достаточно.
```
x = self.fc2(x)
x = F.softmax(x, dim=1)
```
Так как мы решаем задачу классификации на 10 классов, то и выход нашей сети имеет размерность 10. В качестве функции активации на выходе сети мы используем *softmax*. Теперь значения которые возвращает функция *forward* можно интерпретировать как вероятности того что входной пример принадлежит к соответствующим классам.
```
model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.01)
```
Теперь мы можем создать экземпляр нашей сети и выбрать функцию оптимизации. Для того чтобы получился симпатичный график обучения я выбрал обыкновенный стохастический градиентный спуск, но в pyTorch, конечно же, реализованы и более продвинутые методы. Вы можете попробовать например RMSProp или Adam.
```
def train(epoch):
for data, target in train_loader:
optimizer.zero_grad()
output = model(data)
loss = F.cross_entropy(output, target)
loss.backward()
optimizer.step()
```
Функция *train* содержит основной цикл обучения в котором мы итерируемся по батчам из тренировочного множества. *data* — это примеры, а *target* — соответствующие метки. В начале каждой итерации мы обнуляем текущее значение градиентов:
```
optimizer.zero_grad()
```
Обработка данных всей сетью в pyTorch ничем не отличается от применения отдельного слоя. За вызовом *model(data)* скрыт вызов функции *forward*, поэтому в *output* попадают выходы сети. Теперь остается только посчитать значение функции ошибки и сделать шаг обратного распространения:
```
loss = F.cross_entropy(output, target)
loss.backward()
```
На самом деле, при вызове *loss.backward()* веса сети еще не обновляются, но для всех весов использовавшихся при вычислении ошибки pyTorch считает градиенты используя построенный граф вычислений. Для того чтобы обновить веса мы вызываем *optimizer.step()*, который опираясь на свои параметры(у нас это learning rate) обновляет веса.
После 20 эпох обучения наша сеть угадывает цифры с точностью 91%, что, конечно, далеко от SOTA результатов, однако, весьма неплохо для 5 минут программирования. Вот пример из тестового множества с предсказанными ответами
```
[[1 1 5 2 4 6 9 9 9 9]
[2 3 5 4 4 1 3 2 4 7]
[5 0 3 9 4 5 3 2 3 2]
[0 3 8 2 5 5 8 7 8 6]
[8 3 6 8 4 8 5 1 3 9]]
```
В следующих постах я постараюсь рассказать о состязательных сетях в таком же стиле с примерами кода и подготовленными докер-контейнерами, в частности я планирую коснуться таких тем как domain adaptation, style transfer, generative adversarial networks и разобрать несколько наиболее важных статей в этой области.
Upd.1: Как правильно указали в комментариях оборачивать тензоры в *Variable* больше не нужно, поэтому я удалил соответствующу строчку. В докер-контейнере она естественно останется, однако без нее все тоже работает.
Upd.2: Картинки с цифрами былы перепутаны местами, так что я их поменял | https://habr.com/ru/post/358096/ | null | ru | null |
# Модераторы Хабра в лицах: будем знакомы
Я никогда не мечтала быть модератором. Ну то есть, даже мысли не было: хочу или не хочу, в Хабре я занималась совершенно другими вещами. Однако жизнь любит шутить, и 12 июля 2017 года я стала ведущим менеджером по работе с пользователями. Эта должность предполагает кучу функциональных обязанностей, но для пользователей Хабра я именно модератор. Мне казалось, что я неплохо знаю коллег, но изнутри команда оказалась необычной и удивительной, настоящей dream team со своим духом и стилем работы. Мы, модераторы, небольшая команда отдела по ~~борьбе~~ работе с пользователями. Иногда нас спрашивают, а не роботы ли мы. Иногда обижают, иногда сердечно благодарят. С некоторыми пользователями мы дружим, с некоторыми — не очень. Как правило, всё взаимно, всё как у людей.
Мы уже [рассказывали о том, как работает модерация](https://habr.com/ru/company/habr/blog/589587/) — подробно, со смешными примерами и ответами на вопросы. Сегодня мы хотим познакомиться с вами поближе, развеять некоторые мифы, ответить на частые вопросы, рассказать о себе, поделиться некоторыми мыслями, советами, инсайтами и инсайдами. Пойдёмте под кат, я вас со всеми познакомлю!
### Кто все эти люди?!
В структуре Хабра есть отдел по работе с пользователями, который возглавляет [@Boomburum](/users/boomburum). В команде всего несколько человек, но они делают много полезных и нужных для сайта дел (вообще, мы занимаемся всеми проектами, но здесь список конкретно для Хабра):
* занимаются модерацией статей и комментариев на Хабре;
* разбирают Песочницу, выдают инвайты хорошим авторам и отклоняют публикации нарушителей или неподходящие статьи;
* занимаются технической поддержкой пользователей, причём не только Хабра, но вообще всех проектов: Хабра, Карьеры, Фриланса, Q&A
* занимаются технической поддержкой компаний (корпоративных клиентов) в рамках помощи коммерческому департаменту;
* отстаивают права пользователей, право размещения публикаций и делают другую работу, часть которой попадает в transparency report (работа с претензиями третьих лиц и прочими заявителями);
* проводят и помогают проводить все активности Хабра (например конкурс «Технотест»);
* готовят обучающие материалы для пользователей и компаний;
* разрабатывают и пишут справочный раздел и всю документацию, которую вы можете видеть на Хабре;
* решают сложные конфликты, разбирают спорные ситуации, ищут цепочки ботов, альтов и нарушителей;
* информируют пользователей;
* анализируют обратную связь, формируют задачи на разработку и передают их в отделы тестирования и разработки;
* формируют пул кураторов и развивают его *(кстати, если вы опытный, успешный автор, хотите курировать хаб или поток от сообщества, и у вас на это есть время и вдохновение, напишите мне в личку, пообщаемся)*;
* выполняют множество внутренних задач, которые незаметны пользователям, но определяют общий комфорт и удобство использования Хабра.
Это довольно поверхностный список наших задач, потому что каждый из сотрудников кроме всего прочего выполняет задачи, связанные с его профилем, образованием, опытом и т. д. Например, Николай силён в юридических вопросах, Илья отлично раскладывает задачи на слагаемые, Игорь эффективно находит рекламные ссылки и злостных альтоводов, Вика пишет методические материалы и обучающие статьи, Алексей пишет классные анонсы, разбирается с ППА, общается с РКН, занимается обращениями органов и т. д.
Даже по этому короткому списку вы могли заметить, что мы выполняем много ручной работы. Это действительно так, и это одно из важных преимуществ Хабра. Машины и алгоритмы способны закрыть множество рутинных задач, но это бездушный подход, который никогда не учтёт всех факторов, как это может сделать человек. Алгоритмы нам помогают банить пользователей с кармой -31 (срабатывает автоматика и переводит пользователя в режим read only), искать мат, обсценную лексику, некоторые нарушения и рекламные ссылки. Опять же, мы рассматриваем каждое срабатывание, чтобы принять решение: на основе нарушения правил скрипты решение не принимают. А раз много ручной работы, мы все подвержены человеческому фактору: немного устаём, немного выгораем, немного злимся, но стараемся, чтобы это никаким образом не сказалось на пользователях.
### Мифы о модераторах v. 2.0
В [предыдущей статье](https://habr.com/ru/company/habr/blog/589587/) мы уже разобрали несколько мифов о модераторах, но прошло время, и в копилке народного творчества появились новые экземпляры.
#### 1️⃣ У модераторов есть любимые и нелюбимые пользователи
Нет, для нас совершенно все равны, как и перед правилами Хабра. Мы одинаково отзовёмся на просьбу о помощи как опытного пользователя-легенды, так и хамоватого новичка. Однако есть пользователи, которые систематически грубят, игнорируют правила, неадекватно реагируют на общение, угрожают — мы поможем и им, но тёплых отношений может не получиться, вся помощь — в рамках полномочий и формальных рамок. В то время как мы всегда готовы пойти навстречу адекватным и доброжелательным пользователям: помогаем с вёрсткой, подсказываем что-то по темам публикаций, можем прочитать статью до размещения на Хабре и посоветовать правки и т. д. Да, конечно, это исключительно добровольно и в случае форс-мажоров практически невозможно, но в целом мы готовы поддержать всех, кто заинтересован в Хабре и в своём развитии на Хабре.
Однако, если пользователь самый умный и не ставит собеседников ни во что, в совместном развитии нам не по пути. Ни один модератор не станет кого-то преследовать или минусовать, но и секреты хабровского мастерства не откроются :)
#### 2️⃣ Модераторы могут капитально заминусовать и заплюсовать кого угодно
Не могут. С одной стороны, у нас просто нет такого количества плюсов и минусов (у нас такие же аккаунты, как у вас, с теми же возможностями голосования (разве что вес голоса за публикации может быть выше)), с другой — в команде Хабра такое поведение резко осуждается, и никто не будет рисковать репутацией и уважением коллег ради сиюминутной не особо сладкой мести. И вообще — какой смысл в скрутке, если есть физическая возможность обнулить карму или забанить? :-)
#### 3️⃣ С Хабра внезапно «исчезают» статьи, пользователи и комментарии
Они исчезают, но далеко не внезапно, в этом вся соль. Пользователи переходят в режим read only на время или навсегда в случае нарушения правил Хабра, при этом они всегда точно знают причину бана. Статьи исчезают чаще всего по причине того, что их скрывают в черновики сами авторы. Мы скрываем статьи-нарушители правил (реклама, политика, мат, грубость), иногда статьи, не соответствующие формату и тематике Хабра (пустые опросы, видео без расшифровки, совсем уж оголтелый научпоп) и статьи, по которым есть судебные предписания или постановления от РКН (таких крайне мало). Иногда мы скрываем в черновики статьи, которые быстро набирают колоссальное число минусов, особенно если пост кажется не соответствующим тематике Хабра или откровенной провокацией. Эта мера чаще всего направлена на защиту автора от потока негодования аудитории.
С комментариями всё не так скучно: в случае удаления комментария, нарушившего правила, вместе с ним исчезает вся ветка (это логично, т. к. чаще всего поддерживается вектор нарушения, да и ветка без корневого топика теряет смысл). Кстати, нарушившие правила комментарии мы чаще всего обнаруживаем на основе жалоб пользователей, а вот статьи быстрее обнаруживаем сами, потому что за Хабром практически 24/7 приглядывает минимум 2–3 пары глаз (спасибо нашим активным круглосуточным коллегам из информационной службы и лично @denis-19).
#### 4️⃣ Модераторы переписывают фрагменты статей и комментарии
Нет, мы никогда не станем это делать, поскольку речь идёт об авторском контенте, и нам проще и безопаснее обратиться к самому автору и попросить его внести нужные правки (в острых случаях мы можем скрыть статью в черновики до ответа автора). А вот что мы можем исправить:
* любые замеченные орфографические, пунктуационные, лексические и фактические ошибки (их реже всего и чаще всего с предупреждением автора);
* ошибки вёрстки, некрасивую вёрстку, избыточное форматирование;
* мат и нецензурные выражения (меняем на ближайшие приличные слова типа «хрень», «фигня», «заколебался»);
* удаляем рекламные ссылки (можем добавить вот такое примечание [ссылка нарушает правила и удалена мод.]);
* уменьшаем размеры тяжёлых КДПВ и прячем под кат картинки в комментариях (всегда так делайте);
* сокращаем лид (докатный текст), если он занимает несколько абзацев и необоснованно теснит ленту;
* добавляем нужные и удаляем ненужные хабы.
Как видите, ничего из того, что может повлиять на качество, смысл, логику, структуру, основную мысль и подачу текста. Исключительно технические правки на благо авторов и читателей.
#### 5️⃣ Модераторов много
«*Как думаешь, сколько человек модерирует Хабр и отвечает за весь фидбек по всем проектам*?» — если задать такой вопрос даже человеку в теме, то обычно можно услышать ответы типа «*ну, наверное, человек 20, может, 40*». Но нет, нас можно посчитать по пальцам двух рук :-) Трое на фронтенде (на самом Хабре), трое на бэкенде (саппорт и работа с обращениями пользователей) и один на работе с комментариями, новостями и обращениями корпоративных клиентов. На самом деле, это условное деление, потому что, как я уже рассказывала в начале, каждый из нас выполняет по несколько смежных функций, некоторые поддерживают пользователей Хабр Карьеры, Хабр Фриланс и Q&A (у нас на Венере, знаете ли, сутки длинные, вот всё и успеваем).
Дополнительно мы стремимся быть максимально взаимозаменяемыми, чтобы на случай отпуска или форс-мажора замена приходила мгновенно. Такой подход за годы работы обеспечивает высокую квалификацию и гибкость вхождения каждого из нас в разные проекты Хабра (как, например, Технотекст или обучение компаний).
### 👤 Имена, явки и немного компромата
Ну а сейчас мы выйдем из тени и немного расскажем о себе, чтобы вы окончательно могли убедиться насчёт роботов.
---
### Бурум
(он же Boomburum, он же Алексей)
Бурум. Руководитель отдела по работе с пользователями, в Хабре с 2011 года### 1️⃣ Каким Хабр был для тебя до работы и каким стал, когда ты начал работать?
Официально работать в Хабре я начал 27 января аж 2011 года, то есть почти 12 лет назад — это треть моей жизни, ни одно дело в моей жизни не длилось дольше. Но пользоваться Хабром я стал раньше — первый пост был в 2008 году, регистрация в 2007, а за происходящим наблюдал чуть ли не с первых дней.
Когда Хабр только появился, я был активным участником другого сообщества, NNM. Но уже тогда оно начало портиться, поэтому Хабр стал свежим глотком: на тот момент было ничего непонятно, но очень интересно. Зарегистрировался, попробовал, понравилось, освоился. Начал пописывать всякое, начала расти карма, вроде пошло-поехало. Через пару лет заметил Денискин и позвал работать.
Сначала было ощущение, что он сам не понимал, для чего меня позвал :) Начал разбирать тикеты в хелпдеске, генерировать шальные идеи, предложил многое поменять — из того, что я видел как пользователь. Потом то-сё, чем только не занимался. Но почти всегда работа была связана с текстами и общением (всегда открыт — пишите в личку или в одноимённую телегу), чуть меньше с продажами и менеджментом.
Хабр ощутимо поменялся за эти годы, выросла аудитория, повзрослели, пришли новенькие — для меня это отдельный мир, жить в котором очень интересно.
### 2️⃣ Писал ли ты статьи на Хабре? Какие? Даже если не писал — что важно для хорошей статьи на Хабре?
Писал ли я статьи на Хабре? О да. Но несмотря на довольно большой стаж, недавно я преодолел планку лишь в 450 постов. Правда это именно «официальные», написанные на этом аккаунте, а сколько постов за всё время было написано с системных или корпоративных аккаунтов (когда-то я с этого начинал — Intel, ASUS и многие другие компании в рамках контент-услуг) сейчас я даже не знаю, как сосчитать.
Какие? Каких только не было, кажется, я перепробовал все возможные форматы. От банальных [обзоров](https://habr.com/ru/post/90308/), [ликбезных](https://habr.com/ru/post/91646/) и [научпопных](https://habr.com/ru/company/intel/blog/110234/) материалов до [краш-тестов](https://habr.com/ru/company/intel/blog/112608/) (и [этот](https://habr.com/ru/post/365863/)), [скиммерных триллеров](https://habr.com/ru/post/67141/), трансляций [Хабрафутбола](https://habr.com/ru/company/intel/blog/101854/), экскурсий по [офисам](https://habr.com/ru/post/124347/) IT-компаний и 4G-[путешествий](https://habr.com/ru/company/megafon/blog/193090/) по музеям. Но началось всё с DIY — дебютная «[неубиваемая флешка](https://habr.com/ru/post/41152/)» была тепло встречена аудиторией, после чего я решил, что мне надо бы тут что-то ещё рассказать про колхозный моддинг и всевозможные гаджеты (на тот момент я на уровне хобби пописывал ещё в ряд журналов и изданий).
Что важно для хорошей статьи? Считаю, что самое важное — чтобы она была интересной и полезной для читателя, тогда ей простят многие огрехи. Если она аккуратно оформлена, имеет какую-то изюминку, то вообще хорошо. Если со временем выработается узнаваемый стиль и во время чтения будет слышаться «голос автора» — вообще перфекто. В читаемых статьях мне нравится лёгкий стиль изложения, юмор, а также «налёт непонятности» — когда встречаются новые слова или термины, которые интересно погуглить.
### 3️⃣ Что открыл для тебя Хабр?
Если я оказался тут почти сразу после школы, то получается, что Хабр открыл мне дорогу почти ко всему тому, что у меня сейчас есть. Новые знакомства (хорошие и не очень), огромный опыт (удачный и не очень), знания (полезные и не очень). Чертовски благодарен!
### 4️⃣ Что нравится читать на Хабре?
У любой статьи на Хабре есть три возможности «зацепить» читателя: это заголовок, текст до ката и картинка. Если автор потратил (а это чувствуется) время на то, чтобы «отточить» эти три пункта, то у него есть все шансы получить от меня +3 за пост. Если после прочтения в голове пьяняще приятное ощущение от новых знаний, то плюс будет ещё и в карму. И неважно, о чём пост: о прохождении собеседования в Яндексе, что-то по дизайну или научпоп. Хотя статьи о разработке и администрировании я читаю довольно редко: к своему стыду, я ни разу не разработчик, но не теряю надежд освоить python под свои небольшие нужды. Даже интересно, сколько наберёт мой «Как я стал питон-джуном в 50 лет».
Нравится, когда статьи легко читаются и объясняют что-то «на пальцах». Учитесь писать — этот скил довольно легко тренируется и пригодится не только на Хабре. А для этого побольше читайте.
### 5️⃣ Что больше всего нравится и не нравится на Хабре?
Нравится, что ежедневно появляется множество постов, среди которых можно найти что угодно по вкусу и интересам. Что пишется это не куда-то в небо, а для весьма вовлечённой аудитории. И отдельным пунктом нравится осознание того, что работая, мы приносим пользу: с нами люди становятся умнее, а не деградируют.
Не нравится профдеформация: работая, бывает сложно воспринимать Хабр «с колокольни пользователя». Если обычный пользователь может настроить себе ленту, чтобы видеть только интересное ему, то нам приходится видеть вообще всё (и хорошее, и плохое). Иногда расстраивают некоторые пользователи — не скрою, плохишей хватает. Но это не «именно у нас», так везде — будем стараться с этим что-то делать.
### 6️⃣ О себе
Увлечений как таковых нет. Точнее, всё, о чём я подумал в вопросе про хобби, занимает настолько небольшой процент времени в моей жизни, что будет правильней сказать, что увлечений нет. Но попробую что-то выделить то, к чему есть тяга. А тянет: фоткать, рисовать, читать, писать (сейчас это бывает не так часто, но внутри меня что-то копится и рвётся наружу). В свободное время могу залипнуть в ютубе или в плойке. Нравится общаться с интересными людьми. О, а ещё меня очень увлёк ремонт и «управление домом» — мы создали ТСЖ и стараемся наводить порядки, это ппц как интересно (от инженерки до общения с соседями — вокруг нас много классных людей, но часто мы об этом даже не догадываемся).
Из спорта — сейчас начал ходить в зал и на плавание, летом — велик и эпизодические сапы/каяки, на которые в гости приезжали некоторые пользователи Хабра.
«Увлечений как таковых нет» (с) ### 7️⃣ О нём
*Мы опросили друг друга о своих коллегах, и вот что вышло.*
> Как руководитель отдела он прекрасно справляется со своей работой. Но чем он занят весь день — мне не очень понятно. Наверное, я просто не в курсе. Надо отдать должное, Бурум всегда поможет и подскажет, придумает наиболее подходящую формулировку, чтобы вежливо увернуться от ответа, и сообщить пользователю, что мы понятия не имеем, как ответить на его вопрос. Иногда это очень ценный навык. Конечно, так же грамотно он помогает пользователям, и коллегам. Мне нравится, что он не чрезмерно серьёзен, умеет смеяться над собой, и не считает неподобающим поведением появиться на созвоне в костюме розового единорога.
>
>
> Бурум — без преувеличения, лучший руководитель из всех, которые у меня были. Очень нравится его стиль общения с пользователями, умение обходить «острые углы», есть чему у него поучиться.
>
>
> Бурум — продуманный и внимательный руководитель, чуткий и отзывчивый менеджер сообщества, настоящий друг. С первых дней общения меня удивляют его дипломатичность, взвешенность и умение находить точку справедливости в любых вопросах. Это настоящий карбюратор пользовательского комьюнити: смешивает в себе идеи и тренды, зажигает искрой креатива и приводит в движение всю систему. А вот худшая его черта — перфекционизм, иногда хочется статью или идею чик-чик и в продакшен, но не тут-то было :)
>
>
Стена, мел, пара часов времени. Ну совсем нет увлечений (кстати, по свёрнутому ковру бегает кот)
> Ещё пара рисунков: [КиШ](https://habrastorage.org/webt/d_/dp/b9/d_dpb9cocv3kcvzkd8iarpdbjem.jpeg), [Нойз](https://habrastorage.org/webt/6q/vi/lm/6qvilmi5ywinu73j1ftgzpgbmng.jpeg), [Сид](https://habrastorage.org/webt/l6/bt/wt/l6btwtwrw9nk9g6o_zarhd84wdm.jpeg), [Тайсон](https://habrastorage.org/webt/jg/x6/cp/jgx6cpned_nfyoplclhdziokttm.jpeg)
>
>
### 8️⃣ О музыке
У меня лютый винегрет из самых разных стилей самых разных лет. В караоке могу исполнить от Любэ и Круга до Касты и Оксимирона. Но в конце года музыкальные сервисы присылают сводку — согласно им, я больше всего люблю панк-рок (Тараканы, Порнофильмы, Наив, F.P.G, КиШ), тяжёленькое (Metallica, Manowar, Volbeat, Ария), электронное (Armin van Buuren, The Qemists, Pendulum, Black Sun Empire, Skrillex) и рэп (Noize MC, Каста, Заточка, Баста, Корж и 25/17). Ба-дум-тсс!
### 9️⃣ Посоветуй, что посмотреть
Любимый — «1+1» — он и смешной и грустный одновременно, пересматриваю в любой непонятной ситуации. А так — с удовольствием бы пересмотрел «Зелёную милю», «Джентельменов», «Список Шиндлера» и «По соображениям совести».
Из сериалов — «Игра престолов», «Сыны анархии», «Во все тяжкие» и, пожалуй, «Йеллоустоун». На новогодних посмотрел первый сезон «Шантарама», но продолжения, кажется, не будет.
### 🔟 Посоветуй книгу
У меня много интересных книг, но я едва себя заставляю их читать, так что ничего путного не посоветую. Последнее, что прочитал — «Пиши, ленивая \*опа*»,* на одном дыхании. «Вскрытие покажет» (записки судмедэксперта — довольно увлекательно о том, что будет в самом конце). А если из «по теме Хабра», то пусть будет старенькая «Тестирование Дот Ком» — написана очень в духе Хабра. Но в этом году планирую начать больше читать — сколько можно тянуть-то?!
\* \* \*
Всё, что выше, мне немного напомнило начальные классы школы, когда девочки создавали «тетрадки друзей» с анкетами, через которые они наводили справки об увлечениях, друзьях и том, кто в кого «втюрился» :)
---
### Коля
Прагматик, Николай. Старший менеджер по коммуникациям с пользователями, в Хабре с 2015 года### 1️⃣ Каким Хабр был для тебя до работы и каким стал, когда ты начал работать?
Хабр для меня как был, так и остался ресурсом со своеобразной аудиторией. Разве что видеть этого своеобразия я стал гораздо больше. Я узнал, что некоторые пользователи постоянно пытаются принудить администраторов Хабра отстаивать их взгляды на жизнь и цензурировать, в соответствии с этими их взглядами, материалы других пользователей. Сложно представить, сколько раз моё юридическое образование помогало мне защитить материалы пользователей от посягательств разных сутяжников.
### 2️⃣ Писал ли ты статьи на Хабре? Какие? Даже если не писал — что важно для хорошей статьи на Хабре?
Я написал несколько статей по вопросам, казавшимся мне общественно значимыми. Дважды карму моего аккаунта сливали до -20, и приходилось выкарабкиваться из кармаямы, публикуя более нейтральные тексты. Сегодня я бы и сам поставил минусы тем своим статьям. Новые тексты мне приходится вместо Хабра публиковать в научных журналах, чтобы была возможность сослаться на них в отчёте по науке, который ежегодно приходится сдавать в том вузе, где я, в свободное от работы на Хабр время, преподаю юриспруденцию. Времени и сил писать на Хабр уже просто не остаётся.
### 3️⃣ Что нравится читать на Хабре?
Люблю читать материалы в формате расследований и баек. У меня даже есть список любимых публикаций, написанных пользователями Хабра:
* [После подключения бесперебойника программа больше не работает](https://habr.com/ru/company/pvs-studio/blog/191824/)
* [Как я покупал 3D-принтер](https://habr.com/ru/post/205038/)
* [Тест памяти, убивающий ноутбуки — почти детектив](https://habr.com/ru/post/413469/)
* [Когда 'a' не равно 'а'. По следам одного взлома](https://habr.com/ru/post/465355/)
* [Диалоги с пользователями — истории от техподдержки](https://habr.com/ru/post/653053/)
### 4️⃣ О себе
Я люблю спать (*Он почти не спит и доступен 24/7. Это одна из загадок нашего отдела. — прим. авт.*).
### 5️⃣ О нём
> Коля — чел, который постоянно подкалывает Бурума, иногда бывает смешно. Как мне кажется, многое знает про все сервисы Хабра, так сказать, человек-швейцарский-нож.
>
>
> Коля — в целом толковый парень, педантичный и «близкий по духу» спустя много лет. Но иногда, бывает, зудит не по делу и ленится.
>
>
> Это скромный, агрессивный эрудит. Добрый, отзывчивый, с повышенным чувством ответственности, готовый помочь всегда и всегда знающий, что делать. Активного отдыха и развлечений избегает, предпочитая общение с умными людьми и чтение литературы.
>
>
> Коля — один из самых эрудированных людей, которых я знала (а знала я немало — 8 лет в «Что? Где? Когда?»). Способен грамотно и серьёзно ответить даже самому неадекватному пользователю, чем выручает в опасных моментах. 11 высших образований дают о себе знать.
>
>
Прилип к парте на всю жизнь### 6️⃣ О музыке
Я меломан, способный с равным удовольствием слушать попсу, готику, шансон или рок. Тяжело мне даётся только русский рэп, за исключением разве что парочки текстов Кровостока, Касты и Басты. В последний год слушаю преимущественно [Sotiria](https://www.youtube.com/channel/UCiCR_wtQBQslsUWKhyrADYg), [Unheilig](https://www.youtube.com/channel/UCje901lPcWk0m_WVUjyNN_A), [RADIO TAPOK](https://www.youtube.com/@RADIOTAPOK) и [Plamenev](https://www.youtube.com/@Plamenev), а ещё меня буквально заворожила песня «[Эффект соляриса](https://www.youtube.com/watch?v=NtSt4lKeLsQ)», до неё я так часто переслушивал только «Куклу колдуна».
### 7️⃣ Посоветуй, что посмотреть
Однозначно рекомендую «Никто» (2021) – отличные актёры и реплики, нет провисаний сюжета. Наряду с ним, я не менее раза в месяц пересматриваю фильмы «Джентльмены» и «Расплата» (2016). Не менее раза в год пересматриваю «Призраки бывших подружек», «Рождество на двоих», «Дом у озера», «Зеленая книга», «Иллюзия обмана», «Джанго» и «Бесславные ублюдки», а также первые сезоны Шерлока и Нюхача. Ещё на меня произвели впечатление сериалы «Пацаны», «Форс-мажоры», «Миллиарды», «Битва за Uber», «Кремниевая долина», «ТБВ» и «Лучше звоните Солу». Но пересматривать их пока почему-то не тянет.
### 8️⃣ Посоветуй деловую книгу
Из того, что я прочитал с удовольствием, к деловым можно отнести разве что «Чертоги разума. Убей в себе идиота!» Андрея Курпатова. Ну, ещё с определённой натяжкой «Атлант расправил плечи». Но в последние годы я почти не читаю такое, т. к. деловых текстов мне хватает на работе. Чтобы эмоционально отдохнуть от работы, я читаю фэнтези, LitRPG и книги про попаданцев. Иногда нахожу время отмечать прочитанное в своём профиле на [LiveLib](https://www.livelib.ru/reader/pragmatik). Но по факту там отмечена в лучшем случае 1/10 часть от всего мною прочитанного.
---
### Илья
Илья. Менеджер по коммуникациям с пользователями, в Хабре с 2021 года### 1️⃣ Каким Хабр был для тебя до работы и каким стал, когда ты начал работать?
Я знаю о Хабре с конца 2000-х годов. В то время был активным участником форумов по портативной электронике, и там активно обсуждались статьи с Хабра. Хабр казался таким серьёзным, почти научным сообществом авторитетных людей. Сейчас я вижу, что здесь, как и в жизни, есть люди разной квалификации и разной компетенции. Кто-то приходит сюда ради рекламы, кто-то — в общественно-образовательных целях. А кто-то умудряется совмещать и то, и другое. Но какой бы ни была цель, для меня люди, создающие информацию, находятся на ступень выше в пирамиде потребностей, чем люди, потребляющие информацию. Эти люди нужны обществу, и их надо поддерживать. Это что касается сообщества. А об изнанке Хабра как о сообществе разработчиков, модераторов, дизайнеров и людей других специальностей, которые каждый день работают, чтобы дать авторам площадку для самовыражения, а миллионы читателей обеспечить качественным контентом — я и не думал никогда. Пока сам туда не попал. Тогда я увидел, как непросто ассоциировать себя и с авторами, и с читателями. С одной стороны, следить, чтобы авторам было комфортно, чтобы они хотели писать и делали это. А с другой — фильтровать контент, не допускать замусоривания ресурса и информационного поля, не пропускать то, что, по нашему опыту, не найдёт отклика в читателях, некачественный, неполезный и неинтересный материал. Это же касается и комментариев. С одной стороны, нужно дать свободу для общения, а с другой, — понимать, что комментарии — это в первую очередь дополнение к статье, нужное для раскрытия того, что автор раскрыл не до конца. И в последнюю очередь — это площадка для выяснения взаимоотношений внутри сообщества.
### 2️⃣ Писал ли ты статьи на Хабре? Какие? Даже если не писал — что важно для хорошей статьи на Хабре?
Я статьи на Хабре не писал, но хочу когда-нибудь это сделать. Считаю, что для хорошей статьи важно:
1. Выбор темы. В идеале, она должна быть интересной и полезной широкому кругу людей. Но если она не очень интересна широкому кругу, то значит, должна быть очень интересна и очень полезна узкому кругу. Попросту говоря, уникальной (but unique doesn't mean useful), и при этом, полезной. :)
2. Повествование должно быть грамотно структурировано и написано понятным для целевой аудитории языком. При этом желательно избегать перегруженности информацией в одном участке текста. Сложные моменты должны быть равномерно перемешаны с простыми. Так текст лучше усваивается и легче читается. Иначе, одни участки сложно читать, а другие хочется пролистать, поскольку в них одна «вода».
3. Грамотность. Статья должна быть написана грамотным, красивым языком и без ошибок. Если вы красиво сочиняете текст, но не справляетесь со всеми заковырками великого и могучего, то попросите грамотного товарища вычитать вашу статью и исправить все ошибки, а уже потом публикуйте.
### 3️⃣ Что открыл для тебя Хабр?
Хабр открыл для меня людей, ежедневно трудящихся на информационном фронте. Статьи и новости сами собой не пишутся, для этого нужно создавать и поддерживать инфраструктуру. Это и есть Хабр изнутри.
### 4️⃣ Что нравится читать на Хабре?
Читаю статьи на научную и околонаучную тематику, DIY-проекты, а также историю и тенденции космической отрасли, автомобилестроение, электромобили и иногда читаю статьи о здоровье (или отклонениях от него).
### 5️⃣ О себе
Я всегда был очень активным. Что-то изобретал, придумывал, собирал, улучшал и дорабатывал. Я с техникой ближе, чем на «ты». Знаю, как всё устроено, и многое могу починить, люблю дорабатывать и улучшать вещи. В школьные годы учёба была мне неинтересна, я познавал жизнь, почти всё время проводил на улице, в разных компаниях. В институте пришло понимание, что нужны какие-то знания и навыки, но институт их не давал. Тогда я поступил на второй диплом, MBA. В итоге главное, чему я научился в институте, — это общению с людьми, достижению поставленных целей любым способом, а также тому, что порой харизмой и уверенностью в себе можно заменить даже труд и знания. Не знаешь, как правильно? Заставь других сомневаться, что они знают, и вместе вы узнаете, как правильно. :) А также тому, что всему, что нужно в жизни, нужно учиться самостоятельно. Система высшего образования (по крайней мере та, с которой я столкнулся) не работает. Более того, она вредит обществу, тратя ресурсы и бесценное время жизни людей на просиживание попа-часов и очень медленное получение ненужных и устаревших знаний. Но это уже тема отдельного разговора.
Мои хобби и увлечения неразрывно связаны с моей жизнью. Основных увлечений два. Первое — это двухколёсный транспорт. Я с 13 лет езжу на скутерах и мотоциклах. Сейчас мне 34, и я не представляю без этого свою жизнь. Я провёл огромное количество времени в этой среде, за рулём разных классов двухколёсной техники. У меня много друзей из этой, с позволения сказать, культуры. И даже жену я нашёл на соревнованиях по мотождимхане. Это наше семейное увлечение.
Второе жизнеобразующее хобби — это внедорожные путешествия. Я очень люблю поездки в различные дикие и труднодоступные места, регулярно путешествую с женой в одну машину или с клубом внедорожного туризма. Особенно сильно ощущаешь всю хрупкость, локальность и ничтожность мирка, обёрнутого в социальную оболочку и построенного искусственно вокруг нас, когда удаётся из него вырваться. Хочется почаще напоминать себе об этом. Такие путешествия вызывают зависимость, во все места хочется возвращаться снова и снова, и чем больше расширяешь горизонты — тем в большее количество мест хочется возвращаться.
### 6️⃣ О нём
> Я иногда «зависаю» на Хабре и забываю про help desk. Илья — тот человек, который выбирает и назначает на меня самые отборные тикеты, приходящие с Хабра, спасибо ему за это (не шутка и не сарказм).
>
>
> Я не сразу поладила с Ильёй, а сейчас думаю, что иногда первое впечатление беспощадно врёт. Илья строгий, но вдумчивый, серьёзный, по-настоящему озабочен проблемами пользователей и готов о них говорить на любом уровне. К тому же, интересный человек. Мне нравится, когда люди в команде активные и вовлечённые. Это про него.
>
>
Выше суеты### 7️⃣ Что больше всего нравится и не нравится на Хабре?
Долго думал, с какой стороны подойти к ответу на этот вопрос: как пользователь или работник Хабра? Но по-моему, мой ответ будет универсален с обеих сторон.
Мне не нравится медлительность и неповоротливость организационно-исполнительной системы. Долго не могут решиться какие-то проблемы, которые, казалось бы, для таких прогрессивных управленцев и таких талантливых программистов не должны вызывать ступора.
А нравится мне тут коллектив, подходы к принятию текущих, оперативных решений на своих уровнях, построение рабочих процессов, и конечно то, что мы все и наши проекты даём Рунету.
### 8️⃣ О музыке
Свой музыкальный репертуар я не обновлял уже много лет. В моём плейлисте в основном рок, российский и зарубежный, индастриал-метал, немного рэпа старых российских групп.
### 9️⃣ Посоветуй, что посмотреть
Хранители (Watchmen), 2009г. Фантастическая история о героях, борющихся с преступностью в середине 20 века в Америке, но постепенно самих становящихся преступниками в том или ином виде. Об их борьбе с самими собой, как каждый на своём уровне борется с тем, что считает злом: от товарищей до глобальной мировой угрозы. Фильм затрагивает глобальные этические проблемы и заставляет думать о прошлом и будущем и многогранности этого мира.
---
### Вика
aka [@Exosphere](/users/exosphere)
Вика. Ведущий менеджер по работе с пользователями, в Хабре с 2015 года### 1️⃣ Каким Хабр был для тебя до работы и каким стал, когда ты начал работать?
До непосредственной работы здесь Хабр какое-то время был частью моей прежней работы: я вела блоги компаний и немного партизанила (за что и была поймана Бурумом). Для малого бизнеса, в котором я была руководителем отдела IT-маркетинга, Хабр — серьёзная и важная площадка для пиара и общения с целевой аудиторией, важно отвечать за всё, что ты на нём пишешь (жаль, это не всем очевидно). Хабр мне казался невероятным монолитным великаном.
Когда я пришла в команду Хабра, он стал «моим всем»: тот случай, когда проект и ты — душа к душе, и на работу приятно просыпаться. Хабр остался великаном, но изнутри видно, что это не монолит, а сложная, гибкая и подвижная экосистема. Мне стали ближе и пользователи, и компании, потому что я понимаю их задачи и проблемы, знаю, как Хабр может помочь их решить. Мне нравится, насколько близко соприкасаются команда, авторы и читатели, хотя извне этого совершенно не видно. Это отличает Хабр от других UGC-площадок.
### 2️⃣ Писала ли ты статьи на Хабре? Какие? Даже если не писала — что важно для хорошей статьи на Хабре?
Да, на Хабр я писала много (чаще — как автор для компаний, сейчас только подсказываю и иногда редактирую на добровольных началах), сейчас — меньше из-за смены должностных обязанностей. У меня есть [личный аккаунт](https://habr.com/ru/users/Verovir/posts/), где я пишу, в основном, о нижегородских событиях (Нижний Новгород — сильный IT-агломерат, поэтому часто есть о чём рассказать) и [модераторский аккаунт](https://habr.com/ru/users/Exosphere/posts/), с которого я пишу о Хабре, обучении, образовании и т. д. Мне важно давать аудитории полезные материалы, которые помогают писать смелее и лучше.
Можно часами говорить о том, какой должна быть хорошая статья на Хабре, я выделю несколько основных пунктов.
* **Честность.** В статье (неважно, для личного она блога или для компании) должна быть достоверная информация, основанная на опыте автора или на том, в чём он неплохо разбирается. Вы даже не представляете, как заметны «реферативные» публикации, в которых автор компилирует информацию, просто чтобы «забить» эфир и выполнить план. Честная статья вовлечённого автора — всегда выигрышный формат. Я даже приведу пример простейшего материала, который сразу покорил аудиторию (хотя казалось бы!): [Кейс: Как ошибка в рекламе принесла прибыль в 600 000 рублей](https://habr.com/ru/post/692810/). Причина успеха: искренние эмоции автора, честность и немного приключений. Я специально привела в пример нетехническую статью, на ней принцип честности лучше ощущается. Ну а из технических — вот, буквально свежий праздничный пример: [Как запустить Doom на УАЗ Буханке 2022](https://habr.com/ru/post/709392/). Такое не выдумаешь.
* **Польза.** Статья должна быть полезной: нести практическую ценность, быть применимой в управлении и разработке, развивать эрудицию, вовлекать любознательность. Она не должна пройти мимо, читатель должен что-то из неё вынести: так формируется связь автора и читателя, на этом держится классное коммьюнити Хабра.
* **Интерес.** На самом деле, не самый важный фактор успеха публикации, но если она классно читается, то шансы значительно выше. Интересных статей на Хабре очень много, но я хочу привести пример: я читаю каждую статью PVS-Studio, хотя последний раз кодила в 2014 году. Их публикации выглядят, как расследования, и ты втягиваешься, даже если с трудом читаешь код. Потому что интересно и захватывающе. Из новых авторов порадовал, например, этот: [Поэтический редактор: Rust + Tauri](https://habr.com/ru/post/710594/).
* **Фактчекинг.** С ним бывает не очень хорошо: на моей памяти были домашние колонки со звуком «до 850 дБ», лоза персика, много ошибок в коде, фото, подписанные совсем не тем, что на них изображено, и прочее. Чаще всего это банальные опечатки и невнимательность, но одновременно это безразличие к тексту, нежелание вычитать и понять. Бывали истории и посерьёзнее, когда автор выдавал ложную научную теорию за истину или подменял научные тезисы (кстати, таких непризнанных гениев и изобретателей всегда очень много в модераторской Песочнице). Все данные в статье необходимо тщательно проверять, чтобы какая-то мелочь не испортила впечатление об отличном материале.
* **Полнота изложения.** Не бойтесь рассказывать подробности, раскрывать важные моменты и вести ровную линию повествования: кому интересно, прочитают, кто всё понял — проскроллит лишние для него абзацы. Так вы охватываете более широкую аудиторию и становитесь понятнее большему количеству читателей.
* **Форма.** Тоже факультативный фактор, но он способен прокачать любой текст. Если поработать над текстом чуть дольше, выбрать форму и стиль подачи, получается хорошо: такой текст приятно читать. На Хабре можно найти десятки форм подачи: от научных статей до стихотворных материалов. Общая насмотренность помогает выбрать удачный или придумать свой. Так что читайте Хабр, это формирует приличный стиль и даёт вдохновение.
### 3️⃣ Что нравится читать на Хабре?
Всегда интересно читать про DIY-проекты, потому что такие статьи получаются искренними, интересными и местами захватывающими. Из DIY люблю всё, что связано с ботаникой, гидропоникой, домашним фермерством. Никогда не решусь на такой проект сама, но вглядываться в детали и вдумчиво читать описания таких проектов, видеть результат — сплошное удовольствие.
Парадоксально, но люблю хорошие статьи в хабах Биология, Здоровье, Биотехнологии, Мозг. Они коррелируют с моими увлечениями вне работы, и всё, что написано профессионалами со знанием дела, актуально и интересно. На третьем месте среди предпочтений — статьи об изучении языков от обычных пользователей, которые преподают языки. Иногда открываешь для себя невероятные связи языков и технологий, находишь неожиданные инсайты в изучении и думаешь: «Ну как же я до этого сама не дошла!»
Но самое удивительное — когда я сижу и читаю сложные статьи по программированию. Я обучалась полтора года на программиста, работала несколько лет инженером, но код практически не писала — так, на уровне рабочих скриптов и запросов. Если я ловлю себя на чтении статьи о «кишочках» разработки, значит, написано очень круто и захватывающе. Хабр стоило придумать хотя бы ради таких статей.
Тем, кто только знакомится с Хабром, могу посоветовать практиковаться в написании текстов и тренировать насмотренность на [победителях «Технотекстов»](https://habr.com/ru/company/habr/blog/677942/). Это не всё лучшее с Хабра, но неплохая выборка.
### 4️⃣ О себе
Люблю цитату из «Королевы бензоколонки»: «Нет, я не изменила мечте, просто мечту изменила». Изменяю постоянно, поэтому увлечений много. Однако страстных и постоянных не так много: дача и всё, что с ней связано, автомобили, медицина и клиническая психология, мода и парфюмерия как искусство. Несмотря на то, что я айтишник по жизни, по духу и призванию, я всё же человек естественно-научного профиля, собственно, с этим основные увлечения и связаны.
Рубль штучка, пять рублей кучка, кучка пять штучка :-) На самом деле, морковь — редкий гость на грядках, занимаюсь ягодами, цветами и перцами.Сейчас довольно мало свободного времени, поэтому и на увлечения остаётся почти ничего :-) Зато я смело могу сказать, что Хабр — тоже моё хобби, мне нравится писать статьи, готовить какие-то методические и обучающие материалы даже в свободное время. Когда читаешь отзывы и знаешь, что была полезна — это окрыляет.
### 5️⃣ О ней
> Викуся — вздорная, но очень умная и трудолюбивая. (*Иногда доводят, иногда довожу — прим. авт.*)
>
>
> Вика зе бест :) Прекрасный сотрудник и близкий друг даже «вне работы».
>
>
> В высшей степени профессиональна и трудолюбива. Она, можно сказать, HR для всей прибывающей аудитории авторов Хабра. Когда люди приходят, желая написать свою первую статью, то, сами того не осознавая, они должны понравиться Вике, чтобы пройти на следующий уровень. Объём её работы, а также необходимость разбираться в куче разношерстных тем вызывает уважение.
>
>
> Наставник и ментор, помогает мне во всём. Со всеми вопросами и проблемами иду сначала к ней, знаю, что поможет и разрулит.
>
>
Cтоянка ретро-ралли «Пекин-Париж» в Нижнем Новгороде, я была в составе support team на нашем этапе ### 6️⃣ Что больше всего нравится и не нравится на Хабре?
В Хабре нравится то, ради чего он и существует: классные авторы, интересные статьи и прогрессивная команда. Вообще команда Хабра — это самостоятельное сообщество, союз по-настоящему сильных и самостоятельных профессионалов. Иногда мы искрим, но в целом работаем слаженно и на равных. Я сменила пять рабочих команд, мне есть с чем сравнивать: по уровню самостоятельности и погружения в работу Хабр ведёт с разгромным счётом.
Не нравится, когда Хабр используют утилитарно и грубо, преследуя исключительно рекламные или сугубо личные интересы: чтобы покрасоваться «нестандартным мнением», посмотреть на читателей свысока. Не нравится, когда оскорбляют модераторов и подходят к нам с позиций обслуги. Конструктивный диалог всегда даёт приятные плоды, споры раздражают и портят настроение всем сторонам конфликта.
Что там с Dota на УАЗ? :-)### 7️⃣ О музыке
Совершенно всеядна, в плейлисте музыка всех направлений, времён и многих народов. Иногда могу зациклиться на одном треке и слушать его изо дня в день. Из того, что «пробирает» абсолютно в любом настроении: Владимир Высоцкий. Это исполнитель, на песнях которого я выросла, с которым я прошла сложные времена, у которого всегда есть нужные слова.
### 8️⃣ Посоветуй, что посмотреть
* «Блеф» с Адриано Челентано
* «Двое в городе» с Аленом Делоном
* Из более современного — «Меланхолия»
### 9️⃣ Посоветуй деловую книгу
Хотели в этой статье собрать список деловых книг, но как-то не сложилось. Мне кажется, каждый читает то, что соответствует его увлечениям и мировоззрению. Из последнего всем советую прочитать Дейла Бредесена «Нестареющий мозг» и другие его книги («Мозг вне возраста» и «Протокол Альцгеймера»). Это важные книги для будущего каждого из нас, потому что вопрос сохранности интеллекта гораздо серьёзнее, чем мы, молодые, сейчас думаем. Сразу оговорюсь: много специальной терминологии и есть некоторые спорные моменты, но в целом отрезвляет и встряхивает.
---
### Игорь
Игорь. Менеджер по коммуникациям с пользователями, в Хабре с 2022 года### 1️⃣ Каким Хабр был для тебя до работы и каким стал, когда ты начал работать?
Сейчас, когда захожу на Хабр, говорю себе — «нифига себе, я тут работаю, круто-круто!»
До работы в Хабре попадалось некоторое количество статей с хорошим содержанием, но плохим оформлением, руки чесались поправить оформление. С приходом в Хабр у меня появилась возможность исправить это. Стараюсь по мере возможности у каждой проверяемой мной статьи «причесать» вёрстку, если требуется, чтобы статью было приятно и удобно читать.
### 2️⃣ Писал ли ты статьи на Хабре? Какие? Даже если не писал — что важно для хорошей статьи на Хабре?
Не писал. Дальше идёт личное мнение дилетанта. Для хорошей статьи важно, чтобы тебе нравилось то, о чём ты пишешь. Считаю, что один из критериев хорошей и ценной статьи именно на Хабре — взгляд автора на проблему с точки зрения собственного опыта. Также важно раскрыть тему, «копнуть поглубже», а не бежать «по верхам». Автору не нужно торопиться публиковать статью, она не должна подаваться на стол читателя «полуфабрикатом». После написания она должна «настояться», возможно, потребуется добавить каких-либо ингредиентов, «поперчить-посолить», слить лишнюю воду или наоборот добавить, если слишком сухо. Как-то так.
### 3️⃣ Что открыл для тебя Хабр?
Хабр как новое место работы, можно сказать, перезагрузил мою «карьеру». Плюс разблокировал новый уровень — «удалённая работа», т. к. раньше такого опыта не было.
Прошлая работа, до Хабра, была связана с сетевыми технологиями. Очень сильно прокачала мои знания серия статей, которая началась на Хабре — «[Сети для самых маленьких](https://habr.com/ru/post/134892/)». Также Хабр незаменим в плане информации о прохождении собеседований и прочих карьерных штуках, которую получаешь, так сказать, из первых рук, как в самих статьях, так и в комментариях.
### 4️⃣ Что нравится читать на Хабре?
Нравятся статьи про какие-то низкоуровневые вещи, реверс-инжиниринг, взлом, linux, языки программирования, после прочтения которых обычно звучит фраза «ничего не понял, но очень интересно». Нравятся статьи-переводы у автора [@PatientZero](/users/patientzero): у него отличный выбор материалов для переводов. С интересом читаю некоторые статьи из хаба «DIY или Сделай сам».
Очень нравятся статьи, где автор при описании какой-либо технологии сразу лезет «под капот», пытаясь разобраться, как всё работает изнутри, при этом описывает собственный опыт.
Прикольно бывает читать статьи, где собственный опыт пересекается с опытом автора, который он описывает в статье.
Ну и, конечно же, комменты к статьям, где порой бывает «самое вкусное».
### 5️⃣ О себе
Раньше любил играть в компьютерные игры, но с рождением детей это увлечение сошло на нет, думаю, когда они подрастут, будем вместе играть.
Время от времени люблю покрутить кубик Рубика, некоторое время назад увлекался, учил какие-то алгоритмы для скоростной сборки. Но, конечно, в свободное время я больше читаю и провожу с детьми, нежели кручу кубик :-)
Программирую в своё удовольствие на Python и Go, в планах освоить Rust. Пытаюсь автоматизировать некоторые части своей работы, написал для себя пару-тройку скриптов с помощью которых проверяю статьи и комментарии на нарушения правил Хабра.
Из-за сидячей работы стараюсь поддерживать физическую форму и периодически делаю подходы к турнику и брусьям, правда, в последнее время получается реже в связи с рождением второго ребёнка. Компенсирую нехватку физической активности прогулками с детьми, иногда ухожу гулять с коляской на 1–3 часа, в зависимости от сезона.
### 6️⃣ О нём
> Игорь — основательный, умный, технически подкованный.
>
>
> Ответственный и крутой человечек.
>
>
> То, как быстро Игорь влился в рабочие процессы, и качество его работы вызывает уважение. Насколько я могу судить, он выполняет возложенные на него задачи так, как будто всегда здесь работал! Вежливый, неконфликтный, всегда находит нужные слова и в курсе всех процессов.
>
>
> Игорь удивил скоростью входа в работу, системным подходом и желанием разбираться и развиваться. Горжусь, что выбрала среди десятков кандидатов и не прогадала: бывшие телекомовцы рулят ;-)
>
>
### 7️⃣ Что больше всего нравится и не нравится на Хабре?
Для меня Хабр — это место, где собираются люди, у которых есть чему поучиться. Нравятся обсуждения, споры в комментариях в том смысле, что публика разноплановая, с разным бэкграундом, призма жизненного опыта у всех разная, с разными гранями, из-за этого можно посмотреть на обсуждаемые темы под разным углом, с разных точек зрения.
Не нравится, что некоторые пользователи, даже те, которые на Хабре давно, не хотят понимать/принимать тот факт, что Хабр — тематический ресурс определённой направленности. Да, некоторые границы слегка размыты, но это не означает, что сюда можно тащить всё подряд под разными предлогами.
Как читателю, не нравятся битые ссылки на картинки в статьях того времени, когда ещё не было habrastorage.
### 8️⃣ О музыке
Я старомоден в этом плане, музыкальные предпочтения не изменились со времён моей молодости, в основном слушаю ту же музыку, которую слушал 20-25 лет назад: это Wu-Tang, Onyx, какие-то вещи, спродюсированные DJ Premier, и всё в этом духе из 90 годов(на самом деле список большой), некоторые называют тот период «золотой эрой хип-хопа».
### 9️⃣ Посоветуй, что посмотреть
После вопроса «Какую музыку слушаешь?» почему-то сразу вспомнился фильм «Пёс-призрак: Путь самурая», в свое время очень зацепил этот фильм, возможно, из-за музыкальных предпочтений(музыку к фильму написал RZA, поклонники Wu-Tang Clan меня поймут), интересный сюжет, смешение жанров, этакая самурайская философия на современный лад. Пересматривал несколько раз. Помнится, потом даже книжку купил «Хагакурэ. Сокрытое в листве. Кодекс чести самурая».
Из современного очень зашел сериал «Разделение» из-за необычного сюжета.
### Молодые ветра
Ещё у нас есть Тимур — он не модератор как таковой, но здорово помогает работать с комментариями и обращениями сотрудников компаний по техническим вопросам.
У нас был сотрудник техподдержки Дмитрий из Санкт-Петербурга, с юрфака. Недавно он перешёл в другую компанию и ему на смену пришёл Дмитрий из Санкт-Петербурга, с юрфака. Дима работает совсем недавно, и мы сами с ним ещё не очень близко знакомы, но уже оценили, как быстро он включился в работу. Впрочем, в Хабре включаться медленно вообще не принято. Пользуясь случаем, приветствую Диму в команде — Дим, ты в телевизоре :-)
А ещё ребята учатся и совмещают обучение с работой — это заслуживает большого уважения и внушает уверенность в их будущем. Мы поддержим 🙂
---
Такая вот у нас разная и в то же время слаженная и дружная команда модерации — тех людей, которые незримо всегда с вами и готовы прийти на помощь.
Напоминаю, что вызвать Бурума, меня или Игоря [теперь](https://habr.com/ru/company/habr/blog/707170/) можно универсальным упоминанием @moderator.
Если вы давно читаете Хабр и мечтаете на него писать, у вас есть идея статьи, но что-то пугает или смущает, обязательно пишите мне в личку или на почту viki@habr.team — я отвечу на вопросы, оценю черновик, предложу направления редактирования, и вы сможете стать полноценным автором.
---
Статьи по теме:
* [Как работает модерация на Хабре](https://habr.com/ru/company/habr/blog/589587/)
* [Как Хабр взаимодействует с госорганами и другими заявителями](https://habr.com/ru/company/habr/blog/488088/)
* [Информационная служба Хабра рассказывает о себе и своей работе](https://habr.com/ru/company/habr/blog/704046/)
> Нашли опечатку в тексте? Выделите и нажмите `CTRL/⌘+Enter`
>
> | https://habr.com/ru/post/712800/ | null | ru | null |
# ООП в JavaScript
В данной статье мы поговорим об основных особенностях объектно-ориентированного программирования в JavaScript:
* создание объектов,
* функция-конструктор,
* инкапсуляция через замыкания,
* полиморфизм и ключевые слова `call/apply`,
* наследование и способы его реализации.
### Объекты в JavaScript
Объект в JavaScript — это ассоциативный массив, который содержит в себе наборы пар ключ-значение («хэш», «объект», «ассоциативный массив» означают в JavaScript одно и то же).
Создание объекта в JavaScript:
```
var obj = new Object(); // вызов функции конструктора
var obj = {}; // при помощи фигурных скобок.
```
Задание свойств объекта:
```
obj.name = ‘Victor’; // через .property
obj[‘name’]=‘Victor’; // как элементу массива
```
Обращение к свойствам:
```
console.log(obj.name); // через .property
console.log(obj[‘name’]); // как к элементу массива через квадратные скобки
```
Расширенный вариант:
```
var obj = {
name : ’Viktor’,
age : 32
};
```
### Constructor и ключевое слово new
«*Конструктор — это любая функция, которая используется как конструктор*». До появления ECMAScript 6 в JavaScript не было понятия конструктор. Им могла быть любая функция, которая вызывается с помощью ключевого слова `new`.
Пример использования конструктора:
```
var Donkey = function(){ //… }; // создаем объект «ослик»
var iaDonkey = new Donkey();
```
При вызове new Donkey (), JavaScript делает четыре вещи:
1. 1. Создаёт новый объект:
`iaDonkey = new Object(); // присваивается новый пустой объект.`
2. 2. Помещает свойства конструктора объекта Donkey:
`aDonkey.constructor == Donkey // true`
`iaDonkey instanceof Donkey // true`
3. 3. Устанавливает объект для переноса в Donkey.prototype:
`iaDonkey.__proto__ = Donkey.prototype`
4. 4. Вызывает Donkey() в контексте нового объекта:
```
var iaDonkey = function(){
this.constructor(); // function Donkey()
// …
};
```
```
// То же самое, только на грубом псевдокоде:
function New (F, args) {
/*1*/ var n = {'__proto__': F.prototype};
/*2*/ F.apply(n, args);
/*3*/ return n;
}
```
1. Создание нового значения (n) и запись значения `prototype` в `proto`.
2. Вызов нашего метода конструктор через `apply`.
3. Возвращение нового объекта, класса `New`.
### Инкапсуляция через замыкания
Замыкание — это основанный на области видимости механизм, который может создаваться через функцию. Каждая функция создаёт новую область видимости.
Рассмотрим два примера.
Пример 1:
```
for (var i = 0; i < 10; i++) {
setTimeout(function () { console.log(i); }, 0);
}
```
В этом цикле десятка выводится на экран десять раз: после последней итерации будет 10, и тогда начнётся выполнение `setTimeout`.
Пример 2:
```
for (var i = 0; i < 10; i++) {
(function (m) {
setTimeout(function () { console.log(m); },0);
})(i)
}
```
Анонимная самовызывающаяся функция позволяет начать выполнение функции сразу после ее объявления.
Мы применили принцип замыкания: объявляем функцию, передаем в неё фактическое значение, и она «замыкает» в себе значение переменной `i. m` попытается через замыкания получить значение из ближайшей верхней *области видимости*. А так как мы передали ее через самовызывающуюся функцию, то она каждый раз будет равна своему значению (значению переменной `i`), и мы 10 раз получим от 0 до 9.
Этот пример про замыкания и инкапсуляцию взят из реального проекта:
Есть функция `BarChart`, у нее есть публичные методы — построить график и обновить его значения. Есть приватные методы и свойства — что нам нужно выполнять, не показывая это окружающему миру.
Если мы обратимся к `BarChart` через `new`, то получится, что это функция-конструктор, и мы создадим новый объект этого класса. Но все приватные методы замкнутся в этой переменной, и мы сможем обращаться к ним внутри. Они останутся в области видимости, которую создаст эта функция.
### Полиморфизм и ключевые слова call/apply
Применение конструкции `apply`:
```
var obj = { outerWidth: ‘pliers‘ };
function getWidth(){
return this.outerWidth;
}
var a = getWidth();
var b = getWidth.apply(obj);
console.log(a); // текущая ширина браузера, this будет windows
console.log(b); // на экран выведется pliers. outerWidth — это свойство объекта windows, мы, по сути, вызовем windows.outerWidth
```
Вызов механизма:
```
Calling func.call(context, a, b...)
```
эквивалентен записи:
```
func(a, b...), but this == context.
```
Оба вызова идентичны, только apply позволяет передавать параметры через массив.
```
call(context, param1, param2 …)
apply(context, [args])
```
Четыре варианта вызова и его результаты:
```
Вызов function: function(args) – this == window
Вызов method: obj.funct(args) – this == obj
Apply: func.apply(obj,args) – this == obj
Constructor: new func(args) – this == new object
```
### Наследование и методы реализации
Модель базового фильтра — стандартный набор параметров, который есть в фильтре любого приложения. Эти параметры необходимы для пагинации, номера страницы и т.п.
Задаём ему метод через прототип. После получения модели сервера вызываем этот метод, и он преобразует некоторые наши данные в нужный формат.
Есть класс-наследник и конкретная страница “RouteHistorical”. Класс наследуется от базового фильтра, но дополнительно имеет свои поля и параметры.
В строке 73 мы передаём в базовый класс через контекст `apply` новосозданный объект `RouteHistorical` и те же аргументы. Метод инициализирует все поля, и мы получаем новый объект.
Строки 81-82 позволяют нам сделать `RouteHistorical` наследником базового фильтра. В строке 81 мы записываем ссылку на класс конструктора базы в свойство `prototype`. Метод `prototype` перезаписывается полностью, и конструктор теряется. Когда мы создаем новый объект, он не будет знать, к чему обратиться.
В строке 82 мы задаем свойству `prototype.constructor` ссылку на саму себя. Свойство класса `constructor` всегда ссылается на самого себя.
### Прототипы
Свойство `prototype` имеет смысл в паре с ключевым словом `new`. Когда мы создаем новый объект, то записываем значение `prototype` в свойство `__proto__`. Оно содержит ссылку на класс, который является родителем для нашего класса.
`prototype` нужен только для того, чтобы сказать, что нужно записать в `__proto__` при инстанцировании нового объекта.
```
// unsafe
var filter = {
EnablePagination: true
};
function BaseFilter(size) {
this.PageSize = size;
this.__proto__ = filter;
}
// safe
var filter= {
EnablePagination: true
};
function BaseFilter(size) {
this.PageSize = size;
}
BaseFilter.prototype = filter;
```
Две записи одинаковы, но обращаться напрямую к `__proto__` считается небезопасным, и не все браузеры это позволяют.
### Создание потомка из базового класса
Функция `extend`:
```
function extend(Child, Parent) {
var F = function() { }
F.prototype = Parent.prototype //
Child.prototype = new F() // при создании Child в __proto__ запишется наш родитель prototype
Child.prototype.constructor = Child // задаём конструктор, должен ссылаться на самого себя.
Child.superclass = Parent.prototype // чтобы иметь доступ к методам Parent
};
```
Использование:
```
function BaseFilterModel(..) { ... }
function RouteHistoricalFilterModel(..) { ... }
```
### instanceof
Позволяет определить, является ли объект экземпляром какого-либо конструктора *на основе всей цепочки прототипирования*.
instanceof (псевдокод метода):
```
function isInstanceOf(obj, constructor) {
if (obj.__proto__ === constructor.prototype) {
return true;
}
else if (obj.__proto__ !== null) {
return isInstanceOf(obj.__proto__, constructor)
}
else {
return false
}
};
```
### Итог
1. В JavaScript до ECMAScript 6 не было классов, были только функции конструктора, которые вызываются с помощью ключевого слова `new`.
2. Цепочка прототипирования — это основа наследования в JavaScript.
3. Когда мы обращаемся к свойству, то оно ищется в объекте. Если не находится, то в `__proto__`, и так далее по всей цепочке. Таким образом в JavaScript реализуется наследование.
4. `fn.__proto__` хранит ссылку на `fn.prototype`.
5. Оператор `new` создает пустой объект с единственным свойством `__proto__`, который ссылается на `F.prototype`. Конструктор выполняет `F`, где контекст `this` — ранее созданный объект, устанавливает его свойства и возвращает этот объект.
6. Оператор `instanceof` не проверяет, чтобы объект был создан через конструктор `ObjectsConstructor`, а принимает решение на основе всей цепочки прототипирования.
7. В JavaScript `this` зависит от контекста, т.е. от того, как мы вызываем функцию. | https://habr.com/ru/post/302518/ | null | ru | null |
# Mail.Ru для бизнеса: всё, что вы хотели и не стеснялись просить
[](http://habrahabr.ru/company/mailru/blog/223667/)
Вы, возможно, помните, как мы [анонсировали](http://habrahabr.ru/company/mailru/blog/186426/) проект «Mail.Ru для бизнеса» несколько месяцев [назад](http://habrahabr.ru/company/mailru/blog/190340/).
Если кто-то из вас пропустил, «Mail.Ru для бизнеса» — это бесплатный сервис, позволяющий создать до 5000 корпоративных адресов в домене и открывающий пользователям доступ к полному объему ресурсов Почты Mail.Ru. При этом мы обеспечиваем надежную защиту от спама и вирусов и предлагаем неограниченный объем почтового ящика. Почтой можно пользоваться через сторонние клиенты, поддерживающие протоколы IMAP, POP3/SMTP — Outlook, The Bat, а также через мобильные приложения для всех популярных платформ. Вместе с почтой пользователям доступны и другие инструменты, такие как Облако для виртуального хранения данных, Календарь для организации работы и Агент для мгновенного обмена сообщениями с коллегами.
В комментариях вы описали множество «хотелок», которые нам нужно было реализовать. И подавляющее большинство ваших пожеланий мы успешно выполнили. Теперь у нас есть:
* вход по mail.mydomain.tld
* вход через форму на своем сайте
* API
* алиасы доменов
* алиасы пользователей
* миграция с других почтовых сервисов
* массовое добавление из файла
* подпись DKIM
* отчет о действиях пользователей
* доступ к облачному хранилищу
Подробнее обо всех новых функциях — чуть ниже.
Кстати, если они вас заинтересуют, или даже если вы еще не слышали про сервис «Mail.Ru для бизнеса» — мы рады предоставить вам возможность попробовать их в действии. Первым 100 хабраюзерам, отписавшим в комментариях «Хочу попробовать», мы отправим промокод на регистрацию бесплатного домена в зоне .ru с подключенным сервисом почты (конечно, с возможностью смены А-записи).
**Вход по mail.mydomain.tld и через форму на сайте**
На момент старта мы предоставляли вход через главную страницу Mail.Ru, а также через специальную страницу на biz.mail.ru. Теперь же вы можете настроить вход в Почту для своих пользователей при помощи поддомена mail (или любого другого на ваш выбор) и через форму на вашем сайте.
Для входа через поддомен вам нужно будет создать CNAME-запись на поддомене со значением biz.mail.ru.
Для формы входа на вашем сайте мы предлагаем следующий шаблон:
```
``` | https://habr.com/ru/post/223667/ | null | ru | null |
# Организация кода в микросервисах и мой подход применения гексагональной архитектуры и DDD
Привет, Хабр! В Монолите весь код должен быть в едином стиле, a в разных микросервисах можно использовать разные подходы, языки программирования и фреймворки. Для простых микросервисов с 1 — 2 контроллерами и 1 — 10 действиями особо смысла городить слои абстракций нет. Для сложных микросервисов с различными состояниями и логикой перехода между ними наоборот лучше изначально не лениться. Я хочу рассказать о моем опыте организации кода и использования подходов DDD, Портов и Адаптеров для обоих случаев. Есть кратко суть статьи: Джун — пишет код в контроллере. Мидл — пишет кучу абстракций. Сеньор — знает когда нужно писать код в контроллере, а когда нужны абстракции. Тут нужно сразу поставить точку над И — Порты в С# это interface или abstract, а Адаптеры это конкретные реализации (class, struct). В целях ознакомления рекомендую почитать этот перевод [DDD, Hexagonal, Onion, Clean, CQRS… как я собрал всё это вместе](https://habr.com/ru/post/427739/) и вот эту статью [Заблуждения Clean Architecture](https://habr.com/ru/company/mobileup/blog/335382/). Тут только имейте в виду что описывается подход для большого и сложного монолита. Я же хочу рассказать о вариациях этого подхода в микросервисах 80 процентов из которых простые и 20 средней или высокой сложности.
Терминология
------------
### 1) PrimaryAdapters
Представляют интерфейс удобный для потребления для внешней **вызывающей** системой. Вызывают и используют SecondaryApdapters и Logic. Они говорят приложению что-то сделать. Точки входа в ваш код. Типичные представители: ItemsService, CreateItemCommandHandler. Используют Logic и SecondaryAdapters для своей работы.
### 2) SecondaryAdapters
Предоставляет интерфейс к внешней **вызываемой** системе удобный для использования нашей системой. Он получает команды от приложения. Типичные представители: ItemsRepository, EmailSender, Logger, DistributedCache. Используют библиотеки и фреймворки вроде EntityFramework для своей работы.
### 3) Logic
#### 3.1) Entities
Объединяют в себе данные и логику. Типичные ООП объекты. Item, Money, User. Тут так же лежат ValueObjects и Events. Используют только другие объекты из слоя Entities. По идее этот слой это ядро приложения которое ни от кого не зависит. Все зависят от него.
#### 3.2) DomainServices
Голые вычисления. Нужны для логики которую не получается привязать к одной конкретной сущности. Используют Entities или другие DomainServices. **Никогда** не используют PrimaryAdapters (эти вообще всегда сами всех используют) и SecondaryAdapters. Обычно это всякие AmountCalculator, Validator и прочее.
Поток вызова кода всегда должен быть в одном направлении PrimaryAdapters -> Logic и SecondaryAdapters.
### Domain
Это предметная область для которой разрабатывается система. Например для Интернет Магазина Domain это E-Commerce.
### BoundedContext
BoundedContext используется для разбиения системы на изолированные части с определенной ответственностью. Один из путей к успеху в проектировании системы это найти и выделить в ней все ее BoundedContexts. В микросервисной архитектуре 1 микросервис = 1 BoundedContext. Например: У интернет магазина может быть BoundedContext Корзины товаров и BoundedContext работы с заказами, BoundedContext работы с файлами. Причем один большой BoundedContext может быть разбит на маленькие куски внутри. Например для BoundedContext корзины товаров можно сделать разделения на контекст добавления товаров в корзину и контекст удаления товаров из корзины. В монолите 1 большой BoundedContext это один Модуль. Тут надо сделать замечание что все Entities живут в пределах какого-то определенного контекста т.е. Item из контекста корзины товаров и Item из контекста витрины товаров это могут быть разные классы с разными полями и методами. В монолите их просто маппят друг в друга и используют для работы с БД какую нибудь ItemDto которую передают EF и которая имеет поля характерные для всех т. е. если у Item из контекста (модуля) Корзины есть свойство Property1, а у Item из контекста витрины товаров есть свойство Property2 то у ItemDto будет и Property1 и Property2. В каждом контексте будет свой репозиторий который будет вытаскивать из базы уже характерную для этого контекста Item. В микросервисах с этим просто. У каждого своя БД и свои сущности. У каждого миркросервиса свои классы. Просто **помните** что Item и ItemsRepository из разных BoundedContext это могут быть разные объекты с разными методами и свойствами. Часто BoundedContext в микросервисах нарушают введением каких-то общих библиотек. В результате получается класс у которого несколько десятков методов или свойств и каждый микросервис использует 1 — 2 нужных только ему поэтому с общими библиотеками в микросервисах надо быть аккуратными.
### Зависимости между слоями
### Поток вызова кода
Кто, кого и в какой последовательности вызывает.
### Иерархия зависимостей
Вариант для простых микросервисов коих по закону Парето 80 процентов
--------------------------------------------------------------------
Выбрасываем слой PrimaryAdatapters и SecondaryAdapters. Оставляем только слой Logic. Точнее в типичном ASP.NET приложении используем — PimaryAdater это Controller, а SecondaryAdapter это DbContext от EF. Если вдруг Controller становиться слишком большим, то режем его на части с помощью partial. Это намного лучше чем разводить не нужные абстракции и тратить на них время. Например так Microsoft в примере своего EShop приложения на докер контейнерах так сделала для BasketMicrotservice. Да, просто пишем код в контроллер. Только не надо писать спагетти-код. **Важно** помнить что слой Logic у нас остается и мы все еще используем Entities с их логикой и DomainServices с их вычислениями а не просто пишем стену спагетти-код в контроллере. Просто мы выбрасываем типичные ItemService и ItemRepository. Старые, добрые ItemValidator, ItemMapper, AmountCalculator и прочее в этом духе у нас все еще остается. Так как у нас сформированный слой Logic остается то мы можем в любой момент перейти к более сложному варианту накрутив дополнительных абстракций ItemsService, ItemsRepository.
### Пример
Сервис, который вычисляем итоговую цену продукта со скидкой. По идее он часть Domain Интернет Магазина и представляет собой его BoundedContext каталога товаров. Для простоты всю логику валидации я пропустил. Ее можно описать в каком нибудь ItemValidator и DiscountValidator.
1) Папка Logic:
1.1) Папка Entities:
Скидка:
```
public class Discount
{
[Key]
public Guid Id { get; set; }
public decimal Value { get; set; }
}
```
Деньги:
```
[Owned]
public class Money
{
public decimal Amount { get; set; }
public Money Apply(Discount discount)
{
var amount = Amount * (1 - discount.Value);
return new Money()
{
Amount = amount
};
}
}
```
Товар:
```
public class Item
{
[Key]
public Guid Id { get; set; }
public Money Price { get; set; } = new Money();
}
```
1.2) Папка DomainServices
Калькулятор цены продукта с учетом скидки:
```
public interface IPriceCalculator
{
Money WithDiscounts(Item item, IEnumerable discounts);
}
public sealed class PriceCalculator:IPriceCalculator
{
public Money WithDiscounts(Item item, IEnumerable discounts)
{
return discounts.Aggregate(item.Price, (m, d) => m.Apply(d));
}
}
```
2) DbContext
```
public class ItemsDbContext : DbContext
{
public ItemsDbContext(DbContextOptions options) : base(options)
{
}
public DbSet Items { get; set; }
public DbSet Discounts { get; set; }
}
```
3) Controller
```
[ApiController]
[Route("api/v1/items")]
public class ItemsController : ControllerBase
{
private readonly ItemsDbContext _context;
private readonly IPriceCalculator _priceCalculator;
public ItemsController(ItemsDbContext context, IPriceCalculator priceCalculator)
{
_context = context;
_priceCalculator = priceCalculator;
}
[HttpGet("{id}/price-with-discounts")]
public async Task GetPriceWithDiscount(Guid id)
{
var item = await \_context.Items.FindAsync(id);
var discounts = await \_context.Discounts.ToListAsync();
return \_priceCalculator.WithDiscounts(item, discounts).Amount;
}
}
```
Вариант для сложных микросервисов коих 20 процентов и для большинства монолитов
-------------------------------------------------------------------------------
Тут используем стандартный подход с максимальной изоляцией слоев друг от друга. Добавляем класс для PrimaryAdapter (ItemService) и для SecondaryAdapter (ItemRepository). В папке Logic все остается как было до этого.
### Пример
1) Папка SecondaryAdapters
```
public interface IItemsRepository
{
Task Get(Guid id);
}
public sealed class ItemsRepository : IItemsRepository
{
private readonly ItemsDbContext \_context;
public ItemsRepository(ItemsDbContext context)
{
\_context = context;
}
public async Task Get(Guid id)
{
var item = await \_context.Items.FindAsync(id);
return item;
}
}
```
```
public interface IDiscountsRepository
{
Task> Get();
}
public sealed class DiscountsRepository : IDiscountsRepository
{
private readonly ItemsDbContext \_context;
public DiscountsRepository(ItemsDbContext context)
{
\_context = context;
}
public Task> Get()
{
return \_context.Discounts.ToListAsync();
}
}
```
2) Папка PrimaryAdapters
```
public interface IItemService
{
Task GetPriceWithDiscount(Guid id);
}
public class ItemService : IItemService
{
private readonly IItemsRepository \_items;
private readonly IDiscountsRepository \_discounts;
private readonly IPriceCalculator \_priceCalculator;
public ItemService(IItemsRepository items, IDiscountsRepository discounts, IPriceCalculator priceCalculator)
{
\_items = items;
\_discounts = discounts;
\_priceCalculator = priceCalculator;
}
public async Task GetPriceWithDiscount(Guid id)
{
var item = await \_items.Get(id);
var discounts = await \_discounts.Get();
return \_priceCalculator.WithDiscounts(item, discounts).Amount;
}
}
```
Наш контроллер теперь использует наш IItemService
```
[ApiController]
[Route("api/v1/items")]
public class ItemsController : ControllerBase
{
private readonly IItemService _service;
public ItemsController(IItemService service)
{
_service = service;
}
[HttpGet("{id}/price-with-discounts")]
public async Task GetPriceWithDiscount(Guid id)
{
var result = await \_service.GetPriceWithDiscount(id);
return result;
}
}
```
Добавилось много дополнительного кода. Взамен повысилась гибкость системы. Теперь проще сменить Contoller и вообще ASP.NET Core на что-то другое или сменить DbContext и EntityFramework Core на что-то другое или добавить кеширование в Redis. Первый подход выигрывает в простых микросервисах и очень простых и маленьких монолитах. Второй во всех остальных случаях, когда добавлять и допиливать вам этот код надо будет больше года. Ну и во втором подходе кроме Entity Item и Discount полезно сделать еще отдельные DTO которые будет использовать DbContex EF и отдельные DTO (Models) которые будет использовать ASP.NET Controller т.е. ItemDto и ItemModel. Это позволить сделать доменные модели еще более независимыми. Ну и напоследок пример простого приложения которое я написал с применением 2 го подхода [TestRuvds](https://gitlab.com/VictorWinbringer/testruvds). На самом деле он тут излишен и все эти абстракции тут для примера.
Пример реализации
-----------------
[VirtualServersModule](https://gitlab.com/VictorWinbringer/testruvds/-/tree/master/TestRuvds/VirtualServersModule)
Благодарности
-------------
Спасибо [canxes](https://habr.com/ru/users/canxes/) и [AndrewDemb](https://habr.com/ru/users/andrewdemb/) за найденные грамматические ошибки. | https://habr.com/ru/post/493426/ | null | ru | null |
# Примеры кода для интернета вещей: умная поливалка
Недавно мы опубликовали [учебные примеры кода](https://software.intel.com/ru-ru/blogs/2015/11/04/announcing-18-new-how-to-intel-iot-code-samples) для различных проектов, которые формируют интернет вещей. Сегодня расскажем об автоматической системе полива. Построена она с использованием Intel IoT Developer Kit, Intel Edison, в её работе применяются облачные платформы, различные API и другие технологии.
[](https://habrahabr.ru/company/intel/blog/282756/)
* Как подключиться к Intel Edison – платформе, созданной для прототипирования и разработки носимых вычислительных решений и IoT-устройств.
* Как взаимодействовать с интерфейсом ввода вывода Edison и с датчиками при помощи MRAA и UPM из Intel IoT Developer Kit, самодостаточного аппаратно-программного решения, которое предназначено для того, чтобы помочь разработчикам исследовать возможности интернета вещей и создавать инновационные продукты.
* Как запустить код примера в Intel XDK IoT Edition, IDE для создания приложений, которые взаимодействуют с датчиками и актуаторами. Эта среда разработки позволяет быстро приступить к разработке приложений для Intel Edison и Intel Galileo.
* Как настроить сервер веб-приложения, который будет хранить данные системы полива с использованием Azure Redis Cache в Microsoft Azure. Это набор облачных служб для IoT-решений, которые поддерживают анализ данных, машинное обучение и множество полезных инструментов, упрощающих подключение устройств к облаку и позволяющих быстро вывести IoT-проект в рабочий режим.
* Как вызывать службы Twilio API для отправки текстовых сообщений на мобильные телефоны.
Возможности системы
-------------------
Вот какими возможностями обладает автоматическая система полива, которую мы создадим на базе Intel Edison:
* Включение и выключение водяного насоса в соответствии с настраиваемым расписанием.
* Проверка того, действительно ли насос перекачивает воду при подаче ему соответствующей команды. Для этого используется датчик расхода воды.
* Организация доступа к системе с использованием встроенного веб-интерфейса, что позволяет задать расписание полива.
* Хранение сведений о работе системы в облачном хранилище.
* Отправка текстовых сообщений для уведомления потребителей о том, что в работе системы произошёл сбой.
Особенности работы
------------------
Система полива позволяет задавать расписание полива, открывая с помощью смартфона, или другого подходящего устройства, веб-страницу, которая хранится на Intel Edison. Она автоматически опрашивает датчик влажности и выводит полученные данные на веб-страницу.
Если предполагается, что водяной насос включён, но датчик расхода воды показывает, что вода по трубам не двигается, будет отправлено текстовое сообщение на заданный номер через Twilio. Таким образом, систему полива, которая вышла из строя, можно будет оперативно отремонтировать.
Дополнительно система может вести журнал событий с использованием кода из Intel IoT Examples Datastore, который исполняется в среде Microsoft Azure.
Аппаратное обеспечение
----------------------
Аппаратная часть проекта – это Grove Environment & Agriculture Kit, включающий в себя:
* Intel Edison с коммутационной платой Arduino.
* [Датчик влажности Grove](http://iotdk.intel.com/docs/master/upm/node/classes/grovemoisture.html).
* [Водяной насос](http://www.seeedstudio.com/depot/6V-Mini-Water-Pump-p-1945.html).
* [Датчик расхода воды](http://www.seeedstudio.com/depot/G18-Water-Flow-Sensor-p-1346.html).
* Реле с сухим герконом Grove.
Программное обеспечение
-----------------------
* Intel XDK IoT Edition
* Учётная запись Microsoft Azure
* Учётная запись Twilio
Предварительные приготовления
-----------------------------
Для того, чтобы начать работу, скопируйте на компьютер Git репозиторий How-To Intel IoT Code Samples с помощью такой команды:
```
$ git clone https://github.com/intel-iot-devkit/how-to-code-samples.git
```
Если вам удобнее загрузить ZIP-архив с необходимыми материалами, откройте [эту](https://github.com/intel-iot-devkit/how-to-code-samples) страницу и щёлкните по расположенной справа кнопке Download ZIP. Загрузив архив, распакуйте его и найдите папку с кодом к этому проекту (watering-system).
Добавление приложения в Intel XDK IoT Edition
---------------------------------------------
В Intel XDK IoT Edition выберите команду Import Your Node.js Project (Импортировать проект Node.js):
*Импорт Node.js-проекта*
Затем перейдите к папке, в которой расположены файлы учебного проекта и выделите её.
*Выбор папки с кодом проекта*
Теперь нужно подключить плату Intel Edison к компьютеру и загрузить на плату программу. Для этого можно воспользоваться меню IoT Device (IoT-устройство), которое расположено в левой нижней части окна. Если система автоматически распознала подключённую плату, выберите в меню соответствующую строку.
*Подключение Intel Edison*
Если же плата не была распознана автоматически, выберите пункт Add Manual Connection (Добавить подключение вручную), в появившемся окне, в поле Address (Адрес), введите 192.168.2.15, в поле Port (Порт) введите 58888. Кнопкой Connect (Подключить) сохраните подключение.
Ручная установка программы на Intel Edison
------------------------------------------
Кроме того, программу можно установить на Intel Edison вручную. Для этого подключитесь к плате по SSH и выполните следующую команду:
```
$ git clone https://github.com/intel-iot-devkit/how-to-code-samples.git
```
Затем перейдите в папку с примером. Если на Edison ещё не установлен Git, сделать это можно, подключившись к плате по SSL и выполнив следующую команду:
```
$ opkg install git
```
Подключение датчиков Grove
--------------------------
*Прототип системы полива в сборе*
Нужно, чтобы к коммутационной Arduino-совместимой плате была подключена плата расширения Groove (Grove Shield), к которой будут подключаться датчики и актуаторы. Проверьте, чтобы на плате расширения Grove маленький переключатель VCC находился в положении 5V.
Необходимо подвести питание к Intel Edison от внешнего адаптера, который поставляется вместе со Starter Kit, или заменить его на подходящий внешний источник питания (12 В, 1.5 А). Можно использовать и USB-батарею на 5 В.
Кроме того, понадобится макетная плата и дополнительный источник питания на 5 В для водяного насоса. Обратите внимание на то, что для насоса нужен отдельный источник питания. Нельзя использовать один и тот же источник и для Intel Edison и для насоса, то есть, понадобится либо две батареи, либо два адаптера.
Для подключения водяного насоса понадобится реле с сухим герконом Groove. Подключение выполняется так:
1. Один из концов кабеля Grove подключите к реле, второй – к порту D4 на плате расширения Grove.
2. Один из проводов водяного насоса подключите к предназначенному для насоса источнику питания на 5 В.
3. Другой провод насоса подключите к одному из разъёмов питания реле.
4. Другой разъём питания реле подключите к «земле» источника питания насоса.
5. Подключите датчик расхода воды, присоединив красный провод к выводу «5V», чёрный – к выводу «GND», а жёлтый – к цифровому выходу 2 на плате расширения Grove.
6. Подключите один конец кабеля Grove к датчику влажности, другой – к порту A0 на плате расширения Grove.
Ручная установка на Intel Edison
--------------------------------
Если вы выбрали путь самостоятельного запуска кода примера на Intel Edison, понадобится разрешить некоторые зависимости.
Для получения модулей Node.js, необходимых для того, чтобы пример запустился на Edison, выполните такую команду:
```
npm install
```
Настройки: отправка сообщений и облачное хранилище
--------------------------------------------------
Для того, чтобы система могла отправлять текстовые сообщения, необходима учётная запись [Twilio](https://www.twilio.com/) и API-ключ. Без ключа сообщения отправлять нельзя. Пример будет работать и без отправки сообщений, но в реальных проектах подобная возможность весьма полезна.
Для того чтобы настроить пример на работу с вашей учётной записью Twilio, нужно, в файле config.json, задать значения параметров «`TWILIO_ACCT_SID`» и «`TWILIO_AUTH_TOKEN`». В них, соответственно, нужно указать API-ключ и маркер аутентификации.
```
{
"TWILIO_ACCT_SID": "YOURAPIKEY",
"TWILIO_AUTH_TOKEN": "YOURTOKEN"
}
```
При желании можете хранить данные, которые генерируются рассматриваемым примером, в базе данных, развёрнутой с использованием Microsoft Azure, Node.js и хранилища данных Redis. Подробности о том, как настроить облачный сервер, смотрите [здесь](https://github.com/intel-iot-devkit/intel-iot-examples-datastore).
Если у вас есть учётная запись Microsoft Azure и имеется сервер, готовый принимать данные, нужно внести изменения в config.json, а именно, записать в параметры «`SERVER`» и «`AUTH_TOKEN`» данные для подключения к серверу.
```
{
"SERVER": "http://intel-examples.azurewebsites.net/logger/watering-system",
"AUTH_TOKEN": "s3cr3t"
}
```
В том случае, если в вашем варианте примера будет использоваться и отправка текстовых сообщений средствами Twilio, и хранение данных в Microsoft Azure, настройки будут выглядеть так:
```
{
"TWILIO_ACCT_SID": "YOURAPIKEY",
"TWILIO_AUTH_TOKEN": "YOURTOKEN",
"SERVER": "http://intel-examples.azurewebsites.net/logger/watering-system",
"AUTH_TOKEN": "s3cr3t"
}
```
Запуск программы из Intel XDK IoT Edition
-----------------------------------------
Прежде чем запускать программу, сохраните изменения, внесённые в файлы. После этого щёлкните по значку Upload (Выгрузка) для того, чтобы выгрузить код на Intel Edison.
*Выгрузка проекта на Intel Edison*
После выгрузки запустите программу на устройстве с помощью значка Run (Запуск).
*Запуск проекта*
Если вы, при работе над проектом, внесли в код изменения, можете воспользоваться командой Upload and Run (Выгрузить и запустить). Свежая версия программы будет выгружена и запущена на Intel Edison. В ходе выполнения программы на Edison можно будет видеть сообщения, подобные показанным на рисунке ниже.
*Сообщения от программы, которая работает на Intel Edison*
Ручной запуск программы
-----------------------
Для того, чтобы запустить программу вручную, подключитесь к Intel Edison по SSH и выполните следующую команду:
```
node index.js
```
Настройка расписания полива
---------------------------
Для настройки расписания полива используется веб-интерфейс, состоящий из одной страницы. Эту страницу можно открыть, запросив её у веб-сервера, который выполняется на той же плате Intel Edison, на которой выполняется основная программа.
*Страница для настройки расписания полива*
Серверу назначен порт 3000. Таким образом, если Intel Edison подключён к Wi-Fi-сети и ему назначен IP-адрес 192.168.1.13, то адрес сервера (при условии, что подключаются к нему из той же самой локальной сети) будет [http://192.168.1.13:3000](http://192.168.1.13:3000/).
Как определить IP-адрес Intel Edison
------------------------------------
Для того, чтобы узнать IP-адрес Intel Edison, можно воспользоваться следующей командой:
```
ip addr show | grep wlan
```
После её выполнения можно будет увидеть примерно следующее:
```
3: wlan0: mtu 1500 qdisc pfifo\_fast qlen 1000
inet 192.168.1.13/24 brd 192.168.1.255 scope global wlan0
```
Адрес Intel Edison можно обнаружить после «inet». В нашем случае это 192.168.1.13.
Выводы
------
Мы рассказали о том, как, на базе Intel Edison, собрать систему полива, которая включает в себя набор датчиков и водяной насос. Системой, подключённой к Интернету, можно управлять с любого устройства, которое умеет открывать веб-страницы. Если задействовать в рассмотренном примере облачные службы для хранения данных и отправки сообщений, можно собирать статистику работы устройства, а, в случае возникновения аварийной ситуации, получить текстовое сообщение на заданный номер мобильного телефона и быстро исправить поломку.
С другими примерами кода из серии How-To Intel IoT Code Samples можно ознакомиться на [Intel Developer Zone](https://software.intel.com/ru-ru/blogs/2015/11/04/announcing-18-new-how-to-intel-iot-code-samples). Полный код рассмотренного здесь примера можно найти на [GitHub](https://github.com/intel-iot-devkit/how-to-code-samples/tree/master/watering-system/javascript). | https://habr.com/ru/post/282756/ | null | ru | null |
# Подсвечиваем проблемные зоны на коленке с SonarQube и Docker Desktop
Привет, меня зовут Андрей Голяков, я руководитель бэкенд разработки компании Bimeister.
Хочу поделиться опытом быстрого подсвечивания возможных проблемных зон объёмного и малознакомого кода.
Обновлена заглавная картинка, спасибо Лёше Акулову!#### Для кого эта статья?
Показанное здесь решение позволяет сэкономить до 8 часов времени на чтение документации и на путь проб и ошибок **руководителю разработки любого уровня**, **лиду команды** и просто **разработчику**, которому нужно **быстро подсветить потенциальные проблемы в объёмной незнакомой кодовой базе**.
Выбор путиКогда кода много, а времени мало, **можно устроить анонимный опрос** и узнать источники боли у коллег, для которых исследуемый код ближе.
* **Плюсы**:
+ он, несомненно, проще (привет, KISS);
+ можно узнать не только о проблемах, но и их отношении к этому.
* **Минусы**:
+ ответы будут субъективны;
+ они будут касаться лишь тех областей кода, с которыми конкретный человек недавно работал;
+ есть риск вскрыть нарыв, тем самым обрекая себя на исповедь (а по ситуации и отповедь), что может быть затратно по времени;
+ повторная операция потребует столько же времени.
А **можно взять принятое в сообществе бесплатное решение**, натравить его на код и посмотреть на результаты анализа.
* **Плюсы**
+ будет получен более-менее объективный анализ;
+ мы никого не будем отвлекать;
+ такой прогон можно повторить по результатам сделанных исправлений почти бесплатно (привет, DRY).
* **Минусы**
+ порог вхождения выше — надо с чем-то разбираться;
+ понимание результата весьма смутное в самом начале пути — нет понимания, окупится ли вложенное время;
+ если не особо вкладываться в настройку правил анализа, будет подсвечено много нерелевантного.
Я прошёл вариант с опросом, но параллельно решил и прогнать что-то стороннее для большей объективности своих будущих запросов на исправление.
(спасибо всем, кто дочитал до этого места)
Ещё раз определяемся с целямиИтак, в этой статье я постараюсь исправить два первых минуса, а именно:
* предоставить читателю готовую пошаговую инструкцию настройки SonarQube в контейнерах Docker Desktop;
* сформировать у заинтересованных ожидания от конечного результата.
**Поставленная Цель.** Быстро и без последствий для локального ноутбука иметь возможность прогнать дефолтные правила одного из популярных сканеров кодовой базы.
**Дисклеймер.** В этой статье не будет ничего про настройки интеграции сканера в пайплайны CI/CD.
Поехали!Собственно, как я спойлернул выше, решение было выбрано следующее: локально развёрнутый на Windows-ноутбуке Docker Desktop с wsl + SonarQube.
Наскоро пробежав глазами [документацию c Docker Hub-а](https://hub.docker.com/_/sonarqube), находим требования к хосту.
Открываем консоль PowerShell, выполняем подключение к терминалу docker-desktop:
```
wsl -d docker-desktop
```
Вводим рекомендованные в настроечные команды (если коротко, мы делаем это потому, что *elasticsearch* под капотом требует ресурсов больше, чем выделено по умолчанию):
```
sysctl -w vm.max_map_count=524288
sysctl -w fs.file-max=131072
ulimit -n 131072
ulimit -u 8192
```
*(последняя команда вызвала у меня ошибку ‘unknown argument u’, однако, на финальный результат это не повлияло)*
После настройки хоста готовим файлик sonar.yaml, очень похожий на [рекомендуемый на странице вендора](https://github.com/SonarSource/docker-sonarqube/blob/master/example-compose-files/sq-with-postgres/docker-compose.yml):
```
version: "3.8"
services:
sonarqube:
image: sonarqube:community
ports:
- "9000:9000"
- "9092:9092"
depends_on:
- db
environment:
SONAR_JDBC_URL: jdbc:postgresql://db:5432/sonar
SONAR_JDBC_USERNAME: sonar
SONAR_JDBC_PASSWORD: sonar
volumes:
- sonarqube_conf:/opt/sonarqube/conf
- sonarqube_data:/opt/sonarqube/data
- sonarqube_logs:/opt/sonarqube/logs
- sonarqube_extensions:/opt/sonarqube/extensions
- sonarqube_bundled-plugins:/opt/sonarqube/lib/bundled-plugins
networks:
sonar_network:
db:
image: postgres:12
ports:
- "5432:5432"
command: postgres -c 'max_connections=300'
volumes:
- postgresql:/var/lib/postgresql
- postgresql_data:/var/lib/postgresql/data
environment:
POSTGRES_DB: sonar
POSTGRES_USER: sonar
POSTGRES_PASSWORD: sonar
networks:
sonar_network:
restart: unless-stopped
volumes:
sonarqube_conf:
sonarqube_data:
sonarqube_logs:
sonarqube_extensions:
sonarqube_bundled-plugins:
postgresql:
postgresql_data:
networks:
sonar_network:
```
Запускаем контейнеры командой:
```
docker-compose -f sonar.yml -p sonar up -d
```
Если всё сделали правильно, у нас стартуют оба контейнера и мы получаем доступ к панели администратора SonarQube по адресу <http://localhost:9000/>.
Вводим имя пользователя admin и пароль admin.
Первым делом нас просят сменить пароль на что-то более безопасное.
Затем мы попадаем на страницу создания нового проекта. Нам предлагается выбор источников исходного кода, я выбрал "**From GitLab**" (*ещё один дисклеймер: я шёл по шагам "мастера" добавления нового проекта, и поскольку у меня есть доступ к GitLab, я решил воспользоваться именно этим пунктом. Однако, забегая вперёд и учитывая, что весь код в итоге скачивался, собирался и анализировался локально, я не уверен, что нужно было идти именно таким путём*).
Итак, я выбрал **From GitLab**.
Для автоматического подтягивания списка репозиториев потребуется токен доступа к GitLab. Идём в **GitLab** > **User Settings** > **Access Tokens** и создаём новый токен со скоупом **api**. Не забыв скопировать токен в буфер обмена, возвращаемся в админку SonarQube и вводим её в соответствующее поле. Получаем список репозиториев, выбираем:
Определившись с репозиторием, выбираем — как мы будем проводить анализ?
Нам представлено несколько вариантов интеграции, однако мы идём по локальному пути — жмём **Locally**, расположенный внизу особняком:
Далее требуется ввести существующий или выбрать генерацию нового **токена на сканирование выбранного репозитория**:
**Важно!** Сканирование **любого** Git-репозитория с этим токеном будет автоматически привязано к **данному** репозиторию в SonarQube, поэтому переиспользовать эти токены сканирования желательно только в рамках одной репы.
Генерируем, получаем что-то вроде *sqp\_d42feed11ed20248464f8ceb22897aec19533212*.
Жмём **Continue**.
Далее выбираем — на что больше всего похож наш билд? В моём случае это **.net core** приложение, так что жмём **.NET** и **.NET Core**:
Получаем список из четырёх команд для последовательного запуска в папке с репозиторием *(в моём случае, solution-файл лежал на один уровень глубже, так что открываем PowerShell и проваливаемся до папки с solution-файлом, не забыв перед сканированием обновить локальный репозиторий посредством git pull).*
Копируем со странички в окно PowerShell-консоли и выполняем одну за другой 4 команды:
```
dotnet tool install --global dotnet-sonarscanner
dotnet sonarscanner begin /k:"common_identity_ABzn02OgsqQ2PsdJYMkV" /d:sonar.host.url="http://localhost:9000" /d:sonar.login="sqp_d42feed11ed20248464f8ceb22897aec19533212"
dotnet build
dotnet sonarscanner end /d:sonar.login="sqp_d42feed11ed20248464f8ceb22897aec19533212"
```
Последняя команда может работать минуты на большом количестве кода. После завершения обновляем окно проекта в SonarQube и видим красивый интерактивный отчёт.
Сразу становится понятен общий уровень кода и на что нужно обратить внимание в ближайшем спринте.
Получаем, кстати, не только подсвеченные области, вызывающие вопросы, как, например, вот это использование всеми любимого класса Random():
Бонусом идут готовые варианты решения (нужно перейти на вкладку «How can you fix it?»:
Можно идти фиксить самому или превращать в прекрасно описанные задачи.
Спасибо за внимание!
**UPDATE** (спасибо [@andToxa](/users/andtoxa))
Чтобы показывалось покрытие тестами итоговый набор команд должен выглядеть так:
```
dotnet tool install --global dotnet-coverage
dotnet tool install --global dotnet-sonarscanner
dotnet sonarscanner begin /k:"bimeister_bimeister_AYFxkfmmsqQ2PsdJYMlN" /d:sonar.host.url="http://localhost:9000" /d:sonar.login="sqp_669f424dc2ec900930193ce0e0a89e412fbddd1c" /d:sonar.cs.vscoveragexml.reportsPaths=coverage.xml
dotnet build --no-incremental
dotnet-coverage collect -f xml -o coverage.xml dotnet test
dotnet sonarscanner end /d:sonar.login="sqp_669f424dc2ec900930193ce0e0a89e412fbddd1c"
``` | https://habr.com/ru/post/671900/ | null | ru | null |
# Учебное пособие по Nim (часть 2)
**Примечание от переводчика**Первая часть находится здесь: [«Учебное пособие по Nim (часть 1)»](http://habrahabr.ru/post/271197/)
Перевод делался для себя, то есть коряво и на скорую руку. Формулировки некоторых фраз приходилось рожать в страшных муках, чтобы они хоть отдалённо были похожи на русский язык. Кто знает, как написать лучше — пишите в личку, буду править.
Введение
--------
> «Повторение придаёт нелепости вид благоразумия.» – Норман Вайлдбергер
*(в оригинале: "Repetition renders the ridiculous reasonable." – Norman Wildberger)*
Этот документ является учебным пособием по сложным конструкциям языка *Nim.* **Помните, что этот документ в чём-то устарел, а в руководстве есть гораздо больше актуальных примеров по сложным особенностям языка.**
Прагмы
------
Прагмы – это принятый в Nim способ сообщить компилятору дополнительную информацию или команды, не вводя новых ключевых слов. Прагмы заключаются в специальные фигурные скобки с точками `{. and .}`. В этом учебном пособии они не рассматриваются. За списком доступных прагм обращайтесь к [руководству](http://nim-lang.org/docs/manual.html#pragmas) или [пользовательской инструкции](http://nim-lang.org/docs/nimc.html#additional-features).
Объектно-ориентированное программирование
-----------------------------------------
Хотя поддержка объектно-ориентированного программирования (ООП) в Nim минималистична, но мощные техники ООП всё же могут использоваться. ООП рассматривается как *один из,* но не *единственный* способ разработки программ. Бывает, что процедурный подход упрощает код и повышает его эффективность. Например, использование композиции вместо наследования часто приводит к лучшей архитектуре.
### Объекты
Объекты, как и кортежи, предназначены для упаковки различных значений в единую структуру. Но у объектов есть некоторые особенности, которых нет у кортежей: наследование и сокрытие информации. Поскольку объекты инкапсулируют данные, конструктор объекта `T()` принято использовать только во внутренней разработке, а для инициализации программист должен предоставить специальную процедуру (она называется *конструктор).*
Объекты имеют доступ к своему типу во время выполнения. Существует оператор `of`, при помощи которого можно проверить тип объекта:
```
type
Person = ref object of RootObj
name*: string # эта * означает, что `name` будет доступно из других модулей
age: int # а это поле будет недоступно из других модулей
Student = ref object of Person # Student унаследован от Person
id: int # с дополнительным полем id
var
student: Student
person: Person
assert(student of Student) # вернёт true
# конструируем объект:
student = Student(name: "Anton", age: 5, id: 2)
echo student[]
```
Поля объекта, которые должны быть видимы за пределами модуля, в котором они определены, маркируются звёздочкой (`*`). В отличие от кортежей, различные объектные типы никогда не бывают *эквивалентны.* Новые объектные типы можно определять только в секции типов.
Наследование делается с помощью синтаксиса `object of`. Множественное наследование на данный момент не поддерживается. Если для объектного типа нет подходящего предка, то можно сделать предком `RootObj`, но это всего лишь соглашение. Объекты, не имеющие предка, неявно объявляются как `final`. Чтобы ввести новый объект, не унаследованный от `system.RootObj`, можно использовать прагму `inheritable` (это используется, например, в обёртке GTK).
Ссылочные объекты могут использоваться независимо от наследования. Это не строго обязательно, но в случае присвоения не-ссылочных объектов, например, `let person: Person = Student(id: 123)` поля дочернего класса будут обрезаны.
> **Примечание:** для простого повторного использования кода композиция (отношение *«входит в состав»)* часто предпочтительнее наследования (отношение *«является»).*. Поскольку объекты в Nim являются типами-значениями, композиция столь же эффективна, как и наследование.
### Взаимно рекурсивные типы
С помощью объектов, кортежей и ссылок можно моделировать довольно сложные структуры данных, которые зависят друг от друга и, таким образом, являются *взаимно рекурсивными.* В Nim такие типы могут быть объявлены только внутри единой секции типов. (Другие решения потребовали бы дополнительного просмотра символов, который замедляет компиляцию.)
Пример:
```
type
Node = ref NodeObj # отслеживаемая ссылка на NodeObj
NodeObj = object
le, ri: Node # левое и правое поддеревья
sym: ref Sym # листья, содержащие ссылку на Sym
Sym = object # символ
name: string # имя символа
line: int # строка, в которой символ был объявлен
code: PNode # абстрактное синтаксическое дерево символа
```
### Преобразование типов
Nim различает приведение типов (type casts) и преобразование типов (type conversions). Приведение делается при помощи оператора `cast` и заставляет компилятор интерпретировать двоичные данные как указанный тип.
Преобразование типов это более изящный способ превратить один тип в другой: оно проверяет, можно ли преобразовать типы. Если преобразование типов невозможно, об этом либо сообщит компилятор, либо будет выброшено исключение.
Синтаксис для преобразования типов выглядит так: `destination_type(expression_to_convert)` (напоминает обычный вызов).
```
proc getID(x: Person): int =
Student(x).id
```
Если `x` не является экземпляром `Student`, то будет выброшено исключение `InvalidObjectConversionError`.
### Вариантные объекты
Бывают ситуации, для которых объектная иерархия – излишество, и всё можно решить простыми вариантными типами.
Например:
```
# Это пример того, как абстрактное синтаксическое дерево могло бы быть
# смоделировано в Nim
type
NodeKind = enum # типы для различных узлов
nkInt, # лист с числовым значением
nkFloat, # лист со значением с плавающей запятой
nkString, # лист со строковым значением
nkAdd, # сложение
nkSub, # вычитание
nkIf # команда if
Node = ref NodeObj
NodeObj = object
case kind: NodeKind # поле ``kind`` является дискриминатором
of nkInt: intVal: int
of nkFloat: floatVal: float
of nkString: strVal: string
of nkAdd, nkSub:
leftOp, rightOp: PNode
of nkIf:
condition, thenPart, elsePart: PNode
var n = PNode(kind: nkFloat, floatVal: 1.0)
# следующая команда вызовет исключение `FieldError`, поскольку значение
# n.kind не соответствует:
n.strVal = ""
```
Как видно из примера, в отличие от объектной иерархии не нужно делать преобразований между различными объектными типами. Тем не менее, обращение к неправильным полям объекта возбуждает исключение.
### Методы
В обычных объектно-ориентированных языках процедуры (также называемые *методами)* привязаны к классу. У этого подхода есть следующие недостатки:
* добавив метод к классу, программист либо теряет над ним контроль, либо городит корявые обходные пути, если надо работать с методом отдельно от класса;
* часто бывает неясно, к чему должен относиться метод: `join` это метод строки или массива?
Nim избегает этих проблем, не привязывая методы к классам. Все методы в Nim являются мультиметодами. Как мы увидим позже, мультиметоды отличаются от процедур только при динамической привязке.
### Синтаксис вызова методов
Для вызова подпрограмм в Nim есть особый синтаксический сахар: конструкция `obj.method(args)` означает то же, что и `method(obj, args)`. Если аргументов нет, то скобки можно пропустить: `obj.len` вместо `len(obj)`.
Этот синтаксис вызова методов не ограничен объектами, его можно использовать для любого типа:
```
echo("abc".len) # то же, что и echo(len("abc"))
echo("abc".toUpper())
echo({'a', 'b', 'c'}.card)
stdout.writeLine("Hallo") # то же, что и writeLine(stdout, "Hallo")
```
(Другая точка зрения на синтаксис вызова методов состоит в том, что он реализует отсутствующую постфиксную нотацию.)
Это даёт возможность легко писать «чистый объектно-ориентированный код»:
```
import strutils, sequtils
stdout.writeLine("Give a list of numbers (separated by spaces): ")
stdout.write(stdin.readLine.split.map(parseInt).max.`$`)
stdout.writeLine(" is the maximum!")
```
### Свойства
Как видно из примера выше, Nim не нуждается в *get-свойствах:* их заменяют обычные get-процедуры, вызываемые с помощью *синтаксиса вызова методов.* Но присвоение значения – другое дело, для этого нужен особый синтаксис:
```
type
Socket* = ref object of RootObj
host: int # недоступен извне, нет звёздочки
proc `host=`*(s: var Socket, value: int) {.inline.} =
## сеттер адреса хоста
s.host = value
proc host*(s: Socket): int {.inline.} =
## геттер адреса хоста
s.host
var s: Socket
new s
s.host = 34 # то же, что и `host=`(s, 34)
```
(В примере также показаны `inline`-процедуры.)
Для реализации свойств-массивов можно перегрузить оператор доступа к массиву `[]`:
```
type
Vector* = object
x, y, z: float
proc `[]=`* (v: var Vector, i: int, value: float) =
# setter
case i
of 0: v.x = value
of 1: v.y = value
of 2: v.z = value
else: assert(false)
proc `[]`* (v: Vector, i: int): float =
# getter
case i
of 0: result = v.x
of 1: result = v.y
of 2: result = v.z
else: assert(false)
```
Пример корявый, поскольку вектор лучше моделировать кортежем, у которого уже есть доступ к `v[]`.
### Динамическая привязка (dynamic dispatch)
Процедуры всегда используют статическую привязку. Для динамической привязки замените ключевое слово `proc` на `method`:
```
type
PExpr = ref object of RootObj ## абстрактный базовый класс для выражения
PLiteral = ref object of PExpr
x: int
PPlusExpr = ref object of PExpr
a, b: PExpr
# обратите внимание: 'eval' полагается на динамическое связывание
method eval(e: PExpr): int =
# перекрываем базовый метод
quit "to override!"
method eval(e: PLiteral): int = e.x
method eval(e: PPlusExpr): int = eval(e.a) + eval(e.b)
proc newLit(x: int): PLiteral = PLiteral(x: x)
proc newPlus(a, b: PExpr): PPlusExpr = PPlusExpr(a: a, b: b)
echo eval(newPlus(newPlus(newLit(1), newLit(2)), newLit(4)))
```
Заметьте, что в примере конструкторы `newLit` и `newPlus` являются процедурами, поскольку для них лучше использовать статическое связывание, а `eval` уже метод, потому что ему требуется динамическое связывание.
В мультиметоде все параметры, имеющие объектный тип, используются для привязки:
```
type
Thing = ref object of RootObj
Unit = ref object of Thing
x: int
method collide(a, b: Thing) {.inline.} =
quit "to override!"
method collide(a: Thing, b: Unit) {.inline.} =
echo "1"
method collide(a: Unit, b: Thing) {.inline.} =
echo "2"
var a, b: Unit
new a
new b
collide(a, b) # на выходе: 2
```
Из примера видно, что вызов мультиметода не может быть неоднозначным: `collide` 2 предпочтительнее `collide` 1, поскольку разрешение работает слева направо. Таким образом, `Unit`, `Thing` предпочтительнее, чем `Thing`, `Unit`.
> **Примечание о производительности**: Nim не создаёт таблицу виртуальных методов, а генерирует деревья привязки (dispatch trees). Это позволяет избежать затратного непрямого ветвления при вызовах методов и позволяет встраивание. Но другие оптимизации, такие как вычисления на этапе компиляции или удаление «мёртвого» кода не работают с методами.
Исключения
----------
В Nim исключения являются объектами. По соглашению типы исключений заканчиваются на «Error». Модуль `system` определяет иерархию исключений, к которой вы можете привязаться. Исключения происходят от `system.Exception`, предоставляющего общий интерфейс.
Исключения должны размещаться в куче, поскольку время их жизни неизвестно. Компилятор не позволит вам возбудить исключение, размещённое на стеке. Все возбуждённые исключения должны как минимум указывать причину своего появления в поле `msg`.
Предполагается, что исключения должны возбуждаться в *исключительных* случаях: например, если файл не может быть открыт, это не должно возбуждать исключения (файл может не существовать).
### Команда `raise`
Исключения возбуждаются с помощью команды `raise`:
```
var
e: ref OSError
new(e)
e.msg = "the request to the OS failed"
raise e
```
Если за ключевым словом `raise` не следует выражение, то *повторно возбуждается* последнее исключение. Чтобы не писать приведённый выше код, можно использовать шаблон `newException` из модуля `system`:
```
raise newException(OSError, "the request to the OS failed")
```
### Команда `try`
Команда `try` обрабатывает исключения:
```
# читаем первые две строки текстового файла, которые должны содержать числа, и
# пытаемся сложить их
var
f: File
if open(f, "numbers.txt"):
try:
let a = readLine(f)
let b = readLine(f)
echo "sum: ", parseInt(a) + parseInt(b)
except OverflowError:
echo "overflow!"
except ValueError:
echo "could not convert string to integer"
except IOError:
echo "IO error!"
except:
echo "Unknown exception!"
# reraise the unknown exception:
raise
finally:
close(f)
```
Команды после `try` выполняются до тех пор, пока не возникнет исключения. В этом случае будет выполнена соответствующая ветка `except`.
Пустой блок `except` выполняется, если возникшее исключение не входит в список перечисленных явно. Это аналогично ветке `else` в команде `if`.
Если присутствует ветка `finally`, то она выполняется всегда после выполнения обработчиков исключений.
Исключение *поглощается* в ветке `except`. Если исключение не обработано, оно распространяется по стеку вызовов. Это значит, что если возникнет исключение, то оставшаяся часть процедуры, которая не находится внутри блока `finally`, не будет выполняться.
Если вам понадобится получить текущий объект исключения или его сообщение внутри ветки `except`, вы можете использовать процедуры `getCurrentException()` и `getCurrentExceptionMsg()` из модуля `system`. Пример:
```
try:
doSomethingHere()
except:
let
e = getCurrentException()
msg = getCurrentExceptionMsg()
echo "Got exception ", repr(e), " with message ", msg
```
### Аннотирование процедур возбуждаемыми исключениями
С помощью необязательной прагмы `{.raises.}` вы можете указать, что процедура может возбуждать определённый набор исключений или не возбуждает исключений вообще. Если прагма `{.raises.}` используется, компилятор проверит, что она соответствует действительности. Например, если вы указали, что процедура возбуждает `IOError`, а в какой-то точке она (или одна из вызываемых процедур) возбуждает другое исключение, компилятор откажется её компилировать. Пример использования:
```
proc complexProc() {.raises: [IOError, ArithmeticError].} =
...
proc simpleProc() {.raises: [].} =
...
```
После того, как у вас будет подобный код, если список возбуждаемых исключений изменится, компилятор остановится с ошибкой, указывающей на строку в процедуре, которая остановила валидацию прагмы и исключение, отсутствующее в списке. Кроме того, там также будет указан файл и строка, где это исключение появилось, что поможет вам найти подозрительный код, изменение которого привело к этому.
Если вы хотите добавить прагму `{.raises.}` к существующему коду, компилятор также может помочь вам. Вы можете добавить к процедуре команду прагмы `{.effects.}` и компилятор выведет все эффекты, проявляющиеся в этой точке (отслеживание исключений является частью системы эффектов Nim). Ещё один обходной путь для получения списка исключений, возбуждаемых процедурой, это использование команды Nim `doc2`, которая генерирует документацию для всего модуля и декорирует все процедуры списком возбуждаемых исключений. Вы можете прочесть больше о [системе эффектов и соответствующих прагмах в руководстве](http://nim-lang.org/docs/manual.html#effect-system).
Обобщения
---------
Обобщения это то, что позволяет Nim параметризировать процедуры, итераторы или типы с помощью параметров-типов. Они наиболее полезны для создания высокопроизводительных типобезопасных контейнеров:
```
type
BinaryTreeObj[T] = object # BinaryTree это обобщённый тип с обобщённым
# параметром ``T``
le, ri: BinaryTree[T] # левое и правое поддерево; могут быть nil
data: T # данные хранятся в узле
BinaryTree*[T] = ref BinaryTreeObj[T] # тип, который экспортируется
proc newNode*[T](data: T): BinaryTree[T] =
# конструктор узла
new(result)
result.data = data
proc add*[T](root: var BinaryTree[T], n: BinaryTree[T]) =
# вставляем узел в дерево
if root == nil:
root = n
else:
var it = root
while it != nil:
# сравниваем данные элементов; используем обобщённую процедуру ``cmp``
# которая работает с любым типом, имеющим операторы ``==`` и ``<``
var c = cmp(it.data, n.data)
if c < 0:
if it.le == nil:
it.le = n
return
it = it.le
else:
if it.ri == nil:
it.ri = n
return
it = it.ri
proc add*[T](root: var BinaryTree[T], data: T) =
# удобная процедура:
add(root, newNode(data))
iterator preorder*[T](root: BinaryTree[T]): T =
# Предварительно упорядоченный обход двоичного дерева. Поскольку рекурсивные
# итераторы пока не реализованы, используется явный стек (который ещё и более
# эффективен):
var stack: seq[BinaryTree[T]] = @[root]
while stack.len > 0:
var n = stack.pop()
while n != nil:
yield n.data
add(stack, n.ri) # кладём правое поддерево на стек
n = n.le # и переходим по левому указателю
var
root: BinaryTree[string] # инстанцируем BinaryTree как ``string``
add(root, newNode("hello")) # инстанцируем ``newNode`` и добавляем его
add(root, "world") # инстанцируем вторую процедуру добавления
for str in preorder(root):
stdout.writeLine(str)
```
Пример показывает обобщённое двоичное дерево. В зависимости от контекста, квадратные скобки используются либо для ввода параметров-типов, либо для инстанцирования обобщённой процедуры, итератора или типа. Как видно из примера, обобщения работают с перегрузкой: используется наилучшее совпадение `add`. Встроенная процедура `add` для последовательностей не прячется и используется в итераторе `preorder`.
Шаблоны
-------
Шаблоны это простой механизм замещения, который оперирует абстрактными синтаксическими деревьями (AST) Nim. Шаблоны обрабатываются на семантическом проходе компиляции. Они хорошо интегрированы с остальными частями языка и у них нет обычных недостатков C-шных макросов препроцессора.
Чтобы *вызвать* шаблон, вызывайте его как процедуру.
Пример:
```
template `!=` (a, b: expr): expr =
# это определение существует в модуле System
not (a == b)
assert(5 != 6) # компилятор перепишет это как: assert(not (5 == 6))
```
Операторы `!=`, `>`, `>=`, `in`, `notin`, `isnot` фактически являются шаблонами: в результате, если вы перегрузили оператор `==`, то оператор `!=` становится доступен автоматически и правильно работает (кроме чисел с плавающей запятой IEEE – `NaN` ломает строгую булевскую логику).
`a > b` превращается в `b < a`. `a in b` трансформируется в `contains(b, a)`. `notin` и `isnot` получают очевидный смысл.
Шаблоны особенно полезны, когда речь заходит о ленивых вычислениях. Рассмотрим простую процедуру для логгирования:
```
const
debug = true
proc log(msg: string) {.inline.} =
if debug: stdout.writeLine(msg)
var
x = 4
log("x has the value: " & $x)
```
В этом коде есть недостаток: если `debug` однажды выставят в `false`, то довольно затратные операции `$` и `&` по-прежнему будут выполняться! (Вычисление аргументов для процедур сделано «жадным».)
Превращение процедуры `log` в шаблон решает эту проблему:
```
const
debug = true
template log(msg: string) =
if debug: stdout.writeLine(msg)
var
x = 4
log("x has the value: " & $x)
```
Типы параметров могут быть обычными типами или метатипами `expr` (для *выражений),* `stmt` (для *команд)* или `typedesc` (для *описаний типов).* Если в шаблоне не указан явно тип возвращаемого значения, то для совместимости с процедурами и методами используется `stmt`.
Если есть параметр `stmt`, то он должен быть последним в объявлении шаблона. Причина в том, что команды передаются в шаблон с помощью специального синтаксиса с двоеточием (`:`):
```
template withFile(f: expr, filename: string, mode: FileMode,
body: stmt): stmt {.immediate.} =
let fn = filename
var f: File
if open(f, fn, mode):
try:
body
finally:
close(f)
else:
quit("cannot open: " & fn)
withFile(txt, "ttempl3.txt", fmWrite):
txt.writeLine("line 1")
txt.writeLine("line 2")
```
В примере две команды `writeLine` привязываются к параметру `body`. Шаблон `withFile` содержит служебный код и помогает избежать распространённой проблемы: забыть закрыть файл. Отметим, что команда `let fn = filename` гарантирует, что `filename` будет вычислен только один раз.
Макросы
-------
Макросы позволяют интенсивнно трансформировать код на этапе компиляции, но не могут изменять синтаксис Nim. Но это не слишком серьёзное ограничение, поскольку синтаксис Nim достаточно гибок. Макросы должны быть реализованы на чистом Nim, так как [интерфейс внешних функций (FFI)](http://nim-lang.org/docs/manual.html#foreign-function-interface) не разрешён в компиляторе, но помимо этого ограничения (которое будет убрано когда-нибудь в будущем) вы можете писать любой код на Nim и компилятор будет запускать его на этапе компиляции.
Есть два способа написания макросов: либо *генерирование* исходного кода Nim и передача его компилятору для разбора, либо ручное создание абстрактного синтаксического дерева (AST), которое скармливается компилятору. Для построения AST необходимо знать, каким образом конкретный синтаксис Nim преобразуется в абстрактное синтаксическое дерево. AST документировано в модуле `macros`.
Когда ваш макрос готов, есть два способа его вызвать:
1. вызов макроса как процедуры (макрос выражения)
2. вызов макроса с помощью специального синтаксиса `macrostmt` (макрос команд)
### Макросы выражений
Следующий пример реализует мощную команду `debug`, которая принимает любое количество аргументов:
```
# чтобы работать с синтаксическими деревьями Nim нам нужен API, который
# определен в модуле``macros``:
import macros
macro debug(n: varargs[expr]): stmt =
# `n` это AST Nim, содержащее список выражений;
# этот макрос возвращает список выражений:
result = newNimNode(nnkStmtList, n)
# перебираем аргументы, переданные в макрос:
for i in 0..n.len-1:
# добавляем в список команд вызов, который выведет выражение;
# `toStrLit` конвертирует AST в его строковое представление:
result.add(newCall("write", newIdentNode("stdout"), toStrLit(n[i])))
# добавляем в список команд вызов, который выведет ": "
result.add(newCall("write", newIdentNode("stdout"), newStrLitNode(": ")))
# добавляем в список команд вызов, который выведет значение выражения:
result.add(newCall("writeLine", newIdentNode("stdout"), n[i]))
var
a: array[0..10, int]
x = "some string"
a[0] = 42
a[1] = 45
debug(a[0], a[1], x)
```
Вызов макроса разворачивается в:
```
write(stdout, "a[0]")
write(stdout, ": ")
writeLine(stdout, a[0])
write(stdout, "a[1]")
write(stdout, ": ")
writeLine(stdout, a[1])
write(stdout, "x")
write(stdout, ": ")
writeLine(stdout, x)
```
### Макросы команд
Макросы команд определяются так же, как и макросы выражений. Но вызываются они через выражение, заканчивающееся двоеточием.
Следующий пример показывает макрос, который генерирует лексический анализатор для регулярных выражений:
```
macro case_token(n: stmt): stmt =
# создаёт лексический анализатор из регулярных выражений
# ... (реализация -- упражнение для читателя :-)
discard
case_token: # это двоеточие сообщает парсеру, что это макрос команды
of r"[A-Za-z_]+[A-Za-z_0-9]*":
return tkIdentifier
of r"0-9+":
return tkInteger
of r"[\+\-\*\?]+":
return tkOperator
else:
return tkUnknown
```
### Создаём свой первый макрос
Чтобы указать вам направление в написании макросов, мы продемонстрируем, как превратить ваш типичный динамический код в нечто, что может быть скомпилировано статически. Для примера используем в качестве стартовой точки следующий фрагмент кода:
```
import strutils, tables
proc readCfgAtRuntime(cfgFilename: string): Table[string, string] =
let
inputString = readFile(cfgFilename)
var
source = ""
result = initTable[string, string]()
for line in inputString.splitLines:
# Игнорируем пустые строки
if line.len < 1: continue
var chunks = split(line, ',')
if chunks.len != 2:
quit("Input needs comma split values, got: " & line)
result[chunks[0]] = chunks[1]
if result.len < 1: quit("Input file empty!")
let info = readCfgAtRuntime("data.cfg")
when isMainModule:
echo info["licenseOwner"]
echo info["licenseKey"]
echo info["version"]
```
Предположительно, этот фрагмент кода мог бы использоваться в коммерческих программах, чтобы читать файл конфигурации и выводить информацию о том, кто купил программу. Этот внешний файл мог бы генерироваться при покупке, чтобы включать в программу лицензионную информацию:
```
version,1.1
licenseOwner,Hyori Lee
licenseKey,M1Tl3PjBWO2CC48m
```
Процедура `readCfgAtRuntime` будет открывать данное имя файла и возвращать `Table` из модуля `tables`. Разбор файла делается (без обработки ошибок или граничных случаев) с помощью процедуры `splitLines` из модуля `strutils`. Есть много вещей, которые могут пойти не так; помните, что здесь объясняется, как запускать код на этапе компиляции, а не как правильно реализовать защиту от копирования.
Реализация этого кода как процедуры этапа компиляции позволит нам избавиться от файла `data.cfg`, который в противном случае надо было бы распространять вместе с бинарником. Плюс, если информация действительно постоянна, то с точки зрения логики нет смысла держать её в *изменяемой* глобальной переменной, лучше если она будет константой. Наконец, одна из самых ценных фишек в том, что мы можем реализовать некоторые проверки на этапе компиляции. Можете воспринимать это как *улучшенное модульное тестирование,* не дающее получить бинарник, в котором что-то не работает. Это предотвращает поставку пользователям сломанных программ, которые не запускаются из-за сбоя в одном мелком критичном файле.
### Генерация исходного кода
Попробуем изменить программу таким образом, чтобы на этапе компиляции создать строку со *сгенерированным исходным кодом,* который потом передадим в процедуру `parseStmt` из модуля `macros`. Вот модифицированный исходный код, реализующий макрос:
```
1 import macros, strutils
2
3 macro readCfgAndBuildSource(cfgFilename: string): stmt =
4 let
5 inputString = slurp(cfgFilename.strVal)
6 var
7 source = ""
8
9 for line in inputString.splitLines:
10 # Ignore empty lines
11 if line.len < 1: continue
12 var chunks = split(line, ',')
13 if chunks.len != 2:
14 error("Input needs comma split values, got: " & line)
15 source &= "const cfg" & chunks[0] & "= \"" & chunks[1] & "\"\n"
16
17 if source.len < 1: error("Input file empty!")
18 result = parseStmt(source)
19
20 readCfgAndBuildSource("data.cfg")
21
22 when isMainModule:
23 echo cfglicenseOwner
24 echo cfglicenseKey
25 echo cfgversion
```
Здесь хорошо то, что почти ничего не изменилось! Во-первых, изменилась обработка входного параметра (строка 3). В динамической версии процедура `readCfgAtRuntime` получает строковый параметр. Однако в версии макроса он хотя и объявлен строковым, но это лишь *внешний* интерфейс макроса. Когда макрос запускается, он на самом деле получает объект `PNimNode`, а не строку, и нам нужно вызвать процедуру `strVal` из модуля `macros` (строка 5), чтобы получить строку, переданную в макрос.
Во-вторых, мы не можем использовать процедуру `readFile` из модуля `system` из-за ограничений FFI на этапе компиляции. Если мы попробуем использовать эту процедуру (или любую другую, зависящую от FFI), компилятор выдаст ошибку с сообщением, что не может вычислить дамп исходного кода макроса и добавит к нему распечатку стека, показывающую, где находился компилятор на момент ошибки. Мы можем обойти это ограничение, воспользовавшись процедурой `slurp` из модуля `system`, которая сделана специально для этапа компиляции (там же есть похожая процедура `gorge`, выполняющая внешнюю программу и перехватывающая её вывод).
Что интересно, наш макрос не возвращает объекта времени выполнения `Table`. Вместо этого он формирует исходный код Nim в исходной переменной. Для каждой строки конфигурационного файла будет сгенерирована константная переменная (строка 15). Чтобы избежать конфликтов, мы снабдили эти переменные префиксом `cfg`. В целом, всё что делает компилятор – это заменяет строку вызова макроса следующим фрагментом кода:
```
const cfgversion= "1.1"
const cfglicenseOwner= "Hyori Lee"
const cfglicenseKey= "M1Tl3PjBWO2CC48m"
```
Вы можете проверить это самостоятельно, добавив строчку с выводом исходного кода на экран в конце макроса и скомпилировав программу. Ещё одно различие состоит в том, что вместо вызова обычной процедуры `quit` для выхода (которую мы могли бы вызвать) эта версия вызывает процедуру `error` (строка 14). Процедура `error` делает то же, что и `quit` но кроме того ещё и выводит исходный код и номер строки файла, где произошла ошибка, что помогает программисту найти ошибку при компиляции. В этой ситуации нам указали бы на строчку, вызывающую макрос, а **не** на строчку `data.cfg`, которую мы обрабатываем: это мы должны контролировать самостоятельно.
### Генерация AST вручную
Для генерации AST нам, по идее, надо было бы в совершенстве знать используемые компилятором Nim структуры, которые представлены в модуле `macros`. На первый взгляд это выглядит пугающей задачей. Но мы можем воспользоваться макросом `dumpTree`, использовав его в качестве макроса команд, а не макроса выражения. Поскольку мы знаем, что хотим сгенерировать порцию символов `const`, можно создать следующий исходный файл и скомпилировать его, чтобы увидеть, чего же компилятор от нас *ожидает:*
```
import macros
dumpTree:
const cfgversion: string = "1.1"
const cfglicenseOwner= "Hyori Lee"
const cfglicenseKey= "M1Tl3PjBWO2CC48m"
```
По ходу компиляции исходного кода мы должны увидеть вывод следующих строк (так как это макрос, компиляции будет достаточно, не надо запускать никаких бинарников):
```
StmtList
ConstSection
ConstDef
Ident !"cfgversion"
Ident !"string"
StrLit 1.1
ConstSection
ConstDef
Ident !"cfglicenseOwner"
Empty
StrLit Hyori Lee
ConstSection
ConstDef
Ident !"cfglicenseKey"
Empty
StrLit M1Tl3PjBWO2CC48m
```
С этой информацией мы уже лучше представляем, какие данные нужны компилятору от нас. Нам нужно сгенерировать список команд. Для каждой константы исходного кода генерируется `ConstSection` и `ConstDef`. Если бы мы перенесли все эти константы в единый блок `const`, то увидели бы только одну `ConstSection` с тремя потомками.
Возможно, вы не заметили, но в примере с `dumpTree` первая константа явным образом определяет тип констант. Вот почему в дереве вывода у двух последних констант второй потомок `Empty`, а у первой – строковый идентификатор. Итак, в целом, определение `const` состоит из идентификатора, необязательного типа (который может быть *пустым* узлом) и значения. Вооружившись этими знаниями, давайте посмотрим на законченную версию макроса построения AST:
```
1 import macros, strutils
2
3 macro readCfgAndBuildAST(cfgFilename: string): stmt =
4 let
5 inputString = slurp(cfgFilename.strVal)
6
7 result = newNimNode(nnkStmtList)
8 for line in inputString.splitLines:
9 # Игнорируем пустые строки
10 if line.len < 1: continue
11 var chunks = split(line, ',')
12 if chunks.len != 2:
13 error("Input needs comma split values, got: " & line)
14 var
15 section = newNimNode(nnkConstSection)
16 constDef = newNimNode(nnkConstDef)
17 constDef.add(newIdentNode("cfg" & chunks[0]))
18 constDef.add(newEmptyNode())
19 constDef.add(newStrLitNode(chunks[1]))
20 section.add(constDef)
21 result.add(section)
22
23 if result.len < 1: error("Input file empty!")
24
25 readCfgAndBuildAST("data.cfg")
26
27 when isMainModule:
28 echo cfglicenseOwner
29 echo cfglicenseKey
30 echo cfgversion
```
Поскольку мы отталкивались от предыдущего примера генерации исходного кода, будем отмечать только отличия от него. Вместо создания временной переменной типа `string` и записывания в неё исходного кода так, как если бы он был написан *вручную,* мы используем непосредственно переменную `result` и создаём узел списка команд (`nnkStmtList`), который будет содержать наших потомков (строка 7).
Для каждой входной строки мы создаём определение константы (`nnkConstDef`) и оборачиваем его секцией констант (`nnkConstSection`). Как только эти переменные созданы, мы заполняем их иерархически (строка 17), как показано в предыдущем дампе дерева AST: определение константы является потомком определения секции и содержит узел идентификатора, пустой узел (пусть компилятор сам догадается, какой здесь тип) и строковый литерал со значением.
Последний совет по написанию макросов: если вы не уверены, что построенное вами AST выглядит нормально, вы можете попробовать воспользоваться макросом `dumpTree`. Но его нельзя использовать *внутри* макроса, который вы пишете или отлаживаете. Вместо этого выводите на экран строку, сгенерированную `treeRepr`. Если в конце этого примера вы добавите `echo treeRepr(result)`, то увидите тот же вывод, что и при использовании макроса `dumpTree`. Вызывать его именно *в конце* необязательно, можете вызвать его в любой точке макроса, с которым у вас возникли проблемы. | https://habr.com/ru/post/271361/ | null | ru | null |
# Наследование, композиция, агрегация
Нередко случается, что решив разобраться с какой-то новой темой, понятием, инструментом программирования, я читаю одну за другой статьи на различных сайтах в интернете. И, если тема сложная, то эти статьи могут не на шаг не приблизить меня к понимаю. И вдруг встречается статья, которая моментально дает озарение и все паззлы складываются воедино. Трудно определить, что отличает такую статью от других. Правильно подобранные слова, оптимальная логика изложения или же просто более релевантный пример. Я не претендую на то, что моя статься окажется новым словом в C# или же лучшей обучающей статьей. Но, возможно для кого-то она станет именно той, которая позволит разобраться, запомнить и начать правильно применять те понятия, о которых пойдет речь.
В объектно-ориентированных языках программирования существует три способа организации взаимодействия между классами. Наследование — это когда класс-наследник имеет все поля и методы родительского класса, и, как правило, добавляет какой-то новый функционал или/и поля. Наследование описывается словом «является». Легковой автомобиль является автомобилем. Вполне естественно, если он будет его наследником.
```
```class Vehicle
{
bool hasWheels;
}
class Car : Vehicle
{
string model = "Porshe";
int numberOfWheels = 4
}```
```
Ассоциация – это когда один класс включает в себя другой класс в качестве одного из полей. Ассоциация описывается словом «имеет». Автомобиль имеет двигатель. Вполне естественно, что он не будет являться наследником двигателя (хотя такая архитектура тоже возможна в некоторых ситуациях).
Выделяют два частных случая ассоциации: композицию и агрегацию.
Композиция – это когда двигатель не существует отдельно от автомобиля. Он создается при создании автомобиля и полностью управляется автомобилем. В типичном примере, экземпляр двигателя будет создаваться в конструкторе автомобиля.
```
```
class Engine
{
int power;
public Engine(int p)
{
power = p;
}
}
class Car
{
string model = "Porshe";
Engine engine;
public Car()
{
this.engine = new Engine(360);
}
}
```
```
Агрегация – это когда экземпляр двигателя создается где-то в другом месте кода, и передается в конструктор автомобиля в качестве параметра.
```
```
class Engine
{
int power;
public Engine(int p)
{
power = p;
}
}
class Car
{
string model = "Porshe";
Engine engine;
public Car(Engine someEngine)
{
this.engine = someEngine;
}
}
Engine goodEngine = new Engine(360);
Car porshe = new Car(goodEngine);
```
```
Хотя ведутся дискуссии о преимуществах того или иного способа организации взаимодействия между классами, какого-либо абстрактного правила не существует. Разработчик выбирает тот или иной путь основываясь на элементарной логике (“является” или “имеет”), но также принимает во внимание возможности и ограничения, которые дают и накладывают эти способы. Для того, чтобы увидеть эти возможности и ограничения, я попытался написать пример. Достаточно простой, чтобы код оставался компактным, но и достаточно развитый, чтобы в рамках одной программы можно было применить все три способа. И, главное, я попытался сделать этот пример как можно менее абстрактным – все объекты и экземпляры понятны и осязаемы.
Напишем простенькую игру – танковый бой. Играют два танка. Они поочередно стреляют и проигрывает тот, здоровье которого упало до нуля. В игре будут различные типы снарядов и брони. Для того, чтобы нанести урон необходимо во-первых, попасть по танку противника, во-вторых, пробить его броню. Если броня не пробита, урон не наносится. Логика игры построена на принципе «камень-ножницы-бумага»: то есть броня одного типа хорошо противостоит снарядам определенного типа, но плохо держит другие снаряды. Кроме того, снаряды, которые хорошо пробивают броню, наносят малый «заброневой» урон, и, напротив, наиболее «летальные» снаряды имеют меньше шансов пробить броню.
Создадим простенький класс для пушки. Он будет иметь два приватных поля: калибр и длину ствола. От калибра зависит урон, и, частично, способность к пробитию брони. От длины ствола – точность стрельбы.
```
```
public class Gun
{
private int caliber;
private int barrelLength;
}
```
```
Сделаем также конструктор для пушки:
```
```
public Gun(int cal, int length)
{
this.caliber = cal;
this.barrelLength = length;
}
```
```
Сделаем метод для получения калибра из других классов:
```
```
public int GetCaliber()
{
return this.caliber;
}
```
```
Помните, что для поражения цели должно произойти две вещи: попадание в цель и пробитие брони? Так вот, пушка будет отвечать за первую из них: попадание. Поэтому делаем булевый метод IsOnTarget, который принимает случайную величину (dice) и возвращает результат: попали или нет:
```
```
public bool IsOnTarget(int dice)
{
return (barrelLength + dice) > 100;
}
```
```
Целиком класс пушки выглядит следующим образом:
```
```
public class Gun
{
private int caliber;
private int barrelLength;
public Gun(int cal, int length)
{
this.caliber = cal;
this.barrelLength = length;
}
public int GetCaliber()
{
return this.caliber;
}
public bool IsOnTarget(int dice)
{
return (barrelLength + dice) > 100;
}
}
```
```
Теперь сделаем снаряды – это наиболее очевидный случай для применения наследования, но и агрегацию в нем тоже применим. Любой снаряд имеет свои особенности. Просто неких гипотетических снарядов не бывает. Поэтому класс делаем абстрактным. Делаем ему строковое поле «тип».
Снаряды делают для пушек. Для определенных пушек. Снаряд одного калибра не выстрелит из пушки другого калибра. Поэтому добавляем снаряду поле-ссылку на экземпляр пушки. Делаем конструктор.
```
```
public abstract class Ammo
{
Gun gun;
public string type;
public Ammo(Gun someGun, string type)
{
gun = someGun;
this.type = type;
}
}
```
```
Здесь мы применили агрегацию. Где-то будет создана пушка. Потом к этой пушке будут создаваться снаряды, которые имеют указатель на пушку.
Конкретные типы снарядов будут наследниками абстрактного снаряда. Наследники могут просто наследовать методы родителя, но могут и быть переопределены, то есть работать не так, как родительский метод. Но мы точно знаем, что любой снаряд должен иметь ряд методов. Любой снаряд должен наносить урон. Метод GetDamage просто возвращает калибр, умноженный на три. В общем случае, урон снаряда зависит от калибра. Но этот метод будет переопределяться в дочерних классах (помним, что снаряды, которые хорошо пробивают броню, как правило наносят меньший «заброневой» урон. Чтобы иметь возможность переопределить метод в дочернем классе, используем слово virtual.
```
```
public virtual int GetDamage()
{
//TO OVERRIDE: add logic of variable damage depending on Ammo type
return gun.GetCaliber()*3;
}
```
```
Любой снаряд должен пробивать (или по крайней мере пытаться пробить) броню. В общем случае способность пробивать броню также зависит от калибра (ну, и еще от многого – начальной скорости, например, но мы не будем усложнять). Поэтому, метод возвращает калибр. То есть, грубо говоря, снаряд может пробить броню, равную по толщине своему калибру. Этот метод не будет переопределяться в дочерних классах.
```
```
public int GetPenetration()
{
return gun.GetCaliber();
}
```
```
Кроме того, для удобной отладки и организации консольного вывода, имеет смысл добавить метод ToString, который просто позволит нам увидеть, что это за снаряд и какого калибра:
```
```
public override string ToString()
{
return $"Снаряд " + type + " к пушке калибра " + gun.GetCaliber();
}
```
```
Теперь сделаем разные типы снарядов, которые будут наследовать абстрактный снаряд: фугасный, кумулятивный, подкалиберный. Фугасный наносит самый большой урон, кумулятивный – меньше, подкалиберный – еще меньше. Дочерние классы не имеют полей и вызывают конструктор базового снаряда, передавая ему пушку, и строковый тип. В дочернем классе переопределяется метод GetDamage() – вносятся коэффициенты, которые увеличат или уменьшат урон по сравнению с дефолтным.
Фугасный (дефолтный урон):
```
```
public class HECartridge : Ammo
{
public HECartridge(Gun someGun) : base(someGun, "фугасный") { }
public override int GetDamage()
{
return (int)(base.GetDamage());
}
}
```
```
Кумулятивный (дефолтный урон х 0.6):
```
```
public class HEATCartridge : Ammo
{
public HEATCartridge(Gun someGun) : base(someGun, "кумулятивный") { }
public override int GetDamage()
{
return (int)(base.GetDamage() * 0.6);
}
}
```
```
Подкалиберный (дефолтный урон х 0.3):
```
```
public class APCartridge : Ammo
{
public APCartridge(Gun someGun) : base(someGun, "подкалиберный") { }
public override int GetDamage()
{
return (int)(base.GetDamage() * 0.3);
}
}
```
```
Обратите внимание, что в переопределенном методе GetDamage вызывается и метод базового класса. То есть, переопределив метод, мы также сохраняем возможность обратиться к дефолтному методу, использовав ключевое слово base).
Итак, для снарядов мы применили и агрегацию (пушка в базовом классе), и наследование.
Создадим теперь броню для танка. Здесь применим только наследование. Любая броня имеет толщину. Поэтому абстрактный класс брони будет иметь поле thickness, и строковое поле type, которое будет определятся при создании дочерних классов.
```
```
public abstract class Armour
{
public int thickness;
public string type;
public Armour(int thickness, string type)
{
this.thickness = thickness;
this.type = type;
}
}
```
```
Броня будет в нашей игре определять пробита они или нет. Поэтому, у нее будет лишь один метод, который будет переопределяться в дочерних, в зависимости от типа брони.
```
```
public virtual bool IsPenetrated(Ammo projectile)
{
return projectile.GetDamage() > thickness;
}
```
```
А пробита они или нет – зависит от того, какой прилетел снаряд: в дефолтном случае какого калибра. Поэтому метод принимает экземпляр снаряда и возвращает булевый результат: пробита или нет. Создадим несколько типов брони – наследников абстрактной брони. Приведу код лишь одного типа – логика примерно такая же, как и в снарядах. Гомогенная броня хорошо держит фугасный снаряд, но плохо – подкалиберный. Поэтому, если прилетел подкалиберный снаряд, который имеет высокую бронепробиваемость, то в вычислениях наша броня как-бы становится тоньше. И так далее: каждый вид брони имеет свой набор коэфициентов устойчивости к тому или иному снаряду.
```
```
public class HArmour : Armour
{
public HArmour(int thickness) : base(thickness, "гомогенная") { }
public override bool IsPenetrated(Ammo projectile)
{
if (projectile is HECartridge)
{
//Если фугасный, то толщина брони считается больше
return projectile.GetPenetration() > this.thickness * 1.2;
}
else if (projectile is HEATCartridge)
{
//Если кумулятивный, то толщина брони нормальная
return projectile.GetPenetration() > this.thickness * 1;
}
else
{
//Если подкалиберный, то считаем уменьшаем толщину
return projectile.GetPenetration() > this.thickness * 0.7;
}
}
}
```
```
Здесь мы используем одно из чудес, которые дает полиморфизм. Метод принимает любой снаряд. В сигнатуре указан базовый класс, а не дочерние. Но внутри метода, мы можем увидеть, что за снаряд прилетел – какого типа. И в зависимости от этого, реализуем ту или иную логику. Если бы мы не применили наследование для снарядов, а сделали просто три уникальных класса типов снарядов, то проверку пробития брони пришлось бы организовывать иначе. Нам пришлось бы писать столько перегруженных методов, сколько типов снарядов у нас в игре, и вызывать один из них в зависимости от того, какой снаряд прилетел. Это тоже было бы довольно изящно, но не относится к теме данной статьи.
Теперь у нас все готово для создания танка. В танке не будет наследования, но будет композиция и агрегация. Разумеется, у танка будет название. У танка будет пушка (агрегация). Для нашей игры сделаем допущение, что танк может «переодевать» броню перед каждым ходом – выбрать тот или иной тип брони. Для этого, у танка будет список типов брони. У танка будет боеукладка – список снарядов, который будет наполнен снарядами, созданными в конструкторе танка (композиция!). У танка будет здоровье (уменьшается при попадании в него), и, у танка будет текущая выбранная броня и текущий выбранный снаряд.
```
```
public class Panzer
{
private string model;
private Gun gun;
private List armours;
private List ammos;
private int health;
public Ammo LoadedAmmo { get; set; }
public Armour SelectedArmour { get; set; }
}
```
```
Для того, чтобы конструктор танка остался более-менее компактным, сделаем два вспомогательных приватных метода, которые добавляют три типа брони соответствующей толщины, и наполняют боеукладку 10 снарядами каждого из трех типов:
```
```
private void AddArmours(int armourWidth)
{
armours.Add(new SArmour(armourWidth));
armours.Add(new HArmour(armourWidth));
armours.Add(new CArmour(armourWidth));
}
private void LoadAmmos()
{
for(int i = 0; i < 10; i++)
{
ammos.Add(new APCartridge(this.gun));
ammos.Add(new HEATCartridge(this.gun));
ammos.Add(new HECartridge(this.gun));
}
}
```
```
Теперь конструктор танка выглядит вот таким образом:
```
```
public Panzer(string name, Gun someGun, int armourWidth, int h)
{
model = name;
gun = someGun;
health = h;
armours = new List();
ammos = new List();
AddArmours(armourWidth);
LoadAmmos();
LoadedAmmo = null;
SelectedArmour = armours[0]; //по умолчанию - гомогенная броня
}```
```
Обратите внимание, что здесь мы снова используем возможности полиморфизма. Наша боекладка вмещает снаряды любого типа, так как список имеет тип данных Ammo – родительский снаряд. Если бы мы не наследовались, а создавали уникальные типы снарядов, пришлось бы делать отдельный список под каждый тип снаряда.
Пользовательский интерфейс танка состоит из трех методов: выбрать броню, зарядить пушку, выстрелить.
Выбрать броню:
```
```
public void SelectArmour(string type)
{
for (int i = 0; i < armours.Count; i++)
{
if (armours[i].type == type)
{
SelectedArmour = armours[i];
break;
}
}
}
```
```
Зарядить пушку:
```
```
public void LoadGun(string type)
{
for(int i = 0; i < ammos.Count; i++)
{
if(ammos[i].type == type)
{
LoadedAmmo = ammos[i];
Console.WriteLine("заряжено!");
return;
}
}
Console.WriteLine($"сорян, командир, " + type + " закончились!");
}
```
```
Как я упомянул в начале, в этом примере я старался максимально уйти от абстрактных понятий, которые нужно все время держать в голове. Поэтому каждый экземпляр снаряда у нас равен физическому снаряду, который положили в боеукладку перед боем. Следовательно, снаряды могут закончится в самый неподходящий момент!
Выстрелить:
```
```
public Ammo Shoot()
{
if (LoadedAmmo != null)
{
Ammo firedAmmo = (Ammo)LoadedAmmo.Clone();
ammos.Remove(LoadedAmmo);
LoadedAmmo = null;
Random rnd = new Random();
int dice = rnd.Next(0, 100);
bool hit = this.gun.IsOnTarget(dice);
if (this.gun.IsOnTarget(dice))
{
Console.WriteLine("Попадание!");
return firedAmmo;
}
else
{
Console.WriteLine("Промах!");
return null;
}
}
else Console.WriteLine("не заряжено");
return null;
}
```
```
Здесь – поподробнее. Во-первых, есть проверка заряжена ли пушка. Во-вторых, снаряд, который вылетел из ствола, уже не существует для данного танка, его уже нет ни в пушке, ни в боеукладке. Но физически он еще существует – летит по направлению к цели. И если попадет, будет участвовать в вычислении пробития брони и урона цели. Поэтому, мы сохраняем этот снаряд в новой переменной: Ammo firedAmmo. Поскольку на следующей же строке данный снаряд перестанет существовать для данного танка, придется использовать интерфейс IClonable для базового класса снаряда:
```
```
public abstract class Ammo : ICloneable
```
```
Этот интерфейс требует реализации метода Clone(). Вот она:
```
```
public object Clone()
{
return this.MemberwiseClone();
}
```
```
Теперь все супер реалистично: при выстреле генерируется dice, пушка рассчитывает попадание своим методом IsOnTarget, и, если попадание есть, то метод Shoot вернет экземпляр снаряда, а если промах – то вернет null.
Последний метод танка – его поведение при попадании вражеского снаряда:
```
```
public void HandleHit(Ammo projectile)
{
if (SelectedArmour.IsPenetrated(projectile))
{
this.health -= projectile.GetDamage();
}
else Console.WriteLine("Броня не пробита.");
}
```
```
Снова полиморфизм во всей красе. К нам прилетает снаряд. Любой. Исходя из выбранной брони и типа снаряда, вычисляется пробита броня или нет. Если пробита, то вызывается метод конкретного типа снаряда GetDamage().
Все готово. Остается только написать консольный (или неконсольный) вывод, в котором будет обеспечен пользовательский интерфейс и в цикле реализованы поочередные ходы игроков.
Подведем итоги. Мы написали программу, в которой использовали наследование, композицию и агрегацию, надеюсь, поняли и запомнили различия. Активно задействовали возможности полиморфизма, во-первых, когда любые экземпляры дочерних классов можно сложить в список, имеющий тип данных родительского, а во-вторых, создавая методы, которые принимают в качестве параметра родительский экземпляр, но внутри которых вызываются методы дочернего. По ходу текста я упоминал возможные альтернативные реализации – замену наследования на агрегацию, и, универсального рецепта тут нет. В нашей реализации наследование дало нам легкость добавления новых деталей в игру. Например, чтобы добавить новый тип снаряда нам нужно лишь:
* собственно, скопировать один из существующих типов, заменив название и строковое поле, передаваемое в конструктор;
* добавить еще один if в дочерние классы брони;
* добавить дополнительный пункт в меню выбора снаряда в пользовательском интерфейсе.
Аналогично, чтобы добавить еще одну разновидность брони, требуется лишь описать эту разновидность и добавить пункт в пользовательский интерфейс. Модифицировать другие классы или методы не требуется.
Ниже – приведена диаграмма наших классов.
В финальном коде игры все «магические числа», которые использовались в тексте, вынесены в отдельный статический класс Config. К публичным полям статического класса мы можем обратиться из любого фрагмента нашего кода и его экземпляр не нужно (и невозможно) создавать. Вот так он выглядит:
```
```
public static class Config
{
public static List ammoTypes = new List { "фугасный", "кумулятивный", "подкалиберный" };
public static List armourTypes = new List { "гомогенная", "разнесенная", "комбинированная" };
//трешхолд для пушки - величина, выше которой будем считать, что снаряд попал в цель
public static int \_gunTrashold = 100;
//дефолтный коэффициент для заброневого действия базового снаряда
public static int \_defaultDamage = 3;
//коэффициенты урона для снарядов разных типов
public static double \_HEDamage = 1.0;
public static double \_HEATDamage = 0.6;
public static double \_APDamage = 0.3;
//коэффициенты стойкости брони
//для гомогенной:
//Если в гомогенную броню прилетает фугасный, то ее толщина считается большей - коэффициент 1.2
public static double \_HArmour\_VS\_HE = 1.2;
//Если в гомогенную броню прилетает кумулятивный, то ее толщина считается нормальной - коэффициент 1.0
public static double \_HArmour\_VS\_HEAT = 1.0;
//Если в гомогенную броню прилетает подкалиберный, то ее толщина считается меньшей - коэффициент 0.7
public static double \_HArmour\_VS\_AP = 0.7;
//для комбинированной брони
//Если в комбинированную броню прилетает фугасный, то ее толщина считается нормальной - коэффициент 1
public static double \_СArmour\_VS\_HE = 1.0;
//Если в комбинированную броню прилетает фугасный, то ее толщина считается меньше - коэффициент 0.8
public static double \_СArmour\_VS\_HEAT = 0.8;
//Если в комбинированную броню прилетает фугасный, то ее толщина считается больше - коэффициент 1.2
public static double \_СArmour\_VS\_AP = 1.2;
//Для разнесенной брони
//Если в разнесенную броню прилетает фугасный, то ее толщина считается меньше - коэффициент 0.8
public static double \_SArmour\_VS\_HE = 0.8;
//Если в разнесенную броню прилетает кумулятивный, то ее толщина считается больше - коэффициент 1.2
public static double \_SArmour\_VS\_HEAT = 1.2;
//Если в разнесенную броню прилетает подкалибереый, то ее толщина считается нормальной - коэффициент 1
public static double \_SArmour\_VS\_AP = 1.0;
}
```
```
И благодаря этому классу мы можем производить дальнейшую настройку, меняя параметры лишь здесь, без дальнейшего углубления в классы и методы. Если, например, мы пришли к выводу, что подкалиберный снаряд получился слишком сильным, то мы меняем одну циферку в Config.
Весь код игры можно увидеть вот [здесь](https:////github.com/FSuhov/BattleTanks). | https://habr.com/ru/post/354046/ | null | ru | null |
# Делаем радиоуправление для самолета
Прочитав [этот](http://habrahabr.ru/post/168219/) пост загорелся и я идеей склепать свой самолетик. Взял готовые [чертежи](http://forum.rcdesign.ru/f81/thread145233.html), заказал у китайцев моторчики, аккумуляторы и пропеллеры. А вот радиоуправление решил сделать самостоятельно, во-первых — так интереснее, во-вторых — надо себя чем-то занять пока посылка с остальными запчастями будет ехать, ну и в третьих — появилась возможность соригинальничать и добавить всяких плюшек.
Осторожно, картинки!
#### Как и чем управлять
Нормальные люди берут приемник, втыкают в него сервомашинки, регулятор скорости, двигают рычажки на пульте и радуются жизни не задаваясь принципами работы и не углубляясь в подробности. В нашем случае такое не пройдет. Первой задачей стало узнать каким макаром управляются сервомашинки. Все оказывается достаточно просто, у привода есть три провода: + питания, — питания и сигнальный. На сигнальном проводе прямоугольные импульсы изменяемой скважности. Чтобы понять что это такое смотрим картинку:
Итак, если мы хотим установить привод в крайнее левое положение нужно слать импульсы длительностью 0,9мс с интервалом 20мс, если в крайнее правое — длительность 2,1мс, интервал тот же, ну со средними положениями аналогично. Как оказалось, регуляторы скорости управляются аналогично. Те, кто в теме скажут что это [обычный ШИМ](http://easyelectronics.ru/avr-uchebnyj-kurs-ispolzovanie-shim.html), который реализовать на любом микроконтроллере — плевое дело. Вот и я так решил, купил в местном магазине сервомашинку и склепал на макетке для нее так называемый сервотестер на ATtiny13. И тут оказалось, что ШИМ не совсем простой, а с подводными камнями. Как видно из вышеприведенной диаграммы, скважность (отношение длительности импульса к длительности периода) от 5% до 10% (в дальнейшем я за крайние положения принимаю импульсы длительностью 1,0мс и 2,0мс) для 256-значного ШИМ счетчика ATtiny13 это соответствует значениям от 25 до 50. Но это при условии, что на заполнение счетчика уйдет 20мс, а на деле так не получится и для частоты 9,6МГц и предделителя 1024 нужно ограничить счетчик значением 187(ТОР), в таком случае у нас получится частота 50,134Гц. В большинстве (если не во всех) сервомашинок нету точного генератора опорной частоты и поэтому частота управляющего сигнала может немного плавать. Если оставить ТОР счетчика 255, то частота управляющего сигнала будет 36,76Гц — на некоторых приводах оно будет работать (возможно с глюками), но далеко не на всех. Итак, теперь у нас 187-значный счетчик, для него 5-10% соответствуют значениям от 10 до 20 — всего 10 значений, немного дискретно получится. Если думаете поиграть с тактовой частотой и предделителем ниже привожу сравнительную табличку для 8-битного ШИМа:
Но ведь у большинства микроконтроллеров есть 16-битный (и больше) таймер для генерации ШИМ. Здесь проблема с дискретностью сразу пропадет еще и частоту можно точно выставить. Долго расписывать не буду, сразу даю табличку:
Я не думаю, что для китайской сервомашинки есть существенная разница в 600 и 1200 значений, поэтому вопрос с точностью позиционирования можно считать закрытым.
#### Многоканальное управление
С одной сервомашинкой разобрались, но для самолета их нужно минимум три и еще регулятор скорости. Решение «в лоб» — взять микроконтроллер с четырьмя каналами 16-битного ШИМ, но такой контроллер будет стоять дорого и, скорее всего, займет много места на плате. Второй вариант — запилить программный ШИМ, но занимать процессорное время — это тоже не вариант. Если снова посмотреть на диаграммы сигнала, то 80% времени он не несет никакой информации, поэтому рациональнее было бы ШИМом задавать только сам импульс 1-2мс. Почему скважность изменяется в таких узких пределах, ведь проще было бы и формировать и считывать импульсы со скважностью хотя бы 10-90%? Зачем нужен тот неинформативный кусок сигнала занимающий 80% времени? Я заподозрил, что, возможно, эти 80% могут занимать импульсы для других исполнительных механизмов, а потом этот сигнал разделяется на несколько разных. То есть, в периоде длительностью 20мс могут уместится 10 импульсов длительностью 1-2мс, затем этот сигнал каким-то демультиплексором разделяется на 10 различных с длительностью периода как раз 20мс. Сказано — сделано, нарисовал в PROTEUS такую схемку:
В роли демультиплексора — 74HC238, на его вход E подаются импульсы с выхода микроконтроллера. Эти импульсы — ШИМ с периодом 2мс (500Гц) и скважностью 50-100%. У каждого импульса своя скважность, обозначающая состояние каждого канала. Вот так выглядит сигнал на входе Е:
Для того, чтобы 74HC238 знал на какой выход подать текущий сигнал используем PORTC микроконтроллера и входы A, B, C демультиплексора. В результате на выходах получаем такие сигналы:
Сигналы на выходе получаются правильной частоты (50Гц) и скважности (5-10%). Итак, нужно генерировать ШИМ частотой 500Гц и заполнением 50-100%, вот табличка для настройки предделителя и ТОР 16-битного счетчика:
Интересно, что возможное количество значений ШИМа ровно в 1000 раз меньше частоты таймера.
##### Программная реализация
Для ATmega8 с тактовой частотой 16МГц в AtmelStudio6 все реализуется следующим образом: вначале задефайним значения счетчика для крайних положений сервомашинок:
```
#define LOW 16000U
#define HIGH 32000U
```
затем инициализируем генератор ШИМа на таймере/счетчике1:
```
OCR1A = HIGH; //Устанавливаем ТОР
TCCR1A = 0<
```
Остается реализовать прерывания:
```
ISR(TIMER1_COMPA_vect) //прерывание по достижению верхнего значения счетчика, непосредственно перед началом следующего импульса
{
//c_num- переменная, обозначающая номер текущего канала, channels - массив значений каналов
if (c_num <= 7)
{
OCR1B = channels[c_num];
}
else
{
OCR1B = 0; //отключаем ШИМогенератор для несуществующих в демультиплексоре 8 и 9 канала
}
}
ISR(TIMER1_COMPB_vect, ISR_NOBLOCK)// прерывание возникающее в конце импульса
{
if (c_num <= 7)
{
PORTC = c_num; //для каналов 0-7 выводим номер канала на PORTC
}
//и изменяем значение счетчика от 0 до 9
if (c_num >= 9)
{
c_num = 0;
}
else
{
c_num++;
}
}
```
Глобально разрешаем прерывания и готово, забивая в channels значения от LOW до HIGH изменяем значения на каналах.
#### Реализация в железе
Ну с теорией разобрались, пришло время все это реализовать. Мозгом системы выбран микроконтроллер ATmega8A, тактируется от кварца на 16МГц (не потому, что я захотел 16000 позиций сервомашинки, а потому, что у меня такие валялись). Управляющий сигнал для МК будет поступать через UART. В результате получилась вот такая схемка:
Спустя некоторое время появилась вот такая платка:
Два трехштыревых разъема я не припаял потому, что они мне не нужны, а не подряд они впаяны поскольку у меня нету металлизации отверстий, а в нижнем разъеме дорожки с двух сторон, можно было бы заменить проволочкой, но программно нету проблемы выводить сигнал на любой разъем. Также отсутствует 78L05 ибо в моем регуляторе двигателя есть встроенный стабилизатор (ВЕС).
Для получения данных к плате подключается [радиомодуль](http://habrahabr.ru/post/139947/) HM-R868:
Изначально думал втыкать его прямо в плату, но эта конструкция не помещалась в самолетик, пришлось сделать через шлейф. Если изменить прошивку, то контакты разъема для программирования можно использовать для включения/отключения каких-нибудь системам (бортовые огни и т.п.)
Плата обошлась примерно в 20грн = $2.50, приемник — 30грн = $3,75.
#### Передающая часть
Самолетная часть есть, осталось разобраться с наземной аппаратурой. Как уже писалось ранее, данные передаются по UART, на каждый канал по одному байту. Вначале подключал свою систему проводом через [переходник](http://easyelectronics.ru/preobrazovatel-usb-uart-na-ftdi-ft232rl.html) к компьютеру и команды слал через терминал. Чтобы дешифратор определял начало посылки, а в будущем выделял посылки адресуемые именно ему, вначале шлется байт-идентификатор, затем 8 байт определяющих состояние каналов. Позже стал использовать радиомодули, при отключении передатчика все моторчики начинали дико дергаться. Дабы отфильтровать сигнал от шумов, десятым байтом шлю XOR всех 9 предыдущих байт. Помогло, но слабо, добавил еще проверку на таймаут между байтами, если он превышается — вся посылка игнорится и прием начинается заново, с ожидания байта-идентификатора. С добавлением контрольной суммы в виде XOR слать команды с терминала стало напряжным, поэтому я побыстрому наклепал вот такую программку с ползунками:
Число в нижнем левом углу — контрольная сумма. Передвигая ползунки на компе двигались рули на самолете! Вообщем отладил я все это и стал думать о пульте ДУ, купил для него вот такие джойстики:
Но потом меня посетила одна мысль. В свое время я тащился от всяких авиасимуляторов: «Ил-2 Штурмовик», «Lock On», «MSFSX», «Ка-50 Черная Акула» и др. Соответственно был у меня джойстик Genius F-23 и решил я прикрутить его к вышеописанной проге с ползунками. Погуглил как это реализовать, нашел этот [пост](http://habrahabr.ru/post/124851/) и получилось! Управлять самолетиком с помощью полноценного джойстика, мне кажется, гораздо круче, чем маленькой палочкой на пульте. Вообщем все вместе изображено на первой фотке — это нетбук, джойстик, преобразователь на FT232, и подключенный к нему передатчик HM-T868. Преобразователь подключается 2м кабелем от принтера, что позволяет закрепить его на каком нибудь дереве или чем-то подобном.
#### Пуск!
Итак, есть самолетик, есть радиоуправление — Поехали!(с) Первый полет производился над асфальтом, результат — сломанный пополам фюзеляж и полувырванный двигатель. Второй полет производился над более мягкой поверхностью:
Последующие полетов 10 были тоже не особо удачными. Основной причиной я считаю сильную дискретность джойстика — по крену он выдавал только 16 значений (вместо возможных 256), с осью тангажа — не лучше. Но так как в результате испытаний самолет был значительно поврежден и не подлежит ремонту:
— проверить правдивость этой версии пока не представляется возможным. В пользу этой версии говорит и зафиксированная на видео попытка выровнять самолет — он летит накрененным, а потом резко заваливается в противоположную сторону (а должен плавно). Вот более наглядное видео:
Дальность действия аппаратуры — примерно 80м, дальше тоже ловит, но через раз.
Ну вот и все, благодарю за внимание. Надеюсь, приведенная информация окажется для кого-то полезной. Буду рад ответить на все вопросы.
В [архиве](https://www.dropbox.com/s/npyyqeugzi17e1z/Sceme.zip) схема и разводка платы для Протеуса. | https://habr.com/ru/post/180759/ | null | ru | null |
# Awesome-лист своими руками, или GitHub вместо блокнота
Привет, Хабр! Наверное, у каждого из нас есть такой файлик, куда мы припрятываем что-то полезное и интересное для себя. Какие-то ссылки на статьи, книги, репозитории, мануалы. Это могут быть закладки в браузере или даже просто открытые вкладки, оставленные на потом. Со временем все это разбухает, ссылки перестают открываться, а большая часть материалов просто устаревает.
А что если поделиться этой годнотой с сообществом и выложить этот файлик на гитхаб? Тогда ваши труды могут быть полезны еще кому-нибудь, а поддерживать актуальность можно совместно, принимая обновления от желающих через старые добрые PR'ы. Именно для этого предназначен проект [Awesome lists](https://github.com/sindresorhus/awesome). Он входит в ТОП-10 репозиториев гитхаба, обладает 138К звезд, и ссылка на ваши труды может оказаться прямо в его корневом README, что привлечет огромную аудиторию к вашему творчеству. Правда, для этого придется немного постараться. О моем опыте таких стараний хочу поделиться с вами.
Меня зовут Максим Грамин. В КРОК занимаюсь Java-разработкой и исследованиями в области БД. В этом посте я расскажу, что такое Awesome Lists и как сделать свой настоящий официальный awesome-репо.
Что такое Awesome Lists
-----------------------
Когда мне предстоит разобраться с какой-нибудь новой технологией или языком программирования, то я первым делом иду именно сюда — нахожу нужный раздел, а в нем подходящие листы. И судя по количеству звезд и их постоянному росту, так делаю не только я.
На самом деле — это обычный плоский readme.md, который живет в отдельном [репозитории](https://github.com/sindresorhus/awesome), занимает при этом 8-е место среди всех репозиториев GitHub'а и включает ссылки на другие листы, посвященные какой-либо тематике. Например в разделе Programming Languages можно найти листы Awesome Python и Awesome Go, а в Front-End Development есть огромное количество ресурсов по WEB-разработке. Ну и, конечно же, — раздел [Databases](https://github.com/sindresorhus/awesome#databases) (к нему мы еще вернемся чуть позже). И да, все это не ограничивается только техническими темами. Например, в разделах Entertainment и Gaming тоже можно найти много чего интересного (меня лично порадовал [awesome-fantasy](https://github.com/RichardLitt/awesome-fantasy)).
Главная особенность состоит в том, что все эти листы ведутся не лично автором, а сообществом и составлены в соответствии со специальным и очень строгим [awesome manifesto](https://github.com/sindresorhus/awesome/blob/main/awesome.md). Каждый такой лист является самостоятельным сообществом специалистов, живет своей жизнью и открыт для ваших pull request'ов, которые сделают его еще лучше. А также любой желающий может сделать свой собственный лист, если какая-то тема еще не была освещена.
Автор идеи и координатор всего этого хозяйства — легендарный Синдре Сорхус, [первый человек на GitHub'е](https://gitstar-ranking.com/users), автор более [1000 npm-модулей](https://www.npmjs.com/~sindresorhus), и именно он будет принимать ваши PR-ы.
Как попасть в awesome-list
--------------------------
Если вдруг вы не нашли подходящего листа на интересующую вас тему, то это первый признак того, что его нужно сделать самому!
Расскажу на примере своего детища [Awesome Database Tools](https://github.com/mgramin/awesome-db-tools#readme) — Из проекта в проект мне приходится работать с самыми разными базами данных, и поэтому у меня завелся такой файлик, в котором я собирал полезные тулзы для работы с ними, всякие БД-миграторы, IDE-шки, админ-панели, средства мониторинга и всякое разное. Инструменты, которые я уже использовал, или только планировал начать применять. Делился я этим файликом с коллегами в КРОК и за его пределами. Это много кому помогало и было интересно. В итоге я захотел ~~славы~~ большего, когда однажды заметил, что в разделе Databases как раз нет листа на эту тему. И я решил добавить туда свой.
**Что для этого нужно?**
1. Регистрируем обычный GitHub-репо с именем вида awesome-что-то-там. В моем случае это был awesome-database-tools
2. Приводим свой лист к формату awesome, в этом нам поможет [generator-awesome-list](https://github.com/dar5hak/generator-awesome-list), который сгенерирует все нужные файлы в нужном формате
3. Настраиваем самый настоящий CI. [awesome-lint](https://github.com/sindresorhus/awesome-lint) и travis ci помогут нам контролировать [валидность](https://travis-ci.org/github/mgramin/awesome-db-tools) нашего листа
4. Ждем 30 дней
5. Делаем ревью как минимум на 2 чужих PR'а
6. И наконец делаем PR в главный репо, куда добавляем ссылку на свой репо. Тут нужно внимательно все прочесть и тщательно выполнить все многочисленные требования к новому листу и самому PR.
Мой первый блин [оказался комом](https://github.com/sindresorhus/awesome/pull/1336)
Но прошло немного времени, я собрал еще больше материала, поработал над ошибками и отважился на [вторую попытку](https://github.com/sindresorhus/awesome/pull/1679).
Но я забыл об очень важной вещи, о чем мне мягко намекнули:
Я был не очень внимателен и не добавил единорога в знак подтверждения того, что все условия выполнены
Затем прошло еще немного времени, еще немного правок по замечаниям, и появился долгожданный [твит](https://twitter.com/awesome__re/status/1246779641475424256), что мой PR был принят.
Так я стал автором своего первого листа, и мне стали приходить [PR'ы](https://github.com/mgramin/awesome-db-tools/pulls?q=is%3Apr+is%3Aclosed) из сообщества на добавление новых тулзов. И многие из них уже включены в [Awesome Database Tools](https://github.com/mgramin/awesome-db-tools#readme). Если лень переходить по ссылке,
**вот актуальная на момент публикации поста подборка**
Awesome Database Tools [Awesome](https://awesome.re)
====================================================
> Community driven list of database tools
Here we will collect information about awesome useful and awesome experimental tools that simplify working with databases for DBA, DevOps, Developers and mere mortals.
Feel free to add information about your own db-tools or your favorite third-party db-tools.
Contents
--------
* [IDE](#ide)
* [GUI Managers/Clients](#gui-managersclients)
* [CLI tools](#cli-tools)
* [DB-schema navigation and visualization](#db-schema-navigation-and-visualization)
* [Modelers](#modelers)
* [Migration tools](#migration-tools)
* [Code generation tools](#code-generation-tools)
* [Wrappers](#wrappers)
* [Backup tools](#backup-tools)
* [Replication/Data operation](#replicationdata-operation)
* [Scripts](#scripts)
* [Monitoring/Statistics/Perfomance](#monitoringstatisticsperfomance)
+ [Zabbix](#zabbix)
* [Testing](#testing)
+ [Data generator](#data-generator)
* [Administration](#administration)
* [HA/Failover/Sharding](#hafailoversharding)
* [Kubernetes](#kubernetes)
* [Configuration Tuning](#configuration-tuning)
* [DevOps](#devops)
* [Schema samples](#schema-samples)
* [Reporting](#reporting)
* [Distributions](#distributions)
* [Security](#security)
* [Code formatters](#code-formatters)
IDE
---
* [AnySQL Maestro](https://www.sqlmaestro.com/products/anysql/maestro) — Premier multi-purpose admin tool for database management, control and development.
* [Aqua Data Studio](https://www.aquafold.com/aquadatastudio) — Aqua Data Studio is productivity software for Database Developers, DBAs, and Analysts.
* [Database .net](http://fishcodelib.com/Database.htm) — Multiple database management tool with support for 20+ databases.
* [DataGrip](https://www.jetbrains.com/datagrip) — Cross-Platform IDE for Databases & SQL by JetBrains.
* [DBeaver](https://github.com/dbeaver/dbeaver) — Free universal database manager and SQL client.
* [dbForge Studio for MySQL](https://www.devart.com/dbforge/mysql/studio) — Universal IDE for MySQL and MariaDB database development, management, and administration.
* [dbForge Studio for Oracle](https://www.devart.com/dbforge/oracle/studio) — Powerful IDE for Oracle management, administration, and development.
* [dbForge Studio for PostgreSQL](https://www.devart.com/dbforge/postgresql/studio) — GUI tool for managing and developing databases and objects.
* [dbForge Studio for SQL Server](https://www.devart.com/dbforge/sql/studio) — Powerful integrated development environment for SQL Server development, management, administration, data analysis, and reporting.
* [dbKoda](https://github.com/SouthbankSoftware/dbkoda) — Modern (JavaScript/Electron framework), open source IDE for MongoDB. It has features to support development, administration and performance tuning on MongoDB databases.
* [IBExpert](http://www.ibexpert.net/ibe) — Comprehensive GUI tool for Firebird and InterBase.
* [HeidiSQL](https://github.com/HeidiSQL/HeidiSQL) — A lightweight client for managing MySQL, MSSQL and PostgreSQL, written in Delphi.
* [MySQL Workbench](https://www.mysql.com/products/workbench) — MySQL Workbench is a unified visual tool for database architects, developers, and DBAs.
* [Navicat](https://www.navicat.com/en/products#navicat) — A database development tool that allows you to simultaneously connect to MySQL, MariaDB, SQL Server, Oracle, PostgreSQL, and SQLite databases from a single application.
* [Oracle SQL Developer](http://www.oracle.com/technetwork/developer-tools/sql-developer) — Oracle SQL Developer is a free, integrated development environment that simplifies the development and management of Oracle Database in both traditional and Cloud deployments.
* [pgAdmin](https://www.pgadmin.org) — The most popular and feature rich Open Source administration and development platform for PostgreSQL, the most advanced Open Source database in the world.
* [pgAdmin3](https://www.bigsql.org/pgadmin3) — Long Term Support for pgAdmin3.
* [PL/SQL Developer](https://www.allroundautomations.com/products/pl-sql-developer) — IDE that is specifically targeted at the development of stored program units for Oracle Databases.
* [PostgreSQL Maestro](https://www.sqlmaestro.com/products/postgresql/maestro) — Complete and powerful database management, admin and development tool for PostgreSQL.
* [Toad](https://www.quest.com/toad/) — Toad is the premier database solution for developers, admins and data analysts. Manage complex database changes with a single database management tool.
* [Toad Edge](https://www.toadworld.com/products/toad-edge) — Simplified database development tool for MySQL and Postgres.
* [TOra](https://github.com/tora-tool/tora) — TOra is an open source SQL IDE for Oracle, MySQL and PostgreSQL dbs.
* [Valentina Studio](https://www.valentina-db.com/en/valentina-studio-overview) — Create, administer, query and explore Valentina DB, MySQL, MariaDB, PostgreSQL and SQLite databases for FREE.
GUI Managers/Clients
--------------------
* [Adminer](https://github.com/vrana/adminer) — Database management in a single PHP file.
* [DbVisualizer](https://www.dbvis.com) — Universal database tool for developers, DBAs and analysts.
* [HouseOps](https://github.com/HouseOps/HouseOps) — Enterprise ClickHouse Ops UI for you run querys, monitoring ClickHouse health and make a lot of others thinks.
* [JackDB](https://www.jackdb.com) — Direct SQL access to all your data, no matter where it lives.
* [OmniDB](https://github.com/OmniDB/OmniDB) — Web tool for database management.
* [Pgweb](https://github.com/sosedoff/pgweb) — Web-based database browser for PostgreSQL, written in Go and works on macOS, Linux and Windows machines.
* [phpLiteAdmin](https://www.phpliteadmin.org) — Web-based SQLite database admin tool written in PHP with support for SQLite3 and SQLite2.
* [phpMyAdmin](https://github.com/phpmyadmin/phpmyadmin) — A web interface for MySQL and MariaDB.
* [psequel](http://www.psequel.com) — PSequel provides a clean and simple interface for you to perform common PostgreSQL tasks quickly.
* [PopSQL](https://popsql.com) — Modern, collaborative SQL editor for your team.
* [Postico](https://eggerapps.at/postico) — A Modern PostgreSQL Client for the Mac.
* [Robo 3T](https://github.com/Studio3T/robomongo) — Robo 3T (formerly Robomongo) is a shell-centric cross-platform MongoDB management tool.
* [Sequel Pro](https://github.com/sequelpro/sequelpro) — Sequel Pro is a fast, easy-to-use Mac database management application for working with MySQL & MariaDB databases.
* [SQL Operations Studio](https://github.com/microsoft/sqlopsstudio) — A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux.
* [SQLite Expert](http://www.sqliteexpert.com/index.html) — Graphical interface supports all SQLite features.
* [sqlpad](https://github.com/rickbergfalk/sqlpad) — Web-based SQL editor run in your own private cloud.
* [SQLPro](https://www.macpostgresclient.com) — A simple, powerful Postgres manager for macOS.
* [SQuirreL](https://sourceforge.net/projects/squirrel-sql) — Graphical SQL client written in Java that will allow you to view the structure of a JDBC compliant database, browse the data in tables, issue SQL commands etc.
* [SQLTools](https://github.com/mtxr/vscode-sqltools) — Database management for VSCode.
* [SQLyog](https://www.webyog.com/product/sqlyog) — The most complete and easy to use MySQL GUI.
* [Tabix](https://github.com/tabixio/tabix) — SQL Editor & Open source simple business intelligence for Clickhouse.
* [TablePlus](https://github.com/TablePlus/TablePlus) — Modern, native, and friendly GUI tool for relational databases: MySQL, PostgreSQL, SQLite & more.
* [TeamPostgreSQL](http://www.teampostgresql.com) — PostgreSQL Web Administration GUI — use your PostgreSQL databases from anywhere, with rich, lightning-fast AJAX web interface.
CLI tools
---------
* [ipython-sql](https://github.com/catherinedevlin/ipython-sql) — Connect to a database for issue SQL commands within IPython or IPython Notebook.
* [iredis](https://github.com/laixintao/iredis) — A Cli for Redis with AutoCompletion and Syntax Highlighting.
* [pgcenter](https://github.com/lesovsky/pgcenter) — Top-like admin tool for PostgreSQL.
* [pg\_activity](https://github.com/julmon/pg_activity) — Top like application for PostgreSQL server activity monitoring.
* [pg\_top](https://github.com/markwkm/pg_top) — 'top' for PostgreSQL.
* [pspg](https://github.com/okbob/pspg) — Postgres Pager.
* [SQLcl](http://www.oracle.com/technetwork/developer-tools/sqlcl/overview/index.html) — Oracle SQL Developer Command Line (SQLcl) is a free command line interface for Oracle Database.
* [usql](https://github.com/xo/usql) — A universal command-line interface for PostgreSQL, MySQL, Oracle Database, SQLite3, Microsoft SQL Server, [and many other databases](https://github.com/xo/usql#database-support) including NoSQL and non-relational databases!
### dbcli
* [athenacli](https://github.com/dbcli/athenacli) — AthenaCLI is a CLI tool for AWS Athena service that can do auto-completion and syntax highlighting.
* [litecli](https://github.com/dbcli/litecli) — CLI for SQLite Databases with auto-completion and syntax highlighting.
* [mssql-cli](https://github.com/dbcli/mssql-cli) — A command-line client for SQL Server with auto-completion and syntax highlighting.
* [mycli](https://github.com/dbcli/mycli) — A Terminal Client for MySQL with AutoCompletion and Syntax Highlighting.
* [pgcli](https://github.com/dbcli/pgcli) — Postgres CLI with autocompletion and syntax highlighting.
* [vcli](https://github.com/dbcli/vcli) — Vertica CLI with auto-completion and syntax highlighting.
DB-schema navigation and visualization
--------------------------------------
* [dbdiagram.io](https://dbdiagram.io) — Quick and simple tool for help you draw your database relationship diagrams and flow quickly using simple DSL language.
* [ERAlchemy](https://github.com/Alexis-benoist/eralchemy) — Entity Relation Diagrams generation tool.
* [SchemaCrawler](https://github.com/schemacrawler/SchemaCrawler) — A free database schema discovery and comprehension tool.
* [Schema Spy](https://github.com/schemaspy/schemaspy) — Generating your database to HTML documentation, including Entity Relationship diagrams.
* [tbls](https://github.com/k1LoW/tbls) — CI-Friendly tool for document a database, written in Go.
Modelers
--------
* [Navicat Data Modeler](https://www.navicat.com/en/products/navicat-data-modeler) — A powerful and cost-effective database design tool which helps you build high-quality conceptual, logical and physical data models.
* [Oracle SQL Developer Data Modeler](http://www.oracle.com/technetwork/developer-tools/datamodeler/overview/index.html) — Oracle SQL Developer Data Modeler is a free graphical tool that enhances productivity and simplifies data modeling tasks.
* [pgmodeler](https://github.com/pgmodeler/pgmodeler) — Data modeling tool designed for PostgreSQL.
Migration tools
---------------
* [2bass](https://github.com/CourseOrchestra/2bass) — Database configuration-as-code tool that utilizes concept of idempotent DDL scripts.
* [flyway](https://github.com/flyway/flyway) — Database migration tool.
* [gh-ost](https://github.com/github/gh-ost) — Online schema migration for MySQL.
* [liquibase](https://github.com/liquibase/liquibase) — Database-independent library for tracking, managing and applying database schema changes.
* [migra](https://github.com/djrobstep/migra) — Like diff but for PostgreSQL schemas.
* [node-pg-migrate](https://github.com/salsita/node-pg-migrate) — Node.js database migration management built exclusively for postgres. (But can also be used for other DBs conforming to SQL standard — e.g. CockroachDB.)
* [Pyrseas](https://github.com/perseas/Pyrseas) — Provides utilities to describe a PostgreSQL database schema as YAML.
* [SchemaHero](https://github.com/schemahero/schemahero) — A Kubernetes operator for declarative database schema management (gitops for database schemas).
* [Sqitch](https://github.com/sqitchers/sqitch) — Sensible database-native change management for framework-free development and dependable deployment.
* [yuniql](https://github.com/rdagumampan/yuniql) — Yet another schema versioning and migration tool just made with native .NET Core 3.0+ and hopefully better.
Code generation tools
---------------------
* [ddl-generator](https://github.com/catherinedevlin/ddl-generator) — Infers SQL DDL (Data Definition Language) from table data.
* [scheme2ddl](https://github.com/qwazer/scheme2ddl) — Command line util for export Oracle schema to set of ddl init scripts with ability to filter undesirable information, separate DDL in different files, pretty format output.
Wrappers
--------
* [DreamFactory](https://github.com/dreamfactorysoftware/dreamfactory) — A open source REST API backend for mobile, web, and IoT applications.
* [Hasura GraphQL Engine](https://github.com/hasura/graphql-engine) — Blazing fast, instant realtime GraphQL APIs on Postgres with fine grained access control, also trigger webhooks on database events.
* [jl-sql](https://github.com/avz/jl-sql) — SQL for JSON and CSV streams.
* [mysql\_fdw](https://github.com/EnterpriseDB/mysql_fdw) — PostgreSQL foreign data wrapper for MySQL.
* [Oracle REST Data Services](http://www.oracle.com/technetwork/developer-tools/rest-data-services) — A mid-tier Java application, ORDS maps HTTP(S) verbs (GET, POST, PUT, DELETE, etc.) to database transactions and returns any results formatted using JSON.
* [Prisma](https://github.com/prismagraphql/prisma) — Prisma turns your database into a realtime GraphQL API.
* [PostgREST](https://github.com/PostgREST/postgrest) — REST API for any Postgres database.
* [prest](https://github.com/prest/prest) — Is a way to serve a RESTful API from any databases written in Go.
* [restSQL](https://github.com/restsql/restsql) — SQL generator with Java and HTTP APIs, uses a simple RESTful HTTP API with XML or JSON serialization.
* [resquel](https://github.com/formio/resquel) — Easily convert your SQL database into a REST API.
* [sandman2](https://github.com/jeffknupp/sandman2) — Automatically generate a RESTful API service for your legacy database.
* [sql-boot](https://github.com/CrocInc/sql-boot) — Advanced REST and UI wrapper for your SQL-queries.
Backup tools
------------
* [pgbackrest](https://github.com/pgbackrest/pgbackrest) — Reliable PostgreSQL Backup & Restore.
* [BaRMan](https://github.com/2ndquadrant-it/barman) — Backup and Recovery Manager for PostgreSQL.
Replication/Data operation
--------------------------
* [Datasette](https://github.com/simonw/datasette) — A tool for exploring and publishing data.
* [dtle](https://github.com/actiontech/dtle) — Distributed Data Transfer Service for MySQL.
* [pgsync](https://github.com/ankane/pgsync) — Sync Postgres data between databases.
* [pg\_chameleon](https://github.com/the4thdoctor/pg_chameleon) — MySQL to PostgreSQL replica system written in Python 3. The system use the library mysql-replication to pull the row images from MySQL which are stored into PostgreSQL as JSONB.
* [PGDeltaStream](https://github.com/hasura/pgdeltastream) — A Golang webserver to stream Postgres changes atleast-once over websockets, using Postgres logical decoding feature.
* [repmgr](https://github.com/2ndQuadrant/repmgr) — The Most Popular Replication Manager for PostgreSQL.
Scripts
-------
* [pgx\_scripts](https://github.com/pgexperts/pgx_scripts) — A collection of useful little scripts for database analysis and administration, created by our team at PostgreSQL Experts.
* [pgsql-bloat-estimation](https://github.com/ioguix/pgsql-bloat-estimation) — Queries to mesure statistical bloat in indexes and tables for PostgreSQL.
* [pgWikiDont](https://gitlab.com/depesz/pgWikiDont) — SQL test that checks if your database follows rules from <https://wiki.postgresql.org/wiki/Don't_Do_This>.
* [pg-utils](https://github.com/dataegret/pg-utils) — Useful PostgreSQL utilities.
* [Postgres cheat sheet](https://postgrescheatsheet.com) — Useful SQL-scripts and commands by .
* [postgres\_dba](https://github.com/NikolayS/postgres_dba) — The missing set of useful tools for Postgres DBAs and all engineers.
* [postgres\_queries\_and\_commands.sql](https://gist.github.com/rgreenjr/3637525) — Useful PostgreSQL Queries and Commands.
* [TPT](https://github.com/tanelpoder/tpt-oracle) — These sqlplus scripts are for Oracle Database performance optimization & troubleshooting.
Monitoring/Statistics/Perfomance
--------------------------------
* [ASH Viewer](https://github.com/akardapolov/ASH-Viewer) — Provides a graphical view of active session history data within the Oracle and PostgreSQL DB.
* [Monyog](https://www.webyog.com/product/monyog) — Agentless & Cost-effective MySQL Monitoring Tool.
* [mssql-monitoring](https://github.com/microsoft/mssql-monitoring) — Monitor your SQL Server on Linux performance using collectd, InfluxDB and Grafana.
* [Navicat Monitor](https://www.navicat.com/en/products/navicat-monitor) — A safe, simple and agentless remote server monitoring tool that is packed with powerful features to make your monitoring effective as possible.
* [Percona Monitoring and Management](https://github.com/percona/pmm) — Open source platform for managing and monitoring MySQL and MongoDB performance.
* [pganalyze collector](https://github.com/pganalyze/collector) — Pganalyze statistics collector for gathering PostgreSQL metrics and log data.
* [postgres-checkup](https://gitlab.com/postgres-ai/postgres-checkup) — New-generation diagnostics tool that allows users to do a deep analysis of the health of Postgres databases.
* [postgres\_exporter](https://github.com/wrouesnel/postgres_exporter) — Prometheus exporter for PostgreSQL server metrics.
* [pgDash](https://pgdash.io) — Measure and track every aspect of your PostgreSQL databases.
* [PgHero](https://github.com/ankane/pghero) — A performance dashboard for Postgres — health checks, suggested indexes, and more.
* [pgmetrics](https://github.com/rapidloop/pgmetrics) — Collect and display information and stats from a running PostgreSQL server.
* [pgMustard](https://www.pgmustard.com) — A user interface for Postgres explain plans, plus tips to improve performance.
* [pgstats](https://github.com/gleu/pgstats) — Collects PostgreSQL statistics, and either saves them in CSV files or print them on the stdout.
* [pgwatch2](https://github.com/cybertec-postgresql/pgwatch2) — Flexible self-contained PostgreSQL metrics monitoring/dashboarding solution.
* [Telegraf PostgreSQL plugin](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/postgresql) — Provides metrics for your postgres database.
### Zabbix
* [Mamonsu](https://github.com/postgrespro/mamonsu) — Monitoring agent for PostgreSQL.
* [Orabbix](http://www.smartmarmot.com/wiki/index.php?title=Orabbix) — Orabbix is a plugin designed to work with Zabbix Enterprise Monitor to provide multi-tiered monitoring, performance and availability reporting and measurement for Oracle Databases, along with server performance metrics.
* [pg\_monz](https://github.com/pg-monz/pg_monz) — This is the Zabbix monitoring template for PostgreSQL Database.
* [Pyora](https://github.com/bicofino/Pyora) — Python script to monitor Oracle Databases.
* [ZabbixDBA](https://github.com/anetrusov/ZabbixDBA) — ZabbixDBA is fast, flexible, and continuously developing plugin to monitor your RDBMS.
Testing
-------
* [DbFit](https://github.com/dbfit/dbfit) — A database testing framework that supports easy test-driven development of your database code.
* [RegreSQL](https://github.com/dimitri/regresql) — Regression Testing your SQL queries.
### Data generator
* [Databene Benerator](https://sourceforge.net/projects/benerator) — It is a framework for generating realistic and valid high-volume test data for your system under test (avoiding the Datalite anti-pattern).
* [dbForge Data Generator for MySQL](https://www.devart.com/dbforge/mysql/data-generator) — Powerful GUI tool for creating massive volumes of realistic test data.
* [dbForge Data Generator for Oracle](https://www.devart.com/dbforge/oracle/data-generator) — Small but mighty GUI tool for populating Oracle schemas with tons of realistic test data.
* [dbForge Data Generator for SQL Server](https://www.devart.com/dbforge/sql/data-generator) — Powerful GUI tool for a fast generation of meaningful test data for databases.
Administration
--------------
* [pgbadger](https://github.com/dalibo/pgbadger) — A fast PostgreSQL Log Analyzer.
* [pgbedrock](https://github.com/Squarespace/pgbedrock) — Manage a Postgres cluster's roles, role memberships, schema ownership, and privileges.
* [pgslice](https://github.com/ankane/pgslice) — Postgres partitioning as easy as pie.
HA/Failover/Sharding
--------------------
* [Citus](https://github.com/citusdata/citus) — Postgres extension that distributes your data and your queries across multiple nodes.
* [patroni](https://github.com/zalando/patroni) — A template for PostgreSQL High Availability with ZooKeeper, etcd, or Consul.
* [Percona XtraDB Cluster](https://github.com/percona/percona-xtradb-cluster) — A High Scalability Solution for MySQL Clustering and High Availability.
* [stolon](https://github.com/sorintlab/stolon) — Cloud native PostgreSQL manager for PostgreSQL high availability.
* [pg\_auto\_failover](https://github.com/citusdata/pg_auto_failover) — Postgres extension and service for automated failover and high-availability.
* [pglookout](https://github.com/aiven/pglookout) — PostgreSQL replication monitoring and failover daemon.
* [PostgreSQL Automatic Failover](https://github.com/ClusterLabs/PAF) — High-Availibility for Postgres, based on industry references Pacemaker and Corosync.
* [postgresql\_cluster](https://github.com/vitabaks/postgresql_cluster) — PostgreSQL High-Availability Cluster (based on "Patroni" and "DCS(etcd)"). Automating deployment with Ansible.
* [Vitess](https://github.com/vitessio/vitess) — Database clustering system for horizontal scaling of MySQL through generalized sharding.
Kubernetes
----------
* [KubeDB](https://kubedb.com) — Making running production-grade databases easy on Kubernetes.
* [Postgres operator](https://github.com/zalando/postgres-operator) — The Postgres Operator enables highly-available PostgreSQL clusters on Kubernetes (K8s) powered by Patroni.
* [Spilo](https://github.com/zalando/spilo) — HA PostgreSQL Clusters with Docker.
* [StackGres](https://gitlab.com/ongresinc/stackgres) — Enterprise-grade, Full Stack PostgreSQL on Kubernetes.
Configuration Tuning
--------------------
* [MySQLTuner-perl](https://github.com/major/MySQLTuner-perl) — Script written in Perl that allows you to review a MySQL installation quickly and make adjustments to increase performance and stability.
* [PGConfigurator](https://pgconfigurator.cybertec-postgresql.com) — Free online tool to generate an optimized `postgresql.conf`.
* [pgtune](https://github.com/gregs1104/pgtune) — PostgreSQL configuration wizard.
* [postgresqltuner.pl](https://github.com/jfcoz/postgresqltuner) — Simple script to analyse your PostgreSQL database configuration, and give tuning advice.
DevOps
------
* [DBmaestro](https://www.dbmaestro.com) — DBmaestro accelerates release cycles & supports agility across the entire IT ecosystem.
* [Toad DevOps Toolkit](https://www.quest.com/products/toad-devops-toolkit/) — Toad DevOps Toolkit executes key database development functions within your DevOps workflow —without compromising quality, performance or reliability.
Schema samples
--------------
* [Oracle Database Sample Schemas](https://github.com/oracle/db-sample-schemas) — Oracle Database Sample Schemas.
Reporting
---------
* [Poli](https://github.com/shzlw/poli) — An easy-to-use SQL reporting application built for SQL lovers.
Distributions
-------------
* [DBdeployer](https://github.com/datacharmer/dbdeployer) — Tool that deploys MySQL database servers easily.
* [dbatools](https://github.com/sqlcollaborative/dbatools) — PowerShell module that you may think of like a command-line SQL Server Management Studio.
* [Postgres.app](https://github.com/PostgresApp/PostgresApp) — Full-featured PostgreSQL installation packaged as a standard Mac app.
* [BigSQL](https://www.bigsql.org) — A developer-friendly distribution of Postgres.
* [Elephant Shed](https://github.com/credativ/elephant-shed) — Web-based PostgreSQL management front-end that bundles several utilities and applications for use with PostgreSQL.
Security
--------
* [Acra](https://github.com/cossacklabs/acra) — Database security suite. Database proxy with field-level encryption, search through encrypted data, SQL injections prevention, intrusion detection, honeypots. Supports client-side and proxy-side ("transparent") encryption. SQL, NoSQL.
Code formatters
---------------
* [CodeBuff](https://github.com/antlr/codebuff) — Language-agnostic pretty-printing through machine learning.
Contributing
------------
* Your contributions are always welcome! Please read the [contribution guidelines](http://contributing.md) first.
Есть находки для БД — делитесь. Также буду рад получить обратную связь — PR'ы и звездочки. Остались вопросы по созданию своих листов — тоже пишите. | https://habr.com/ru/post/496594/ | null | ru | null |
# Разработка собственного ядра для встраивания в процессорную систему на базе ПЛИС
Итак, в [первой статье цикла](https://habr.com/ru/post/452656/) говорилось, что для управления нашим оборудованием, реализованным средствами ПЛИС, для комплекса Redd лучше всего использовать процессорную систему, после чего на протяжении первой и второй статей показывалось, как эту систему сделать. Хорошо, она сделана, мы даже можем выбирать какие-то готовые ядра из списка, чтобы включить их в неё, но конечная цель — именно управлять нашими собственными нестандартными ядрами. Пришла пора рассмотреть, как включить в процессорную систему произвольное ядро.
Все статьи цикла:
[Разработка простейшей «прошивки» для ПЛИС, установленной в Redd, и отладка на примере теста памяти](https://habr.com/ru/post/452656/)
[Разработка простейшей «прошивки» для ПЛИС, установленной в Redd. Часть 2. Программный код](https://habr.com/ru/post/453682/)
Для понимания сегодняшней теории, следует найти и скачать документ **Avalon Interface Specifications**, так как базовой шиной для системы NIOS II является именно шина Avalon. Я буду ссылаться на разделы, таблицы и рисунки для редакции документа от 26 сентября 2018 года.
Открываем раздел 3, посвящённый Memory Mapped Interfaces, а точнее — 3.2. В таблице 9 приведён перечень сигналов шины. Обратите внимание, что все эти сигналы опциональные. Я не нашёл ни одного сигнала, у которого в графе Required стояло бы «Yes». Мы вполне можем не пробрасывать тот или иной сигнал в наше устройство. Поэтому в самом простом случае шина получается чрезвычайно простой в реализации. Начало таблицы выглядит так:
Как видим, все сигналы очень хорошо описаны (разве что, сделано это по-английски). Ниже идут временные диаграммы для различных случаев. Самый-самый-самый простой случай не вызывает никаких вопросов. Я сейчас возьму временную диаграмму из документа и прикрою некоторые линии полупрозрачной заливкой (они же все опциональны, мы имеем право исключать любую из рассмотрения).
Страшно? Но всё просто: нам ставят адрес и строб **read**, мы должны выставить данные на шину readdata. И наоборот: нам ставят адрес, данные на шине writedata и строб write, а мы должны защёлкнуть данные. Совершенно не страшно, шина типовая синхронная.
Прикрытые линии **byteenable** нужны для случая, когда обращение к памяти идёт не 32-битными словами. Это чрезвычайно важно, когда мы проектируем универсальные ядра. Но когда мы проектируем ядро-однодневку, то просто пропишем в документе об этом ядре (я противник отметки в голове, но кто-то может ограничиться и этим), что обращаться нужно 32-битными словами и всё. Ну, а сигнал **response**, он совсем особый, и он нас не интересует в принципе.
Иногда важно, чтобы при неготовности аппаратуры, можно было задержать работу шины на несколько тактов. В этом случае, следует добавить сигнал **WaitRequest**. Временная диаграмма изменится следующим образом:
Пока **WaitRequest** взведён, мастер знает, что наше устройство занято. Будьте осторожны, если этот сигнал не будет сброшен, вся система «зависнет» при обращении, так что только перезагрузка ПЛИС сможет сбросить её. JTAG зависнет вместе с системой. Последний раз я наблюдал это явление при подготовке данной статьи, так что воспоминания ещё яркие.
Дальше в фирменном документе рассматриваются более производительные случаи конвейеризации данных и пакетных транзакций, но задача статьи — не рассмотреть все возможные варианты, а показать читателю путь для работы, подчеркнув, что всё это совсем не страшно, поэтому ограничимся этими двумя простыми вариантами.
Давайте спроектируем какое-то простейшее устройство, которое будет периодически становиться недоступным по шине. Первое, что приходит в голову — последовательный интерфейс. Пока идёт передача, будем заставлять систему ждать. Причём в жизни я так делать категорически не советую: процессор будет останавливаться до конца занятой транзакции, но для статьи это идеальный случай, так как реализующий код будет понятным и не очень громоздким. В общем, сделаем последовательный передатчик, который сможет посылать данные и сигналы выбора кристалла на два устройства.
Начнём с самого простейшего варианта шины. Сделаем параллельный порт вывода, формирующий сигналы выбора кристаллов.
Для этого я возьму проект, получившийся в прошлой статье, но во избежание путаницы, положу его в каталог AVALON\_DEMO. Имена прочих файлов изменять не буду. В этом каталоге создаём каталог **my\_cores**. Имя каталога может быть любым. В нём будем складировать свои ядра. Правда, сегодня оно будет одно. Создаём там файл **CrazySerial.sv** со следующим содержимым:
```
module CrazySerial
(
input clk,
input reset,
input [1:0] address,
input write,
input [31:0] writedata,
output reg [1:0] cs
);
always @(posedge clk, posedge reset)
begin
if (reset == 1)
begin
cs <= 0;
end else
begin
if (write)
case (address)
2'h00: cs <= writedata [1:0];
default:;
endcase
end
end
endmodule
```
Давайте разбираться. В первую очередь, интерфейсные линии. **clk** и **reset** — это линии тактирования и сброса. Имена линий **address**, **write** и **writedata** взяты из таблицы с перечнем сигналов **Memory Mapped Interfaces** документа.
На самом деле, имена я мог дать любые. Связывание логических линий с физическими будет производиться позже. Но если дать имена, как в таблице, среда разработки свяжет их сама. Поэтому лучше брать имена именно из таблицы.
Ну, а **cs** — это линии выбора кристалла, которые будут выходить из микросхемы.
Сама реализация тривиальна. При сбросе выходы зануляются. А так — на каждом такте проверяем, нет ли сигнала **write**. Если есть и адрес равен нулю, то защёлкиваем данные. Можно, конечно, было бы здесь добавить дешифратор, который предотвратит выбор двух устройств сразу, но что хорошо в жизни, то перегрузит статью. В статье приводятся только самые необходимые шаги, однако, отмечается, что в жизни всё можно сделать и посложнее.
Прекрасно. Мы готовы внедрять этот код в процессорную систему. Идём в **Platform Designer**, выбираем в качестве входного файла систему, построенную нами при прошлых опытах:
Обращаем внимание на пункт **New Component** в левом верхнем углу:
Чтобы добавить свой компонент, надо щёлкнуть по этому пункту. В открывшемся диалоге заполняем поля. А для статьи заполним только имя компонента:
Теперь переходим на вкладку **Files** и нажимаем **Add File**:
Добавляем ранее созданный файл, выбираем его в списке и нажимаем **Analyze Synthesis File**:
Ошибок при разборе **SystemVerilog** нет, но есть несколько концептуальных ошибок. Они вызваны тем, что некоторые линии были неверно связаны средой разработки. Идём на вкладку **Signals & Interfaces** и обращаем внимание сюда:
Линии **cs** были неверно отнесены к интерфейсу **avalon\_slave0**, сигналу **readdata**. Но зато все остальные линии были распознаны верно, благодаря тому, что мы дали им имена из таблицы документа. Но что делать с проблемными линиями? Их надо отнести к интерфейсу типа **conduit**. Для этого щёлкаем по пункту «add interface»
В выпавшем меню выбираем **conduit**:
Получаем новый интерфейс:
При желании, его можно переименовать. Правда, это будет непременно нужно, если мы хотим сделать несколько внешних интерфейсов. В рамках статьи оставим ему имя **conduit\_end**. Теперь цепляем «мышкой» линию **cs** и тянем её в этот интерфейс. Надо умудриться бросить сигнал под строку **conduit\_end**, тогда нам это позволят это сделать. В других местах будет отображаться курсор в виде перечёркнутого круга. В конце концов, у нас должно получиться так:
Заменим тип сигнала с **readdata** на, скажем, **chipselect**. Итоговая картинка:
Но ошибки остались. Шине **avalon** не назначен сигнал сброса. Выбираем в списке **avalon\_slave\_0** и смотрим его свойства.
Заменяем **none** на **reset**. Заодно осмотрим прочие свойства интерфейса.
Видно, что адресация идёт словами. Ну, и ряд других вещей из документации настраивается именно здесь. Какие при этом получаются временные диаграммы, будет нарисовано в самом низу свойств:
Собственно, ошибок больше нет. Можно нажимать **Finish**. Наш созданный модуль появился в дереве устройств:
Добавляем его в процессорную систему, подключаем тактовые сигналы и сброс. Подключаем шину данных к **Data Master** процессора. Дважды щёлкаем по **Conduit\_end** и даём внешнему сигналу имя, скажем, **lines**. Получается как-то так:
Здесь важно не забыть, что раз мы добавили в систему блок, то надо сделать так, чтобы он не конфликтовал ни с кем в адресном пространстве. В данном конкретном случае на рисунке конфликтов нет, но всё равно я выберу пункт меню **System->Assign Base Addresses**.
Всё. Блок создан, настроен, добавлен в систему. Нажимаем кнопку **Generate HDL**, затем — **Finish**.
Делаем черновую сборку проекта, после чего идём в **Pin Planner** и назначаем ножки. У меня получилось так:
Что соответствует контактам B22 и C22 интерфейсного разъёма.
Делаем чистовую сборку, загружаем процессорную систему в ПЛИС. Теперь нам надо доработать программный код. Запускаем Eclipse.
Напомню, я сейчас работаю с проектом, который расположен в другом каталоге относительно моей прошлой работы с Redd. Чтобы не путаться, я удалю старые проекты из дерева (но только из дерева, не стирая сами файлы).
Далее нажму на пустом дереве правую кнопку «мыши» и выберу в меню **Import**:
Далее — **General->Existing Project into Workspace**:
И просто выберу каталог, в котором хранятся файлы проектов:
Оба проекта, унаследованные от прошлых экспериментов, подключатся к среде разработки.
Следующий пункт я выделю в рамку:
> Каждый раз после изменения аппаратной конфигурации следует заново выбирать пункт меню **Nios II ->Generate BSP** для проекта BSP.
Собственно, после этой операции, в файле **\AVALON\_DEMO\software\SDRAMtest\_bsp\system.h** появился новый блок:
```
/*
* CrazySerial_0 configuration
*
*/
#define ALT_MODULE_CLASS_CrazySerial_0 CrazySerial
#define CRAZYSERIAL_0_BASE 0x4011020
#define CRAZYSERIAL_0_IRQ -1
#define CRAZYSERIAL_0_IRQ_INTERRUPT_CONTROLLER_ID -1
#define CRAZYSERIAL_0_NAME "/dev/CrazySerial_0"
#define CRAZYSERIAL_0_SPAN 16
#define CRAZYSERIAL_0_TYPE "CrazySerial"
```
Нас, в первую очередь, интересует константа **CRAZYSERIAL\_0\_BASE**.
Добавим в функцию **main()** код следующего вида:
```
while (true)
{
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x00);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x01);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x02);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x03);
}
```
Запускаем отладку и смотрим содержимое линий осциллографом. Должен быть инкрементирующийся двоичный код. Он там имеется.
Причём частота доступа к портам просто замечательная:
Примерно 25 МГц — половина частоты шины (2 такта на цикл). Иногда время доступа не 2 такта, а больше. Это связано с исполнением операций ветвления в программе. В общем, простейшее обращение к шине работает.
Пришла пора добавить к примеру функциональность последовательного порта. Для этого добавим интерфейсный сигнал **waitrequest**, относящийся к шине и пару сигналов последовательного порта — **sck** и **sdo**. Итого, получаем следующий фрагмент кода на **systemverilog**:
**То же самое текстом:**
```
module CrazySerial
(
input clk,
input reset,
input [1:0] address,
input write,
input [31:0] writedata,
output waitrequest,
output reg [1:0] cs,
output reg sck,
output sdo
);
```
По правилам хорошего тона надо сделать несложный автомат, который будет осуществлять передачу данных. К сожалению, самый несложный автомат в рамках статьи будет выглядеть очень сложно. Но на самом деле, если я не буду наращивать функционал автомата (а в рамках статьи я не собираюсь этого делать), то состояний у него будет всего два: идёт передача и не идёт передача. Поэтому я могу состояние закодировать одним сигналом:
reg sending = 0;
Во время передачи мне понадобится счётчик битов, делитель тактовой частоты (я же делаю заведомо медленное устройство) и регистр сдвига для передаваемых данных. Добавляем соответствующие регистры:
```
reg [2:0] bit_cnt = 0;
reg [3:0] clk_div = 0;
reg [7:0] shifter = 0;
```
Частоту я буду делить на 10 (руководствуясь принципом «а почему бы и нет?»). Соответственно, на пятом такте я буду взводить SCK, а на десятом — ронять эту линию, после чего — выполнять переход к следующему биту данных. На всех остальных тактах — просто увеличивать счётчик делителя. Важно не забывать, что на четвёртом такте также надо увеличивать счётчик, а на девятом — занулять его. Если опустить процесс перехода к следующему биту, то указанная логика выглядит так:
```
if (sending)
begin
case (clk_div)
4: begin
sck <= 1;
clk_div <= clk_div + 1;
end
9: begin
sck <= 0;
clk_div <= 0;
// <переход к следующему биту>
end
default: clk_div <= clk_div + 1;
endcase
end else
```
Переход к следующему биту прост. Сдвинули регистр сдвига, затем, если текущий бит седьмой, прекратили работу, переключив состояние автомата, иначе — увеличили счётчик битов.
```
shifter <= {shifter[6:0],1'b0};
if (bit_cnt == 7)
begin
sending <= 0;
end else
begin
bit_cnt <= bit_cnt + 1;
end
```
Собственно, всё. Выходной бит всегда берём из старшего бита регистра сдвига:
```
assign sdo = shifter [7];
```
И самая главная строка для текущей доработки. Сигнал **waitrequest** взводим в единицу всегда, когда идёт передача последовательных данных. То есть, он является копией сигнала **sending**, задающего состояние автомата:
```
assign waitrequest = sending;
```
Ну, и при записи в адрес 1 (напоминаю, здесь адресация у нас в 32-битных словах), мы защёлкиваем данные в регистр сдвига, зануляем счётчики и запускаем процесс передачи:
```
if (write)
//...
2'h01: begin
bit_cnt <= 0;
clk_div <= 0;
sending <= 1;
shifter <= writedata [7:0];
end
default:;
endcase
end
```
**Теперь приведу все описанные фрагменты в виде единого текста:**
```
module CrazySerial
(
input clk,
input reset,
input [1:0] address,
input write,
input [31:0] writedata,
output waitrequest,
output reg [1:0] cs,
output reg sck,
output sdo
);
reg sending = 0;
reg [2:0] bit_cnt = 0;
reg [3:0] clk_div = 0;
reg [7:0] shifter = 0;
always @(posedge clk, posedge reset)
begin
if (reset == 1)
begin
cs <= 0;
sck <= 0;
sending <= 0;
end else
begin
if (sending)
begin
case (clk_div)
4: begin
sck <= 1;
clk_div <= clk_div + 1;
end
9: begin
clk_div <= 0;
shifter <= {shifter[6:0],1'b0};
sck <= 0;
if (bit_cnt == 7)
begin
sending <= 0;
end else
begin
bit_cnt <= bit_cnt + 1;
end
end
default: clk_div <= clk_div + 1;
endcase
end else
if (write)
case (address)
2'h00: cs <= writedata [1:0];
2'h01: begin
bit_cnt <= 0;
clk_div <= 0;
sending <= 1;
shifter <= writedata [7:0];
end
default:;
endcase
end
end
assign sdo = shifter [7];
assign waitrequest = sending;
endmodule
```
Начинаем внедрять новый код в систему. Собственно, путь такой же, как при создании компонента, но часть шагов уже можно опустить. Сейчас мы как раз познакомимся с процессом доработки. Идём в **Platform Designer**. Если бы у нас поменялся только verilog код, было бы достаточно просто выполнить операцию **Generate HDL** для готовой системы. Но так как у модуля появились новые линии (то есть, изменился интерфейс), его надо переделать. Для этого выбираем его в дереве, нажимаем правую кнопку «мыши» и выбираем **Edit**.
Мы редактируем уже готовую систему. Поэтому просто идём на вкладку **Files** и нажимаем **Analyze Sinthesis Files**:
Предсказуемо возникли ошибки. Но мы уже знаем, что виной всему неверно трактованные линии. Поэтому идём на вкладку **Signals & Interfaces**, перетаскиваем по одной линии **sck** и **sdo** из интерфейса **avalon\_slave\_0** в интерфейс **conduit\_end**:
Также переименовываем для них поля **Signal Type**. Результат должен быть следующий:
Собственно, всё. Нажимаем **Finish**, вызываем **Generate HDL File** для процессорной системы, делаем черновую сборку проекта в Quartus, делаем назначение новых ножек:
Это контакты A21 и A22 интерфейсного разъёма, делаем чистовую сборку, заливаем «прошивку» в ПЛИС.
Железо обновлено. Теперь — программа. Идём в Eclipse. Что там не забываем сделать? Правильно, не забываем выбрать **Generate BSP**.
Собственно, всё. Осталось добавить функциональность в программу. Сделаем передачу пары байтов в последовательный порт, но первый байт отправим в устройство, выбранное линией **cs[0]**, а второй — **cs[1]**.
```
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x01);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE+4,0x12);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x02);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE+4,0x34);
IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x00);
```
Обратите внимание, что никаких проверок готовности там нет. Посылки идут одна за другой. Тем не менее, на осциллографе всё получилось вполне последовательно
Жёлтый луч — **cs[0]**, зелёный — **sdo**, фиолетовый — **sck**, голубой — **cs[1]**. Видно, что в первое устройство ушёл код 0x12, во второе — 0x34.
Чтение делается аналогично, но мне просто не придумать какого-либо красивого примера, кроме банального чтения содержимого ножки разъёма. Но тот пример настолько вырожденный, что его даже не интересно делать. Но здесь стоит отметить, что при чтении чрезвычайно важной может быть вот эта настройка шины:
Если имеется линия **Read**, то на диалоге настройки появится и временная диаграмма чтения. И на ней будет видно влияние данного параметра. При чтении ножки разъёма, это всё равно будет не заметно, а вот при чтении из того же FIFO или ОЗУ – вполне. ОЗУ может быть настроено на выдачу данных сразу после подачи адреса, а может на синхронную выдачу. Во втором случае, добавляется латентность. Ведь шина выставила адрес, выставила строб… Но по ближайшему фронту тактового сигнала данных ещё нет. Они появятся уже после этого фронта… То есть, у системы имеется латентность в один такт. И её как раз надо учесть, задав именно этот параметр. Короче, если читается не то, что ожидалось, в первую очередь проверяйте, не надо ли настроить латентность. В остальном — чтение ничем не отличается от записи.
Ну, и ещё раз напомню, что готовность шины на время длительных операций лучше не снимать, иначе вполне можно резко снизить производительность системы. Сигнал готовности хорош, чтобы придержать выполнение транзакции на пару-тройку тактов, а не вплоть до 80 тактов, как у меня в примере. Но во-первых, любой другой пример был бы неудобен для статьи, а во-вторых, для ядер-однодневок, это вполне допустимо. Вы вполне будете отдавать себе отчёт в своих действиях и будете избегать ситуаций, когда шина блокируется. Правда, если ядро переживёт отпущенное ему время, такое допущение может испортить жизнь в будущем, когда о нём все забудут, а оно всё затормозит. Но это будет потом.
Тем не менее, мы научились делать так, чтобы процессорное ядро управляло нашими ядрами. С адресуемым миром всё ясно, теперь пришла пора разобраться с миром потоковым. Но это мы сделаем уже в следующей статье, а возможно — даже нескольких статьях.
### Заключение
В статье показано, как произвольное ядро на языке Verilog может быть подключено на управление средствами процессорной системы Nios II. Показаны варианты простейшего подключения к шине Avalon, а также подключения, при котором шина может находиться в занятом состоянии. Даны ссылки на литературу, из которой можно узнать прочие режимы работы шины Avalon в режиме Memory Mapped.
Получившийся в результате проект можно скачать [здесь](https://yadi.sk/d/PxT_VU_F6mtP_w). | https://habr.com/ru/post/454938/ | null | ru | null |
# Изучаем ResponseEntity<?> и избавляемся от него в контроллерах Spring
Всем привет! Проверяя задания в учебном центре моей компании, обнаружил, что двумя словами описать то, как можно избавиться от ResponseEntity в контроллерах не получится, и необходимо написать целую статью. Для начала, немного введения.
*ВАЖНО! Статья написана для новичков в программировании и Spring в часности, которые знакомы со Spring на базовом уровне.*
Что такое ResponseEntity<>? Представим ситуацию - у нас есть интернет магазин. И, при примитивной реализации, мы переходим по продуктам, передавая его Id в качестве параметра[@RequestParam.](/users/requestparam.) Например, наш код выглядит таким образом:
```
@ResponseBody
@GetMapping("/products")
public Product getProduct(@RequestParam Long id){
return productsService.findById(id);
}
```
При запросе через адресную строку браузера, вывод будет в виде JSON, таким:
```
{"id":1,"title":"Milk","price":100}
```
Однако, если мы обратимся к продукту, который у нас отсутствует, например с id=299, то получим следующую картину:
Для пользователя, или даже для фронтендщика, будет абсолютно непонятно, что пошло не так и в чём проблема. Совершая тот же запрос через Postman, ситуация яснее не будет:
```
{
"timestamp": "2022-06-30T18:21:03.634+00:00",
"status": 500,
"error": "Internal Server Error",
"path": "/app/api/v1/products"
}
```
И вот тут мы переходим к ResponseEntity<>. Этот объект представляет собой оболочку для Java классов, благодаря которой мы в полной мере сможем реализовать RESTfull архитектуру. Суть использования сводится к тому, чтобы вместо прямого возвращаемого типа данных в контроллере, использовать оболочку ResponseEntity<> и возвращать конечному пользователю, или, что скорее всего вероятно - фронту, JSON, который бы более-менее подробно описывал ошибку. Выглядит такой код примерно так:
```
@GetMapping("/products")
public ResponseEntity getProductRe(Long id){
try {
Product product = productsService.findById(id).orElseThrow();
return new ResponseEntity<>(product, HttpStatus.OK);
} catch (Exception e){
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
}
```
Что здесь происходит? Вместо строгого типа Product, мы ставим ResponseEntity , где под **?** понимается любой Java объект. Конструктор ResponseEntity позволяет перегружать этот объект, добавляя в него не только наш возвращаемый тип, но и статус, чтобы фронтенд мог понимать, что именно пошло не так. Например, при корректном исполнении программы, передавая id=1, мы увидим просто успешно переданный объект Product с кодом 200, а вот в случае продукта с id = 299 результат уже будет такой:
Всё ещё не красиво, но уже хотя бы понятно, что продукт не найден. Мы имеем статус код 404 и фронт уже как-то может с этим работать. Это здорово, но нам бы хотелось более конкретного описания ошибки и результата. Давайте, в таком случае, создадим новый класс:
```
public class AppError {
private int statusCode;
private String message;
public int getStatusCode() {
return statusCode;
}
public void setStatusCode(int statusCode) {
this.statusCode = statusCode;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public AppError() {
}
public AppError(int statusCode, String message) {
this.statusCode = statusCode;
this.message = message;
}
}
```
Это будет вспомогательный класс. Его задача - принять наше сообщение и переслать его фронту вместе со статусом 404. Как мы это сделаем? Очень просто:
```
@GetMapping("/products")
public ResponseEntity getProduct(Long id){
try {
Product product = productsService.findById(id).orElseThrow();
return new ResponseEntity<>(product, HttpStatus.OK);
} catch (Exception e){
return new ResponseEntity<>(new AppError(HttpStatus.NOT_FOUND.value(),
"Product with id " + id + " nor found"),
HttpStatus.NOT_FOUND);
}
}
```
В этом примере, если мы ловим ошибку, просто отдаём в конструктор ResponseEntity наш кастомный объект и статус 404. Теперь, если мы попробуем получить продукт с id = 299, то ответ будет таким:
```
{
"statusCode": 404,
"message": "Product with id 299 nor found"
}
```
Отлично! Этого мы и хотели. Стало понятно, в чём проблема. Фронтенд легко распарсит этот JSON и обработает наше сообщение. Однако, сам метод контроллера теперь выглядит не слишком красиво. Да и когда сталкиваешься с чужим кодом, любой из нас сразу хотел бы видеть тип объекта, который будет возвращаться, а не какой-то там ResponseEntity со знаком вопроса в скобочках. Тут мы и переходим к основному материалу статьи.
**Как избавиться от ResponseEntity в сигнатуре метода контроллера, при этом сохранив информативность возвращаемой ошибки?**
Для этого нам понадобиться глобальный обработчик ошибок, который нам любезно предоставляется в пакете со спрингом. Для начала, создадим какой-то свой кастомный Exception, в котором унаследуемся от RuntimeException:
```
public class ResourceNotFoundException extends RuntimeException {
public ResourceNotFoundException(String message) {
super(message);
}
}
```
Здесь ничего особенного. Интересное начинается дальше. Давайте внимательно посмотрим на листинг этого класса:
```
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
@ExceptionHandler
public ResponseEntity catchResourceNotFoundException(ResourceNotFoundException e) {
log.error(e.getMessage(), e);
return new ResponseEntity<>(new AppError(HttpStatus.NOT\_FOUND.value(), e.getMessage()), HttpStatus.NOT\_FOUND);
}
}
```
Начнём сверху вниз. `@ControllerAdvice` используется для глобальной обработки ошибок в приложении Spring. То есть любой Exception, выпадающий в нашем приложении, будет замечен нашим ControllerAdvice. [@Slf4j](/users/slf4j) используется для логгирования, заострять внимание мы на этом не будем. Далее создаём собственный класс, назвать его можем как угодно. И вот тут уже интересное - аннотация[@ExceptionHandler](/users/exceptionhandler)над методом. Эта аннотация позволяет нам указать, что мы хотим перехватывать и обрабатывать исключения определённого типа, если они возникают, и зашивать их в ResponseEntity, чтобы вернуть ответ нашему фронту. В аргументах метода указываем, какую именно ошибку мы собираемся ловить. В данном случае, это наш кастомный ResourceNotFoundException. И возвращать мы будем точно такой же ResponseEntity, как и в примере выше, однако прописываем мы его уже всего 1 раз - в этом классе. Спринг на этапе обработки этой ошибки самостоятельно поймёт, что в методе нашего контроллера вместо нашего класса Product нужно будет вернуть ResponseEntity.
Теперь мы можем убрать из контроллера все ResponseEntity:
```
@GetMapping("/products")
public Product getProduct(Long id){
return productsService.findById(id);
}
```
А логику появления ошибки перенести в сервисный слой:
```
public Product findById(Long id) {
return productsRepository.findById(id).orElseThrow(
() -> new ResourceNotFoundException("Product with id " + id + " not found"));
}
```
Теперь, если продукт не будет найден, выбросится ResourceNotFoundException. Наш глобальный обработчик исключений поймает это исключение, самостоятельно преобразует его в ResponseEntity и вместо Product'a вернут JSON с подробным описанием ошибки, как и прежде:
```
{
"statusCode": 404,
"message": "Product with id 299 not found"
}
```
Таким образом, мы избавились от ResponseEntity и кучи лишнего кода, переписываемого из метода в метод, при этом сохранив всю функциональность, которую нам предоставляет ResponseEntity. | https://habr.com/ru/post/675716/ | null | ru | null |
# Надежный способ сокрытия ссылок сайта от поисковых роботов
В один из рабочих дней мне пришел список заданий. Отдельным пунктом была просьба найти способ надежного сокрытия внешних ссылок на сайте от поисковых систем.
В чем суть проблемы? Существует несколько способов спрятать ссылку от поисковых роботов, но у них имеются свои особенности:
1. javascript позволяет закрыть ссылку от индексации, но сам google уже спокойно понимает такие скрипты;
2. можно добавить к ссылке атрибут nofollow – это просто, но ссылочный вес самой ссылки будет теряться и при периодическом переиндексировании снизится общий вес сайта;
3. cамый странный метод сокрытия ссылок — это закрытие конкретных страниц от индексации при помощи мета тегов или в файле robots.txt, но происходит полная потеря ссылочного веса передаваемого странице.
Зная эти нюансы, специалист по СЕО исключил все три способа сокрытия ссылок и предложил мне попытаться найти новое решение. И оно было найдено: что, если засунуть ссылку в некий стандартный функционал на сайте, который поисковый робот всегда игнорирует?
Возьмем обычную форму с методом отправки post:
```
Образец экспериментальной ссылки
```
При помощи класса my можно стиль формы сделать оптимальным для дизайна вашего сайта, например:
```
.my{
border:none;
background: none;
text-decoration: underline;
color: blue;
cursor: pointer;
color:#00bceb
}
.form{
width: 300px;
margin: 50px auto;
}
```
Как же добавить в форму нужную ссылку? Тут я вспомнил про javascript, теперь наша форма выглядит так:
```
Образец экспериментальной ссылки
```
Как только пользователь кликнет по кнопке формы, замаскированной под ссылку, сработает форма с методом post, команда onclick выполнится и откроется новая вкладка по требуемому адресу. Задача условно решена. Однако, если таких ссылок много на странице, для каждой писать форму?
Воспользуемся PHP. Пусть у нас имеется массив ссылок, например:
```
$mass = [
'Таинственный остров' => 'https://www.litmir.me/bd/?b=265607',
'Три дня Индиго' => 'https://www.litres.ru/sergey-lukyanenko/tri-dnya-indigo/',
'Зеленая Миля' => 'https://librebook.me/the_green_mile',
'Герой должен быть один' => 'https://librebook.me/geroi_doljen_byt_odin',
'Затерянный мир' => 'https://librebook.me/zateriannyi_mir_doil_artur_ignatius_konan',
];
```
Добавим простейшим способом все формы на страницу:
```
foreach($mass as $k => $v) {
echo '
'. $k .'';
}
```
Здесь нужно очень внимательно следить за расстановкой одинарных и двойных кавычек, чтобы не было ошибки.
Для одной страницы задача решена, а если страниц много? Проще всего создать функцию и ее вызывать с нужными параметрами:
```
function s_link(string $name, string $link) {
$res = '
'. $name .'';
return $res;
}
$res = s_link('Yandex','https://ya.ru');
echo $res;
```
Если js в данном примере не нравится, то можно обойтись без него:
```
Таинственный остров
```
Тогда функция будет выглядеть так:
```
function m_link(string $name, string $link) {
$res = '
'.$name.'';
return $res;
}
$res = m_link('Books','https://www.labirint.ru/books/');
echo $res;
```
Если заместо названия ссылки хочется поместить картинку, то html код:
```
```
Теперь посмотрим, как браузер реагирует на простую ссылку: видим появление сообщения в левом нижнем углу с адресом ссылки.
После помещения ссылки в форму, браузер ее уже не замечает.
Есть небольшой недостаток внешнего вида "ссылки" у данного способа: сам тег является блочным, то есть занимает всю строку. Если попытаться вставить подобные элементы в предложение, то все формы уходят на новую строку и текст становится с разрывами. Это явление лучше учитывать: я добавлял в стили "display: contents" и разрывов уже не было.
[Код на гитхабе для ленивых](https://github.com/coderme777/How-to-hide-links-on-a-website)
**Уважаемые читатели!** Какими методами сокрытия ссылок веб-страниц вы пользуетесь? | https://habr.com/ru/post/667016/ | null | ru | null |
# Разворачиваем Kubernetes на десктопе за несколько минут с MicroK8s
Начать работать с Kubernetes не всегда бывает просто. Не у всех есть необходимая для разворачивания полноценного кластера Kubernetes инфраструктура. Для локальной работы Kubernetes предлагет утилиту [Minikube](https://kubernetes.io/docs/setup/minikube/). Minikube — достаточно простое и удобное средство, и есть несколько обучающих курсов по работете с Minikube. Но, все же, о Minikube нельзя сказать, что с помощью этой утилиты можно за несколько минут развернуть среду Kubernetes.
Сегодня я хочу рассказать о пакете [MicroK8s](https://microk8s.io/#quick-start), который без преувеличения позволяет развернуть Kubernetes локально за несколько минут, и начать разработку. Не требуется даже предустановленных Docker и Kubernetes, т.к. все включено. В предлагаемом Вам уроке будет рассмотрен деплой приложения Django в локальной среде Kubernetes.
В качестве источника я шел вслед за серией статей [Mark Gituma](https://medium.com/@markgituma/kubernetes-local-to-production-with-django-2-docker-and-minikube-ba843d858817), в которых описана аналогичная работа, но только с Minikube, а не с MicroK8s.
Все же есть одно требование, которое необходимо удовлетворить до начала работы. У Вас должен быть установлен [Snap](https://docs.snapcraft.io/installing-snapd/6735), что в свою очередь означает, что у Вас должен быть установлен Linux.
Установка MicroK8s описана в [руководстве на сайте](https://microk8s.io/#quick-start). Впрочем, это всего одна строчка:
```
sudo snap install microk8s --classic
```
Далее, возможно, будет необходимо стартовать среду:
```
sudo microk8s.start
```
Далее необходимо активизировать расширения. Полный список расширений можно получить командой `microk8s.enable --help`: dashboard, dns, gpu, ingress, istio, metrics-server, registry, storage. Сразу можно активизировать все, кроме gpu и istio, т.к. первое из них требует предустаноленного драйвера, а второе существенно апгрейдит среду и (лично у меня на слабом десктопе) сильно грузит систему.
```
microk8s.enable dashboard dns ingress metrics-server registry storage
```
Как Вы уже сейчас можете заключить по списку расширений, у Вас будет доступ ко многим сервисам, в том числе к dashboard и метрикам.
Создадим Dockerfile для создания образа:
```
FROM python:3-slim
LABEL maintainer="mark.gituma@gmail.com"
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN django-admin startproject mysite /app
EXPOSE 8000
STOPSIGNAL SIGINT
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]
```
и файл с необходимыми зависимостями requirements.txt:
```
celery==4.1.0
Django==2.0
kombu==4.1.0
```
Соберем образ. Для этого не нужен предустановленный Docker, т.к. он поставляется c MicroK8s:
```
microk8s.docker build django -t apapacy/tut-django:1.0.0
```
Если Вы собираете образ раннее установенным докером, возможно Вам будет недостаточно просто собрать образ, а еще дополнительно отправить в локальный реестр, который также поставляется с MicroK8s, и работет на порту 32000:
```
microk8s.docker tag apapacy/tut-django:1.0.0 localhost:32000/apapacy/tut-django:1.0.0
microk8s.docker push localhost:32000/apapacy/tut-django:1.0.0
```
Скорее всего этот шаг будет не нужен, но для полноты я указал на него, и заодно обратил Ваше внимание, что у Вас есть локальный реестр докера.
Базовым строительным блоком Kubernetes является Pod (Под), в котором работает контенйер (чаще всего один но может быть и несколько). Поды могут создаваться разными средствами. Но нас сегодня интересует Deployment (Деплоймент). Деплоймент описывает шаблон по которому создаются Поды. Деплоймент определяется при помощи файлов конфигрураций в формате yml. В конфигурации Деплоймента Вы указываете количество реплик Пода и образ, из которого этот Под и его реплики будут собираться, а также порт (порт 8000 на котором работет Django из Dockerfile — никакой магии):
```
apiVersion: apps/v1beta2
kind: Deployment
metadata:
name: django
labels:
app: django
spec:
replicas: 2
selector:
matchLabels:
pod: django-container
template:
metadata:
labels:
pod: django-container
spec:
containers:
- name: django-web
image: localhost:32000/apapacy/tut-django:1.0.0
ports:
- containerPort: 8000
```
Депоймент загружается в среду командой:
```
microk8s.kubectl apply -f config/deployment.yml
```
Параллельно Вы можете запустить команду, которая будет мониторить происходящие при деплойменте действия:
```
watch microk8s.kubectl get all
```
Теперь у Вас есть несколько Подов с приложениями Django, к которым нет доступа. Для того, чтобы Поды могли общаться между собой и с внешним миром, существует еще одна абстракция — это Сервис. Сервис, как и Деплоймент, определяется файлом конфигурации:
```
kind: Service
apiVersion: v1
metadata:
name: django-service
spec:
selector:
pod: django-container
ports:
- protocol: TCP
port: 8000
# targetPort: 8001
type: ClusterIP
# type: NodePort
```
Селектор `pod: django-container` определяет, какой именно Деплоймент будет обслуживаться Сервисом (имя селектора «pod» не является предопределенным — это всего лишь метка котороая должна совпасть). Загружается сервис аналогично Деплойменту:
```
microk8s.kubectl apply -f config/service.yml
```
После загрузки, к Сервису можно обращаться по внутреннему сетевому адресу. Если выполнить команду `microk8s.kubectl get all`, то можно увидеть этот адрес:
```
service/django-service ClusterIP 10.152.183.156 none 8000/TCP 3h33m
```
Выполнив команду curl (или открыв браузер) мы получим приветсвенную страничку Django:
```
curl 10.152.183.156:8000
```
В конфигурации Сервиса есть две закомментированные строчки. Если их раскомментировать, то сервис дополнительно будет доступен из внешней сети по случайному порту в диапазоне от 32000 и выше.
Для того чтобы получить постоянный адрес для Сервиса, по котрому можно будет обращаться из вешней сети, в MicroK8s предлагается на выбор два варианта 1) ingress и 2) istio. Проще всего реализовать при помощи ingress. Если еще не активизирован, то нужно активизировать компнент ingress:
```
microk8s.enable ingress
```
После этого можно убедиться, что данный компонент установлен и работает, выполнив команду `microk8s.kubectl get all`. В списке приложений и сервисов должно появиться несколько записей с именем `default-http-backend`. В частности, должен появиться сервис, работающий на порту 80:
```
service/default-http-backend ClusterIP 10.152.183.42 none 80/TCP 179m
```
Имя default-http-backend — предопределенное имя в MicroK8s. Именно по этому имени необходимо ссылаться на этот сервис в конфигурациях ingress.
Конфигруации ingress напоимнают конфигруации веб-сервера или прокси-сервера, и где-то там внутри системы, ими и являются. Поэтому в них присутсвуют хосты, пути и порты — все атрибуты, которые хорошо знакомы:
```
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: tut-django
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
backend:
serviceName: default-http-backend
servicePort: 80
rules:
- host: localhost
http:
paths:
- path: /django
backend:
serviceName: django-service
servicePort: 8000
```
Загружается конфигруация ingress командой:
```
microk8s.kubectl apply -f config/ingress.yml
```
После чего, приветственная страница Django будет доступна по адресу [localhost/django](http://localhost/django)
На этом на сегодня все.
Полезные ссылки:
1. [github.com/apapacy/microk8s-tut](https://github.com/apapacy/microk8s-tut)
2. [medium.com/@markgituma/kubernetes-local-to-production-with-django-2-docker-and-minikube-ba843d858817](https://medium.com/@markgituma/kubernetes-local-to-production-with-django-2-docker-and-minikube-ba843d858817)
3. [k3s.io](https://k3s.io)
apapacy@gmail.com
10 февраля 2019 года | https://habr.com/ru/post/439734/ | null | ru | null |
# Храним сессии на клиенте, чтобы упростить масштабирование приложения (3-я из 12 статей о Node.js от команды Mozilla Identity)
***От переводчика:** Это третья статья из [цикла о Node.js](https://hacks.mozilla.org/category/a-node-js-holiday-season/) от команды Mozilla Identity, которая занимается проектом [Persona](http://ru.wikipedia.org/wiki/Mozilla_Persona). Эта статья посвящена применяемому в Persona способу хранения данных сессии на клиенте.
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)"*
---
Статические веб-сайты хорошо масштабируются. Их легко кэшировать, и не нужно постоянно синхронизировать данные на нескольких серверах.
К сожалению, большинство веб-приложений должны хранить информацию о состоянии, чтобы предлагать пользователям персонализированные страницы. Если пользователи могут регистрироваться на сайте, то нам надо хранить сессии. Самый распространенный способ — установить cookie со случайным идентификатором сессии, а детали хранить на сервере.
#### Масштабирование сайта с хранением состояния
Если необходимо масштабировать такой сайт, есть три варианта:
1. Реплицировать данные сессии между всеми серверами.
2. Использовать центральное хранилище, к которому будут обращаться все серверы.
3. Закрепить за каждым пользователем определённый сервер.
У всех этих подходов есть недостатки:
1. Репликация ухудшает производительность и увеличивает сложность.
2. Центральное хранилище ограничивает возможность масштабирования и приводит к дополнительным задержкам.
3. Привязка пользователей к конкретным серверам приводит к проблемам, когда сервер отключается.
Тем не менее, поразмыслив немного, можно придумать и четвёртый способ: хранить все данные сессии на клиенте.
#### Хранение сессий на клиенте
У хранения данных сессии в браузере есть несколько очевидных преимуществ:
1. Данные доступны всегда, независимо от того, какой сервер обслуживает клиента.
2. Не надо хранить состояние на сервере.
3. Не надо синхронизировать информацию о состоянии между серверами.
4. Можно очень легко добавлять новые серверы.
Но есть одна большая проблема: данным, хранящимся у клиента, нельзя доверять. К примеру, если вы храните в cookie ID пользователя, то он может подменить его и получить доступ к чужой учётной записи.
Хоть эта проблема и кажется непреодолимой, у неё есть решение: хранить данные в защищённом контейнере. Таким образом, больше нет необходимости доверять клиенту — у него нет возможности незаметно их подменить.
На практике это означает, что данные в cookie надо зашифровать и подписать ключом, хранящимся на сервере. Именно этим занимается модуль client-sessions.
#### node-client-sessions
Библиотека [node-client-sessions](https://github.com/mozilla/node-client-sessions) для Node.js заменяет стандартные middleware-модули фреймворка Connect [session](http://www.senchalabs.org/connect/session.html) и [cookie-parser](http://www.senchalabs.org/connect/cookieParser.html). Вот как включить её в простое приложение для Express:
```
const clientSessions = require("client-sessions");
app.use(clientSessions({
secret: '0GBlJZ9EKBt2Zbi2flRPvztczCewBxXK' // set this to a long random string!
}));
```
Затем можно устанавливать значения свойств объекта `req.session`:
```
app.get('/login', function (req, res){
req.session.username = 'JohnDoe';
});
```
и считывать их:
```
app.get('/', function (req, res){
res.send('Welcome ' + req.session.username);
});
```
Для закрытия сессии служит метод `reset()`:
```
app.get('/logout', function (req, res) {
req.session.reset();
});
```
#### Мгновенное закрытие сессий Persona
Один из главных недостатков хранения сессий на клиенте состоит в том, что сервер больше не может закрывать сессии самостоятельно.
При хранении данных сессии на сервере достаточно просто удалить данные сессии из БД, после чего все cookie на всех клиентах буду указывать на несуществующую запись. Когда данные хранятся на клиенте, сервер не может быть уверен, что данные были удалены во всех браузерах. Другими словам, не так то просто синхронизировать новое состояние сервера (пользователь завершил сессию) с состоянием на клиенте (сессия открыта).
Чтобы немного снизить остроту проблемы, client-sessions хранит в cookie время жизни сессии. Прежде чем распаковывать данные из зашифрованного контейнера, сервер проверит, не просрочены ли они. Если да, то он проигнорирует эти данные и будет считать, что сессия закрыта.
Хотя схема с установкой времени жизни работает неплохо, особенно, если время не очень большое, в случае с Persona нам нужен был способ немедленно закрывать сессию на всех клиентах, если пользователь менял пароль.
Нам всё же пришлось хранить малую толику состояния на сервере. [Мы сделали это](https://github.com/mozilla/browserid/commit/1b0444d85700a951edc74a0bf7ad5581b2cbfedd), добавив одно поле в таблицу БД на сервере и в cookie.
Каждый вызов API, который обращается к данным сессии, теперь считывает это поле в БД и сравнивает его с аналогичным полем в cookie. Если они не совпадают, сессия считается закрытой.
Лишнее обращение к БД — это, конечно не очень хорошо, но, к счастью, нам и так приходилось читать из таблицы с данными пользователей при почти каждом вызове, так что идентификатор сессии можно было получить без лишних накладных расходов. Чтобы вы могли быстрее начать экспериментировать с модулем, мы написали небольшое [демонстрационное приложение](https://github.com/fmarier/node-client-sessions-sample).
---
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)" | https://habr.com/ru/post/196018/ | null | ru | null |
# Оптимизация картинок для Google PageSpeed
Нет предела совершенству, и [Google PageSpeed](https://developers.google.com/speed/pagespeed/) тому доказательство. С его помощью меньше чем за минуту можно получить подробный отчет о производительности Web страницы. В подавляющем большинстве случаев PageSpeed подскажет, что нужно оптимизировать графику. Это [наиболее частая](http://habrahabr.ru/company/io/blog/257533/) проблема и наиболее весомая.
[](http://habrahabr.ru/company/io/blog/258363/)
Например, даже на стартовой странице Google Developers графику можно сжать на 71%. Чем [меньше весят фотки](https://onthe.io/learn+%D0%9A%D0%B0%D0%BA+%D0%B2%D1%8B%D0%B1%D1%80%D0%B0%D1%82%D1%8C+%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82+%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9) – тем быстрее грузится сайт. Меньше картинки — меньше трафика — все работает быстрее. Посетители тратят меньше времени – все довольны.
В этом материале подобраны основные инструменты для оптимизации графики.
#### Серверные инструменты
Самые частые — изображения в формате JPG. Основные инструменты:
* [Jpegtran](http://jpegclub.org/jpegtran/) сжимает картинки [без потерь](https://onthe.io/learn+%D0%A1%D0%B6%D0%B0%D1%82%D0%B8%D0%B5+%D0%BA%D0%B0%D1%80%D1%82%D0%B8%D0%BD%D0%BE%D0%BA+%D1%81+%D0%BF%D0%BE%D1%82%D0%B5%D1%80%D1%8F%D0%BC%D0%B8+%D0%B8+%D0%B1%D0%B5%D0%B7#1) и удаляет метаданные:
```
jpegtran -copy none -optimize -outfile output.jpg input.jpg
```
* [Imagemagick](http://www.imagemagick.org/script/index.php) работает практически со всеми форматами. Утилита convert позволяет указывать параметр качества для сжатия, что поможет уменьшить размер картинки:
```
convert input.jpg -quality 75 output.jpg
```
Формат PNG используется для иконок, логотипов и малоцветных изображений. Инструменты для оптимизации:
* [pngquant](https://pngquant.org/) – инструмент [lossy-сжатия](https://onthe.io/learn+%D0%A1%D0%B6%D0%B0%D1%82%D0%B8%D0%B5+%D0%BA%D0%B0%D1%80%D1%82%D0%B8%D0%BD%D0%BE%D0%BA+%D1%81+%D0%BF%D0%BE%D1%82%D0%B5%D1%80%D1%8F%D0%BC%D0%B8+%D0%B8+%D0%B1%D0%B5%D0%B7#2) для оптимизации PNG с потерями качества. Основной алгоритм работы — уменьшается количество используемых оттенков цветов. Это снижает размер с небольшими потерями в качестве:
```
pngquant --quality 75 —speed 1 input.png
```
* [pngcrush](http://pmt.sourceforge.net/pngcrush/) – еще одно средство оптимизации для PNG. Использует алгоритм сжатия без потерь:
```
pngcrush -reduce -brute in.png out.png
```
#### Облачные инструменты
* [JPEGmini](http://www.jpegmini.com/). Отлично сжимает фотки на 20…30%. Создатели заявляют, что могут сжать некоторые изображения в 5 раз без потерь в качестве. Есть API для автоматизации.
* [TinyPNG](https://tinypng.com/). Реально крутой инструмент оптимизации для PNG. Очень хорошее сжатие без заметных потерь в качестве. Также есть API и большой бесплатный пакет.
* [i.onthe.io/google\_speed](https://i.onthe.io/test). Простой сжиматор, работает с любым форматом. Удобен для одноразовой обработки.
#### Модуль PageSpeed
Google потрудился и выпустил модуль к Ngnix и Apache для повышения производительности сайтов. Он увеличивает скорость загрузки, оптимизируя дофига [всяких параметров](https://developers.google.com/speed/docs/insights/rules), в том числе и фотки. Работает автоматически, его нужно только [установить](https://developers.google.com/speed/pagespeed/module/download) и включить:
```
pagespeed on;
pagespeed FileCachePath /var/cache/nginx;
```
Модуль делает все сам — и анализирует HTML, и оптимизирует ресурсы. Например, пережимает картинки или минифицирует статику. В исходниках страницы все оптимизированные ресурсы будут иметь другой путь.
##### Прямая оптимизация ресурсов
После оптимизации PageSpeed сохраняет файл по новому пути. Но как быть с фотками, отображаемыми через JavaScript? Или со ссылками на Ваши фотки на сторонних ресурсах? Тут на помощь приходит IPRO – оптимизация ресурсов не отходя от кассы, а точнее не изменяя URL.
Для этого достаточно включить в конфиг такие инструкции (для Nginx):
```
pagespeed InPlaceResourceOptimization on;
```
#### Конспект
* Используйте PageSpeed для поиска проблем с графикой на сайте.
* Если графики много, используйте серверные инструменты для оптимизации: jpegtran, jpegoptim, ImageMagick, pngquant, pngcrush.
* Облачные инструменты для одноразовых задач и подключения по API: JPEGmini, tinyPNG, i.onthe.io/google\_speed.
* Модуль PageSpeed к Nginx/Apache сделает всю оптимизацию сам, но его нужно собирать. | https://habr.com/ru/post/258363/ | null | ru | null |
# Стековая машина на моноидах
Не так давно на Хабре появилась отличная и вдохновляющая [статья](https://habr.com/company/badoo/blog/428878/) про компиляторы и стековые машины. В ней показывается путь от простой реализации исполнителя байт-кода ко всё более и более эффективным версиям. Мне захотелось показать на примере разработки стековой машины, как это можно сделать Haskell-way.
На примере интерпретации языка для стековой машины мы увидим, как математическая концепция полугрупп и моноидов помогает разрабатывать и расширять архитектуру программы, как можно использовать алгебру моноидов и каким образом можно строить программы в форме набора гомоморфизмов между алгебраическими системами. В качестве рабочих примеров мы сначала построим интерпретатор, неотделимый от кода в виде EDSL, а потом научим его разным штукам: вести запись произвольной отладочной информации, отделять код программы от самой программы, проводить простой статический анализ и вычислять с различными эффектами.
Статья рассчитана на тех, кто владеет языком Haskell на среднем уровне и выше, на тех, кто его уже использует в работе или исследованиях и на всех любопытных, заглянувших поглядеть чего это функциональщики ещё понаворотили. Ну, и для тех, конечно, кого не испугал предыдущий абзац.
Материала получилось много, со множеством примеров в коде, и чтобы облегчить читателю понимание нужно ли ему в неё погружаться, приведу аннотированное содержание.
**Содержание статьи*** [Языки и программы для стековых машин.](#ch1) *Рассматриваются структурные особенности языков стековых машин, которые можно использовать для реализации интерпретатора*
* [Строим машину.](#ch2) *Более или менее подробно разбирается код интерпретатора для стековой машины с памятью, основанный на моноидах трансформации.*
* [Комбинируем моноиды.](#ch3) *С помощью алгебры моноидов добавляем в интерпретатор ведение журнала вычислений, с практически произвольными типами записей.*
* [Программы и их коды.](#ch4) *Строим изоморфизм между программой и её кодом, дающий возможность оперировать ими по-отдельности.*
* [Освобождение моноида.](#ch5) *Новые гомомофизмы из программ в другие структуры используютсях для форматированного листинга, статического анализа и оптимизации кода.*
* [От моноидов к монадам и снова к моноидам.](#ch6) *Конструируем гомоморфизмы в элементы категории Клейсли, открывающие возможности использования монад. Расширяем интерпретатор командами ввода/вывода и неоднозначными вычислениями.*
Задачи трансляции и интерпретации дарят множество интересных и полезных примеров для демонстрации самых разных аспектов программирования. Они позволяют переходить на разные ступени сложности и абстракции, оставаясь при этом вполне практичными. В этой статье мы сосредоточимся на демонстрации возможностей двух важных математических структур — *полугруппы* и *моноида*. Они не так часто обсуждаются, как монады или линзы, и ими не пугают маленьких программистов, эти структуры существенно проще для понимания, но при всём том, они лежат в основе функционального программирования. Виртуозное владение моноидальными типами, которое демонстрируют профессионалы, вызывает восхищение простотой и изяществом решений.
Поиск слова "моноид" по статьям на Хабре выдаёт не более четырёх десятков статей (про те же монады, например, их три сотни). Все они концептуально начинают с чего-то вроде: *моноид это такое множество...* а потом, с вполне понятным восторгом, перечисляют что является моноидом — от строк до пальчиковых деревьев, от парсеров регулярных выражений до [бог знает ещё чего](https://www.listal.com/list/one-eyed)! Но на практике мы мыслим в обратном порядке: у нас есть объект, который необходимо моделировать, мы анализируем его свойства и обнаружив, что он обладает признаками той или иной абстрактной структуры, решаем: нужны ли нам следствия из этого обстоятельства и как нам это использовать. Мы пройдём именно этим путём. А заодно добавим в коллекцию полезных моноидов ещё парочку интересных примеров.
### Языки и программы для стековых машин
Стековые машины при изучении функционального программирования, обычно появляются в тот момент, когда подходят к концепции свёртки. При этом приводится крайне лаконичная реализация исполнителя простейшего стекового калькулятора, например, такая:
**Простейший стековый калькулятор**
```
calc :: String -> [Int]
calc = interpretor . lexer
where
lexer = words
interpretor = foldl (flip interprete) []
interprete c = case c of
"add" -> binary $ \(x:y:s) -> x + y:s
"mul" -> binary $ \(x:y:s) -> x * y:s
"sub" -> binary $ \(x:y:s) -> y - x:s
"div" -> binary $ \(x:y:s) -> y `div` x:s
"pop" -> unary $ \(x:s) -> s
"dup" -> unary $ \(x:s) -> x:x:s
x -> case readMaybe x of
Just n -> \s -> n:s
Nothing -> error $ "Error: unknown command " ++ c
where
unary f s = case s of
x:_ -> f s
_ -> error $ "Error: " ++ c ++ " expected an argument."
binary f s = case s of
x:y:_ -> f s
_ -> error $ "Error: " ++ c ++ " expected two arguments."
```
Здесь используется тотальный парсер `readMaybe` из модуля `Text.Read`. Можно было бы привести программу и раза в два короче, но уже без информативных сообщениях об ошибках, а это некрасиво.
Прекрасное начало для разговора! Далее, как правило, начинают навешивать эффекты: меняют свёртку `foldl` на `foldM`, обеспечивают тотальность через монаду `Either String`, потом добавляют логирование, оборачивая всё трасформером `WriterT`, внедряют с помощью `StateT` словарь для переменных, и так далее. Иногда, для демонстрации крутости монадических вычислений, реализуют неоднозначный калькулятор, возвращающий все возможные значения выражения . Это долгий, хороший и интересный разговор. Однако, свой рассказ мы сразу поведём по-другому, хотя и закончим его тем же результатом.
Почему, вообще, речь заходит о свёртке? Потому что свёртка (катаморфизм) — это *абстракция последовательной обработки индуктивных данных*. Стековая машина линейно проходит по коду, выполняя последовательность инструкций и порождает одно значение — состояние стека. Мне нравится представлять себе работу свёрточной стековой машины, как трансляцию матричной РНК в живой клетке. Рибосома шаг за шагом проходит всю цепочку РНК, сопоставляет триплеты нуклеотидов с аминокислотами и [создаёт](https://youtu.be/8dsTvBaUMvw) первичную структуру белка.
У свёрточной машины есть ряд ограничений, основное — программа всегда прочитывается от начала до конца и один раз. Ветвление, циклы и вызовы подпрограмм требуют концептуального изменения интерпретатора. Ничего сложного, конечно, но такая машина уже не может быть описана простой свёрткой.
Согласно гипотезе лингвистической относительности, свойства используемого нами языка напрямую влияют на свойства нашего мышления. Давайте обратим внимание не на машину, а на *языки* и *программы*, которыми она управляется.
Все стеково-ориентированные языки, как относительно низкоуровневые (байт-коды виртуальных машин Java и Python или .NET), так и языки уровнем повыше (PostScript, Forth или Joy), имеют одно фундаментальное общее свойство: если записать последовательно две корректные программы, то получится корректная программа. Правда, корректная не значит "правильная", эта программа может вылетать с ошибкой на любых данных или проваливаться в бесконечные циклы и вообще не иметь смысла, но главное — такая программа сможет быть выполнена машиной. В то же время, разбивая корректную программу на части мы легко можем эти части использовать повторно, именно в силу их корректности. Наконец, в любом стековом языке можно выделить подмножество команд, оперирующих только внутренним состоянием машины (стеком или регистрами), не использующих какую-либо внешнюю память. Это подмножество будет образовывать язык, обладающий свойством *конкатенативности*. В таком языке любая программа имеет смысл преобразователя состояния машины, а последовательное выполнение программ эквивалентно их композиции, а значит, тоже является преобразователем состояния.
Просматривается общий паттерн: комбинация (конкатенация) корректных программ порождает корректную программу, комбинация преобразователей порождает преобразователь. Получается, что программы стековых языков *замкнуты относительно операции конкатенации* или образуют структуру, которая называется *группоидом* или *магмой*. Это означает, что можно, записав программу на ленту, разрезать её почти как попало и потом из полученных отрезков формировать новые программы. Причём разрезать можно вплоть до отрезков с единственной инструкцией.
При склеивании важен порядок. Например, эти две программы, несомненно, разные:
Зато нам неважно где программу разрезать, если тут же её в этом месте склеить:
Это простое обстоятельство отражает *ассоциативность* операции конкатенации и поднимает структуру, которую образуют стековые программы, на новый уровень, мы понимаем что это *полугруппа*.
И что это нам даёт, как программистам? Ассоциативность позволяет выполнять прекомпиляцию, оптимизацию и даже распараллеливание произвольных пригодных для этого отрезков программы, а потом объединять их в эквивалентную программу. Мы можем позволить себе провести статический анализ любого отрезка программы и использовать его в анализе всей программы именно потому, что нам всё равно, где ставить скобки. Это очень важные и серьёзные возможности для языка низкого уровня или промежуточного языка, на котором пишет не человек, а транслятор. А с точки зрения математика и матёрого функциональщика, это делает программы-преобразователи состояния машины полноценными *эндоморфизмами*. Эндоморфизмы тоже образуют полугруппу с операцией композиции. В алгебре такие эндоморфизмы называются *полугруппами трансформации* по отношению к какому-либо множеству. Например, конечные автоматы образуют полугруппу трансформации множества состояний.
"Полугруппа" звучит половинчато, как-то неполноценно. Может быть, стековые программы образуют *группу*? Э… нет, большинство программ необратимо, то есть, по результату выполнения не выйдет однозначно восстановить исходные данные. А вот нейтральный элемент у нас есть. В языках ассемблера он обозначается  и ничего не делает. Если в стековом языке такого оператора явно не определили, то его можно легко получить комбинируя некоторые команды, например: ,  или . Такие пары можно безболезненно вырезать из программ или, напротив, вставлять куда угодно в произвольном количестве. Поскольку единица имеется, наши программы образуют *полугруппу с единицей* или *моноид*. Значит, можно программно реализовать их в виде моноидов — эндоморфизмов над состоянием стековой машины. Это позволит определить небольшой набор базовых операций для машины, а потом создавать программы с помощью их композиции, получив стековый язык в форме встроенного предметно-ориентированного языка (EDSL).
В языке Haskell полугруппы и моноиды описаны с помощью классов `Semigroup` и `Monoid`. Их определения просты и отражают только базовую структуру, требования ассоциативности и нейтральности приходится проверять программисту:
```
class Semigroup a where
(<>) :: a -> a -> a
class Semigroup a => Monoid a where
mempty :: a
```
### Строим машину
**Заголовочная часть программы**
```
{-# LANGUAGE LambdaCase, GeneralizedNewtypeDeriving #-}
import Data.Semigroup (Max(..),stimes)
import Data.Monoid
import Data.Vector ((//),(!),Vector)
import qualified Data.Vector as V (replicate)
```
Мы сразу построим машину, которая располагает стеком, конечной памятью и умеет аварийно останавливаться по-хорошему, чистым образом. Всё это реализуем без использования монад, инкапсулировав необходимые данные в тип, описывающий машину. Таким образом, все базовые программы, а значит и все их комбинации будут чистыми преобразователями её состояния.
Начнём с определения типа для виртуальной машины и тривиальных функций-сеттеров.
```
type Stack = [Int]
type Memory = Vector Int
type Processor = VM -> VM
memSize = 4
data VM = VM { stack :: Stack
, status :: Maybe String
, memory :: Memory }
deriving Show
emptyVM = VM mempty mempty (V.replicate memSize 0)
setStack :: Stack -> Processor
setStack x (VM _ s m) = VM x s m
setStatus :: Maybe String -> Processor
setStatus x (VM s _ m) = VM s x m
setMemory :: Memory -> Processor
setMemory x (VM s st _) = VM s st x
```
Сеттеры нужны для того, чтобы сделать явной семантику программы. Под процессором (тип `Processor`) мы будем понимать преобразователь `VM -> VM`.
Теперь определим типы-обёртки для моноида трансформации и для программы:
```
newtype Action a = Action { runAction :: a -> a }
instance Semigroup (Action a) where
Action f <> Action g = Action (g . f)
instance Monoid (Action a) where
mempty = Action id
newtype Program = Program { getProgram :: Action VM }
deriving (Semigroup, Monoid)
```
Типы-обёртки определяют принцип комбинирования программ: это эндоморфизмы с обратным порядком композиции (слева направо). Использование обёрток позволяет компилятору самостоятельно определить каким образом тип `Program` реализует требования классов `Semigroup` и `Monoid`.
Исполнитель программ тривиален:
```
run :: Program -> Processor
run = runAction . getProgram
exec :: Program -> VM
exec prog = run prog emptyVM
```
Сообщение об ошибке будет формировать функция `err`:
```
err :: String -> Processor
err = setStatus . Just $ "Error! " ++ m
```
Мы используем тип `Maybe` не так как он используется обычно: пустое значение `Nothing` в статусе означает, что ничего опасного не происходит, и вычисления можно продолжать, в свою очередь, строковое значение знаменует проблемы. Для удобства, определим два умных конструктора: один — для программ, работающих только со стеком, другой — для тех, которым нужна память.
```
program :: (Stack -> Processor) -> Program
program f = Program . Action $
\vm -> case status vm of
Nothing -> f (stack vm) vm
_ -> vm
programM :: ((Memory, Stack) -> Processor) -> Program
programM f = Program . Action $
\vm -> case status vm of
Nothing -> f (memory vm, stack vm) vm
_ -> vm
```
Теперь можно определять базовые команды языка для работы со стеком и памятью, целочисленную арифметику, а также отношения эквивалентности и порядка.
**Работа со стеком**
```
pop = program $
\case x:s -> setStack s
_ -> err "pop expected an argument."
push x = program $ \s -> setStack (x:s)
dup = program $
\case x:s -> setStack (x:x:s)
_ -> err "dup expected an argument."
swap = program $
\case x:y:s -> setStack (y:x:s)
_ -> err "swap expected two arguments."
exch = program $
\case x:y:s -> setStack (y:x:y:s)
_ -> err "exch expected two arguments."
```
**Работа с памятью**
```
-- конструктор для функций с ограниченным индексом
indexed i f = programM $ if (i < 0 || i >= memSize)
then const $ err $ "expected index in within 0 and " ++ show memSize
else f
put i = indexed i $
\case (m, x:s) -> setStack s . setMemory (m // [(i,x)])
_ -> err "put expected an argument"
get i = indexed i $ \(m, s) -> setStack ((m ! i) : s)
```
**Арифметические операции и отношения**
```
unary n f = program $
\case x:s -> setStack (f x:s)
_ -> err $ "operation " ++ show n ++ " expected an argument"
binary n f = program $
\case x:y:s -> setStack (f x y:s)
_ -> err $ "operation " ++ show n ++ " expected two arguments"
add = binary "add" (+)
sub = binary "sub" (flip (-))
mul = binary "mul" (*)
frac = binary "frac" (flip div)
modulo = binary "modulo" (flip mod)
neg = unary "neg" (\x -> -x)
inc = unary "inc" (\x -> x+1)
dec = unary "dec" (\x -> x-1)
eq = binary "eq" (\x -> \y -> if (x == y) then 1 else 0)
neq = binary "neq" (\x -> \y -> if (x /= y) then 1 else 0)
lt = binary "lt" (\x -> \y -> if (x > y) then 1 else 0)
gt = binary "gt" (\x -> \y -> if (x < y) then 1 else 0)
```
Для полноценной работы не хватает ветвления и циклов. Вообще-то, для встроенного языка достаточно только ветвления, циклы можно организовать с помощью рекурсии во вмещающем языке (в Haskell), но мы сделаем наш язык самодостаточным. Кроме того, воспользуемся тем, что программы образуют полугруппу и определим комбинатор повторения программы указанное число раз. Количество повторений он будет брать со стека.
**Ветвление и циклы**
```
branch :: Program -> Program -> Program
branch br1 br2 = program go
where go (x:s) = proceed (if (x /= 0) then br1 else br2) s
go _ = err "branch expected an argument."
while :: Program -> Program -> Program
while test body = program (const go)
where go vm = let res = proceed test (stack vm) vm
in case (stack res) of
0:s -> proceed mempty s res
_:s -> go $ proceed body s res
_ -> err "while expected an argument." vm
rep :: Program -> Program
rep body = program go
where go (n:s) = proceed (stimes n body) s
go _ = err "rep expected an argument."
proceed :: Program -> Stack -> Processor
proceed prog s = run prog . setStack s
```
Типы функций `branch` и `while` говорят о том, что это не самостоятельные программы, а комбинаторы программ: типичный подход при создании EDSL в Haskell. Функция `stimes` определена для всех полугрупп, она возвращает композицию указанного числа элементов.
Наконец, напишем несколько программ, для опытов.
**Примеры программ**
```
-- рекурсивный факториал
fact = dup <> push 2 <> lt <>
branch (push 1) (dup <> dec <> fact) <>
mul
-- итеративный факториал
fact1 = push 1 <> swap <>
while (dup <> push 1 <> gt)
(
swap <> exch <> mul <> swap <> dec
) <>
pop
-- заполняет стек последовательностью чисел
-- в указанном диапазоне
range = exch <> sub <> rep (dup <> inc)
-- ещё один итеративный факториал,
-- записанный через свёртку списка команд
fact2 = mconcat [ dec, push 2, swap, range, push 3, sub, rep mul]
-- итеративный факториал с использованием памяти
fact3 = dup <> put 0 <> dup <> dec <>
rep (dec <> dup <> get 0 <> mul <> put 0) <>
get 0 <> swap <> pop
-- копирует два верхних элемента стека
copy2 = exch <> exch
-- вычисляет наибольший общий делитель
-- по простейшему алгоритму Евклида
gcd1 = while (copy2 <> neq)
(
copy2 <> lt <> branch mempty (swap) <> exch <> sub
) <>
pop
-- возведение в степень методом русского крестьянина
pow = swap <> put 0 <> push 1 <> put 1 <>
while (dup <> push 0 <> gt)
(
dup <> push 2 <> modulo <>
branch (dec <> get 0 <> dup <> get 1 <> mul <> put 1) (get 0) <>
dup <> mul <> put 0 <>
push 2 <> frac
) <>
pop <> get 1
```
Получилось 120 строк кода с комментариями и аннотациями типов, которые определяют машину, оперирующую 18 командами с тремя комбинаторами. Вот как наша машина работает .
```
λ> exec (push 6 <> fact)
VM {stack = [720], status = Nothing, memory = [0,0,0,0]}
λ> exec (push 6 <> fact3)
VM {stack = [720], status = Nothing, memory = [720,0,0,0]}
λ> exec (push 2 <> push 6 <> range)
VM {stack = [6,5,4,3,2], status = Nothing, memory = [0,0,0,0]}
λ> exec (push 6 <> push 9 <> gcd1)
VM {stack = [3], status = Nothing, memory = [0,0,0,0]}
λ> exec (push 3 <> push 15 <> pow)
VM {stack = [14348907], status = Nothing, memory = [43046721,14348907,0,0]}
λ> exec (push 9 <> add)
VM {stack = [9], status = Just "Error! add expected two arguments", memory = [0,0,0,0]}
```
На самом деле, мы ничего нового не сделали — комбинируя преобразователи-эндоморфизмы, мы, по существу, вернулись к свёртке, но она стала неявной. Напомним, свёртка даёт абстракцию последовательной обработки индуктивных данных. Данные, в нашем случае, образуются индуктивным образом при склеивании программ оператором , и "хранятся" они в эндоморфизме в виде цепочки композиций функций-преобразователей машины до момента применения этой цепочки к исходному состоянию. В случае применения комбинаторов `branch` и `while` цепочка начинает превращаться в дерево или в цикл. В общем случае, мы получаем граф, отражающий работу автомата с магазинной памятью, то есть, стековой машины. Именно эту структуру мы "сворачиваем" при выполнении программы.
Насколько эффективна такая реализация? Композиция функций — это самое лучшее, что умеет делать компилятор языка Haskell. Он, буквально, рождён для этого! Когда речь заходит о преимуществах использования знания о моноидах, часто приводят пример разностных списков `diffList` — реализации связного списка в виде композиции эндоморфизмов. Разностные списки принципиально ускоряют формирование списков из множества кусочков благодаря ассоциативности композиции функций. Возня с типами-обёртками не приводит к увеличению накладных расходов, они "растворяются" на этапе компиляции. Из лишней работы остаётся только проверка состояния на каждом шаге выполнения программы.
### Комбинируем моноиды
Думаю, к этому моменту скептики и случайные читатели уже нас покинули, можно позволить себе расслабиться и перейти на следующий уровень абстракции.
Концепция полугрупп и моноидов не была бы столь полезной и универсальной, если бы не ряд свойств, присущих всем полугруппам и моноидам без исключения, которые позволяют из простых структур строить сложные точно таким же образом, каким мы строим сложные программы из простых. Эти свойства относятся уже не к объектам, а к типам и их лучше записать не в математической нотации, а в виде программ на Haskell, которые в силу изоморфизма Карри-Ховарда, являются их доказательствами.
1) Моноиды и полугруппы можно "перемножать". Здесь имеется в виду произведение типов, абстракцией которого в Haskell является кортеж или пара.
```
instance (Semigroup a, Semigroup b) => Semigroup (a,b) where
(a1, b1) <> (a2, b2) = (a1 <> a2, b1 <> b2)
instance (Monoid a, Monoid b) => Monoid (a,b) where
mempty = (mempty, mempty )
```
2) Существует единичный моноид, он представлен единичным типом `()`:
```
instance Semigroup () where
() <> () = ()
instance Monoid () where
mempty = ()
```
С операцией перемножения полугруппы сами образуют полугруппу, а принимая во внимание единичный тип, можно сказать, что моноиды образуют моноид! Ассоциативность и нейтральность единицы при этом выполняется с точностью до изоморфизма, но это не принципиально.
3) Отображения в полугруппу или моноид образуют, соответственно, полугруппу или моноид. И тут тоже проще записать это утверждение на Haskell:
```
instance Semigroup a => Semigroup (r -> a) where
f <> g = \r -> f r <> g r
instance Monoid a => Monoid (r -> a) where
mempty = const mempty
```
Воспользуемся этими комбинаторами для того, чтобы расширить возможности построенного нами стекового языка. Давайте внесём серьёзное изменение и сделаем наши базовые команды *функциями, возвращающими программы*. Это не лишит их моноидальных свойств, зато позволит вводить в работу всех команд машины произвольную информацию извне. Вот что имеется ввиду:
```
(command1 <> command2) r == command1 r <> command2 r
```
Информация может быть любой, например, внешний словарь с какими-то определениями, или способ вести журнал вычислений, нужный при отладке. Это очень похоже на действие монады `Reader`, которая, как раз, и является просто функцией.
Мы введём в структуру машины журнал, но не будем привязывать его к какому-то определённому типу, а выведем его в параметр типа. Писать в журнал будем с помощью обобщённой моноидальной операции.
```
data VM a = VM { stack :: Stack
, status :: Maybe String
, memory :: Memory
, journal :: a }
deriving Show
mkVM = VM mempty mempty (V.replicate memSize 0)
setStack x (VM _ st m l) = VM x st m l
setStatus st (VM s _ m l) = VM s st m l
setMemory m (VM s st _ l) = VM s st m l
addRecord x (VM s st m j) = VM s st m (x<>j)
newtype Program a = Program { getProgram :: Action (VM a) }
deriving (Semigroup, Monoid)
type Program' a = (VM a -> VM a) -> Program a
```
С этого момента мы позволим себе не указывать аннотации типов для всех определений, предоставляя компилятору разбираться с ними самостоятельно, они не сложные, хоть и становятся громоздкими. Сами команды менять не придётся, благодаря умным конструкторам, которые примут на себя все изменения. Совсем небольшие.
**Новые конструкторы и комбинаторы.**
```
program f p = Program . Action $
\vm -> case status vm of
Nothing -> p . (f (stack vm)) $ vm
m -> vm
programM f p = Program . Action $
\vm -> case status vm of
Nothing -> p . (f (memory vm, stack vm)) $ vm
m -> vm
proceed p prog s = run (prog p) . setStack s
rep body p = program go id
where go (n:s) = proceed p (stimes n body) s
go _ = err "rep expected an argument."
branch br1 br2 p = program go id
where go (x:s) = proceed p (if (x /= 0) then br1 else br2) s
go _ = err "branch expected an argument."
while test body p = program (const go) id
where go vm = let res = proceed p test (stack vm) vm
in case (stack res) of
0:s -> proceed p mempty s res
_:s -> go $ proceed p body s res
_ -> err "while expected an argument." vm
```
Осталось научить вводить внешнюю информацию в исполнитель программ. Это очень просто сделать, создавая различные исполнители с различной стратегией ведения журнала. Первый исполнитель будет самым простым, молчаливым, не тратящим сил на ведение журнала:
```
exec prog = run (prog id) (mkVM ())
```
Тут нам пригодился единичный моноид `()` — нейтральный элемент в алгебре моноидов. Далее, можно определить функцию для исполнителя, готового записывать в журнал ту или иную информацию о состоянии машины.
```
execLog p prog = run (prog $ \vm -> addRecord (p vm) vm) (mkVM mempty)
```
Информация может быть, например, такая:
```
logStack vm = [stack vm]
logStackUsed = Max . length . stack
logSteps = const (Sum 1)
logMemoryUsed = Max . getSum . count . memory
where count = foldMap (\x -> if x == 0 then 0 else 1)
```
Проверяем работу:
```
λ> exec (push 4 <> fact2)
VM {stack = [24], status = Nothing, memory = [0,0,0,0], journal = ()}
λ> journal $ execLog logSteps (push 4 <> fact2)
Sum {getSum = 14}
λ> mapM_ print $ reverse $ journal $ execLog logStack (push 4 <> fact2)
[4]
[3]
[2,3]
[3,2]
[2,2]
[3,2]
[3,3,2]
[4,3,2]
[4,4,3,2]
[5,4,3,2]
[3,5,4,3,2]
[2,4,3,2]
[12,2]
[24]
```
Логгеры можно комбинировать, пользуясь тем обстоятельством, что моноиды перемножаются. Введём простой комбинатор для логгеров:
```
f &&& g = \r -> (f r, g r)
```
Так можно провести сравнение четырёх реализаций факториала по числу шагов и максимальной длине стека
```
λ> let report p = journal $ execLog (logSteps &&& logStackUsed) p
λ> report (push 8 <> fact)
(Sum {getSum = 48},Max {getMax = 10})
λ> report (push 8 <> fact1)
(Sum {getSum = 63},Max {getMax = 4})
λ> report (push 8 <> fact2)
(Sum {getSum = 26},Max {getMax = 9})
λ> report (push 8 <> fact3)
(Sum {getSum = 43},Max {getMax = 3})
```
Логгеры можно было бы объявить моноидом с операцией `&&&`, если бы они все возвращали одинаковый тип. Но так как они разные, Haskell это сделать не позволяет. Так что не всё, что комбинируется является работающим моноидом.
### Программы и их коды
Полноценная отладка подразумевает информацию о выполняемых командах. Но наши команды — это настоящие функции, у них нет имени вне пространства имён Haskell. И тут мы приходим к красивому рассуждению.
Можно сопоставить каждой базовой команде уникальный код, в то же время, можно сопоставить коду — команду. Оба соответствия однозначные, а значит: множества команд и имён *изоморфны*. Программы (комбинации команд) образуют моноид, и тексты программ (последовательность кодов) образуют моноид. Мы и начинали разговор с того, что разрезали и склеивали именно *тексты* программ, записанные на лентах. Значит между программами и их кодами можно построить пару взаимно-обратных *гомоморфизмов*.
Давайте же построим эти отображения! Определим сначала тип для кодов нашего языка:
```
data Code = IF [Code] [Code]
| REP [Code]
| WHILE [Code] [Code]
| PUT Int | GET Int
| PUSH Int | POP | DUP | SWAP | EXCH
| INC | DEC | NEG
| ADD | MUL | SUB | DIV
| EQL | LTH | GTH | NEQ
deriving (Read, Show)
```
Теперь построим гомоморфизм код  программа:
```
fromCode :: [Code] -> Program' a
fromCode = hom
where
hom = foldMap $ \case
IF b1 b2 -> branch (hom b1) (hom b2)
REP p -> rep (hom p)
WHILE t b -> while (hom t) (hom b)
PUT i -> put i
GET i -> get i
PUSH i -> push i
POP -> pop
DUP -> dup
SWAP -> swap
EXCH -> exch
INC -> inc
DEC -> dec
ADD -> add
MUL -> mul
SUB -> sub
DIV -> frac
EQL -> eq
LTH -> lt
GTH -> gt
NEQ -> neq
NEG -> neg
```
Здесь мы используем то, что программы являются моноидами. `foldMap` это эффективная свёртка, рассчитанная на моноиды и использующая ассоциативность моноидальных операций. Гомоморфизм `fromCode` является транслятором программы, записанной в кодах, он уже позволяет транслировать программы, записанные в виде кодов и даже в виде текcта:
```
λ> stack $ exec (fromCode [PUSH 2, PUSH 5, EXCH, SUB, REP [DUP, INC]])
[5,4,3,2]
λ> stack $ exec (fromCode $ read "[PUSH 2, PUSH 5, EXCH, SUB, REP [DUP, INC]]")
[5,4,3,2]
```
Обратный гомоморфизм *программа*  *код* построить таким же образом не выйдет, поскольку мы не можем перебирать в `case` функции. Но можно снова воспользоваться двумя замечательными обстоятельствами: тем что программы образуют моноид и тем что моноиды образуют полугруппу! Перемножим в определении типа `Program` код программы и соответствующий ему трансформер:
```
newtype Program a = Program { getProgram :: ([Code], Action (VM a)) }
deriving (Semigroup, Monoid)
run = runAction . snd . getProgram
```
Наряду с исполняющей функцией `run` появляется возможность получить код программы и вот он второй гомоморфизм, обратный `fromCode`:
```
toCode :: Program' a -> [Code]
toCode prog = fst . getProgram $ prog id
```
Теперь остаётся переписать выражения для умных конструкторов так, чтобы каждой базовой программе можно было бы указать её код. Впрочем, конструкторы и определения команд языка изменятся не существенно:
```
type Program' a = (Code -> VM a -> VM a) -> Program a
program c f p = Program . ([c],) . Action $
\vm -> case status vm of
Nothing -> p c . f (stack vm) $ vm
_ -> vm
programM c f p = Program . ([c],) . Action $
\vm -> case status vm of
Nothing -> p c . f (memory vm, stack vm) $ vm
_ -> vm
```
Как видно, функция, которую мы передаём для ведения журнала стала бинарной, поскольку она теперь располагает кодом программы. Значит надо немного поменять логгеры, а за одно создать логгер для кода и говорливый логгер-отладчик:
**Логгеры и отладчик**
```
none = const id
exec prog = run (prog none) (mkVM ())
execLog p prog = run (prog $ \c -> \vm -> addRecord (p c vm) vm) (mkVM mempty)
logStack _ vm = [stack vm]
logStackUsed _ = Max . length . stack
logSteps _ = const (Sum 1)
-- новые логгеры
logCode c _ = [c]
logRun com vm = [pad 10 c ++ "| " ++ pad 20 s ++ "| " ++ m]
where c = show com
m = unwords $ show <$> toList (memory vm)
s = unwords $ show <$> stack vm
pad n x = take n (x ++ repeat ' ')
debug :: Program' [String] -> String
debug = unlines . reverse . journal . execLog logRun
```
**Определения именованных базовых команд и комбинаторов**
```
pop = program POP $
\case x:s -> setStack s
_ -> err "POP expected an argument."
push x = program (PUSH x) $ \s -> setStack (x:s)
dup = program DUP $
\case x:s -> setStack (x:x:s)
_ -> err "DUP expected an argument."
swap = program SWAP $
\case x:y:s -> setStack (y:x:s)
_ -> err "SWAP expected two arguments."
exch = program EXCH $
\case x:y:s -> setStack (y:x:y:s)
_ -> err "EXCH expected two arguments."
app1 c f = program c $
\case x:s -> setStack (f x:s)
_ -> err $ "operation " ++ show c ++ " expected an argument"
app2 c f = program c $
\case x:y:s -> setStack (f x y:s)
_ -> err $ "operation " ++ show c ++ " expected two arguments"
add = app2 ADD (+)
sub = app2 SUB (flip (-))
mul = app2 MUL (*)
frac = app2 DIV (flip div)
neg = app1 NEG (\x -> -x)
inc = app1 INC (\x -> x+1)
dec = app1 DEC (\x -> x-1)
eq = app2 EQL (\x -> \y -> if (x == y) then 1 else 0)
neq = app2 NEQ (\x -> \y -> if (x /= y) then 1 else 0)
lt = app2 LTH (\x -> \y -> if (x > y) then 1 else 0)
gt = app2 GTH (\x -> \y -> if (x < y) then 1 else 0)
proceed p prog s = run (prog p) . setStack s
rep body p = program (REP (toCode body)) go none
where go (n:s) = if n >= 0
then proceed p (stimes n body) s
else err "REP expected positive argument."
go _ = err "REP expected an argument."
branch br1 br2 p = program (IF (toCode br1) (toCode br2)) go none
where go (x:s) = proceed p (if (x /= 0) then br1 else br2) s
go _ = err "IF expected an argument."
while test body p = program (WHILE (toCode test) (toCode body)) (const go) none
where go vm = let res = proceed p test (stack vm) vm
in case (stack res) of
0:s -> proceed p mempty s res
_:s -> go $ proceed p body s res
_ -> err "WHILE expected an argument." vm
put i = indexed (PUT i) i $
\case (m, x:s) -> setStack s . setMemory (m // [(i,x)])
_ -> err "PUT expected an argument"
get i = indexed (GET i) i $ \(m, s) -> setStack ((m ! i) : s)
indexed c i f = programM c $ if (i < 0 || i >= memSize)
then const $ err "index in [0,16]"
else f
```
Всё, изоморфизм между программами и их кодами установлен! Давайте посмотрим, как он работает.
Во-первых, мы можем получить код любой программы:
```
λ> toCode fact1
[PUSH 1,SWAP,WHILE [DUP,PUSH 1,GTH] [SWAP,EXCH,MUL,SWAP,DEC],POP]
```
Теперь программы можно создавать с помощью EDSL, записывать их в файл и считывать из него.
Во-вторых, можем убедиться в том, что два гомоморфизма `toCode` и `fromCode` являются взаимо-обратными.
```
λ> toCode $ fromCode [PUSH 5, PUSH 6, ADD]
[PUSH 5, PUSH 6, ADD]
λ> exec (fromCode $ toCode (push 5 <> push 6 <> add))
VM {stack = [11], status = Nothing, memory = [0,0,0,0], journal = ()}
```
Правда, наш изоморфизм имеет один существенный недостаток: он не позволяет превратить в конечный код программы, определённые с помощью явной рекурсии. Попробуйте в `ghci` посмотреть код программы `fact`, только держите пальцы на готове, чтобы поскорее нажать `Ctrl+C`. Приходится признать, что гомоморфизм `toCode` существует, но вычислим частично.
Наконец, давайте запустим полноценный отладчик, причём, он-то как раз хорошо работает и с рекурсивными функциями тоже:
```
λ> putStrLn $ debug (push 3 <> fact)
PUSH 3 | 3 | 0 0 0 0
DUP | 3 3 | 0 0 0 0
PUSH 2 | 2 3 3 | 0 0 0 0
LTH | 0 3 | 0 0 0 0
DUP | 3 3 | 0 0 0 0
DEC | 2 3 | 0 0 0 0
DUP | 2 2 3 | 0 0 0 0
PUSH 2 | 2 2 2 3 | 0 0 0 0
LTH | 0 2 3 | 0 0 0 0
DUP | 2 2 3 | 0 0 0 0
DEC | 1 2 3 | 0 0 0 0
DUP | 1 1 2 3 | 0 0 0 0
PUSH 2 | 2 1 1 2 3 | 0 0 0 0
LTH | 1 1 2 3 | 0 0 0 0
PUSH 1 | 1 1 2 3 | 0 0 0 0
MUL | 1 2 3 | 0 0 0 0
MUL | 2 3 | 0 0 0 0
MUL | 6 | 0 0 0 0
```
### Освобождение моноида
Код программы имеет вид дерева и он представляет собой чистую информацию о программе. Мы получили *свободную алгебру* программ для нашей стековой машины. Более того, и сами программы являются свободными структурами, так как мы построили изоморфизм между кодом программы и исполнителем!
Кроме возможностей сериализации и десериализации, свободные структуры предоставляют свободу интерпретации. Мы построили пока только один способ интерпретации свободной программы — в виде трансформаций состояния стековой машины. Но имея программу в свободной форме можно делать с ней что угодно, например обеспечивать форматированный вывод, проводить оптимизацию или статический анализ.
Обычно, на этом замечательном пассаже статья про свободные структуры обрывается: можно и можно, правда сложно и в одном разделе не рассказать. Но так вышло, что наш язык чрезвычайно прост и чрезвычайно моноидален, а это позволяет делать некоторые вещи очень изящно. Грех этим не воспользоваться и не поделиться!
Вот, например, как просто написать форматированный листинг программы:
```
listing :: Program' a -> String
listing = unlines . hom 0 . toCode
where
hom n = foldMap f
where
f = \case
IF b1 b2 -> ouput "IF" <> indent b1 <> ouput ":" <> indent b2
REP p -> ouput "REP" <> indent p
WHILE t b -> ouput "WHILE" <> indent t <> indent b
c -> ouput $ show c
ouput x = [stimes n " " ++ x]
indent = hom (n+1)
```
И снова строится гомоморфизм: теперь командам ставятся в соответствие строки с отступом, которые, опять же, образуют моноид.
**Пара симпатично напечатанных программ:**
```
λ> putStrLn . listing $ fact2
INC
PUSH 1
SWAP
EXCH
SUB
DUP
PUSH 0
GTH
IF
REP
DUP
INC
:
NEG
REP
DUP
DEC
DEC
DEC
REP
MUL
λ> putStrLn . listing $ gcd1
WHILE
EXCH
EXCH
NEQ
EXCH
EXCH
LTH
IF
:
SWAP
EXCH
SUB
POP
```
Не будем на этом останавливаться и попробуем провести нехитрый статический анализ программ для стековой машины. Тип данных у нас один, так что статическая типизация для языка не актуальна, зато на стеке может не хватить данных для выполнения программы. У нас есть возможность вычислить строгие требования для работы программы до её выполнения.
Введём такую характеристику программ, как *валентность* — это информация о максимальном количестве аргументов, которые должны быть на стеке перед её выполнением и о минимальном числе элементов которые останутся на стеке после её выполнения. Например перед выполнением операции сложения нужно иметь на стеке не менее двух элементов, а после выполнения останется как минимум один элемент. Мы запишем это обстоятельство в таком виде:
Приведём валентности некоторых других операторов:
Почему мы всё время оговариваемся: минимальное число, максимальные требования..? Дело в том, что все базовые операторы имеют точно определённую валентность, но при ветвлении разные ветви могут иметь разные требования и результаты. Наша задача: вычислить наиболее строгие требования, которые должны обеспечить работу всех ветвей, сколько бы их ни было.
При последовательном выполнении команд валентности комбинируются следующим нетривиальным образом:
Эта операция ассоциативна и имеет нейтральный элемент, что не удивительно для статьи, посвящённой моноидам. Добавим этот результат в программу:
```
infix 7 :>
data Arity = Int :> Int
deriving (Show,Eq)
instance Semigroup Arity where
(i1 :> o1) <> (i2 :> o2) = let a = 0 `max` (i2 - o1)
in (a + i1) :> (a + o1 + o2 - i2)
instance Monoid Arity where
mempty = 0:>0
```
А после чего можно строить гомоморфизм:
```
arity :: Program' a -> Arity
arity = hom . toCode
where
hom = foldMap $
\case
IF b1 b2 -> let i1 :> o1 = hom b1
i2 :> o2 = hom b2
in 1:>0 <> (i1 `max` i2):>(o1 `min` o2)
REP p -> 1:>0
WHILE t b -> hom t <> 1:>0
PUT _ -> 1:>0
GET _ -> 0:>1
PUSH _ -> 0:>1
POP -> 1:>0
DUP -> 1:>2
SWAP -> 2:>2
EXCH -> 2:>3
INC -> 1:>1
DEC -> 1:>1
NEG -> 1:>1
_ -> 2:>1
```
Комбинаторы циклов имеют валентность, не зависящую от тела цикла, поскольку код тела при выполнении программы может не исполниться вовсе. А так как мы рассматриваем строгие требования, мы можем точно сказать, что гарантированно выполнится только проверка на вход в цикл.
Рассчитаем требования для некоторых программ (кроме рекурсивных):
```
λ> arity (exch <> exch)
2 :> 4
λ> arity fact1
1 :> 1
λ> arity range
2 :> 1
λ> arity (push 3 <> dup <> pow)
0 :> 1
```
Что ещё можно посчитать перед выполнением? Так как регистры памяти указываются статически, каждая программа "знает" какой объём памяти ей потребуется. Можно построить гомоморфизм `Program' a -> Max Int`, и при иниализации машины создавать область памяти нужного объёма. Он может быть построен, например, так:
```
memoryUse :: Program' a -> Max Int
memoryUse = hom . toCode
where
hom = foldMap $
\case
IF b1 b2 -> hom b1 <> hom b2
REP p -> hom p
WHILE t b -> hom t <> hom b
PUT i -> Max (i+1)
GET i -> Max (i+1)
_ -> 0
```
```
λ> memoryUse fact1
Max {getMax = 0}
λ> memoryUse fact3
Max {getMax = 1}
λ> memoryUse pow
Max {getMax = 2}
```
При конкатенации программ могут возникать конфликты с совместным использованием памяти. Это можно решить автоматически вводя соответствующие смещения для всех указываемых индексов, ведь на требования памяти доступны до выполнения программы.
Вычисление валентности позволяет провести простую, но эффектную оптимизацию: можно выделять максимально длинные непрерывные линейные отрезки программ, которые не требуют элементов на стеке перед выполнением, то есть, с валентностью `0:>_` и не задействуют память. Такие цепочки не зависят от текущих данных и могут быть вычислены заранее и заменены результатом на этапе трансляции. Обычно, это арифметические вычисления.
**Пример построения оптимизатора**
```
isReducible p = let p' = fromCode p
in case arity p' of
0:>_ -> memoryUse p' == 0
_ -> False
reducible = go [] . toCode
where go res [] = reverse res
go res (p:ps) = if isReducible [p]
then let (a,b) = spanBy isReducible (p:ps)
in go (a:res) b
else go res ps
-- здесь используется моноид Last, который комбинируется,
-- оставляя последний нетривиальный результат
spanBy test l = case foldMap tst $ zip (inits l) (tails l) of
Last Nothing -> ([],l)
Last (Just x) -> x
where tst x = Last $ if test (fst x) then Just x else Nothing
-- здесь используется моноид Endo комбинирующийся как эндоморфизм
-- функции intercalate и splitOn можно подгрузить из библиотек
-- Data.List и Data.List.Split
reduce p = fromCode . process (reducible p) . toCode $ p
where
process = appEndo . foldMap (\x -> Endo $ x `replaceBy` shrink x)
shrink = toCode . foldMap push . reverse . stack . exec . fromCode
replaceBy x y = intercalate y . splitOn x
```
Пример оптимизации простой программы:
```
λ> let p = push 6 <> fact1 <> swap <> push 5 <> dup <> push 14 <> gcd1 <> put 1
λ> toCode $ p
[PUSH 6,PUSH 1,SWAP,WHILE [DUP,PUSH 1,GTH]
[SWAP,EXCH,MUL,SWAP,DEC],POP,SWAP,PUSH 5,DUP,PUSH 14,WHILE
[EXCH,EXCH,NEQ] [EXCH,EXCH,LTH,IF [] [SWAP],EXCH,SUB],POP,PUT 1]
λ> toCode $ reduce p
[PUSH 720,SWAP,PUSH 5,PUSH 1,PUT 1]
λ> execLog logSteps (push 8 <> p)
VM {stack = [5,8,720], status = Nothing, memory = [0,1,0,0],
journal = Sum {getSum = 107}}
λ> execLog logSteps (push 8 <> reduce p)
VM {stack = [5,8,720], status = Nothing, memory = [0,1,0,0],
journal = Sum {getSum = 6}}
```
Оптимизация сократила число шагов нужных программе со 107 до 6.
Далее, от валентности можно перейти, скажем, к тройкам Хоара и формально верифицировать программы, выводя логические пред- и постусловия для работы линейных участков программ (для циклов придётся возиться инвариантами).
### От моноидов к монадам и снова к моноидам
Но что если нашей машине нужно выйти в мир эффектов: общаться с пользователем, с файловой системой, базой данных, случайными числами и т.д.? Можно ли наше решение оснастить монадическими вычислениями? Можно, хоть и придётся переписывать реализацию, но оно того стоит!
При использовании монады `m` преобразователи `VM -> VM` должны превратиться в `VM -> m VM`, это уже не эндоморфизм. Но вспомним крылатую фразу: *"Монада — это всего лишь моноид в категории эндофункторов, в чём проблема?!"* В категории Клейсли, которую образуют преобразователи `VM -> m VM` определена композиция, а она, согласно правилам категорий, ассоциативна и имеет нейтральный элемент. Эту композицию в Haskell обозначают оператором `>=>` и называют "рыбкой Клейсли". Значит, для выхода в мир вычислений с эффектами достаточно поменять начинку `Action` на моноид `ActionM`, определив его следующим образом:
```
newtype ActionM m a = ActionM { runActionM :: a -> m a }
instance Monad m => Semigroup (ActionM m a) where
ActionM f <> ActionM g = ActionM (f >=> g)
instance Monad m => Monoid (ActionM m a) where
mempty = ActionM return
```
Поменяются сеттеры, они должны стать монадическими, и везде вместо их композиции надо будет будет использовать оператор `>=>`. Все же прочие определения останутся без изменений.
**Стековая машина с монадическими вычислениями**
```
{-# LANGUAGE LambdaCase, GeneralizedNewtypeDeriving, TupleSections #-}
import Data.Monoid hiding ((<>))
import Data.Semigroup (Semigroup(..),stimes,Max(..))
import Data.Vector ((//),(!),Vector,toList)
import qualified Data.Vector as V (replicate)
import Control.Monad
import Control.Monad.Identity
type Stack = [Int]
type Memory = Vector Int
memSize = 4
data VM a = VM { stack :: Stack
, status :: Maybe String
, memory :: Memory
, journal :: a }
deriving Show
mkVM = VM mempty mempty (V.replicate memSize 0)
setStack x (VM _ st m l) = return $ VM x st m l
setStatus st (VM s _ m l) = return $ VM s st m l
setMemory m (VM s st _ l) = return $ VM s st m l
addRecord x (VM s st m l) = VM s st m (x<>l)
------------------------------------------------------------
data Code = IF [Code] [Code]
| REP [Code]
| WHILE [Code] [Code]
| PUT Int | GET Int
| PUSH Int | POP | DUP | SWAP | EXCH
| INC | DEC | NEG
| ADD | MUL | SUB | DIV | MOD
| EQL | LTH | GTH | NEQ
| ASK | PRT | PRTS String
| FORK [Code] [Code]
deriving (Read, Show)
newtype ActionM m a = ActionM {runActionM :: a -> m a}
instance Monad m => Semigroup (ActionM m a) where
ActionM f <> ActionM g = ActionM (f >=> g)
instance Monad m => Monoid (ActionM m a) where
ActionM f `mappend` ActionM g = ActionM (f >=> g)
mempty = ActionM return
newtype Program m a = Program { getProgram :: ([Code], ActionM m (VM a)) }
deriving (Semigroup, Monoid)
type Program' m a = (Code -> VM a -> m (VM a)) -> Program m a
program c f p = Program . ([c],) . ActionM $
\vm -> case status vm of
Nothing -> p c =<< f (stack vm) vm
m -> return vm
programM c f p = Program . ([c],) . ActionM $
\vm -> case status vm of
Nothing -> p c =<< f (memory vm, stack vm) vm
m -> return vm
run :: Monad m => Program m a -> VM a -> m (VM a)
run = runActionM . snd . getProgram
toCode :: Monad m => Program' m a -> [Code]
toCode prog = fst . getProgram $ prog none
none :: Monad m => Code -> VM a -> m (VM a)
none = const return
-- запуск программы вне монад
exec :: Program' Identity () -> VM ()
exec = runIdentity . execM
execM :: Monad m => Program' m () -> m (VM ())
execM prog = run (prog none) (mkVM ())
execLog p prog = run (prog $ \c -> \vm -> return $ addRecord (p c vm) vm) (mkVM mempty)
f &&& g = \c -> \r -> (f c r, g c r)
logStack _ vm = [stack vm]
logStackUsed _ = Max . length . stack
logSteps _ = const (Sum 1)
logCode c _ = [c]
logRun com vm = [pad 10 c ++ "| " ++ pad 20 s ++ "| " ++ m]
where c = show com
m = unwords $ show <$> toList (memory vm)
s = unwords $ show <$> stack vm
pad n x = take n (x ++ repeat ' ')
debug p = unlines . reverse . journal <$> execLog logRun p
------------------------------------------------------------
pop,dup,swap,exch :: Monad m => Program' m a
put,get,push :: Monad m => Int -> Program' m a
add,mul,sub,frac,modulo,inc,dec,neg :: Monad m => Program' m a
eq,neq,lt,gt :: Monad m => Program' m a
err m = setStatus . Just $ "Error : " ++ m
pop = program POP $
\case x:s -> setStack s
_ -> err "pop expected an argument."
push x = program (PUSH x) $ \s -> setStack (x:s)
dup = program DUP $
\case x:s -> setStack (x:x:s)
_ -> err "dup expected an argument."
swap = program SWAP $
\case x:y:s -> setStack (y:x:s)
_ -> err "swap expected two arguments."
exch = program EXCH $
\case x:y:s -> setStack (y:x:y:s)
_ -> err "expected two arguments."
put i = indexed (PUT i) i $
\case (m, x:s) -> setStack s <=< setMemory (m // [(i,x)])
_ -> err "put expected an argument"
get i = indexed (GET i) i $ \(m, s) -> setStack ((m ! i) : s)
indexed c i f = programM c $ if (i < 0 || i >= memSize)
then const $ err "index in [0,16]"
else f
app1 c f = program c $
\case x:s -> setStack (f x:s)
_ -> err $ "operation " ++ show c ++ " expected an argument"
app2 c f = program c $
\case x:y:s -> setStack (f x y:s)
_ -> err $ "operation " ++ show c ++ " expected two arguments"
add = app2 ADD (+)
sub = app2 SUB (flip (-))
mul = app2 MUL (*)
frac = app2 DIV (flip div)
modulo = app2 MOD (flip mod)
neg = app1 NEG (\x -> -x)
inc = app1 INC (\x -> x+1)
dec = app1 DEC (\x -> x-1)
eq = app2 EQL (\x -> \y -> if (x == y) then 1 else 0)
neq = app2 NEQ (\x -> \y -> if (x /= y) then 1 else 0)
lt = app2 LTH (\x -> \y -> if (x > y) then 1 else 0)
gt = app2 GTH (\x -> \y -> if (x < y) then 1 else 0)
proceed p prog s = run (prog p) <=< setStack s
rep body p = program (REP (toCode body)) go none
where go (n:s) = if n >= 0
then proceed p (stimes n body) s
else err "rep expected positive argument."
go _ = err "rep expected an argument."
branch br1 br2 p = program (IF (toCode br1) (toCode br2)) go none
where go (x:s) = proceed p (if (x /= 0) then br1 else br2) s
go _ = err "branch expected an argument."
while test body p = program (WHILE (toCode test) (toCode body)) (const go) none
where go vm = do res <- proceed p test (stack vm) vm
case (stack res) of
0:s -> proceed p mempty s res
_:s -> go =<< proceed p body s res
_ -> err "while expected an argument." vm
ask :: Program' IO a
ask = program ASK $
\case s -> \vm -> do x <- getLine
setStack (read x:s) vm
prt :: Program' IO a
prt = program PRT $
\case x:s -> \vm -> print x >> return vm
_ -> err "PRT expected an argument"
prtS :: String -> Program' IO a
prtS s = program (PRTS s) $
const $ \vm -> print s >> return vm
fork :: Program' [] a -> Program' [] a -> Program' [] a
fork br1 br2 p = program (FORK (toCode br1) (toCode br2)) (const go) none
where go = run (br1 p) <> run (br2 p)
------------------------------------------------------------
fromCode :: Monad m => [Code] -> Program' m a
fromCode = hom
where
hom = foldMap $ \case
IF b1 b2 -> branch (hom b1) (hom b2)
REP p -> rep (hom p)
WHILE t b -> while (hom t) (hom b)
PUT i -> put i
GET i -> get i
PUSH i -> push i
POP -> pop
DUP -> dup
SWAP -> swap
EXCH -> exch
INC -> inc
DEC -> dec
ADD -> add
MUL -> mul
SUB -> sub
DIV -> frac
MOD -> modulo
EQL -> eq
LTH -> lt
GTH -> gt
NEQ -> neq
NEG -> neg
_ -> mempty
fromCodeIO :: [Code] -> Program' IO a
fromCodeIO = hom
where
hom = foldMap $ \case
IF b1 b2 -> branch (hom b1) (hom b2)
REP p -> rep (hom p)
WHILE t b -> while (hom t) (hom b)
ASK -> ask
PRT -> ask
PRTS s -> prtS s
c -> fromCode [c]
fromCodeList :: [Code] -> Program' [] a
fromCodeList = hom
where
hom = foldMap $ \case
IF b1 b2 -> branch (hom b1) (hom b2)
REP p -> rep (hom p)
WHILE t b -> while (hom t) (hom b)
FORK b1 b2 -> fork (hom b1) (hom b2)
c -> fromCode [c]
```
В рамках такой модели вычислений можно определить две новых команды: для считывания данных из `stdin` или с клавиатуры и для вывода значения либо сообщения на печать.
```
ask, prt :: Program' IO a
ask = program ASK $
\case s -> \vm -> do x <- getLine
setStack (read x:s) vm
prt = program PRT $
\case x:s -> \vm -> print x >> return vm
_ -> err "PRT expected an argument"
prtS :: String -> Program' IO a
prtS s = program (PRTS s) $
const $ \vm -> print s >> return vm
```
Теперь можно написать что-то такое интерактивное и убедиться в том, что нам удалось совместить вычисления и эффекты:
```
ioprog = prtS "input first number" <> ask <>
prtS "input second number" <> ask <>
rep (prt <> dup <> inc) <>
prt
```
```
λ> exec ioprog
input first number
3
input second number
5
3
4
5
6
7
8
VM {stack = [8,7,6,5,4,3], status = Nothing, memory = [0,0,0,0], journal = ()}
```
Для организации неоднозначных вычислений достаточно определить комбинатор, разветвляющий поток:
```
fork :: Program' [] a -> Program' [] a -> Program' [] a
fork br1 br2 p = program (FORK (toCode br1) (toCode br2)) (const go) pure
where go = run (br1 p) <> run (br2 p)
```
Здесь опять сработала алгебра моноидов: функции `run` возвращают преобразователь `VM -> m VM`, их моноидальная композиция — функцию, возвращающую композицию преобразователей, но теперь уже в рамках монады `[]`, то есть — список вариантов.
Результатом работы разветвлённой программы будет список конечный состояний машины:
```
λ> stack <$> exec (push 5 <> push 3 <> add `fork` sub)
[[8],[2]]
λ> stack <$> exec (push 5 <> push 3 `fork` dup <> push 2)
[[2,3,5],[2,5,5]]
```
Посчитаем пример из начала статьи: :
```
λ> let pm = add `fork` sub
λ> stack <$> exec (push 2 <> push 3 <> push 4 <> push 8 <> pm <> push 5 <> pm <> pm <> mul)
[[40],[-28],[20],[-8],[8],[4],[-12],[24]]
```
А вот сравнение эффективности четырёх реализаций факториалов:
```
λ> journal <$> execLog logSteps (push 8 <> fact `fork` fact1 `fork` fact2 `fork` fact3)
[Sum {getSum = 48},Sum {getSum = 63},Sum {getSum = 34},Sum {getSum = 43}]
```
Записать выражение из четырёх ветвей вычислений без скобок нам позволило то, что программы образуют моноид с операцией `fork`, значит, операция `fork` ассоциативна.
Приятно что все базовые команды и комбинаторы сосуществуют вместе в одном модуле и склеиваются однотипно. Для всех типов вычислений работает отладка. Единственное ограничение состоит в том, что в нашей реализации невозможно комбинировать неоднозначные вычисления и ввод/вывод, однако, и это решается при помощи трансформеров монад.
С древне-греческого μάγμα переводится как грязь или тесто. Действительно, склеивая куски теста, мы вновь будем получать куски теста, которые можно склеивать. Это кажется более чем тривиальным наблюдением, но именно в этом заключается очарование пластилина или, например, конструктора Lego: благодаря универсальному интерфейсу соединение двух кубиков конструктора порождает новый кубик, готовый с кем-нибудь соединиться. С игрушками, соединяемыми липучками, например, так уже не получится.
Кубики Lego позволяют мастерить то, что даже не могло прийти в голову их создателям, в то время как многие конструкторы не допускают расширения модели — как на фабрике сделали, какую программу зашили, так и будет. И как ни соединяй, получится только то, что предусмотрено конструкцией либо неработающий хлам. С точки зрения защиты от дурака — это замечательно! Но если серьёзно, то суть и ценность функционального программирования состоит именно в богатстве и гибкости комбинирования. Функции при комбинировании могут образовывать новые функции, которые снова можно по-разному комбинировать. Десятками лет люди не перестают находить новые комбинации (это и продолжения и пресловутые монады и линзы-профункторы) с полезными, а иногда и восхитительными свойствами. Но самое главное — этот подход не прерогатива функционального программирования! В любой парадигме можно создавать жёсткие "одноразовые" блоки, громоздя из них фреймворки, требующие производства новых и новых блоков, поскольку они не комбинируются произвольным образом, либо создавать изящные расширяемые долгоживущие решения. Но именно в функциональной парадигме такие решения можно строить последовательно, доказывать и исследовать их свойства математически, оттачивать их прежде чем упаковывать в красивые и непрозрачные коробки и выпускать в мир технологий.
---
Все модули доступны в [репозитории](https://github.com/samsergey/monopig). Кое-какие цифры, отражающие производительность решения добавлены в комментарии. Самый важный результат — использование моноида в категории Клейсли открывает возможности для *существенного* увеличения скорости выполнения программ стековой машины, использующей память. Принцип построения программы при этом не меняется. | https://habr.com/ru/post/429530/ | null | ru | null |
# Использование R для «промышленной» разработки
Является продолжением [предыдущих публикаций](https://habrahabr.ru/post/341668/). Не секрет, что при упоминании R в числе используемых инструментов вторым по популярности является вопрос о возможности его применения в «промышленной разработке». Пальму первенства в России неизменно держит вопрос «А что такое R?»
Попробуем разобраться в аспектах и возможности применения R в «промышленной» разработке.
Что такое промышленная разработка ПО?
=====================================
Нисколько не удивляет, что под этим термином каждый понимает что-то свое. Начиная с «только C++» или «только java» и заканчивая «наличием плана продаж и роадмэпом на 10 лет вперед». Но без четкого определения термина дальше двигаться невозможно.
Поскольку однозначно устоявшегося определения нет, для ответа на поставленный вопрос соберем это понятие из совокупности внешних и внутренних присущих артефактов:
* **Артефакты с точки зрения менеджмента**. Промышленная разработка ПО: профессиональная занятость в сфере разработки ПО в организации или подразделении, основная цель которого – создание программного продукта. [Источник](https://www.slideshare.net/MikhailPayson/1-public)
* **Внутренние артефакты**. Совокупность команды, управленческих методологий, используемых инструментов и соглашений по методам разработки ПО, позволяющих в заданный срок выдавать ПО с требуемыми характеристиками по функциональности, надежности, производительности и эргономичности. Это определение построено на основе трудов различных известных людей: Д.Кнут, С.Макконнелл, К.Вигерс, М.Фаулер, Э.Хант, Ф.Брукс, К.Бек, Дж.Спольски и др.
По артефактам с точки зрения менеджера все понятно, но они слабо относятся к языку программирования. Внутренних артефактов набирается великое множество, но для многих из них совершенно неважно, на каком языке ведется разработка. В частности, при применении R могут использоваться из числа любимых/привычных
* система управления требованиями (методология и инструменты);
* система ведения проекта (методология и инструменты);
* система контроля версий;
* багтрекер
* пр.
Таким образом, основные претензии можно переформулировать в контексте надежности («ага, интерактивная работа в консоли это вам не 24x7, да и писали все для академических исследований!»). Замечание в целом верное, но по слегка устаревшим данным. По факту в R в настоящее время сформирован набор пакетов и подходов, которые позволяют легко и элегантно делать приложения и в формате 24x7. Поэтому далее сфокусируемся на наиболее интересных моментах в задаче обеспечения надежности разрабатываемого ПО:
* поддержка различных парадигм программирования;
* отладка;
* статический анализ кода;
* логирование и анализ во время исполнения;
* функциональное и юнит тестирование;
* пакетирование и автоматизированная сборка;
* система генерации документации.
Отчасти эти моменты пересекаются с областью [«defensive programming»](https://en.wikipedia.org/wiki/Defensive_programming).
Также не следует забывать, что R — высокоуровневый язык, ориентированный на решение задач по манипуляции с данными и обладающий широким набором проверенных библиотек (пакетов). Содержательная часть решения даже весьма сложных задач может занимать всего лишь несколько сотен строчек кода. Для более крупных проектов желательно использование механизма пакетирования, позволяющего структурировать код путем формирования собственных библиотек (пакетов).
Поддержка различных парадигм программирования
---------------------------------------------
Существующий набор пакетов, дополняет и расширяет возможности base-R не только в части математических алгоритмов, но и в части парадигм разработки. Вынося за скобки вселенную [tidyverse](https://www.tidyverse.org), имеет смысл упомянуть два пакета, расширяющих реализацию ООП и функционального программирования:
* Система R6 классов. Детально ознакомиться с реализацией ООП на базе R6 можно по видео с конференции [UseR! 2017. The R6 Class System](https://user2017.sched.com/event/Axp8), [Video](https://channel9.msdn.com/Events/useR-international-R-User-conferences/useR-International-R-User-2017-Conference/The-R6-Class-System) и естественно, на сайте [CRAN](https://cran.r-project.org/web/packages/R6/). Там же можно почитать про сравнение характеристик по производительности по сравнению со штатной системой классов S3.
* Функциональный подход. Пакет [lambda.r](https://cran.r-project.org/web/packages/lambda.r/index.html) реализует парадигму функционального программирования.
Если говорить о функциональном подходе, то реализация отдельного набора элементов такого подхода в пакете [`purrr`](http://purrr.tidyverse.org/) в совокупности с pipe оператором [`%>%`](https://cran.r-project.org/web/packages/magrittr/vignettes/magrittr.html) позволяет на практике очень сильно упростить и обезопасить обработку данных с существенным сокращением требуемого для этого объема кода. В качестве старта можно ознакомиться с хорошим докладом на эту тему: [Happy R Users Purrr – Tutorial](https://www.rstudio.com/resources/videos/happy-r-users-purrr-tutorial/)
Отладка
-------
В дополнение к классическим инструментам отладки, хорошо описанным в статье [«Debugging with RStudio»](https://support.rstudio.com/hc/en-us/articles/205612627-Debugging-with-RStudio) я бы упомянул следующие небесполезные инструменты:
* Функция [`DebugFnW()` из пакета `wrapr`](https://github.com/WinVector/wrapr) для сохранения окружения в случае падений внутри функции. [Ссылки на видео](https://youtu.be/zFEC9-1XSN8?list=PLAKBwakacHbQT51nPHex1on3YNCCmggZA) по этому инструменту можно найти в [кратком описании](https://cran.r-project.org/web/packages/wrapr/vignettes/DebugFnW.html) к пакету.
* Пакет [`listviewer`](https://cran.r-project.org/web/packages/listviewer/index.html) для интерактивного анализа иерархических объектов. Виджет базируется на коде [`jsoneditor`](https://github.com/josdejong/jsoneditor).
* Пакет [`diffobj`](https://cran.r-project.org/web/packages/diffobj/vignettes/diffobj.html) для визуального сравнения различных объектов.
Статический анализ кода
-----------------------
Тут все достаточно просто. Наиболее популярный инструмент — [lintr@CRAN](https://cran.r-project.org/web/packages/lintr/index.html) или [lintr@github](https://github.com/jimhester/lintr).
Lintr интегрируется с RStudio IDE, чтобы не повторяться, детали можно посмотреть в ветке [Lintr integration with RStudio](https://community.rstudio.com/t/lintr-integration-with-rstudio/1807).
Логирование и анализ во время исполнения
----------------------------------------
### Логирование
Логирование процесса исполнения ПО в логически значимых точках хоть и добавляет накладные расходы, но будучи организованным правильным образом существенным образом упрощает задачу обеспечения последующей технической поддержки разработанного ПО. С учетом высокоуровневости R и компактности кода, даже постоянно включенное логирование не является накладным по ресурсам.
Для задачи логирования наиболее удобен пакет [futile.logger](https://cran.rstudio.com/web/packages/futile.logger/index.html). Семантика log4j многим известна и не требует изучения нового. Из полезно-удобных дополнений/расширений я бы выделил следующие:
1. Конфигурация логгера в форме `flog.appender(appender.tee(log_name))` позволяет включать одновременный вывод и в файл и в консоль.
2. Для формирования сложных строк, содержащих значения переменных, вместо `base::paste` гораздо удобнее использовать `glue::glue`. Например, строка `paste0(" FROM", ch_db$table, "WHERE ", where_string, sep=" ")` превращается в одну форматную строку `glue(" FROM {ch_db$table} WHERE {where_string}")`. С учетом векторизации glue печать табличной выборки также превращается в одну строчку. Детали можно посмотреть в анонсе [glue 1.2.0](https://www.tidyverse.org/articles/2017/10/glue-1.2.0/)
3. Для вывода сообщений, выдаваемых функциями в stdout можно использовать функцию `capture.output(fun...)`.
4. Для вывода времени исполнения блока команд весьма удобно использовать функции `tic()`, `toc()` из пакета [tictoc](https://cran.r-project.org/package=tictoc). При этом финализирующую функцию сразу включать в логгер в форме такой конструкции: `flog.info(glue("Data query response time: {capture.output(toc())}"))`
### Real-time валидация
В целом, особенно в языках с динамической типизацией, правилом хорошего тона является проверка данных, поступающих на обработку в ту или иную функцию. По-хорошему, проверку следует разделить на два этапа: физическая проверка (данные требуемого типа) и логическая проверка (содержание данных правильного типа также следует установленным требованиям). Время на исполнение логической проверки может быть на порядки больше, нежели на физическую. Элементарный пример — на этапе физической проверки мы смотрим, что на вход пришел вектор чисел с плавающей точкой, а на этапе логической проверки смотрим, что все элементы вектора неотрицательны.
В R для этого все есть и даже с весьма неплохим выбором. Упомяну только самые интересные и перспективные пакеты. [`checkmate`](https://cran.r-project.org/web/packages/checkmate/index.html) для физической проверки и [`assertr`](https://cran.r-project.org/web/packages/assertr/index.html), [`validate`](https://cran.r-project.org/web/packages/validate/index.html) для логической.
Приятно, что в отличие от `assertive`, реализация `checkmate` изначально ориентирована на скорость и минимальный оверхед, о чем можно прочесть в публикации [«checkmate: Fast Argument Checks for Defensive R Programming»](https://arxiv.org/abs/1701.04781).
Ну и возможность написания компактных правил валидации в стиле regexp средствами [`qassert`](https://mllg.github.io/checkmate/reference/qassert) очень радует, поскольку позволяет свернуть типичную функцию проверки на 2 строки до строки в несколько символов.
В части логической проверки — тут каждый может выбрать удобный ему способ. Все зависит от того, какие рода данные, идет ли обработка независимо или в конвейере (pipe), что именно нужно проверять.
В зависимости от того, что требуется по логике программы, можно либо делать проверку на соответствие условиям с получением `TRUE/FALSE` и последующим ветвлением логики, либо генерировать exception (assert).
### Обработка исключений
Механизм генерации исключений несомненно полезен при работе с данными, а подробный вывод сопутствующей информации как нельзя кстати при интерактивной работе в консоли. Однако при переходе к потоковому исполнению останов программы при возникновении ошибки совершенно не нужен, а разнообразие в способах формирования диагностических сообщений начинает утомлять при создании обработчиков.
Обработка исключений штатными механизмами `tryCatch` хорошо [описана](http://adv-r.had.co.nz/Exceptions-Debugging.html) в книге [«Advanced R»](http://adv-r.had.co.nz). Более интересным и полезным применительно к обработке данных в программном режиме является два следующих расширения:
* обработка исключений без останова конвейера (pie);
* унификация ответов от функций.
И тот и другой функционал реализован в пакете `purrr` семейством функций-оберток `safely`. Получение от любой функции стандартизованного списка с полями error/result позволяет не прерывать потоковую обработку, а обработать возникшие исключения и ошибки после завершения конвейера. Вовсе нет необходимости всегда бить в колокол и поднимать исключение, если в ходе обработки вектора возникло деление на 0. Достаточно пометить некорректный элемент и перейти к следующему. Такая инкапсуляция обработки исключений позволяет вместо нескольких десятков строк кода, призванных учету непредвиденных ситуаций при обработке данных свести все к одной обертке. Меньше код, меньше избыточной вариативности — стабильней результат.
Хорошо и кратко возможности по использованию `safely` были описаны в блоге RStudio: [purrr 0.2.0 by Hadley Wickham](https://blog.rstudio.com/2016/01/06/purrr-0-2-0/) + документация.
Функциональное и юнит тестирование
----------------------------------
Пакет [`testthat`](https://cran.r-project.org/web/packages/testthat/index.html). Изучение можно начать со статьи [«testthat: Get Started with Testing»](https://journal.r-project.org/archive/2011-1/RJournal_2011-1_Wickham.pdf), продолжить CRAN и книгами [Hadley Wickham](http://hadley.nz/), а также книгой [«Testing R Code»](https://www.crcpress.com/Testing-R-Code/Cotton/p/book/9781498763653). С учетом положений, упомянутых выше, я бы перекладывал при чтении функции из `assertive` на функции из пакета `checkmate`. Автотесты можно писать как для пакетов, так и для отдельных функций.
Пакетирование и автоматизированная сборка
-----------------------------------------
Просто констатируем, что есть но не все об этом знают. Сборка, валидация, документирование, проверка и пр., все интегрировано RStudio IDE. Кратко охвачено в статье [«Building, Testing, and Distributing Packages»](https://support.rstudio.com/hc/en-us/articles/200486508-Building-Testing-and-Distributing-Packages). Досконально все описано в отличной книге Hadley Wickham: [«R packages»](http://r-pkgs.had.co.nz/). Полезным может оказаться применение хелпер-пакета [`usethis`](https://github.com/r-lib/usethis)
Также есть пакет [`packrat`](https://rstudio.github.io/packrat/) позволяющий сформировать снапшот пакетов, необходимых для работы конкретного приложения. Тем самым обеспечивается независимость среды функционирования ПО от пакетов, установленных в системе.
Система генерации документации
------------------------------
Просто констатируем, что есть для пакетов, но не все об этом знают. Построена на базе roxygen, интегрировано с RStudio IDE.
Досконально все описано в отличной книге Hadley Wickham: [«R packages»](http://r-pkgs.had.co.nz/).
Заключение
==========
Сейчас R очень активно развивается. Каждую неделю появляются новые полезные функции, пакеты, подходы или улучшаются существующие. В задачах, связанных с обработкой данных указанный в публикации набор пакетов позволяет писать на R быстрый, стабильный, компактный и прогнозируемый код. Год назад этих пакетов было меньше, что будет в конце 2018 — время покажет.
В такой ситуации делать заключения о возможности или невозможности применения языка и платформы на основании данных двух и более летней давности некорректно. Как минимум, надо ознакомиться с текущим состоянием.
Что касается скорости, то, как всегда, этот вопрос относителен. 2 дня разработки + 10 секунд на исполнение на R много меньше, чем 2 недели разработки + 0.1 секунда на исполнение, например, на Java. О скорости необходимо говорить в контексте. Для функций, требующих быстроты исполнения, есть возможность реализовать ее на C++ не выходя за границы R путем применения пакета [Rcpp](http://www.rcpp.org/). С кратким обзором возможностей можно ознакомиться также в одной из статей автора: [«Extending R with C++: A Brief Introduction to Rcpp»](https://peerj.com/preprints/3188/).
Задач по разнообразной обработке данных (от сбора до визуализации) становится все больше. Почему бы не взглянуть в сторону R?
Предыдущая публикация — [«R, Asterisk и платяной шкаф»](https://habrahabr.ru/post/341668/). | https://habr.com/ru/post/342254/ | null | ru | null |
# Фильтрация запросов на уровне DNS
Начиная с версии 9.8.1 DNS-сервера bind появилась новая возможность — DNS RPZ. Это интересный инструмент, который может оказаться весьма полезным для многих сисадминов. Странно, но в русскоязычном сегменте интернета эта тема совершенно не освещена. Спешу восполнить этот пробел.
#### Что это за зверь и с чем его едят?
Аббревиатура RPZ означает response policy zone — зона с политикой ответов. Это технология, разработанная ISC, которая предоставляет опрераторам связи простой способ блокирования DNS-запросов к некоторым ресурсам или перенаправления их на альтернативный адрес. RPZ — это зона, которая может передаваться между серверами (DNS AXFR/IXFR), защищена подписями транзакций (DNS TSIG) и обновляется в режиме реального времени (DNS NOTIFY).
#### Формат зоны
Как и для любой другой DNS-зоны, требуется SOA-запись и, как минимум, одна NS-запись. SOA — действительная, имеющая серийный номер и таймеры запись, используемая для делегирования зоны и указывающая времени жизни записей (TTL). NS-запись никогда не используется и служит для совместимости. Обычно, единственная NS-запись имеет фиктивное значение localhost. Остальная часть зоны — это выражения для DNS-политик. Политики могут применяться к именам доменов или к их шаблонам.
#### Как работает
Упрощенно работу RPZ можно представить следующей схемой:
В правой части показана схема работы с обычным кеширующим DNS-сервером, который возвращает клиенту все ответы от коневых серверов, как есть. В случае с RPZ появляется Security Policy Provider (провайдер политик безопасности) — DNS-сервер с которого мы берем политики разрешения доменных имен. Наличие стороннего провайдера совершенно не обязательно, мы можем сами задать свои локальные политики. Об этом чуть позже, в примерe.
Провайдеров может быть несколько, в том числе мы можем создать свой собственный сервер RPZ:
Более подробно о работе протокола можно прочитать в официальной документации (ссылки ниже) — думаю, те, кому нужны детали, осилят ее самостоятельно.
Покажем работу RPZ на примере рабочих конфигов. Здесь подразумевается что у вас уже есть настроенный DNS-сервер, я лишь покажу опции, которые нужно включить, чтобы все заработало. Действо разворачивается в Ubuntu 12.10.
Сперва в файле /etc/bind/named.conf.options опцией «response-policy» включаем RPZ:
```
response-policy {
zone "rpz.zone";
};
```
Внутри «response-policy» зон может быть несколько, причем у каждой может быть своя политика (подробности см. в спецификации).
В файле /etc/bind/named.conf.local помещаем описание зоны:
```
zone "rpz.zone" {
type master;
file "/etc/bind/db.rpz.zone";
allow-query {any;};
allow-update {none;};
};
```
И, наконец, сама зона (файл /etc/bind/db.rpz.zone):
```
;RPZ
$TTL 10
@ IN SOA rpz.zone. rpz.zone. (
5;
3600;
300;
86400;
60 )
IN NS localhost.
vk.com CNAME habrahabr.ru.
*.gov.by CNAME .
gov.by MX 0 gmail.com.
*.blabla.com A 1.2.3.4
*.xxx A 127.0.0.1
1.by CNAME abcde-net.by.
```
Применяем новые настройки:
```
sudo rndc reload
```
и смотрим, что у нас вышло:
```
dig vk.com
; <<>> DiG 9.8.1-P1 <<>> vk.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 11880
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;vk.com. IN A
;; ANSWER SECTION:
vk.com. 10 IN CNAME habrahabr.ru.
habrahabr.ru. 466 IN A 212.24.43.44
;; Query time: 0 msec
;; SERVER: 192.168.3.204#53(192.168.3.204)
;; WHEN: Thu Apr 25 00:56:49 2013
;; MSG SIZE rcvd: 66
```
Как видно из ответа сервера, адрес подменен на habrahabr.ru.
В браузере увидим следующее:
Разумеется, мы можем сделать подмену на свой внутренний сервер, который, например, будет сообщать клиенту, что доступ на запрошенный домен запрещен политикой безопасности.
```
dig gov.by
; <<>> DiG 9.8.1-P1 <<>> gov.by
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10961
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;gov.by. IN A
;; AUTHORITY SECTION:
rpz.zone. 10 IN SOA rpz.zone. rpz.zone. 8 3600 300 86400 60
;; Query time: 11 msec
;; SERVER: 192.168.3.204#53(192.168.3.204)
;; WHEN: Thu Apr 25 00:59:18 2013
;; MSG SIZE rcvd: 68
```
Здесь запрос остался без ответа. То же самое произойдет с любым поддоменом gov.by:
Нетрудно догадаться, что все субдомены домена blabla.com будут подменены на адрес 1.2.3.4, а все домены зоны xxx будут заменены на localhost.
Последнюю строчку зоны поясню отдельно. Являясь мелким провайдером в провинциальном городке, часто сталкиваемся с проблемой совершенно тугих юзеров, для которых набрать адрес нашей домашней странички является непосильной задачей (а это отправная точка для всех наших внутренних ресурсов).
Дело порой доходит до комических случаев, когда техподдержка бьется в истерике головой об стол. Именно для этого была создана эта запись. Клиенту достаточно набрать в адресной строке браузера «1.by» (без кавычек), и он попадает туда, куда нужно:
А чтобы подобное безобразие не мозолило глаз более-менее грамотным пользователям, средствами веб-сервера (RewriteRule в Apache) хост «1.by» перенаправляется на валидный адрес сервера.
Ссылки:
[ftp.isc.org/isc/dnsrpz/isc-tn-2010-1.txt](ftp://ftp.isc.org/isc/dnsrpz/isc-tn-2010-1.txt)
[kb.isc.org/category/110/0/10/Software-Products/BIND9/Features/DNSRPZ](https://kb.isc.org/category/110/0/10/Software-Products/BIND9/Features/DNSRPZ/) | https://habr.com/ru/post/177649/ | null | ru | null |
# Публичные свойства, геттеры и сеттеры или магические методы?
Как правило, мнения расходятся касательно того, хорошей ли практикой является использование публичных свойств в PHP классах или всё же стоит использовать геттеры и сеттеры (и хранить свойства приватными или защищёнными). Ещё одно, компромиссное мнение, состоит в том, чтобы использовать магические методы `__get()` и`__set()`.
У каждого из подходов существуют свои достоинства и недостатки, давайте взглянем на них…
**Пример использования публичных свойств:**
```
class Foo
{
public $bar;
}
$foo = new Foo();
$foo->bar = 1;
$foo->bar++;
```
В данном примере *bar* является публичным свойством класса *Foo*. При таком подходе мы можем манипулировать данным свойством как угодно и хранить в нём любые данные.
**Достоинства публичных свойств**
* По сравнению с геттерами и сеттерами, нужно печатать на много меньше текста!
* Код выглядит более читабельным и работать с ним проще, чем с вызовами геттеров и сеттеров.
* Вызов публичного свойства (вместо `set` или `get`) работает быстрее и использует меньше памяти чем вызов метода, но выгода от этого будет почти незаметной до тех пор, пока вы не будете вызывать метод множество раз в длинном цикле.
* Объекты с публичными свойствами могут использоваться в качестве параметров для некоторых PHP функций (таких как `http_build_query`).
**Недостатки публичных свойств**
* Нет возможности осуществлять контроль за тем, какие именно данные содержатся в свойствах — их очень легко заполнить данными, некорректными для методов этого класса. Например, если класс будет использоваться сторонним разработчиком, отличным от автора класса, то могут возникать проблемы связанные с тем, что он может быть не в курсе (да он и не обязан) внутреннего устройства класса. В конце концов, ни для кого не секрет, что зачастую по прошествии несколько месяцев даже сам автор забывает логику написанного им кода.
* Если вы хотите использовать публичные свойства в API, то этого нельзя будет сделать используя интерфейс, так как в PHP интерфейсы допускают только определения сигнатур методов.
**Пример использования геттеров и сеттеров:**
```
class Foo
{
private $bar;
public function getBar()
{
return $this->bar;
}
public function setBar($bar)
{
$this->bar = $bar;
}
}
$foo = new Foo();
$foo->setBar(1);
$foo->setBar($foo->getBar() + 1);
```
Свойство `bar` тут является приватным, в связи с этим, доступ к нему не может быть получен напрямую. Для того, чтобы получить значение свойства, вам придётся использовать метод `getBar`, или `setBar` для присвоения свойству значения. Чтобы вы могли быть уверенны в том, что входные данные полностью корректны, данные методы могут включать в себя соответствующий функционал для их валидации.
**Достоинства геттеров и сеттеров**
* Используя геттеры и сеттеры вы можете осуществлять контроль за тем, какие именно данные содержатся в свойствах объекта, и отклонять любые некорректные значения.
* Так же вы можете осуществлять дополнительные операции перед тем, как установить или получить значение свойства (например, если обновление данного свойства должно вызывать некоторое действие, такое как оповещение пользователя).
* При установке значения, которое является объектом или массивом, вы можете явно указать тип переменной в сигнатуре функции(прим. `public function setBar(Bar $bar)`). К большому сожалению, PHP не позволяет проделывать тоже самое с типами `int` и `string`!
* Если значение свойства должно получаться из внешнего источника или среды исполнения, вы можете использовать ленивую загрузку данных — таким образом ресурсы, требуемые для загрузки данных, будут задействованы непосредственно во время получения значения свойства. Разумеется, в данном случае нужно соблюдать осторожность, и не следует получать данные из внешнего источника при каждом обращении к свойству. Будет лучше сделать одно обращение к базе данных и заполнить значения всех свойств сразу, чем делать это для каждого в отдельности.
* Вы можете сделать свойство доступным только на чтение или только на запись, путём создания только геттера или только сеттера.
* Вы можете добавить геттеры и сеттеры в интерфейс для того, чтобы отобразить их в API.
**Недостатки геттеров и сеттеров**
* Для разработчиков, которые используют прямой доступ к свойствам, геттеры и сеттеры кажутся настоящей головной болью! Для каждого свойства нужно определить само свойство, геттер и сеттер; и для того чтобы использовать данное свойство в коде, нужно осуществлять дополнительные вызовы метода — намного легче написать `$foo->bar++;` вместо `$foo->setBar($foo->getBar() + 1);` (хотя, конечно, можно добавить ещё один метод `$foo->incrementBar();`)
* Как уже отмечалось выше, существуют небольшие дополнительные расходы, затрачиваемые на вызов метода.
* Имена геттеров и сеттеров принято начинать с глаголов `get` и `set`, но данные глаголы так же могут использоваться и в других методах, которые ни коим образом не относятся к свойствам класса.
**Пример использования магических геттеров и сеттеров:**
```
class Foo
{
protected $bar;
public function __get($property)
{
switch ($property)
{
case 'bar':
return $this->bar;
//etc.
}
}
public function __set($property, $value)
{
switch ($property)
{
case 'bar':
$this->bar = $value;
break;
//etc.
}
}
}
$foo = new Foo();
$foo->bar = 1;
$foo->bar++;
```
В данном случае свойство `bar` не является публичным, однако в коде оно используется так, как если бы было публичным. Когда PHP не может найти соответствующего публичного свойства он вызывает соответствующий магический метод (`__get()` для получения значения, `__set()` для установки значения). Данный подход может показаться золотой серединой, но у него есть существенный недостаток (см. недостатки ниже!). Следует также отметить, что `__get()` и `__set()` методы НЕ вызываются для публичных свойств, и вызываются в случае, если свойство помечено как `protected` или `private` и находится за пределами области видимости, или если свойство не определено.
**Достоинства магических геттеров и сеттеров**
* Вы можете манипулировать свойствами напрямую (как если бы они были публичными) и сохраняете полный контроль над тем, какие данные хранятся в каких свойствах.
* Аналогично использованию обычных геттеров и сеттеров, вы можете осуществлять дополнительные операции, когда свойство используется.
* Вы можете использовать ленивую загрузку данных.
* Вы можете сделать свойства доступными только на чтение или только на запись.
* Вы можете использовать магические методы для перехвата всех вызовов к свойствам, которые не были определены и обрабатывать их некоторым образом
**Недостатки магических геттеров и сеттеров**
* Недостатком магических методов является то, что они не делают свойство доступным(«видимым»). Для того чтобы использовать или расширить класс, вам необходимо «просто знать» какие свойства он содержит. В большинстве случаев это невозможно (если только вы не один из хардкорных программистов, которые думают что notepad является IDE!), хотя бывают случаи, когда упомянутые выше преимущества, перевешивают это ограничение. Как заметил один из комментаторов, этот недостаток может быть устранён использованием phpDoc тегов `@property`, `@property-read`, и `@property-write`. Круто.
**Какой подход использовать**
Очевидно, что у геттеров и сеттеров есть ряд существенных преимуществ, и некоторые люди считают, что их стоит использовать всё время (особенно те, у кого прошлое связано с `Java`!). Но на мой взгляд, этим они нарушают естественное развитие языка, и их излишняя сложность и детализация принуждают меня работать с этим, даже если в этом нет надобности (меня раздражает, когда обычные геттеры и сеттеры НЕ делают ничего, кроме получения и установки свойства). В таких случаях я стараюсь использовать публичные свойства, а геттеры и сеттеры я использую для критических свойств, которые необходимо более строго контролировать, или если в них необходимо использовать отложенную загрузку данных.
**Другие альтернативы?**
До изучения PHP я использовал C#. В C# все свойства имеют методы доступа, но вам не нужно вызывать их как методы, вы можете манипулировать свойсвами напрямую и соответствующие методы будут вызываться магически. Это в некотором роде это похоже на магические методы `__get()` и `__set()` в PHP, однако свойства остаются определены и доступны. Это золотая середина и было бы очень хорошо увидеть аналогичную возможность в PHP.
Печально, но, RFC необходимый для реализации C# подобного синтаксиса определения методов доступа к свойствам не набрал необходимых две трети голосов: [wiki.php.net/rfc/propertygetsetsyntax-v1.2](https://wiki.php.net/rfc/propertygetsetsyntax-v1.2) Вот так! | https://habr.com/ru/post/197332/ | null | ru | null |
# Кластеризация nodejs web-сервера с помощью node-clusterize-cli
Последние полгода я занимаюсь разработкой достаточно большого web-приложения, под капотом которого ревет и дымится NodeJS. Когда дело дошло до деплоя на продакшн я задумался: «почему бы мне не использовать несколько тредов с инстансом приложения?».
Реализовав кластер, я увидел, что производительность от его использования возросла [в 1,5 раза](https://gist.github.com/shuvalov-anton/8399476), что очень даже не плохо, учитывая малый объем потраченных усилий. Но я решил не останавливаться на этом, и сделать удобный CLI для работы с кластером, чтобы отвязать код, который отвечает за запуск кластера от конкретного приложения. Кроме того, очень хотелось демонизировать кластер, чтобы он висел себе молча в процессах, поднимал упавшие воркеры, писал в логи, и никого больше не отвлекал.
Так появился [node-clusterize-cli](https://github.com/shuvalov-anton/node-clusterize-cli) — утилита работающая из командной строки, не затрагивающая кода приложения. Основанная на оригинальном модуле «cluster» NodeJS.
##### Механизм работы
Модуль устроен просто — для начала он запускает мастер-процесс, в котором стартует то количество воркеров, которое вам необходимо (по-умолчанию, по два процесса на ядро), а затем отвязывает мастер-процесс от CLI интерфейса и оставляет его работать аки демона. Кроме того, мастер-процесс слушает сообщения об ошибках, которые могут произойти в воркерах, и автоматически перезапускает павших товарищей. За то, чтобы каждый запрос обрабатывался случайным процессом отвечает модуль из API NodeJS под названием «cluster».
##### Использование
В общем-то, все банально:
```
# Установка глобального модуля
$ npm i -g node-clusterize-cli
# Запуск кластера
$ clusterize --app ./app.js --workers 32 --log ./cluster.log
```
Так же, для удобства есть метод для получения списка запущенных кластеров, и метод для их убийства:
```
# фактически, алиас `ps -eo pid,comm | grep "clusterize master"`
$ clusterize list
53416 app.js
# алиас на `kill -9 CLUSTER_PID`
$ clusterize kill 53416
```
Подробнее можно посмотреть в подсказке — `clusterize -h` и readme на GitHub.
[репозиторий на GitHub](https://github.com/shuvalov-anton/node-clusterize-cli)
[Логи нагрузочных тестов ab](https://gist.github.com/shuvalov-anton/8399476) | https://habr.com/ru/post/208914/ | null | ru | null |
# Китайская ошибка роутинга трафика России
В сентябре прошлого года третий по размеру российский мобильный оператор «Вымпелком» и China Telecom [подписали](http://www.comnews.ru/node/76819) соглашение о прямом присоединении сетей международной и междугородной связи и установлении межсетевого взаимодействия, сумма этого контракта составила 2,2 млн. долларов. Целью этой сделки для российской стороны было достижение Дальнего Востока.
За последний год китайский телеком-оператор несколько раз пробовал поиграть в Ивана Сусанина. Об этом подробно [пишет](http://research.dyn.com/2014/11/chinese-routing-errors-redirect-russian-traffic/) Дуг Мэдори в в блоге компании DynResearch.
В переводе с языка обычных людей на язык специалистов заключённая сделка означает, что две компании согласились делиться информацией о динамической маршрутизации по протоколу BGP. И как это часто случается в подобных ситуациях, одна из сторон может выдать данные о маршрутизации от других провайдеров, что поставит её линии связи на пути трафика второй компании. Конкретно с этими двумя компаниями это происходило уже более десятка раз за прошедший год. Это явление случается, но его слабо описывают в литературе по BGP.
Вообще, пиринг BGP — это частое явление в мире крупных сетевых провайдеров, и у этого действия есть несколько смыслов. Конкретно в данном случае под ним понимается маршрутизация таким образом, при которой обмен трафиком происходит свободно, без оплаты его одной из сторон. Без транзитного провайдера можно сильно сэкономить, пусть даже и тратя средства на обслуживания этих пиринговых схем.
В любом случае, информация о маршрутизации, полученная одним из провайдеров от другого по договору о пиринге, обычно остаётся внутри сети этого оператора. В примере ниже провайдер A шлёт информацию о маршрутизации данных его клиентов провайдеру B, в результате чего трафик от клиентов провайдера B идёт через пиринговое соединение клиентам провайдера A. Это нормальный режим работы.
Что-то пойти не так может несколькими различными способами. Провайдер B может взять маршруты от провайдера A и выслать их другим провайдерам, как это показано ниже. Таким образом, провайдер B ставит себя на пути внешнего трафика, предназначенного для провайдера A.
Если провайдер B предоставит маршрут, полученный от провайдеров, к которым он имеет подключение, провайдеру A, то трафик последнего будет идти по этим путям через провайдера B, пусть даже обычно он не должен идти через провайдера B.
В отличие от других крупных и хорошо известных происшествий, описанные выше ситуации могут случаться часто, а их появление не вызывает такого всплеска внимания. Растёт отклик и меняются маршруты пакетов, а это труднее заметить, чем полное отсутствие сети, поэтому эти проблемы могут оставаться нерешёнными продолжительное время. В любом случае, трафик идёт не туда, куда должен, что отрицательно воздействует на производительность сетей и безопасность информации.
Итак, за последний год неверная информация о маршрутизации от China Telecom несколько раз попадала в сети «Вымпелкома». Такое произошло, к примеру, 5 августа этого года, когда China Telecom (AS4134) ненадолго предоставила «Вымпелкому» почти всю свою BGP-таблицу (326 622 записи), что привело в резкому росту отклика для пользователей российских провайдеров. Ещё бы — только на путешествие из России в Китай нужно примерно 120 мс. Маршрутизация даже внутри России осуществлялась через сети China Telecom.
Так выглядел результат traceroute: информация начинала свой путь в Вирджинии (США), затем она отправлялась в Калифорнию по сетям NTT, где её передавали China Telecom. Оттуда она шла в Шанхай, а затем в Франкфурт и лишь потом в Россию, в Омск.
**Скрытый текст**`trace from Reston, VA to Omsk, Russia at 12:00 Aug 05, 2014`
`1 *`
`2 129.250.204.153 (NTT America, Ashburn, US) 1.010ms`
`3 129.250.4.40 (NTT America, Ashburn, US) 0.934ms`
`4 *`
`5 129.250.5.13 (NTT America, San Jose, US) 74.649ms`
`6 129.250.8.6 xe-0.chinanet.snjsca04.us.bb.gin.ntt.net 70.909ms`
`7 202.97.90.33 (China Telecom, San Jose, US) 71.451ms`
`8 202.97.58.237 (China Telecom, Shanghai, CN) 341.819ms`
`9 202.97.58.66 (China Telecom, Frankfurt, DE) 641.424ms`
`10 118.85.204.58 (China Telecom, Frankfurt, DE) 608.965ms`
`11 79.104.245.250 pe-r.Omsk.gldn.net 632.054ms`
`12 195.239.162.178 (Vimpelcom, Omsk, RU) 687.536ms`
`13 89.179.76.25 vpn2-gi0-0.omsk.corbina.net 682.153ms`
`14 128.73.155.213 128-73-155-213.broadband.corbina.ru 707.525ms`
Для более наглядной иллюстрации ненормальности этой ситуации посмотрим на traceroute «Вымпелкома» до Германии. Трафик идёт от сетей «Вымпелкома» во Франкфурт, затем входит в сети China Telecom, которые доставляют его в Шанхай прежде, чем отдать Chello Broadband, который имеет договор пиринга с China Telecom в Лос-Анджелесе. Затем Chello Broadband уводит его в Нью-Йорк, оттуда опять в Франкфурт и лишь потом в Германию. За полсекунды трафик как минимум один раз огибает земной шар.
**Скрытый текст**`trace from Moscow, Russia to Marburg an der Lahn, Germany at 14:29 Aug 05, 2014`
`1 *`
`2 194.154.89.125 (Vimpelcom, Moscow, RU) 0.908ms`
`3 79.104.235.74 mx01.Frankfurt.gldn.net 40.695ms`
`4 118.85.204.49 beeline-gw2.china-telecom.net 48.799ms`
`5 202.97.58.61 (China Telecom, Shanghai, CN) 290.810ms`
`6 202.97.58.202 (China Telecom, Los Angeles, US) 514.115ms`
`7 202.97.90.62 (China Telecom, Los Angeles, US) 537.933ms`
`8 213.46.190.217 213-46-190-217.aorta.net (New York) 414.365ms`
`9 84.116.135.122 (UPC Austria GmbH, Vienna, AT) 420.591ms`
`10 213.46.160.205 uk-lon02a-rd1-pos-4-0-0.aorta.net 421.530ms`
`11 84.116.133.65 (UPC Austria GmbH, Frankfurt, DE) 421.557ms`
`12 81.210.129.234 7111a-mx960-01-ae1.fra.unity-media.net 420.867ms`
`13 80.69.107.214 7111a-mx960-02-ae0.fra.unity-media.net 418.427ms`
`14 80.69.107.185 7211a-mx960-01-ae1.gie.unity-media.net 420.454ms`
`15 88.152.128.0 (Unitymedia, Marburg an der Lahn, DE) 423.105ms`
Даже внутрироссийский трафик, который обычно идёт в Москву, шёл через оборудование China Telecom. В следующем примере трафик из Москвы направляется во Франкфурт, затем обрабатывается China Telecom там же и лишь после возвращается в сети «Мегафона». Уж спасибо на том, что не через Шанхай. (Иллюстрация именно этой ситуации на карте Европы показана до ката.)
**Скрытый текст**`trace from Moscow, Russia to Yaroslavl, Russia at 13:13 Aug 05, 2014`
`1 *`
`2 194.154.89.125 (Vimpelcom, Moscow, RU) 0.542ms`
`3 79.104.235.74 mx01.Frankfurt.gldn.net 37.006ms`
`4 118.85.204.57 beeline-gw4.china-telecom.net 39.505ms`
`5 213.248.84.185 ffm-b10-link.telia.net 41.481ms`
`6 62.115.137.180 ffm-bb2-link.telia.net 42.227ms`
`7 80.91.251.159 s-bb4-link.telia.net 42.894ms`
`8 213.155.133.105 s-b2-link.telia.net 41.528ms`
`9 80.239.128.234 megafon-ic-151430-s-b2.c.telia.net 42.707ms`
`10 *`
`11 78.25.73.42 (MegaFon, Volga,RU) 49.992ms`
`12 213.187.127.98 ysu1-ccr1036-1.yar.ru 50.301ms`
`13 213.187.117.230 (NETIS Telecom, Yaroslavl’, RU) 54.769ms`
Конечно, при планировании сетевого уровня организации Интернета над его безопасностью задумывались слабо, и этих пиринговых утечек вряд ли можно избежать. Но это приводит не только к проблемам с производительностью, но и заставляет сильно беспокоиться о безопасности.
Всё это несколько забавно, если вспомнить, что несколько недель назад официально стало известно о желании российского правительства иметь больший контроль за безопасностью сегмента российского Интернета. Неужели нельзя заняться конкретными вопросами, ведь именно они составляют безопасность нашего сегмента Сети? | https://habr.com/ru/post/356560/ | null | ru | null |
# PHP: Определение языка текста с помощью N-грамм. Часть 1
*Примечание*: я не смог по какой-то причине восстановить свой перевод, за который получил инвайт и он куда-то пропал. Поэтому публикую его снова.
Обычно, когда мы смотрим на текст, мы разбиваем его на слова и используем эти слова для определения языка, на котором он написан. Однако существует достаточно много способов сделать это, сравнивая другие единицы текста. Например, буквенные n-граммы.
N-граммы — это просто n-буквенные последовательности, извлеченные из документа. Например, слово «констебль», разложенное в триграммы (трехбуквенные последовательности) будет выглядеть так: {«кон», «онс», «нст», «сте», «теб», «ебл», «бль»}. Существует большое количество способов извлечения таких последовательностей. Более-менее очевидный приведен ниже. С помощью этой функции можно извлекать n-граммы из входной строки. По умолчанию извлекаются триграммы.
> `**php</b**
>
>
>
> function getNgrams($word, $n = 3) {
>
> $ngrams = array();
>
> for($i = 0; $i < strlen($match); $i++) {
>
> if($i > ($n - 2)) {
>
> $ng = '';
>
> for($j = $n-1; $j >= 0; $j--) {
>
> $ng .= $match[$i-$j];
>
> }
>
> $ngrams[] = $ng;
>
> }
>
> }
>
> return $ngrams;
>
> }`
> `Этот исходный код отформатирован с помощью FractalizeR's HabraSyntax Source Code Highlighter.`
#### Определение языка
Взглянув на текст, разбитый на n-граммы, можно заметить, что с их помощью достаточно легко определять язык, на котором он написан. Для этого существует множество алгоритмов, использующих дву- или триграммы, рассчитывающих различные коэффициенты «похожести», но все они сходятся в одном: сначала следует построить статистическую модель распределения триграмм в каждом языке, а затем посмотреть, которой из построенных моделей наиболее полно соответствует заданный текст. В нашем примере мы будем использовать триграммы и косинусную меру сходства векторных пространств (vector space style cosine similarity).
Один из наиболее очевидных вопросов — «что делать с пробелами». В нашем примере мы их игнорируем и генерируем триграммы только из слов. Мы также игнорируем слова длиной менее 3-х букв. Учитывать будем только частоту, с которой встречается триграмма в данном тексте. В принципе, мы можем увеличить точность определения, введя в алгоритм, например, глобальный вес триграммы, который показывает, насколько общей данная триграмма является для всех языков нашей модели. Но и без этого метод триграмм работает довольно точно, особенно при небольшом количестве языков.
Ниже приведен небольшой класс, реализующий детектирование. Ключевыми методами являются addDocument, который разбивает входной документ на триграммы и сохраняет частоты, с которыми она встречается в каждом языке во внутреннем словаре (метод обучения нашей модели, прим. пер.), и detect, который разбивает входящий текст аналогичным образом и для каждой встретившейся триграммы проверяет частоту ее присутствия в каждом языке нашей модели.
> `**php</b**
>
>
>
> class LangDetector {
>
> private $index = array();
>
> private $languages = array();
>
>
>
> public function addDocument($document, $language) {
>
> if(!isset($this->languages[$language])) {
>
> $this->languages[$language] = 0;
>
> }
>
>
>
> $words = $this->getWords($document);
>
> foreach($words as $match) {
>
> $trigrams = $this->getNgrams($match);
>
> foreach($trigrams as $trigram) {
>
> if(!isset($this->index[$trigram])) {
>
> $this->index[$trigram] = array();
>
> }
>
> if(!isset($this->index[$trigram][$language])) {
>
> $this->index[$trigram][$language] = 0;
>
> }
>
> $this->index[$trigram][$language]++;
>
> }
>
> $this->languages[$language] += count($trigrams);
>
> }
>
> }
>
>
>
> public function detect($document) {
>
> $words = $this->getWords($document);
>
> $trigrams = array();
>
> foreach($words as $word) {
>
> foreach($this->getNgrams($word) as $trigram) {
>
> if(!isset($trigrams[$trigram])) {
>
> $trigrams[$trigram] = 0;
>
> }
>
> $trigrams[$trigram]++;
>
> }
>
> }
>
> $total = array\_sum($trigrams);
>
>
>
> $scores = array();
>
> foreach($trigrams as $trigram => $count) {
>
> if(!isset($this->index[$trigram])) {
>
> continue;
>
> }
>
> foreach($this->index[$trigram] as $language => $lCount) {
>
> if(!isset($scores[$language])) {
>
> $scores[$language] == 0;
>
> }
>
> $score = ($lCount / $this->languages[$language])
>
> \* ($count / $total);
>
> $scores[$language] += $score;
>
> }
>
> }
>
> arsort($scores);
>
> return key($scores);
>
> }
>
>
>
> private function getWords($document) {
>
> $document = strtolower($document);
>
> preg\_match\_all('/\w+/', $document, $matches);
>
> return $matches[0];
>
> }
>
>
>
> private function getNgrams($match, $n = 3) {
>
> $ngrams = array();
>
> for($i = 0; $i < strlen($match); $i++) {
>
> if($i > ($n - 2)) {
>
> $ng = '';
>
> for($j = $n-1; $j >= 0; $j--) {
>
> $ng .= $match[$i-$j];
>
> }
>
> $ngrams[] = $ng;
>
> }
>
> }
>
> return $ngrams;
>
> }
>
> }
>
> **?>**`
> `Этот исходный код отформатирован с помощью FractalizeR's HabraSyntax Source Code Highlighter.`
Продолжение статьи [тут](http://fractalizer.habrahabr.ru/blog/75512/). | https://habr.com/ru/post/75509/ | null | ru | null |
# Обновление древовидной модели в Qt
Всем доброго времени суток! В этой статье я хочу рассказать про трудности, с которыми столкнулся при отображении и обновлении древовидной структуры с помощью QTreeView и QAbstractItemModel. Так же предложу велосипед, который я создал, чтобы обойти эти трудности.
Для отображения данных Qt использует парадигму ModelView, в которой модель должна реализовываться наследниками QAbstractItemModel. Данный класс сделан удобно, однако поддержка иерархии, как мне показалось, пришита где-то сбоку и не очень удобно. Построить правильную древовидную модель, как разработчики признаются в документации, дело непростое и даже [ModelTest](http://qt-project.org/wiki/Model_Test), призванный помочь в его отладке, не всегда помогает выявить ошибки в модели.
В моем проекте я столкнулся с еще одной сложностью – с обновлением извне. Дело в том, что QAbstractItemModel требует, что перед любыми действиями с элементами требуется явно указать какие элементы конкретно удаляются, добавляются, перемещаются. Как я пониманию, предполагается, что модель будет редактироваться только посредством View-ов или через методы QAbstractItemModel. Однако, если я работаю с чужой моделью из библиотеки, которая не умеет «правильно» оповещать о своих изменениях, или модель интенсивно редактируется так, что отправлять сообщения об её изменениях становиться накладно, то обновление структуры модели усложняется.
Для решения проблемы такого обновления и упрощения создания реализации QAbstractItemModel. Я решил использовать следующий подход: сделать простой интерфейс для запроса структуры дерева:
```
class VirtualModelAdapter {
public:
// запрос структуры
virtual int getItemsCount(void *parent) = 0;
virtual void * getItem(void *parent, int index) = 0;
virtual QVariant data(void *item, int role) = 0;
// процедуры обновления
void beginUpdate();
void endUpdate();
}
```
и реализовать свою QAbstractItemModel, в которой структура будет кэшироваться и лениво подгружаться по мере необходимости. А обновление модели сделать простой сихранизацией кэшированной структуры с VirtualModelAdapter.
Таким образом, вместо кучи вызовов beginInsertRows/endInsertRows и beginRemoveRows/endRemoveRows можно заключить обновление модели в скобки beginUpdate() endUpdate() и по окончанию обновления выполнять синхронизацию. При этом заметьте – кэшируется только струтура (не данные) и только та её часть, что раскрывается пользователем. Сказано – сделано. Для кэширования дерева я использовал следующую структуру:
```
class InternalNode {
InternalNode *parent;
void *item;
size_t parentIndex;
std::vector> children;
}
```
А для обновления структуры модели я использую функцию, которая сравнивает список элементов и при несовпадении вставляет новые и удаляет ненужные элементы:
```
void VirtualTreeModel::syncNodeList(InternalNode &node, void *parent)
{
InternalChildren &nodes = node.children;
int srcStart = 0;
int srcCur = srcStart;
int destStart = 0;
auto index = getIndex(node);
while (srcCur <= static_cast(nodes.size()))
{
bool finishing = srcCur >= static\_cast(nodes.size());
int destCur = 0;
InternalNode \*curNode = nullptr;
if (!finishing) {
curNode = nodes[srcCur].get();
destCur = m\_adapter->indexOf(parent, curNode->item, destStart);
}
if (destCur >= 0)
{
// remove skipped source nodes
if (srcCur > srcStart)
{
beginRemoveRows(index, srcStart, srcCur-1);
node.eraseChildren(nodes.begin() + srcStart, nodes.begin() + srcCur);
if (!finishing)
srcCur = srcStart;
endRemoveRows();
}
srcStart = srcCur + 1;
if (finishing)
destCur = m\_adapter->getItemsCount(parent);
// insert skipped new nodes
if (destCur > destStart)
{
int insertCount = destCur - destStart;
beginInsertRows(index, srcCur, srcCur + insertCount - 1);
for (int i = 0, cur = srcCur; i < insertCount; i++, cur++)
{
void \*obj = m\_adapter->getItem(parent, destStart + i);
auto newNode = new InternalNode(&node, obj, cur);
nodes.emplace(nodes.begin() + cur, newNode);
}
node.insertedChildren(srcCur + insertCount);
endInsertRows();
srcCur += insertCount;
destStart += insertCount;
}
destStart = destCur + 1;
if (curNode && curNode->isInitialized(m\_adapter))
{
syncNodeList(\*curNode, curNode->item);
srcStart = srcCur + 1;
}
}
srcCur++;
}
node.childInitialized = true;
}
```
По сути получается следующая система: когда структура данных начинает меняться после вызова BeginUpdate(), все обращения View к index(), parent() и т.п. транслируются к кэшу, а data() возвращает пустой QVariant(). По завершению обновления структуры вы вызываете endUpdate() и происходит синхронизация со всеми вставками и удалениями и View перерисовывается.
В качестве примера я сделал следующую структуру разделов:
```
class Part {
Part *parent;
QString name;
std::vector> subParts;
}
```
Теперь для её отображения мне достаточно реализовать следующий класс:
```
сlass VirtualPartAdapter : public VirtualModelAdapter {
int getItemsCount(void *parent) override;
void * getItem(void *parent, int index) override;
QVariant data(void *item, int role) override;
void * getItemParent(void *item) override;
Part *getValue(void * data);
};
```
А для любых изменений извне используем следующий подход:
```
m_adapter->beginUpdate();
Part* cur = currentPart();
auto g1 = cur->add("NewType");
g1->add("my class");
g1->add("my struct");
m_adapter->endUpdate();
```
В качестве еще более простой альтернативы можно вызвать QueuedUpdate() перед изменением данных и тогда обновление структуры произойдет автоматически после обработки сигнала, посланного через Qt::QueuedConnection:
```
m_adapter-> QueuedUpdate();
Part* cur = currentPart();
auto g1 = cur->add("NewType");
g1->add("my class");
g1->add("my struct");
```
#### Заключение
Мой опыт работы с C++ и Qt не велик и меня не покидает ощущение, что проблему можно решить проще. В любом случае, надеюсь, этот способ будет кому-нибудь полезен. С полным текстом и примером можно ознакомиться на [github](https://github.com/RemKolomna/VirtualTree).
Замечания и критика категорически приветствуются. | https://habr.com/ru/post/250431/ | null | ru | null |
# Резервирование констант и Git hooks на C#
Позвольте мне рассказать вам историю. Жили-были два разработчика: Сэм и Боб. Они вместе работали над проектом, в котором была база данных. Когда разработчик хотел внести в неё изменения, он обязан был создать файл `stepNNN.sql`, где NNN — некоторое число. Чтобы избежать конфликтов этих чисел между различными разработчиками, они использовали простой Web-сервис. Каждый разработчик прежде чем начать писать SQL-файл должен был зайти на этот сервис и зарезервировать за собой новое число для step-файла.
В этот раз Сэму и Бобу обоим нужно было внести изменения в базу данных. Сэм послушно отправился на сервис и зарезервировал за собой число 333. А Боб забыл сделать это. Он просто использовал 333 для своего step-файла. Так случилось, что в этот раз Боб первым залил свои изменения в систему контроля версий. Когда Сэм был готов залиться, он обнаружил, что файл `step333.sql` уже существует. Он связался с Бобом, объяснил ему, что номер 333 был зарезервирован за ним и попросил исправить конфликт. Но Боб ответил:
— Чувак, мой код уже в 'master'е, куча разработчиков уже используют его. К тому же он уже выкачен на production. Так что просто исправь там у себя всё, что нужно.
Надеюсь, вы заметили, что произошло. Наказанным оказался человек, который следовал всем правилам. Сэму пришлось менять свои файлы, править свою локальную базу данных и т.д. Лично я ненавижу такие ситуации. Давайте посмотрим, как мы можем избежать её.
Основная идея
-------------
Как нам избежать подобных вещей? Что, если бы Боб не смог залить свой код, если он не зарезервировал за собой соответствующее число на Web-сервисе?
И мы на самом деле можем добиться этого. Мы можем использовать Git hook'и чтобы выполнять пользовательский код перед каждым commit'ом. Этот код будет проверять все заливаемые изменения. Если они содержат новый step-файл, код будет связываться с Web-сервисом и проверять, зарезервирован ли номер step-файла за текущим разработчиком. И если номер не зарезервирован, код будет запрещать заливку.
Такова основная идея. Давайте же перейдём к деталям.
Git hook'и на C#
----------------
Git не ограничивает вас в том, на каких языках вы должны писать hook'и. Как C#-разработчик, я бы предпочёл использовать хорошо знакомый мне C# для этих целей. Могу ли я это сделать?
Да, могу. Основная идея взята мною из [этой статьи](https://medium.com/@max.hamulyak/using-c-code-in-your-git-hooks-66e507c01a0f), написанной Max Hamulyák. В ней требуется, чтобы мы использовали глобальный инструмент [dotnet-script](https://github.com/filipw/dotnet-script). Этот инструмент требует наличия .NET Core 2.1 + SDK на машине разработчика. Я полагаю, что это разумное требование для тех, кто занимается .NET разработкой. Установка `dotnet-script` очень проста:
```
> dotnet tool install -g dotnet-script
```
Теперь мы можем писать Git hook'и на C#. Для этого нужно перейти в папку `.git\hooks` вашего проекта и создать файл `pre-commit` (безо всякого расширения):
```
#!/usr/bin/env dotnet-script
Console.WriteLine("Git hook");
```
С этого момента всякий раз, когда вы делаете `git commit`, вы будете видеть текст `Git hook` в вашей консоли.
Несколько обработчиков на один hook
-----------------------------------
Что ж, начало положено. Теперь мы можем писать что угодно в файле `pre-commit`. Но мне не очень нравится эта идея.
Во-первых, работать со скрипт-файлом не очень удобно. Я бы предпочёл использовать мой любимый IDE со всеми его возможностями. И я предпочёл бы иметь возможность разбить сложный код на несколько файлов.
Но есть и ещё кое-что, что мне не нравится. Представьте себе следующую ситуацию. Вы создали `pre-commit` с какими-нибудь проверками. Но позже вам потребовалось добавить ещё проверок. Вам придётся открывать файл, решать, куда вставить ваш код, как он будет взаимодействовать со старым кодом и т.п. Лично я предпочитаю писать новый код, а не копаться в старом.
Давайте разберёмся с этими проблемами по одной.
Вызов внешнего кода
-------------------
Вот как мы поступим. Давайте создадим отдельную папку (например, `gitHookAssemblies`). В эту папку я положу .NET Core сборку (например, `GitHooks`). Мой скрипт в файле `pre-commit` будет просто вызывать некоторый метод из этой сборки.
```
public class RunHooks
{
public static void RunPreCommitHook()
{
Console.WriteLine("Git hook from assembly");
}
}
```
Я могу создавать эту сборку в моём любимом IDE и использовать любые инструменты.
Теперь в файле `pre-commit` я могу написать:
```
#!/usr/bin/env dotnet-script
#r "../../gitHookAssemblies/GitHooks.dll"
GitHooks.RunHooks.RunPreCommitHook();
```
Здорово, не правда ли! Теперь я могу делать изменения только в моей сборке `GitHooks`. Код файла `pre-commit` уже никогда не будет меняться. Когда мне потребуется добавить какую-нибудь проверку, я изменю код метода `RunPreCommitHook`, пересоберу сборку и положу её в папку `gitHookAssemblies`. И всё!
Ну, не совсем.
Борьба с кэшем
--------------
Давайте попробуем последовать нашему процессу. Поменяем сообщение в `Console.WriteLine` на что-нибудь другое, пересоберём сборку и положим результат в папку `gitHookAssemblies`. После этого вызовем `git commit` снова. Что же мы увидим? Старое сообщение. Наши изменения не подцепились. Почему?
Пусть, для определённости, ваш проект находится в папке `c:\project`. Это означает, что скрипты Git hook'ов расположены в папке `c:\project\.git\hooks`. Теперь, если вы используете Windows 10, перейдите в папку `c:\Users\\AppData\Local\Temp\scripts\c\project\.git\hooks\`. Здесь — имя вашего текущего пользователя. Что же мы увидим здесь? Когда мы запускаем скрипт `pre-commit`, в этой папке создаётся скомпилированная версия этого скрипта. Здесь же вы можете найти все сборки, на которые ссылается скрипт (включая нашу `GitHooks.dll`). И в подпапке `execution-cache` вы можете найти SHA256-файл. Я могу предположить, что он содержит SHA256-хэш нашего файла `pre-commit`. В тот момент, когда мы запускаем скрипт, среда исполнения сравнивает текущий хэш файла с сохранённым хэшем. Если они равны, будет использована сохранённая версия скомпилированного скрипта.
Это означает, что поскольку мы никогда не меняем файл `pre-commit`, изменения в `GitHooks.dll` никогда не достигнут кэша и никогда не будут использованы.
Что мы можем сделать в этой ситуации? Ну, нам поможет Reflection. Я перепишу мой скрипт так, чтобы он использовал Reflection вместо прямой ссылки на сборку `GitHooks`. Вот как после этого будет выглядеть наш файл `pre-commit`:
```
#!/usr/bin/env dotnet-script
#r "nuget: System.Runtime.Loader, 4.3.0"
using System.IO;
using System.Runtime.Loader;
var hooksDirectory = Path.Combine(Environment.CurrentDirectory, "gitHookAssemblies");
var assemblyPath = Path.Combine(hooksDirectory, "GitHooks.dll");
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath);
if(assembly == null)
{
Console.WriteLine($"Can't load assembly from '{assemblyPath}'.");
}
var collectorsType = assembly.GetType("GitHooks.RunHooks");
if(collectorsType == null)
{
Console.WriteLine("Can't find entry type.");
}
var method = collectorsType.GetMethod("RunPreCommitHook", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
if(method == null)
{
Console.WriteLine("Can't find method for pre-commit hooks.");
}
method.Invoke(null, new object[0]);
```
Теперь мы можем обновлять `GitHook.dll` в нашей папке `gitHookAssemblies` в любой момент, и все изменения будут подхвачены тем же самым скриптом. Модифицировать сам скрипт больше не нужно.
Всё это звучит замечательно, но есть ещё одна проблема, которую следует решить перед тем, как двигаться далее. Я говорю о сборках, на которые ссылается наш код.
Используемые сборки
-------------------
Всё работает прекрасно, пока единственной вещью, которую делает метод `RunHooks.RunPreCommitHook`, является вывод строки на консоль. Но, откровенно говоря, обычно вывод текста на экран не представляет никакого интереса. Нам нужно делать более сложные вещи. А для этого нам требуется использовать другие сборки и NuGet-пакеты. Давайте посмотрим, как сделать это.
Я изменю `RunHooks.RunPreCommitHook` так, чтобы он использовал пакет `LibGit2Sharp`:
```
public static void RunPreCommitHook()
{
using var repo = new Repository(Environment.CurrentDirectory);
Console.WriteLine(repo.Info.WorkingDirectory);
}
```
Теперь, если я выполню `git commit`, я получу следующее сообщение об ошибке:
```
System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation.
---> System.IO.FileLoadException: Could not load file or assembly 'LibGit2Sharp, Version=0.26.0.0, Culture=neutral, PublicKeyToken=7cbde695407f0333'. General Exception (0x80131500)
```
Ясно, что нам требуется некоторый способ обеспечить загрузку сборок, на которые мы ссылаемся. Основная идея здесь такова. Я буду класть все требуемые для выполнения кода сборки в ту же папку `gitHookAssemblies` вместе с моей `GitHooks.dll`. Чтобы получить все требуемые сборки, вы можете воспользоваться командой `dotnet publish`. В нашем случае нам нужно поместить в эту папку `LibGit2Sharp.dll` и `git2-7ce88e6.dll`.
Так же нам придётся изменить `pre-commit`. Мы добавим в него следующий код:
```
#!/usr/bin/env dotnet-script
#r "nuget: System.Runtime.Loader, 4.3.0"
using System.IO;
using System.Runtime.Loader;
var hooksDirectory = Path.Combine(Environment.CurrentDirectory, "gitHookAssemblies");
var assemblyPath = Path.Combine(hooksDirectory, "GitHooks.dll");
AssemblyLoadContext.Default.Resolving += (context, assemblyName) => {
var assemblyPath = Path.Combine(hooksDirectory, $"{assemblyName.Name}.dll");
if(File.Exists(assemblyPath))
{
return AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath);
}
return null;
};
...
```
Этот код будет пытаться загружать все сборки, которые среда исполнения не смогла найти самостоятельно, из папки `gitHookAssemblies`.
Теперь можно запускать `git commit` и он выполнится без проблем.
Улучшение расширяемости
-----------------------
Наш файл `pre-commit` завершён. Больше нам не требуется изменять его. Но в случае необходимости внесения изменений, нам придётся изменять метод `RunHooks.RunPreCommitHook`. Так что мы просто перенесли проблему на другой уровень. Лично я предпочёл бы иметь некоторую систему плагинов. Каждый раз, когда мне потребуется добавить некоторое действие, которое нужно выполнять перед заливкой кода, я просто будут писать новый плагин, и ничего изменять не потребуется. Насколько трудно этого добиться?
Совсем не трудно. Давайте воспользуемся [MEF](https://docs.microsoft.com/en-us/dotnet/framework/mef/). Вот как он работает.
Сперва нужно определить интерфейс для наших обработчиков hook'ов:
```
public interface IPreCommitHook
{
bool Process(IList args);
}
```
Каждый обработчик может получать от Git некоторые строковые аргументы. Эти аргументы будут передаваться через параметр `args`. Метод `Process` будет возвращать `true`, если он разрешает заливку изменений. В противном случае будет возвращён `false`.
Подобные интерфейсы можно определить для всех hook'ов, но в этой статье мы сосредоточимся только на pre-commit.
Теперь нужно написать реализацию этого интерфейса:
```
[Export(typeof(IPreCommitHook))]
public class MessageHook : IPreCommitHook
{
public bool Process(IList args)
{
Console.WriteLine("Message hook...");
if(args != null)
{
Console.WriteLine("Arguments are:");
foreach(var arg in args)
{
Console.WriteLine(arg);
}
}
return true;
}
}
```
Такие классы можно создавать в разных сборках, если вам так хочется. Буквально нет никаких ограничений. Атрибут `Export` берётся из NuGet-пакета `System.ComponentModel.Composition`.
Так же давайте создадим вспомогательный метод, который будет собирать все реализации интерфейса `IPreCommitHook`, помеченные атрибутом `Export`, запускать их всех и возвращать информацию о том, все ли они разрешили заливку. Я поместил мой обработчик в отдельную сборку `GitHooksCollector`, но это не так важно:
```
public class Collectors
{
private class PreCommitHooks
{
[ImportMany(typeof(IPreCommitHook))]
public IPreCommitHook[] Hooks { get; set; }
}
public static int RunPreCommitHooks(IList args, string directory)
{
var catalog = new DirectoryCatalog(directory, "\*Hooks.dll");
var container = new CompositionContainer(catalog);
var obj = new PreCommitHooks();
container.ComposeParts(obj);
bool success = true;
foreach(var hook in obj.Hooks)
{
success &= hook.Process(args);
}
return success ? 0 : 1;
}
}
```
Этот код так же использует NuGet-пакет `System.ComponentModel.Composition`. Во-первых, мы говорим, что будем просматривать все сборки, чьё имя соответствует шаблону `*Hooks.dll`, в папке `directory`. Вы можете использовать здесь любой шаблон, какой вам нравится. Затем мы собираем все экспортированные реализации интерфейса `IPreCommitHook` в объект `PreCommitHooks`. И, наконец, мы запускаем все обработчики hook'а и собираем результат их выполнения.
Последней вещью, которую нам нужно сделать, является небольшое изменение файла `pre-commit`:
```
#!/usr/bin/env dotnet-script
#r "nuget: System.Runtime.Loader, 4.3.0"
using System.IO;
using System.Runtime.Loader;
var hooksDirectory = Path.Combine(Environment.CurrentDirectory, "gitHookAssemblies");
var assemblyPath = Path.Combine(hooksDirectory, "GitHooksCollector.dll");
AssemblyLoadContext.Default.Resolving += (context, assemblyName) => {
var assemblyPath = Path.Combine(hooksDirectory, $"{assemblyName.Name}.dll");
if(File.Exists(assemblyPath))
{
return AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath);
}
return null;
};
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath);
if(assembly == null)
{
Console.WriteLine($"Can't load assembly from '{assemblyPath}'.");
}
var collectorsType = assembly.GetType("GitHooksCollector.Collectors");
if(collectorsType == null)
{
Console.WriteLine("Can't find collector's type.");
}
var method = collectorsType.GetMethod("RunPreCommitHooks", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
if(method == null)
{
Console.WriteLine("Can't find collector's method for pre-commit hooks.");
}
int exitCode = (int) method.Invoke(null, new object[] { Args, hooksDirectory });
Environment.Exit(exitCode);
```
И не забудьте поместить все задействованные сборки в папку `gitHookAssemblies`.
Да, это было долгое вступление. Но теперь у нас есть вполне надёжное решение для создания обработчиков Git hook'ов на C#. Всё, что от нас требуется, это изменение содержимого папки `gitHookAssemblies`. Её содержимое может быть помещено в систему контроля версий и, таким образом, распространено между всеми разработчиками.
В любом случае, нам пора вернуться к нашей первоначальной проблеме.
Web-сервис для резервирования констант
--------------------------------------
Мы хотели убедиться, что разработчики не смогут залить определённые изменения в случае, если они забыли зарезервировать за собой соответствующую константу на Web-сервисе. Давайте создадим простенький Web-сервис, чтобы можно было работать с ним. Я использую ASP.NET Core Web-сервис с Windows аутентификацией. Но на самом деле здесь возможны различные варианты.
```
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace ListsService.Controllers
{
public sealed class ListItem
{
public ListItem(T value, string owner)
{
Value = value;
Owner = owner;
}
public T Value { get; }
public string Owner { get; }
}
public static class Lists
{
public static List> SqlVersions = new List>
{
new ListItem(1, @"DOMAIN\Iakimov")
};
public static Dictionary>> AllLists = new Dictionary>>
{
{1, SqlVersions}
};
}
[Authorize]
public class ListsController : Controller
{
[Route("/api/lists/{listId}/ownerOf/{itemId}")]
[HttpGet]
public IActionResult GetOwner(int listId, int itemId)
{
if (!Lists.AllLists.ContainsKey(listId))
return NotFound();
var item = Lists.AllLists[listId].FirstOrDefault(li => li.Value == itemId);
if(item == null)
return NotFound();
return Json(item.Owner);
}
}
}
```
Здесь, для целей тестирования, я использовал статический класс `Lists` в качестве механизма хранения списков. Каждый список будет иметь целочисленный идентификатор. Каждый список будет содержать целочисленные значения и информацию о людях, за которыми эти значения зарезервированы. Метод `GetOwner` класса `ListController` позволяет получить идентификатор человека, за которым зарезервирован данный элемент списка.
Проверка SQL step-файлов
------------------------
Теперь мы готовы проверить, можем ли мы залить новый step-файл или нет. Предположим для определённости, что мы храним step-файлы следующим образом. В корневой папке нашего проекта имеется каталог `sql`. В нём каждый разработчик может создать папку `verXXX`, где `XXX` — некоторое число, которое должно быть предварительно зарезервировано на Web-сервисе. Внутри каталога `verXXX` может быть один или несколько `.sql` файлов, содержащих инструкции изменения базы данных. Мы не будем здесь обсуждать проблему обеспечения порядка выполнения этих `.sql` файлов. Это не важно для нашего обсуждения. Мы просто хотим сделать следующее. Если разработчик пытается залить новый файл, содержащийся внутри папки `sql/verXXX`, мы должны проверить, зарезервирована ли константа `XXX` за этим разработчиком.
Вот как выглядит код соответствующего обработчика Git hook:
```
[Export(typeof(IPreCommitHook))]
public class SqlStepsHook : IPreCommitHook
{
private static readonly Regex _expr = new Regex("\\bver(\\d+)\\b");
public bool Process(IList args)
{
using var repo = new Repository(Environment.CurrentDirectory);
var items = repo.RetrieveStatus()
.Where(i => !i.State.HasFlag(FileStatus.Ignored))
.Where(i => i.State.HasFlag(FileStatus.NewInIndex))
.Where(i => i.FilePath.StartsWith(@"sql"));
var versions = new HashSet(
items
.Select(i => \_expr.Match(i.FilePath))
.Where(m => m.Success)
.Select(m => m.Groups[1].Value)
.Select(d => int.Parse(d))
);
foreach(var version in versions)
{
if (!ListItemOwnerChecker.DoesCurrentUserOwnListItem(1, version))
return false;
}
return true;
}
}
```
Здесь мы используем класс `Repository` из NuGet-пакета `LibGit2Sharp`. Переменная `items` будет содержать все новые файлы в индексе Git, которые расположены внутри папки `sql`. Вы можете улучшить процедуру поиска таких файлов, если есть желание. В переменную `versions` мы собираем различные константы `XXX` из папок `verXXX`. И, наконец, метод `ListItemOwnerChecker.DoesCurrentUserOwnListItem` проверяет, зарегистрированы ли эти версии за текущим пользователем на Web-сервисе в списке 1.
Реализация `ListItemOwnerChecker.DoesCurrentUserOwnListItem` довольно проста:
```
class ListItemOwnerChecker
{
public static string GetListItemOwner(int listId, int itemId)
{
var handler = new HttpClientHandler
{
UseDefaultCredentials = true
};
var client = new HttpClient(handler);
var response = client.GetAsync($"https://localhost:44389/api/lists/{listId}/ownerOf/{itemId}")
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
return null;
}
var owner = response.Content
.ReadAsStringAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
return JsonConvert.DeserializeObject(owner);
}
public static bool DoesCurrentUserOwnListItem(int listId, int itemId)
{
var owner = GetListItemOwner(listId, itemId);
if (owner == null)
{
Console.WriteLine($"There is no item '{itemId}' in the list '{listId}' registered on the lists service.");
return false;
}
if (owner != WindowsIdentity.GetCurrent().Name)
{
Console.WriteLine($"Item '{itemId}' in the list '{listId}' registered by '{owner}' and you are '{WindowsIdentity.GetCurrent().Name}'.");
return false;
}
return true;
}
}
```
Здесь мы запрашиваем у Web-сервиса идентификатор пользователя, который зарегистрировал указанную константу (метод `GetListItemOwner`). Затем полученный результат сравнивается с именем текущего пользователя Windows. Это только один из многих возможных путей реализации подобной функциональности. Например, вы можете использовать имя или e-mail пользователя из конфигурации Git.
Вот и всё. Просто соберите соответствующую сборку и поместите её в папку `gitHookAssemblies` вместе со всеми её зависимостями. И всё заработает автоматически.
Проверка значений enum
----------------------
Это здорово! Теперь никто не сможет залить изменения для базы данных, предварительно не зарезервировав за собой соответствующую константу на Web-сервисе. Но подобный метод может использоваться и в других местах, где требуется резервирование констант.
К примеру, где нибудь в коде проекта у вас есть enum. Каждый разработчик может добавлять в него новые члены с присвоенными целочисленными значениями:
```
enum Constants
{
Val1 = 1,
Val2 = 2,
Val3 = 3
}
```
Мы хотим избежать коллизии значений для членов этого перечисления. Поэтому мы требуем предварительного резервирования соответствующих констант на Web-сервисе. Насколько трудно реализовать проверку такого резервирования?
Вот как выглядит код для нового обработчика Git hook:
```
[Export(typeof(IPreCommitHook))]
public class ConstantValuesHook : IPreCommitHook
{
public bool Process(IList args)
{
using var repo = new Repository(Environment.CurrentDirectory);
var constantsItem = repo.RetrieveStatus()
.Staged
.FirstOrDefault(i => i.FilePath == @"src/GitInteraction/Constants.cs");
if (constantsItem == null)
return true;
if (!constantsItem.State.HasFlag(FileStatus.NewInIndex)
&& !constantsItem.State.HasFlag(FileStatus.ModifiedInIndex))
return true;
var initialContent = GetInitialContent(repo, constantsItem);
var indexContent = GetIndexContent(repo, constantsItem);
var initialConstantValues = GetConstantValues(initialContent);
var indexConstantValues = GetConstantValues(indexContent);
indexConstantValues.ExceptWith(initialConstantValues);
if (indexConstantValues.Count == 0)
return true;
foreach (var version in indexConstantValues)
{
if (!ListItemOwnerChecker.DoesCurrentUserOwnListItem(2, version))
return false;
}
return true;
}
...
}
```
Сначала мы проверяем, был ли изменён файл, содержащий наше перечисление. Затем мы извлекаем содержимое этого файла из последней залитой версии и из индекса Git с использованием методов `GetInitialContent` и `GetIndexContent`. Вот их реализация:
```
private string GetInitialContent(Repository repo, StatusEntry item)
{
var blob = repo.Head.Tip[item.FilePath]?.Target as Blob;
if (blob == null)
return null;
using var content = new StreamReader(blob.GetContentStream(), Encoding.UTF8);
return content.ReadToEnd();
}
private string GetIndexContent(Repository repo, StatusEntry item)
{
var id = repo.Index[item.FilePath]?.Id;
if (id == null)
return null;
var itemBlob = repo.Lookup(id);
if (itemBlob == null)
return null;
using var content = new StreamReader(itemBlob.GetContentStream(), Encoding.UTF8);
return content.ReadToEnd();
}
```
После этого мы извлекаем из обоих версий файла целочисленные значения членов перечисления. За это отвечает метод `GetConstantValues`. Я использовал [`Roslyn`](https://github.com/dotnet/roslyn) для реализации этой функциональности. Его можно задействовать с помощью NuGet-пакета `Microsoft.CodeAnalysis.CSharp`.
```
private ISet GetConstantValues(string fileContent)
{
if (string.IsNullOrWhiteSpace(fileContent))
return new HashSet();
var tree = CSharpSyntaxTree.ParseText(fileContent);
var root = tree.GetCompilationUnitRoot();
var enumDeclaration = root
.DescendantNodes()
.OfType()
.FirstOrDefault(e => e.Identifier.Text == "Constants");
if(enumDeclaration == null)
return new HashSet();
var result = new HashSet();
foreach (var member in enumDeclaration.Members)
{
if(int.TryParse(member.EqualsValue.Value.ToString(), out var value))
{
result.Add(value);
}
}
return result;
}
```
При использовании `Roslyn` я столкнулся со следующей проблемой. На тот момент, когда я писал этот код, последней версией пакета `Microsoft.CodeAnalysis.CSharp` была `3.4.0`. Я поместил эту сборку в папку `gitHookAssemblies`, но программа выдала ошибку, что она не может найти соответствующую версию сборки. Вот в чём причина такого поведения. Видите ли, `dotnet-script` так же использует `Roslyn` для своей работы. Это означает, что какая-то версия сборки `Microsoft.CodeAnalysis.CSharp` уже была загружена в домен. В моём случае это была версия `3.3.1`. Когда в своём коде я стал использовать именно эту версию NuGet-пакета, проблема исчезла.
И, наконец, в методе `Process` нашего обработчика hook`а, мы выбираем все новые значения и проверяем их владельцев на Web-сервисе.
Направления дальнейшего развития
--------------------------------
Вот и всё. Наша система проверки резервирования констант построена. В конце я хотел бы кратко коснуться некоторых проблем, о которых ещё предстоит подумать.
1. Мы создали файл `pre-commit`, но ничего не сказали о том, как он попадёт в папки `.git\hooks` на компьютерах всех разработчиков. Здесь можно использовать параметр `--template` команды `git init`. Или же что-то подобное:
```
git config init.templatedir git_template_dir
git init
```
Или можно использовать опцию `core.hooksPath` конфигурации Git, если у вас версия Git 2.9 или более поздняя:
```
git config core.hooksPath git_template_dir
```
Или же мы можем сделать это частью процесса сборки нашего приложения.
2. Тот же самый вопрос касается и инсталляции `dotnet-script`. Мы можем либо предустановить его на все машины разработчиков вместе с определённой версией .NET Core, либо так же сделать это частью процесса сборки приложения.
3. Лично я считаю наибольшей проблемой размещение сборок, на которые мы ссылаемся. Мы договорились, что будем помещать их в папку `gitHookAssemblies`, но я не уверен, что это поможет в любых ситуациях. Например, пакет `LibGit2Sharp` поставляется с множеством нативных библиотек для различных операционных систем. Здесь я использовал `git2-7ce88e6.dll`, подходящую для Win-x64. Но если разные разработчики используют различные операционные системы, мы можем столкнуться с проблемой.
4. Мы почти ничего не сказали о реализации Web-сервиса. Здесь мы использовали Windows-аутентификацию, но существует и множество других возможностей. Так же Web-сервис должен предоставлять некоторый UI для резервирования новых констант и создания новых списков.
5. Возможно вы заметили, что использование асинхронных операций в наших обработчиках Git hook'ов было неудобным. Я думаю, что поддержку таких операций следует улучшить.
Заключение
----------
В этой статье мы научились строить надёжную систему для создания обработчиков Git hook`ов на языках .NET. На этой основе мы создали несколько таких обработчиков, позволяющих проверять резервирование различных констант и предотвращать заливку кода в случае нарушений.
Я надеюсь, что эта информация будет полезна вам. Удачи!
P.S. Код для этой статьи вы можете найти на [GitHub](https://github.com/yakimovim/csharp-git-hooks). | https://habr.com/ru/post/485218/ | null | ru | null |
# 7 распространенных ошибок в SQL-запросах, которые делал каждый (почти)
Сегодня SQL используют уже буквально все на свете: и аналитики, и программисты, и тестировщики, и т.д. Отчасти это связано с тем, что базовые возможности этого языка легко освоить.
Однако работая с большим количеством junior-ов, мы раз от раза находим в их решениях одни и те же ошибки. Реально — иногда просто создается ощущение, что они копируют друг у друга код.
*Кстати, иногда такая же участь постигает и специалистов более высокого полета.*
Сегодня мы решили собрать 7 таких ошибок в одном месте, чтобы как можно меньше людей их совершали.
***Примечание:*** *Ошибки будут 2 видов — реальные ошибки и своего рода best practices, которым часто не следуют.*
Но, обо всем по порядку :)
> Кстати, будем рады видеть вас в своих социальных сетях — [ВКонтакте](https://vk.com/itresume) [Телеграм](https://t.me/it_resume) [Инстаграм](https://www.instagram.com/itresume.ru/)
>
>
1. Преобразование типов
-----------------------
Мы привыкли, что в математике мы всегда можем разделить одно число на другое и получить ответ. Если нацело не получается, то в виде дроби.
В SQL это не всегда так работает. Например, в PostgreSQL деление двух целых чисел друг на друга даст целочисленный ответ. Это можно проверить как для целочисленных столбцов, так и для чисел.
```
SELECT a/b FROM demo
# столбец целых чисел
SELECT 1 / 2
# 0
```
Аналогичные запросы, например, в MySQL дадут дробное число, как и положено.
Если Вы точно не уверены или хотите подстраховаться, то лучше всегда явно делать преобразование типов. Например:
```
SELECT a::NUMERIC/b FROM demo
SELECT a*1.0/b FROM demo
SELECT CAST(1 AS FLOAT)/2 FROM demo
```
Все перечисленные примеры дадут нужный ответ.
2. HAVING вместо WHERE
----------------------
Часто встречается ошибка — оператор HAVING используется вместо WHERE в запросах с агрегацией. Это неверно!
WHERE производит фильтрацию строк в исходном наборе данных, отсеивая неподходящие. После этого GROUP BY формирует группы и оператор HAVING производит фильтрацию уже целых групп (будто группа — одно запись).
Например:
```
SELECT date, COUNT(*)
FROM transactions t
WHERE date >= '2019-01-01'
GROUP BY date
HAVING COUNT(*) = 2
```
Здесь мы сначала отсеиваем строки, в которых хранятся записи до 2019 года. После этого формируем группы и оставляем только те, в которых ровно две записи.
Некоторые же пишут так:
```
SELECT date, COUNT(*)
FROM transactions t
GROUP BY date
HAVING COUNT(*) = 2 AND date >= '2019-01-01'
```
Так делать не нужно :)
Кстати, для закрепления этой темы мы специально делали [задачку](https://itresume.ru/problems/filtered-sales-in-apecified-date-period) «Отфильтрованные продажи» у себя на платформе. Если интересно порешать и другие задачки по SQL - [welcome](https://itresume.ru/problems?tag=SQL) :)
3. Алиасы и план запроса
------------------------
Если «проговаривать SQL-запрос» словами, то получится что-то такое:
> В таблице есть старая цена, а есть новая цена. Их разность я назову diff. Я хочу отобрать только те строки, где значение diff больше 100.
>
>
Звучит вполне логично. Но в SQL прям так реализовать не получится - и многие попадаются в эту ловушку.
Вот неправильный запрос:
```
SELECT old_price - new_price AS diff
FROM goods
WHERE diff > 100
```
Ошибка его заключается в том, что мы используем алиас столбца diff внутри оператора WHERE.
Да, это выглядит вполне логичным, но мы не можем так сделать из-за порядка выполнения операторов в SQL-запросе. Дело в том, что фильтр WHERE выполняется сильно раньше оператора SELECT (а значит и AS). Соответственно, в момент выполнения столбца diff просто не существует. Об этом, кстати, и говорит ошибка:
```
ERROR: column "diff" does not exist
```
Правильно будет использовать подзапрос или переписать запрос следующим образом:
```
SELECT old_price - new_price AS diff
FROM goods
WHERE old_price - new_price > 100
```
**Важно:** Внутри ORDER BY вы можете указывать алиас - этот оператор выполняется уже после SELECT.
Кстати, мы тут делали [карточку](https://vk.com/itresume?w=wall-197837145_2137), где наглядно показывается последовательность выполнения операторов. Возможно, это вам пригодится.
4. Не использовать COALESCE
---------------------------
Пришло время неочевидных пунктов. Но сейчас мы поясним свои чаяния.
COALESCE - это оператор, который принимает N значений и возвращает первое, которое не NULL. Если все NULL, то вернется NULL.
Нужен этот оператор для того, чтобы в расчеты случайно не попадали пропуски. Такие пропуски всегда сложно заметить, потому что при расчете среднего на основании ста тысяч строк вы вряд ли заметите подвох, даже если 1000 просто будет отсутствовать. Обычно такие численные пропуски заполняют средними значениями/минимальными/максимальными/медианными/средними или с помощью какой-то интерполяции — зависит от задачи.
Мы же рассмотрим нечисловой пример, а вполне себе бизнесовый. Например, есть таблица клиентов Clients. В поле name заносится имя пользователя.
Отдел маркетинга решил сделать email-рассылку, которая начинается с фразы:
`Приветствуем, имя_пользователя!`
Очевидно, что если name is NULL, то это превратится в ~~тыкву~~:
`Приветствуем, !`
Вот в таких случаях и помогает COALESCE:
```
SELECT COALESCE(name, 'Дорогой друг') FROM Clients
```
**Совет:** Лучше всегда перестраховываться. Особенно это касается вычислений и агрегирований - там вы не найдете ошибку примерно никогда, так что лучше подложить соломку.
5. Игнорирование CASE
---------------------
Если вы используете CASE, то иногда вы можете сократить свои запросы в несколько раз.
Вот, например, была задача — вывести поле sum со знаком «-», если type=1 и со знаком «+», если type=0.
Пользователь предложил такое решение:
```
SELECT id, sum FROM transactions t WHERE type = 0
UNION ALL
SELECT id, -sum FROM transactions t WHERE type = 1
```
В целом, не так плохо. Но это всего лишь промежуточный запрос, задача была намного масштабней и таких конструкций в итоге было наворочено очень много.
А вот то же самое с CASE:
```
SELECT id, CASE WHEN type = 0 THEN sum ELSE -sum END FROM transactions t
```
Согласитесь, получше?
Так более того, CASE можно использовать еще много для чего. Например, чтобы [сделать из «длинной» таблицы «широкую»](https://itresume.ru/problems/long-table-to-wide).
А еще, кстати, COALESCE, который мы обсуждали выше — это просто «синтаксический сахар» и обертка вокруг CASE. Если интересно — мы подробно это описали в [статье](https://vk.com/@itresume-sintaksicheskii-sahar-sql-vyrazhenie-coalesce).
6. Лишние подзапросы
--------------------
Из-за того, что многие пишут SQL-запросы также, как это «звучит» в их голове, получается нагромождение подзапросов.
Это проходит с опытом — начинаешь буквально «мыслить на SQL» и все становится ок. Но первое время появляются такие штуки:
```
SELECT id, LAG(neg) OVER(ORDER BY id) AS lg
FROM (
SELECT id, sm, -sm AS neg
FROM (
SELECT id, sum AS sm FROM transactions t
) t
) t1
```
И это еще не все — можно и побольше накрутить. Но зачем так, если можно так:
```
SELECT id, LAG(-sum) OVER(ORDER BY id) FROM transactions t
```
**Совет:** Если пока сложно, не надо сразу бросаться писать оптимизированными конструкциями. Напишите сначала, как сможете, а потом пытайтесь сократить.
Как говорил дядюшка Кнут:
> Преждевременная оптимизация — корень всех зол
>
>
7. Неправильное использование оконных функций
---------------------------------------------
Вообще говоря, оконные функции — довольно продвинутый инструмент. Считается, что им владеют специалисты уровня Middle и выше. Но по факту, их нужно знать всем — сейчас без них уже сложно жить (это чистое имхо).
И если базовые вещи по оконным функциям можно освоить довольно быстро, то всякая экзотика и нестандартное поведение осваивается, как правило, только на собственных шишках.
Одна из таких вещей — поведение оконной функции LAST\_VALUE и прочих.
Например, когда мы пишем запрос:
```
WITH cte AS (
SELECT 'Marketing' AS department, 50 AS employees, 2018 AS year
UNION
SELECT 'Marketing' AS department, 10 AS employees, 2019 AS year
union
SELECT 'Sales' AS department, 35 AS employees, 2018 AS year
UNION
SELECT 'Sales' AS department, 25 AS employees, 2019 AS year
)
SELECT c.*,
LAST_VALUE(employees) OVER (PARTITION BY department ORDER BY year) AS emp
FROM cte c
```
Мы ожидаем увидеть 2 раза по 10 для департамента Маркетинг и 2 раза по 25 для Продаж. Однако такой запрос дает иную картину:
Получается, что запрос тупо продублировал значения из столбца employees. Как так?
Лезем в документацию PostgreSQL и видим:
> Заметьте, что функции first\_value, last\_value и nth\_value рассматривают только строки в «рамке окна», которая по умолчанию содержит строки от начала раздела до **последней родственной строки для текущей**.
>
>
Ага, вот и ответ. То есть каждый раз у нас окно — это не весь набор строк, а только до текущей строки.
Получается, есть два способа вылечить такое поведение:
* Убрать ORDER BY
* Добавить определение рамки
Вот, например, второй вариант:
```
WITH cte AS (
SELECT 'Marketing' AS department, 50 AS employees, 2018 AS year
UNION
SELECT 'Marketing' AS department, 10 AS employees, 2019 AS year
union
SELECT 'Sales' AS department, 35 AS employees, 2018 AS year
UNION
SELECT 'Sales' AS department, 25 AS employees, 2019 AS year
)
SELECT c.*,
LAST_VALUE(employees) OVER (
PARTITION BY department
ORDER BY year ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
) AS emp
FROM cte c
```
Кстати, такую тему подняла наша подписчица в [Телеграме](https://t.me/it_resume) под постом [«7 самых важных оконных функций»](https://t.me/it_resume/1314). Спасибо ей!
А вас рады будем видеть в числе подписчиков :)
Эпилог
------
Эти 7 ошибок — не единственные, которые часто встречаются среди новичков и даже профессионалов. У нас есть еще одна пачка тезисов по этому поводу — но это уже тема другой статьи.
Если вам есть что добавить — будем рады продолжить обсуждение в комментариях. Возможно, чей-то код станет лучше и чище в результате нашей беседы :) | https://habr.com/ru/post/651965/ | null | ru | null |
# Поиск по дереву методом Монте-Карло и крестики-нолики
Так вышло, что для получение автомата по программированию бедным первокурам задали одну интересную задачу: написать программу, которая ищет по дереву методом Монте-Карло.
Конечно, всё началось с поиска информации в интернете. На великом и могучем русском языке было всего-лишь пара статей с Хабра, словесно объясняющие суть алгоритма, и статья из Википедии, перенаправляющая на проблему игры Го и компьютера. По мне — уже неплохое начало. Гуглю на английском языке для полноты и натыкаюсь на английскую статью с Википедии, в которой алгоритм так же словесно объясняется.
Немного теории
--------------
Метод Монте-Карло для поиска по дереву достаточно давно применяется в играх для искусственного интеллекта. Задача алгоритма — выбрать наиболее выигрышный вариант развития событий. Дерево представляет из себя структуру, в которой помимо хода и указателей есть количество сыгранных и количество выигранных партий. На основе этих двух параметров метод выбирает следующий шаг. Следующее изображение наглядно продемонстрирует работу алгоритма:
**Шаг 1: Выбор — Selection.** На этом шаге алгоритм выбирает ход своего противника. Если такой ход существует — мы его выберем, если нет — добавим.
**Шаг 2: Расширение — Expansion.** К выбранному узлу с ходом противника мы добавим узел со своим ходом и с нулевыми результатами.
**Шаг 3: Симуляция — Simulation.** Отыграем партию от текущего состояния игрового поля до чей-либо победы. Отсюда мы возьмём только первый ход (т.е. свой ход) и результаты.
**Шаг 4: Обратное распространение — Backpropagation.** Результаты из симуляции мы будем распространять от текущего до корня. Ко всем родительским узлам мы добавим единицу в количество сыгранных партий, а если мы наткнёмся на узел победителя — то в такой узел мы добавим единицу в количество выигранных партий.
В результате, бот с таким алгоритмом будет делать выигрышные для него ходы.
Собственно, алгоритм не такой сложный. Скорее, объёмный.
Реализация
----------
Алгоритм я решил реализовать в качестве бота для игры Крестики-нолики. Игра простая и для примера подойдёт отлично. Но дьявол кроется в деталях...
Проблема в том, что мы должны отыграть игру на шаге симуляции без реального игрока. Можно было, конечно, заставить алгоритм делать рандомные ходы в таких симуляциях, но мне хотелось какое-нибудь осмысленное поведение.
Тогда был написан простейший бот, который умел только две вещи — мешать игроку и делать рандомные ходы. Для симуляции этого было более чем достаточно.
Как и все, бот с алгоритмом располагал информацией о текущим состоянием поля, состоянием поля с прошлого хода, своим деревом ходов и текущим выбранным узлом в этом дереве. Начну с того, что я найду новый ход оппонента.
```
// 0. add node with new move.
bool exist = false;
int enemyx = -1, enemyy = -1;
this->FindNewStep ( __field, enemyx, enemyy );
for ( MCBTreeNode * node : this->mCurrent->Nodes )
{
if ( node->MoveX == enemyx && node->MoveY == enemyy )
{
exist = true;
this->mCurrent = node;
}
}
if ( !exist )
{
MCBTreeNode * enemymove = new MCBTreeNode;
enemymove->Parent = this->mCurrent;
enemymove->MoveX = enemyx;
enemymove->MoveY = enemyy;
enemymove->Player = (this->mFigure == TTT_CROSS) ? TTT_CIRCLE : TTT_CROSS;
this->mCurrent->Nodes.push_back ( enemymove );
this->mCurrent = enemymove;
}
```
Как видно, если есть такой ход противника в дереве, то мы выберем его. Если нет — добавим.
```
// 1. selection
// select node with more wins.
MCBTreeNode * bestnode = this->mCurrent;
for ( MCBTreeNode * node : this->mCurrent->Nodes )
{
if ( node->Wins > bestnode->Wins )
bestnode = node;
}
```
Здесь мы произведем выбор.
```
// 2. expanding
// create new node.
MCBTreeNode * newnode = new MCBTreeNode;
newnode->Parent = bestnode;
newnode->Player = this->mFigure;
this->mCurrent->Nodes.push_back ( newnode );
```
Расширим дерево.
```
// 3. simulation
// simulate game.
TTTGame::Field field;
for ( int y = 0; y < TTT_FIELDSIZE; y++ )
for ( int x = 0; x < TTT_FIELDSIZE; x++ )
field[y][x] = __field[y][x];
Player * bot1 = new Bot ();
bot1->SetFigure ( (this->mFigure == TTT_CROSS) ? TTT_CIRCLE : TTT_CROSS );
Player * bot2 = new Bot ();
bot2->SetFigure ( this->mFigure );
Player * current = bot2;
while ( TTTGame::IsPlayable ( field ) )
{
current->MakeMove ( field );
if ( newnode->MoveX == -1 && newnode->MoveY == -1 )
this->FindNewStep ( field, newnode->MoveX, newnode->MoveY );
if ( current == bot1 )
current = bot2;
else
current = bot1;
}
```
Сыграем игру между ботами. Думаю, здесь надо немного объясниться: текущее состояние поле копируется и боты доигрывают на этой копии, первым ходит второй бот и его первый ход мы запомним.
```
// 4. backpropagation.
int winner = TTTGame::CheckWin ( field );
MCBTreeNode * currentnode = newnode;
while ( currentnode != nullptr )
{
currentnode->Attempts++;
if ( currentnode->Player == winner )
currentnode->Wins++;
currentnode = currentnode->Parent;
}
```
И последнее: получим результат и распространим его вверх по дереву.
```
// make move...
this->mCurrent = newnode;
TTTGame::MakeMove ( __field, this->mFigure, mCurrent->MoveX, mCurrent->MoveY );
```
И в конце мы просто делаем ход и текущим узлом ставим наш новый узел из второго шага.
Заключение
----------
Как видно, алгоритм не такой страшный и сложный. Конечно, моя реализация далека от идеала, но суть и некоторое практическое применение она показывает.
Полный код доступен на моём [GitHub](https://github.com/NKozhevnikov/MonteCarloTreeSearch).
Всем добра. | https://habr.com/ru/post/330092/ | null | ru | null |
# Пишем блог на микросервисах – часть 1 «Общее описание»
В этой статье хочу поделится нашими c [SergeyMaslov](https://habr.com/ru/users/sergeymaslov/) наработками решения типовых задач с использованием микросервисной архитектуры на примере задачи «создание блога» (в надежде, что читатель представляет как устроен блог и это не должно вызывать вопросов по функциональности:)
Итак, наш блог будет состоять из 5 микросервисов, написанных на golang:
* API Gateway (api-gw) – отвечает за маршрутизацию, аутентификацию, логирование и трасировку запросов
* Пользователи (user) – регистрация/аутентификация пользователей, логирование, трасировка запросов
* Статьи (post) – создание/чтение/изменение/удаление статей (CRUD), логирование, трасировка и авторизация запросов
* Комментарии (comment) – создание/чтение/изменение/удаление комментариев (CRUD), логирование, трасировка и авторизация запросов
* Категории (category) – создание/чтение/изменение/удаление категорий (CRUD), логирование, трасировка и авторизация запросов
Клиентское приложение (web/frontend) будет реализован на vue.js и будет взаимодействовать с микросервисами через REST API, а сами микросервисы будут взаимодействовать друг с другом по gRPC.
В качестве хранилища мы будем использовать MongoDB.
Отдельной вишенкой на торте покажем, как с минимальными трудозатратами поддерживать документацию API (в формате swagger) в актуальном состоянии в активно развивающемся проекте.
#### Компонентная схема блога
Каждый микросервис будет реализован в отдельном Docker контейнере, а запуск проекта будет осуществляться с помощью docker-compose.
Сразу оговорюсь в примере, для упрощения процесса разработки, буду использовать два допущения, которые не следует использовать в продакшене.
* База данных развернута в Docker контейнере. Такой подход снижает надежность хранилища (за исключением схемы, о которой говорилось на HighLoad 2018).
* Весь проект размещен в одном git-репозитории. Этот подход противоречит одному из основных принципов микросервисной архитектуры — изолированность, и увеличивает вероятность появления межкомпонентной связанности.
Демо проекта можно посмотреть [здесь](http://85.143.220.160), а исходный код [здесь](https://github.com/msa-library/blog).
#### Структура проекта
#### Как будет построен процесса разработки
Как я уже ранее говорил, взаимодействие между микросервисами будет построено на основе gRPC. В двух словах gRPC это высокопроизводительный фреймворк, разработанный компанией Google, для вызова удаленных процедур (RPC) — работает поверх HTTP/2. В основе gRPC лежит так называемый протофайл (см. пример ниже), основная задача которого в компактной форме задекларировать две вещи:
* дать полный перечень интерфейсов сервиса (аналог API интерфейсов);
* описать что подается на вход каждого интерфейса и что получаем на выходе.
Ниже, в качестве примера, приведен протофайла сервис Category.
```
syntax = "proto3";
package protobuf;
import "google/api/annotations.proto";
//Описание интерфейсов сервиса Category
service CategoryService {
//Создание записи
rpc Create (CreateCategoryRequest) returns (CreateCategoryResponse) {
option (google.api.http) = {
post: "/api/v1/category"
};
}
//Обновление записи
rpc Update (UpdateCategoryRequest) returns (UpdateCategoryResponse) {
option (google.api.http) = {
post: "/api/v1/category/{Slug}"
};
}
//Удаление записи
rpc Delete (DeleteCategoryRequest) returns (DeleteCategoryResponse) {
option (google.api.http) = {
delete: "/api/v1/category/{Slug}"
};
}
//Возвращает запись по SLUG
rpc Get (GetCategoryRequest) returns (GetCategoryResponse) {
option (google.api.http) = {
get: "/api/v1/category/{Slug}"
};
}
//Поиск
rpc Find (FindCategoryRequest) returns (FindCategoryResponse) {
option (google.api.http) = {
get: "/api/v1/category"
};
}
}
//------------------------------------------
// CREATE
//------------------------------------------
message CreateCategoryRequest {
string ParentId = 1;
string Name = 2;
string Path = 3;
}
message CreateCategoryResponse {
Category Category = 1;
}
//------------------------------------------
// UPDATE
//------------------------------------------
message UpdateCategoryRequest {
string Slug = 1;
string ParentId = 2;
string Name = 4;
string Path = 5;
int32 Status = 6;
}
message UpdateCategoryResponse {
int32 Status =1;
}
//------------------------------------------
// DELETE
//------------------------------------------
message DeleteCategoryRequest {
string Slug = 1;
}
message DeleteCategoryResponse {
int32 Status =1;
}
//------------------------------------------
// GET
//------------------------------------------
message GetCategoryRequest {
string Slug = 1;
}
message GetCategoryResponse {
Category Category = 1;
}
//------------------------------------------
// FIND
//------------------------------------------
message FindCategoryRequest {
string Slug = 1;
}
message FindCategoryResponse {
repeated Category Categories = 1;
}
//------------------------------------------
// CATEGORY
//------------------------------------------
message Category {
string Slug = 1;
string ParentId = 2;
string Path = 3;
string Name = 4;
int32 Status = 5;
}
```
Теперь, когда мы в общих чертах разобрались зачем нужен протофайл, посмотрим как будет выглядеть процесс разработки наших микросервисов:
1. Описываем структуру сервис в протофайле;
2. Запускаем генератор кода (./bin/protogen.sh), он сгенерит нам основную часть серверного кода + создаст клиентский код, например, для API Gateway + создаст актуальную документацию в формате swagger;
3. Все что нам останется сделать своими руками, это написать код реализацию интерфейсов в специальном файле /protobuf/functions.go.
Далее, если мы захотим внести изменения в один из наших микросервисов, действуем по вышеописанному алгоритму: правим протофайл, запускаем protogen, правим реализацию в functions.go, а в документацию и к клиентам изменения “уедут” автоматически.
Продолжение в статье [«Пишем блог на микросервисах часть 2 API Gateway»](https://habr.com/ru/post/473516/). | https://habr.com/ru/post/473514/ | null | ru | null |
# Функциональное программирование в Java
Сейчас появляются новые модные языки использующие парадигму функционального программирования. Тем не менее, в обычной Java
можно использовать функции для описания поведения объектов. Причём делать это можно полностью в рамках синтаксиса Java.
Я опубликовал Java-библиотеку позволяющую связывать (binding) объекты через функции (см. <https://code.google.com/p/tee-binding/> )
##### Описание классов
public class It‹E›
— основной класс, содержит ссылку на объект любого типа и обновляет все связи при изменении значений в одном из экземпляров. Пример
```
It‹String› a1 = new It‹String›().value("A");
It‹String› a2 = new It‹String›().value("B");
System.out.println("a1: "+a1.value()+", a2: "+a2.value());
a1.bind(a2);
System.out.println("a1: "+a1.value()+", a2: "+a2.value());
a1.value("C");
System.out.println("a1: "+a1.value()+", a2: "+a2.value());
a2.value("D");
System.out.println("a1: "+a1.value()+", a2: "+a2.value());
```
результат:
```
a1: A, a2: B
a1: B, a2: B
a1: C, a2: C
a1: D, a2: D
```
Класссы Number, Note, Toggle являются производными класса It для хранения значений конкретного типа (соответственно для Double, String и Boolean) и содержат методы задания связывания с использованием функций. Пример:
```
Numeric c = new Numeric().value(0);
Numeric f = c.multiply(9.0).divide(5.0).plus(32.0);
System.out.println("f: " + f.value() + ", c: " + c.value());
System.out.println("/let f = 100 ");
f.value(100);
System.out.println("f: " + f.value() + ", c: " + c.value());
System.out.println("/let c = 100 ");
c.value(100);
System.out.println("f: " + f.value() + ", c: " + c.value());
```
результат:
```
f: 32.0, c: 0.0
/let f = 100
f: 100.0, c: 37.77777777777778
/let c = 100
f: 212.0, c: 100.0
```
как видно, это функция конвертации температуры из шкалы Цельсия в шкалу Фаренгейта (F' = C' \* 9 / 5 + 32). Из определения переменной
`Numeric f = c.multiply(9.0).divide(5.0).plus(32.0);`
это вполне очевидно. Также можно отметить что связывание через функцию является двунаправленным.
*Примечание: псевдооператоры функции вычисляются последовательно без учёта приориетета операций.*
Для более сложных случаев можно использовать класс Fork. Он позволяет использовать в связывании условия, пример:
```
System.out.println("/n = -10");
Numeric n = new Numeric().value(-10);
Note r = new Note().bind(new Fork‹String›()
.condition(new Toggle().less(n, -5))
.then("Frost")
.otherwise(new Fork‹String›()
.condition(new Toggle().less(n, +15))
.then("Cold")
.otherwise(new Fork‹String›()
.condition(new Toggle().less(n, +30))
.then("Warm")
.otherwise("Hot")
)));
System.out.println(r.value());
System.out.println("/let n = +10");
n.value(10);
System.out.println(r.value());
System.out.println("/let n = +20");
n.value(20);
System.out.println(r.value());
System.out.println("/let n = +40");
n.value(40);
System.out.println(r.value());
```
результат:
```
/n = -10
Frost
/let n = +10
Cold
/let n = +20
Warm
/let n = +40
Hot
```
Запись условия вполне наглядна, в зависимости от значения переменной n, в переменную r заносится текст Frost, Cold, Warm или Hot.
##### Применение библиотеки
К сожалению, связывание и функции нельзя использовать непосредственно. Рассмотрим модификации необходимые для применения связывания в Swing:
```
class BindableLabel extends JLabel {
private Note bindableValue = new Note().value("").afterChange(new Task() {
@Override public void job() {
if (bindableValue != null) {
setText(bindableValue.value());
}
}
});
public Note bindableValue() {
return bindableValue;
}
public BindableLabel() {
super();
}
}
```
это класс расширяющий стандартный JLabel. Он позволяет обновлять связывать текст надписи с переменно имеющий тип Note.
Для редактируемых Swing-компонентов также придётся добавить ChangeListener. Пример определения поведения компонентов из формы на скриншоте:
```
void bindComponents() {
Numeric celsius = new Numeric().value(0);
Numeric fahrenheit = celsius.multiply(9.0).divide(5.0).plus(32.0);
fahrenheitSlider.bindableValue().bind(fahrenheit);
fahrenheitSpinner.bindableValue().bind(fahrenheit);
celsiusSlider.bindableValue().bind(celsius);
celsiusSpinner.bindableValue().bind(celsius);
```
— как видно, это занимает всего несколько строк и при редактировании любого значения в форме (или перемещения ползунка слайдера) остальные компоненты мгновенно обновляют своё состояние. | https://habr.com/ru/post/127076/ | null | ru | null |
# ESET обнаружила банкер BackSwap, использующий новый метод манипуляции браузером
Банковские трояны в последние годы теряют популярность среди киберпреступников. Одна из причин – развитие технологий защиты антивирусных вендоров и разработчиков веб-браузеров. Провести атаку с помощью банкера сложно, поэтому многие вирусописатели переходят на более простые и выгодные инструменты: шифраторы, майнеры, ПО для кражи криптовалют.
Многие, но не все. Мы обнаружили новое семейство банкеров, использующее для манипуляций с браузером новую технику. Вместо сложного внедрения кода в процесс браузера для мониторинга его активности, малварь перехватывает события Windows в цикле ожидания сообщений, чтобы проверять значения объектов, связанных с банковскими операциями.
Обнаружив работу с онлайн-банкингом, малварь инжектирует вредоносный JavaScript в веб-страницу – через консоль разработчика в браузере, либо напрямую в адресную строку. Операции производятся без ведома и участия пользователя. Простая на первый взгляд схема позволяет обходить продвинутые механизмы защиты браузеров от комплексных атак.
### Введение
Мы впервые заметили данную кибергруппу в январе 2018 года, когда она распространяла ранние разработки – например, программу для кражи криптовалюты путем подмены адреса кошелька в буфере обмена. Группа занималась криптовалютой несколько месяцев, после чего выпустила первую версию банкера – с 13 марта антивирусные продукты ESET детектируют его как Win32/BackSwap.A.
На графике ниже можно наблюдать резкий скачок обнаружений по сравнению с предыдущими проектами, согласно нашей статистике. Авторы совершенствуют банкер и выпускают новые версии почти каждый день (с перерывами на выходные).
*Рисунок 1. Обнаружения Win32/BackSwap.A и связанных с ним предыдущих проектов*
### Распространение и исполнение
Win32/BackSwap.A распространяется в спам-письмах, содержащих во вложении обфусцированный JavaScript-загрузчик из семейства Nemucod. В настоящее время эти рассылки ориентированы на пользователей из Польши.
Мы нередко обнаруживали на машинах жертв [еще](https://www.welivesecurity.com/2013/08/26/nymaim-obfuscation-chronicles/) [один](https://www.welivesecurity.com/2013/10/23/nymaim-browsing-for-trouble/) [известный](https://www.welivesecurity.com/2016/07/12/nymaim-rides-2016-reaches-brazil/) загрузчик Win32/TrojanDownloader.Nymaim, вероятно, распространяющийся тем же способом. В настоящее время мы не знаем, совпадение это или семейства связаны друг с другом.
Полезная нагрузка доставляется в виде модифицированной версии легитимного приложения, частично переписанного вредоносным компонентом. Приложение, используемое для модификации, регулярно меняется – мы наблюдали в этом качестве TPVCGateway, SQLMon, DbgView, WinRAR Uninstaller, 7Zip, OllyDbg и FileZilla Server.
Приложение модифицируют таким образом, что оно переходит на вредоносный код после его инициализации. Для этого авторы добавляют указатель на вредоносный компонент в таблицу функций `_initterm()`, внутреннюю часть среды выполнения библиотек языка С, которая инициализирует глобальные переменные и другие части программы перед вызовом функции main().
*Рисунок 2. Массив указателей \_initterm легитимного приложения, в конце которого добавлен указатель на шеллкод банкера*
Метод напоминает троянизацию; разница в том, что в нашем случае оригинальное приложение прекращает работу после инициализации малвари. Цель метода – не маскировка от пользователя, а, скорее, противодействие детектированию и исследованию. Аналитикам сложнее обнаружить этот банкер, поскольку многие инструменты реверс-инжиниринга, такие как IDA Pro, показывают оригинальную функцию main() как легитимное начало кода приложения. Не факт, что аналитик с первого взгляда заметит что-то подозрительное.
Полезная нагрузка – позиционно-независимый объект бинарного кода с встроенными данными. Символьные строки хранятся в виде простого текста, что позволяет замести и без того малозаметные следы, так как все требуемые Windows API ищутся в ходе работы хешированием. В начале работы малварь обеспечивает персистентность, копируя себя в папку автозагрузки, после чего переходит к функциям банкера.
### Традиционные методы инжекта
Обычный банкер для кражи средств со счета жертвы через интерфейс онлайн-банкинга внедряет себя или специальный модуль в адресное пространство процесса браузера. По ряду причин это непростая задача. Прежде всего, инъекция может быть перехвачена антивирусным продуктом. Кроме того, разрядность внедряемого модуля должна совпасть с разрядностью браузера – 32-битный модуль не внедрить в 64-битный процесс и наоборот. В результате для атаки нужны две версии одного и того же модуля – 32-/64-бит.
После успешного инжекта банковский модуль должен обнаружить функции, относящиеся к браузеру, и перехватить их. Ему нужны функции, отвечающие за отправку и получение НТТР-запросов в формате простого текста до шифрования и после расшифровки соответственно. Сложность поиска функций варьируется от браузера к браузеру. В Mozilla Firefox они экспортируются библиотекой nss3.dll, и их адреса легко найти по их известным именам. Google Chrome и другие браузеры на платформе Chromium скрывают эти функции. Это вынуждает вирусописателей придумывать специальные схемы, нацеленные на конкретную версию браузера, и менять тактику при выходе новых версий.
Если функции найдены и перехват произведен (и его не обнаружило антивирусное решение), банкер может изменять НТТР-трафик или перенаправлять жертву на сайты, которые имитируют легитимные ресурсы онлайн-банкинга, подделывая сертификаты. Подобные методы используют известные банковские трояны [Dridex](https://habr.com/company/eset/blog/348364/), [Ursnif, Zbot, Trickbot, Qbot](https://www.virusbulletin.com/uploads/pdf/conference_slides/2017/Kalnai-VB2017-browser-attack-points-trojans.pdf) и многие другие.
### Новый метод манипуляции браузером
В Win32/BackSwap.A реализован совершенно другой подход. Банкер использует элементы графической оболочки Windows и имитацию пользовательского ввода. Метод может показаться тривиальным, но он эффективен, поскольку позволяет решить известные проблемы традиционного инжекта. Во-первых, малварь не взаимодействует с браузером на уровне процесса. Благодаря этому отсутствует необходимость в специальных привилегиях и обходе антивирусов, защищающих от обычного инжекта. Второе преимущество для атакующих – банкер не зависит ни от архитектуры браузера, ни от его версии; работает один код для всех.
Малварь отслеживает URL посещаемой страницы, устанавливая перехватчики событий (event hooks) для определенного диапазона релевантных событий доступных через цикл ожидания сообщений Windows, таких как EVENT\_OBJECT\_FOCUS, EVENT\_OBJECT\_SELECTION, EVENT\_OBJECT\_NAMECHANGE и нескольких других. Обработчик ищет значения URL с помощью поиска по объектам строк, которые начинаются с НТТРS, получаемых вызовом метода `get_accValue` из интерфейса события `IAccessible`.
*Рисунок 3. Прием, используемый для получения URL текущей страницы в браузере. Эти адреса получены через проверку подстроки [ht]tp[s] (выделено красным)*
Затем Win32/BackSwap.A ищет адреса, относящиеся к банкам, и заголовки окон в браузере, указывающие на то, что пользователь готовит денежный перевод.
*Рисунок 4. Банкер ищет строки кода, относящиеся к определенным банкам. Первая строка – заголовок окна, вторая – часть URL*
Обнаружив искомое, банкер загружает вредоносный JavaScript, соответствующий определенному банку, и внедряет его в браузер. Инжект производится простым, но эффективным способом.
В старых образцах Win32/BackSwap.A вставляет вредоносный скрипт в буфер обмена и имитирует нажатие комбинации клавиш, чтобы открыть консоль разработчика (CTRL+SHIFT+J в Google Chrome, CTRL+SHIFT+K в Mozilla Firefox), затем вставляет содержимое буфера (CTRL+V) и «нажимает» ENTER для выполнения содержимого консоли. Затем малварь повторяет комбинацию клавиш, чтобы закрыть консоль. На это время окно браузера становится невидимым – обычный пользователь, скорее всего, подумает, что браузер на несколько секунд завис.
В новых вариантах схема усовершенствована. Вместо взаимодействия с консолью разработчика вредоносный скрипт выполняется напрямую из адресной строки через [специальный протокол JavaScript](https://msdn.microsoft.com/en-us/library/aa767736(v=vs.85).aspx), малоиспользуемую функцию, которую поддерживает большинство браузеров. Банкер имитирует нажатие CTRL+L для выбора адресной строки, DELETE – для очистки поля, «вводит» символы на «javascript» через вызов SendMessageA в цикле, после чего вставляет вредоносный скрипт с помощью комбинации CTRL+V. Скрипт выполняется после «нажатия» ENTER. В конце процесса адресная строка очищается, чтобы убрать следы компрометации.
На рисунке 5 можно видеть часть инжектируемого кода в консоли. Сначала Win32/BackSwap.A определяет браузер путем проверки имени класса выбранного окна (отмечено синим). Вредоносный JavaScript копируется в буфер (отмечено красным). Затем значение прозрачности окна браузера меняется на «3», что делает его невидимым (отмечено фиолетовым). Зеленым выделена часть, относящаяся к функции `ToggleBrowserConsole`, которая включает и выключает консоль.
*Рисунок 5. Инжект скрипта*
Win32/BackSwap.A поддерживает атаки на Google Chrome и Mozilla Firefox, в последних версиях появилась поддержка Internet Explorer. Метод подходит для большинства браузеров с консолью разработчика или возможностью выполнения кода JavaScript из адресной строки (стандартные функции браузера).
Три браузера, подверженные компрометации, имеют интересную [функцию защиты](https://blogs.msdn.microsoft.com/ieinternals/2011/05/19/socially-engineered-xss-attacks/), разработанную для предотвращения [атак Self-XSS](https://en.wikipedia.org/wiki/Self-XSS): когда пользователь пробует вставить скопированный текст, начинающийся с «javascript:» в адресную строку, префикс протокола удаляется, и его нужно снова вводить вручную для исполнения скрипта. Win32/BackSwap.A обходит это препятствие через имитацию посимвольного ввода префикса в адресную строку перед вставкой скопированного вредоносного скрипта.
Еще один инструмент защиты реализован в Mozilla Firefox. Браузер запрещает копировать скрипты в консоль по умолчанию; вместо этого он показывает уведомление о возможных рисках и заставляет пользователя сначала вводить вручную фразу «allow pasting», чтобы разрешить вставку скопированных символов. Для обхода этой меры безопасности в Win32/BackSwap.A предусмотрено исполнение шелл-команды (рисунок 6), которая вносит изменения в файл конфигурации `prefs.js` и удаляет эту защиту.
*Рисунок 6. Шелл-команда, убирающая защиту от вставки скрипта в консоль Firefox*
### Вредоносный код на JavaScript
Win32/BackSwap.A использует специальный скрипт для каждого из целевых банков. Поскольку у всех банков разные сайты, код различается и имеет разные переменные. Скрипты инжектируются в страницы, на которых, по оценке банкера, осуществляется подготовка денежного перевода. Внедренные скрипты скрытно заменяют номер счета получателя другим, и, когда жертва отправит перевод, деньги поступят на счет атакующих. Меры противодействия несанкционированным переводам (двухфакторная аутентификация) бессильны, поскольку владелец счета подтверждает отправку средств.
Авторы Win32/BackSwap.A написали скрипты для работы с пятью польскими банками: PKO Bank Polski, Bank Zachodni WBK S.A., mBank, ING и Pekao. Операторы убирают некоторые банки из списка целей – в большинстве новых версий осталось три банка: PKO BP, mBank и ING. В старых версиях атакующие передают номер счета получателя с C&C-серверов на взломанных сайтах на WordPress. В новых версиях номера хранятся в самих вредоносных скриптах. Счета часто меняются – новый номер счета используется почти в каждой новой кампании.
Банкер интересуют переводы в определенном диапазоне – как правило, от 10 000 до 20 000 польских злотых (168 000–337 000 рублей). Скрипт не только подменяет номер счета получателя, но и заменяет поле ввода на фейковое – пользователь видит корректный номер и ничего не подозревает.
*Рисунок 7. Часть вредоносного кода на JavaScript. Участки, отмеченные красным, отвечают за проверку суммы перевода и замену номера счета получателя*
### Заключение
Win32/BackSwap.A доказывает, что в противостоянии между индустрией безопасности и вирусописателями не всегда нужна новая сложная техника и тактика. Браузеры усиливают защиту от инжекта кода, поэтому авторы малвари переключились на другие методы атак, и в Win32/BackSwap.A реализован только один.
Антивирусные [продукты ESET](https://www.esetnod32.ru/home/products/) детектируют угрозу как Win32/BackSwap.A.
Специалисты ESET сообщили разработчикам браузеров, подверженных компрометации, о новом методе атак.
### IoCs
`9BC4C1D5403DDD90712CE87225490A21D1EDC516 JS/Nemucod.EAN trojan
CF5A74C268661501156663F74CD5E20603B0F261 Win32/BackSwap.A trojan
6251F9AD0E5F551AC4A6B918EF366E86C4CCFDC4 Win32/BackSwap.A trojan
2DC9760A7C6E9D261C73EFB7B2604840734BC058 Win32/BackSwap.A trojan
A68901D0D8C1247FF280F9453E3AE45687C57566 Win32/BackSwap.A trojan (JavaScript)` | https://habr.com/ru/post/413307/ | null | ru | null |
# Применение паттерна observer в Redux и Mobx
Паттерн "observer" известен наверное с момента появления самого ооп. Упрощенно можно представить что есть объект который хранит список слушателей и имеет метод "добавить", "удалить" и "оповестить", а внешний код либо подписывается либо оповещает подписчиков
```
class Observable {
listeners = new Set();
subscribe(listener){
this.listeners.add(listener)
}
unsubscribe(listener){
this.listeners.delete(listener)
}
notify(){
for(const listener of this.listeners){
listener();
}
}
}
```
В redux-е этот паттерн применяется без всяких изменений — пакет "react-redux" предоставляет функцию `connect` которая оборачивает компонент и при вызове componentDidMount вызовет `subscribe()` метод у `Observable`, при вызове `componentWillUnmount()` вызовет `unsubscribе()` а `dispatch()` просто вызовет метод `trigger()` который в цикле вызовет всех слушателей где каждый в свою очередь вызовет `mapStateToProps()` и потом в зависимости от того изменилось ли значение — вызовет `setState()` на самом компоненте. Все очень просто, но платой за такую простоту реализации является необходимость работать с состоянием иммутабельно и нормализировать данные а при изменении отдельного объекта или даже одного свойства оповещать абсолютно всех подписчиков-компонентов даже если они никак не зависят от той измененной части состояния и при этом в компоненте-подписчике необходимо явно указывать от каких частей стора он зависит внутри `mapStateToProps()`
Mobx очень похож на redux тем что использует этот паттерн observer только развивает его еще дальше — что если мы не будем писать `mapStateToProps()` а сделаем так чтобы компоненты зависели от данных которые они "рендерят" самостоятельно , по отдельности. Вместо того чтобы собирать подписчиков на одном объекте состояния всего приложения, подписчики будут подписываться на каждое отдельное поле в состоянии. Это как если бы для юзера, у которого есть поля `firstName` и `lastName` мы создали бы целый redux-стор отдельно для `firstName` и отдельно для `lastName`.
Таким образом, если мы найдем легкий способ создавать такие "сторы" и подписываться на них, то `mapStateToProps()` будет не нужен, потому что эта зависимость от разных частей состояния уже выражается в существовании разных сторов.
Итак на каждое поле у нас будет по отдельному "мини-стору" — объекту observer где кроме `subscribe()`, `unsubscribe()` и `trigger()` добавится еще поле `value` а также методы `get()` и `set()` и при вызове `set()` подписчики вызовутся только если само значение изменилось.
```
class Observable {
listeners = new Set();
constructor(value){
this.value = value
}
get(){
return this.value;
}
set(newValue){
if(newValue !== this.value){
this.notify();
}
}
subscribe(listener){
this.listeners.add(listener)
}
unsubscribe(listener){
this.listeners.delete(listener)
}
notify(){
for(const listener of this.listeners){
listener();
}
}
}
const user = {
fistName: new Observable("x"),
lastName: new Observable("y"),
age: new Observable(0)
}
const listener = ()=>console.log("new firstName");
user.firstName.subscribe(listener)
user.firstName.get()
user.firstName.set("new name");
user.firstName.unsubscribe(listener);
```
Вместе с этим требование иммутабельности стора нужно трактовать немного по-другому — если мы в каждом отдельном сторе будем хранить только примитивные значение, то с точки зрения redux нет ничего зазорного в том чтобы вызвать `user.firstName.set("NewName")` — поскольку строка это иммутабельное значение — то здесь происходит просто установка нового иммутабельного значения стора, точно так же как и в redux. В случаях когда нам нужно сохранить в "мини-сторе" объект или сложные структуры то можно просто вынести их в отдельные "мини-сторы". Например вместо этого
```
const user = {
profile: new Observable({email: "...", address: "..."})
}
```
лучше написать так чтобы компоненты могли по отдельности зависеть то от `"email"` то от `"address"` и чтобы не было лишних "перерендеров"
```
const user = {
profile: {
email: new Observable("..."),
address: new Observable("..."}
}
}
```
Второй момент — можно заметить что с таким подходом мы будем вынуждены на каждый доступ к свойству вызывать метод `get()`, что добавляет неудобств.
```
const App = ({user})=>(
{user.firstName.get()} {user.lastName.get()}
)
```
Но эта проблема решается через геттеры и сеттеры javascript-а
```
class User {
_firstName = new Observable("");
get firstName(){ return this._firstName }
set firstName(val){ this._firstName = val }
}
```
А если вы не относитесь негативно к декораторам то этот пример можно еще больше упростить
```
class User {
@observable firstName = "";
}
```
В общем можно пока подвести итоги и сказать что 1) никакой магии в этом моменте нет — декораторы это всего лишь геттеры и сеттеры 2) геттеры и сеттеры всего лишь считывают и устанавливают root-state в "мини-сторе" а-ля redux
Идем дальше — для того чтобы подключить все это к реакту нужно будет в компоненте подписаться на поля которые в нем выводятся и потом отписаться в `componentWillUnmount`
```
this.listener = ()=>this.setState({})
componentDidMount(){
someState.field1.subscribe(this.listener)
....
someState.field10.subscribe(this.listener)
}
componentWillUnmount(){
someState.field1.unsubscribe(this.listener)
....
someState.field10.unsubscribe(this.listener)
}
```
Да, при росте полей которые выводятся в компоненте, количество болерплейта будет возрастать многократно но одним небольшим движением ручную подписку можно убрать полностью если добавить несколько строчек кода — поскольку в шаблонах так или иначе будет вызываться метод `.get()` чтобы отрендерить значение то мы можем воспользоваться этим чтобы сделать автоматическую подписку — если перед вызовом метода `render()` компонента мы запишем в глобальной переменной текущий массив то в методе `.get()` мы просто добавим `this` в этот массив и потом в к конце вызова метода `render()` мы получим массив всех “мини-сторов” на которые подписан текущий компонент. Этот простой механизм решает даже ситуации когда сторы на которые подписан компонент динамически меняются во время рендера — например когда компонент рендерит `{user.firstName.get().length < 5 ? user.firstName.get() : user.lastName.get()}` ( если длина имени меньше 5 компонент не будет реагировать (то есть не будет подписан) на изменение фамилии а подписка автоматически произойдет когда длина имени будет больше-равно 5)
```
let CurrentObservables = null;
class Observable {
listeners = new Set();
constructor(value){
this.value = value
}
get(){
if(CurrentObservables) CurrentObservables.add(this);
return this.value;
}
set(newValue){
if(newValue !== this.value){
this.notify();
}
}
subscribe(listener){
this.listeners.add(listener)
}
unsubscribe(listener){
this.listeners.delete(listener)
}
notify(){
for(const listener of this.listeners){
listener();
}
}
}
function connect(target){
return class extends (React.Component.isPrototypeOf(target) ? target : React.Component) {
stores = new Set();
listener = ()=> this.setState({})
render(){
this.stores.forEach(store=>store.unsubscribe(this.listener));
this.stores.clear();
const prevObservables = CurrentObservables;
CurrentObservables = this.stores;
cosnt rendered = React.Component.isPrototypeOf(target) ? super.render() : target(this.props);
this.stores = CurrentObservables;
CurrentObservables = prevObservables;
this.stores.forEach(store=>store.subscribe(this.listener));
return rendered;
}
componentWillUnmount(){
this.stores.forEach(store=>store.unsubscribe(this.listener));
}
}
}
```
Здесь функция `connect` оборачивает компонент или stateless-component (функцию) реакта и возвращает компонент который благодаря этому механизму автоподписки подписывается на нужные "мини-сторы".
В итоге у нас получился такой вот механизм автоподписок только на нужные данные и оповещений только когда эти данные изменились. Компонент будет обновляться только тогда когда изменились только те "мини-сторы" на которые он подписан. Учитывая, что в реальном приложении, где может быть тысячи этих "мини-сторов", с данным механизмом множественных сторов при изменении одного поля будут обновляться только те компоненты которые находятся в массиве подписчиков на это поле, а вот подходом redux когда мы подписываем все эти тысячи компонентов на один единственный стор, при каждом изменении нужно оповещать в цикле все эти тысячи компонентов (и при этом заставляя программиста вручную описывать от каких частей состояния зависят компоненты внутри `mapStateToProps`)
Более того этот механизм автоподписок способен улучшить не только redux а и такой паттерн как мемоизацию функций, и заменить библиотеку reselect — вместо того чтобы явно указывать в createSelector() от каких данных зависит наша функция, зависимости будут определяться автоматически точно так же выше сделано с функцией render()
Вывод
-----
Mobx это логичное развитие паттерна observer для решения проблемы "точечных" обновлений компонентов и мемоизации функций. Если немного отрефакторить и вынести код в примере выше из компонента в `Observable` и вместо вызова `.get()` и `.set()` поставить геттеры и сеттеры, то мы почти что получим `observable` и `computed` декораторы mobx-а. Почти — потому что у mobx вместо простого вызова в цикле находится более сложный алгоритм вызова подписчиков для того чтобы исключить лишние вызовы `computed` для ромбовидных зависимостей, но об этом в следующей статье.
upd: Появилось [продолжение](https://habrahabr.ru/post/349022/) статьи | https://habr.com/ru/post/348960/ | null | ru | null |
# Решаем проблемы с установкой Web Optimizer
[](http://code.google.com/p/web-optimizator/)После многочисленных установок приложения для автоматического ускорения сайтов — [Web Optimizer](http://code.google.com/p/web-optimizator/) на [Joomla!](http://joomla.org/) (как версии 1.0, так и 1.5) было решено собрать воедино полезное знание о возникающих проблемах (связанных, в основном, с текущим некорректным серверным окружением), чтобы позволить их самостоятельно решить большому числу пользователей.
Итак, давайте разбираться по порядку, что нам делать в следующих случаях.
Загрузить Web Optimizer: [code.google.com/p/web-optimizator/downloads/list](http://code.google.com/p/web-optimizator/downloads/list)
### Функционирование Web Optimizer
Довольно часто приходится разобраться с тем, работает ли Web Optimizer на сайте, или его установка каким-то образом не подключилась к обработке HTML-документа. Начиная с версии 0.5.2 это можно установить, найдя строку в коде страницы (если метка там отсутствует, значит Web Optimizer не отрабатывает).
Для более ранних версий это решение можно принять на основе отсутствия в коде HTML-документа отступов в начале строки, двойных переводов строк или наличия характерных закэшированных имен файлов в `head`-секции (`cache/1234a6789b.css` или `cache/1234c6789d.js`, здесь `1234c6789d` — произвольная строка в шестнадцатеричной записи).
Если обнаружить следы работы Web Optimizer не удалось, то необходимо перепроверить корректность вызовов Web Optimizer в файлах системы управления сайтом и, возможно, провести установку приложения еще раз — таким образом Web Optimizer сможет самостоятельно произвести все необходимые изменения.
Если нужно получить информацию о необходимых изменениях исходных файлов CMS, то следует в ходе установки отключить автоматическое изменение `/index.php`:
>
> ```
> Изменение /index.php -> Включить авто-запись -> Нет
> ```
>
и на последнем шаге зайти на вкладку «Необходимые изменения».
### «Кракозяблы» вместо сайта
Обычно это связано с двойным сжатием HTML-документа. Одно из сжатий может быть наложено самим Web Optimizer, а второе — как используемой системой управления сайтом, так и сервером.
Чтобы снять одно из накладываемых сжатий, можно отключить его либо в CMS, либо в конфигурации сервера, либо в самом Web Optimizer:
>
> ```
> Настройки архивирования -> Применить gzip для HTML -> Нет
> ```
>
### Белый экран вместо сайта
Основная проблема возникновения белого экрана (превышение лимита памяти при создании CSS Sprites) уже устранена в версии 0.5+, поэтому если у вас более старая версия, то стоит просто ее обновить.
Также стоит заглянуть в логи ошибок вашего сервера, чтобы узнать, что привело к такому состоянию. Обычно это помогает решить проблему.
В некоторых случаях белый экран возникает из-за некорректной установки приложения либо двойного сжатия. Как решить эти проблемы, описано чуть выше.
Если все приведенные шаги не принесли результата, то можно попробовать отключить часть настроек Web Optimizer, чтобы понять, какие вещи ваш сервер может выполнить самостоятельно. Начать стоит с корневого набора («Настройки сжатия» и «Настройки архивирования») для всех трех групп (CSS, JavaScript, HTML) действий по оптимизации и двигаться в сторону подключения более детальных параметров (например, «Включить внешние файлы», «Вечное» кэширование» или «CSS Sprites»).
### Некорректный внешний вид
Это может быть причиной различных проблем, но для начала можно попробовать отключить CSS Sprites:
>
> ```
> CSS Sprites -> Применить CSS Sprites -> Нет
> ```
>
затем, если это не помогло ситуации, можно отключить `data:URI`:
>
> ```
> Data:URI -> Применить data:URI -> Нет
> ```
>
После этих шагов все подключаемые CSS-файлы не будут обрабатываться через CSS Tidy, а будут только объединяться (и будет выполняться первичная минимизация).
Если и после этого внешний вид сайта «разъехался», то стоит отключить объединение стилей внутри `head`
>
> ```
> Включить внешние файлы -> Включить объединение внешних CSS-файлов -> Нет
> ```
>
млм вообще минимизацию для CSS-файлов
>
> ```
> Настройки сжатия -> Минимизировать и объединить CSS-файлы -> Нет
> ```
>
Если есть желание разобраться в возникшей проблеме более детально, то можно при отключенном объединении стилей внутри `head` попробовать исключить один за другим при помощи следующей настройки:
>
> ```
> Включить внешние файлы -> Исключить из объединения файлы -> Список файлов через пробел
> ```
>
Найти тот файлы (или те файлы), которые обрабатываются некорректно, привести их к стандартному состоянию при помощи валидатора [jigsaw.w3.org/css-validator/](http://jigsaw.w3.org/css-validator/) и попробовать объединить снова.
### Пропавшие или неправильные фоновые изображения
В некоторых случаях проблемы после установки Web Optimizer сводятся к тому, что некоторые фоновые изображения пропадают или «портятся». Для решения этого набор проблем необходимо установить, с какими первоначальными фоновыми изображениями возникают трудности (используя любые средства для отладки верстки) и исключить эти изображения из процесса создания CSS Sprites:
>
> ```
> CSS Sprites -> Исключить из CSS Sprites файлы -> Список файлов через пробел
> ```
>
Если данная мера не приносит результата, то CSS Sprites можно вообще выключить:
>
> ```
> CSS Sprites -> Применить CSS Sprites -> Нет
> ```
>
### Некорректное поведение сайта
Обычно это сводится к тому, что часть клиентской логики перестает отрабатывать. Нужно хорошо понимать, что если, например, форма для ввода комментариев у вас на сайте выводится при помощи JavaScript, и после Web Optimizer она перестала выводиться, то это проблемы не внешнего вида, а клиентской логики.
Для локализации проблемы с клиентской логикой рекомендуется попробовать отключить минимизацию JavaScript-файлов:
>
> ```
> Настройки сжатия -> Минимизировать и объединить JavaScript-файлы -> Нет
> ```
>
а потом (при сохранении проблемы) попробовать исключить один за другим отдельные файлы:
>
> ```
> Включить внешние файлы -> Исключить из объединения файлы -> Список файлов через пробел
> ```
>
При установлении имени файла, на котором объединение отказывает, можно просто его исключить из общего пакета либо попытаться настроить его корректное включение в первоначальную логику (обычно ошибки происходят из-за некорректного синтаксиса исходных файлов, которые не конфликтуют внутри одного окружения-файла, но начинают конфликтовать при объединении этих окружений).
### Недоступность файлов для пользователей
Иногда возникают проблемы с отображением и функционированием сайта у всех пользователей, хотя у владельца сайта (в его браузере) при этом все хорошо. Если диагноз проблемы звучит подобным образом, то нужно проверить, по какому адресу находятся директории кэширования, сам Web Optimizer и включена ли защита Web Optimizer от внешнего доступа:
>
> ```
> Использование .htaccess -> Защитить установку Веб Оптимизатора с помощью
> htpasswd -> Да
> ```
>
В этом случае директории кэширования нужно вынести из папки самого Web Optimizer (например, в корневую директорию cache, доступную на запись для веб-сервера) либо отключить защиту приложения:
>
> ```
> Использование .htaccess -> Защитить установку Веб Оптимизатора с помощью
> htpasswd -> Нет
> ```
>
### Отсутствие поддержки множественных хостов
Если требуется включить несколько параллельных хостов для ускорения загрузки статических ресурсов, то стоит проверить следующие моменты:
1. Наличие поддержки этих хостов в DNS. Для этого нужно сделать соответствующие этим хостам записи в вашей DNS-зоне, указывающие на требуемый IP-адрес (обычно тот же, что и у текущего сайта).
2. Включить поддержку этих хостов на уровне самого сервера. Для Apache это делается директивой `ServerAlias`, например:
>
> ```
> ServerAlias i1.site.ru
> ServerAlias i2.site.ru
> ```
>
3. Проверить, что эти хосты зеркалируют основной сайт. Для этого нужно взять адрес любого статического объекта на сайте (например, `site.ru/images/my.png`) и попробовать его открыть через все дополнительные хосты (`i1.site.ru/images/my.png`). При наличии каких-либо проблем необходимо повторить предыдущие шаги.
4. Добавить указанные хосты в конфигурацию Web Optimizer
>
> ```
> Множественные хосты -> Доступные хосты -> Название хостов через пробел
> ```
>
и включить поддержку множественных хостов
>
> ```
> Множественные хосты -> Включить параллельные хосты, например, i1 i2 -> Да
> ```
>
Web Optimizer автоматически проверяет несколько наиболее распространенных хостов и последняя настройка может и не потребоваться.
После описанных действий все изображения на сайте будут отдаваться через несколько хостов, что существенно ускорит загрузку каждой страницы.
### Замеченные ошибки и документации
Документация и описание приложения будет шириться и расти. на данный момент уже опубликованы [статья с описанием настроек](http://webo.in/articles/habrahabr/96-web-optimizer-settings/) и [статья с пошаговым руководством по установке](http://webo.in/articles/habrahabr/99-web-optimizer-installation-0.5/).
Часть документации (в основном, касательно принципов работы) выложена на английском здесь: [code.google.com/p/web-optimizator/w/list](http://code.google.com/p/web-optimizator/w/list)
Некоторые известные проблемы и методы их решения уже [описаны в предыдущей статье](http://webo.in/articles/habrahabr/96-web-optimizer-settings/). Если вы обнаружили некорректное поведение Web Optimizer для вашего сайта, вы можете [опубликовать описание ошибки](http://code.google.com/p/web-optimizator/issues/entry) (требуется Google-аккаунт) или [посмотреть все известные (или решенные) вопросы](http://code.google.com/p/web-optimizator/issues/list?can=1&cells=tiles). На данный момент среднее время решения проблемы составляет около суток (обычно несколько часов).
Также можно попробовать решить проблему в интерактивном режиме, [используя указанные контакты](http://webo.in/contacts/).
### Эффективность
Несколько результатов использования Web Optimizer (для «чистой» установки системы, без каких-либо предварительных оптимизаций) [приведено здесь](http://webo.in/articles/habrahabr/93-web-optimizer-0.4.5/). Оценка YSlow поднимается до 89-97, скорость клиентской загрузки в 2-3 (реже 3-5) раз. Сам Web Optimizer после создания кэшированных файлов тратит всего 3-10мс на проверку и обновление выходного HTML-документа (при настройках по умолчанию, корректное сжатие HTML в одну строку — достаточно ресурсоемкая операция и может занимать еще 50-100мс).
Загрузить Web Optimizer: [code.google.com/p/web-optimizator/downloads/list](http://code.google.com/p/web-optimizator/downloads/list)
Поддержать проект материально: [sprites.in/donate](http://sprites.in/donate/) | https://habr.com/ru/post/63753/ | null | ru | null |
# Неслучайный генератор случайных одноразовых кодов Тинькофф банка
Совершая очередную транзакцию в моем любимом банке Тинькофф, получил уже привычное сообщение:
> Никому не говорите код: 3131! Перевод с карты \*\*\*\*. Сумма \*\*\*.00 RUB
Если будут спрашивать — я вам его не говорил.
И снова взгляд зацепился за интересное совпадение цифр в «случайном» одноразовом коде (вспомнился Нео с чёрной кошкой). В итоге решил поднять всю историю сообщений, чтобы посмотреть, насколько случаен «случайный» одноразовый код и чем это может грозить.
В телефоне нашлось всего 234 таких сообщения за прошедший год. Все эти операции можно разделить на 2 типа: неслучайный код (190 штук) и случайный (42 штуки).
В категорию неслучайного кода относятся все операции покупки в интернете, операции перевода между своими картами. А на операции оплаты через мобильный банк, установку пин кода, вход в интернет банк, переводы третьим лицам приходят случайные коды.
Итак, были выбраны все неслучайные коды и отсортированы по возрастанию:
`0200 0207 0207 0208 0301 0307 0308 0401 0602 0706 0802 0808 0809 0900 0901 0903 0905 1119 1315 1515 1516 1516 1610 1614 1712 1715 1715 1715 1812 1812 1818 1918 2121 2125 2128 2220 2226 2228 2321 2325 2325 2423 2429 2528 2621 2721 2723 2727 2826 2827 2926 2927 3131 3131 3134 3231 3234 3237 3335 3432 3437 3637 3734 3736 3831 3832 3930 3932 3937 3939 4140 4143 4149 4240 4243 4442 4443 4448 4546 4640 4640 4641 4641 4842 4843 4844 4941 4946 4948 5153 5154 5158 5250 5250 5350 5354 5355 5454 5455 5550 5556 5557 5557 5558 5559 5653 5653 5659 5755 5755 5852 5950 5954 5956 5957 5959 6160 6162 6168 6261 6267 6366 6368 6369 6567 6761 6861 6863 6867 6960 7273 7370 7379 7473 7473 7570 7578 7670 7673 7679 7771 7772 7773 7773 7778 7877 7971 8189 8388 8480 8581 8581 8583 8586 8587 8587 8688 8782 8785 8886 8887 8981 8982 8983 8984 9192 9193 9195 9197 9199 9394 9395 9492 9493 9496 9499 9595 9596 9693 9793 9794 9890 9895 9897 9897 9899 9899 9990 9993 9995`
Как видно невооруженным глазом случайность этих кодов вызывает сомнения. В каждом коде 1 и 3 цифры совпадают, причем для выборки из 190 штук мы имеем 19 дублей кодов.
Посчитаем вероятность получения двух одинаковых чисел на первой и третьей позиции:
`P = 0,1 * 0,1 * 10 = 0,1`
Не так уж и невероятно получить код с одинаковыми цифрами в первой и третьей позиции, хотя интуитивно я считал, что это более редкое событие.
Но вернемся к выборке. Какова вероятность получить 190 кодов подряд, в которых первая и третья цифры совпадают при равномерном распределении?
`P = 0,1190`
Таким образом четырехзначный код превращается в трехзначный.
Возможно в сообществе найдутся знатоки теории вероятности и смогут вытащить из этих данных больше информации, буду рад почитать в комментариях.
P.S. Возможно такая ситуация наблюдается только у меня и связана с алгоритмом генерации кодов на основании данных клиента, например. Прошу сообщество посмотреть, имеет ли данная проблема массовый характер.
**UPD.:** вторая цифра всегда больше 0. Таким образом остается 900 комбинаций | https://habr.com/ru/post/462071/ | null | ru | null |
# Как EA усложнили нам жизнь, или как мы чинили баг 12-летней давности
Иногда в программы закрадываются баги. Причем закрадываются так, что обнаружить их получается лишь через много-много лет после выпуска, когда чинить их уже нерентабельно. Иногда такие баги оказываются слишком критическими, чтобы их игнорировать. Поэтому под катом я расскажу, как мы устраняли один такой критический баг в одной старенькой гонялке. А заодно наглядно продемонстрирую, чем плох float, какие могут быть последствия и как с этим бороться.
### Лирика
Речь пойдет об игре Need for Speed: Most Wanted. Эта игра очень популярна и крайне любима многими геймерами-энтузиастами, и многими считается чуть ли не лучшей в серии. Даже если вы не азартный игрок, то наверняка слышали об этой игре в частности или о серии в целом. Но обо всем по порядку.
Я – спидранер. Прохожу игры на скорость. Довелось мне быть одним из первопроходцев в деле скоростного прохождения гоночных игр, поэтому я заодно являюсь одним из «глобальных модераторов» спидран-коммьюнити серии NFS. Участь со мной разделил чех под ником Ewil.
Почему участь? Потому что в один прекрасный момент к нам в дискорд-сервер пришел человек и заявил, что все наши рекорды трасс неправильны, и что мы – нубы. Скрепя сердце, подавляя багет от, как казалось, необоснованного обвинения и борясь с языковым барьером (английским этот человек владеет на очень плохом уровне), мы начали разбираться, что же не так с нашими рекордами. Из обрывков речи мы поняли, что в игре есть некий «timebug», который делает IGT неправильным. Ewil пересмотрел некоторые записи и руками пересчитал время. Оказалось, нам не врали. На записях IGT резко отличалось от RTA. Это были не пара миллисекунд, которые тоже могу решить исход рекорда, а местами разница доходила даже до нескольких секунд(!).
Мы начали искать причину и последствия этого явления. Еще задолго до этого я в личных интересах пытался «вытащить» из игры IGT. Моя попытка не увенчалась успехом, и я как-то забил на эту идею. Информации в интернете мы найти не смогли, за исключением какой-то английской [странички](http://extrememostwantedracers.weebly.com/additional-infomation.html) с очень коротким описанием, без какой-либо доказательной базы. Поиск по ютубу также не принес результатов, но были найдены записи, которые гласили «No TimeBug».
Чуть позже я познакомился со SpeedyHeart, и она мне подсказала, что в игре время считается как float. Тут все начало проясняться, и мы медленно переходим от унылого вступления к лютому экшону!
### Как это работает
Вооружившись Cheat Engine, OllyDbg, DxWND и NFS: MostWanted версии 1.3, я полез рыться в памяти. Выкопал я примерно вот что (картинка кликабельна):
[](https://habrastorage.org/web/660/8da/ec6/6608daec685f4a35a72181e6867d7f5d.png)
Нас интересуют последние три адреса. Они хранят в себе IGT для разных ситуаций. Почему они float – одному Блэк Боксу известно… Но так не делают! Float, у него же точность, как у дробовика, а может и того хуже.
**Занудство**Кстати, в предыдущей игре серии время считается как int – общее количество тиков процессора (а когда оно перевалит за те самые 2 миллиарда, игра запаникует и предпочтет упасть). Соответственно, этот модуль их движка был переписан, но лучше не стало. В предыдущей части, кстати, IGT тоже отличается от RTA, но там это, скорее всего, вызвано подлагиванием движка.
Собственно, немного о самих таймерах. Таймеры хранят время в секундах, т. е. целая часть – количество полных секунд. Два из этих таймеров, а именно Global IGT и Race IGT, периодически обнуляются. Для Global IGT это происходит в момент выхода в главное меню, а Race IGT обнуляется при рестарте гонки. Подсчет IGT производится через Global IGT, и в какой-то момент времени ему уже не хватает точности. Из-за этого время считается неправильно.
На этой стадии меня заинтересовали несколько вопросов:
1. Раз уж есть разница во времени, то отличается ли геймплей с багом и без? Логично предположить, что если IGT ускоряется, то и в целом игра должна становиться «быстрее»
2. Какие рамки у этого бага? Как он будет себя вести при разных значениях таймера, и как на это будет реагировать игра.
Ответ на вопрос номер 1 был найден крайне быстро. Я просто взял и изменил показания Global IGT на 300000.0 и получил то, что получил. Время ускорилось почти в два раза(!), однако на физике и поведении игры это никак не отразилось. Прикола ради я тыркал и другие таймеры, но они, почему-то, ни на что не влияют. Собственно, если бы с ускорением времени ускорялся и геймплэй, то в нашем мире спидранерства это считается вполне законным. Все таки мы любим баги. Но такой расклад никого не устроил.
Я пошел немного глубже и нашел ответ на вопрос 2. Как только Global IGT достигает отметки в 524288 время в игре полностью останавливается. Это немного смущает игру, и она начинает ~~плохо себя вести~~ делать интересные вещи. Например, не дает начать гонку после рестарта, намертво блокируя игру (выйти из нее можно только через диспетчер задач или Alt+F4). Отрыв/отставание от соперников перестает работать. А если проиграть гонку, то игра отправляет вас в свободное плавание по миру.
### Float — ад перфекциониста.
Хоть и не в прямом смысле, но все же. Для наглядной демонстрации я написал небольшую программу, которая поможет мне оценить всю печальность происходящего.
Перед непосредственно кодом, распишу немного про цели. Известно, что игра «блокирует» цикл обновления физики на 120 раз в секунду (опять же, спасибо SpeedyHeart за информацию). Однако vsync обрубает обновление физики еще сильнее, до 60 раз в секунду. Соответственно, мы просто возьмем float-переменную и будем циклически туда добавлять 1/60 секунды. Потом мы посчитаем, за сколько шагов мы добились результата, и за сколько шагов мы ***должны были*** добиться этого результата. Также будем делать все циклически для разных случайных величин и считать среднюю погрешность в рассчетах. Любые отклонения в 2 и менее шагов (33мс) мы будем считать незначительными, потому что игра показывает время до сотых секунды.
```
#include
#include
#include
#include
#include
#define REPEATS 1000 // Количество проверок
#define ESCAPE 27 // Код клавиши ESCAPE
#define TEST\_TIME 2 // Время, проведенное на трассе
#define START\_TIME 0 // Изначальное значение внутриигрового таймиера
void main( )
{
time\_t t;
srand( time( &t ) );
while ( true )
{
float diffs[ REPEATS ];
int frame\_diffs[ REPEATS ]; // Сторэйдж разниц
for ( int i = 0; i < REPEATS; i++ )
{
int limit = rand( ) % TEST\_TIME + 1;// Генерируем случайное кол-во времени,
// +1 не даст нам сгенерировать 0
limit \*= 60; // Минуты в секунды
limit += (START\_TIME \* 60); // Выравниваем конечное время
float t = 0.0f + (START\_TIME\*60); // Выравниваем начальное время
float step = 1.0f / 60.0f; // И лочим все на 60 фпс
int steps = 0;
while ( t < limit )
{
steps++;
t += step;
}
// Считаем ожидания и выводим их на экран
double expectation = (double)(limit - START\_TIME\*60)/ ( 1.0 / 60.0 );
printf("%f\n", t );
printf("Difference = %f; steps = %d\n", t - limit, steps );
printf( "Expected steps = %f; frames dropped = %d\n",
expectation, (int)expectation - (int)steps );
diffs[i] = fabs( t - limit );
frame\_diffs[ i ] = (int)expectation - (int)steps;
}
// Считаем среднее и статистику
float sum = 0;
int frame\_sum = 0;
for ( int j = 0; j < REPEATS; j++ )
{
sum += diffs[ j ];
frame\_sum += frame\_diffs[ j ];
}
printf( "Avg. time difference = %f, avg. frame difference = %d\n",
sum / REPEATS, frame\_sum / REPEATS );
// В случае "any key" продолжаем, в случае "ESCAPE" выходим
printf( "Press any key to continue, press esc to quit\n" );
if ( getch() == ESCAPE )
break;
}
}
```
Меняя значения START\_TIME и TEST\_TIME мы можем получить необходимую нам статистику. В целом, пока START\_TIME не превышает 15 минут, то обычный 2-х минутный заезд окажется «свободным» от бага. Разница остается не критичной в рамках игры, 1-2 кадра:
16 Минут же оказались «критической точкой», когда время беспощадно плывет:
Интересен так же тот момент, что в зависимости от START\_TIME будет меняться «сторона» ошибки. Например, после полутора часового непрерывного геймплея время начнет течь медленнее, чем должно:
Поигравшись со значениями еще немного я оценил, что в получившейся программе «время» течет примерно так же, как в игре. Это было подтверждено практически – любые рекорды, записанные «из главного меню» в течение первых 15 минут геймплея были чистыми. При START\_TIME близкому к 300000 секунд количество шагов было почти в два раза меньше, чем ожидалось. При START\_TIME, большем магической константы 524288 программа переставала работать. Все это подтверждало, что процесс подсчета времени был скопирован верно.
**Еще нудности**Результаты вычислений будут отличаться, если игра отрабатывает больше чем 60 кадров в секунду. При 120 кадрах в секунду значение «свободной от бага зоны» составляет 7 минут. Да и время останавливается значительно раньше. В двух словах, чем быстрее работает игра, тем сильнее становится ошибка.
### Устраняем нежелательное поведение
Теперь, когда известна проблема и ее поведение, можно ее устранить. Нужно лишь перезаписывать Global IGT всякий раз, когда игрок начинает заезд заново. Это можно узнать довольно просто – в этот момент обнуляется Race IGT. Но тут есть проблема.
Есть два издания игры: NFS: Most Wanted и NFS: Most Wanted Black Edition. Второе издание включает в себя две дополнительные машины и две трассы, да 69-ое испытание. Но, технически, это две совершенно разные игры! Их запускаемые файлы отличаются. Помимо этого, есть патч 1.3… Который отличается для каждого издания. В итоге у нас есть 4 разных версии игры, которые надо поддерживать. Этот факт делает «правильный» путь чрезмерно сложным и неоправданным. По-хорошему, нужно слегка подправить запускаемый файл и обнулять счетчик там, но… Править 4 разных экзешника, которые еще и запакованы, да защищены от отладки… Лучше просто напишем простую программку, которая будет в реалтайме отслеживать состояние таймеров и обнулять их при необходимости. Писать будем на C#.
Вот такую архитектурку я набросал. GameProcess – это вспомогательный класс, который упрощает доступ к чтению-записи памяти процесса. GameHolder – сердце программы. Он будет инициализировать GameProcess, а при «подцепе» процесса будет определять версию игры и создавать необходимый экземпляр наследника Game. Поскольку логика «фикса» не отличается от версии к версии, то ее лучше вынести в один класс.
Как же нам определить версию? Просто – по размеру основного модуля. Я специально реализовал проперти ImageSize. А чтобы не захламлять код магическими константами, запилим enum:
```
enum ProcessSizes
{
MW13 = 0x00678e4e
}
```
Остальные версии добавим по мере их попадания ко мне в руки.
isUnknown отвечает за тот факт, удалось ли нам определить версию или нет. Из всего класса нам интересен только метод Refresh, вот он:
```
public void Refresh()
{
if(!process.IsOpen)
{
// In cases when the process is not open, but the game exists
// The process had either crashed, either was exited on purpose
if(game != null)
Console.WriteLine("Process lost (quit?)");
game = null;
return;
}
if(isUnknown) // If we couldn't determine game version, do nothing
{
return;
}
// If process is opened, but the game doesn't exist, we need to create it
if(process.IsOpen && game == null)
{
Console.WriteLine("Opened process, size = 0x{0:X}", process.ImageSize);
switch((ProcessSizes)process.ImageSize) // Guessing version
{
case ProcessSizes.MW13:
game = new MW.MW13(process);
break;
default:
Console.WriteLine("Unknown game type");
isUnknown = false;
break;
}
}
// At last, update game
game.Update();
}
```
Логика фикса вышла совсем простенькой:
```
public abstract class Game
{
private float lastTime;
private GameProcess game;
///
/// Synch-timer's address
///
protected int raceIgtAddress;
///
/// Timer-to-sync address
///
protected int globalIgtAddress;
private void ResetTime()
{
byte[] data = { 0, 0, 0, 0 };
game.WriteMemory(globalIgtAddress, data);
}
public void Update()
{
float tmp = game.ReadFloat(raceIgtAddress);
if (tmp < lastTime)
{
ResetTime();
Console.WriteLine("Timer reset");
}
lastTime = tmp;
}
public Game(GameProcess proc)
{
game = proc;
lastTime = -2; // Why not anyway
}
}
```
Дело осталось за малым: реализовать версию, выставив в конструкторе необходиме значения соответствующим protected-переменным. В мэйне же просто кидаем цикл обновления в отдельный трэд и забываем про него. Ах да, из-за особенностей карточек Nvidia и особенностей реализации установщика игр NFS мы будет принимать на вход имя процесса, чтобы была возможность кастомизации.
```
class Program
{
static void Run(object proc)
{
GameHolder holder = new GameHolder((string)proc);
while (true)
{
Thread.Sleep(100);
holder.Refresh();
}
}
static void Main(string[] args)
{
Thread t = new Thread(new ParameterizedThreadStart(Run));
t.Start(args[0]);
Console.WriteLine("Press any key at any time to close");
Console.ReadKey();
t.Abort();
}
}
```
На этом фикс заканчивается. Компилируем, запускаем и забываем о таймбаге, yay! ^\_^ Картинка кликабельна.
[](https://habrastorage.org/web/4d2/857/cce/4d2857cce5df450aa2ecca224aa0548c.png)
На самом деле, никуда этот баг не денется. Если один заезд физически не уложится в рамки 15 минут, то тут уже ничего не поделаешь. Но таких заездов в игре аж один, и тот от полиции.
Полные исходники на [гитхабе](https://github.com/GrimMaple/timebug_fixer).
### Summary
Вот так один маленький баг нехило подпортил нам жизнь. А ведь его можно было избежать, если бы Black Box использовали в свое время double, но нет. Кстати, это яркий пример того, как «написанное однажды» выливается в кучу неулавливаемых/перекатывающихся багов. Timebug присутствовал в ***каждой игре от Black Box ever since***. В Carbon, ProStreet и даже Undercover. В последнем они поменяли логику подсчета IGT, но эти три таймера там все так же присутствуют, и ошибки округления приводят к странным последствиям. SpeedyHeart обещала сделать видео-обзор всей найденой в процессе информации, так что ждем-с.
Чему меня научила эта ситуация? Не знаю. Я и так понимал, что использовать float для серьезных вычислений – идея сомнительная. Но теперь я лучше представляю, как именно все это будет работать на практике. Однако забавно получилось, что такая серьезная компания могла допустить такую серьезную ошибку, да еще и несколько лет подряд не замечать ее.
Мне кажется, что для данной задачи (подсчет IGT) нужно использовать такой путь: ставить timestamp в начале заезда, а потом вычитать из текущего времени. Причем арифметических операций стоит избегать, даже над целыми числами. 1/60 секунды это 16,(6) миллисекунд, поэтому в случае целого числа мы будем наивно откидывать 0,(6) при каждом сложении, что приведет к неточностям в подсчете.
В некоем обозримом будущем я постараюсь написать фикс и на другие версии. На этом у меня все, спасибо за внимание.
**UPD**: Поправил ссылку на гитхаб всвязи с переездом на новое имя.
**UPD2**: Выкатил вторую часть, интересующиеся могут [прочитать](https://habrahabr.ru/post/335432/). | https://habr.com/ru/post/333676/ | null | ru | null |
# Корпоративные сети могут быть взломаны с помощью Windows Update
Обновления Windows в последние дни становятся опасны для пользователей. Несколько дней назад желающие обновить свою операционную систему до Windows 10 [стали](http://www.zdnet.com/article/windows-10-scam-email-will-encrypt-your-files-for-ransom/) жертвами вируса-шифровальщика. Другая [история](http://www.net-security.org/secworld.php?id=18725) произошла на конференции Black Hat 2015, где исследователи из Великобритании показали технику доставки вредоносных программ на корпоративные Windows-ПК посредством локального сервера обновлений WSUS.
[](http://habrahabr.ru/company/pt/blog/264479/)
С помощью WSUS системные администраторы координируют обновления программного обеспечения на серверах и рабочих станциях. По умолчанию компания Microsoft применяет для WSUS незащищенный протокол HTTP, и чтобы включить HTTPS, администратору необходимо осуществить ряд манипуляций. Но их осуществляют далеко не всегда. Воспользовавшись отсутствием SSL-шифрования, специалисты британской компании Context Information Security смогли загрузить и установить на целевую систему поддельные обновления. Подобные апдейты могут быть использованы злоумышленниками для загрузки любой вредоносной программы и получения доступа с правами администратора.
Исследователи осуществили MITM-атаку при помощи ARP-спуфинга (возможен вариант и с WPAD-инъекцией), перехватив и изменив SOAP-запросы между клиентами и сервером WSUS, а также модифицировав метаданные в обновлениях.
Сегодня к подобным атакам уязвим любой компьютер на базе Windows, загружающий обновления с сервера WSUS не по HTTPS, утверждают британские специалисты, и рекомендуют компаниям проверить действующие у них политики безопасности в отношении WSUS.
Чтобы определить наличие SSL-шифрования в WSUS, необходимо посмотреть следующие ключи реестра:
* `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate`
WUServer — это URL-адрес сервера обновлений. Если этот адрес (например, `HTTP: / /wsus-server.local: 8530`) не начинается с HTTPS, значит компьютер уязвим для атаки.
* `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU`
Если стоит 0, тогда параметр WUServer будет игнорироваться. Если стоит 1, SSL во WSUS будет работать. Другие ключи реестра Windows Update можно посмотреть [тут](https://technet.microsoft.com/en-us/library/dd939844%28v=ws.10%29.aspx).
Администраторы могут проверить настройки групповой политики WSUS по следующему адресу:
* `Windows Components > Windows Update > Specify intranet Microsoft update`
Процедура включения SSL в службах WSUS [описана](https://technet.microsoft.com/ru-ru/library/hh852346.aspx) на сайте Microsoft.
Чтобы предотвратить загрузку фальсифицированных апдейтов, эксперты советуют Microsoft использовать отдельный сертификат для Windows Update. Как пишут авторы данного исследования, сейчас любой файл, подписанный Microsoft, может быть принят за обновление. Кроме того, британские специалисты рекомендуют подписывать и метаданные обновлений, так как в них содержится основная информация об обновлениях, включая теги handler. Подписанные сертификатом Microsoft теги позволят избежать необходимости создания доверенного канала между клиентом и сервером WSUS.
В последние дни опасений по поводу оригинальности обновлений Windows добавила и новая p2p-система в Windows 10 под названием WUDO (Windows Update Delivery Optimization). Она позволяет загружать обновления Windows с компьютеров других пользователей. Отключить пиринговую загрузку в целях безопасности (или экономии трафика) можно из раздела «Выберите способ загрузки обновлений» (Центр обновления Windows-> Дополнительные параметры-> Выберите способ загрузки обновлений):
Подробности исследования «Compromising the Windows Enterprise via Windows Update» можно прочитать [здесь](http://www.contextis.com/documents/161/CTX_WSUSpect_White_Paper.pdf). | https://habr.com/ru/post/264479/ | null | ru | null |
# Настройка отступов в VIM
Процесс смены Komodo IDE на VIM я начал с изучения всевозможных туториалов и хау ту, однако, что удивительно, ни в одном из них мне не удалось встретить человеческого описания процесса настройки отступов. В одних предлагали регулировать ширину отступа с помощью опции *tabstop*, в других — с помощью *softtabstop*, в третьих — выставлять и то и другое и *shiftwidth* в придачу. После нескольких часов экспериментов с настройками я понял, что единственный способ не только заставить все работать, но и понять, почему оно работает — читать документацию. Своими «открытиями» я и хочу с вами поделиться.
Начну с описания опций, которые могут использоваться при настройке отступов.
**tabstop** (по умолчанию 8) — количество пробелов, которыми символ табуляции отображается в тексте. Оказывает влияние как на уже существующие табуляции, так и на новые. В случае изменения значения, «на лету» применяется к тексту.
**softtabstop** (0) — количество пробелов, которыми символ табуляции отображается при добавлении. Несмотря на то, что при нажатии на Tab вы получите ожидаемый результат (добавляется новый символ табуляции), фактически в отступе могут использоваться как табуляция так и пробелы. Например, при установленных *tabstop* равной 8 и *softtabstop* равной 4, троекратное нажатие Tab приведет к добавлению отступа шириной 12 пробелов, однако сформирован он будет из одного символа табуляции и 4 пробелов.
**shiftwidth** (8) — по умолчанию используется для регулирование ширины отступов в пробелах, добавляемых командами >> и <<. Если значение опции не равно *tabstop*, как и в случае с *softtabstop*, отступ может состоять как из символов табуляций так и из пробелов. При включении опции — *smarttab*, оказывает дополнительное влияние.
**smarttab** (выключена) — в случае включения этой опции, нажатие Tab в начале строки (если быть точнее, до первого непробельного символа в строке) приведет к добавлению отступа, ширина которого соответствует *shiftwidth* (независимо от значений в *tabstop* и *softtabstop*). Нажатие на Backspace удалит отступ, а не только один символ, что очень полезно при включенной *expandtab*. Напомню: опция оказывает влияние только на отступы в начале строки, в остальных местах используются значения из *tabstop* и *softtabstop*.
**expandtab** (выключена) — в режиме вставки заменяет символ табуляции на соответствующее количество пробелов. Так же влияет на отступы, добавляемые командами >> и <<.
Вооружившись полученными знаниями, очень просто настроить требуемое поведение отступов. Популярная практика у разработчиков: пробелы вместо табуляции, ширина отступа — 4 пробела. Настройка в данном случае будет выглядеть следующим образом:
`set tabstop=4
set shiftwidth=4
set smarttab
set expandtab`
На десерт я оставил описание двух life changing опций для тех, кто использует VIM в качестве редактора для разработки:
**autoindent** (выключена) — копирует отступы с текущей строки при добавлении новой.
**smartindent** (выключена) — делает то же, что и *autoindent* плюс автоматически выставляет отступы в «нужных» местах. В частности, отступ ставится после строки, которая заканчивается символом {, перед строкой, которая заканчивается символом }, удаляется перед символом #, если он следует первым в строке и т.д. (подробнее help 'smartindent').
Вот, собственно, и все.
Мой конфигурационный файл в части отступов выглядит следующим образом:
`set tabstop=4
set shiftwidth=4
set smarttab
set expandtab
set smartindent`
Буду благодарен за любые уточнения или дополнения. | https://habr.com/ru/post/64224/ | null | ru | null |
# Как протестировать производительность серверов: подборка из нескольких open source бенчмарков
Продолжаем нашу серию материалов, посвященную тестированию производительности серверов. Сегодня поговорим о паре проверенных временем бенчмарках, которые до сих пор поддерживают и обновляют — NetPerf, HardInfo и ApacheBench.
[](https://habr.com/ru/company/1cloud/blog/476126/)
*Фото — [Peter Balcerzak](https://www.flickr.com/photos/pbalcer/11344696695/) — CC BY-SA*
[NetPerf](https://github.com/HewlettPackard/netperf)
----------------------------------------------------
Это — инструмент для оценки пропускной способности сети. Его разработали инженеры из Hewlett-Packard. Инструмент [включает](https://www.linuxlinks.com/netperf/) два исполняемых файла: netserver и netclient. Для проведения теста их нужно запустить на разных машинах. По умолчанию netperf использует порт 12865, но его можно заменить при помощи флага -p. Утилита работает с TCP и UDP по BSD Sockets, DLPI, Unix Domain Sockets и IPv6.
Сегодня netperf входит в набор инструментов для бенчмаркинга [Flent](https://flent.org/). Также его использует довольно большое количесвто ИТ-компаний, [например Red Hat](https://blog.openshift.com/troubleshooting-openshift-network-performance-with-a-netperf-daemonset/). Вот так выглядит описание сервиса netperf в одном из примеров для оценки производительности OpenShift:
```
apiVersion: v1
kind: Service
metadata:
labels:
app-name: netperf
name: netperf
namespace: your_project
spec:
ports:
- port: 12865
protocol: TCP
targetPort: 12865
selector:
app-name: netperf
sessionAffinity: ClientIP
type: ClusterIP
```
В официальном репозитории сказано, что netperf распространяется по специальной лицензии Hewlett-Packard. Однако автор утилиты — Рик Джонс (Rick Jones) — утверждает, что она оформлена в лучших традициях open source. Также отметим, что последнее время обновления для netperf стали выходить довольно редко. Возможно, это связано со зрелостью продукта.
У netperf есть аналоги — например, [iperf2](https://sourceforge.net/projects/iperf2/) и [iperf3](https://software.es.net/iperf/). Они также позволяют протестировать пропускную способность сети. Разработку iperf3 начали после того, как репозиторий iperf2 пришел в упадок. Новая версия написана с нуля и несовместима с предыдущей реализацией, хотя и содержит часть её кода. Что интересно, после релиза iperf3, работа над iperf2 вновь закипела. В итоге два инструмента [обладают](https://richardimaoka.github.io/blog/network-benchmark-tools/) похожей, но в то же время разной функциональностью. Например, iperf2 — многопоточный, а iperf3 — [работает](https://software.es.net/iperf/faq.html) лишь с одним потоком.
[Hardinfo](https://github.com/lpereira/hardinfo)
------------------------------------------------
Это — утилита для сбора информации об оборудовании и операционной системе. Она отображает данные о работе устройств на: PCI, ISA PnP, USB, IDE, SCSI, а также последовательных и параллельных портах. Но её можно использовать в качестве бенчмарка и инструмента мониторинга.
HardInfo предлагает несколько тестов. Например, CPU Blowfish — оценивает производительность процессора с помощью криптографических алгоритмов блочного симметричного шифрования. Есть [CPU N-Queens](http://groups.csail.mit.edu/cag/raw/benchmark/suites/nqueens/README.html) — тест из комбинаторики. Система решает шахматную задачу размещения N ферзей на доске N x N клеток. Она расставляет фигуры так, чтобы ни одна из них не могла атаковать другие. Также стоит отметить FPU FFT — тест на быстрое вычисление дискретного преобразования Фурье и FPU Raytracing — расчёт трассировки лучей при рендеринге 3D-сцены.
Результат в большинстве тестов даётся в секундах и, соответственно, чем он меньше — тем лучше. Все отчеты показаны в форматах HTML и txt.
> Изначально утилиту разрабатывали в рамках проекта [BerliOS](https://ru.wikipedia.org/wiki/BerliOS). Он включал в себя хостинг-платформу для приложений с открытым исходным кодом (вроде [SourceForge](https://ru.wikipedia.org/wiki/SourceForge.net)) и несколько баз данных для документации и профилей open source разработчиков. BerliOS закрыли в 2014 году из-за недостаточного финансирования. Сегодня HardInfo развивается усилиями энтузиастов [в отдельном репозитории](https://github.com/lpereira/hardinfo) на GitHub.
Отметим, что в работе системы иногда встречаются баги. Известно о периодически возникающей [ошибке сегментации](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=853749), проблемах с [отображением USB-устройств](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=638951) и нескольких [других](https://bugs.debian.org/cgi-bin/pkgreport.cgi?pkg=hardinfo;dist=unstable).
[ApacheBench](http://httpd.apache.org/docs/2.2/programs/ab.html)
----------------------------------------------------------------
Инструмент для нагрузочного тестирования HTTP-серверов. ApacheBench (AB) разрабатывался для проверки Apache, но он может работать на любом другом сервере. Инструмент предустановлен на многих дистрибутивах Linux.
*Фото — [Victor Freitas](https://unsplash.com/photos/_YO7f0XmUt4) — Unsplash*
Утилита «бомбардирует» серверы большим количеством запросов. Для запуска нужно ввести следующую команду:
```
ab -n 100 -c 10 http://www.example.com/
```
Она отправит сто GET-запросов (одновременно будут переданы максимум десять из них) к тестовому ресурсу. На выходе система покажет среднее время обработки запросов, общий объем переданных данных, пропускную способность и количество ошибок.
> Сегодня вокруг утилиты собралось обширное сообщество. В сети регулярно появляются [свежие руководства](https://www.youtube.com/watch?v=W7jYCFvTmeQ) о том, как настроить и использовать ApacheBench.
Отметим, что у AB есть аналог — [Apache jMeter](https://github.com/apache/jmeter), но с большими возможностями. Например, он позволяет генерировать запросы с нескольких компьютеров, управляя процессом с одного из них. Также в программе реализованы механизмы авторизации виртуальных пользователей, поддерживаются пользовательские сеансы. Этот инструмент применяют многие ИТ-компании, [в том числе](https://enlyft.com/tech/products/apache-jmeter) облачные провайдеры, например [Qualys](https://en.wikipedia.org/wiki/Qualys).
---
Мы в 1cloud предоставляем услугу [«Частное облако»](https://1cloud.ru/services/private-cloud?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench_6&utm_content=site). Это — аренда виртуальной инфраструктуры с возможностью быстрой кастомизации парка [виртуальных серверов](https://1cloud.ru/services/vps-vds?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench_6&utm_content=site).
---
Наше облако [построено на железе](https://1cloud.ru/infrastructure/hardware?utm_source=habrahabr&utm_medium=cpm&utm_campaign=bench_6&utm_content=site) Cisco, Dell, NetApp. Оборудование стоит в нескольких ЦОД: DataSpace (Москва), SDN/Xelent (Санкт-Петербург), Ahost (Алма-Ата).
--- | https://habr.com/ru/post/476126/ | null | ru | null |
# Запуск сервера сборки Jenkins
Итак, в вашем репозитории накопилось количество сборок превысившее число 1. Настало время задуматься о DevOps(е). В этом тексте я напишу как развернуть локальный сервер сборки на основе Jenkins.
### Пролог
Зачем все это? Дело в том, что сам по себе репозиторий с кодом это Филькина грамота, если поверх кода нет работающего сервера сборки, который даст гарантию, что "это что-то" вообще хотя бы собирается компилятором без ошибок.
Потом, сами артефакты это Филькина грамота, если отсутствуют модульные тесты, которые дадут гарантию, что \*.bin(ари) вообще работают.
Классический способ дать гарантию качества исходников это запустить поверх него сервер сборки. Есть множество готовых технологий для серверов сборки. Среди тех кто в теме на слуху такие программы как CircleCI, Jenkins и GitLab.
Идея проста. Сервер сборки это просто инфраструктурный прикладной процесс\утилита, который периодически запускает скрипты построения конкретных сборок и затем сохраняет результат (артефакты) в конкретную папку или архив. Обычно сервер сборки работает автономно 24/7 и собирает артефакты из репозитория с кодом сразу после новых коммитов.
Когда кому-то понадобится артефакты (прошивка), можно зайти в Web GUI и там выбирать, то, что нужно прямо как в супермаркете.
### Достоинство серверов сборки
* Всегда есть артефакт для отгрузки. Если не вчерашний, то позавчерашний.
* Есть сортировка сборок по различным атрибутам. Размер бинаря, время сборки.
* Сразу видны конфликты. Какие сборки с чем конфликтуют. Можно не глядя на код уже примерно понять в каком программном компоненте ошибки.
* Можно анализировать полный лог сборки
* Экономия времени на разработку и ускорение разработки в общем. Вам не придется больше ждать пока локально соберется код (3....7мин по 20 раз в день). Вы локально будете только редактировать код и делать коммиты. Вам даже не обязательно локально устанавливать ToolChain. Всё будет происходить на сервере сборки. Сервер сборки сэкономит вам 2...2,5 часа в день.
* Быстрая отгрузка артефактов. Например вас попросили собрать артефакт для какой-то конкретной платы. Вы просто дадите готовый артефакт из сервера сборки.
* Контроль прохождения модульных тестов
* Сервер сборки нужен для контроля качества работы программистов. Тут всё просто. У хороших программистов сборки собираются, а модульные тесты проходят. У плохих программистов сборки не собираются, а тесты не проходят.
* Простой контроль целостности репозитория
* Азарт при разработке софтвера. Появляется желание исправить все конфликты в кодовой базе и построить по-настоящему модульный код.
### Недостатки сервера сборки
* При неправильной сборке могут переполнить жесткий диск. Всегда в настройках Jenkins Job(а) указывайте максимальное количество сборок, которое будет храниться на PC для каждой конкретной сборки. В противном случае вы просто переполните себе жесткий диск. У меня был случай как за полтора года Jenkins сохранил 79GByte артефактов и мне пришлось его сносить.
* Желателен отдельный PC(NetTop) для работы сервера
* Нужно вручную мышкой конфигурировать каждую сборку в Web интерфейсе
### Пошаговое руководство запуска Jenkins на Win
#### Какой понадобится софтвер?
| | |
| --- | --- |
| **Программа** | **Назначение** |
| \*jdk-11.0.16.1\_windows-x64\_bin.exe | Виртуальная машина для работы сервера сборки |
| Notepad++.exe | Текстовый редактор для изменения конфигов |
| \*Windows 10 | Операционная система для сервера сборки |
| git.exe | Система контроля версий исходных кодов |
| gcc.exe | Компилятор С кода. Входит в состав CygWin |
| make.exe | Культовая утилита сборки сорцов. Входит в состав CygWin |
| TeamViewer.exe | Удаленный доступ к NetTop для коллективного доступа к серверу сборки |
| \*Tor Browser | Для скачивания JDK на санкционных территориях |
| Chrome.exe | Браузер для просмотра таблицы сборок |
| \*jenkins.exe | Сервер сборки |
Звездочной \* отмечены ключевые программные компоненты. Остальное можно и заменить альтернативами.
#### Фаза 1: Установка Java Runtime Environment
Дело в том, что Jenkins работает поверх виртуальной машины Java. Так сделано специально, чтобы программа была переносима между различными операционными системами. Поэтому перед установкой Jenkins надо установить Java Runtime Environment(JRE). JRE это виртуальная машина для исполнения байт-кода, который генерирует компилятор Java. JRE входит в состав Java Development Kit(JDK). Это компилятор языка Java и Java Runtime Environment.
Если у вас нет java, то консоль Windows напишет это
```
C:\Users\xxx>java -version
'java' is not recognized as an internal or external command,
operable program or batch file.
C:\Users\xxx>
```
Всю JDK можно скачать по этой ссылке
```
https://www.oracle.com/java/technologies/javase/jdk11-archive-downloads.html
```
Сразу хочу отметить, что скачивать что-либо с сайта [www.oracle.com](http://www.oracle.com) следкет через Tor браузер так как РФ у них числится санкционной территорией. Плюс нужна регистрация сайте oracle. Надо скачать файл jdk-11.0.16.1\_windows-x64\_bin.exe
Скачивается jdk-11.0.16.1\_windows-x64\_bin.exe очень долго. Порядка часа. Получив дистрибутив запускаем установку
Запоминает адрес установки **C:\Program Files\Java\jdk-11.0.16.1\** Он нам пригодится при установке Jenkins.
Признаком того, что Java установилась служит сообщение версии Java
```
C:\Users\xxxx>java -version
java version "11.0.16.1" 2022-08-18 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.16.1+1-LTS-1)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.16.1+1-LTS-1, mixed mode)
C:\Users\xxxx>
```
#### Фаза 2: Установка Jenkins
Прежде всего Jenkins надо установить на NetTop. Допустим у вас Windows. Скачать дистрибутив можно с официального сайта <https://www.jenkins.io/download/>
Указываем путь установки
Надо указать, что сервер будет работало локально
Указывает порт на котором будет работать Jenkins. По умолчанию 8080
Вот тут как раз следует прописать путь к JDK. **C:\Program Files\Java\jdk-11.0.16.1**
Признаком работы Jenkins служит его появление в диспетчере задач
Как же открыть Jenkins? Надо в браузере и набрать этот URL
```
http://localhost:8080
```
придется настроить Jenkins. Jenkins попросит admin password из файла C:\Program Files\Jenkins\jenkins.err.log
Также придется еще подождать пока произойдет настройка плагинов. Это примерно 30 мин.
осталось только придумать логин и пароль
Открыть браузер и указать снова URL <http://localhost:8080>
и вот долгожданное сообщение. Jenkins установился.
Теперь остается только наполнить сервер задачами. Тут их называют Job(ами)
#### Фаза 4: Создание задачи Job(а)
Как же создать Jenkins Job, первую сборку?
Открывает URL <http://localhost:8080/>. Нажимаем **New Item**,
Надо придумать название сборки.
Пишем название сборки **nrf5340\_dk\_headset\_app\_cmake**, выбираем **Freestyle** **project**
А вот тут очень важно. Надо активировать опцию удаления устаревших сборок (**Discard old builds**). Иначе Jenkins увеличит папку C:\Windows\System32\config\systemprofile\AppData\Local\Jenkins\.jenkins\jobs до запредельных размеров. У меня как-то за полтора года набралось 79 GByte артефактов.
Надо указать адрес Workspace в котором данный Job будет искать скрипты сборки. То есть заполнить поле **Use custom workspace**
Надо указать при каких событиях будет происходить сборка. Самое простое это сказать, что надо собирать каждые 2 часа. Написать H H/2 \* \* \*
Надо создать команду самой сборки. Нажимаем на кнопку **Add build step**
При работе в Windows выбираем **Execute Windows batch command**
Прописываем путь к скрипту сборки относительно корня репозитория. Тут как раз важно подчеркнуть, что сборки должны инициироваться **скриптом**. Даже если вы собираете из-под IDE вам придется разобраться как вызывать сборку IDE(шного) проекта из скрипта.
Последний шаг это сохранить артефакты. Нажимаем **Add post-build action**.
и выбираем вариант **Archive the artefacts**
И указывает конкретные расширения, которые надо сохранить
```
source/projects/board_build_cmake/build/**/*.elf, source/projects/board_build_cmake/build/**/*.hex, source/projects/board_build_cmake/build/**/*.bin, source/projects/board_build_cmake/build/**/*.dts, source/projects/board_build_cmake/build/**/*.map
```
надо прописать это в поле **Archive the artifacts**
Сборка настроена. Нажимаем **Save**.
Чтобы инициировать сборку надо нажать на кнопку **Build Now**. Как видно сборка собралась.
Тут сразу появилось множество интересных метрик: длительность сборки, размер прошивки, лог сборки, \*.elf файл для отладки.
После всего этого вы можете конечно написать: "я не буду пользоваться сервером сборки потому, что у меня нет отдельного компьютера, а при работе в моём Workspace работающий Jenkins будет мне только мешать".
Разруливается эта ситуация очень просто. Вы организуете на своем локальном компьютере 2 репозитория: **workspace** и **release**. Workspace для редактирования кода, а release для генерации release(ных) артефактов. Release репозиторий он, как бы, только read only. Release репозиторий пополнять только из git pull(ами). Это важно, чтобы гарантировать, что все зависимости проиндексированы и находятся в репозитории c кодом.
В идеале надо, конечно же, отдельный компьютер с сервером сборки (Зомбик), чтобы на него могли заходить все заинтересованный в артефактах: разработчики, тестировщики, интеграторы, клиенты. Общий доступ можно организовать через TeamViewer или RDP.
Вот теперь вы умеете накатывать Jenkins и можете даже учить этому других.
### Вывод
Надеюсь этот текст поможет сомневающимся начать практики коллективной разработки софтвера и развернуть соответствующий DevOps для этого. Пользуйтесь серверами сборки. В этом нет, ровным счетом, ничего сложного.
### Links
<https://www.jenkins.io/doc/book/installing/windows/>
<https://www.dmosk.ru/miniinstruktions.php?mini=jenkins-ubuntu> | https://habr.com/ru/post/695978/ | null | ru | null |
# Software renderer — 1: матчасть
Программный рендеринг (software rendering) — это процесс построения изображения без помощи GPU. Этот процесс может идти в одном из двух режимов: в реальном времени (вычисление большого числа кадров в секунду — необходимо для интерактивных приложений, например, игр) и в «оффлайн» режиме (при котором время, которое может быть потрачено на вычисление одного кадра, не ограничено настолько строго — вычисления могут длиться часы или даже дни). Я буду рассматривать только режим рендеринга в реальном времени.
У этого подхода существуют как недостатки так и достоинства. Очевидным недостатком является производительность — CPU не в состоянии конкурировать с современными видеокартами в этой области. К достоинствам стоит причислить независимость от видеокарты — именно поэтому он используется как замена аппаратного рендеринга в случаях, когда видеокарта не поддерживает ту или иную возможность (так называемый software fallback). Существуют и проекты, цель которых — полностью заменить аппаратный рендеринг программным, например, WARP, входящий в состав Direct3D 11.
Но главным плюсом является возможность написания подобного рендерера самостоятельно. Это служит образовательным целям и, на мой взгляд, это — самый лучший способ понять лежащие в основе алгоритмы и принципы.
Это именно то, о чем будет рассказано в серии этих статей. Мы начнем с возможности закрашивать пиксель в окне заданным цветом и построим на этом возможность отрисовки трехмерной сцены в реальном времени, с движущимися текстурированными моделями и освещением, а так же с возможностью перемещаться по этой сцене.
Но для того, чтобы вывести на экран хотя бы первый полигон, необходимо освоить математику, на которой это построено. Первая часть будет посвящена именно ей, поэтому в ней будет много различных матриц и прочей геометрии.
В конце статьи будет ссылка на гитхаб проекта, который можно рассматривать как пример реализации.
Несмотря на то, что статья будет описывать самые основы, читателю все же необходим определенный фундамент для ее понимания. Этот фундамент: основы тригонометрии и геометрии, понимание декартовых систем координат и базовые операции над векторами. Так же, хорошей идеей будет прочтение какой-либо статьи об основах линейной алгебры для разработчиков игр (например, [этой](http://habrahabr.ru/post/131931/)), поскольку я буду пропускать описания некоторых операций и останавливаться только на самых, с моей точки зрения, важных. Я постараюсь показать, при помощи чего делается вывод некоторых важных формул, но не буду расписывать их детально — полные доказательства можно сделать самому или найти в соответствующей литературе. По ходу статьи я сначала постараюсь давать алгебраические определения того или иного понятия, а затем уже описывать их геометрическую интерпретацию. Большая часть примеров будет в двухмерном пространстве, поскольку мои навыки рисования трехмерных и, тем более, четырехмерных пространств оставляют желать лучшего. Тем не менее, все примеры легко обобщаются на пространства других размерностей. Все статьи будут в большей степени ориентированы на описание алгоритмов, а не на их реализацию в коде.
#### Вектора
Вектор — одно из ключевых понятий в трехмерной графике. И хотя линейная алгебра дает ему очень абстрактное определение, в рамках наших задач под *n*-мерным вектором мы можем понимать просто массив из *n* действительных чисел: элемент пространства *Rn*:
Интерпретация этих чисел зависит от контекста. Две самые частые: эти числа задают координаты точки в пространстве или же направленное смещение. Несмотря на то, что их представление одинаково (*n* действительных чисел), их концепции различаются — точка описывает положение в системе координат, а смещение не имеет положения как такового. В дальнейшем, мы так же можем определять точку с помощью смещения, подразумевая, что смещение происходит от начала координат.
Как правило, в большинстве игровых и графических движков присутствует класс вектора именно как набора чисел. Смысл же этих чисел зависит от контекста, в котором они используются. В этом классе определены методы как для работы с геометрическими векторами (например, вычисление векторного произведения) так и с точками (например, вычисление расстояния между двумя точками).
Во избежание путаницы, в рамках статьи мы не будем больше понимать под словом «вектор» абстрактный набор чисел, а будем так называть смещение.
##### Скалярное произведение
Единственная операция над векторами, на которой я хочу остановиться подробно (ввиду ее фундаментальности) — это скалярное произведение. Как ясно из названия, результат этого произведения — скаляр, и определяется он по следующей формуле:
У скалярного произведения есть две важные геометрические интерпретации.
1. Измерение угла между векторами.
Рассмотрим следующий треугольник, полученный из трех векторов:
Записав для него теорему косинусов и сократив выражение, придем к записи:
Поскольку длина ненулевого вектора по определению больше 0, то косинус угла определяет знак скалярного произведения и его равенство нулю. Получаем (считая, что угол от 0 до 360 градусов):
2. Скалярное произведение вычисляет длину проекции вектора на вектор.
Из определения косинуса угла получаем:
Мы так же уже знаем из предыдущего пункта, что:
Выразив из второго выражения косинус угла, подставив в первое и домножив на *||w||*, получаем результат:
Таким образом, скалярное произведение двух векторов равно длине проекции вектора *v* на вектор *w*, умноженное на длину вектора *w*. Часто встречающийся частный случай этой формулы — *w* имеет единичную длину и, следовательно, скалярное произведение вычисляет точную длину проекции.
Эта интерпретация очень важна, поскольку она показывает, что скалярное произведение вычисляет координаты точки (заданной вектором *v*, подразумевая смещение от начала координат) вдоль заданной оси. Самый простой пример:
Мы в дальнейшем воспользуемся этим при построении трансформации в систему координат камеры.
#### Системы координат
Этот раздел призван подготовить основу для введения матриц. Я, на примере мировой и локальной систем, покажу, по каким причинам используются несколько систем координат, а не одна, и о том, как описать одну систему координат относительно другой.
Представим, что у нас возникла необходимость в отрисовке сцены с двумя моделями, например:
Какие системы координат естественным образом вытекают из такой постановки? Первая — это система координат самой сцены (которая изображена на рисунке). Это система координат, описывающая мир, который мы собираемся рисовать — именно поэтому она и называется «мировой» (на картинках будет обозначена словом «world»). Она «связывает» все объекты сцены вместе. Например, координаты центра объекта *A* в этой система координат — *(1, 1)*, а координаты центра объекта *B* — *(-1, -1)*.
Таким образом, одна система координат уже есть. Теперь необходимо подумать о том, в каком виде к нам приходят модели, которые мы будем использовать в сцене.
Для простоты будем считать, что модель описывается просто списком точек («вершин») из которых она состоит. Например, модель *B* состоит из трех точек, которые приходят нам в следующем формате:
*v0 = (x0, y0)
v1 = (x1, y1)
v2 = (x2, y2)*
На первый взгляд, было бы здорово, если бы они уже были описаны в нужной нам «мировой» системе! Представляете, вы добавляете модель на сцену, а она уже находится там, где нам и нужно. Для модели *B* это могло бы выглядеть вот так:
*v0 = (-1.5, -1.5)
v1 = (-1.0, -0.5)
v2 = (-0.5, -1.5)*
Но использовать такой подход не выйдет. На то есть важная причина: это лишает возможности использовать одну и ту же модель заново в разных сценах. Представьте, что вам дали модель *B*, которая была смоделирована так, что при добавлении ее на сцену она оказывается в нужном нам месте, как в примере выше. Затем, внезапно, требование изменилось — мы хотим ее сдвинуть совсем на другую позицию. Получается, человеку, который создал эту модель, придется двигать ее самостоятельно и затем опять отдавать вам. Конечно, это — полный абсурд. Еще более сильный аргумент это то, что в случае с интерактивными приложениями, модель может двигаться, поворачиваться, анимироваться на сцене — что же, художнику делать модель во всех возможных положениях? Это звучит еще более глупо.
Решение этой проблемы — «локальная» система координат модели. Мы моделируем объект таким образом, чтобы его центр (или то, что можно условно за таковой принять) был расположен в начале координат. Затем мы программно ориентируем (перемещаем, поворачиваем и т.д.) локальную систему координат объекта в нужное нам положение в мировой системе. Возвращаясь к сцене выше, объект *A* (единичный квадрат, повернутый на 45 градусов по часовой стрелке) может быть смоделирован следующим образом:
Описание модели в этом случае будет выглядеть следующим образом:
*v0 = (-0.5, 0.5)
v1 = (0.5, 0.5)
v2 = (0.5, -0.5)
v3 = (-0.5, -0.5)*
И, соответственно, положение в сцене двух систем координат — мировой и локальной объекта *A*:
Это — один из примеров, почему наличие нескольких систем координат упрощает жизнь разработчикам (и художникам!). Есть еще и другая причина — переход к другой системе координат может упростить необходимые вычисления.
##### Описание одной системы координат относительно другой
Не существует такого понятия как «абсолютные координаты». Описание чего-либо всегда происходит относительно какой-то системы координат. В том числе и описание другой системы координат.
Мы можем построить своеобразную иерархию систем координат в примере выше:
```
- world space
- local space (object A)
- local space (object B)
```
В нашем случае эта иерархия очень проста, но в реальных ситуациях она может иметь гораздо более сильное ветвление. Например, у локальной системы координат объекта могут быть дочерние системы отвечающие за положение той или иной части тела.
Каждая дочерняя система координат может быть описана относительно родительской при помощи следующих значений:
* точка начала координат дочерней системы относительно родительской
* координаты базисных векторов дочерней системы относительно родительской
Например, в картинке ниже, начало координат системы *x'y'* (обозначенное как *O'*) расположено в точке *(1, 1)*, а координаты ее базисных векторов *i'* и *j'* равны *(0.7, -0.7)* и *(0.7, 0.7)* соответственно (что приблизительно соответствует осям, повернутым на 45 градусов по часовой стрелке).
Нам не нужно описывать мировую систему координат относительно какой-либо другой, потому что мировая система — корень иерархии, нас не волнует где она расположена или как она ориентирована. Поэтому для ее описания мы используем стандартный базис:
##### Перевод координат точек из одной системы в другую
Координаты точки *P* в родительской системе координат (обозначим как *Pparent*) могут быть вычислены при помощи координат этой точки в дочерней системе (обозначим как *Pchild*) и ориентации этой дочерней системы относительно родительской (описаной с помощью начала координат *Ochild* и базисных векторов *i'* и *j'*) следующим образом:
Снова вернемся к примеру сцены выше. Мы сориентировали локальную систему координат объекта *A* относительно мировой:
Как мы уже знаем, в процессе отрисовки нам необходимо будет перевести координаты вершин объекта из локальной системы координат в мировую. Для этого нам необходимо описание локальной системы координат относительно мировой. Выглядит оно следующим образом: начало координат в точке *(1, 1)*, а координаты базисных векторов равны *(0.7, -0.7)* и *(0.7, 0.7)* (способ расчета координат базисных векторов после поворота будет описан позже, пока что нам достаточно результата).
Для примера возьмем первую вершину *v = (-0.5, 0.5)* и вычислим ее координаты в мировой системе:
В верности результата можно убедиться, посмотрев на изображение выше.
#### Матрицы
Матрица размерности *m x n* — соответствующей размерности таблица чисел. Если количество столбцов в матрице равно количеству строк, то матрица называется квадратной. Например, матрица *3 x 3* выглядит следующим образом:
##### Перемножение матриц
Предположим, что у нас есть две матрицы: *M* (размерностью *a x b*) и *N* (размерностью *c x d*). Выражение *R = M · N* определено только в том случае, если количество столбцов в матрице *M* равно числу строк в матрице *N* (т.е. *b = c*). Размерность полученной матрицы будет равна *a x d* (т.е. количество строк равно кол-ву строк *M* а число столбцов — числу столбцов в *N*), а значение, находящееся на позиции *ij*, вычисляется как скалярное произведение *i*-й строки *M* на *j*-й столбец *N*:
Если результат умножения двух матриц *M · N* определен, то это вовсе не значит, что определено и умножение в обратную сторону — *N · M* (могут не совпадать кол-во строк и столбцов). В общем случае, операция умножения матриц так же не коммутативна: *M · N ≠ N · M*.
Единичная матрица — это матрица, которая не изменяет домноженную на нее другую матрицу (т.е. *M · I = M*) — своеобразный аналог единицы для обычных чисел:
##### Представление векторов в виде матриц
Мы так же можем представить вектор как матрицу. Есть два возможных способа это сделать, которые называют ''вектор-строка'' и ''вектор-столбец''. Как понятно из название, вектор-строка — это вектор, представленный в виде матрицы с одной строкой, а вектор-столбец — вектор, представленный в виде матрицы с одним столбцом.
Вектор-строка:
Вектор-столбец:
Далее мы очень часто будем сталкиваться с операцией умножения матрицы на вектор (для чего — будет обьяснено в следущем разделе), и, забегая вперед, матрицы с которыми мы будем работать будут иметь размерность либо *3 x 3* либо *4 x 4*.
Рассмотрим, каким способом мы можем умножить трехмерный вектор на матрицу *3 x 3* (аналогичные рассуждения применяются для других размерностей). Согласно определению, две матрицы могут быть перемножены, если количество столбцов первой матрицы равняется количеству строк второй. Таким образом, поскольку мы можем представить вектор и как матрицу *1 x 3* (вектор-строка) и как матрицу *3 x 1* (вектор-столбец), мы получаем два возможных варианта:
* Умножение вектора на матрицу «слева»:
* Умножение вектора на матрицу «справа»:
Как видно, мы получаем разный результат в каждом из случаев. Это может привести к случайным ошибкам, если API позволяет умножать вектор на матрицу с обоих сторон, поскольку, как мы увидим в дальнейшем, матрица трансформации подразумевает что вектор будет умножен на нее одним из двух способов. Так что, по моему мнению, в API лучше придерживаться только одного из двух вариантов. В рамках этих статей я буду использовать первый вариант — т.е. вектор умножается на матрицу слева. Если вы решили использовать другой порядок, то, для того чтобы получить корректные результаты, вам нужно будет транспонировать все матрицы, которые в дальнейшем встретятся в этой статье, а слово «строка» заменить на «столбец». Это так же влияет на порядок умножения матриц при наличии нескольких трансформаций (подробнее будет рассмотрено далее).
Из результата умножения так же видно, что матрица определенным образом (зависящем от значения ее элементов) изменяет вектор, который был на нее домножен. Это могут быть такие трансформации как поворот, масштабирование и другие.
Еще одно крайне важное свойство операции умножения матриц, которое нам в дальнейшем пригодится — дистрибутивность относительно сложения:
##### Геометрическая интерпретация
Как мы увидели в предыдущем разделе — матрица определенным образом трансформирует домноженный на нее вектор.
Еще раз вспомним, что любой вектор может быть представлен как линейная комбинация базисных векторов:
Умножим это выражение на матрицу:
Используя дистрибутивность относительно сложения, получим:
Мы уже видели подобное ранее, когда рассматривали, как перевести координаты точки из дочерней системы в родительскую, тогда это выглядело следующим образом (для трехмерного пространства):
Между этими двумя выражениями есть два различия — в первом выражении нет перемещения (*Ochild*, мы рассмотрим позже этот момент подробнее, когда будем говорить о линейных и афинных трансформациях), а вектора *i'*, *j'* и *k'* заменены на *iM*, *jM* и *kM* соответственно. Следовательно, *iM*, *jM* и *kM* — есть базисные вектора дочерней системы координат и мы переводим точку *vchild(vx, vy, vy)* из этой дочерней системы координат в родительскую (*vtransformed = vparentM*).
Процесс трансформации можно изобразить следующим образом на примере вращения против часовой стрелки (*xy* — изначальная, родительская система координат, *x'y'* — дочерняя, полученная в результате трансформации):
На всякий случай, чтобы убедиться, что нам понятен смысл каждого из векторов, используемых выше, перечислим их заново:
* *vparent* — вектор, который мы изначально умножали на матрицу *M*. Его координаты описаны относительно родительской системы координат
* *vchild* — вектор, координаты которого равны вектору *vparent*, но они описаны относительно дочерней системы координат. Это вектор *vparent* трансформированный тем же образом, что и базисные вектора (поскольку мы используем те же координаты)
* *vtransformed* — тот же самый вектор, что и *vchild* но с координатами пересчитанными относительно родительской системы координат. Это итоговый результат трансформации вектора *vparent*
Теперь рассмотрим, что происходит при умножении базисных векторов на матрицу *M*:
Видно, что базисные вектора новой дочерней системы координат, полученной в результате умножения на матрицу *M*, совпадают со строками матрицы. Это и есть та самая геометрическая интерпретация, которую мы искали. Теперь, увидев матрицу трансформации, мы будем знать куда смотреть, чтобы понять что она делает — достаточно представить ее строки как базисные вектора новой системы координат. Трансформация, происходящая с системой координат, будет та же что и трансформация, происходящая с вектором, домноженным на эту матрицу.
Мы так же можем комбинировать трансформации, представленные в виде матриц, при помощи умножения их друг на друга:
Таким образом, матрицы представляют собой очень удобный инструмент для описания и комбинирования трансформаций.
#### Линейные трансформации
Для начала рассмотрим самые часто используемые линейные трансформации. Линейная трансформация — это трансформация, которая удовлетворяет двум свойствам:
Важное следствие — линейная трансформация не может содержать перемещения (это так же является причиной, по которой слагаемое *Ochild* отсутствовало в предыдущем разделе), поскольку, согласно второй формуле, *0* всегда отображается в *0*.
##### Вращение
Рассмотрим вращение в двумерном пространстве. Это трансформация, которая поварачивает систему координат на заданный угол. Как мы уже знаем, нам достаточно вычислить новые координатные оси (полученные после вращения на заданный угол), и использовать их как строки матрицы трансформации. Результат легко получается из базовой геометрии:
Пример:
Результат для вращения в трехмерном пространстве получается аналогичным образом, с той лишь разницей что мы вращаем плоскость составленную из двух координатных осей, и фиксируем третью (вокруг которой и происходит вращение). Например, матрица вращения вокруг оси *x* выглядит следующим образом:
##### Масштабирование
Мы можем изменить масштаб объекта относительно всех осей применив следующую матрицу:
Оси трансформированной системы координат будут направлены так же, как и у изначальной системы координат, но будут требовать в *S* раз большей длины для одной единицы измерения:
Пример:
Масштабирование с одинаковым коэффициентом относительно всех осей называется равномерным (uniform). Но мы так же можем произвести масштабирование с разными коэффициентами вдоль разных осей (nonuniform):
##### Сдвиг
Как понятно из названия, эта трансформация производит сдвиг вдоль координатной оси, оставляя остальные оси нетронутыми:
Соответственно, матрица сдвига оси *y* выглядит следующим образом:
Пример:
Матрица для трехмерного пространства строится аналогичным образом. Например, вариант для сдвига оси *x*:
Несмотря на то, что эта трансформация используется очень редко, она пригодится нам в будущем, когда мы будем рассматривать афинные трансформации.
В нашем запасе уже есть приличное кол-во трансформаций, которые могут быть представлены как *3 x 3* матрица, но нам не хватает еще одной — перемещения. К несчастью, выразить перемещение в трехмерном пространстве при помощи *3 x 3* матрицы невозможно, поскольку перемещение не является линейной трансформацией. Решением этой проблемы являются однородные координаты, которые мы рассмотрим позже.
#### Центральная проекция
Наша итоговая цель — изобразить трехмерную сцену на двухмерном экране. Таким образом, мы должны тем или иным способом спроектировать нашу сцену на плоскость. Существует две самые часто используемые типы проекций — ортографическая и центральная (другое название — перспективная).
Когда человеческий глаз смотрит на трехмерную сцену, объекты, находящиеся дальше от него, становятся меньше в итоговом изображении, которое и видит человек — этот эффект называется перспективой. Ортографическая проекция игнорирует перспективу, что является полезным свойством при работе в различных САПР-системах (а так же в 2D играх). Центральная же проекция обладает этим свойством и потому добавляет значительную долю реалистичности. В этой статье мы будем рассматривать только ее.
В отличии от ортографической проекции, линии в перспективной проекции не параллельны друг другу, а пересекаются в точке, называемой центром проекции. Центром проекции выступает «глаз», которым мы смотрим на сцену — виртуальная камера:
Изображение формируется на плоскости, находящейся на заданном расстоянии от виртуальной камеры. Соответственно, чем больше расстояние от камеры, тем больше размер проекции:
Рассмотрим самый простой пример: камера расположена в начале координат, а плоскость проекции находится на расстоянии *d* от камеры. Нам известны координаты точки, которую мы хотим спроецировать: *(x, y, z)*. Найдем координату *xp* проекции этой точки на плоскость:
На этой картинке видны два подобных треугольника — *CDP* и *CBA* (по трем углам):
Соответственно, отношения между сторонами сохраняются:
Получаем результат для *x*-координаты:
И, аналогично, для *y*-координаты:
Позже, нам необходимо будет использовать эту трансформацию для формирования спроецированного изображения. И тут возникает проблема — мы не можем представить деление на *z*-координату в трехмерном пространстве с помощью матрицы. Решением этой проблемы, так же как и в случае с матрицей перемещения, являются однородные (homogeneous) координаты.
#### Проективная геометрия и однородные координаты
К текущему моменту мы столкнулись с двумя проблемами:
* Перемещение в трехмерном пространстве не может быть представлено как *3 x 3* матрица
* Перспективная проекция не может быть представлена в виде матрицы
Обе эти проблемы решает использование однородных координат. Однородные координаты — понятие из проективной геометрии. Проективная геометрия изучает проективные пространства, и, чтобы понять геометрическую интерпретацию однородных координат, нужно с ними познакомиться.
Ниже мы будем рассматривать определения для двухмерных проективных пространств, поскольку их легче изобразить. Аналогичные рассуждения применяются и для трехмерных проективных пространств (мы в дальнейшем будем использовать именно их).
Определим луч в пространстве *R3* следующим образом: луч — это множество векторов вида *kv* (*k* — скаляр, *v* — ненулевой вектор, элемент пространства *R3*). Т.е. вектор *v* задает направление луча:
Теперь мы можем перейти к определению проективного пространства. Проективная плоскость (т.е. проективное пространство с размерностью равной двум) *P2*, ассоциированная с пространством *R3*, это множество лучей в *R3*. Таким образом, «точка» в *P2* — это луч в *R3*.
Соответственно, два вектора в *R3* задают один и тот же элемент в *P2*, если один из них может быть получен домножением второго на какой-либо скаляр (поскольку в этом случае они лежат на одном луче):
К примеру, вектора *(1, 1, 1)* и *(5, 5, 5)* представляют один и тот же луч, а значит являются одной и той же «точкой» в проективной плоскости.
Таким образом мы и пришли к однородным координатам. Каждый элемент в проективной плоскости задается лучом из трех координат *(x, y, w)* (последняя координата называется *w* вместо *z* — общепринятое соглашение) — эти координаты называются однородными и определены с точностью до скаляра. Это означает, что мы можем домножать (или делить) на скаляр однородные координаты, и они все равно будут представлять ту же самую «точку» в проективной плоскости.
В дальнейшем мы будем использовать однородные координаты для представления афинных (содержащих перемещение) трансформаций и проецирования. Но до этого нужно решить еще один вопрос: каким образом представить в виде однородных координат уже данные нам вершины модели? Поскольку «дополнение» до однородных координат происходит за счет добавления третьей координаты *w*, вопрос сводится к тому, какое значение w нам необходимо использовать. Ответ на этот вопрос — любое не равное нулю. Разница в использовании различных значений *w* заключается в удобстве работы с ними.
И, как будет понятно далее (и что отчасти ясно интуитивно), самым удобным значением *w* является единица. Преимущества этого выбора следующие:
* Это позволяет в более естественном виде представить перемещение в виде матрицы (будет показано далее)
* После некоторых трансформаций (включая перспективную проекцию) значение *w* будет произвольным, и нам нужно будет вернуться на выбранную нами изначально плоскость (т.е. вернуть изначально выбранное значение w):
Если эта плоскость — *w = 1*, нам достаточно будет поделить все координаты на *w* — в результате, мы получим единицу в w координате
Таким образом, мы выбираем значение *w = 1*, а значит наши входные данные в однородных координатах теперь будут выглядить следующим образом (разумеется, единица уже добавлена будет нами, а не будет находиться в самом описании модели):
*v0 = (x0, y0, 1)
v1 = (x1, y1, 1)
v2 = (x2, y2, 1)*
Теперь нужно рассмотреть особый случай при работе с *w*-координатой. А именно — ее равенство нулю. Выше мы говорили, что мы можем выбрать любое значение *w*, не равное нулю, для расширения до однородных координат. Мы не может взять *w = 0*, в частности, потому, что это не позволит перемещать эту точку (поскольку, как мы увидим дальше, перемещение происходит именно за счет значения в w координате). Так же, если у точки координата *w* — нулевая, мы можем рассматривать ее как точку «в бесконечности», поскольку при попытке вернуться на плоскость *w = 1* мы получим деление на ноль:
И, хотя мы не можем использовать нулевое значение для вершин модели, мы можем использовать его для векторов! Это приведет к тому, что вектор не будет подвержен перемещениям при трансформациях — что имеет смысл, ведь вектор не описывает положение. Например, при трансформации нормали мы не можем перемещать ее, иначе получим неверный результат. Мы рассмотрим это подробнее, когда возникнет необходимость в трансформации векторов.
В связи с этим, часто пишут, что при *w = 1* мы описываем точку, а при *w = 0* — вектор.
Как я уже писал, мы использовали пример двухмерных проективных проективных пространств, но в действительно будем использовать трехмерные проективные пространства, а значит каждая точка будет описываться 4-мя координатами: *(x, y, z, w)*.
##### Перемещение с использование однородных координат
Теперь у нас есть все необходимые инструменты для описания афинных трансформаций. Афинные трансформации — линейные трансформации с последующим смещением. Они могут быть описаны следующим образом:
Мы так же можем использовать *4 х 4* матрицы для описания афинных трансформаций, используя однородные координаты:
Рассмотрим результат умножения вектора, представленного в виде однородных координат, и умножения на *4 x 4* матрицу:
Как видно, отличие от трансформации, представленной в виде *3 x 3* матрица, состоит в наличии 4-й координаты, а так же новых слагаемых в каждой из координат вида vw · m3i. Используя это, и подразумевая *w = 1*, мы можем представить перемещение следующим образом:
Тут можно убедиться в правильности выбора *w = 1*. Для представления смещения dx мы используем слагаемое вида *w · dx / w*. Соответственно, последняя строка матрицы выглядит как *(dx/w, dy/w, dz/w, 1)*. В случае *w = 1* мы можем просто опустить знаменатель.
У этой матрицы так же есть геометрическая интерпретация. Вспомним матрицу сдвига, которую мы рассматривала ранее. Она имеет в точности такой же формат, разница лишь в том, что происходит сдвиг четвертой оси, таким образом сдвигая трехмерное подпространство расположенное в гиперплоскости *w = 1* на соответствующие значения.
#### Описание виртуальной камеры
Виртуальная камера — это «глаз», которым мы смотрим на сцену. Прежде чем двигаться дальше, необходимо понять, каким образом можно описать положение камеры в пространстве, и какие параметры необходимы для формирования итогового изображения.
Параметры камеры задают усеченную пирамиду обзора (view frustum), которая определяет, какая часть сцены попадет в итоговое изображение:
Рассмотрим их по очереди:
* Местоположение и ориентация камеры в пространстве. Положение, очевидно, просто точка. Описать ориентацию можно различными способами. Я буду использовать так называемую «UVN» систему, т.е. ориентация камеры описывается положением связанной с ней системой координат. Обычно, оси в ней называются *u*, *v* и *n* (поэтому и такое название), но я буду использовать *right*, *up* и *forward* — из этих названий проще понять, чему соответствует каждая ось. Мы будем использовать левостороннюю систему координат.
При создании объекта камеры в API можно описывать все три оси — но это очень неудобно для пользователя. Чаще всего, пользователь знает в каком направлении должна смотреть камера, а так же приблизительную ориентацию вектора *up* (будем называть этот вектор *up'*). Используя эти два значения мы может построить верную систему координат для камеры по следующему алгоритму:
+ Вычисляем вектор *right* используя вектора *forward* и *up'* при помощи векторного произведения:
+ Теперь вычисляем корректный *up*, используя *right* *и forward*:
То есть, вектор *up'* совместно с *forward* задают плоскость, в которой должен быть расположен настоящий вектор *up*. Если у вас есть опыт использования OpenGL, то именно по такому алгоритму работает известная функция [gluLookAt](https://www.opengl.org/sdk/docs/man2/xhtml/gluLookAt.xml).
Важно не забыть нормализовать полученные в результате вектора — нам нужна ортонормированная система координат, поскольку ее удобнее использовать в дальнейшем
* *z*-координаты ближней и дальней плоскостей отсечения (near/far clipping plane) в системе координат камеры
* Углы обзора камеры. Они задают размеры усеченной пирамиды обзора:
Поскольку сцена в дальнейшем будет спроецирована на плоскость проекции, то изображение на этой плоскости в дальнейшем будет отображено на экране компьютера. Поэтому важно, чтобы соотношение сторон у этой плоскости и окна (или его части), в котором будет показано изображение, совпадали. Этого можно добиться, дав пользователю API возможность задавать только один угол обзора, а второй вычислять в соответствии с соотношением сторон окна. Например, зная горизонтальный угол обзора, мы можем вычислить вертикальный следующим образом:
Когда мы обсуждали центральную проекцию, мы видели, что чем дальше находится плоскость проекции от камеры, тем больше размер полученного изображения — мы обозначали расстояние от камеры (считая, что она расположена в начале координат) вдоль оси *z* до плоскости проекции переменной *d*. Соответственно, следует решить вопрос, какое значение *d* нам необходимо выбрать. На самом деле, любое ненулевое. Несмотря на то, что размер изображения увеличивается при увеличении *d*, пропорционально увеличивается и та часть плоскости проекции, которая пересекается с пирамидой обзора, оставляя одним и тем же масштаб изображения относительно размеров этой части плоскости. В дальнейшем мы будем использовать *d = 1* для удобства.
Пример в 2D:
В итоге, для изменения масштаба изображения, нам необходимо менять углы обзора — это изменит размер части плоскости проекции, пересекающейся с пирамидой обзора, оставив размер проекции тем же.
Мы можем двигать и поворачивать камеру, меняя положение и ориентацию ее системы координат. Пример кода:
**Скрытый текст**
```
void camera::move_right(float distance)
{
m_position += m_right * distance;
}
void camera::move_left(float const distance)
{
move_right(-distance);
}
void camera::move_up(float const distance)
{
m_position += m_up * distance;
}
void camera::move_down(float const distance)
{
move_up(-distance);
}
void camera::move_forward(float const distance)
{
m_position += m_forward * distance;
}
void camera::move_backward(float const distance)
{
move_forward(-distance);
}
void camera::yaw(float const radians)
{
matrix3x3 const rotation{matrix3x3::rotation_around_y_axis(radians)};
m_forward = m_forward * rotation;
m_right = m_right * rotation;
m_up = m_up * rotation;
}
void camera::pitch(float const radians)
{
matrix3x3 const rotation{matrix3x3::rotation_around_x_axis(radians)};
m_forward = m_forward * rotation;
m_right = m_right * rotation;
m_up = m_up * rotation;
}
```
#### Графический конвейер
Теперь у нас есть весь необходимый фундамент, для того чтобы описать по шагам действия, которые необходимы для получения изображения трехмерной сцены на экране компьютера. Для простоты будем считать, что конвейер отрисовывает один объект за раз.
Входящие параметров конвейера:
* Объект и его ориентация в мировой системе координат
* Камера, чьи параметры мы будем использовать при составлении изображения
##### 1. Переход в мировую систему координат
На этой стадии мы трансформируем вершины объекта из локальной системы координат в мировую.
Предположим, что ориентация объекта в мировой системе координат задается следующими параметрами:
* В какой точке в мировой системе координат находится объект: *(xworld, yworld, zworld)*
* Каким образом объект повернут: *(rx, ry, rz)*
* Масштаб объекта: *(sx, sy, sz)*
Назовем матрицы этих трансформаций *T*, *R* и *S* соответственно. Для получения итоговой матрицы, которая будет трансформировать объект в мировую систему координат, нам достаточно перемножить их. Тут важно заметить, что порядок перемножения матриц играет роль — это напрямую следует из того факта, что умножение матриц некоммутативно.
Вспомним, что масштабирование происходит относительно начала координат. Если мы сначала сместим объект на желаемую точку, а потом применим к нему масштаб, мы получим неверный результат — положение объекта снова изменится после масштабирования. Простой пример:
Аналогичное правило применяется и относительно вращения — оно происходит относительно начала координат, а значит положение объекта изменится, если мы сначала произведем перемещение.
Таким образом, корректная последовательность в нашем случае выглядит следующим образом: масштабирование — поворот — смещение:
##### 2. Переход в систему координат камеры
Переход в систему координат камеры, в частности, используется для упрощения дальнейших вычислений. В этой системе координат камера расположена в начале координат, а ее оси — вектора *forward*, *right*, *up*, которые мы рассматривали в предыдущем разделе.
Переход в систему координат камеры состоит из двух шагов:
* Перемещаем мир таким образом, чтобы положение камеры совпадало с началом координат
* Используя вычисленные оси *right*, *up*, *forward*, вычисляем координаты вершин объекта вдоль этих осей (этот шаг можно рассматривать как поворот системы координат камеры таким образом, чтобы она совпадала с мировой системой координат)
Первый шаг легко можно представить в виде матрицы перемещения на *(-posx, -posy, -posz)*, где *pos* — положение камеры в мировой системе координат:
Для реализации второго пункта мы воспользуемся свойством скалярного произведения, которое мы рассматривали в самом начале — скалярное произведение вычисляет длину проекции вдоль заданной оси. Таким образом, для того чтобы перевести точку *A* в систему координат камеры (с учетом того, что камера находится в начале координат — мы проделали это в первом пункте), нам достаточно взять ее скалярное произведение с векторами *right*, *up*, *forward*. Обозначим точку в мировой системе координат *v*, а эту же точку, переведенную в систему координат камеры, *v'*, тогда:
Эту операцию можно представить в виде матрицы:
Комбинируя эти две трансформации, мы получаем матрицу перехода в систему координат камеры:
Схематично, этот процесс можно изобразить следующим образом:
##### 3. Переход в однородное пространство отсечения и нормализация координат
В результате предыдущего пункта, мы получили координаты вершин объекта в системе координат камеры. Следующее, что необходимо сделать, это произвести проекцию этих вершин на плоскость и «отсечь» лишние вершины. Вершина объекта отсекается, если она лежит вне пирамиды обзора (т.е. ее проекция не лежит на той части плоскости, которую охватывает пирамида обзора). Например, вершина *v1* на рисунке ниже:
Обе эти задачи частично решает матрица проекции (projection matrix). «Частично» — потому что она не производит саму проекцию, но подготавливает *w*-координату вершины для этого. Из-за этого название «матрица проекции» звучит не очень подходяще (хотя это довольно распространенный термин), и я буду в дальнейшем называть ее матрицей отсечения (clip matrix), поскольку она так же производит отображение усеченной пирамиды обзора в однородное пространство отсечения (homogeneous clip space).
Но обо всем по порядку. Итак, первое — подготовка к проекции. Для этого мы кладем *z*-координату вершины в ее *w*-координату. Сама проекция (т.е. деление на *z*) будет происходить при дальнейшей нормализации w-координаты — т.е. при возвращении в пространство *w = 1*.
Следующее, что должна сделать эта матрица — это перевести координаты вершин объекта из пространства камеры в однородное пространство отсечения (homogeneous clip space). Это пространство, координаты не отсеченных вершин в котором таковы, что после применения проекции (т.е. деления на *w*-координату, поскольку в ней мы сохранили старую *z*-координату) координаты вершины нормализуются, т.е. удовлетворяют следующим условиям:
Неравенство для *z*-координаты может различаться для разных API. Например, в OpenGL оно соответствует тому, что выше. В Direct3D же *z*-координата отображается в интервал *[0, 1]*. Мы будем использовать принятый в OpenGL интервал, т.е. *[-1, 1]*.
Подобные координаты называются нормализованными координатами устройства (normalized device coordinates или просто NDC).
Поскольку мы получаем NDC-координаты поделив координаты на *w*, вершины в пространстве отсечения удовлетворяют следующим условиям:
Таким образом, переведя вершины в это пространство, мы можем узнать, нужно ли отсекать вершину, просто проверив ее координаты на неравенства выше. Любая вершина, не удовлетворяющая этим условиям, должна быть отсечена. Само отсечение — тема для отдельной статьи, поскольку ее корректная реализация приводит к созданию новых вершин. Пока что, в качестве быстрого решения, мы не будем рисовать грань, если хотя бы одна из ее вершин отсечена. Конечно, результат получится не сильно аккуратным. Например, для модели машины это выглядит следующим образом:
Итого, данный этап состоит из следующих шагов:
* Получаем вершины в пространстве камеры
* Домножаем на матрицу отсечения — переходим в пространство отсечения
* Помечаем отсеченные вершины, проверяя по неравенствам описанным выше
* Делим координаты каждой вершины на ее *w*-координату — переходим к нормализованным координатам
Теперь рассмотрим, каким образом мы отображаем координаты из пространства камеры в пространство отсечения. Вспомним, что мы решили использовать плоскость проекции *z=1*. Для начала нам нужно найти функцию, которая отображает координаты, лежащие на пересечении пирамиды обзора и плоскости проекции в интервал *[-1, 1]*. Для этого найдем координаты точек, определяющих эту часть плоскости. Эти две точки имеют координаты *(left, top)* и *(right, bottom)*. Мы будем рассматривать только случай, когда пирамида обзора симметрична относительно направления камеры.
Мы можем их вычислить, используя углы обзора:
Получаем:
Аналогично для *top* и *bottom*:
Таким образом, нам нужно отобразить интервал *[left, right]*, *[bottom, top]*, *[near, far]* в *[-1; 1]*. Найдем линейную функцию, которая дает такой результат для *left* и *right*:
Аналогично получается функция для *bottom* и *top*:
Выражение для *z* находится по-другому. Вместо того, чтобы рассматривать функцию вида *az + b* мы будем рассматривать функцию *a · 1/z + b*, потому что в дальнейшем, когда мы будем реализовывать буфер глубины, нам нужно будет линейно интерполировать величину, обратную z-координате. Мы не будем рассматривать этот вопрос сейчас, и просто примем это за данное. Получим:
Таким образом, мы можем записать, что нормализованные координаты получаются следующим образом из координат в пространстве камеры:
Мы не можем сразу применить эти формулы, потому что деление на *z* произойдет позже, при нормализации *w*-координаты. Мы можем воспользоваться этим, и вместо этого вычислить следующие значения (домножив на z), которые после деления на *w* в результате дадут нормализованные координаты:
Именно по этим формулам мы и производим трансформацию в пространство отсечения. Мы можем записать эту трансформацию в матричной форме (дополнительно вспомнив, что в *w*-координату мы кладем *z*):
##### Переход в систему координат экрана
К текущему этапу у нас есть координаты вершин объекта в NDC. Нам нужно перевести их в систему координат экрана. Вспомним, что левый верхний угол плоскости проекции был отображен в (-1, 1), а правый нижний в (1, -1). Для экрана я буду использовать левый верхний угол как начало системы координат, с осями направленным вправо и вниз:
Это отображение (viewport transformation) можно произвести при помощи простых формул:
Или, в матричной форме:
Мы оставим использование zndc до реализации буфера глубины.
В результате у нас есть координаты вершин на экране, которые мы и используем для отрисовки.
##### Реализация в коде
Ниже приведен пример кода, реализующий конвейер по описанному выше способу и производящий отрисовку в wireframe-режиме (т.е. просто соединяя вершины линиями). В нем так же подразумевается, что объект описан набором вершин и набором индексов вершин (faces), из которых состоят его полигоны:
**Скрытый текст**
```
void pipeline::draw_mesh(
std::shared_ptr mesh,
vector3 const& position,
vector3 const& rotation,
camera const& camera,
bitmap\_painter& painter) const
{
matrix4x4 const local\_to\_world\_transform{
matrix4x4::rotation\_around\_x\_axis(rotation.x) \*
matrix4x4::rotation\_around\_y\_axis(rotation.y) \*
matrix4x4::rotation\_around\_z\_axis(rotation.z) \*
matrix4x4::translation(position.x, position.y, position.z)};
matrix4x4 const camera\_rotation{
camera.get\_right().x, camera.get\_up().x, camera.get\_forward().x, 0.0f,
camera.get\_right().y, camera.get\_up().y, camera.get\_forward().y, 0.0f,
camera.get\_right().z, camera.get\_up().z, camera.get\_forward().z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f};
matrix4x4 const camera\_translation{
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
-camera.get\_position().x, -camera.get\_position().y, -camera.get\_position().z, 1.0f};
matrix4x4 const world\_to\_camera\_transform{camera\_translation \* camera\_rotation};
float const projection\_plane\_z{1.0f};
float const near{camera.get\_near\_plane\_z()};
float const far{camera.get\_far\_plane\_z()};
float const right{std::tan(camera.get\_horizontal\_fov() / 2.0f) \* projection\_plane\_z};
float const left{-right};
float const top{std::tan(camera.get\_vertical\_fov() / 2.0f) \* projection\_plane\_z};
float const bottom{-top};
matrix4x4 const camera\_to\_clip\_transform{
2.0f \* projection\_plane\_z / (right - left), 0.0f, 0.0f, 0.0f,
0.0f, 2.0f \* projection\_plane\_z / (top - bottom), 0.0f, 0.0f,
(left + right) / (left - right), (bottom + top) / (bottom - top), (far + near) / (far - near), 1.0f,
0.0f, 0.0f, -2.0f \* near \* far / (far - near), 0.0f};
matrix4x4 const local\_to\_clip\_transform{
local\_to\_world\_transform \* world\_to\_camera\_transform \* camera\_to\_clip\_transform};
std::vector transformed\_vertices;
for (vector3 const& v : mesh->get\_vertices())
{
vector4 v\_transformed{vector4{v.x, v.y, v.z, 1.0f} \* local\_to\_clip\_transform};
if ((v\_transformed.x > v\_transformed.w) || (v\_transformed.x < -v\_transformed.w))
{
mark\_vector4\_as\_clipped(v\_transformed);
}
else if ((v\_transformed.y > v\_transformed.w) || (v\_transformed.y < -v\_transformed.w))
{
mark\_vector4\_as\_clipped(v\_transformed);
}
else if ((v\_transformed.z > v\_transformed.w) || (v\_transformed.z < -v\_transformed.w))
{
mark\_vector4\_as\_clipped(v\_transformed);
}
transformed\_vertices.push\_back(v\_transformed);
}
float const width{static\_cast(painter.get\_bitmap\_width())};
float const height{static\_cast(painter.get\_bitmap\_height())};
matrix4x4 const ndc\_to\_screen{
width / 2.0f, 0.0f, 0.0f, 0.0f,
0.0f, -height / 2.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
width / 2.0f, height / 2.0f, 0.0f, 1.0f};
for (vector4& v : transformed\_vertices)
{
if (is\_vector4\_marked\_as\_clipped(v))
{
continue;
}
float const w\_reciprocal{1.0f / v.w};
v.x \*= w\_reciprocal;
v.y \*= w\_reciprocal;
v.z \*= w\_reciprocal;
v.w = 1.0f;
v = v \* ndc\_to\_screen;
}
for (face const& f : mesh->get\_faces())
{
vector4 const& v1{transformed\_vertices[f.index1]};
vector4 const& v2{transformed\_vertices[f.index2]};
vector4 const& v3{transformed\_vertices[f.index3]};
bool const v1\_clipped{is\_vector4\_marked\_as\_clipped(v1)};
bool const v2\_clipped{is\_vector4\_marked\_as\_clipped(v2)};
bool const v3\_clipped{is\_vector4\_marked\_as\_clipped(v3)};
if (!v1\_clipped && !v2\_clipped)
{
painter.draw\_line(
point2d{static\_cast(v1.x), static\_cast(v1.y)},
point2d{static\_cast(v2.x), static\_cast(v2.y)},
color{255, 255, 255});
}
if (!v3\_clipped && !v2\_clipped)
{
painter.draw\_line(
point2d{static\_cast(v2.x), static\_cast(v2.y)},
point2d{static\_cast(v3.x), static\_cast(v3.y)},
color{255, 255, 255});
}
if (!v1\_clipped && !v3\_clipped)
{
painter.draw\_line(
point2d{static\_cast(v3.x), static\_cast(v3.y)},
point2d{static\_cast(v1.x), static\_cast(v1.y)},
color{255, 255, 255});
}
}
}
```
#### Пример использования SDL2 для реализации
В этом разделе я вкратце расскажу, как можно использовать SDL2 для реализации отрисовки.
##### Инициализация, создание текстуры
Первое — это, естественно, инициализация библиотеки и создание окна. Если от SDL нужна только графика, то можно инициализировать с флагом **SDL\_INIT\_VIDEO**:
**Скрытый текст**
```
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw std::runtime_error(SDL_GetError());
}
m_window = SDL_CreateWindow(
"lantern",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height,
SDL_WINDOW_SHOWN);
if (m_window == nullptr)
{
throw std::runtime_error(SDL_GetError());
}
m_renderer = SDL_CreateRenderer(m_window, -1, SDL_RENDERER_ACCELERATED);
if (m_renderer == nullptr)
{
throw std::runtime_error(SDL_GetError());
}
```
Затем, создаем текстуру, в которую будем производить отрисовку. Я буду использовать формат **ARGB8888**, который означает, что на каждый пиксель в текстуре будет выделяться 4 байта — три байта на RGB каналы, и один на альфа-канал.
**Скрытый текст**
```
m_target_texture = SDL_CreateTexture(
m_renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
width, height);
if (m_target_texture == nullptr)
{
throw std::runtime_error(SDL_GetError());
}
```
Нужно не забыть произвести «очистку» SDL и всех взятых у него переменных при выходе приложения:
**Скрытый текст**
```
if (m_target_texture != nullptr)
{
SDL_DestroyTexture(m_target_texture);
m_target_texture = nullptr;
}
if (m_renderer != nullptr)
{
SDL_DestroyRenderer(m_renderer);
m_renderer = nullptr;
}
if (m_window != nullptr)
{
SDL_DestroyWindow(m_window);
m_window = nullptr;
}
SDL_Quit();
```
##### Отрисовка, отображение на экране
Мы можем использовать **SDL\_UpdateTexture** для обновления текстуры, которую мы затем отобразим на экране. Эта функция принимает, помимо прочих, следующие параметры:
* Данные — массив байт, который представляет собой массив пикселей с соответствующими значениями
* Количество байт в одной строке изображения (pitch) — вычисляется как кол-во пикселей, умноженное на 4 (потому что формат — **ARGB8888**)
Логично выделить функционал рисования в текстуру, представленную массивом байт, в отдельный класс. Он будет выделять память под массив, очищать текстуру, рисовать пиксели и линии. Рисование пикселя может быть сделано следующим образом (порядок байт различается в зависимости от **SDL\_BYTEORDER**):
**Скрытый текст**
```
void bitmap_painter::draw_pixel(point2d const& point, color const& c)
{
unsigned int const pixel_first_byte_index{m_pitch * point.y + point.x * 4};
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
m_data[pixel_first_byte_index + 0] = c.b;
m_data[pixel_first_byte_index + 1] = c.g;
m_data[pixel_first_byte_index + 2] = c.r;
// m_data[pixel_first_byte_index + 3] is alpha, we don't use it for now
#else
// m_data[pixel_first_byte_index + 0] is alpha, we don't use it for now
m_data[pixel_first_byte_index + 1] = c.r;
m_data[pixel_first_byte_index + 2] = c.g;
m_data[pixel_first_byte_index + 3] = c.b;
#endif
}
```
Рисование линий можно реализовать, например, по [алгоритму Брезенхэма](http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm).
После использования **SDL\_UpdateTexture**, необходимо скопировать текстуру в **SDL\_Renderer** и отобразить на экране с помощью **SDL\_RenderPresent**. Все вместе:
**Скрытый текст**
```
SDL_UpdateTexture(m_target_texture, nullptr, m_painter.get_data(), m_painter.get_pitch());
SDL_RenderCopy(m_renderer, m_target_texture, nullptr, nullptr);
SDL_RenderPresent(m_renderer);
```
На этом все. Ссылка на проект: <https://github.com/loreglean/lantern>. | https://habr.com/ru/post/243011/ | null | ru | null |
# Как работает JS: о внутреннем устройстве V8 и оптимизации кода
**[Советуем почитать] Другие 19 частей цикла**Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Перед вами — второй материал из серии, посвящённой особенностям работы JavaScript на примере движка V8. В [первом](https://habrahabr.ru/company/ruvds/blog/337042/) шла речь о механизмах времени выполнения V8 и о стеке вызовов. Сегодня мы углубимся в особенности V8, благодаря которым исходный код на JS превращается в исполняемую программу, и поделимся советами по оптимизации кода.
[](https://habrahabr.ru/company/ruvds/blog/337460/)
О JS-движках
------------
JavaScript-движок — это программа, или, другими словами, интерпретатор, выполняющий код, написанный на JavaScript. Движок может быть реализован с использованием различных подходов: в виде обычного интерпретатора, в виде динамического компилятора (или JIT-компилятора), который, перед выполнением программы, преобразует исходный код на JS в байт-код некоего формата.
Вот список популярных реализаций JavaScript-движков.
* [V8](https://en.wikipedia.org/wiki/V8_%28JavaScript_engine%29) — движок с открытым исходным кодом, написан на C++, его разработкой занимается Google.
* [Rhino](https://en.wikipedia.org/wiki/Rhino_%28JavaScript_engine%29) — этот движок с открытым кодом поддерживает Mozilla Foundation, он полностью написан на Java.
* [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey_%28JavaScript_engine%29) — это самый первый из появившихся JS-движков, который в прошлом применялся в браузере Netscape Navigator, а сегодня — в Firefox.
* [JavaScriptCore](https://en.wikipedia.org/wiki/JavaScriptCore) — ещё один движок с открытым кодом, известный как Nitro и разрабатываемый Apple для браузера Safari.
* [KJS](https://en.wikipedia.org/wiki/KJS_%28KDE%29) — JS-движок KDE, который разработал Гарри Портен для браузера Konqueror, входящего в проект KDE.
* [Chakra (JScript9)](https://en.wikipedia.org/wiki/JScript) — движок для Internet Explorer.
* [Chakra (JavaScript)](https://en.wikipedia.org/wiki/Chakra_%28JavaScript_engine%29) — движок для Microsoft Edge.
* [Nashorn](https://en.wikipedia.org/wiki/Nashorn_%28JavaScript_engine%29) — движок с открытым кодом, являющийся частью OpenJDK, которым занимается Oracle.
* [JerryScript](https://en.wikipedia.org/wiki/JerryScript) — легковесный движок для интернета вещей.
В этом материале мы остановимся на особенностях V8.
Почему был создан движок V8?
----------------------------
Движок с открытым кодом V8 был создан компанией Google, он написан на C++. Движок используется в браузере Google Chrome. Кроме того, что отличает V8 от других движков, он применяется в популярной серверной среде Node.js.
*Логотип V8*
При проектировании V8 разработчики задались целью улучшить производительность JavaScript в браузерах. Для того, чтобы добиться высокой скорости выполнения программ, V8 транслирует JS-код в более эффективный машинный код, не используя интерпретатор. Движок компилирует JavaScript-код в машинные инструкции в ходе исполнения программы, реализуя механизм динамической компиляции, как и многие современные JavaScript-движки, например, SpiderMonkey и Rhino (Mozilla). Основное различие заключается в том, что V8 не использует при исполнении JS-программ байт-код или любой промежуточный код.
О двух компиляторах, которые использовались в V8
------------------------------------------------
Внутреннее устройство V8 изменилось с выходом версии 5.9, которая появилась совсем недавно. До этого же он использовал два компилятора:
* full-codegen — простой и очень быстрый компилятор, который выдаёт сравнительно медленный машинный код.
* Crankshaft — более сложный оптимизирующий JIT-компилятор, который генерирует хорошо оптимизированный код.
Внутри движка используются несколько потоков:
* Главный поток, который занимается тем, что от него можно ожидать: читает исходный JS-код, компилирует его и выполняет.
* Поток компиляции, который занимается оптимизацией кода в то время, когда выполняется главный поток.
* Поток профилировщика, который сообщает системе о том, в каких методах программа тратит больше всего времени, как результат, Crankshaft может эти методы оптимизировать.
* Несколько потоков, которые поддерживают механизм сборки мусора.
При первом исполнении JS-кода V8 задействует компилятор full-codegen, который напрямую, без каких-либо дополнительных трансформаций, транслирует разобранный им JavaScript-код в машинный код. Это позволяет очень быстро приступить к выполнению машинного кода. Обратите внимание на то, что V8 не использует промежуточное представление программы в виде байт-кода, таким образом, устраняя необходимость в интерпретаторе.
После того, как код какое-то время поработает, поток профилировщика соберёт достаточно данных для того, чтобы система могла понять, какие методы нужно оптимизировать.
Далее, в другом потоке, начинается оптимизация с помощью Crankshaft. Он преобразует абстрактное синтаксическое дерево JavaScript в высокоуровневое представление, использующее модель единственного статического присваивания (static single-assignment, SSA). Это представление называется Hydrogen. Затем Crankshaft пытается оптимизировать граф потока управления Hydrogen. Большинство оптимизаций выполняется на этом уровне.
Встраивание кода
----------------
Первая оптимизация программы заключается в заблаговременном встраивании в места вызовов как можно большего объёма кода. Встраивание кода — это процесс замены команды вызова функции (строки, где вызывается функция) на её тело. Этот простой шаг позволяет сделать следующие оптимизации более результативными.
*Вызов функции заменяется на её тело*
Скрытые классы
--------------
JavaScript — это язык, основанный на прототипах: здесь нет классов. Объекты здесь создаются с использованием процесса клонирования. Кроме того, JS — это динамический язык программирования, это значит, что, после создания экземпляра объекта, к нему можно добавлять новые свойства и удалять из него существующие.
Большинство JS-интерпретаторов используют структуры, напоминающие словари (основанные на использовании [хэш-функций](http://en.wikipedia.org/wiki/Hash_function)), для хранения сведений о месте расположения значений свойств объектов в памяти. Использование подобных структур делает извлечение значений свойств в JavaScript более сложной задачей, чем в нединамических языках, таких, как Java и C#. В Java, например, все свойства объекта определяются не изменяющейся после компиляции программы схемой объекта, их нельзя динамически добавлять или удалять (надо отметить, что в C# есть [динамический](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/dynamic) тип, но тут мы можем не обращать на это внимание). Как результат, значения свойств (или указатели на эти свойства) могут быть сохранены, с фиксированным смещением, в виде непрерывного буфера в памяти. Шаг смещения можно легко определить, основываясь на типе свойства, в то время как в JavaScript это невозможно, так как тип свойства может меняться в процессе выполнения программы.
Так как использование словарей для выяснения адресов свойств объекта в памяти очень неэффективно, V8 использует вместо этого другой метод: скрытые классы. Скрытые классы похожи на обычные классы в типичном объектно-ориентированном языке программирования, вроде Java, за исключением того, что создаются они во время выполнения программы. Посмотрим, как всё это работает, на следующем примере:
```
function Point(x, y) {
this.x = x;
this.y = y;
}
var p1 = new Point(1, 2);
```
Когда происходит вызов `new Point(1, 2)`, V8 создаёт скрытый класс `C0`.
*Первый скрытый класс С0*
Пока, ещё до выполнения конструктора, у объекта `Point` нет свойств, поэтому класс `C0` пуст.
Как только будет выполнена первая команда в функции `Point`, V8 создаст второй скрытый класс, `C1`, который основан на `C0`. `C1` описывает место в памяти (относительно указателя объекта), где можно найти свойство `x`. В данном случае свойство x хранится по [смещению](https://en.wikipedia.org/wiki/Offset_%28computer_science%29) 0, что означает, что если рассматривать объект `Point` в памяти как непрерывный буфер, первое смещение соответствует свойству `x`. Кроме того, V8 добавит в класс `C0` сведения о переходе к классу `C1`, где указывается, что если к объекту `Point` будет добавлено свойство `x`, скрытый класс нужно изменить с `C0` на `C1`. Скрытый класс для объекта `Point`, как показано на рисунке ниже, теперь стал классом `С1`.
*Каждый раз, когда к объекту добавляется новое свойство, в старый скрытый класс добавляются сведения о переходе к новому скрытому классу. Переходы между скрытыми классами важны, так как они позволяют объектам, которые создаются одинаково, иметь одни и те же скрытые классы. Если два объекта имеют общий скрытый класс и к ним добавляется одно и то же свойство, переходы обеспечат то, что оба объекта получат одинаковый новый скрытый класс и весь оптимизированный код, который идёт вместе с ним.*
Этот процесс повторяется при выполнении команды `this.y = y` (опять же, делается это внутри функции `Point`, после вышеописанной команды по добавлению свойства `x`).
Тут создаётся новый скрытый класс, `C2`, а в класс `C1` добавляются сведения о переходе, где указывается, что если к объекту `Point` добавляется свойство `y` (при этом речь идёт об объекте, который уже содержит свойство `x`), тогда скрытый класс объекта должен измениться на `C2`.
*Переход к использованию класса C2 после добавления к объекту свойства y*
Переходы между скрытыми классами зависят от порядка, в котором к объекту добавляются свойства. Взгляните на этот пример кода:
```
function Point(x, y) {
this.x = x;
this.y = y;
}
var p1 = new Point(1, 2);
p1.a = 5;
p1.b = 6;
var p2 = new Point(3, 4);
p2.b = 7;
p2.a = 8;
```
В подобной ситуации можно предположить, что у объектов `p1` и `p2` будет один и тот же скрытый класс и одно и то же дерево переходов скрытых классов. Однако, на самом деле это не так. В объект `p1` первым добавляется свойство `a`, а затем — свойство `b`. В объект `p2` сначала добавляют свойство `b`, а затем — `a`. В результате объекты `p1` и `p2` будут иметь различные скрытые классы — результат различных путей переходов между скрытыми классами. В подобных случаях гораздо лучше инициализировать динамические свойства в одном и том же порядке для того, чтобы скрытые классы могли быть использованы повторно.
Встроенные кэши
---------------
V8 использует и другую технику для оптимизации выполнения динамически типизированных языков, называемую встроенным кэшем вызовов. Встроенное кэширование основано на наблюдении, которое заключается в том, что повторяющиеся обращения к одному и тому же методу имеют тенденцию происходить с использованием объектов одного типа. Более подробно об этом можно почитать [здесь](https://github.com/sq/JSIL/wiki/Optimizing-dynamic-JavaScript-with-inline-caches). Если у вас нет времени слишком в это углубляться, читая вышеупомянутый материал, здесь мы изложим концепцию встроенного кэширования буквально в двух словах.
Итак, как же всё это работает? V8 поддерживает кэш типов объектов, которые мы передали в качестве параметра недавно вызванным методам, и использует эту информацию для того, чтобы сделать предположение о типах объектов, которые будут переданы как параметры в будущем. Если V8 смог сделать правильное предположение о типе объекта, который будет передан методу, он может пропустить процесс выяснения того, как получать доступ к свойствам объекта, а, вместо этого, использовать сохранённую информацию из предыдущих обращений к скрытому классу объекта.
Как связаны концепции скрытых классов и встроенных кэшей вызовов? Когда метод вызывается для некоего объекта, движок V8 должен обратиться к скрытому классу этого объекта для того, чтобы определить смещение для доступа к конкретному свойству. После двух успешных обращений одного и того же метода к одному и тому же скрытому классу, V8 опускает операцию обращения к скрытому классу и просто добавляет сведения о смещении свойства к самому указателю объекта. Выполняя вызовов этого метода в будущем, V8 *предполагает*, что скрытый класс не менялся и идёт прямо по адресу памяти для конкретного свойства, используя смещение, сохранённое после предыдущих обращений к скрытому классу. Это очень сильно увеличивает скорость выполнения кода.
Встроенное кэширование вызовов, кроме того, является причиной того, почему так важно, чтобы объекты одного и того же типа использовали общие скрытые классы. Если вы создаёте два объекта одинакового типа, но с разными скрытыми классами (как сделано в примере выше), V8 не сможет использовать встроенное кэширование, так как, даже хотя объекты имеют один и тот же тип, в соответствующих им скрытых классах назначено разное смещение их свойствам.
*Перед нами объекты одного типа, но их свойства a и b были созданы в разном порядке и имеют разное смещение*
Компиляция в машинный код
-------------------------
Как только граф Hydrogen оптимизирован, Crankshaft переводит его в низкоуровневое представление, которое называется Lithium. Большинство реализаций Lithium зависимо от архитектуры системы. На этом уровне, например, происходит выделение регистров.
В итоге Lithium-представление компилируется в машинный код. Затем происходит то, что называется замещением в стеке (on-stack replacement, OSR). Перед компиляцией и оптимизацией методов, в которых программа тратит много времени, нужно будет поработать с их неоптимизированными вариантами. Затем, не прерывая работу, V8 трансформирует контекст (стек, регистры) таким образом, чтобы можно было переключиться на оптимизированную версию кода. Это очень сложная задача, учитывая то, что помимо других оптимизаций, V8 изначально выполняет встраивание кода. V8 — не единственный движок, способный это сделать.
Как быть, если оптимизация оказалась неудачной? От этого есть защита — так называемая деоптимизация. Она направлена на обратную трансформацию, возвращающую систему к использованию неоптимизированного кода в том случае, если предположения, сделанные движком и положенные в основу оптимизации, больше не соответствуют действительности.
Сборка мусора
-------------
Для сборки мусора V8 использует традиционный генеалогический подход «пометь и выброси» (mark-and-sweep) для маркировки и очистки предыдущих поколений кода. Фаза маркировки предполагает остановку выполнения JavaScript. Для того, чтобы контролировать нагрузку на систему, создаваемую сборщиком мусора и сделать выполнение кода более стабильным, V8 использует инкрементный алгоритм маркирования: вместо того, чтобы обходить всю кучу, он пытается пометить всё, что сможет, обходя лишь часть кучи. Затем нормальное выполнение кода возобновляется. Следующий проход сборщика мусора по куче начинается там, где закончился предыдущий. Это позволяет добиться очень коротких пауз в ходе обычного выполнения кода. Как уже было сказано, фазой очистки памяти занимаются отдельные потоки.
Ignition и TurboFan
-------------------
С выходом в этом году V8 версии 5.9. был представлен и новый конвейер выполнения кода. Этот конвейер позволяет достичь ещё большего улучшения производительности и значительной экономии памяти, причём, не в тестах, а в реальных JavaScript-приложениях.
Новая система построена на базе [интерпретатора Ingnition](https://github.com/v8/v8/wiki/Interpreter) и новейшего оптимизирующего компилятора [TurboFan](https://github.com/v8/v8/wiki/TurboFan). Подробности об этих новых механизмах V8 можно почитать в [этом](https://v8project.blogspot.bg/2017/05/launching-ignition-and-turbofan.html) материале.
С выходом V8 5.9 full-codegen и Crankshaft (технологии, которые использовались в V8 с 2010-го года) больше применяться не будут. Команда V8 развивает новые средства, стараясь не отстать от новых возможностей JavaScript и внедрить оптимизации, необходимые для поддержки этих возможностей. Переход на новые технологии и отказ от поддержки старых механизмов означает развитие V8 в сторону более простой и хорошо управляемой архитектуры.
*Улучшения в тестах производительности для браузерного и серверного вариантов использования JS*
Эти улучшения — лишь начало. Новый конвейер выполнения кода на основе Ignition и TurboFan открывает путь к дальнейшим оптимизациям, которые улучшат производительность JavaScript и сделают V8 экономичнее.
Мы рассмотрели некоторые особенности V8, а теперь приведём несколько советов по оптимизации кода. На самом деле, кстати, всё это вполне можно вывести из того, о чём мы говорили выше.
Подходы к оптимизации JavaScript-кода для V8
--------------------------------------------
1. **Порядок свойств объектов**. Всегда инициализируйте свойства объектов в одном и том же порядке. Нужно это для того, чтобы одинаковые объекты использовали одни и те же скрытые классы, и, как следствие, оптимизированный код.
2. **Динамические свойства**. Добавление свойств к объектам после создания экземпляра объекта приведёт к изменению скрытого класса и к замедлению методов, которые были оптимизированы для скрытого класса, используемого объектами ранее. Вместо добавления свойств динамически, назначайте их в конструкторе объекта.
3. **Методы**. Код, который несколько раз вызывает один и тот же метод, будет выполняться быстрее, чем код, который вызывает несколько разных методов по одному разу (из-за встроенных кэшей).
4. **Массивы**. Избегайте разреженных массивов, ключи которых не являются последовательными числами. Разреженный массив, то есть массив, некоторые из элементов которого отсутствуют, будет обрабатываться системой как хэш-таблица. Для доступа к элементам такого массива требуется больше вычислительных ресурсов. Кроме того, постарайтесь избежать заблаговременного выделения памяти под большие массивы. Лучше, если их размер будет увеличиваться по мере надобности. И, наконец, не удаляйте элементы в массивах. Из-за этого они превращаются в разреженные массивы.
5. **Числа**. V8 представляет числа и указатели на объекты, используя 32 бита. Он задействует один бит для того, чтобы определить, является ли некое 32-битное значение указателем на объект (флаг — 1), или целым числом (флаг — 0), которое называется маленьким целым числом (SMall Integer, SMI) из-за того, что его длина составляет 31 бит. Если для хранения числового значения требуется более 31 бита, V8 упакует число, превратив его в число двойной точности и создаст новый объект для того, чтобы поместить в него это число. Постарайтесь использовать 31-битные числа со знаком везде, где это возможно, для того, чтобы избежать ресурсоёмких операций упаковки чисел в JS-объекты.
Итоги
-----
Мы, в SessionStack, стараемся следовать вышеизложенным принципам при написании JS-кода. Надеемся, немного разобравшись в том, как работают внутренние механизмы V8, и учтя то, что мы рассказали выше, вы сможете улучшить качество и производительность ваших программ.
Уважаемые читатели! Какими советами по оптимизации JS-кода можете поделиться вы? | https://habr.com/ru/post/337460/ | null | ru | null |
# Обнаружение DDoS-атак «на коленке»
Приветствую, Хабр! Я работаю в небольшом интернет провайдере масштаба области. У нас транзитная сеть (это значит, что мы покупаем интернет у богатых провайдеров и продаем его бедным). Несмотря на небольшое количество клиентов и такое же небольшое количество трафика протекающего по нашей сети, довольно часто приходится иметь дело с весьма внушительными DDoS-атаками по 10-20Гбит/с. (чаще всего конечно это атаки гораздо меньшего калибра). И хотя некоторые из наших клиентов обзавелись уже системами обнаружения таких атак и могут самостоятельно отправить жертву в блек-холл, гораздо чаще обнаружение атаки и бан конкретного IP жертвы ложится на наши плечи (тем более, если атака способна забить наши внешние каналы).
О решении, которое помогает обнаруживать эти самые атаки и которое принято у нас в сети, я и хотел бы рассказать. Оно бесплатно, основывается на анализе данных NetFlow, поэтому просто и весьма эффективно.
На самом деле систем для обнаружения Ddos-атак основанных на анализе данных протоколов NetFlow/SFlow/IPFIX существует довольно много (вероятно почти все?). В первом приближении, суть всех таких систем сводится к установлению порогов по количеству пакетов/потоков/октетов на определенный тип трафика к конкретному IP, при превышении которого система сигнализирует о возможной атаке. И наше решение ничем от них в этом плане не отличается. Однако, основная проблема – большинство из них платные. А бесплатные версии предлагают довольно грубый анализ, который часто неэффективен (к примеру, позволяет устанавливать порог только на весь трафик к конкретному IP, без его предварительной фильтрации, что в случае анализа транзитного трафика почти всегда бесполезно).
Итак, сперва необходимо настроить протокол NetFlow на сетевом оборудовании с минимально возможным active timeout (интервал с котором экспортируются данные с оборудования на коллектор) — это 60с для Cisco и Juniper.
**Настраиваем Netflow на маршрутизаторе**В качестве core-маршрутизатора у нас выступает Juniper MX480, он и будет заниматься отправкой телеметрии. Сначала настраиваем сэмплинг:
```
forwarding-options {
sampling {
input {
rate 2000;
run-length 0;
}
family inet {
output {
flow-inactive-timeout 15;
flow-active-timeout 60;
flow-server 10.0.0.10 {
port 9999;
autonomous-system-type origin;
source-address 10.0.0.1;
version 5;
}
}
}
}
}
```
Здесь:
* rate и run-length отвечают за семплирование статистики. Для анализа трафика берется один из 2000 пакетов. Данные взяты из рекомендаций Juniper для 10G интерфейсов. (К удивлению обнаружил, что сейчас не могу найти этих рекомендаций)
* flow-active-timeout 60; — вышеуказанный интервал с котором экспортируются днные на коллектор
* flow-inactive-timeout 15; — интервал неактивности, после которого поток считается завершенным.
* autonomous-system-type origin; — Экспортировать номер AS источника (Для нашей задачи не нужно, но для Traffic Engineering необходимая вещь)
* version 5 — здесь надо сделать небольшое отступление. Выбор 5й версии, а не 9й обусловлен двумя причинами. Во-первых, для работы 9й версии нужна доп плата в Juniper. Во-вторых, выбранный коллектор должен понимать 9ую версию (спойлер: он не понимает). Однако для нашей задачи вполне подойдет и 5ая версия.
Затем вешаем его на интерфейсы, где будем собирать статистику (как минимум это должны быть uplink интерфейсы):
```
interfaces {
ae1 {
vlan-id ...;
family inet {
sampling {
input;
output;
}
address ...
}
}
}
```
Далее, нам необходимо настроить NetFlow коллектор, который будет собирать данные статистики с оборудования.
В качестве коллектора решено было использовать многим знакомый flow-capture из набора утилит **flow-tools**. Именно набор утилит, который позволяет строить разнообразные и подробные отчеты на основе собранной статистики является главным достоинством этого пакета. (К слову в наборе утилит также есть и flow-dscan для обнаружения сканирования хостов/портов и другой нежелательной активности). В недостатки можно записать отсутствие веб-оболочки и отсутствие поддержки 9й версии NetFlow. Однако, повторюсь, гибкость таких утилит как flow-nfilter, flow-report и, конечно же, свободное распространение с легкостью все перекрывают.
**Настраиваем flow-tools на сервере**Сервер, на котором работает коллектор, в нашем случае под FreeBSD (конечно flow-tools доступен и для linux).
```
# cd /usr/ports/net-mgmt/flow-tools
# make install clean
```
Добавляем в /etc/rc.conf:
```
flow_capture_enable="YES"
flow_capture_localip="10.0.0.10" #локальный ip на который принимается поток
flow_capture_remoteip="10.0.0.1" #ip с которого льется поток
flow_capture_port="9999" #порт на который льется поток
flow_capture_datadir="/var/db/flows" #директория с файлами собранной телеметрии
flow_capture_flags="-z0 -n1439 -N3 -E10G -e0 -S1" #параметры
```
Здесь:
-z0 – сжатие файлов (0 — выключено)
-n1439 – количество файлов, которое создаст коллектор в сутки. По умолчанию 95 – это один файл в 15 минут. 1439 – максимальное значение — это один файл в минуту. Нам необходимо, чтобы файлики создавались как можно быстрее.
-N3 – это уровень вложенности файлов и папок (YYYY/YYYY-MM/YYYY-MM-DD/flow-file)
-E10G – ограничение на занимаемое пространство на диске. Будет удалять старые файлы таким образом, чтобы общий объем файлов с телеметрией был менее этого числа. Очень полезная штука, жаль не подчищает созданные директории.
-e0 – тоже самое только про количество файлов (0 – не следить)
-S1 – логировать каждую минуту сообщение о полученных/потерянных/обработанных потоках
Из всего набора утилит flow-tools нас будут интересовать три:
1. **Flow-nfilter** – позволяет фильтровать статистику по таким параметрам как ip адрес/протокол/порт. Нам она нужна будет для своеобразного белого списка IP, которые нужно исключить из проверки. Например, ip-адреса гугл-кэш серверов в вашей сети (или любых других кэшей), где достаточно высокий поток трафика может ложно сигнализировать о ддос-атаке. Создадим файл filters.cfg с фильтром (ip-адреса для примера):
```
filter-primitive white-list-ip
type ip-address-prefix
deny 8.8.8.8
deny 64.233.160.0/19
default permit
filter-definition white-list
match ip-destination-address white-list-ip
match ip-source-address white-list-ip
```
2. **Flow-report** – утилита позволяющая строить отчеты, группируя трафик и сортируя данные по заданным параметрам. Чем-то похожа на функцию Groups By в SQL. Типов отчетов, которые она может сгенерировать множество (многие из них могут быть полезны для Traffic Engineering). Нас интересуют следующие:
* **ip-destination-address/ip-source/destination-port** – группировка потоков, как не сложно догадаться, по ip-destination адресу, source/dest порту. Это значит, что будут объединены все потоки с одинаковыми ip-destination-address & ip-source & destination-port и представлены в отчете в отсортированном порядке, например, по потокам или пакетам (если конечно эту сортировку задать). Такого рода отчет позволит выявить так называемые DDoS-атаки с отражением на какой-нибудь сервис. К примеру, если зафиксировано аномально большое количество потоков с порта 53 на порт 80 какого-нибудь хоста, можно говорить о возможной атаке. Это удобно, так как в большинстве случаев такого рода потоков немного, и при правильно настроенном пороге можно выявить атаку даже с минимальным результирующим трафиком. Для того что бы задать отчет, нужно создать файл с его описанием. Создадим файл reports.cfg:
```
stat-report sdport_flows
type ip-destination-address/ip-source/destination-port
output
format ascii
options -header,-xheader,-totals,-names
fields +flows,-octets,-packets,-duration
sort +flows
stat-definition sdport_flows
report sdport_flows
```
* **ip-destination-address/ip-destination-port** – более грубая группировка, учитывающая только два параметра. Но работать она будет по пакетам. Добавим в созданный файл reports.cfg:
```
stat-report dport_packets
type ip-destination-address/ip-destination-port
output
format ascii
options -header,-xheader,-totals,-names
fields -flows,-octets,+packets,-duration
sort +packets
stat-definition dport_packets
report dport_packets
```
* **ip-destination-address** – и самая грубая группировка по результирующему трафику на конкретный ip. Здесь мы создадим два отчета по потокам и по пакетам.
```
stat-report flows
type ip-destination-address
output
format ascii
options -header,-xheader,-totals,-names
fields +flows,-octets,-packets,-duration
sort +flows
stat-definition flows
report flows
stat-report packets
type ip-destination-address
output
format ascii
options -header,-xheader,-totals,-names
fields -flows,-octets,+packets,-duration
sort +packets
stat-definition packets
report packets
```
3. **Flow-print** – позволяет отобразить собранную телеметрию.
Результирующий скрипт (Python 3) с установленными порогами для каждого отчета будет анализировать собранную телеметрию и в случае обнаружения атаки (то есть превышения порога для отчета), сбрасывать письмо на почту с расшифровкой трафика на IP жертвы за данную минуту.
Код скрипта я приводить не буду, он с файлами filters.cfg и reports.сfg доступен на [GitHub](https://github.com/owenear/ddos-detect)
Для его работы достаточно сконфигурировать некоторые параметры в config.ini. И добавить его в крон на исполнение в каждую минуту.
**Настраиваем config.ini**В частности, задать пороги для отчетов в зависимости от интенсивности трафика в вашей сети, а также от настроек семплинга NetFlow на сетевом оборудовании.
```
[REPORTS]
sdport_flows
dport_packets
flows
packets
# Reports(rules) options
# threshold - threshold value
# key_field - report field index number to which the threshold applies
# filter - name of a filter described in FiltersFileName
[sdport_flows]
threshold = 300
key_field = 4
filter = white-list
[dport_packets]
threshold = 3000
key_field = 3
filter = white-list
[flows]
threshold = 2000
key_field = 2
filter = white-list
[packets]
threshold = 5000
key_field = 2
filter = white-list
```
* threshold — пороговое значение, IP адреса в отчете с количеством потоков/пакетов превышающим это значение считаются атакуемыми.
* key\_field — индекс поля в выводе отчета (начиная с 1), к которому применяется порог.
* filter — имя фильтра применяющегося к данным статистики до группировки данных отчетом flow-report.
Задать пути расположения файлов и настройки отправки почты:
```
[FILES]
# Dir with flow-tools binary files
FlowToolsBinDir = /usr/local/bin/
# Dir with Whois, AWK binary files
SysBinDir = /usr/bin/
FlowsDir = /var/db/flows/
ReportsFileName = reports.cfg
FiltersFileName = filters.cfg
[EMAIL]
SMTPServer = localhost
# 0-default port
SMTPPort = 0
MailFrom = mail@example.com
MailTo = mail@example.com
Subject = [DDoS Detect]
# Amount of flow-print records in an email
FlowPrintTail = 50
# Use TLS (if True, Auth must be the same)
Secure = False
# Use Login and Password
Auth = False
# Notification Frequency about current DDoS attack - every value minutes
# if 0 - don't send email, print victims ip to stdout
NotifyFreq = 5
# Act if Auth = True
[EMAIL-AUTH]
Login = ...
Password = ...
```
Письмо с уведомлением об атаке выглядит так:
Скрипт позволяет добавлять/убирать свои отчеты по которым будет происходить анализ трафика, задавать для каждого отчета свой фильтр из файла filters.cfg, менять частоту уведомлений для текущей DDoS-атаки. Позволяет также вывести список атакуемых IP на stdout, не отправляя письмо.
Еще раз ссылка на [**GitHub**](https://github.com/owenear/ddos-detect)
Вот собственно и все. Спасибо за внимание! | https://habr.com/ru/post/478238/ | null | ru | null |
# MockK — библиотека для mocking-а в Kotlin
 Kotlin пока еще очень новая технология и это значит, что существует множество возможностей сделать что-то лучше. Для меня этот путь был таким. Я начал писать простой слой веб-обработки на Netty и coroutine-ах. Всё было в порядке, я даже сделал что-то вроде веб-фреймворка с роутингом, веб-сокетами, DSL и полной асинхронностью. Для первого раза всё показалось лёгким в освоении. Действительно, coroutine-ы делают из лапши коллбэков линейный и читаемый код.
Сюрприз ожидал меня, когда я начал тестировать это всё. Оказывается, Kotlin и mocking сложно совместимые вещи. В первую очередь из-за final полей. Далее, существует ровно одна библиотека для тестирования котлина и это Mockito. Для неё создана обёртка, которая предоставляет что-то вроде DSL. Но и тут не всё гладко. В первую очередь это тестирование функций с именованными параметрами. Mockito требует задавать абсолютно все параметры в виде matcher-ов, а в Kotlin этих параметров часто много и часть из них имеют значения по умолчанию. Задавать их все слишком накладно. Кроме того, часто последним параметром передается лямбда-блок. Создавать ArgumentCaptor и выполнять сложный кастинг, для того чтобы его вызвать — перебор. Сами корутины — это функции с последним параметром типа Continuation. И это требует специальной обработки. В Mockito её добавили, но не добавили удобства вызова самых корутин. Итого, из всех этих мелочей складывается ощущение, что обёртка эта не совсем гармонично вписывается в язык.
Прикинув объем работ я пришел к выводу, что один человек вполне может справиться и начал писать свою библиотеку. Я постарался сделать её близкой к языку и решить те проблемы, с которыми я столкнулся при тестировании.
Сейчас я расскажу, что у меня вышло. Вот для затравки простейший пример:
```
val car = mockk()
every { car.drive(Direction.NORTH) } returns Outcome.OK
car.drive(Direction.NORTH) // returns OK
verify { car.drive(Direction.NORTH) }
```
Здесь не используются matcher-ы, просто в целом показан синтаксис DSL. Вначале блок every/returns задает, что mock должен возвращать, и блок verify для проверки был ли вызов произведен.
Конечно, в MockK есть возможность захвата переменных, множество matcher-ов, spy-и и других конструкций. Вот более развернутый [пример](https://gist.github.com/oleksiyp/289c2a49cabe38023a05ea0e9335d22f). Все это также есть в Mockito. Поэтому хотелось бы описать отличия.
 Итак, чтобы всё это работало, мне потребовался Java Agent, чтобы убрать все final атрибуты. Это совсем не сложно, работает из Maven/Gradle, но не очень хорошо работает с IDE. Каждый раз нужно приписывать “-javaagent:<какой-то путь>” параметр. Была даже идея написать плагины для популярных IDE, которые позволяют легко запускать Java Agent-ы. Но в результате, пришлось сделать поддержку запуска JUnit4 и JUnit5 без Java Agent.
Для JUnit4 это запуск посредством стандартной аннотации @RunWith, которую и сам не люблю, но деваться некуда. Для того, чтобы хоть как-то сделать жизнь проще, я добавил ChainedRunWith. Она позволяет задавать следующий Runner в цепочке и таким образом использовать две разные библиотеки.
Для JUnit5 достаточно добавить зависимость на JAR с агентом, и вся магия произойдет сама собой. Но могу сказать, что в реализации это сущий хак с Unsafe, Javassist и Reflection. По этой причине официальным способом запуска все-же считается запуск через Java Agent.
Следующая фишка — возможность задать не все параметры, как matcher-ы, а только часть из них. Для реализации этой возможности пришлось пораскинуть мозгами. Если у нас есть вот такая функция:
```
fun response(html: String = "",
contentType: String = "text/html",
charset: Charset = Charset.forName("UTF-8"),
status: HttpResponseStatus = HttpResponseStatus.OK)
```
И где-то есть его вызов:
```
response(“Great”)
```
То чтобы протестировать это в Mockito, обязательно нужно указывать все параметры:
```
`when`(mock.response(eq(“Great”), eq("text/html"),
eq(Charset.forName(“UTF-8”)), eq(HttpResponseStatus.OK)))).doNothing()
```
Это явно ограничивает. В MockK можно указать только необходимые matcher-ы, все остальные параметры будут заменены на eq(...) или, если указан matcher allAny(), то на any().
```
every { response(“Great”) } answers { nothing }
every { response(eq(“Great”)) } answers { nothing }
every { response(eq(“Great”), allAny()) } answers { nothing }
```
 Это достигается таким трюком: блок every вызывается несколько раз и каждый раз matcher возвращает случайное значение, дальше данные сопоставляются и находятся нужные matcher-ы. Для тех мест, где не задан matcher, аргумент почти всегда будет константный. «Почти всегда» потому, что иногда всё-таки параметром по умолчанию будет функция, возвращающая время или что-то подобное. Это легко обойти явным указанием matcher-а.
Далее о тестировании DSL. К примеру, рассмотрим такой код:
```
fun jsonResponse(block: JsonScope.() -> Unit) {
val str = StringBuilder()
JsonScope(str).block()
response(str.toString(), "application/json")
}
jsonResponse {
seq {
proxyOps.allConnections().forEach {
hash {
"listenPort"..it.listenPort
"connectHost"..it.connectHost
"connectPort"..it.connectPort
}
}
}
}
```
Не важно, что он делает сейчас — важно, что это композиция конструкций из DSL-а, собирающая JSON.
Как это тестировать? В MockK для этого есть специальный matcher captureLambda. Удобство заключается в том, что мы одним выражением можем захватить lambd-у и в ответе вызвать ее:
```
val strBuilder = StringBuilder()
val jsonScope = JsonScope(strBuilder)
every {
scope.jsonResponse(captureLambda(Function1::class))
} answers {
lambda(jsonScope)
}
```
Чтобы проверить правильность основного кода, можно сравнить содержимое StringBuilder-а с образцом того, что должно быть в ответе. Удобство только в том, что блок, передаваемый как последний параметр, это идиома языка, и удобно иметь специальный способ её обработки в mocking фреймворке.
Поддержка coroutine тоже не столько сложно реализуемая функция, сколько просто удобный способ делать то, что язык представляет из коробки. Просто заменяем вызов every и verify на coEvery и coVerify и можем вызывать coroutine-у внутри.
```
suspend fun jsonResponse(block: JsonScope.() -> Unit) {
val str = StringBuilder()
JsonScope(str).block()
response(str.toString(), "application/json")
}
coVerify { scope.jsonResponse(any()) }
```
В итоге, цель проекта сделать mocking в Kotlin максимально удобным, а не нарастить тысячи функций, которые есть в PowerMock и Mockito. К этому я буду стремиться и дальше.
Прошу общественность не судить строго, попробовать библиотеку в своих проектах и предложить новые функции, довести до ума текущие.
Сайт проекта: <http://mockk.io> | https://habr.com/ru/post/341202/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.