text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Пишем 3D игру под Windows Mobile, ч.1
На хабре достаточно много пользователей коммуникаторов. И вы рассказывали достаточно много историй о том, как вы их использовали в своё время: раскладывали пасьянс, играли в шарики, сидели в интернете, читали книги и в конце-концов, использовали как телефон. А что, если я вам скажу, что на коммуникаторах было аж два API для рисования 3D графики? Причем оба могли уметь хардварное ускорение. Так почему бы не написать **3D** игрушку под них, причем с фоллбеком до девайсов без 3D ускорения?
### Что будет за игра?
Давайте определимся с вектором развития нашей игры: жанр, проекция, GAPI, поддерживаемые платформы и методы ввода.
Игра будет в классическом жанре скроллшутера. Только шутер у нас 3D, поэтому вид у нас будет сзади нашего космического корабля. Как многие догадываются, в таких играх кораблик обычно никуда не летит, он стоит на месте, а впереди него просто спавнятся и летят в его сторону враги. За это у нас будет отвечать SpawnDirector. Как GAPI мы возьмём D3D Mobile - спец GAPI для Windows Mobile, появившееся с WM5.0(но его можно установить и на Pocket PC 2003). Из платформ мы будем поддерживать от PPC2003, до WM6.5, т.е почти все устройства. Из методов ввода у нас будут как хардварные кнопки с альтернативными биндами(например влево - это dpad и кнопка a, для девайсов с полноценной клавиатурой аля qtek 9100) и тачскрин. В качестве "графа" сцены будет использоваться классическая концепция сущностей - есть World, есть Entity, а игровые объекты наследуются от этого Entity и обновляют своё состояние/рисуют себя сами. Язык будет C#, основной принцип программирования - KISS. Я решил излагать в начале каждого "модуля" концепцию каждого отдельного класса, за что он отвечает и как влияет на общую картину. Возможно тот, кто читает эту статью не имел опыта в разработке игр, или имел самый базовый на готовом движке типа unity, и пытается теперь этот опыт тащить во все остальные сферы - это совершенно необязательно.
Вся диаграмма классовСтоит отметить что каких-то разительных отличий разработки именно под WM нет - здесь нет концепции бандлов из iOS или ассетов из Android, тачскрин == мышка, нет удобного DirectSound, но есть классический waveOut. Однако достаточно переносимое кроссплатформенное ядро будет реализовано. Настолько переносимое, что игру можно будет портировать за пару часов на совершенно другое GAPI или платформу(там, где есть .NET).
Хочется отметить, что разработку и отладку мы в первую очередь будем проводить на ПК(не под эмулятором). Постоянно деплоить на КПК неудобно и долго, поэтому у нас будет две версии игры - под ПК для отладки игровой логики, и для коммуникатора для оптимизации и адаптации управления. Именно такая практика позволит сделать ядро игры легко портируемым куда угодно. Изначально бОльшую часть игры я написал деплоя на реальный девайс(дабы понимать потянет ли софтрендер вообще такое качество графики), но когда пришел черед доводки геймплейных механик - портировал игру на ПК. Порт занял где-то 15-20 минут(это не шутка).
Зачаток портаВо время портирования игры я свожу к минимуму использование препроцессора и всякие #if WIN32 #if WINMOBILE #if ANDROID и.т.п.
Теперь по модулям:
### Рендерер
Для такой игры сложный рендерер с крутыми тенями и оптимизациями не нужен. Наоборот - чем меньше тем лучше. Как я уже говорил - Entity сам может себя рисовать, и для этого ему предоставлен фактически один единственный метод - DrawMesh, принимающий в себя сам меш, матрицу трансформации и материал. Установкой рендерстейтов(а большинство рендерстейтов задаются при создании контекста) занимается тоже он, в зависимости от материала. По большей части это текстура(у которой фиксированный сэмплерстейт - repeat режим адрессации текстуры, отключенный мипмаппинг и point фильтрация), и цвет. Ещё например, можно отключить запись в глубину(что используется для фона).
Очень раннее фото. Только дописан рендер моделек и загрузка текстур.За рендеринг отвечает класс Graphics. Он создаёт контекст, задает рендерстейты, отображает картинку на экран, задаёт трансформацию и проекцию для камеры и.т.п. Текстуры только 2D(никаких кубмап), и загружаются они с помощью встроенного загрузчика текстур(я не увидел смысла писать свой, поскольку у d3d нативный загрузчик очень шустрый) GAPI. Меши содержат в себе VertexBuffer(меши не индексированные), и грузятся из md2(простой и лёгкий формат, грузится только первый кадр анимации). Кроме того, он умеет рисовать текст(TextRenderer) используя нативное API системы.
Фактически порт с WM на ПК у меня занял 10-20 минут, поскольку D3DM очень похож на D3D8, а следовательно, и на D3D9. Всё те же концепции - "вершинные потоки", FVF, texture stages. Нет только шейдеров(только FFP), и есть более тонкая настройка некоторых аспектов(например перспективная коррекция текстур).
Под WM(и вообще старые платформы, в том числе Symbian) нужно соблюдать некоторые правила, например стоит вообще отказаться от альфа-блендинга, и заменить его на альфа-тест. Альфа-тест не нужно сортировать в отличии от блендинга(поэтому он используется например в cutout шейдерах листвы). Здесь нет сглаживания(оно хардварно может не поддерживаться драйвером), а формат бэкбуфера обычно RGB565(вместо ARGB/XRGB). Глубина обычно либо D16, либо D15S1(15 бит под глубину, 1 под трафарет).
Вот например, код заполнения структуры инициализации контекста:
```
PresentParameters pp = new PresentParameters();
pp.AutoDepthStencilFormat = DepthFormat.D16;
pp.BackBufferCount = 1;
pp.BackBufferFormat = Format.R5G6B5;
pp.BackBufferWidth = Engine.Current.Window.ViewportWidth;
pp.BackBufferHeight = Engine.Current.Window.ViewportHeight;
pp.EnableAutoDepthStencil = true;
pp.PresentFlag = PresentFlag.None;
pp.SwapEffect = SwapEffect.Discard;
pp.MultiSample = MultiSampleType.None;
pp.FullScreenPresentationInterval = PresentInterval.Default;
pp.Windowed = true;
```
Нужно быть готовым к тому, что драйвер может даже не поддерживать VSync(PresentationInterval), кроме Default(интеловский не поддерживает). Напоминает ситуацию с встроенной графикой Intel в нулевых, когда она кое-как поддерживала d3d и очень слабо держала ogl.
Формат вершины имеет позицию и текстурную координату. Нормалей нет, т.к ни освещения, ни отражений нет. На **данный** момент, они тут не нужны. Все расчёты в float(на девайсах без FPU, ага).
### Движок
Громко сказано. Это просто центральный объект, который управляет игровым циклом, считает delta time, создаёт окно и остальные подмодули. А ещё он занимается логированием(один-единственный метод Log) и резолвом ассетов. Выполнен как синглтон с конструктором, который создаёт окошко и задаёт базовые параметры, и методом Init, который инициализирует собственно сами подмодули(адепты RAII покидают этот пост и ~~ставят минус~~)
Зачатки геймплея### Звук
Классика. waveOut. Никакого 3D звука и даже панирования, сырой PCM поток направляется прямо в системный микшер через waveOut. Есть ещё DirectShow, но с ним отваливается PPC2003 - а у меня целых два деваса на этой платформе и терять её я не хочу ;P
WAV 8-битный, моно. Этого качества вполне хватает и оно универсально между платформами.
### Ввод
Ввод представлен как стандартный Sony-like контроллер, плюс тачскрин. Никакой абстракции типа GetAxis нет, игра получает инпут ровно от того, что ей нужно. Игра поддерживает как тачскрин(игровое поле поделено на две части - каждое отвечает за свое направление движение кораблика), так и дпад. Тоже самое и в менюшках - в будущем это даст возможность портировать игру, например, на Android TV.
Ввод посылает **Window**, он же разбирается с назначениями клавиш. Таким образом легко протянуть в игру ввод с XInput, Android геймпадов, XNA геймпадов(если будет порт на wp7). Это лучше чем городить отдельные абстракции типа клавиатуры, мыши, тача и геймпада. Фактически весь инпут это структура Touch(одно касание только) и IsKeyPressed. Всё.
### Матлиба
Опять же, громко сказано. Универсальная абстракция, дабы не зависеть от типов векторов/матриц GAPI. Реализован Mathf с широко-используемой математикой(интерполяция, градусы в радианы, clamp) и Vector3/Vector4. Для физики используется BoundingBox.
Сами матрицы не представлены как обёртки над матрицами матлибы того GAPI, что мы используем. Вместо этого есть класс Transform который оперирует с позицией/поворотом(углы Эйлера, в будущем можно легко добавить кватернионы)/масштабом.
```
public Matrix Matrix;
public Vector3 Position;
public Vector3 Rotation;
public Vector3 Scale;
public Transform(Vector3 pos, Vector3 rot, Vector3 scale)
{
Position = pos;
Rotation = rot;
Scale = scale;
Matrix = Matrix.Scaling(scale.X, scale.Y, scale.Z) *
Matrix.RotationY(rot.Y * Mathf.DegToRad) *
Matrix.RotationZ(rot.Z * Mathf.DegToRad) *
Matrix.RotationX(rot.X * Mathf.DegToRad) *
Matrix.Translation(pos.X, pos.Y, pos.Z);
}
```
Всё! Это весь "движок"! Без шуток ;) Теперь переходим к геймплею.
### Геймплей
Как я уже говорил - геймплей строится на том, что кораблик летает из точки в точку по одной оси, и уворачивается(и отстреливает) астероиды(однако противников можно добавить в будущем). "Граф" сцены строится на списке игровых объектов, а игровые объекты наследуются от Entity. Так давайте по порядку!
Самые примитивные модельки я делал сам(скайбокс, астероид, кубик снаряда и.т.п). Кораблик же взял чужой и конветрировал в md2.### World
Основной класс в игре, в каком-то смысле даже годобжект. Именно он управляет списком сущностей, спавном и деспавном игровых объектов, рисует фон, анимирует его, считает время и счёт и создаёт SpawnDirector. Кроме того, он рисует HUD(Head's Up Display - "геймплейный" UI).
**SpawnDirector** же управляет спавном врагов(т.е астероидов) и бонусов в фиксированные промежутки времени в зависимости от сложности. Сложность - нарастающая переменна раз в минуту, которая означает стадию игры. Чем выше стадия, тем быстрее спавнятся и летят астероиды на игрока.
**Entity** базовый класс для всех игровых объектов. Сам по себе очень примитивный, управляет апдейтами и отрисовкой. Имеет общие для всех объектов свойства - позицию, поворот, масштаб и хитбокс. Адепты противников виртуальных методов могут высказать своё мнение в комментариях(в манагед языке то).
```
public Vector3 Position;
public Vector3 Rotation;
public Vector3 Scale;
public BoundingBox Bounds;
public Entity()
{
Scale = new Vector3(1, 1, 1);
}
public BoundingBox GetBounds()
{
return new BoundingBox(Position.X + Bounds.X, Position.Y + Bounds.Y, Position.Z + Bounds.Z, Bounds.X2, Bounds.Y2, Bounds.Z2);
}
protected Transform GetTransform()
{
return new Transform(Position, Rotation, Scale);
}
public virtual void Update()
{
}
public virtual void Draw()
{
}
```
### Player
Собственно, класс игрока. Рисует кораблик, обрабатывает ввод от игрока, обрабатывает эффекты от бонусов и анимацию.
Код апдейта:
```
public override void Update()
{
base.Update();
UpdateFOVEffect();
UpdateInput();
if (nextAttack < 0)
{
if (Bonus == PlayerBonus.DoubleTheFun)
{
Projectile p1 = new Projectile(50, 1, false);
p1.Position = Position;
p1.Position.X -= p1.Bounds.X2;
Projectile p2 = new Projectile(50, 1, false);
p2.Position = Position;
p2.Position.X += p1.Bounds.X2;
Game.Current.World.Spawn(p1);
Game.Current.World.Spawn(p2);
nextAttack = 0.5f;
}
else
{
Projectile proj = new Projectile(50, 1, false);
proj.Position = Position;
Game.Current.World.Spawn(proj);
if (Bonus == PlayerBonus.QuickDick)
nextAttack = 0.3f;
else
nextAttack = 0.5f;
}
}
if (BonusTime < 0)
Bonus = PlayerBonus.None;
Position.X = Mathf.Clamp(Position.X, -World.Bounds, World.Bounds);
nextAttack -= Engine.Current.DeltaTime;
BonusTime -= Engine.Current.DeltaTime;
}
```
Где **UpdateFOVEffect** - анимирует плавающий угол обзора, создающий эффект полёта и качения, а **UpdateInput** - собственно обрабатывает ввод и двигает кораблик:
```
float strafe = 0;
if (Engine.Current.Input.IsPressed(Key.Left))
strafe = -1;
if (Engine.Current.Input.IsPressed(Key.Right))
strafe = 1;
if (Engine.Current.Input.Touch.IsTouching)
{
if (Engine.Current.Input.Touch.X < Engine.Current.Window.ViewportWidth / 2)
strafe = -1;
else
strafe = 1;
}
Position.X += strafe * (Speed * Engine.Current.DeltaTime);
Rotation.Z = strafe * -RotationEffect;
}
```
Кораблик сам стреляет в определенные промежутки времени, а эффекты бонусов обрабатываются "на месте", без всяких модных IBonusModifier.
### Projectile
Собственно, сам снаряд. Спавнит его игрок, но попозже его смогут спавнить и враги в сторону игрока. Каждый кадр "проходятся" по списку сущностей и, если пересекаются с кем-то, то наносят урон и сами себя уничтожают. Урон снаряда, и его направление регулирует тот, кто стреляет.
```
public override void Update()
{
base.Update();
foreach (Entity ent in Game.Current.World.EntityList)
{
if (ent.GetBounds().Intersects(GetBounds()))
{
if (ent is Enemy)
{
((Enemy)ent).Health -= damage;
Game.Current.World.Destroy(this);
}
}
}
if (lifeTime < 0)
Game.Current.World.Destroy(this);
lifeTime -= Engine.Current.DeltaTime;
Position.Z += direction * Speed;
}
```
### Pickup
Очевидно - различные бонусы, которые игра может подкидывать, чтобы игрок не скучал(и не умирал слишком рано). Есть два типа - аптечка и случайный бонус:
```
public abstract class Pickup : Entity
{
public const float Speed = 15.0f;
public Mesh Mesh;
public Material Material;
public Pickup()
{
Mesh = Mesh.FromFile("pickup.md2");
Bounds = new BoundingBox(-15, -15, -15, 15, 15, 15);
}
public override void Draw()
{
base.Draw();
Engine.Current.Graphics.DrawMesh(Mesh, GetTransform(), Material);
}
public override void Update()
{
base.Update();
if(GetBounds().Intersects(Game.Current.World.Player.GetBounds()))
{
Pick();
Game.Current.World.Destroy(this);
}
Rotation.Y += (Speed * 3) * Engine.Current.DeltaTime;
Position.Z -= Speed * Engine.Current.DeltaTime;
}
public abstract void Pick();
}
public class HealthPickup : Pickup
{
public HealthPickup()
: base()
{
Material.Texture = Texture2D.FromFile("health.jpg");
}
public override void Pick()
{
Game.Current.World.Player.Health = Mathf.Clamp(Game.Current.World.Player.Health + 40, 0, 120);
}
}
public class BonusPickup : Pickup
{
public BonusPickup()
: base()
{
Material.Texture = Texture2D.FromFile("upgrade.jpg");
}
public override void Pick()
{
Game.Current.World.Player.TakeBonus((PlayerBonus)new Random().Next(1, (int)PlayerBonus.MaxBonus - 1));
}
}
```
### Enemy
Базовый класс для врагов. Отрисовывает врага, отрабатывает столкновение с игроком. Остальное поведение(в т.ч анимацию и "пуляния"/траекторию отрабатывает дочерний класс).
**Asteroid** - один из видов врагов. Вот фактически весь код его реализации:
```
public sealed class Asteroid : Enemy
{
public const float Speed = 15;
public const float Rotate = 56;
public const int HPAmount = 20;
public Asteroid()
{
Mesh = Mesh.FromFile("asteroid.md2");
Material.Texture = Texture2D.FromFile("as0.jpg");
Bounds = new BoundingBox(-10, -10, -10, 10, 10, 10);
}
public override void Update()
{
base.Update();
if (Game.Current.World.Player.GetBounds().Intersects(GetBounds()))
{
Game.Current.World.Player.Health -= HPAmount;
Game.Current.World.Destroy(this);
}
Rotation.X += Rotate * Engine.Current.DeltaTime;
Position.Z -= Speed * Engine.Current.DeltaTime;
}
}
```
Просто и понятно? Я тоже так считаю, и можно легко добавить новых!
### HUD
HUD рисует UI во время игры - т.е здоровье, очки и всё такое. Кроме того, он рисует статус игрока(подобран бонус например).
### Заключение
Это скорее технодемка, нежели действительно полноценная игра. Её ещё предстоит доводить в следующей статье - вектор развития выбираете вы в голосовании. Хоть на данный момент это технодемка, в целом, получившийся фреймворк можно использовать не только для таких примитивных игр - например можно сделать простенькие гоночки. Или три в ряд. Возможно будет порт на Android. Если вам зашел такой стиль подачи игровой архитектуры - то я могу написать девлоги и по другим демкам, коих у меня несколько. Например "ралли кубок на тазах"(рабочее название, я питаю тёплые чувства к машинам этого автозавода):
С графики не плюёмся! Это же демка :)Или арена-шутер для мобилок "мощный семён" и его 2D версия
[Репозиторий на гитхабе](https://github.com/monobogdan/spaceshooterwm)
[Архив с билдом под Windows](https://disk.yandex.ru/d/Sqau0OWGpRlong)
Всем спасибо. Жду вас во второй части, а снизу опрос, на что делать упор. | https://habr.com/ru/post/695428/ | null | ru | null |
# Создание приложения с использованием Styled-Components в Vue.js
Привет, Хабр! На днях наткнулся на одну очень интересную статью на португальском. К счастью, удалось найти её английскую версию. Предлагаю вашему вниманию перевод на русский. Другие мои переводы вы можете найти на мой странице на хабре.
Ссылка на оригинал: [португальский](https://medium.com/@fsenaweb/construindo-sua-aplica%C3%A7%C3%A3o-com-styled-components-no-vue-js-3e550449ae0e), [английский](https://medium.com/javascript-in-plain-english/building-your-application-with-styled-components-in-vue-js-8d0fdd8e605a)
Для тех кто не в теме. Styled-Components это библиотека очень популярная в среде React & Ract-native разработчиков. Она позволяет писать пользовательский CSS прямо в JS.
Во Vue мы знаем сколь удобно работать с однофайловыми компонентами(SFC), ведь всё необходимое компоненту собрано в одном месте. Паттерн SFC существенно повысил популярность Vue.
Крайние несколько месяцев мне довелось принять участие в разработке крупного проекта на React. В нём мы использовали Styled-Components, и это был очень интересный опыт.
Однако, в большинстве своих проектов я использую Vue, поэтому естественно, что мне захотелось объединить новый опыт со Styled-Components и преимущества Vue.js экосистемы. Именно тогда я обнаружил, что такое решение уже есть и оно поддерживается теми же создателями, что и аналогичная библиотека под React: [vue-styled-components](https://github.com/styled-components/vue-styled-components?source=post_page-----8d0fdd8e605a----------------------).
#### Начало
Отложим пустую болтовню и перейдём к коду. Как обычно, используйте yarn или npm.
```
// for yarn
yarn add vue-styled-components
// for npm
npm install --save vue-styled-components
```
На моём [гитхабе](https://github.com/fsenaweb) вы найдёте репозиторий с примерами использования этой библиотеки.
Каждый элемент, используемый в примерах, может обрабатываться vue-styled-компонентами как изолированный компонент с его индивидуальными свойствами или путем получения данных от других компонентов.
Наш первый пример просто кнопка с дефолтными стилями.
```
import styled from "vue-styled-components";
const CButton = styled.button`
font-size: 1em;
text-align: center;
color: #FFFFFF;
border-radius: 5px;
padding: 10px 15px;
background-color: #0057AA;
`;
export default CButton;
```
В любом месте нашего приложения мы можем использовать этот компонент.
```
import CButton from '@/components/elements/Button'
export default {
name: 'app',
components: {
CButton
},
}
```
#### Передача параметров
В vue-styled-components вы можете динамически определять стили для компонента, передавая эти значения через свойства. Этот пример иллюстрирует, что при передаче основного атрибута кнопка получит новый стиль фона и цвет шрифта.
```
import styled from "vue-styled-components";
const typeButton = { primary: Boolean };
const CButtonProps = styled('button', typeButton)`
font-size: 1em;
text-align: center;
color: ${props => props.primary ? '#0057AA' : '#FFFFFF'};
border-radius: 5px;
padding: 10px 15px;
background-color: ${props => props.primary ? '#FFFFFF' : '#0057AA'};
`;
export default CButtonProps;
```
Приведенный выше пример может быть улучшен и даже добавлены новые свойства (вы можете передать столько атрибутов, сколько захотите). Все идет в соответствии с вашими потребностями в рамках проекта.
С помощью этой библиотеки мы получаем возможность управлять стилями через логику. В приведенном ниже примере у вас есть возможность выбрать, какую цветовую схему вы хотите назначить своей кнопке, не влияя на другие, тем самым разнообразив ваше приложение.
```
import styled from "vue-styled-components";
const typeButton = {
type: String,
radius: Boolean
};
const styleButton = type => {
switch (type) {
case "primary":
return `
background-color: #FFFFFF;
color: #0057AA;
`;
case "error":
return `
background-color: #B4000B;
color: #FDFDFD;
`;
case "success":
return `
background-color: #00C887;
color: #37435F;
`;
default:
return `
background-color: #0057AA;
color: #FFFFFF;
`;
}
}
const CButtonPropsCond = styled('button', typeButton)`
font-size: 1em;
text-align: center;
padding: 10px 15px;
border-radius: ${({ radius }) => radius ? "6px" : null};
${(props) => styleButton(props.type)}
`;
export default CButtonPropsCond;
```
Чтобы лучше объяснить процесс создания этой кнопки: мы сначала (всегда) импортируем vue-styled-components, сразу после (от строки 3 до строки 6) нам нужно определить, какие типы свойств будут переданы компоненту. От строки 8 до 31 мы создаем функцию, которая принимает значение свойства type, в соответствии с тем, что было передано, оно возвращает атрибуты фона. цвет и цвет их соответствующего регистра, если в качестве свойства ничего не передано, то кнопке будет присвоено значение по умолчанию.
Благодаря этим знаниям вы можете реализовать новые атрибуты, которые сделают ваш пользовательский компонент очень динамичным.
Я оставил эти маленькие примеры в своем GitHub, чтобы вы могли сделать начальный шаг в освоении этой библиотеки. Наслаждайтесь.
[Ссылка на репозиторий с примерами](https://github.com/fsenaweb/vue-styled-components?source=post_page-----8d0fdd8e605a----------------------). | https://habr.com/ru/post/467977/ | null | ru | null |
# Windows Phone 7 XNA: гнем пиксели или нет шейдерам
Привет дорогой друг.
Опять прошло много времени и я не радовал вас интересной информацией по
поводу разработки игр. Сегодня эту статью я хочу посветить разработке игр под **WP7**, используя
замечательный фреймворк **XNA**, о котором я писал [здесь](http://habrahabr.ru/blogs/gdev/128286/), [здесь](http://habrahabr.ru/blogs/gdev/128349/) и [здесь](http://habrahabr.ru/blogs/gdev/134819/) и [тут](http://habrahabr.ru/blogs/gdev/128112/). А конкретно, я вам расскажу, как можно сделать красивые эффекты **без шейдеров**. В этой статье рассмотрим **эффект искажения**. Остальное под катом.
#### Теория
Последние две статьи я писал про шейдеры и о том, как можно улучшить визуальное восприятие в вашей игре. Но если [посмотреть](http://blogs.msdn.com/b/shawnhar/archive/2010/03/12/reach-vs-hidef.aspx) на сравнение **Reach** и **HiDef** профилей XNA, то можно с ужасом
увидеть, что **Reach** поддерживает **Shader Modele 2.0**, а **WP7** её не поддерживает вообще. И от этого хочется ~~взять и ударить~~ придумать, как это все можно сделать без шейдеров.
Конечно, речь не идет о крутом освещении с normal mapping (хотя, извратиться можно), а просто о том, как можно погнуть пиксели с помощью **BasicEffect**. Такой метод прост до безумия, но крайне эффективен.
Итак, если вспомнить, ~~кто я такой и~~ о чем [я писал](http://habrahabr.ru/blogs/gdev/128349/), то можно вспомнить алгоритм, который мы
использовали в шейдерах: есть карта искажений и цветная карта. По карте искажений — гнем цветную карту. Просто? Забудьте. Такой метод крайне сложен в реализации под **WP7** без вмешательства GPU (доступа к которому у нас, к сожалению, нет).
*— Как же быть, парень?*
Вспомним, по каком принципу у нас рисуется что-либо в 3D, например обычный плоский квадрат? Он рисуется с помощью двух треугольников. В чем это может нам помочь? Все просто, создаем много треугольников, а потом, с помощью координат текстуры — будем двигать «какбэ» сам треугольник, отчего создается эффект искажения.
На деле — есть картинка — 480x800, мы создаем сетку размером 48x80 (поверьте, для красивого эффекта — в самый раз). Сетка — одномерный массив, состоящий из 3840 элементов. Просчитывается это все на WP7 примерно **3-4 ms**, при более низком качестве сетки — **1-2 ms**. Но если сетка будет слишком маленькая, то при искажении будет заметно, что треугольники все-таки существуют. А вот когда сетка меньше в 10 раз, это мало заметно, для сравнения — шаг на экране в 3 мм = 10 пикселям. Ну да ладно, что-то я разговорился.
*— Эй, чувак, хватит теории, переходи к практике.*
#### Практика
Чтобы рисовать что-либо на экране из примитивов, нужен **BasicEffect**. Например, **spriteBatch** — огромный класс, который скрывает от наших глаз всякие **BasicEffect**, но в конечном счете — все сводится к рисованию примитивов, накладывание текстур на них. Постараюсь более подробно объяснить об использовании **BasicEffect** в нашем случае.
Собираемся в путь, ищем материал.
Для начала нам нужна текстура, которую мы будем гнуть, встречайте нашего любимого друга:
И как-то странно, но нам еще нужен пустой проект, создаем его.
Сразу скажу, что одна из особенностей **XNA** под **WP7**, что по дефолту там **30 FPS** (взамен, родных **60 FPS**). Но что-то мне подсказывает, что можно и больше; С другой стороны — кому нужен батарея-киллер, а не таймкиллер? Поэтому, мы будем использовать **30 FPS**.
В пустом проекте вы найдете:
```
// Frame rate is 30 fps by default for Windows Phone.
TargetElapsedTime = TimeSpan.FromTicks(333333);
// Extend battery life under lock.
InactiveSleepTime = TimeSpan.FromSeconds(1);
```
Строчка, отвечающая за FPS — догадайтесь сами.
Следующий момент, это отсутствие клавиатуры, все действия выполняются с помощью мультитача.
Единственную кнопку, какую можно перехватить, это кнопка Back (назад), по дефолту — она выходит из приложения:
```
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
```
Поэтому, трогать в пустом проекте мы ничего не будем, приступаем к програмированию и собственно, практике. Для начала — наполним **Game1** смыслом ~~и любовью~~.
Создаем переменные:
```
Texture2D background;
BasicEffect basicEffect;
```
**background** — наша текстура, ну или RenderTarget какой-то.
**BasicEffect** — наш герой, нужный для отрисовки примитивов.
Грузим контент:
```
background = Content.Load("distortion");
```
Чуть не забыл, выставляем в конструкторе:
```
graphics.PreferredBackBufferWidth = 480;
graphics.PreferredBackBufferHeight = 800;
graphics.IsFullScreen = true;
```
Дабы была одна ориентация и не было проблем с позиционированием.
Инициализируем **BasicEffect** *(в Initialize)*:
```
basicEffect = new BasicEffect(GraphicsDevice);
basicEffect.TextureEnabled = true; // включаем накладывание текстур на примитивы
basicEffect.Projection = Matrix.CreateOrthographicOffCenter(0, 480, 800, 0, 0f, 10f);
basicEffect.View = Matrix.Identity;
basicEffect.World = Matrix.Identity;
```
**Projection** — матрица-проекция трехмерного объекта на двухмерную плоскость (экран).
**View** — матрица вида, камеры, если хотите.
**World** — мировая матрица: вращение, размер, позиция.
Зададим **View** и **World** — единичные матрицы.
А **Projection** зададим ортогональную проекцию, т.е. у нас будет примитив проецироваться на экран полностью. Концы примитива с концами экрана, если объяснить проще.
Так, пока с **Game1** все, создадим новый класс **GridVertexPositionColorTexture**, и вот его полный листинг (прошу прощения за полный, но он с комментариями):
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
namespace GridDistortion
{
public class GridVertexPositionColorTexture
{
public VertexPositionColorTexture[] Vertices; // Массив из вертексов, которые несут в
себе позицию вертекса, цвет вертекса и UV координаты текстуры
public short[] Indices; // Индексы, о них я расскажу в другой статье, где будет 3D тематика, заодно и расскажу, как строить примитивы
public int Width; // размер сетки по X
public int Height; // размер сетки по Y
public Vector2 CellSize; // шаг между точками в сетке по X и Y соответственно
public void BuildGeometry(int colums, int rows, Vector2 cellSize) // строим геометрию нашего примитива
{
Width = colums;
Height = rows;
CellSize = cellSize;
Vertices = new VertexPositionColorTexture[(Width + 1) * (Height + 1)]; // инициализация массива вертексов
Indices = new short[Width * Height * 6]; // тоже самое и про индексы
/* заполнение массива вертексов */
for (int i = 0; i < Width + 1; i++)
{
for (int j = 0; j < Height + 1; j++)
{
int index = j * (Width + 1) + i;
VertexPositionColorTexture vertex = new VertexPositionColorTexture()
{
Position = new Vector3(new Vector2(i, j) * CellSize, 0f), // позиция вертекса
Color = Color.White,
TextureCoordinate = GetDefaultUV(index) // текстурная координата
};
Vertices[index] = vertex;
}
}
/* заполнение массива индексов */
int indexPos = 0;
for (int i = 0; i < Width; i++)
{
for (int j = 0; j < Height; j++)
{
int v0 = j * (Width + 1) + i;
int v1 = j * (Width + 1) + i + 1;
int v2 = (j + 1) * (Width + 1) + i;
int v3 = (j + 1) * (Width + 1) + i + 1;
Indices[indexPos] = (short)v0;
Indices[indexPos + 1] = (short)v1;
Indices[indexPos + 2] = (short)v2;
Indices[indexPos + 3] = (short)v2;
Indices[indexPos + 4] = (short)v1;
Indices[indexPos + 5] = (short)v3;
indexPos += 6;
}
}
}
public void Draw(GraphicsDevice graphicsDevice) // отрисовка массива из наших VertexPositionColorTexture
{
graphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, Vertices, 0, Vertices.Length, Indices, 0, Indices.Length / 3);
}
public void ResetUVs() // сброс UV сетки
{
for (int i = 0; i < Vertices.Length; i++)
{
VertexPositionColorTexture v = Vertices[i];
v.TextureCoordinate = GetDefaultUV(i);
Vertices[i] = v;
}
}
public Vector2 GetUV0(int index) // получить значение сетки
{
return Vertices[index].TextureCoordinate;
}
public void SetUV0(int index, Vector2 value) // задать значение сетки
{
Vertices[index].TextureCoordinate = value;
}
public Vector2 GetDefaultUV(int index) // получить значение для сетки по дефолту
{
int i = index % (Width + 1);
int j = index / (Width + 1);
return new Vector2((float)i / Width, (float)j / Height);
}
}
}
```
Все хорошо, класс, отвечающий за прорисовку примитивов и за саму сетку — создан. Теперь нужно придумать контроллер к этой сетке, который будет её гнуть. В этой статье — расскажу вам про два контроллера сетки: **SimpleGrid**, **ElasticGrid**.
Первый у нас будет сбрасывать сетку, применять к ней текущие искажения.
Второй превратит нашу сетку в желе, которая будет колебаться, пока не придет к дефолтному состоянию.
Напишем первый контроллер, создадим новый класс **SimpleGrid** и его листинг:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
namespace GridDistortion
{
public class SimpleGrid
{
publicGridVertexPositionColorTexture grid; // наша подконтрольная сетка
public SimpleGrid(GridVertexPositionColorTexture grid)
{
this.grid = grid;
}
public void Update()
{
swap();
}
public virutal void swap() // просто сбрасываем сетку на стандартные значения
{
grid.ResetUVs();
}
public void Rebellion(Vector2 pos_rebellion, float radius) // делаем искажение на сетке с позицией и радиусом
{
Vector2 gridSize = new Vector2(grid.Width, grid.Height) * grid.CellSize; // размер нашего примитива
for (int i = 0; i < grid.Vertices.Length; i++)
{
Vector2 pos = grid.GetUV0(i) * gridSize; // получаем реальную позицию вертекса из сетки
Vector2 newPos = pos;
Vector2 center = pos_rebellion; // где произошло искажение
float distance = Distance(pos, center); // получаем дистанцию от центра искажение до текущей точки
if (distance < radius) // если дистанция больше радиуса, то не трогаем пиксель, экономим ресурсы
{
Vector2 dir = pos - center; // получаем вектор направления
float length = dir.Length();
float minDisplacement = -length;
if (dir.Length() != 0)
{
dir.Normalize(); // нормализуем вектор
}
Vector2 displacement = dir * Math.Max(-100f, minDisplacement); // задаем вектор искажения, где -100f — его сила, положительная величина — не увеличит изображение, а сожмет
newPos += displacement * (1f - distance / radius) * 0.25f;
grid.SetUV0(i, newPos / gridSize); // задаем новую позицию
}
}
}
public static float Distance(Vector2 vector1, Vector2 vector2)
{
double value = ((vector2.X - vector1.X) * (vector2.X - vector1.X)) + ((vector2.Y -
vector1.Y) * (vector2.Y - vector1.Y));
return (float)Math.Sqrt(value);
}
}
}
```
Контроллер написан, теперь вернемся к **Game1**, две новых переменных:
```
GridVertexPositionColorTexture grid;
SimpleGrid simpleGrid;
```
Их инициализация:
```
grid = new GridVertexPositionColorTexture();
grid.BuildGeometry(48, 80, new Vector2(10, 10));
simpleGrid = new SimpleGrid(grid);
```
Сам **Update**:
```
simpleGrid.Update(); // обновляем контроллер сетки
TouchCollection collection = TouchPanel.GetState(); // получаем все прикосновения
foreach (TouchLocation point in collection)
{
if (point.State == TouchLocationState.Moved)
{
simpleGrid.Rebellion(point.Position, 100f); // создаем искажение в точки point.Position с радиусом 100f
}
}
```
Ну и наконец прорисовка:
```
GraphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; // уставливаем Clamp, т.к. с Wrap-ом будут проблемы в Reach профиле, чьи размеры не степень двойки
basicEffect.Texture = background; // задаем текстуру для примитива
basicEffect.CurrentTechnique.Passes[0].Apply(); // применяем basicEffect
grid.Draw(GraphicsDevice); // рисуем примитив
```
Запускаем, касаемся экрана и видим искажения или эффект линзы.
Но повеселимся еще, сделаем желе из текстуры, класс **ElasticGrid**, наследуемый от **SimpleGrid**:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
namespace GridDistortion
{
public class ElasticGrid : SimpleGrid
{
private Vector2[] Velocity; // скорости вертексов
public ElasticGrid(GridVertexPositionColorTexture grid) : base(grid) { this.Velocity =
new Vector2[(grid.Width + 1) * (grid.Height + 1)]; }
public override void swap()
{
Vector2 gridSize = new Vector2(grid.Width, grid.Height) * grid.CellSize;
for (int i = 0; i < grid.Vertices.Length; i++)
{
//Get the position in pixels
Vector2 pos = grid.GetUV0(i) * gridSize;
Vector2 pos_default = grid.GetDefaultUV(i) * gridSize;
Vector2 dir = (pos_default - pos) / 1.1f; // получаем вектор скорости и делим
его каждый раз на 1.1f,
//Set the new Texture Coordinates
grid.SetUV0(i, (pos + Velocity[i]) / gridSize); // задаем позицию + вектор
скорости
Velocity[i] = dir; // пишем в массив скорость
}
}
}
}
```
Меняем контроллер сетки в **Game1** и любуемся искажениями.
Вот такой простой и интересный подход. Контроллеров может быть бесконечное кол-во, например, реалистичная вода в реалтайме без всяких шейдеров с волнами ~~и шлюхами~~.
В другой раз я попробую описать другие методы придания вашей игре красоты.
Так же из серии по XNA планируется написание статей на тематику 3D.
Ну и как бонус, следующая статья возможно будет о том, как можно написать игру на WP7, разместить её в маркете бесплатно, без рекламы и сидеть в нищете.
Исходники скачать можно [тут](http://forhaxed.ru/GridDistortion.zip).
Экспериментируйте, творите; до новых встреч :-) | https://habr.com/ru/post/137869/ | null | ru | null |
# Путешествие через вычислительный конвейер процессора
Так как карьера программиста тесно связана с процессором, неплохо бы знать как он работает.
Что происходит внутри процессора? Сколько времени уходит на исполнение одной инструкции? Что значит, когда новый процессор имеет 12, или 18, или даже 31-уровневый конвейер?
Программы обычно работают с процессором, как с чёрным ящиком. Инструкции входят и выходят из него по порядку, а внутри совершается некая вычислительная магия.
Программисту полезно знать, что происходит внутри этого ящика, особенно, если он будет заниматься оптимизацией программ. Если вы не знаете какие процессы протекают внутри процессора, как вы сможете оптимизировать под него?
Эта статья рассказывает, как устроен вычислительный конвейер x86 процессора.
#### Вещи, которые вы уже должны знать
Во-первых, предполагается, что вы немного разбираетесь в программировании или может даже немного знаете ассемблер. Если вы не понимаете, что я имею ввиду, когда использую термин «указатель на инструкцию» (instruction pointer), тогда, возможно, эта статья не для вас. Когда я пишу о регистрах, инструкциях и кэшах, я предполагаю, что вы уже знаете, что это значит, можете понять или нагуглить.
Во-вторых, эта статья – упрощение сложной темы. Если вам кажется, что я пропустил какие-то важные моменты, добро пожаловать в комментарии.
В-третьих, я акцентирую внимание только на процессорах Intel x86 семейства. Я знаю о существовании других семейств процессоров, кроме x86. Я знаю, что AMD внесло много полезных нововведений в x86 семейство, и Intel их приняло. Но архитектура и набор инструкций принадлежит Intel, также Intel представило реализацию самых главных особенностей семейства, так что для простоты и логичности, речь пойдет именно об их процессорах.
В-четвертых, эта статья уже устарела. В разработке более новые процессоры, и некоторые из них уже скоро ожидаются в продаже. Я очень рад, что технологии развиваются такими быстрыми темпами и надеюсь, что когда-нибудь все стадии, описанные ниже, полностью устареют и будут заменены еще более удивительными достижениями в процессоростроении.
#### Основы вычислительного конвейера
Если посмотреть на x86 семейство в целом, то можно заметить, что оно не сильно изменилось за 35 лет. Было много дополнений, но оригинальный дизайн, как и почти весь набор команд, в основном остались нетронутыми и до сих пор прослеживаются в современных процессорах.
Первоначальный 8086 процессор имеет 14 регистров, которые используются до сих пор. Четыре регистра общего назначения – AX, BX, CX и DX. Четыре сегментных регистра, которые используют для облегчения работы с указателями – CS (Code Segment), DS (Data Segment), ES (Extra Segment) и SS (Stack Segment). Четыре индексных регистра, которые указывают на различные адреса в памяти – SI (Source Index), DI (Destination Index), BP (Base Pointer) и SP (Stack Pointer). Один регистр содержит битовые флаги. И, наконец, самый главный регистр в этой статье – IP (Instruction Pointer).
IP регистр – это указатель с особой функцией, его задача указывать на следующую инструкцию, которая подлежит исполнению.
Все процессоры в x86 семействе следуют одному и тому же принципу. Сначала они следуют указателю на инструкцию и декодируют следующую команду по этому адресу. После декодирования следует этап выполнения этой инструкции. Некоторые инструкции читают из памяти или пишут в нее, другие производят вычисления, сравнения или другую работу. Когда работа окончена, команда проходит через этап отставки (retire stage) и IP начинает указывать на следующую инструкцию.
Этот принцип декодирования, выполнения и отставки одинаково применяется как в первом 8086 процессоре, так и в самом последнем Core i7. С течением времени были добавлены новые этапы конвейера, но принцип работы остался прежним.
#### Что изменилось за 35 лет
Первые процессоры были просты по сегодняшним меркам. 8086 процессор начинал с проверки команды на текущем указателе на инструкцию, декодировал ее, выполнял, отставлял и продолжал работу со следующей инструкцией на которую указывал IP.
Каждый новый чип в семействе добавлял новую функциональность. Большинство добавляло новые инструкции, некоторые добавляли новые регистры. Чтобы оставаться в рамках этой статьи, я буду уделять внимание изменениям, которые непосредственно касаются прохождения команд через ЦП. Другие изменения, такие как добавление виртуальной памяти или параллельной обработки, конечно же интересны, но выходят за рамки данной статьи.
В 1982 был введён кэш инструкций. Вместо обращения к памяти на каждой команде, процессор читал на несколько байт дальше текущего IP. Кэш инструкций был всего несколько байт в размере, достаточным для хранения лишь нескольких команд, но ощутимо увеличивал производительность, исключая постоянные обращения к памяти каждые несколько тактов.
В 1985 в 386 процессор был добавлен кэш данных и увеличен размер кэша инструкций. Этот шаг позволил увеличить производительность за счет чтения на несколько байт дальше запроса на данные. На тот момент кэши данных и инструкций измерялись в килобайтах, нежели в байтах.
В 1989 i486 процессор перешел на 5-уровневый конвейер. Вместо наличия одной инструкции во всем процессоре, теперь каждый уровень конвейера мог иметь по инструкции. Это нововведение позволило увеличить производительность более чем в два раза по сравнению с 386 процессором на той частоте. Этап загрузки (fetch stage) извлекал команду из кэша инструкций (размер кэша в то время был обычно 8кб). Второй этап декодировал инструкцию. Третий этап транслировал адреса памяти и смещения, необходимые для команды. Четвёртый этап выполнял инструкцию. Пятый этап отправлял команду в отставку и записывал результаты обратно в регистры и память по мере необходимости. Появление возможности держать в процессоре множество инструкций одновременно позволило программам выполняться гораздо быстрее.
1993 год был годом появления процессора Pentium. Название семейства процессоров сменилось с номеров на имена из-за судебного процесса, поэтому оно было названо Pentium вместо 586. Конвейер чипа изменился еще больше по сравнению с i486. Архитектура Pentium добавила второй отдельный суперскалярный конвейер. Основной конвейер работал также, как и на i486, в то время как второй выполнял более простые инструкции, такие как целочисленная арифметика, параллельно и намного быстрее.
В 1995 Intel выпустило процессор Pentium Pro, который имел кардинальные изменения в дизайне. У чипа появилось несколько особенностей, включая ядро с внеочерёдным (Out-of-Order, OOO) и упреждающим (Speculative) исполнением команд. Конвейер был расширен до 12 этапов, и в него вошло нечто, называемое суперконвейером (superpipeline), где большое количество инструкций могло исполняться одновременно. OOO ядро будет более подробно освещено ниже в статье.
Между 1995 годом, когда OOO ядро было представлено, и 2002 было сделано много важных изменений. Были добавлены дополнительные регистры и представлены инструкции, которые могли обрабатывать множество данных за раз (Single Instruction Multiple Data, SIMD). Появились новые кэши, старые увеличились в размере. Этапы конвейера делились и объединялись, адаптируясь к требованиям реального мира. Эти и многие другие изменения были важны для общей производительности, но мало что значили, когда речь шла о потоке данных через процессор.
В 2002 Pentium 4 представил новую технологию — Hyper-Threading. OOO ядро было настолько успешным в обработке команд, что способно было обрабатывать инструкции быстрее, чем они могли быть посланы ядру. Для большинства пользователей OOO ядро процессора практически бездействовало большую часть времени даже под нагрузкой. Для обеспечения постоянного потока инструкций к OOO ядру добавили второй фронт-энд. Операционная система видела два процессора вместо одного. Процессор содержал два набора x86 регистров, два декодера инструкций, которые следили за двумя наборами IP и обрабатывали два набора инструкций. Далее команды обрабатывались одним общим OOO ядром, но это было незаметно для программ. Потом инструкции проходили этап отставки, как и ранее, и посылались назад к виртуальным процессорам, на которые они поступали.
В 2006 Intel выпустило микроархитектуру Core. В маркетинговых целях она была названа Core 2 (потому что каждый знает, что два лучше, чем один). Неожиданным ходом было снижение частоты процессоров и отказ от Hyper-Threading. Снижение частот способствовало расширению всех этапов вычислительного конвейера. OOO ядро было расширено, кэши и буферы были увеличены. Архитектура процессоров была переработана с уклоном на двух- и четырёхъядерные чипы с общими кэшами.
В 2008 Intel ввело схему именования процессоров Core i3, Core i5 и Core i7. В этих процессорах вновь появился Hyper-Threading с общим OOO ядром, и отличались они, в основном, лишь размерами кэшей.
Будущие процессоры: Следующее обновление микроархитектуры, названной Haswell, по слухам, будет выпущено во второй половине 2013. Опубликованные на данный момент документы говорят о том, что это будет 14-уровневый конвейер, и, скорей всего, принцип обработки информации будет все также следовать дизайну Pentium Pro.
Так что же такое этот вычислительный конвейер, что такое OOO ядро и как это все увеличивает скорость обработки?
#### Вычислительный конвейер процессора
В самом простой форме, описанной выше, одиночная инструкция входит в процессор, обрабатывается и выходит с другой стороны. Это довольно интуитивно для большинства программистов.
Процессор i486 имел 5-уровневый конвейер – загрузка (Fetch), основное декодирование (D1), вторичное декодирование или трансляция (D2), выполнение (EX), запись результата в регистры и память (WB). Каждый этап конвейера мог содержать по инструкции.
*Конвейер i486 и пять инструкций, проходящие через него одновременно.*
Однако такая схема имела серьезный недостаток. Представьте себе код ниже. До прихода конвейера следующие три строки кода были распространенным способом поменять значения двух переменных без использования третьей.
```
XOR a, b
XOR b, a
XOR a, b
```
Чипы, начиная с 8086 и до 386 не имели внутреннего конвейера. Они обрабатывали только одну инструкцию в каждый момент времени, независимо и полностью. Три последовательных XOR инструкции в такой архитектуре вовсе не проблема.
Теперь подумаем, что происходит с i486, так как это был первый x86 чип с конвейером. Наблюдать за многими вещами в движении одновременно может быть затруднительно, поэтому, возможно, вы сочтёте полезным обратиться к диаграмме выше.
Первая инструкция входит в этап загрузки, на этом первый шаг закончен. Следующий шаг – первая инструкция входит в D1 этап, вторая инструкция помещается в этап загрузки. Третий шаг – первая инструкция двигается в D2 этап, вторая в D1 и третья загружается в Fetch. На следующем шагу что-то идет не так – первая инструкция переходит в EX..., но остальные остаются на месте. Декодер останавливается, потому что вторая XOR команда требует результат первой. Переменная «a» должна быть использована во второй инструкции, но в неё не будет произведена запись, пока не выполнилась первая инструкция. Поэтому команды в конвейере ждут, пока первая команда не пройдет EX и WB этапы. Только после этого вторая инструкция может продолжить свой путь по конвейеру. Третья команда аналогично застрянет в ожидании выполнения второй команды.
Такое явление называется ступор конвейера (pipeline stall) или конвейерный пузырь (pipeline bubble).
Другой проблемой конвейеров является возможность одних инструкций выполняться очень быстро, а других очень медленно, что было более заметно с двойным конвейером Pentium.
Pentium Pro представил с собой 12-уровневый конвейер. Когда это число было впервые озвучено, то понимавшие как работал суперскалярный конвейер программисты затаили дыхание. Если бы Intel последовало такому же принципу с 12-уровневым конвейером, то любой ступор конвейера или медленная инструкция серьезно бы сказывались на производительности. Но в то же время Intel анонсировало кардинально отличающийся конвейер, названный ядром с внеочерёдным исполнением (OOO core). Несмотря на то, что это трудно было понять из документации, Intel заверило разработчиков, что они будут потрясены результатами.
Давайте разберем OOO ядро более детально.
#### OOO конвейер
В случае с OOO ядром, иллюстрация стоит тысячи слов. Так что давайте посмотрим несколько картинок.
##### Диаграмы конвейеров процессора
5-уровневый конвейер i486 работал замечательно. Эта идея была довольно распространена среди других семейств процессоров в то время и работала отлично в реальных условиях.
*Суперскалярный конвейер i486.*
Конвейер Pentium был даже еще лучше i486. Он имел два вычислительных конвейера, которые могли работать параллельно, и каждый из них мог содержать множество инструкций на различных этапах, позволяя вам обрабатывать почти в двое больше инструкций за то же время.
*Два параллельных суперскалярных конвейера Pentium.*
Однако наличие быстрых команд, ожидающих выполнение медленных, было все также проблемой в параллельных конвейерах, как и наличие последовательных команд (привет ступор). Конвейеры были все так же линейными и могли сталкиваться с непреодолимыми ограничениями производительности.
Дизайн OOO ядра сильно отличался от предыдущих чипов с линейными путями. Сложность конвейера возросла, и были введены нелинейные пути.
*OOO ядро, используемое с 1995 года. Цветовое обозначение соответствует пяти этапам, используемых в предыдущих процессорах. Некоторые этапы и буферы не показаны, так как варьируются от процессора к процессору.*
Сначала инструкции загружаются из памяти и помещаются в кэш инструкций процессора. Декодер современного процессора может предсказать появление скорого ветвления (например вызов функции) и начать загрузку инструкций заранее.
Этап декодирования был немного изменен по сравнению с более ранними чипами. Вместо обработки лишь одной инструкции на IP, Pentium Pro мог декодировать до трех инструкций за такт. Сегодняшние процессоры (2008-2013) могут декодировать до четырёх инструкций за такт. Результатом декодирования являются микрооперации (micro-ops / µ-ops).
Следующий этап (или группа этапов) состоит из трансляции микроопераций (micro-op transaltion) и последующего присвоения псевдонимов регистрам (register aliasing). Множество операций выполняются одновременно, возможно внеочерёдно, поэтому одна инструкция может читать из регистра, пока другая в него пишет. Запись в регистр может подавить значение, нужное другой инструкции. Оригинальные регистры внутри процессора (AX, BX, CX, DX итд.) транслируются (или создаются псевдонимы) во внутренние, скрытые от программиста регистры. Значение регистров и адресов памяти затем должны быть привязаны к временным значениям для обработки. На данный момент 4 микрооперации могут проходить через этап трансляции за такт.
После трансляции все микрооперации входят в буфер переупорядочивания (reorder buffer, ROB). На данный момент этот буфер может вмещать до 128 микроопераций. На процессорах с HT ROB также может выступать в роли координатора входных команд с виртуальных процессоров, распределяя два потока команд на одно OOO ядро.
Теперь микрооперации готовы для обработки и помещаются в резервацию (reservation station, RS). RS на данный момент может вмещать 36 микроопераций в любой момент времени.
Теперь настало время для магии OOO ядра. Микрооперации обрабатываются одновременно на множестве исполнительных блоков (execution unit), причем каждый блок работает максимально быстро. Микрооперации могут обрабатываться внеочерёдно, если все нужные данные для этого уже доступны. Если данные недоступны, выполнение откладывается до их готовности, пока выполняются другие готовые микрооперации. Таким образом долгие операции не блокируют быстрые и последствия ступора конвейера уже не так печальны.
OOO ядро Pentium Pro имело шесть исполнительных блоков: два для работы с целыми числами, один для чисел с плавающей точкой, загрузочный блок, блок сохранения адресов и блок сохранения данных. Два целочисленных блока были специализированы, один мог работать со сложными операциями, другой мог обрабатывать две простые операции за раз. В идеальных условиях исполнительные блоки Pentium Pro могли обрабатывать семь микроопераций за такт.
Сегодняшнее OOO ядро также содержит шесть исполнительных блоков. Оно до сих пор содержит блоки загрузки адреса, сохранения адреса и сохранения данных. Однако остальные три немного изменились. Каждый из трех блоков теперь может выполнять простые математические операции или более сложную микрооперацию. Каждый из трех блоков специализирован для конкретных микроопераций, позволяя выполнять работу быстрее, по сравнению с блоками общего назначения. В идеальных условиях нынешнее OOO ядро может обрабатывать 11 микроопераций за такт.
Наконец микрооперация начинает выполняться. Она проходит через более мелкие этапы (отличающиеся между процессорами) и проходит этап отставки. В этот момент микрооперация возвращается во внешний мир и IP начинает указывать на следующую инструкцию. С точки зрения программы, инструкция просто входит в процессор и выходит с другой стороны, точно так же, как это было со старым 8086.
Если вы внимательно читали статью, вы возможно могли заметить очень важную проблему в описании выше. Что произойдет в случае смены места исполнения? Например, что произойдет, если код доходит до if или switch конструкции? В более старых процессорах это значило сброс всей работы в суперскалярном конвейере и ожидание начала обработки новой ветки исполнения.
Ступор конвейера, когда в процессоре находится сотня или более инструкций очень серьезно сказывается на производительности. Каждая инструкция вынуждена ждать, пока инструкции с нового адреса будут загружены и конвейер будет перезапущен. В этой ситуации OOO ядро должно отменить всю текущую работу, откатиться до предыдущего состояния, подождать, пока все микрооперации пройдут отставку, отбросить их вместе с результатами и затем продолжить работу по новому адресу. Эта проблема была очень серьёзной и часто случалась при проектировании. Показатели производительности в такой ситуации были неприемлемы для инженеров. Именно здесь приходит на помощь еще одна важная особенность OOO ядра.
Их ответ был – упреждающее выполнение. Упреждающее выполнение означает, что когда OOO ядро встречает в коде условные конструкции (например if блок), оно просто загрузит и выполнит две ветки кода. Как только ядро понимает, какая ветка верная, результаты второй будут сброшены. Это предотвращает ступор конвейера ценой незначительных издержек на запуск кода в неверной ветке. Также был добавлен кэш для предсказания ветвления (branch prediction cache), который намного улучшил результаты в ситуациях, когда ядро было вынуждено прогнозировать среди множества условных переходов. Ступоры конвейера до сих пор встречаются из-за ветвления, однако это решение позволило сделать их редким исключением, нежели обычным явлением.
Ну и наконец, процессор с HT предоставляет два виртуальных процессора для одного общего OOO ядра. Они разделяют общий ROB и OOO ядро и будут видны для операционной системы как два отдельных процессора. Это выглядит примерно так:
*OOO ядро с Hyper-Threading, см. [примечание](http://habrahabr.ru/post/182002/#comment_6328302).*
Процессор с HT получает два виртуальных процессора, которые взамен поставляют больше данных OOO ядру, что дает увеличение производительности при обычном пользовании. Лишь некоторые тяжелые вычислительные нагрузки, оптимизированные под многопроцессорные системы, могут полностью загрузить OOO ядро. В этом случае HT может несколько понизить производительность. Однако такие нагрузки относительно редки. Для потребителя HT обычно позволяет увеличивать скорость работы примерно вдвое при обычном ежедневном пользовании компьютером.
#### Пример
Всё это может показаться немного запутанным. Надеюсь, пример расставит всё на свои места.
С точки зрения приложения, мы все ещё работаем на вычислительном конвейере старого 8086. Это чёрный ящик. Инструкция, на которую указывает IP, обрабатывается этим ящиком, и, когда инструкция выходит из него, результаты уже отображены в памяти.
Хотя с точки зрения инструкции, этот чёрный ящик то ещё приключение.
Ниже приводится путь, который совершает инструкция в современном процессоре (2008-2013).
Поехали, вы – инструкция в программе, и эта программа запускается.
Вы терпеливо ждете, пока IP начнет указывать на вас для последующей обработки. Когда IP указывает примерно за 4кб до вашего расположения, или за 1500 инструкций, вы перемещаетесь в кэш инструкций. Загрузка в кэш занимает некоторое время, но это не страшно, так как вы ещё нескоро будете запущены. Эта предзагрузка (prefetch) является частью первого этапа конвейера.
Тем временем IP указывает всё ближе и ближе к вам, и, когда он начинает указывать за 24 инструкции до вас, вы и пять соседних команд отправляетесь в очередь инструкций (instruction queue).
Этот процессор имеет четыре декодера, которые могут вмещать одну сложную команду и до трёх простых. Так случилось, что вы сложная инструкция и были декодированы в четыре микрооперации.
Декодирование – это многоуровневый процесс. Часть декодирования включает в себя анализ на предмет требуемых вами данных и вероятность перехода в какое-то новое место. Декодер зафиксировал потребность в дополнительных данных. Без вашего участия, где-то на другом конце компьютера, нужные вам данные начинают загрузку в кэш данных.
Ваши четыре микрооперации подходят к таблице псевдонимов регистров. Вы объявляете с какого адреса памяти вы читаете (это оказывается fs:[eax+18h]), и чип транслирует его во временный адрес для ваших микроопераций. Ваши микрооперации входят в ROB, откуда, при первой же возможности, двигаются в резервацию.
Резервация содержит инструкции, готовые к исполнению. Ваша третья микрооперация немедленно подхватывается пятым портом исполнения. Вам не известно, почему она была выбрана первой, но её уже нет. Через несколько тактов ваша первая микрооперация устремляется во второй порт, блок загрузки адресов. Оставшиеся микрооперации ждут, пока различные порты подхватывают другие микрооперации. Они ждут, пока второй порт загружает данные из кэша данных во временные слоты памяти.
Долго ждут…
Очень долго ждут…
Другие инструкции приходят и уходят, в то время как ваши микрооперации ждут своего друга, пока тот загружает нужные данные. Хорошо, что этот процессор знает как обрабатывать их внеочерёдно.
Внезапно, обе оставшиеся микрооперации подхватываются нулевым и первым портом, должно быть загрузка данных завершена. Все микрооперации запущены и со временем они вновь встречаются в резервации.
По пути обратно через ворота, микрооперации передают свои билеты с временными адресами. Микрооперации собираются и объединяются, и вы вновь, как инструкция, чувствуете себя единым целым. Процессор вручает вам ваш результат и вежливо направляет к выходу.
Через дверь с пометкой “Отставка” стоит короткая очередь. вы встаете в очередь и обнаруживаете, что вы стоите за той же инструкцией, за которой и заходили. Вы даже стоите в том же порядке. Получается, что OOO ядро действительно знает своё дело.
Со стороны выглядит так, что каждая выходящая из процессора команда выходит по одной, точно в таком же порядке, в каком IP указывал на них.
#### Заключение
Надеюсь, что эта маленькая лекция пролила немного света на то, что происходит внутри процессора. Как видите, здесь нет магии, дыма и зеркал.
Теперь мы можем ответить на вопросы, заданные в начале статьи.
Так что же происходит внутри процессора? Это сложный мир, где инструкции разбиваются на микрооперации, обрабатываются при первой же возможности и в любом порядке, и вновь собираются воедино, сохраняя свой порядок и расположение. Для внешнего мира выглядит так, будто они обрабатываются последовательно и независимо друг от друга. Но мы теперь знаем, что на самом деле, они обрабатываются внеочерёдно, иногда даже предсказывая и запуская вероятные ветки кода.
Сколько времени уходит на исполнение одной инструкции? Тогда как в бесконвейерном мире для этого имелся хороший ответ, в современном же процессоре всё зависит от того какие инструкции находятся рядом, какой размер соседних кэшей и что в них находится. Есть минимальное время прохождения команды через процессор, но эта величина практически постоянна. Хороший программист или оптимизирующий компилятор может заставить множество инструкций исполняться за среднее время близкое к нулю. Среднее время близкое к нулю – это не время исполнения самой медленной инструкции, а время, требуемое для прохождения инструкции через OOO ядро и время, требуемое кэшу для загрузки и выгрузки данных.
Что значит, когда новый процессор имеет 12, или 18, или даже 31-уровневый конвейер? Это значит, что больше инструкций за раз могут быть приглашены на вечеринку. Очень длинный конвейер может значить, что несколько сотен инструкций могут быть помечены как “обрабатываются” за раз. Когда все идет по плану, OOO ядро постоянно загружено и пропускная способность процессора просто впечатляет. К сожалению, это так же значит, что ступор конвейера перерастает из мелкой неприятности, как это было раньше, в кошмар, так как сотни команд будут вынуждены ожидать очистки конвейера.
Как вы можете применить эти знания в своих программах? Хорошие новости – процессор может предугадать большинство распространённых шаблонов кода, и компиляторы оптимизируют код для OOO ядра уже почти два десятилетия. Процессор лучше всего работает с упорядоченными инструкциями и данными. Всегда пишите простой код. Простой и не извилистый код поможет оптимизатору компилятора найти и ускорить результаты. Если возможно, не создавайте переходы по коду. Если вам необходимо совершать переходы, пытайтесь делать это, следуя определенному шаблону. Сложные дизайны, наподобие динамических таблиц переходов, выглядят классно и многое могут, но ни компилятор, ни процессор, не смогут спрогнозировать какой кусок кода будет выполняться в следующий момент времени. Поэтому сложный код с большой вероятностью будет провоцировать ступоры и неверные предсказания ветвления. Напротив, поддерживайте ваши данные простыми. Организуйте данные упорядоченно, связанно и последовательно для предотвращения ступоров. Правильный выбор структуры и разметки данных может заметно сказаться на повышении производительности. До тех пор, пока ваши данные и код остаются простыми, вы обычно можете положиться на работу оптимизирующего компилятора.
Спасибо, что были частью этого путешествия.
*Оригинал — [www.gamedev.net/page/resources/\_/technical/general-programming/a-journey-through-the-cpu-pipeline-r3115](http://www.gamedev.net/page/resources/_/technical/general-programming/a-journey-through-the-cpu-pipeline-r3115)* | https://habr.com/ru/post/182002/ | null | ru | null |
# Мы сократили время разработки нового сценария публикации объявления с 6 дней до 42 секунд
Всем привет! Меня зовут Артем Пескишев, я iOS-разработчик в Авито. Хочу рассказать, как мы завели управляемый с бэкенда сценарий публикации новых объявлений в наших мобильных приложениях.
Разберём, что такое пошаговые сценарии в приложениях и какие проблемы со сценарием размещения объявления были у нас. Статья — про разработанный нами инструмент для решения этих проблем и результаты его внедрения.
Backend-driven UI
-----------------
Backend-driven UI — это подход к проектированию интерфейсов, при котором в приложении есть набор компонентов, эдаких строительных блоков, с которыми приложение умеет работать, а расположение, порядок и наполнение этих блоков приходят с бэкенда.
Backend-driven UI решает проблему хардкода большого количества полей в формах на клиенте, а также связей между этими полями. Если вся логика вынесена на бэкенд, то клиент становится более гибким и расширяемым с бэкенда. Это значит, что не надо постоянно релизить новые версии приложений. Часть валидации полей также можно перенести на клиент и обновлять правила валидации с бэкенда. При хардкоде же приходится всегда лезть в сеть, чтобы проверить отдельные поля.
В статье я буду рассказывать про backend-driven сценарий приложения — это более широкий взгляд на backend-driven UI.
Пошаговый сценарий в приложениях
--------------------------------
Пошаговый сценарий — это порядок действий, которые пользователь должен совершить для получения необходимого результата. Классический пример — это настройка нового айфона. После включения телефона пользователь последовательно заполняет определённые параметры: страну, сеть Wi-Fi, место хранения данных и свой Apple ID. В итоге айфон полностью настроен.
Онбординг в приложении — тоже пошаговый сценарий. Например, перед тем как начать пользоваться MyFitnessPal, нужно заполнить несколько параметров. На их основе приложение генерирует норму калорий, которую нужно потреблять в день.
В приложениях Авито есть два основных сценарий размещения объявления. Первый характерен для категории «Авто». Пользователь выбирает основную категорию объявления и уточняет её. Например, он хочет продать автомобиль с пробегом. Далее заполняет все параметры, которые относятся к категории, после чего переходит на экран контактов, добавляет информацию о себе и нажимает кнопку «разместить объявление». После этих действий объявление попадает на сайт.
Второй сценарий характерен для подачи объявления в «Личные вещи». Пользователь выбирает эту категорию, фотографирует товар, указывает его название. На основе заполненных параметров Авито предсказывает, в какую подкатегорию разместить объявление. Далее пользователь заполняет описание и цену товара, переходит на экран контактов и нажимает «разместить объявление».
Проблемы со сценариями размещения объявления
--------------------------------------------
Оба основных сценария у нас были жёстко зашиты на клиенте. Для их изменения или расширения функциональности нам приходилось исправлять клиент и выпускать новую версию приложения. В итоге от идеи до того, как доработки попадут к пользователям, проходило много времени.
Например, пользователи часто ошибались в выборе подкатегории в услугах. Нам требовалось вынести название объявления на первый экран при размещении, чтобы подключить предсказание подкатегорий по названию. Вся функциональность уже была готова, нужно было просто добавить в сценарий два экрана и убрать одно поле. На это ушло восемь дней от момента, когда разработчик начал делать задачу до её закрытия QA-инженером. Это много.
Мы хотели улучшать сценарий размещения объявления, чтобы пользователи могли опубликовать максимально качественное объявление в максимально короткий срок. Чтобы понять, какой сценарий является оптимальным, нам требовалось проводить быстрые эксперименты. Мы хотели при необходимости быстро изменять набор параметров на экране и их порядок, а также менять экраны между собой местами. Чтобы это работало, мы сделали свой инструмент.
Новый инструмент для управления сценариями
------------------------------------------
Мы хотели, чтобы из админки приходил набор параметров, которые должны отображаться на форме, а также массив шагов, которые будут составлять сценарий размещения объявления. Бэкенд получал бы эти данные и обогащал их с помощью микросервисов. Он дополнительно подставлял бы определённые значения или убирал какие-то поля в зависимости от профиля пользователя. После чего массив обогащённых параметров и шагов попадал бы в приложение. Эта архитектура актуальна для iOS, Android, а также для Desktop и мобильной версии сайта Авито.
После того, как приложение получило данные о параметрах и шагах, оно могло бы выстроить стек шагов для перемещения пользователя. То есть создать сценарий публикации объявления.
Для реализации идеи нужно было:
1. Избавиться от захардкоженных параметров.
2. Сформировать типы шагов для публикации объявления.
3. Интегрировать шаги в сценарий размещения объявления
### Избавляемся от хардкода
Наша большая форма подачи объявления строилась из многих «кубиков». На клиенте поддерживались различные типы компонентов:
* Select для выбора значения из списка.
* Input для ввода значения с клавиатуры.
* Address для адреса.
* Photos для фотографий.
* Bool для параметров с бинарным значением.
Часть параметров мы получали с сервера. Это были уникальные для конкретных категорий параметры, например, год выпуска для объявлений с продажей автомобиля или этаж для квартиры. Другая часть параметров, которые были абсолютно во всех категориях объявлений, были захардкожены. Это название, описание, цена и фотографии.
Чтобы встроить их в систему «конструктора» формы подачи объявления, мы перенесли всю логику на бэкенд. После этого форма подачи объявления в рамках одного экрана стала строиться динамически.
### Формулируем типы шагов
Дальше было необходимо понять концепцию шагов в сценарии подачи объявления. Шаги — это новые блоки конструктора, из которых мы можем собирать различные сценарии размещения объявления.
Мы решили, что шаг — это не просто один экран, а некая часть сценария. Он может содержать в себе несколько экранов или не содержать экранов вообще. Шаг может включать заголовок, подзаголовок, определённый тип и набор параметров, которые отображаются на экране. Но также может быть шаг, во время которого мы отправляем запрос на сервер, например для валидации заполненных пользователем данных. Никакого специфического интерфейса пользователь при этом не видит — на экране просто вращается активити-индикатор.
Основной тип шагов — это шаг заполнения параметров. Он может выглядеть по-разному в зависимости от набора полей. Это могут быть просто три поля типа select. Или одно поле с добавлением фотографий с подзаголовком у экрана. Это может быть шаг выбора места встречи с покупателем, где под полем есть мотивирующий заполнить его текст. Но это всё один и тот же тип шага, просто его внешний вид зависит от набора параметров, которые он отображает.
Второй основной тип — это шаг выбора категории объявления. Он включает в себя несколько экранов, потому что пользователю необходимо дойти до конечной подкатегории.
Ещё один из сформулированных шагов — выбор значения. Иногда мы хотим, чтобы пользователь просто выбрал быстро одно значение из многих. И вместо того, чтобы заставлять его совершать лишние действия, мы превратили отдельный шаг в шаг выбора значения. В нём нужно сделать всего один клик.
Вот как это было устроено раньше. Представим, что пользователь публикует объявление опродаже недвижимости. Открывается экран с одной ячейкой параметра «Вид объекта», где значение не заполнено. Пользователь кликает на параметр, и открывается экран с вариантами. Пользователь выбирает один из них, возвращается на первый экран с ячейкой и нажимает кнопку «Продолжить».
Мы изменили шаг, и теперь на экране «Вид объекта» сразу показываются ячейки со значениями. Пользователь выбирает нужное и сразу переходит дальше. То есть нужно сделать один клик вместо трёх.
Следующий экран уникален для подачи объявления в категорию «Авто». Это шаг заполнения VIN, где пользователь может вбить VIN машины или отсканировать свидетельство о регистрации транспортного средства. По этим данным мы сами заполняем до 18 параметров автомобиля.
Также есть шаг подсказки подкатегории, где мы на основе заполненных пользователем данных, например, заголовка и описания, предсказываем, в какой подкатегории стоит разместить объявление. Так как некоторые пользователи сталкиваются с проблемами выбора категории из-за того, что их достаточно много, мы упрощаем им жизнь за счёт таких подсказок. Если предложенные варианты пользователю не нравятся, он всегда может выбрать подкатегорию самостоятельно.
После того как мы сформировали визуальные типы шагов, у нас остались вопросы:
* Когда валидировать на сервере параметры, которые ввёл пользователь?
* В какой момент мы должны загрузить дополнительные данные? Иногда мы не можем сразу прислать весь сценарий от первого до последнего шага, потому что он зависит от решений пользователя. Например, пока пользователь не выберет в какой подкатегории он размещает объявление — автомобили или мотоциклы, мы не знаем, какие шаги ему показать. Но после выбора мы можем сходить на сервер и получить дальнейшие шаги в сценарии публикации.
* В какой момент необходимо выполнить публикацию объявления? На последний шаг мы завязываться не можем, потому что последний шаг не обязательно является конечным. Иногда после него требуется загрузить дополнительные данные.
Чтобы решить эти вопросы, мы сформировали так называемые технические шаги. Во время выполнения технического шага пользователь не видит новые экраны, просто на текущем крутится активити-индикатор. В этот момент приложение отправляет запрос к серверу и ждёт ответа.
Технических шагов получилось три:
1. Pretend, во время которого мы отправляем все заполненные параметры пользователя на бэк, и бэк проверяет корректность их заполнения.
2. Дозагрузка дальнейших шагов. Мы также все заполненные параметры отправляем на бэкенд, и бэкенд возвращает оставшийся хвост сценария размещения объявления.
3. Публикация объявления. В этот момент публикуем объявление и закрываем сценарий.
После того, как мы сформировали типы шагов и сделали backend-driven UI в рамках каждого, оставалось интегрировать всё это в единую архитектуру.
### Интегрируем шаги в сценарий размещения объявления
В цепочке интеграции сценария размещения объявления три участника: админка, бэкенд и приложение или сайт.
Админка — это визуальный UI-интерфейс для проектирования сценариев. Любой специалист, который умеет с ней работать, может создать шаги сценария размещения объявления. Все созданные шаги превращаются в джисонку в виде массива. Каждый шаг индивидуально настраивается: в админке задаётся его заголовок, подзаголовок, параметры и тип.
```
"steps": [{
"id": 1133,
"title": "Выберите категорию",
"fields": [],
"type": "wizard"
}, {
"id": 1169,
"title": "Загрузка шагов",
"fields": [],
"type": "request",
"subtype": "steps",
}, {
"id": 1168,
"title": "Фотографии",
"fields": [499],
"type": "params"
}, {
"id": 1134,
"title": "VIN номер",
"fields": [838],
"type": "vin"
}, {
"id": 1163,
"title": "Технические данные",
"fields": [549, 498, ...],
"type": "params"
},
{...}]
```
После этого для каждого шага забиваются параметры. Они составляют отдельную джисонку с массивом всех параметров, которые участвуют в сценарии размещения объявления. В итоге админка возвращает собранную третью финальную джисонку из параметров и шагов, и передаёт новую структуру в бэкенд.
Бэкенд получает эту структуру и обогащает её, используя различные микросервисы. Например, в форме размещения объявления есть поле «Адрес», который пользователь должен указать. Но обычно мы знаем, где пользователь размещает свои объявления, и можем предзаполнить поле. Бэкенд идёт в микросервис пользователя, получает его стандартный адрес, и подставляет значение в поле "value" параметра адреса. После чего обогащённая структура попадает в клиенты — iOS, Android или сайт.
Расскажу про архитектуру нашего фреймворка.
Координирующий модуль DynamicPublish загружает первоначальные данные, инициирует открытие каждого шага, обрабатывает навигацию между экранами и закрытие сценария подачи, если пользователь решил прервать сценарий или подача завершена.
Первое, что делает координирующий модуль динамической подачи — загружает шаги. Он лезет в DataService, который получает данные с бэкенда, маппит их в объекты типа параметр-дата и стек-дата, и возвращает их. После чего модуль берёт первый шаг сценария и инициирует его открытие через обработчик этого шага.
Появляется новая сущность — StepHandler. Она открывает один из модулей, обрабатывает результат его выполнения и обновляет данные в стейте, который работает с данными сценария размещения объявления.
Для каждого типа шага существует отдельный StepHandler, который открывает тот или иной модуль. Например, есть шаг типа Wizard — он вызывает StepHandler, а тот инициирует модуль с выбором подкатегорий объявления. А тип шага Steps просто показывает активити-индикатор. Экран типа Select может открыть модуль выбора значения. И шаг Params показывает экран со списком параметров.
У каждого модуля несколько возможных результатов выполнения. Во-первых, пользователь может закрыть подачу и прервать сценарий размещения объявления. Он может уйти назад с текущего экрана и вернуться на предыдущий. Или после того, как заполнил все параметры, нажать кнопку «Продолжить» и перейти к следующему экрану.
Модуль возвращает результат выполнения в StepHandler. StepHandler обновляет данные в дата-холдере теми параметрами, которые пользователь заполнил в форме. И возвращает полученный результат в координирующий модуль.
Координирующий модуль может либо показать следующий шаг, если пользователь нажал «Продолжить», либо закрыть подачу или закончить её в зависимости от того, разместил ли пользователь объявление. Модуль также может обработать шаг назад, если пользователь нажал кнопку «Назад».
Суммируем. Модуль динамической подачи создаёт каждый раз новый StepHandler для каждого модуля. Пользователь совершает какие-то операции — выбирает категорию, заполняёт поля, и результат возвращается в координирующий модуль. Это продолжается доn тех пор, пока пользователь не дойдет до последнего шага — публикации объявления, либо не прервет сценарий публикации.
Результаты внедрения нового инструмента
---------------------------------------
Сравним ситуации до внедрения нового инструмента и после. Например, была задача разделить экран названия объявления и цены на два раздельных, чтобы пользователь сначала заполнял название, а потом выбрал цену. На это у нас уходило шесть дней. Из-за хардкода приходилось тратить кучу времени на переделку, хотя задача кажется достаточно простой.
С внедрением нового инструмента стало значительно проще. У нас есть форма подачи объявления в приложении и есть форма в админке. Мы редактируем первый шаг — удаляем цену, сохраняем, и добавляем отдельный шаг для цены товара. Вводим название нового шага, выбираем поле, которое должно на нём отображаться, конфигурируем шаг, выставив ему корректный тип, и сохраняем. После чего перезагружаем форму и получаем новый сценарий. Обновлять приложение нет необходимости.
В итоге нужно потратить всего 42 секунды на то, чтобы внести изменения в сценарий размещения объявления. По сравнению с шестью днями это фантастика.
Плюс — работать с админкой может любой. Сейчас конфигурацией всех шагов занимаются не инженеры, а продакты. Это люди, которые наиболее заинтересованы в проведении быстрых экспериментов, чтобы найти оптимальный сценарий размещения объявления.
Бизнес получил возможность проводить быстрые эксперименты с настройкой сценария подачи объявления без обновления версий приложений. Можно запускать множество А/В-тестов параллельно и получать оперативную обратную связь от пользователей.
Пользователи получили удобный интерфейс публикации объявления. Эксперименты позволяют нам понять, какие сценарии наиболее оптимальны и удобны по скорости подачи и качеству размещения объявления.
Разработчики получили гибкую и легко расширяемую систему для внесения изменений. Теперь не нужно тратить время на перемещение шагов между собой внутри приложения и изменение порядка полей. Всё, что должны делать разработчики — это расширять существующую систему. Например, добавлять новые типы шагов, если это необходимо, или поддерживать новые типы полей.
На разработку инструмента ушло полгода. Мы не сразу строили космолёт, а делали его кусочками. Сначала поддержали все шаги для подачи объявлений по продаже транспорта — это заняло два месяца работы команды из трёх человек. Когда мы поняли, что MVP работает, начали расширять его на остальные категории. Сейчас сценарии во всех категориях объявлений конфигурируются через админку, баги исправлены, и всё работает. | https://habr.com/ru/post/501698/ | null | ru | null |
# Практический пример использования Backbone
В данной заметке речь пойдет об использовании Backbone, а в частности, примеры кода работающего с сервером. Это должен быть некий промежуточный пункт в блужданиях Ищущего, так как иначе начать им пользоваться очень сложно, а вероятность отказаться от идеи перехода стремится к единице.
Зачем вообще нужна данная публикация? Тут уже были статьи по теме, но они затрагивают лишь очень поверхностно то, о чем и так написано в документации, хотя следовало бы показать пути недокументированные. Именно так: backbone это не комплексная standalone библиотека вроде Jquery, которую и не тронешь, не сломав. Данная библиотека предназначена лишь для построения приблизительной структуры; мы же можем лепить из данного материала то, что нам нужно. Еще раз: тут нет смысла искать готовые паттерны, буква в букву примеры не нужно перепечатывать, все равно не поможет. Нужно научиться пользоваться инструментом, после чего уже бросаться в бой.
Итак, вы перешагнули рубеж хабраката. Я не ставлю своей целью объяснение базовых принципов библиотеки, статей было уже предостаточно:
[habrahabr.ru/blogs/javascript/129928](http://habrahabr.ru/blogs/javascript/129928/)
[habrahabr.ru/blogs/javascript/118782](http://habrahabr.ru/blogs/javascript/118782/)
[habrahabr.ru/blogs/webdev/123130](http://habrahabr.ru/blogs/webdev/123130/)
Замечу, что все три описывают стандартное использование Backbone, но очень редко действительно нужно, например, использовать роутер. Или же нужно банально связаться с сервером — а как это сделать? Все отсылают к Backbone.sync, а примеров почему-то никто не предоставляет. Считайте предыдущее предложение одной из основных причин написания данной заметки. Если вы с ним не согласны — дальше можно не читать.
Начнем. Писать мы будем фронтенд редактирования заметок. Сфокусируемся на сриптах, нагло игнорируя как эстетические пожелания пользователей, так и право выбора: тестировать я буду только в хроме. Ссылки на пример и код в архиве приведу в конце.
Что нам нужно, чтобы начать? Создаем пустую xhtml страничку со стандартной структурой, подключаем jquery, underscore, backbone (именно в таком порядке). В конце добавляем ссылку на наш скрипт. Со стороны сервера создаем php файл, который будет отвечать за чтение/запись данных (лежит в архиве, app.php, код приводить не буду, скрипт просто обрабатывает запросы вида ?method=).
Когда приготовления закончены, начнем писать скрипт на js. Создадим контейнер для хранения моделей и лога:
```
app = {
debug: true,
log: function(obj) {
if(this.debug) {
console.log(obj);
}
},
models: {}
}
```
Функция Backbone.sync спроектирована так, что ее очень легко переобъявить, ничего не испортив. Кроме того, у кажой модели может быть свой метод синхронизации (угадайте, как он должен называться?). Мы будем писать глобальную функцию для всего нашего срипта. Цели, преследуемые нами:
* Заставить Backbone работать с нашим бекэндом
* При получении данных фронтеном аукать в лог для проверок
* Проверять данные с сервера на флаг ошибки (is\_error — устанафливается нашим скриптом)
* Упростить добавление/сохранение (сливаем методы в один)
* Производить проверку входных данных
* Прерывать старый запрос при новом (только для пары модель/метод)
Что получилось у меня (ваша реализация может отличаться):
```
Backbone.sync = function(method, model, options) {
// Сливаем методы дубовым способом
var method = (method=='update'||method=='create')?'save':method;
// Прерываем старый запрос
if(model.loading && model.loading.method == method) {
model.loading.xhr.abort();
}
app.log('Запрос на "'+model.url(method)+'"');
var xhr = $.ajax({
type: 'POST',
url: model.url(method),
data: (model instanceof Backbone.Model)?model.toJSON():{},
success: function(ret) {
// Проверка наличия ошибки
if(ret.is_error) {
app.log('Ошибка запроса');
} else {
app.log('Запрос завершен');
(function(data){
app.log('Backbone.sync получил данные:', data);
if(data.res) {
// Ответ - строка, вместо записей
model.trigger('load:res', data.res);
} else {
// Ответ - записи, либо данные
options.success(data.rows?data.rows:data);
}
model.trigger((method=='save')?'save':'load', data);
})(ret.data);
}
},
error: function (req_obj, msg, error) {
app.log('Ошибка запроса');
},
dataType: 'json'
});
// Сохраняем ссылку на запрос в модель
model.loading = {
method: method,
xhr: xhr
}
};
```
Я немного слукавил. Если вызвать у модели методы так: read list read, то последний read не оборвет первый, но статья не об этом, так что кладем огромный болт.
Код модели записи:
```
app.models.note = (Backbone.Model.extend({
defaults: {
id: 0,
text: ''
},
url: function(method){
return './app.php?method='+method;
}
}));
app.models.Note = (Backbone.View.extend({
tagName: 'li',
className: 'entity',
render: function(){
var data = this.model.toJSON();
var that = this;
$(this.el).html('').data('rowId', data.id);
$(this.el).append($('').val(data.text));
$(this.el).append($('Сохранить').click(function(){
app.models.page.trigger('post:save', {
'id': $(this).closest('li').data('rowId'),
'text': $(this).closest('li').find('input').val()
});
}));
$(this.el).append($('Удалить').click(function(){
if(!confirm('Вы уверены, что хотите удалить эту запись?')) return;
app.models.notes.get($(this).closest('li').data('rowId')).destroy();
}));
return this;
}
}));
```
Список записей:
```
app.models.notes = new (Backbone.Collection.extend({
model: app.models.note,
initialize: function(){
this.bind('destroy', function(){
this.reload();
}, this);
},
reload: function(){
var that = this;
var options = ({
error:function(){
app.log('Ошибка обновления записей!');
that.trigger('change');
},
success: function(){
app.log('Записи обновлены');
that.trigger('change');
}
});
app.log('Обновление записей...');
this.fetch(options);
},
url: function(method){
return './app.php?method=list';
}
}));
```
И последнее, модель страницы:
```
app.models.page = new (Backbone.View.extend({
el: null,
el_list: null,
notes: null,
initialize: function(){
this.bind('page:load', this.pageLoad, this);
this.bind('list:reload', this.listReload, this);
this.bind('post:save', this.postSave, this);
this.notes = app.models.notes;
this.notes.bind('change', this.onListChange, this);
this.notes.bind('load:res', this.onListChange, this);
return this;
},
pageLoad: function(data) {
var that = this;
this.el = $('.layout');
this.el_list = this.el.find('.items-list');
// Кнопка обновления
this.el.find('.title .refresh').bind('click', function(){
that.trigger('list:reload')
});
// Кнопка добавления
this.el.find('.items-add-submit').bind('click', function(){
that.trigger('post:save', {
id: false,
text: $('.items-add-text').val()
});
});
this.trigger('list:reload');
},
render: function(ret){
$(this.el_list).html('');
if(!ret) {
app.log('Вывод записей. Количество: '+this.notes.length);
_(this.notes.models).each(function(item){
this.appendItem(item);
}, this);
} else {
app.log('Вывод записей. Результат: "'+ret+'"');
$(this.el_list).html('').append($('-
').text(ret));
}
return this;
},
appendItem: function(item) {
var view = new app.models.Note({
model: item
});
$(this.el_list).append(view.render().el);
},
onListChange: function(ret){
this.render(ret);
},
postSave: function(obj){
var model = new app.models.note();
if(obj.id) {
model.set({
id:obj.id
});
}
model.set({
text:obj.text
});
model.save();
this.trigger('list:reload');
},
listReload: function(){
this.notes.reload();
}
}));
```
Что-то забыли… Ах да, запускаем рендеринг:
```
$(document).ready(function(){
app.models.page.trigger('page:load');
});
```
Как видите, все просто. Я намеренно приводил код кусками, вместо разжевывания каждой функции, т.к. статья ориентированна на человека хоть немного знакомого с js/backbone. Если это не про вас — выше я давал ссылки, там подробно все расписано. Если возникнут сложности в понимании или нужны ополнительные пояснения к коду — пишите.
Код в действии: [yurov.me/art](http://yurov.me/art)
Весь код в архиве: [yurov.me/art/art.tar.gz](http://yurov.me/art/art.tar.gz)
P.s. код на сервере дубовый, возможны глюки. Важно показать фронтенд. Если не будет работать — можете попробовать запустить у себя локально либо просто просмотреть архив
P.P.S. Товарищ [oWeRQ](http://habrahabr.ru/users/owerq/) привел код в порядок, позже обновлю статью (его код значительно чище):
[owerq.dyndns.org/test/art](http://owerq.dyndns.org/test/art/) | https://habr.com/ru/post/132728/ | null | ru | null |
# Python, исследование данных и выборы: часть 5
Заключительный пост №5 **для** **начинающих** посвящен сопоставительной визуализации электоральных данных. Предыдущий пост см. [здесь](https://habr.com/ru/post/556044/).
Сопоставительная визуализация электоральных данных
--------------------------------------------------
Теперь рассмотрим набор данных других всеобщих выборов, на этот раз Российских, проходивших в 2011 г. Россия — гораздо более крупная страна, и поэтому данные о проголосовавших на выборах там гораздо объемнее. Для этого мы загрузим в оперативную память один большой TSV-файл с разделением полей данных символом табуляции.
```
def load_ru():
'''Загрузить данные по России'''
return pd.read_csv('data/ch01/Russia2011.tsv', '\t')
```
Посмотрим, какие имена столбцов имеются в российских данных:
```
def ex_1_29():
'''Показать список полей электоральных
данных по России'''
return load_ru().columns
```
Будет выведен следующий список столбцов:
```
Index(['Код ОИК', 'ОИК №', 'Имя участка',
'Число избирателей, внесенных в список избирателей',
...
'Политическая партия СПРАВЕДЛИВАЯ РОССИЯ',
'Политическая партия ЛДПР - Либерально-демократическая партия России',
'Политическая партия "ПАТРИОТЫ РОССИИ"',
'Политическая партия КОММУНИСТИЧЕСКАЯ ПАРТИЯ КОММУНИСТЫ РОССИИ',
'Политическая партия "Российская объединенная демократическая партия "ЯБЛОКО"',
'Политическая партия "ЕДИНАЯ РОССИЯ"',
'Всероссийская политическая партия "ПАРТИЯ РОСТА"'],
dtype='object')
```
Имена столбцов в российском наборе данных очень описательны, но, пожалуй, длиннее, чем нужно. Также, было бы удобно, если столбцы, представляющие те же самые атрибуты, которые мы уже видели в данных по выборам в Великобритании (к примеру, доля победителя и явка на выборы) были промаркированы одинаковым образом в обоих наборах данных. Переименуем их надлежащим образом.
Наряду с набором данных функция библиотеки pandas `rename` ожидает словарь, в котором ключам с текущими именами столбцов поставлены в соответствие значения с новыми именами. Если объединить это с данными, которые мы уже рассматривали, то мы получим следующее:
```
def load_ru_victors():
'''Загрузить данные по России,
выбрать, переименовать и вычислить поля'''
new_cols_dict = {
'Число избирателей, внесенных в список избирателей':'Электорат',
'Число действительных избирательных бюллетеней':
'Действительные бюллетени',
'Политическая партия "ЕДИНАЯ РОССИЯ"':'Победитель'
}
newcols = list(new_cols_dict.values())
df = load_ru().rename( columns=new_cols_dict )[newcols]
df['Доля победителя'] = df['Победитель'] / df['Действительные бюллетени']
df['Явка'] = df['Действительные бюллетени'] / df['Электорат']
return df
```
Библиотека pandas располагает функцией безопасного деления `divide`, которая идентична операции `/`, но защищает от деления на ноль. Она вместо пропущенного значения (`nan`) в одном из полей подставляет значение, передаваемое в именованном аргументе `fill_value`. Если же оба значения поля равны `nan`, то результат будет отсутствовать. Поэтому операцию деления можно было бы переписать следующим образом:
```
df[ 'Доля победителя' ] = \
df[ 'Победитель' ].divide( df[ 'Действительные бюллетени' ], \
fill_value=1 )
```
Визуализация электоральных данных РФ
------------------------------------
Мы ранее видели, что гистограмма явки на выборы в Великобритании была приближенно нормально распределенной (хотя и с легкими хвостами). Теперь, когда мы загрузили и преобразовали данные о выборах в России, посмотрим, насколько они сопоставимы:
```
def ex_1_30():
'''Показать гистограмму
электоральных данных по России'''
load_ru_victors()['Явка'].hist(bins=20)
plt.xlabel('Явка в России')
plt.ylabel('Частота')
plt.show()
```
Приведенный выше пример сгенерирует следующую гистограмму:
Эта гистограмма совсем не похожа на классические колоколообразные кривые, которые мы видели до сих пор. Имеется явно выраженная положительная асимметрия, и явка избирателей в действительности увеличивается с 80% в сторону 100% — совсем не то, что мы ожидали бы от нормально распределенных данных.
Учитывая ожидания, заданные данными из Британии и центральной предельной теоремой (ЦПТ), такой результат любопытен. Для начала покажем данные на квантильном графике:
```
def ex_1_31():
'''Показать квантильный график
победителя на выборах в РФ'''
qqplot( load_ru_victors()['Доля победителя'].dropna() )
plt.show()
```
Этот пример вернет следующий график:
На квантильном графике показана линия, которая не является ни прямой, ни одной из S-образных кривых. По существу, квантильный график говорит о наличии легкого хвоста в верхнем конце распределения и тяжелого хвоста в нижнем. Это почти противоположно тому, что мы видим на гистограмме, которая четко указывает на крайне тяжелый правый хвост.
На самом деле, этот квантильный график дезориентирует, и происходит этот именно потому, что хвост очень тяжелый: плотность точек между 0.5 и 1.0 на гистограмме говорит о том, что пик должен составлять порядка 0.7 с последующим правым хвостом за пределами 1.0. Наличие значения, превышающего 100% явно выходит за рамки логики, но квантильный график не объясняет это (он не учитывает, что речь идет о процентах), так что внезапное отсутствие данных за пределами 1.0 интерпретируется как подрезанный правый хвост.
С учетом центральной предельной теоремы и того, что мы наблюдали в данных выборов в Великобритании, тенденция к 100% явке избирателей на выборы выглядит очень любопытно. Давайте выполним параллельный сопоставительный анализ наборов данных по Великобритании и России.
Сравнительная визуализация
--------------------------
Предположим, мы хотели бы сравнить распределение электоральных данных между Великобританией и Россией. Мы уже видели в этой серии постов, как использовать ИФР и коробчатые диаграммы, поэтому теперь займемся исследованием альтернативного варианта, который аналогичен гистограмме.
Мы могли бы попытаться изобразить оба набора данных на гистограмме, но это будет безуспешной затеей, поскольку результаты не поддаются интерпретации по двум следующим причинам:
* Размеры избирательных округов, и, следовательно, средних значений распределений сильно отличаются
* Абсолютные количества избирательных округов настолько отличаются, что столбцы гистограмм будут иметь разную высоту
Вместо гистограммы альтернативным вариантом, позволяющим решить обе эти задачи, является *функция массы вероятности*.
Функции массы вероятности
-------------------------
Функция массы вероятности (ФМВ), от англ. Probability Mass Function (PMF), чаще именуемая функцией вероятности дискретной случайной величины, имеет много общего с гистограммой. Однако, вместо того, чтобы показывать количества значений, попадающих в частотные корзины, она показывает вероятность, что взятое из распределения число будет в точности равно заданному значению. Поскольку функция закрепляет вероятность за каждым значением, которое может быть возвращено распределением, и поскольку вероятности измеряются по шкале от 0 до 1, (где 1 соответствует полной определенности), то площадь под функцией массы вероятности равна 1.
Таким образом функция массы вероятности обеспечивает, чтобы площадь под нашими графиками была сопоставимой между наборами данных. Однако у нас все еще имеется одно затруднение — несопоставимость размеров избирательных округов, а значит и средних значений распределений. Это затруднение решается отдельно — при помощи нормализации (или шкалирования).
Существует неисчислимое количество способов нормализации данных, однако один из самых базовых обеспечивает, чтобы каждый числовой ряд находился в интервале от 0 до 1. Ни одно наше значение не находится в отрицательном интервале, поэтому мы можем выполнить нормализацию, попросту разделив каждое индивидуальное значение на самое большое:
```
def plot_as_pmf(dt, label, ax):
'''График функции вероятности дискретной случайной величины
(или функции массы вероятности)'''
s = pd.cut(dt, bins=40, labels=False) # разбить на 40 корзин
pmf = s.value_counts().sort_index() / len(s) # подсчитать кво в корзинах
newax = pmf.plot(label=label, grid=True, ax=ax)
return newax
```
Имея в распоряжении приведенную выше функцию, мы теперь можем нормализовать данные по Великобритании и России и изобразить их рядом на тех же осях:
```
def ex_1_32():
'''Сопоставление данных явки по Великобритании и РФ,
данные нормализованы на основе функции массы вероятностей'''
ax = plot_as_pmf(load_uk_victors()['Явка'], 'Великобритания', None)
plot_as_pmf(load_ru_victors()['Явка'], 'Россия', ax)
plt.xlabel('Интервальные группы явки') # Частотные корзины
plt.ylabel('Вероятность')
plt.legend(loc='best')
plt.show()
```
Приведенный выше пример сгенерирует следующий график:
После нормализации эти два распределения вполне готовы для проведения сопоставительного анализа. Теперь становится совершенно очевидным, каким образом — несмотря на более низкую среднюю явку, чем в Великобритании (0.6366 против 0.6523) — на российских выборах произошел массивный подъем явки близкий к 100%. Поскольку *результаты голосования представляют собой* ***объединенный эффект многих независимых волеизъявлений***, *они ожидаемо будут соответствовать центральной предельной теореме и будут приближенно нормально распределенными*. В сущности, за редким исключением, как в Канаде, например, где население имеет гетерогенный характер (там французскоговорящая и англоговорящая группы населения в результате дают бимодальную кривую), результаты выборов по всему миру такому ожиданию обычно соответствуют.
Данные российских выборов показывают чрезвычайно аномальный результат, хотя и не настолько высокий, как модальный пик в центре распределения, который приблизительно соответствует 50% явке. Исследователь [Питер Климек](http://www.complex-systems.meduniwien.ac.at/elections/election.html) (Peter Klimek) и его коллеги в Венском медицинском университете пошли дальше и предположили, что этот результат является явным признаком подтасовки результатов голосования.
Диаграммы рассеяния
-------------------
Мы обнаружили любопытные результаты, связанные с явкой на российских выборах и установили, что они имеют сигнатуру, отличающуюся от британских выборов. Теперь посмотрим, каким образом доля голосов за побеждающего кандидата связана с явкой. В конце концов, если неожиданно высокая явка действительно является признаком нечестной игры в пользу действующего президента и правительства, то можно ожидать, что они будут голосовать за себя, а не за кого-либо еще. Таким образом, большинство, если не все, из этих дополнительных голосов ожидаемо будут отданы за итоговых победителей выборов.
Раздел статистики посвященный корреляции довольно подробно рассматривает величины, лежащие в основе взаимосвязи двух переменных, однако на данный момент было бы интересно попросту визуализировать связь между явкой и долей голосов за побеждающую партию.
Заключительный технический прием визуализации, с которым мы познакомим в этом посте, представлен диаграммой рассеяния. *Диаграммы рассеяния* очень хорошо подходят для визуализации взаимосвязей между двумя переменными: там, где существует линейная взаимосвязь, на графике она будет видна, как диагональная направленность. Библиотека pandas содержит для этого вида графиков функцию `scatter` с такими же аргументами, что и для функции двумерных графиков `plot`.
```
def ex_1_33():
'''Показать диаграмму рассеяния
выборов в Великобритании'''
df = load_uk_victors()[ ['Явка', 'Доля победителей'] ]
df.plot.scatter(0, 1, s=3)
plt.xlabel('Явка')
plt.ylabel('Доля победителя')
plt.show()
```
Приведенный выше пример сгенерирует следующую ниже диаграмму:
Хотя точки широко разбросаны в виде нечеткого эллипса, четко видна общая диагональная направленность к верхнему правому углу графика рассеяния. Она указывает на интересный результат — явка на выборы коррелирует с долей голосов, отданных за окончательных победителей на выборах, в то время, как ожидалось получить обратный результат: наличия так называемого самодовольства избирателей, которое приводит к более низкой явке в случае, когда победитель гонки очевиден.
Как отмечалось ранее, британские выборы 2010 г. были далеко необычными: они привели к «подвисшему» парламенту и коалиционному правительству. Фактически, «победители» в данном случае представлены обеими сторонами, которые были противниками, вплоть до дня выборов. И поэтому голосование за любую из партий считается как голосование за победителя.
Затем, мы создадим такую же диаграмму рассеяния для выборов в России:
```
def ex_1_34():
'''Показать диаграмму рассеяния выборов в РФ'''
df = load_ru_victors()[ ['Явка', 'Доля победителя'] ]
df.plot.scatter(0, 1, s=3)
plt.xlabel('Явка')
plt.ylabel('Доля победителя')
plt.show()
```
Этот пример сгенерирует следующую диаграмму:
Хотя из расположения точек в данных по России четко прослеживается диагональная направленность, сплошной объем данных затеняет внутреннюю структуру. В последнем разделе этого поста мы покажем простой метод, который позволяет с помощью настройки прозрачности графического изображения вычленять структуру из графиков, подобных этому.
Настройка прозрачности рассеяния
--------------------------------
В ситуациях, аналогичных приведенной выше, когда диаграмма рассеяния переполнена точками, можно улучшить визуализацию внутренней структуры данных путем настройки уровня прозрачности. Поскольку наложение полупрозрачных точек будет менее прозрачным, а области с меньшим количеством точек будут более прозрачными, то диаграмма рассеяния с полупрозрачными точками может изобразить плотность данных намного лучше, чем сплошные точки.
Выполнить настройку альфа-канала, регулирующего прозрачность изображаемых на графике pandas точек можно при помощи именованного аргумента `alpha` в функции scatter в виде числа между 0 и 1, где 1 означает полную непрозрачность, 0 — полную прозрачность.
```
def ex_1_35():
'''Показать диаграмму рассеяния (с прозрачностью) выборов в РФ'''
df = load_ru_victors()[ ['Явка', 'Доля победителя'] ]
rows = sp.random.choice(df.index.values, 10000)
df.loc[rows].plot.scatter(0, 1, s=3, alpha=0.1)
plt.xlabel('Явка')
plt.ylabel('Доля победителя')
plt.axis([0, 1.05, 0, 1.05])
plt.show()
```
Приведенный выше пример сгенерирует следующую диаграмму:
Приведенная выше диаграмма рассеяния показывает общую направленность совместного изменения доли победителя и явки на выборы. Мы видим корреляцию между двумя значениями и «горячую точку» в правом верхнем углу графика, которая соответствует явке близкой к 100% и 100%-ому голосованию в пользу побеждающей стороны. Как раз эта особенность в частности является признаком того, что исследователи из Венского медицинского университета обозначили как *сигнатура фальсификации выборов*. Этот факт также подтверждается результатами других спорных выборов по всему миру, например, таких как президентские выборы 2011 г. в Уганде.
Результаты многих других выборов по всему миру на уровне округов доступны [здесь](http://www.complex-systems.meduniwien.ac.at/elections/election.html). На указанном веб-сайте можно получить ссылку на научно-исследовательскую работу и скачать другие наборы данных, на которых можно попрактиковать то, что вы узнали в этой серии постов об очистке и преобразовании реальных данных.
Примеры исходного кода для этого поста находятся в моем [репо](https://github.com/capissimo/python-for-data-science) на Github. Все исходные данные взяты в [репозитории](https://github.com/clojuredatascience/ch1-statistics) автора книги.
Выводы
------
Эта серия постов была посвящена сводным статистическим величинам и значениям статистических распределений. Мы увидели, каким образом даже простой анализ может предъявлять свидетельства о потенциальной *фальсификационной* активности.
В частности, мы познакомились с центральной предельной теоремой и причиной, почему она играет такую важную роль в объяснении широкого применения нормального распределения в исследовании данных. Подходящее статистическое распределение способно всего в нескольких статистиках выразить сущность большой последовательности чисел, некоторые из которых были имплементированы тут на основе встроенных функций языка Python и функций библиотеки scipy. Кроме того, были показаны возможности библиотеки pandas, которая была задействована для загрузки, преобразования и визуального сопоставления нескольких наборов данных. В ходе анализа было обнаружено любопытное расхождение между двумя статистическими распределениями.
Внизу поста можно *проголосовать* за или против размещения следующей серии постов. Их тема - инференциальная статистика, которая позволяет давать количественную оценку измеренному расхождению между двумя или несколькими статистическими распределениями и принимать решение о статистической значимости этого расхождения. Указанная серия постов также посвящена методам проверки статистических гипотез, которые лежат в основе проведения робастных статистических экспериментов, позволяющих делать выводы на основе имеющихся данных. | https://habr.com/ru/post/556048/ | null | ru | null |
# Простые числа — насколько велико наше бессилие?
Представьте, что вас окружает бесконечно высокая стена, а о том, что находится за стеной абсолютно ничего неизвестно. Теперь представьте, что олицетворением данной стены является вот это уравнение:
Эту метафору будет проще понять, если провести аналогию с черной дырой: мы не знаем, что находится под ее горизонтом событий, и чтобы это узнать нам нужно придумать способ, как туда добраться. Нечто подобное существует в мире математики. Данное уравнение — это настоящая «формула» простого числа, но чтобы ею пользоваться, нам нужно придумать, как искать подходящие *{a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, w, v, x, y, z}*.
Черная дыра и данное уравнение — это предельные состояния чего-то реального и абстрактного. И, если о первом существует достаточно догадок и представлений, то о втором, практически ничего не известно. Но, что если это действительно «математическая» черная дыра? Разве вам не интересно что может произойти, если мы попадем под горизонт?
### Из чего состоит стена?
Числа — их нет в реальном мире. Бывает семь игральных костей, семь атомов, семь смертных грехов, но самой по себе семерки не существует — это абстракция. Да, мы бы могли сказать, что числа — это просто множество абстрактных объектов, однако, это целый мир. Мир, в котором, как и в мире реальном, существуют свои законы. Сама мысль об этом кажется очень странной. Тем не менее, существование такого раздела математики, как теория чисел, говорит о том, что эта «странность» очень важна для нас.
Самым волнительным является то, что среди этих воображаемых объектов есть особенные — простые числа. Они как детерминированный хаос — предсказуемы и непредсказуемы одновременно, в зависимости от масштаба их рассмотрения. Например, находясь рядом с ними, мы можем заметить, что их количество перед некоторым произвольным числом n, не превзойдет:
Меняя масштаб, мы начинаем замечать очень много намеков на какие-то внутренние правила их поведения. Постепенно этих намеков становится слишком много. Все чаще и чаще звучат вопросы «Откуда они вообще могли взяться?», «А что если существует некий алгоритм получения простых чисел?», «А что если каждое простое число может быть получено с помощью одного и того же алгоритма?»
### Как появилась стена
Если некоторая последовательность чисел получается в результате работы некоторого алгоритма, то множество чисел данной последовательности считается перечислимым, даже, несмотря на то, что оно может быть бесконечно большим. Перечислимые множества обладают одним замечательным свойством — диофантовостью. Это значит, что любое такое множество может быть представлено диофантовым уравнением — полиномом с целыми положительными коэффициентами и степенями.
Следующее заявление может показаться абсолютно неправдоподобным, но, исходя из такого определения, мы можем утверждать, что все ключи безопасности и значения хеш-функций (даже биткоины) могут быть выражены через диофантовы уравнения. т.е. уравнения, которые решаются в целых числах. И да, теоретически, кто-то может узнавать любые секреты, быть бесконечно богатым и влиятельным человеком. Но, для того, чтобы стать таким человеком, эти уравнения надо сначала вывести, а потом решить.
С задачей представления множества диофантовым уравнением, частично или полностью, может справиться компьютер. Но здесь появляется другая проблема — диофантовы уравнения не решаются в общем виде, т.е. какой-то единый алгоритм их решения отсутствует. Это не кажется большой проблемой, потому что мы знаем, что некоторые уравнения выделяются в отдельные виды, для решения которых уже найдены эффективные методы.
Но даже несмотря на наличие этих методов, мы неизбежно сталкиваемся с вычислительными трудностями, которые связаны либо с точностью вычислений, либо со скоростью выполнения итераций.
Как же так получилось, что простые числа оказались перечислимы? Сам процесс создания уравнений, представляющих перечислимые множества, опирается на основания математики — арифметику и логику. И если мы имеем достаточно знаний о свойствах объектов некоторого множества, то, опираясь на эти знания, мы можем делать предположения об алгоритме, который позволяет их получать. И, как оказалось, знаний о свойствах простых чисел было накоплено достаточно для этой цели. Уравнение было получено, и теперь все вопросы, связанные с простыми числами, сводятся к нему одному.
Но мы не можем его решить.
### Толщина и прочность стены
Фактически, нам брошен вызов. И нам заранее известно о неизбежном поражении. Возможно, отступление было бы самым благоразумным решением. Но разве нам не нужны эти поражения, чтобы превзойти себя? Давайте хоть чуть-чуть попытаемся его решить.
Взглянем на уравнение еще раз:
Это полином, множество положительных значений которого совпадает с множеством простых чисел. Он состоит из двух сомножителей: левый множитель будет простым числом лишь тогда, когда правый множитель, обозначенный фигурными скобками, будет равен единице, а это, в свою очередь, возможно, только если каждое слагаемое в данном множителе, обозначенное квадратными скобками, будет равно нулю. Получается, что вопрос о решении данного уравнения сводится к решению системы следующих уравнений:
Если решить эту систему уравнений и прибавить 2 к найденному значению *k*, то мы получим простое число. Но мы можем пойти и другим путем. Взять некоторое простое число, вычесть из него 2, получив таким образом значение *k*, затем подставить это значение в систему и попытаться найти значения остальных переменных относительно него. Именно этим путем мы и пойдем — попытаемся найти хоть одно решение данного полинома.
На все переменные накладывается два строгих ограничения, они должны быть целыми и не могут быть отрицательными. Если мы примем *k=0*, то первое простое число, которое мы сможем получить — это 2. Это и будет нашей отправной точкой. После подстановки этого значения в систему уравнений она примет следующий вид:
Уравнения (1)-(5) — это линейные уравнения, т.е. степени всех переменных равны 1. Уравнения (6)-(11) имеют очень схожую структуру. Ну и, наконец, уравнения (12)-(14) тоже выделяются в отдельную группу, причем уравнения (13) и (14) похожи друг на друга, как две капли воды.
Мы можем избавляться от переменных, или понижать степень, но до нас этим уже занимались. Уменьшение количества переменных приводит к сильному росту степеней других переменных, а уменьшение степеней переменных возможно только через увеличение их количества. Так что попробуем решить эту систему именно в таком виде.
Уравнения (6)-(11) являются модификациями уравнения Пелля:
В самом деле, если переписать их вот так:
то сходство становится очевидным. Это очень обнадеживающе, так как решать уравнения Пелля мы умеем довольно неплохо. Мы можем попробовать решать эту систему примерно так: сначала решаем какое-нибудь одно уравнение, его решения подставляем в другое, которое тоже решаем и так далее, до самого конца. Звучит довольно просто, но не мешало бы нарисовать что-то вроде графа подстановок, чтобы хоть примерно знать, в каком порядке решать уравнения:
Вроде, все просто.
### Удар по стене
Мы начнем с уравнений Пелля. Для их решения напишем небольшой скрипт:
```
from decimal import *
getcontext().prec = 50
def peq_dec(N):
n = Decimal(N).sqrt()
a = int(n)
x = n - a
p0, q0 = 1, 0
p1, q1 = int(a), 1
while True:
a = int(1/x)
x = 1/x - a
p_i = a*p1 + p0
q_i = a*q1 + q0
if p_i**2 - N*q_i**2 == 1:
return p_i, q_i
break
p0, q0 = p1, q1
p1, q1 = p_i, q_i
```
Благодаря ему мы можем сразу найти решение уравнения (10) *n = 2*, *f = 17*. Однако, прежде чем двигаться дальше, мы должны кое-что знать об уравнении Пелля.
Начнем с того, что *n* не может быть полным квадратом. К тому же у любого уравнения Пелля существует бесконечное количество решений, среди которых всегда есть тривиальное: *x = 1* и *y = 0*. Каждое последующее решение может быть получено на основе предыдущих, по следующей рекуррентной формуле:
Получается, что нам достаточно найти минимальное нетривиальное решение, а все остальные мы можем получить, пользуясь простым алгоритмом. Например, для *n = 2* мы можем легко найти такое решение, это *x = 3* и *y = 2*, тогда последующие решения будут выглядеть так:
```
17, 12
99, 70
577, 408
3363, 2378
19601, 13860
114243, 80782
665857, 470832
3880899, 2744210
22619537, 15994428
131836323, 93222358
768398401, 543339720
4478554083, 3166815962
26102926097, 18457556052
152139002499, 107578520350
886731088897, 627013566048
```
Стоит ли продолжать дальнейшее решение? Конечно, стоит, но… мы можем попытаться предугадать, что нас ждет впереди.
Давайте пока просто представим, что мы решаем систему уравнений из трех уравнений Пелля следующего вида:
Решением любого уравнения Пелля являются точки гиперболы с целыми координатами. Тогда, мы можем вообразить решение первых двух уравнений примерно так:
Решением первого уравнения являются целочисленные точки красной гиперболы, но координата *y*, каждой такой такой точки присутствует во втором уравнении и может порождать любую гиперболу синего цвета, целочисленные точки которой будут являться решением второго уравнения.
Даже этого схематического графика достаточно, чтобы понять, что мы имеем дело с очень большим множеством потенциальных кандидатов на решение системы. Почему кандидатов? Потому что некоторые целочисленные точки гиперболы обязательно будут полными квадратами, т.е. неподходящими решениями. А если представить, что на каждую переменную в системе накладываются какие-то дополнительные условия, то поиск кандидатов на решение станет чрезвычайно трудным. А речь пока идет только системе из трех уравнений.
Но давайте вернемся к нашей «формуле» простых чисел. Что нас может ждать впереди?
Рано или поздно мы обнаружим, что параметр *n* в уравнении Пелля будет становиться катастрофически большим. Метод цепных дробей станет просто бесполезен. Мы обязательно попробуем что-нибудь еще, например перебор значений с просеиванием, как-нибудь обобщим весь этот процесс и придем к алгоритмам подобным квадратичному решету или решету числового поля. В конце концов мы остановимся на методе «чакравала», хотя и он будет испытывать некоторые трудности.
В определенный момент мы почувствуем некоторую уверенность в решении каждого отдельного уравнения системы. Но не всей системы. Мы постараемся применить какие-нибудь эвристические методы оптимизации, например, алгоритм отжига, или алгоритм муравья. Но и здесь мы потерпим неудачу. Для того, чтобы хоть как-то понять причины этих неудач, нам придется немного погрузиться в алгебраическую геометрию и топологию. Постепенно мы получим какое-то представление о «кристаллизуемой субстанции». Сможем отдаленно представить структуру гиперповерхности, на которую выпускаем муравьев.
Опираясь на эти представления мы постараемся улучшить наши алгоритмы. Чтобы сделать это, мы будем брать самые лучшие достижения из многих разделов математики. Постепенно, в алгоритмах будет меньше случайности, но избавиться от нее все равно не получится. Что произойдет потом? Мы вдруг обнаружим, что множество подходящих кандидатов на истинное решение в некоторых местах является парадоксально плотным. Каждая такая плотность будет дарить надежду на то, что где-то в ее центре и спрятан заветный ответ. Муравьям такие плотности будут «казаться» чем-то вроде перевернутой гиперворонки. Мы будем стараться «бить» по их центрам и максимумам. Но что произойдет потом?
### Что за стеной?
Наверное, не знаю как, но мы решим это уравнение. Может быть, нам помогут квантовые или (!) кварковые компьютеры. Но и это не станет дырой в стене. Наверное, дальше нас будут ждать Гауссовы простые числа и еще более сложное уравнение, которое будет представлять их множество. Потом, возможно, среди других гиперкомплексных чисел мы снова наткнемся на какое-то подобие «простого» поведения. Может это, в конце концов, и будет пределом, своеобразным горизонтом событий математической черной дыры.
Что может быть под этим горизонтом? Наверное, какая-то математическая сингулярность. Наверное, мы будем знать абсолютно все обо всех множествах, сможем решать любые уравнения и любые задачи. А может новых вопросов и задач больше вообще не будет?
Возникают именно такие мысли. Ну в самом деле, задайте любой вопрос о простых числах и благодаря данному уравнению вы можете получить на него ответ. Бесконечно ли количество простых чисел-близнецов? Решите данное уравнение, сделайте парочку алгебраических выкладок и получите ответ. Каких простых чисел больше, оканчивающихся на 1, 3, 7 или 9? Тот же самый алгоритм: пара-тройка выкладок и подстановка уравнения. Хотите быстро раскладывать числа на простые множители?..
### В заключение
Впервые с этим уравнением я познакомился в 2008 году, к тому времени я уже сходил с ума по криптографии и теории чисел, в частности по схеме RSA и задаче факторизации. Конечно же, полином, генерирующий простые числа, показался мне очень интересной темой, но слишком сложной. Однако, все задачи, которые удавалось или не удавалось решить, так или иначе были связаны с диофантовыми уравнениями. Поэтому, уже в 2014 году я вновь обратился к этому полиному, решив просто исследовать все разделы математики подряд и искать то, что могло бы пригодиться в его решении. Конечно, ни о какой академической культуре всех моих трудов не может быть и речи — я никогда не вел систематических записей, никогда не агрегировал создаваемый код. Это просто мое хобби.
Мысль о написании этой статьи появилась после того, как я увидел фильм «Интерстеллар». Я не мог поверить в то, что черные дыры и гравитация могут быть представлены так чертовски захватывающе. Но, как оказалось, «несуществующий» мир математики снабжал меня такими же впечатлениями постоянно. В этом мире тоже есть свой недоступный «дальний космос» и свои «элементарные частицы».
Этой статьей я хотел показать, что к любой, самой сложной, даже непосильной задаче можно хоть чуть-чуть подступиться. Таких задач очень много, и можно выбрать ту, что по душе и ближе всего к интересуемой сфере деятельности. Конечно, чрезмерная сложность и гарантированное поражение лишат малейшего желания в этом начинании. Но весь парадокс в том, что самые интересные путешествия и приключения, даже в «не существующем» мире математики, чаще всего, начинаются именно так. | https://habr.com/ru/post/477900/ | null | ru | null |
# Как интегрировать Zimbra Collaboration Suite c Active Directory
Многие предприятия, особенно на территории СНГ, уже имеют сложившуюся ИТ-инфраструктуру, в которой для управления и аутентификацией пользователями зачастую используется такой инструмент как Active Directory от Microsoft. И зачастую у таких предприятий, когда они начинают планировать внедрение Zimbra Collaboration Suite, возникает вопрос о том, сможет ли ZCS нормально вписаться в их инфраструктуру и использовать Microsoft AD для аутентификации пользователей? Что ж, Zimbra вполне способна работать в связке с Active Directory и сейчас мы расскажем о том, как этого добиться.
Итак, предположим, что в инфраструктуре вашего предприятия Active Directory находится на домене **ad.domain.ru** с ip-адресом **192.168.1.102**, а Zimbra предполагается установить на домен **mail.domain.ru**. В процессе интеграции Zimbra и Active Directory мы подключим AD в качестве внешнего LDAP для ZCS и поэтому рекомендуем сразу запретить пользователям самостоятельную смену пароля. Также отметим, что для проверки успешности интеграции Zimbra и Active Directory, на сервере с AD рекомендуется иметь хотя бы один аккаунт с известной вам парой логин/пароль для проверки успешности подключения двух информационных систем.
Подключение AD к ZCS производится в администраторской консоли Zimbra по адресу **[mail.domain.ru](https://mail.domain.ru):7071/zimbraAdmin/**. Здесь нам предстоит в левой боковой панели выбрать пункт Configure, а затем и подпункт Domains. В списке доменов теперь надо выбрать тот, который мы будем использовать в связке с AD и, нажав на выбранном домене правую кнопку мыши, выбрать пункт «Configure Authentification». После этого на экране появится диалог настройки внешнего LDAP, в котором мы и «подружим» Zimbra с AD.
На странице Authentification Mode следует выбрать пункт «External Active Directory», после чего на странице Authentification Settings ввести данные о сервере с AD. От вас потребуется ввести имя домена, ip-адрес сервера и порт, по которому осуществляется доступ к AD, а следующую страницу под названием LDAP Bind предлагаем оставить незаполненной.
В окне Authentification Config Summary можно проверить успешность подключения Zimbra к AD путем ввода корректной пары логин/пароль любого пользователя. В случае, если соединение будет успешным, Zimbra самостоятельно вычислит Bind DN для данного пользователя. После этого можно оставить страницы External Group Settings и Domain Configuration Complete без изменений. На этом интеграция Zimbra с AD закончена и нам остается лишь создать в Zimbra существующих пользователей из AD для успешного выполнения синхронизации между информационными системами.
При небольшом количестве аккаунтов сделать это можно вручную, но в том случае, если аккаунтов действительно много, лучше всего будет автоматизировать данный процесс при помощи функции Auto-provisioning. Для этого нам потребуется зайти на сервер Zimbra и создать файл **/srv/autoprovision.zmp** со следующим содержимым:
```
md domain.ru zimbraAutoProvAccountNameMap "sAMAccountName"
md domain.ru zimbraAutoProvAttrMap "sn=sn"
md domain.ru +zimbraAutoProvAttrMap "description=description"
md domain.ru +zimbraAutoProvAttrMap "cn=displayName"
md domain.ru +zimbraAutoProvAttrMap "givenName=givenName"
md domain.ru zimbraAutoProvBatchSize "20"
md domain.ru zimbraAutoProvLdapAdminBindDn "cn=Administrator,cn=users,dc=domain,dc=ru"
md domain.ru zimbraAutoProvLdapAdminBindPassword "P@$$w0rD"
md domain.ru zimbraAutoProvLdapBindDn "cn=Administrator,cn=users,dc=domain,dc=ru"
md domain.ru zimbraAutoProvLdapSearchBase "dc=domain,dc=ru"
md domain.ru zimbraAutoProvLdapSearchFilter "(&(ObjectCategory=person))"
md domain.ru zimbraAutoProvLdapURL "ldap://192.168.1.102:389"
md domain.ru zimbraAutoProvMode "EAGER"
md domain.ru zimbraAutoProvNotificationBody "Ваша учетная запись была создана автоматически. Адрес вашей электронной почты ${ACCOUNT_ADDRESS}."
md domain.ru zimbraAutoProvNotificationFromAddress "admin@domain.ru"
md domain.ru zimbraAutoProvNotificationSubject "Account ${ACCOUNT_ADDRESS} auto provisioned"
ms mail.domain.ru zimbraAutoProvPollingInterval "1m"
ms mail.domain.ru zimbraAutoProvScheduledDomains "domain.ru"
```
После этого необходимо выполнить созданный нами файл с помощью команд
> su — zimbra
>
> zmprov < /srv/autoprovision.zmp
При такой конфигурации Zimbra OSE будет автоматически каждую минуту подхватывать учетные записи на сервере AD и создавать одноименные учетные записи на сервере Zimbra. Отметим, что в некоторых случаях для корректной работы автонастройки может понадобиться изменить номер порта с 389 на 3268.
Отметим также, что поскольку все действия выполняются на стороне Zimbra OSE, корректной работе инструкции могут помешать различные настройки и изменения, внесенные в Active Directory. Кроме того, может возникнуть путаница с правами доступа к папкам на самом сервере Zimbra. В таком случае рекомендуем [ознакомиться со скриптом](https://habr.com/ru/post/495688/), составленным пользователем kiby75.
После выполнения всех этих действий ваши пользователи смогут входить в свою почту на сервере с Zimbra по паре логин/пароль из AD, что значительно упростит управление ИТ-инфраструктурой предприятия.
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/437240/ | null | ru | null |
# Tarantool: ускорение разработки с Rust
Tarantool, как известно, поддерживает любой язык, который совместим с C и компилируется в машинный код. В том числе есть возможность реализации хранимых функций и модулей на Lua и C. Тем не менее, уже в двух своих проектах мы использовали Rust (в одном из них полностью перенесли Lua-код на Rust) и получили 5-кратное увеличение производительности по сравнению с Lua и сопоставимый результат, который дает по производительности C.
Меня зовут **Олег Уткин** и в Tarantool я занимаюсь высоконагруженными системами хранения данных. Я расскажу про упомянутые два проекта, а также о том, чем так хорош Rust, в котором уже давно существуют различные биндинги для API Tarantool и написания Lua-модулей. Например, вы можете прямо сейчас взять Rust и написать код под Tarantool, в том числе, хранимые процедуры и сторонние модули, которые можно использовать без Lua. Интересно? Поехали!
Казалось бы, Lua или C — неплохие языки. Если бы не их существенные недостатки. Например, хоть Lua и позволяет быстро разрабатывать код, но в некоторых ситуациях он бывает недостаточно быстрым.
И, откровенно говоря, у него не очень хорошая экосистема, просто потому, что обычно этот язык встраивают в приложения, чтобы пользователь мог расширить их функционал и написать свой код. Это приводит к тому, что существующие Lua-модули зачастую несовместимы с Tarantool — например, для работы с сетью и прочими асинхронными операциями. А код, написанный для одного окружения, допустим, OpenResty на Nginx, вы не сможете запустить на Tarantool или на чистом Lua-интерпретаторе. Из-за этого получаются немного изолированные экосистемы.
Если говорить о С, то код быстро исполняется, но его достаточно тяжело писать из-за ручного управления памятью. Что может вызывать различные баги в работе с ней и замедлять время отладки кода. Кроме того, у него достаточно сложный интерфейс для написания Lua-модулей и бывает трудно интегрироваться со сторонними библиотеками. Во-первых, из-за огромного зоопарка систем сборки, которые для использования приходится интегрировать со своим кодом. А, во-вторых, из-за отличий подходов, например, к работе с сетью — подходы приходится «женить».
Поэтому я составил список того, чего бы я хотел от языка:
* Богатая экосистема пакетов, которые можно переиспользовать, экономя время на разработку, отладку и тестирование.
* Удобный пакетный менеджер, чтобы можно было подключить и отслеживать зависимости.
* Удобная система сборки, которая будет все это собирать, линковать и упрощать интеграцию с другими библиотеками.
* Относительно быстрая скорость разработки.
* Безопасная работа с памятью.
* Скорость исполнения.
Как мне показалось, Rust вполне удовлетворяет этим критериям. Давайте посмотрим это сначала на наших кейсах.
Кейс: разработка хранимых процедур для Tarantool
------------------------------------------------
Это простейшая хранимая процедура, которая принимает три параметра: год, квартал и минимальную стоимость:
Код на Lua
```
function some_procedure(year, quarter, min_cost)
local space = box.space.some_space.index.some_index
local result = space
:pairs({ year, quarter }, { iterator = 'GE' })
:take_while(function(record)
return record.year == year
and record.quarter == quarter
end)
:filter(function(record)
return record.earning > min_cost
end)
:totable()
return result
end
```
Что она делает? Из таблицы с транзакциями, которые разбиты по кварталам, выбирает те, что соответствуют определенному кварталу и при этом имеют большую сумму, чем мы указали в запросе.
На Lua это сделать достаточно просто. Но если нам нужно было получить код, который работает быстрее, мы переписывали его на C, и он выглядел так:
Код на C
```
int some_procedure(box_function_ctx_t* ctx, const char* args, const char* args_end) {
uint32_t args_n = mp_decode_array(&args);
assert(args_n == 3);
uint32_t year = mp_decode_uint(&args);
uint32_t quarter = mp_decode_uint(&args);
double min_cost = mp_decode_double(&args);
uint32_t space_id = box_space_id_by_name("some_space", strlen("some_space"));
uint32_t index_id = 0;
char key_buf[128];
char *key_end = key_buf;
key_end = mp_encode_array(key_end, 3);
key_end = mp_encode_uint(key_end, year);
key_end = mp_encode_uint(key_end, quarter);
key_end = mp_encode_double(key_end, min_earnings);
box_iterator_t* it = box_index_iterator(space_id, index_id, ITER_GE, key_buf, key_end);
while (1) {
box_tuple_t* tuple;
if (box_iterator_next(it, &tuple) != 0) {
return -1;
}
if (tuple == NULL) {
break;
}
uint32_t args_n = mp_decode_array(&tuple);
assert(args_n == 3);
uint32_t record_year = mp_decode_uint(&tuple);
uint32_t record_quarter = mp_decode_uint(&tuple);
double record_cost = mp_decode_double(&tuple);
if (record_year != year || record_quarter != quarter) {
break;
}
if (record_cost <= min_cost) {
continue;
}
box_return_tuple(ctx, tuple);
}
box_iterator_free(it);
return 0;
}
```
Он раза в три больше. Причем две трети этого кода — не сама логика хранимой процедуры, а просто работа по десериализации данных, которые приходят из хранилища. Для сравнения, на Rust это выглядит так:
Код на Rust
```
#[derive(Serialize, Deserialize)]
struct Record {
year: u16,
quarter: u8,
earnings: f64,
}
fn some_procedure(ctx: &FunctionCtx, args: FunctionArgs) -> c_int {
let args_tuple: Tuple = args.into();
let (year, quarter, min_cost): (u16, u8, f64) = args.as_struct().unwrap();
let space = Space::find("some_space").index("some_index");
let result: Vec = index
.select(IteratorType::GE, &(year, quarter))
.map(|tuple| tuple.as\_struct::())
.take\_while(|record| record.year == year && record.quarter == quarter)
.filter(|record| record.cost >= min\_cost)
.collect()
match ctx.return\_mp(&result) {
Ok(\_) => 0,
Err(\_) => -1,
}
}
```
Для написания этого кода мы использовали уже готовые [биндинги к Tarantool](https://crates.io/crates/tarantool). По размеру и логике это аналогично Lua, но производительность такая же, как у C. За счет чего это достигается?
### Кодогенерация, макросы
Одна из крутых вещей, которая есть в Rust — это метапрограммирование. Вы можете писать свои макросы, которые во время компиляции будут работать с вашим кодом через манипуляции с абстрактным синтаксическим деревом. По сути, это нечто вроде хранимой процедуры, которая принимает это дерево и может делать с ним любые модификации.
Вы это даже можете не писать сами. Уже есть много библиотек, которые сделают это за вас. Как правило, они используют фреймворк Serde (Serializer, Deserializer):
Serde
```
#[derive(Serialize, Deserialize)]
struct Record {
year: u16,
quarter: u8,
cost: f64,
}
fn parse_record(raw_data: &str) -> Result {
let record: Record = serde\_json::from\_str(raw\_data)?;
return record;
}
```
Serde, по сути, реализует универсальный интерфейс для написания библиотек, который будет сериализовать/десериализовать ваши данные во время компиляции. На основе этого кода можно подключить любую библиотеку, которая умеет сериализовать JSON либо MessagePack, и делает это буквально в одну строку.
### Функциональное программирование, итераторы
Rust включает в себя различные операции для обработки данных, которые приходят из итераторов. Например, можно cмаппить данные с помощью оператора map, отфильтровать или агрегировать их с reduce:
Здесь видно, что запрос, который мы делаем на Rust, занимает примерно столько же кода, сколько мы могли бы написать на Lua, и логически выглядит примерно также.
### Результаты
Приведу пример теста. На процедуре выборки и на одном инстансе Tarantool (один поток) при 100% утилизации CPU получаются такие результаты:
Видим, что код на Lua дает 340 RPS, а на C — 1700. Rust при этом позволяет написать столько же простого кода как на Lua, но получить производительность сопоставимую с C.
Кейс: разработка модулей
------------------------
Следующий кейс, в котором мы использовали Rust — это разработка модулей. Это пример, как код на Rust можно обернуть в биндинг, и не важно, Lua это, JS или Python — вы получите готовый модуль для вашего языка программирования. Покажу на простейшем примере:
Есть процедура, написанная на Lua, которая выводит «hello, world». Чтобы реализовать ее на Rust, достаточно соблюсти некоторую сигнатуру функций, которые дальше мы можем пробросить в Lua. При этом никаких преобразований данных делать не нужно. И это касается всех примитивных типов данных, которые есть в Rust: они будут автоматически кодированы в тип, удобный для работы в Lua.
Если у вас есть какой-то кастомный тип, то вы можете для своей структуры определить методы, которые будут проброшены в Rust. Вот хороший пример:
Пример Lua-биндингов библиотеки avro\_rs
```
struct Avro { schema: Schema }
impl Avro {
pub fn new(schema: &str) -> Result {
Ok(Avro { schema: Schema::parse\_str(schema)? })
}
pub fn decode(&self, reader: &mut R) -> Result {
let avro\_value = avro\_rs::from\_avro\_datum(&self.schema, reader, None)?;
Ok(Value::try\_from(avro\_value)?)
}
}
impl mlua::UserData for Avro {
fn add\_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
methods.add\_method("decode", |lua, this: &Avro, blob: LuaString| {
let json\_value = this.decode(&mut blob.as\_bytes())?;
lua.to\_value\_with(&json\_value)
});
}
}
```
В нашем реальном кейсе была задача декодировать Avro-сообщения с помощью Lua внутри Tarantool. К сожалению, реализации Avro на Lua не существовало, а если бы и существовало, то, скорее всего, она работала бы достаточно медленно. Но у нас уже была готовая библиотека, написанная на Rust. Мы портировали её на Lua, просто написав для нее биндинги.
Конечно, это не все возможные области применения Rust. Говоря в общем, Rust может заменить такие языки, как C и C++, поскольку он так же, как они, компилируется в машинный код. При этом за все возможности языка вы платите только один раз — во время компиляции.
Но вы сможете его использовать и в более прикладных задачах. Например, ускорить бэкенд, переписав код на Rust и затратив на это немного усилий. Также есть большое количество библиотек реализации блокчейнов. Думаю, он так популярен там просто потому, что им необходима высокая скорость исполнения кода и несложность разработки. Rust всё это дает.
А теперь посмотрим, что в принципе делает Rust таким крутым. Я разбил его особенности на 4 основных категории: память, типы, экосистема и разработка сетевых приложений.
Чем хорош Rust
--------------
### Память
Одна из особенностей Rust — это понятия владения и аффинных типов данных:
Передача владения
```
struct User {
name: String,
country: String,
age: i32,
}
pub fn main() {
let user = User {
name: String::from("Igor"),
country: String::from("Russia"),
age: 30,
};
print_user_age(user); // здесь происходит перемещение user внутрь функции
print_user_country(user); // ошибка: используем перемещенный объект
}
fn print_user_age(user: User) {
println!("{} is {} years old", user.name, user.age);
}
fn print_user_country(user: User) {
println!("{} lives in {}", user.name, user.country);
}
```
Это означает, что данные, которые вы инициализируете в некоторой области видимости, точно освободятся, причем ровно один раз. Не будет ситуации, что они ушли в другую область видимости, освободились там, а вы переиспользуете данные, на которые уже вызваны деструкторы. Компилятор может это отследить и сообщить программисту, чтобы он это исправил.
#### Заимствование
В случае, когда мы не хотим передавать владение какими-то нашими переменными в другие области видимости, мы можем передать их по ссылке:
Заимствование
```
struct User {
name: String,
country: String,
age: i32,
}
pub fn main() {
let user = User {
name: String::from("Igor"),
country: String::from("Russia"),
age: 30,
};
print_user_age(&user); // передаем по ссылке
print_user_country(&user); // передаем по ссылке
// Здесь вызовется деструктор user
}
fn print_user_age(user: &User) {
println!("{} is {} years old", user.name, user.age);
}
fn print_user_country(user: &User) {
println!("{} lives in {}", user.name, user.country);
}
```
Владение переменными, которые мы выделяем в текущем скоупе, остается там же, и там же будет вызван деструктор. Но теоретически может случиться, что у нас появится ссылка, которая была объявлена во внешнем скоупе, а данные, на которые она указывает — выделены в дочернем скоупе.
То есть данные, на которые указывает ссылка, могут быть освобождены до того, как была освобождена ссылка, и в этот момент она укажет на невалидные данные. Здесь на помощь придет **Borrow checker** (проверщик заимствований), который встроен в компилятор Rust:
Borrow checker
```
struct User { age: i32 }
pub fn main() {
let user_ref: &User
{
let user = User { age: 30 };
user_ref = &user // ошибка компиляции, т.к. может вызвать невалидную ссылку
// здесь вызовется деструктор user, делая ссылку user_ref невалидной
}
// здесь вызовется деструктор user_ref
}
```
Если у вас действительно возникнет такая ситуация, то компилятор вам об этом скажет, а ваш код не скомпилируется. В принципе, можно сказать, что компилятор Rust дает гарантию того, что у вас не будет ссылок, которые указывают на невалидные данные.
#### Умные указатели
Но что, если мы не можем определить размер данных во время компиляции? Тут на помощь приходит **тип Box**. Он позволяет выделять данные на heap. По сути, это умный указатель, похожий на std::unique\_ptr в C++. Мы выделяем данные на стеке, сразу перемещаем их на heap, а их поведение остается такое же, как если бы мы эти данные выделили на стеке. Здесь видно, что точно так же мы перемещаем переменную user в вызываемую функцию, и там данные уже освобождаются:
тип Box
```
struct User {
name: String,
country: String,
age: i32,
}
pub fn main() {
let user = Box::new(User {
name: String::from("Igor"),
country: String::from("Russia"),
age: 30,
});
print_user_age(user); // здесь происходит перемещение user внутрь функции
}
fn print_user_age(user: Box) {
println!("{} is {} years old", user.name, user.age);
// Здесь вызовется деструктор user
}
```
Но бывают ситуации, когда нужно использовать ссылку на одни и те же в несколькими областях видимости или передать в другие потоки исполнения. Для этого в Rust есть тип **Rc (reference counter)**, и это тоже умный указатель. Когда мы выделяем память с помощью Rc, то у нас есть счётчик, который указывает — сколько есть ссылок на конкретно эти данные. Когда мы явно клонируем этот указатель, то счетчик ссылок на эти данные инкрементируется. И декрементируется, если указатель вызывает свой деструктор. Если счётчик становится 0, то данные освобождаются:
тип Rc (reference counter)
```
struct User {
name: String,
country: String,
age: i32,
}
pub fn main() {
let user = Rc::new(User {
name: String::from("Igor"),
country: String::from("Russia"),
age: 30,
});
let user2 = user.clone(); // клонируем умный указатель
print_user_age(user2); // здесь происходит перемещение указателя на user внутрь функции
print_user_country(user); // здесь происходит перемещение user внутрь функции
}
fn print_user_age(user: Rc) {
println!("{} is {} years old", user.name, user.age);
}
fn print\_user\_country(user: Rc) {
println!("{} lives in {}", user.name, user.country);
}
```
Этот подход называется **подсчетом ссылок и** используется еще много где. Чем же он хорош? Например, вот графики из достаточно интересной [статьи Discord](https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f) о том, как они с помощью перехода с Go на Rust смогли ускорить свои сервисы:
Garbage Collection заставляет прервать исполнение кода и начать освобождать неиспользуемую память. Но такие остановки негативно влияют на latency запросов, особенно на 95% и выше. На графике видно, что при использовании Rust удалось значительно сократить latency, а нагрузку на CPU сделать более равномерной.
#### Unsafe
Мы говорили о возможностях, которые позволяют Rust проверять используемую память на безопасность. Но бывают ситуации, когда нам нужно делать операции с сырыми указателями, а их компилятор Rust проверять не умеет. Поэтому ответственность за проверку того, что за данные лежат под указателями и насколько они валидные, ложится на разработчика.
Для таких ситуаций в Rust есть специальное ключевое слово **unsafe**, позволяющее выделить блок кода, где компилятор сможет дать доступ разработчику к unsafe-операциям:
```
let mut num = 5;
let r1 = # as *const i32;
let r2 = &mut num as *mut i32;
unsafe {
println!("r1 is: {}", *r1);
println!("r2 is: {}", *r2);
}
```
Благодаря этому, вы сможете разыменовывать сырые указатели. Это могут быть нулевые указатели или указывающие на невалидный участок памяти. А также иметь возможность вызывать функции, помеченные как unsafe. Внутри таких функций можно выполнять unsafe операции, но сами они могут вызываться только из unsafe блоков. Используя unsafe-функции, программист должен понимать, что компилятор не может точно сказать, испортит ли данный код данные или нет. И будут ли валидными указатели, которые он передает или получаете из нее.
Также вы сможете работать с FFI, когда, допустим, вы подключаете динамическую библиотеку. Естественно, компилятор не может проверить, что операции, которые вы будете делать в этой динамической библиотеке, точно никак не повлияют на вашу память.
Теперь перейдём к следующей категории.
### Алгебраические типы данных
Алгебраические типы данных пришли в Rust из функционального программирования. По сути, это что-то типа суммы типов, и в некоторых языках их называют тегированные enum. Они позволяют в одном типе хранить сразу несколько вариантов того, как он будет выглядеть и какую структуру иметь:
Enum
```
enum Shape {
Square { width: u32, length: u32 },
Circle { radius: u32 },
Triangle { side1: u32, side2: u32, side3: u32 },
}
pub fn main() {
let square = Shape::Square { width: 10, length: 20 };
let circle = Shape::Circle { radius: 20 };
let shape: Shape = square;
match shape {
Shape::Square { width, length } => println!("square({}, {})", width, length),
Shape::Circle { radius } => println!("circle({})", radius),
_ => println!("other shape"),
}
}
```
В примере мы выделяем несколько вариантов enum (Square, Circle, Triangle) и присваиваем их общей переменной Shape. Потом, с помощью pattern matching, определяем, что у нас лежит внутри этой переменной, и на основе этого реализовываем какую-то логику.
На основе этого механизма в Rust также организована работа с ошибками:
Проверка на ошибки
```
enum Result {
Ok(T),
Err(E),
}
fn do\_something\_that\_might\_fail(i: i32) -> Result {
if i == 42 {
Ok(13.0)
} else {
Err(String::from("this is not the right number"))
}
}
fn main() -> Result<(), String> {
let v = do\_something\_that\_might\_fail(42)?;
println!("found {}", v);
// эквивалентно
let result = do\_something\_that\_might\_fail(42);
match result {
Ok(v) => println!("found {}", v),
Err(e) => return Err(err),
}
Ok(())
}
```
Как это работает? Из функции возвращается тип Result, который может находиться в двух состояниях: Ok(T), то есть выполнилось с успехом или Err(E), возвращая какую-то ошибку. Мы можем работать с этим явно — с помощью того же pattern matching). Либо используя специальный оператор (знак вопроса), который возвращает то, что вернулось из функции при успехе. Если завершилось с ошибкой, то он передает её дальше в ту функцию, которая вызвала исполнение.
Таким же образом решается проблема с нулевыми указателями. У нас есть переменные, которые могут в себе хранить данные, а могут не хранить. Тут на помощь приходит тип Option, который может находиться в двух состояниях. Это либо None (в текущей переменной нет данных), либо Some(T), которое хранит данные, что мы хотим вернуть:
тип Option
```
enum Option {
None,
Some(T),
}
fn do\_something\_that\_might\_fail(i: i32) -> Option {
if i == 42 {
Some(13.0)
} else {
None
}
}
fn main() {
let result = do\_something\_that\_might\_fail(42);
match result {
Some(v) => println!("found {}", v),
None => println!("not found"),
}
}
```
Это позволяет нам во время компиляции точно обработать все случаи, когда в переменной нет данных.
### Traits (типажи)
Ещё один из ключевых механизмов языка — это traits (типажи), что-то вроде интерфейсов или абстрактных классов, которые есть в ООП-языках. Traits позволяют определить желаемое поведение некой структуры или enum, указав, какие методы они должны реализовывать.
Помимо этого, traits позволяют реализовать дефолтные методы, которые, например, основаны на обязательных методах. То есть, реализовав всего парочку обязательных методов, мы можем получить множество методов, основанных на них — и автоматически реализовывать логику для наших структур:
traits (типажи)
```
trait Animal {
pub fn get_name(&self);
pub fn say();
}
struct Dog { name: String };
impl Animal for Dog {
pub fn get_name(&self) -> String { self.name.clone() }
pub fn say() { println!("bark"); }
}
struct Cat { name: String };
impl Animal for Cat {
pub fn get_name(&self) -> String { self.name.clone() }
pub fn say() { println!("meow"); }
}
fn main() {
let animal: Animal = Dog{ name: String::from("Rex") };
animal.say();
println!("animal's name is {}", animal.get_name());
}
```
Теперь перейдём к следующей категории.
### Экосистема
#### Пакетный менеджер и система сборки
В Rust есть Cargo, который совмещает в себе очень удобный пакетный менеджер и систему сборки. Cargo позволяет на основе описания вашего пакета со всеми зависимостями и любой дополнительной метаинформации, автоматически скачать, собрать и слинковать эти зависимости. При этом есть возможность описания дополнительной логики при сборке:
Чем это может быть полезно? Например, при сборке нашего пакета мы можем сразу скомпилировать реализацию Protobuf спецификации. А если мы хотим скомпилировать наш проект на Rust «сишным» кодом, то это можно будет сделать автоматически во время компиляции — просто указав, какие файлы нужно к нему прилинковать.
#### Сторонние библиотеки
В экосистеме Rust есть огромное количество пакетов, которые могут нам пригодиться на все случаи жизни: от различных сетевых протоколов коннекторов к БД до HTTP-фреймворков. Но если вам и этого недостаточно, то в Rust есть интерфейс для взаимодействия со сторонними языками. Например, вы можете писать код на C и вызывать его в коде на Rust:
Это очень удобно, если у вас уже есть часть кодовой базы, которая написана на C — вы просто можете переписать часть кода на Rust. Либо наоборот, у вас есть небольшой код на Rust, и тогда вы сможете интегрировать его в свой проект.
> **Стоит заметить, что вызов «сишного» кода по FFI в Rust всегда считается unsafe. Тут программисту нужно быть более аккуратным, чтобы обработать случаи, когда происходит небезопасная работа с памятью. Он должен написать безопасную обертку над небезопасным интерфейсом.**
>
>
#### Инструменты отладки
Также из C в Rust пришли различные инструменты для отладки. Например, Valgrind для поиска утечек, дебаггеры GDB и LLDB, а также профайлеры perf и dtrace. Вот пример трейса через perf простого приложения:
Видно, что все символы удобно подтягиваются. Также можно смотреть по функциям, кто сколько процессорного времени отъедает.
#### Документация
У Rust есть специальный сайт, где собрана документация для всех пакетов, которые есть в их registry. Вы можете в своем пакете описать комментарии к вашим функциям, добавив части документов прямо в код — и всё будет отображаться на сайте вместе с остальной документацией по пакетам Rust.
Кроме этого, есть очень хорошая официальная [документация Rust book](https://doc.rust-lang.org/book/), в качестве учебника от разработчиков языка. В ней с примерами описаны все компоненты, которые есть в языке. В принципе, прочитав Rust book, вы сможете сказать, что умеете программировать на Rust.
И, наконец, по работе с unsafe есть [Rustonomicon](https://doc.rust-lang.org/nomicon/) — подробное руководство, как правильно писать обертки на unsafe-код, которые будут безопасны уже для работы из Rust’ового кода. Это руководство также описывает некоторые внутренности языка, и его полезно почитать.
Для начинающих я бы рекомендовал пройти [Rust tour](https://tourofrust.com/) — он показывает все возможности языка, приводя различные примеры для каждой. Для себя я еще нашел [лекции Алексея Кладова](https://www.youtube.com/playlist?list=PLlb7e2G7aSpTfhiECYNI2EZ1uAluUqE_e). Он достаточно подробно и популярно объясняет, что и как работает в Rust.
А у нас осталась последняя категория, которую нужно разобрать, чтобы понимать особенности Rust.
### Разработка сетевых приложений
#### Асинхронные интерфейсы, async/await
В стандартной библиотеке Rust из коробки идут интерфейсы, которые позволяют реализовывать свои асинхронные рантаймы и взаимодействовать с чужими из вашего кода. Но при этом сам Rust в себе рантайм не содержит — его реализуют сторонние разработчики. Для этого есть две самые популярные библиотеки: **Tokio и async-std**. Они похожи интерфейсами и производительностью, но Tokio появилась чуть раньше, поэтому более популярна и для неё больше пакетов.
Из самого основного, что нужно, Tokio включает в себя **многопоточный work-stealing-рантайм для исполнения асинхронного кода**. Это значит, что внутри рантайма есть тредпул, который на каждый поток CPU запускает поток ОС. Те асинхронные задачи, которые вы исполняете в своем коде, будут равномерно балансироваться между этими потоками — то есть вы сможете задействовать в коде все ядра процессора.
Work-stealing означает, что один из потоков, выполнив все свои задачи, может начать выполнять задачи из очереди другого потока. Это позволяет нагружать процессор более равномерно, и у вас не будет ситуации, когда один поток, выполнив свои задачи, простаивает в ожидании новых.
Кроме этого, Tokio включает в себя часть стандартной библиотеки, отвечающей за работу с асинхронным кодом и несет огромную экосистему уже готовых пакетов. В целом в Tokio это очень похоже на подход, который используется в языке Go. Только горутины (goroutine) в Rust называются тасками (task), которые уже рантайм балансируют между потоками. Вот достаточно простой пример TCP сервера:
Сначала мы создаем TcpListener, который будет в бесконечном потоке принимать соединения из сокета. Каждое отдельное соединение можно запустить в отдельной таске, и они будут балансироваться между потоками процессора, равномерно его утилизируя.
Или, например, так же как в Go, в Rust вместе с Tokio можно создать каналы, которые позволят обмениваться данными между тасками через передачу сообщений:
Выводы
------
Rust может выступить более удобной заменой для языков C и C++ в качестве языка системной разработки. Например, на нем можно писать модули для Linux, которые до сих пор нельзя было писать на C++.
Также он подходит не только для системной, но и для прикладной разработки. По сути, как я говорил, можно переписать бэкенд на Rust и получить большой прирост по скорости.
И наконец, Rust хорошо подходит для написания модулей для других языков (Lua, JS, Python), если мы хотим ускорить код или в том языке нет библиотек, которые мы хотели бы использовать.
> Конференция [**Highload++ Foundation**](https://clck.ru/bEYea) пройдет 17 и 18 марта в Москве, в Крокус-Экспо. Описание [докладов](https://clck.ru/bEYvu) и [раcписание](https://clck.ru/bEZM2) уже готовы. [Билеты](https://clck.ru/bEZZi) можно купить на сайте.
>
> А сейчас идет [открытое голосование по Open Source трибуне](https://clck.ru/bEc8w), где определятся 5 лучших решений. Отдайте свой голос за то, что вам нравится и помогите определить лучших!
>
> | https://habr.com/ru/post/650991/ | null | ru | null |
# Аудит-логи на базе Афины
Логирование бывает разным. Часто в проектах можно встретить следующие виды логов:
* Системные об ошибках и исключениях;
* Авторизационные о попытках входа;
* Почтовые о работе, например, SMTP сервера;
* Логи доступа к базе данных;
* Аудит-логи о действиях пользователя.
Наша история будет про аудит-логирование. Я попробую рассказать её так, чтобы вы не уснули со скуки, и добавлю интересные вставки по реализации. Цель — дать возможность разобраться в архитектуре и причинах выбора именно такого подхода к решению проблемы.
### Когда нужны аудит-логи?
Однажды у одного из клиентов нашей системы возникла проблема. Ему нужно было отследить изменение конкретного заказа, который был закрыт уже достаточно давно. Само собой, в системе использовалось программное удаление (soft delete), т.е. по факту ничего не удалялось. Нужный заказ был поднят из базы, он хранил в себе даты создания и закрытия, статус и десятки других значений… Но этого оказалось мало. Кто, как и когда менял заказ было неизвестно.
Так у нас появилась первая задача, связанная с аудитом. Необходимо было сделать так, чтобы вся информация о работе с заказом, каким-то образом хранилась в базе.
### Как мы добавляли аудит-логи?
#### Добавили сущность Workflow.
В нашем понимании Workflow — это жизненный путь заказа, от момента его создания и до закрытия. Эта сущность в БД обросла небольшой обвязкой, из которой хотелось бы выделить такую сущность как WorkflowTransition. Из названия становится понятно, что WorkflowTransition хранит информацию о переходе из одного состояния в другое. Если быть точным, то в нем хранится два состояния, одно — до, второе — после изменения статуса. Хранятся эти состояния в сериализованном виде, в формате JSON (дальше вы поймете почему). Теперь каждое редактирование заказа приводило к тому, что система сохраняла достаточное количество информации для того, чтобы мы знали кто, когда и как изменял заказ.
Ура, заработало! Но это был только первый шажок.
#### Добавили поле Type.
Зачем мы выделили сущность Workflow? Почему нельзя было сразу создать сущность типа OrderTransition и ссылаться напрямую на заказ?
Ответ — универсальность.
Если добавить в Workflow поле Type, то сразу становится понятным, что теперь мы можем не ограничиваться логированием только заказов, а можем логировать абсолютно любую сущность. Ведь снэпшоты сущностей хранятся в текстовом виде и это снимает с нас много ограничений, но, буду честен, накладывает и определенные трудности.
#### Нужно больше логов…
Наши заказчики стали еще счастливее! Мы дали им инструмент для быстрого поиска корня их бизнес проблем — страничку с аудит логами. Но прошло время… Заказы копились, росло и количество клиентов. Наша “нерезиновая” БД плакала и распухала.
По сути, мы не очень рационально использовали ресурсы, храня информацию, которая, в большинстве случаев, оставалась невостребованой. Но жертвовать было нечем — требовалось хранить всё, хранить всегда и, иногда, ещё и искать в этом безобразии нужные записи.
И тут нам на помощь пришли облака. Сейчас вы могли подумать, что это же очевидно, скучно и не очень то и удобно… Но поспешу вас заверить, что это не совсем так, а скорее наоборот. Это оказалось мега-удобно и даже экономически выгоднее! И так, что же мы сделали?
#### Миграция в облако.
Мы добавили в систему самописный сервис — он каждый день искал старые аудит-логи и мигрировал их в S3-хранилище. Старыми считались логи старше шести месяцев. Пользователи, как раньше, могли искать нужные записи аудита в привычном интерфейсе. А те логи, которые перебрасывались в S3 на долгое хранение, немного преобразовывались, архивировались и записывались в определенном формате по бакетам, которые создавались отдельно для каждого клиента. Безопасная безопасность! :)
Можно подумать, что это всё банально и скучно. Что теперь делать с этими архивами? Искать руками? Писать парсилку? Зачем нужно преобразовывать и соблюдать какой-то формат?
Да всё просто! Тут нам на помощь приходит ̶б̶о̶г̶и̶н̶я̶ ̶м̶у̶д̶р̶о̶с̶т̶и̶ Афина, а если точнее, то аналитический сервис Athena от Амазон. А все вышеуказанные преобразования нужны для того, чтобы наши логи хранились в форматах “открытых таблиц и файлов”.
Объясню проще. Если мы правильно сложим наши данные, то Афина сама их распарсит и, более того, даст нам возможность искать записи при помощи SQL-подобных запросов, используя в запросах как имена папок, так и содержимое сжатых JSON файлов. А раз у нас будет возможность писать запросы для поиска логов на SQL, так почему бы не сделать так, чтобы наши клиенты могли сами искать нужную информацию, не задумываясь, где она хранится, в обычной продовской базе или в архивах облачных сервисов?
И мы это сделали, написав обертку над API Афины в виде кастомного IQueryable.
Хочу обратить ваше внимание на то, что в обычной базе у нас хранятся аудит логи за полгода. Это покрывает 99% потребностей клиентов. Остальные данные за несколько лет хранятся в достаточно дешевом сторадже, а обращения к Афине тарифицируются по запросам, коих буквально единицы. Но чтобы еще больше сэкономить, было решено уведомить клиентов о том, что они по умолчанию ищут информацию за последние 6 месяцев, но если вдруг нужно, клиент может чекнуть галочку “хочу искать за весь доступный период”, и тогда подключается поиск через API Афины.
Само собой, Афина поддерживает и множественные условия, и сортировку результатов. Это почти полноценный привычный SQL со своими нюансами, поэтому нам не составило большого труда объединить результаты из базы и AWS, сохранив функционал фильтрации и сортировки.
В итоге мы получили такую архитектуру наших аудит-логов:
### Чего мы добились:
1. Система обзавелась аудит логами для любых сущностей.
2. Логи хранят детальную информацию: кто, что, как и когда менял.
3. Быстрый и простой доступ к последним логам.
4. Продовская база данных не растёт, а хранит логи только за нужное время.
5. Старые логи хранятся в облаке и имеют удобный SQL-интерфейс для работы.
6. Единый интерфейс для поиска как свежих, так и архивных записей.
7. Доступ к архивным логам есть только у их владельца.
8. Можно легко копировать логи из облака — они уже заархивированы и структурированы.
Потребности клиентов полностью удовлетворены!
### Скучные технические детали
Теперь немного технической информации об Афине для тех, кого заинтересовал такой подход. Готового решения не будет, но я постараюсь рассказать обо всём что вам пригодится. Эдакий онбординг в Афину.
Первое, что нужно сделать — зарегистрироваться в AWS, создать AIM пользователя и группу, добавить необходимые для работы с Афиной права `AmazonAthenaFullAccess` и `AWSQuicksightAthenaAccess`. Это позволит работать с S3.
Афина не только читает оттуда данные, но и сохраняет результат запроса. Здесь я хочу пояснить как работает выполнение запроса в Афине. Под капотом используется движок Presto, но вам не придется настраивать какую-либо инфраструктуру. Это серверлес-решение, которое позволяет выполнять запросы параллельно, автоматически расширяясь при необходимости. Афина позволяет использовать множество различных способов коммуникации:
* AWS Management Console;
* JDBC или ODBC;
* Athena API;
* Athena CLI;
* AWS SDK;
* AWS Tools for Windows PowerShell.
Чтобы создавать таблицы автоматически можно настроить интеграцию с AWS Data Glue, но в нашем случае таблица создавалась вручную — так было нужно. Все ваши запросы сохраняются Афиной и складываются в определенный S3 бакет, который вы указываете в настройках.
Работа с AWS-сервисом в коде была исключительно проста. Всё сводилось к написанию одного сервиса поверх AWS SDK, который вызывал асинхронный метод `StartQueryExecutionRequest()`, возвращающий `QueryExecutionId`, и ждал результатов, опрашивая периодически Athena API, вызывая у клиента метод `GetQueryExecution()`. Ну да, еще была реализация интерфейса `IQueryable`, но это не относится напрямую к Афине.
Теперь немного о формате, в котором хранятся данные на S3.
Допустим, у нас есть некий JSON или CSV файл, который нужно поместить в хранилище и потом писать запросы, чтобы найти его, когда понадобится. Для нас важно время когда заказ был закрыт, следовательно, искать аудит логи по времени будет самым частым кейсом. Путь по которому файл будет сохранен должен выглядеть примерно так:
`s3://bucket-for-client1/orders/year=2023/month=01/…`
Этот путь должен соответствовать такой схеме:
`s3:////partition-1=/partition-2=/`
В нашем случае `year` и `month` **—** партишены, которые при написании SQL-запроса используются в качестве колонок, то есть запрос может включать такие условия:
`… WHERE year = ‘2023’ AND month = ‘1’...`
Но нужно помнить, что при ручном создании таблицы мы должны явно указать эти партишены:
```
CREATE EXTERNAL TABLE IF NOT EXISTS `Audit`.`Orders`(
`id` string,
…)
PARTITIONED BY (
`year` int,
`month` int)
ROW FORMAT SERDE
'org.apache.hive.hcatalog.data.JsonSerDe'
LOCATION
…
```
Если при миграции наших логов нужно сохранять их в новую папку, например, наступил новый год или месяц, то надо будет сказать Афине, что у нас появилось новое значение партишена:
```
ALTER TABLE Audit.Orders
ADD IF NOT EXISTS
PARTITION (year = '2023', month = '01')
LOCATION
…
```
Тем самым мы даем понять, что это составной партишен, т.е. значения `2023` и `01` используются в паре, что влияет на оптимизацию будущих запросов.
При выполнении запроса Афина будет сканировать все данные. Это может быть накладно, если таковых много. Но если в запросе фигурируют партишены, то проблема решается сама собой. Сканироваться будут только те файлы, которые хранятся в указанных в запросе партишенах. Кстати, чем меньше данных сканируется, тем меньше мы платим за запрос! ;)
В нашем случае, содержимое JSON-файлов, сохраняемых в S3, как ни странно, является сериализованным в JSON объектом. Вы можете складывать в один файл несколько объектов, но не кладите их в массив, а просто добавляйте каждый новый объект с новой строки. Иначе Афина будет считать, что вы отдаете ей не список записей, а один массив. Логично же? :)
```
{“id”:”1”, “name”:”name1”}
{“id”:”2”, “name”:”name1”}
{“id”:”3”, “name”:”name1”}
```
Если ваш сериализованный объект имеет поле, где содержится другой объект или массив объектов, то вы можете хранить такие данные в одной таблице, используя такие типы данных как Array и Struct.
```
CREATE EXTERNAL TABLE IF NOT EXISTS `Audit`.`Orders`(
`id` string,
`values` array<
struct <
`FieldName`: string,
`ValueBefore`: string,
`ValueAfter`: string> >)
…
)
```
Есть еще один приятный момент. В вопросе безопасности Афина тоже на высоте. Она умеет работать с зашифрованными данными из коробки.
Все описанные возможности Афины полностью покрыли наши потребности, но это всего лишь верхушка айсберга. AWS дают Афине огромные возможности, реализуя интеграции со всевозможными сервисами и поддержку всё большего количества форматов данных.
Я надеюсь, что наш опыт будет вам полезен. Ведь когда знаешь о возможностях какой-либо технологии, как её варить и в каких целях использовать, тогда сможешь применить свои знания в нужный момент. | https://habr.com/ru/post/711110/ | null | ru | null |
# «Реверс-инжиниринг» клиентского приложения в образовательном центре
Привет, Хабр. Хочу поделиться историей из жизненного опыта. Несколько месяцев назад я записался на платные курсы по изучению языка программирования JavaScript в прекрасном городе Минск. Потратил около недели времени на подробное изучение отзывов о каждой из компаний на рынке, сравнивал цены на услуги и местоположение относительно моего дома. Наконец, выбрав «достойного» кандидата, направился к ним в офис для заключения договора. В общем, прошел я начальный инструктаж, получил расписание занятий и содержание всего курса и с радостью приступил к делу.
Курс был довольно качественный, преподаватели имели реальный опыт разработки на production проектах и очень старались объяснить максимально просто различные аспекты языка, но это история не об этом…
В конце двух месяцев занятий c частотой 4 дня в неделю по 4 часа, каждый студент обязан был пройти контрольный тест в виде 80 вопросов по предмету с множеством вариантов ответов. Компания обещала при условии успешной сдачи тестирования помочь трудоустроится в крупную компанию нашего города на позицию JavaScript Developer. Очень заманчиво.
Вот пример вопроса:
1. **Что выведет команда console.log() ?**
```
(function() {
var x = 1;
function x() {};
console.log(x);
})();
```
И несколько вариантов ответа, оформленные примерно так:
На рисунке черные квадраты — это *checkboxes*. Вариантов ответов на все 80 вопросов может быть от 1 до всех, что есть в списке вариантов.
Я, как прилежный ученик, тут же бросился отвечать на них. Однако, остановившись на 3-4 вопросе, мне захотелось узнать, как работает эта система. Пролистав в самый низ страницы, я нажал кнопку «Done» и увидел следующее: все вопросы, на которые были даны неверные ответы — а это все оставшиеся без моих ответов — стали подсвечены красным цветом. Появилась красивая рамка и изменился background-color у родителя элемента вопроса. «О, валидация!», — подумал я и начал выяснять, как же она работает.
Открыл, в общем, FireBug, обновил страницу и нажал кнопку «Done» еще раз. Я увидел, что запрос на сервер не отправился, то есть валидация сугубо клиентская работает в данный момент. Затем я открыл список JavaScript файлов, которые подключены к странице (там, кстати, использовался **Backbone + RequireJS**), и нашел модуль под названием *«validation.js»*.
Сперва я отправился на [unminify.com](http://unminify.com/), мне нужно было привести код к нормальному состоянию. После прочтения кода я нашел метод *«validate»* со следующим содержанием:
```
/*здесь был код с такой вот логикой*/
$(".questions").each(function(i,e){
var a = [];
$(e).find(":checkbox").each(function(index,elem){
if($(elem).val() % 31 == 0) {
/*все окей, ответ как минимум правильный*/
} else {
/*все плохо, ответ неверный*/
a.push(index);
}
});
if (!a.length) {
/*значит все ответы на вопрос правильные, вызываем функцию correctAnswer();*/
} else {
/*был как минимум один неверный ответ, вызываем функцию wrongAnswer();*/
}
});
```
Далее посмотрел html-разметку всех чекбоксов:
```
```
Так вот, замечательное число в атрибуте «value» и было ключём к правильным ответам теста. Не трудно догадаться, что запрос на сервер будет выполнен только в том случае, если выбраны только правильные ответы.
Я написал небольшой скрипт, который пробегался по всем вопросам, в каждом конкретном вопросе находил элементы *checkbox*, брал их значение и делил на 31; если остаток 0 – выставляем атрибут *‘checked’* в *true*, если нет — идем дальше:
```
var parent = $(".questionnaire-text");
var answers = parent.find(".answers[data-type='checkboxes']");
answers.each(function(index,elem){
var checkboxes = $(elem).find(":checkbox");
checkboxes.each(function(i,e){
if ($(e).val() % 31 === 0) {
$(e).attr("checked","checked");
}
});
});
```
Через мгновение увидел все правильные ответы на абсолютно все 80 вопросов теста. Я с радостью нажал кнопку «Done» и- о, чудо — в FireBug увидел отправленный запрос на удаленный сервер учебного центра, на который получил ответ с поздравлением об успешной сдаче теста на 100%.
Естественно, я не хотел быть уличенным в мошенничестве во время сдачи теста, поэтому посидел еще минуток 20-25 тихонько за компьютером, прежде чем сообщить куратору о готовности.
Сразу скажу, никто кроме меня на 100% не сдал этот тест. В общей сложности только 3 человека, включая меня, сдали тест положительно на более чем 75%. Остальные ребята не набрали и 50% правильных ответов.
После успешного окончания курсов я прошел собеседование в одну из компаний города Минска на должность JavaScript Developer, но мысль о той хитрости во время сдачи теста не давала мне покоя. В один прекрасный день я пришел в тот самый учебный центр и все им рассказал. Мне выразили благодарность за честность и подарили волейбольный мячик.
Вот такая история. Хочу посоветовать всем не боятся исследовать неизвестные области и постоянно находить легкие пути для решения трудных задач. Спасибо за внимание.
*P.S. Приведенные примеры кода лишь частично описывают реальный функционал. Также история не моя личная, а моего очень хорошего друга, который попросил остаться инкогнито.* | https://habr.com/ru/post/251705/ | null | ru | null |
# На мгновение быстрее: измеряем время упаковки и распаковки значимых типов данных
#### Доброго дня, Хабр!
Многие неопытные разработчики не всегда знают и понимают, что же происходит за кулисами их кода. Сейчас речь пойдет об упаковке и распаковке значимых типов данных (по-русски это звучит ужасно, поэтому «boxing and unboxing value types»).
Под катом небольшой пример и измерение времени выполнения.
Что такое упаковка (boxing)?
Коротко. Есть значимые типы данных (value types) и ссылочные (reference types). Переменные значимых типов данных хранят само значение (спасибо, кэп!), переменные ссылочных типов данных — ссылку на участок в памяти, где хранится это значение.
```
int valType = 15;
```
Это значимый тип данных. Значение переменной **valType** будет храниться в стэке. Многие стандартные типы данных — значимые (int, byte, long, bool и т.д.).
Дальше если мы попробуем сделать вот так:
```
int valType = 15;
Object refType = valType;
```
И получим в результате переменную ссылочного типа (**refType**). Тут произойдет следующее: сначала в стэке появится значение переменной **valType** (значимый тип), потом в памяти будет создан контейнер для хранения значения этой переменной (в нашем случае контейнер для переменной типа **int**, то есть 4 байта под значение + sync block index (еще 4 байта)), а вот уже указатель на этот контейнер и будет храниться в нашей переменной ссылочного типа (**refType**). Этот процесс называется упаковка (boxing).
Подробности можно посмотреть [тут](http://msdn.microsoft.com/en-us/library/yz2be5wk.aspx), а лучше прочитать в книжке [Дж.Рихтера «CLR via C#»](http://www.amazon.com/CLR-via-C-Developer-Reference/dp/0735667454) (Глава 5).
Самое неприятное в этих операциях то, что они происходят неявно.
Например, мы хотим вывести число в консоль. Так:
```
Console.WriteLine(20);
```
Или вот так:
```
Console.WriteLine("{0}", 20);
```
В чем разница? Давайте посмотрим на результат компиляции в MSIL (сделать это можно утилитой [ILdasm.exe](http://msdn.microsoft.com/en-us/library/f7dy01k1(v=vs.110).aspx)):
```
// Это для вызова Console.WriteLine(20);
IL_0000: ldc.i4.s 20
IL_0002: call void [mscorlib]System.Console::WriteLine(int32)
// А это для вызова Console.WriteLine("{0}", 20);
IL_0007: ldstr "{0}"
IL_000c: ldc.i4.s 20
IL_000e: box [mscorlib]System.Int32
IL_0013: call void [mscorlib]System.Console::WriteLine(string,
object)
```
Во втором случае мы видим команду **box**, которая и выполняет упаковку.
Чтобы понять откуда она взялась, взглянем на сигнатуру метода **Console.WriteLine** и заметим, что их есть аж 18 штук.
В первом вызове используется такая сигнатура:
```
void WriteLine(int value);
```
Тут все просто — этот метод принимает значимый тип данных **int**, передаем мы значение типа **int**, происходит передача параметра по значению. Упаковка тут не нужна.
Во втором случае используется другая сигнатура:
```
void WriteLine(string format, object arg0);
```
С передачей форматной строки понятно: требуется строка — мы передаем строку. А с аргументом **arg0** чуть сложнее: метод просит от нас объект ссылочного типа данных **object**, а передаем мы в метод значение типа **int**. Вот тут и нужна упаковка. В результате чего в памяти создается контейнер для типа **int**, в него копируется значение 20, и указатель на этот контейнер попадает в аргумент **arg0**.
Теперь попробуем посчитать, сильно ли замедляют данные операции наш код.
Для этого я написал небольшой кусочек кода:
**Простынка кода**
```
static void Main()
{
// переменная значимого типа, неупакованная
var val = 15;
// переменная ссылочного типа, уже упакованная
Object obj = val;
// количество циклов - мильён =)
const int cycles = 1000000;
var str = "";
// временные результаты будем заносить в список
var results = new List();
// повторяем опыт 20 раз, чтобы получить более достоверное среднее значение
for (var j = 0; j < 20; j++)
{
// засекаем время
var start = DateTime.Now;
for (var i = 0; i < cycles; i++)
{
// создаем строку из 10 одинаковых чисел
// тут передаются уже упакованные значения
str = String.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}",
obj, obj, obj, obj, obj, obj, obj, obj, obj, obj);
}
// останавливаем таймер
var end = DateTime.Now;
// и получаем время выполнения цикла без операций упаковки (box)
var objResult = end.Subtract(start);
// снова засекаем время
start = DateTime.Now;
for (var i = 0; i < cycles; i++)
{
// делаем точно такую же строку
// но за этот вызов происходит 10 операций упаковки (box)
str = String.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}",
val, val, val, val, val, val, val, val, val, val);
}
// останавливаем таймер
end = DateTime.Now;
// и получаем время выполнения цикла, в котором было 10 миллионов операций упаковки
var valResult = end.Subtract(start);
// разницу во времени между двумя циклами аккуратно заносим в список
results.Add(valResult.Subtract(objResult));
}
// выводим список результатов
foreach (var timeDif in results)
{
Console.WriteLine(timeDif);
}
// и считаем среднюю разницу
Console.WriteLine();
Console.Write("Milliseconds need for 10KK boxing operations: ");
Console.WriteLine(results.Aggregate(TimeSpan.Zero, (sum, current) => sum.Add(current)).TotalMilliseconds / results.Count);
}
```
Результат выполнения я получил следующий (процессор Intel Core i5 750 2.67GHz, 4 ядра, выполнялось на одном):
```
00:00:00.0600060
00:00:00.0770077
00:00:00.0570057
00:00:00.0710071
00:00:00.0680068
00:00:00.0650065
00:00:00.0530053
00:00:00.0740074
00:00:00.0570057
00:00:00.0580058
00:00:00.0590059
00:00:00.0500050
00:00:00.0550055
00:00:00.0720072
00:00:00.0800080
00:00:00.0640064
00:00:00.0640064
00:00:00.0670067
00:00:00.0660066
00:00:00.0590059
Milliseconds need for 10KK boxing operations: 63,80638
```
Итого в среднем почти **64мс** на **10млн.** операций упаковки.
#### Вывод
В качестве вывода хочу сказать, что все вышеизложенное вовсе не повод параноидально выискивать дизассемблером boxing'и в своем коде и добиваться лишнего миллиметра в секунду на скорости сто километров в час. Нет, конечно, это полный бред. Но понимать, что на самом деле происходит в вашем коде, важно. И в какой-то момент лишняя операция в цикле, выполняемом миллиарды раз, может стать критичной.
**UPD!** В комментариях пользователь [exmachine](http://habrahabr.ru/users/exmachine/) подсказывает, что я не совсем корректно проводил измерения. Вот результаты с учетом поправок:
**Результаты**
```
Cache warming results:
00:00:00.0505219
00:00:00.0491484
00:00:00.0527804
00:00:00.0586028
00:00:00.0595744
00:00:00.0573599
00:00:00.0678498
00:00:00.0560197
00:00:00.0591139
00:00:00.0382205
00:00:00.0602378
00:00:00.0862110
00:00:00.0632895
00:00:00.0584091
00:00:00.0556713
00:00:00.0572194
00:00:00.0544349
00:00:00.0750407
00:00:00.0579586
00:00:00.0561487
Test results:
00:00:00.0640218
00:00:00.0558972
00:00:00.0612732
00:00:00.0560300
00:00:00.0547193
00:00:00.0556158
00:00:00.0558210
00:00:00.0554421
00:00:00.0632168
00:00:00.0611355
00:00:00.0539173
00:00:00.0594863
00:00:00.0549896
00:00:00.0585462
00:00:00.0598485
00:00:00.0586522
00:00:00.0560457
00:00:00.0568806
00:00:00.0784523
00:00:00.0521756
Milliseconds need for 10KK boxing operations: 58,60835
```
**UPD2!** Пользователь [mstyura](http://habrahabr.ru/users/mstyura/) напомнил, что ранее на Хабре подобный вопрос уже [освещался](http://habrahabr.ru/post/70217/). Советую заглянуть и туда для дополнительной информации. | https://habr.com/ru/post/210108/ | null | ru | null |
# Kaboom: необычный сапёр
*В детстве я три раза в неделю по часу-полтора сидел на работе у отца. Меня пускали за компьютер, где из развлечений был лишь сапёр и Paint. Рисовать мне быстро надоедало, зато желание открыть всё поле и не взорваться мотивировало искать новые и новые способы прохождения этой игры. Спустя много лет я случайно наткнулся на интересную статью про клона сапёра, и не мог пройти мимо. Предлагаю и вам ознакомиться с ней. Это история о разработке Kaboom, клона легендарной игры Сапёр с собственной изюминкой.*
«Сапёр» (Minesweeper) появился довольно давно по меркам компьютерной игры. Но мне кажется, что большинство людей помнят игры, которые входили в состав ранних версий Windows. Я никогда не был хорош в «Сапёре», но время от времени поигрывал в неё. Некоторые люди играют [более серьёзно](http://www.minesweeper.info/wiki/Strategy). А тем, кто хочет поднять себе настроение, рекомендую посмотреть [Minesweeper — The Movie](https://www.youtube.com/watch?v=LHY8NKj3RKs).
Идея
----
Недавно у меня возникла идея: а что если вам придется играть в «Сапёр» против «поумневшего» компьютера?
Обычно расположение мин определяется в начале игры (но тут есть несколько хитростей — например, чтобы вы не могли проиграть с первого клика). Но что, если бы местонахождение мин не было определено заранее и игре можно было бы выбирать место расположения мин после начала игры?
Это было бы довольно жестоко: если вы кликаете на квадрат, который может содержать мину, он всегда будет содержать её! Таким образом, вы должны заранее доказать, что квадрат безопасен.
*На изображении выше в клетках, помеченных точкой, гарантированно нет мин, а клетки, отмеченные восклицательным знаком, гарантированно содержат одну. Знаки вопроса означают неопределённость: возможно, если вы откроете больше клеток, то сможете вычислить, спрятана там мина или нет*
С другой стороны, бывают ситуации, когда вам приходится угадывать:
В одной из нижних клеток есть мина. Но в какой именно, понять невозможно. Вы должны выбрать одну из них. Но согласно тому условию, о котором я только что говорил, это означало бы верную смерть! Я хотел, чтобы игра была жестокой, но теперь она заведомо проигрышная.
Поэтому я немного изменю идею. Угадывать можно, но только если не осталось безопасных клеток. Таким образом, игра будет жестокой, но честной.
Другими словами:
* Если вы кликаете на гарантированно безопасную клетку, она будет пустой.
* Если вы кликаете на гарантированно заминированную клетку, на ней будет мина, и вы взорвётесь.
* Если вы кликаете на клетку с неопределённостью, то:
1. Если на доске есть безопасные клетки, вы будете наказаны за игру в угадайку, в этой клетке обязательно будет мина.
2. Если безопасных клеток нет, то угадывание разрешено, и эта клетка может оказаться пустой.
Мины на границе
---------------
Как реализовать такую игру? Я мог бы попытаться вычислить все возможные поля, но это нереально: даже маленькое поле 10х10 означает 2 ^ 100 возможностей. Выбор только тех, которые содержат ровно N мин, не помогает.
К счастью, мне не нужно волноваться обо всём поле. Мы ничего не знаем о минах, не прилегающих к меткам. Меня интересуют только те, которые на границе, остальные могут быть определены совершенно случайно.
Затем я могу вычислить все варианты расположения мин на границе в соответствии с метками. [Поиск с возвратом](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D1%81_%D0%B2%D0%BE%D0%B7%D0%B2%D1%80%D0%B0%D1%82%D0%BE%D0%BC) (бэктрекинг) — хорошая техника, которая позволяет перебирать все комбинации, но также быстро отступать, как только мы определим, что ветвь вычисления невозможна.
*Выше показано два возможных расположения мин на границе. Объединяя их, мы поймём, какие клетки гарантированно будут пустыми или заминированными.*
Мне также нужно отслеживать общее количество мин. Таким образом, расположение действительно похоже на «5 мин на границе, 5 мин снаружи». Это важно, потому что иначе я мог бы создать слишком много мин на границе (или слишком мало!)
Итак, у меня есть все варианты. Что происходит, когда игрок решает открыть клетку?
* Выберите случайный вариант (тот, который удовлетворяет «жестоким, но справедливым» правилам). Это определит расположение мин на границе.
* Случайным образом разбросайте оставшиеся вне границы.
* Если в выбранной клетке есть мина, игра окончена.
* В противном случае:
1. Определить новую метку для выявленной клетки
2. Выявить дополнительные клетки, если это будет 0
3. Забудьте про игру в угадайку, которую мы обсудили ранее! Отныне только метки будут подсказывать вам путь.
Это очень неэффективно
----------------------
Для небольших полей это нормально. Обычно есть только несколько возможных комбинаций… погодите, что это?
О, нет!
Каким-то образом мне удалось разблокировать 18 миллионов возможных минных расположений. Мой Firefox пожирает 12 гигабайт памяти, а раскрытие клетки занимает полминуты. Очевидно, мне нужен лучший алгоритм.
Кто-то может заметить, что «Сапёр» является [NP-полной игрой](https://ru.wikipedia.org/wiki/NP-%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0), и поэтому не удастся избежать экспоненциально возрастающего времени. И в общем случае это верно – будут позиции, на вычисления которых уйдет много времени. Но для небольшой площади это работает.
Мне не нужно запоминать все комбинации. Мне даже не нужно вычислять все комбинации. Всё что требуется, это способ:
* проверить, является ли клетка безопасной, опасной или неопределенной,
* найти любую действительную возможность (возможно, с дополнительным требованием, чтобы данная клетка была пустой или заполненной).
Поиск решателя
--------------
Вместо того, чтобы самому заниматься перебором вариантов, я собираюсь использовать [SAT-решатель](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8_%D0%B1%D1%83%D0%BB%D0%B5%D0%B2%D1%8B%D1%85_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB). Это инструменты, которые принимают формулу, состоящую из логических переменных, и ищут набор значений, которые сделали бы формулу истинной. Такой себе, но вполне действующий метод для нашей задачи.
Более мощный класс программного обеспечения — это [SMT-решатели](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB_%D0%B2_%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F%D1%85), которые работают с более широким набором значений и формул, таких как логика первого порядка (квантификаторы), массивы, целые числа и так далее. Это поможет, по крайней мере, определить некоторые уравнения для целых чисел. Но мне требуется что-то, работающее в браузере. Людям удалось портировать некоторые сложные инструменты вроде [Z3Prover](https://github.com/Z3Prover/z3), в браузер, но версия WebAssembly весит [17 МБ](https://people.csail.mit.edu/cpitcla/z3.wasm/z3.html), и это чересчур.
Я нашел [MiniSat](http://minisat.se/), небольшой SAT-решатель, который был скомпилирован для Javascript Джоэлем Галенсоном. [Скомпилированный файл](https://jgalenson.github.io/research.js/demos/minisat.js) занимает всего 200 килобайт, поэтому я использую его.
Формулы CNF
-----------
Решатели SAT работают с формулами конъюнктивной нормальной формы ([CNF](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%8A%D1%8E%D0%BD%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0)). Формулой CNF является «an AND of ORs», например:
`(a | ~ b | ~ c) & (c | d ~ e) & f`
Вы можете преобразовать любую формулу логики высказываний (variables, and, or, not, implication) в CNF, так что это что-то вроде универсального формата.
Как мы это используем? Допустим, у нас есть доска:
`? ? 1
2 ? 1`
Если я создам переменные для неизвестных клеток (по часовой стрелке: x1, x2, x3), они должны будут удовлетворять следующим уравнениям:
`х1 + х2 + х3 = 2
х2 + х3 = 1
х2 + х3 = 1 (как и в предыдущем)`
Но как выразить «сумма переменных равна 2» в CNF?
Я нашел способ, который, как я узнал позже, называется «биномиальное кодирование» и является самым простым кодированием. Вы должны рассмотреть все возможные подмножества переменных. Например, для `x1 + x2 + x3 = 2` нужны следующие формулы:
* Для каждого подмножества из 2-х переменных, по крайней мере, одна истинна. Это гарантирует, что сумма больше 1.
`(x1 | x2) & (x1 | x3) & (x2 | x3)`
* По крайней мере, одна переменная ложна. Это гарантирует, что сумма меньше 3.
`(~ x1 | ~ x2 | ~ x3)`
Для `x2 + x3 = 1` мне нужен аналогичный набор формул:
* По крайней мере, одна из переменных верна: `(x2 | x3)`
* По крайней мере, одна из переменных является ложной `(~ x2 | ~ x3)`.
Соединив это, я получу формулу CNF с 6 пунктами (частями). В стандартном формате DIMACS:
`p cnf 3 6
1 2 0
1 3 0
2 3 0
-1 -2 -3 0
2 3 0
-2 -3 0`
Все строки положения заканчиваются на 0, а отрицание помечается минусом. Если я подключу его к MiniSat (попробуйте сами), я получу:
`SAT 1 2 -3`
Это означает, что MiniSat нашел решение, где x1 и x2 истинны, а x3 ложны. Вот как будет выглядеть доска:
`! ! 1
2 . 1`
Вся программа немного сложнее: это всего лишь одно решение, существует и другое. Поэтому, чтобы узнать, может ли x1, x2, x3 быть истинными (или ложными), нужно сделать больше запросов. Мне нужно спросить: «Учитывая приведенную выше формулу, а также x1, выполнимо ли это? Как насчет приведенной выше формулы, а также ~ x1»?
Кодировка означает, что мне нужно найти все возможные комбинации (например, все подмножества из 3) набора переменных. Однако для данного уравнения будет только до 8 переменных, поэтому формула обычно достаточно мала, чтобы MiniSat мог быстро ее решить.
Отслеживание количества мин
---------------------------
К сожалению, это не полное решение! Мне всё ещё нужно отследить, сколько мин осталось. Некоторые комбинации невозможны, так как иначе вы можете создать больше мин, чем разрешено, и победить будет невозможно.
На самом деле, возможен и противоположный случай: если мин окажется слишком мало, игра закончится, ведь нечего будет расставлять.
Поэтому мне нужно указать в формуле SAT, что «количество мин составляет не менее X и не более Y». Сначала я думал, что смогу использовать трюк со всеми комбинациями. К сожалению, он не слишком хорошо работает с большими числами. Если есть, скажем, 20 клеток и 10 мин, то после подключения чисел к [биномиальному коэффициенту](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D0%B5) мы узнаем, что число комбинаций уже в 6 цифрах!
Так я узнал, что есть много других способов кодирования суммы переменных в формулу SAT. Вам необходимо создать схему, которая будет объединять отдельные переменные. Посмотрите, например, [этот ответ](https://cs.stackexchange.com/questions/6521/reduce-the-following-problem-to-sat/6522#6522) на StackExchange или [этот](https://cstheory.stackexchange.com/a/23777/10624).
В итоге я реализовал идею из статьи под названием «Эффективное кодирование CNF с булевыми ограничениями кардинальности», [написанную](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.458.7676&rep=rep1&type=pdf) Оливье Байо и Ясином Буфхадом. Мы видим дерево, которое рекурсивно добавляет унарные числа (или сортирует биты так, чтобы все были в начале):
В конце этой схемы вы получите отсортированный набор «выходных» переменных. Чтобы подтвердить, что сумма не меньше X, проверьте, что первые X получающихся переменных равны 1. Чтобы утверждать, что сумма не более Y, проверьте, что последние N — Y получающихся переменных равны 0.
Это намного лучше, чем использование всех возможных комбинаций, однако эта схема всё ещё нерациональна, поскольку генерирует предложения Ө (N ^ 2). Когда количество открытых клеток составляет около 100, игра становится вялой. Мы можем оптимизировать игру дальше.
Сокращение количества запросов
В ходе изучения вопроса я заметил, что могу сократить количество запросов к решателю. Я хотел определить статус всех клеток (то есть проверить, гарантированно ли они опасны, безопасны или нет). Я сделал это, используя простой цикл. Допустим, доска описывается формулой F:
* Решите для `F & ~ x1`, чтобы проверить, может ли x1 быть 0
* Решите для `F & x1`, чтобы проверить, может ли x1 быть 1
* Решите для `F & ~ x2` , чтобы проверить, может ли x2 быть 0
* Решите для `F & x2`, чтобы проверить, может ли x2 быть 1
* И так далее.
Что я заметил? Если я получу решение для F & ~ x1, оно также будет содержать значения всех других переменных. Это уже отвечает на многие другие вопросы: если решение содержит x2 = 0, мне не нужно спрашивать, может ли x2 быть 0, потому что я это уже знаю. Это позволяет мне сократить количество запросов примерно в 2-5 раз.
Кэширование
-----------
Это не решает проблему огромной формулы, сгенерированной «счетной» схемой. Как я уже говорил, количество предложений в порядке N ^ 2. На большой доске формула может составлять до 10 000 предположений.
К счастью, большую часть времени мы знаем точное значение многих клеток. Если клетка гарантированно пустая или гарантировано заполненная, значение никогда не изменится! Это означает, что мы можем кэшировать его и не включать в формулу SAT. Как только мы определим состояние клетки, нам больше не нужно будет снова включать его в расчет. Клетки будут использоваться до тех пор, пока они являются неопределенными.
Эта оптимизация слегка опасна: у нас больше нет формулы, подтверждающей правильность всей доски. Если всё остальное работает как запланировано, это не проблема, но может усложнить отслеживание ошибок.
Другой случай: игра за границей
-------------------------------
Разрешено ли вам нажимать в любом месте карты за пределами границы между открытой и неоткрытой зоной поля?
Изначально я думал, что это то же самое что угадывание: если нет безопасных клеток, вы можете просто щелкнуть в любом месте на поле. Но некоторые считают странным, что это гарантирует открытие пустой клетки.
Поэтому я изменил игру так, что клик за пределами границы всегда наказывается. За исключением начала игры, конечно, потому что тогда вся доска «снаружи».
Но оказывается, есть еще один вариант развития событий: что, если все пограничные поля смертельны?
`3 . .
. . .
. . .`
У вас нет выбора, кроме как раскрыть что-то ещё. Эта ситуация может сделать игру непроходимой с самого начала. Так что теперь есть ещё одно исключение. Вам разрешено играть за пределами границ, если:
* Поле не открыто
* Заминированные клетки могут находится на границе (щелчок снаружи должен быть безопасным), или
* Во всех клетках на границе обязательно должны быть бомбы (вы вынуждены кликать снаружи).
**Обновление**: изменение оказалось спорным, так как ограничение является несколько искусственным. Я добавил переключатель, который позволит/запретит играть с этими условиями.
Это всё
-------
Вы можете поиграть в Kaboom [здесь](https://pwmarcz.pl/kaboom/). Попробуйте включить режим отладки: он делает игру тривиальной, но хорошо показывает, как она работает.
Исходный код на [Github](https://github.com/pwmarcz/kaboom/). Он не очень красивый.
Вас также может заинтересовать [похожая игра](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/mines.html) от Саймона Тэтхэма, создателя PuTTY. Его версия имеет другой поворот: она всегда разрешима без догадок.
Играйте с умом!
**Что ещё полезного можно почитать в блоге [Cloud4Y](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)**
→ [Как «сломался» банк](https://habr.com/post/484644/)
→ [Неприкосновенность личной жизни? Нет, не слышали](https://habr.com/post/487044/)
→ [Великая теория снежинок](https://habr.com/post/483312/)
→ [Диагностика сетевых соединений на виртуальном роутере EDGE](https://habr.com/post/486726/)
→ [Устойчивые к CRISPR вирусы строят «убежища» для защиты геномов от ДНК-проникающих ферментов](https://habr.com/post/485636/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью! Пишем не чаще двух раз в неделю и только по делу. Напоминаем, что стартапы могут получить 1 000 000 р. от Cloud4Y. Условия и анкета для желающих — на нашем сайте: [bit.ly/2sj6dPK](https://bit.ly/2sj6dPK) | https://habr.com/ru/post/487052/ | null | ru | null |
# Как работает JS: технология Shadow DOM и веб-компоненты
**[Советуем почитать] Другие 19 частей цикла**Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Сегодня, в переводе 17 части материалов, посвящённых особенностям всего, что так или иначе связано с JavaScript, речь пойдёт о веб-компонентах и о различных стандартах, которые направлены на работу с ними. Особое внимание здесь будет уделено технологии Shadow DOM.
[](https://habr.com/company/ruvds/blog/415881/)
Обзор
-----
Веб-компоненты — это семейство API, предназначенных для описания новых элементов DOM, подходящих для повторного использования. Функционал таких элементов отделён от остального кода, их можно применять в веб-приложениях собственной разработки.
Существует четыре технологии, относящиеся к веб-компонентам:
* Shadow DOM (теневой DOM)
* HTML Templates (HTML-шаблоны)
* Custom Elements (пользовательские элементы)
* HTML Imports (HTML-импорт)
В этом материале мы поговорим о технологии Shadow DOM, которая разработана для создания приложений, основанных на компонентах. Она предлагает способы решения распространённых проблем веб-разработки, с которыми вы, возможно, уже сталкивались:
* Изоляция DOM: компонент обладает изолированным деревом DOM (это означает, что команда `document.querySelector()` не позволит обратиться к узлу в теневом DOM компонента). Кроме того, это упрощает систему CSS-селекторов в веб-приложениях, так как компоненты DOM изолированы, что даёт разработчику возможность использовать одни и те же универсальные идентификаторы и имена классов в различных компонентах, не беспокоясь о возможных конфликтах имён.
* Изоляция CSS: CSS-правила, описанные внутри теневого DOM, ограничены им. Эти стили не покидают пределов элемента, они не смешиваются с другими стилями страницы.
* Композиция: разработка декларативного API для компонентов, основанного на разметке.
Технология Shadow DOM
---------------------
Тут предполагается, что вы уже знакомы с концепцией DOM и с соответствующими API. Если это не так — можете почитать [этот](https://developer.mozilla.org/ru/docs/DOM/DOM_Reference/%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) материал.
Shadow DOM — это, в целом, то же самое, что и обычный DOM, но с двумя отличиями:
* Первое заключается в том, как Shadow DOM создают и используют, в частности, речь идёт об отношении Shadow DOM к остальным частям страницы.
* Второе заключается в поведении Shadow DOM по отношению к странице.
При работе с DOM создаются узлы DOM, которые присоединяются, в качестве дочерних элементов, к другим элементам страницы. В случае с технологией Shadow DOM создают изолированное дерево DOM, которое присоединяется к элементу, но оно отделено от его обычных дочерних элементов.
Это изолированное поддерево называют shadow tree (теневое дерево). Элемент, к которому присоединено такое дерево, называется shadow host (теневой хост-элемент). Всё, что добавляется в теневое поддерево DOM, оказывается локальным для элемента, к которому оно присоединено, в том числе — стили, описываемые с помощью тегов `</code>. Именно так в рамках технологии Shadow DOM обеспечивается изоляция CSS.<br/>
<br/>
<h2><font color="#3AC1EF">Создание Shadow DOM</font></h2><br/>
Shadow root (теневой корневой элемент) — это фрагмент документа, который присоединяется к хост-элементу. Элемент обзаводится теневым DOM тогда, когда к нему присоединяют теневой корневой элемент. Для того, чтобы создать для некоего элемента теневой DOM, нужно воспользоваться командой вида <code>element.attachShadow()</code>:<br/>
<br/>
<pre><code>var header = document.createElement('header');
var shadowRoot = header.attachShadow({mode: 'open'});
shadowRoot.appendChild(document.createElement('<p> Shadow DOM </p>');</code></pre><br/>
Надо отметить, что в <a href="http://w3c.github.io/webcomponents/spec/shadow/#h-methods">спецификации</a> Shadow DOM имеется список элементов, к которым нельзя подключать теневые поддеревья DOM.<br/>
<br/>
<h2><font color="#3AC1EF">Композиция в Shadow DOM</font></h2><br/>
Композиция — это одна из важнейших возможностей Shadow DOM, это способ создания веб-приложений, который применяется в процессе написания HTML-кода. В ходе этого процесса программист комбинирует различные строительные блоки (элементы), из которых состоит страница, вкладывая их, при необходимости, друг в друга. Например, это такие элементы, как <code><div></code>, <code><header></code>, <code><form></code>, и другие, используемые для создания интерфейсов веб-приложений, в том числе, выступающие в роли контейнеров для других элементов.<br/>
<br/>
Композиция определяет возможности элементов, таких, как <code><select></code>, <code><form></code>, <code><video></code>, по включению в их состав других HTML-элементов в качестве дочерних, и возможности организации особого поведения таких конструкций, состоящих из разных элементов.<br/>
<br/>
Например, элемент <code><select></code> имеет средства для рендеринга элементов <code><option></code> в виде выпадающего списка с заранее заданным содержимым элементов такого списка.<br/>
<br/>
Рассмотрим некоторые возможности Shadow DOM применяемые при композиции элементов.<br/>
<br/>
<h2><font color="#3AC1EF">Light DOM</font></h2><br/>
Light DOM — это разметка, создаваемая пользователем вашего компонента. Этот DOM находится за пределами теневого DOM компонента и представляет собой дочерний элемент компонента. Представьте себе, что вы создали пользовательский компонент, называемый <code><better-button></code>, который расширяет возможности стандартного HTML-элемента <code><button></code>, и пользователю нужно добавить в этот новый элемент изображение и какой-то текст. Вот как это выглядит:<br/>
<br/>
<pre><code><extended-button>
<!-- теги img и span - это Light DOM элемента extended-button -->
<img align="center" src="boot.png" slot="image">
<span>Launch</span>
</extended-button></code></pre><br/>
Элемент <code><extended-button></code> — это пользовательский компонент, описанный программистом самостоятельно, а HTML-код внутри этого компонента — это его Light DOM — то, что добавил в него пользователь этого компонента.<br/>
<br/>
Теневой DOM в этом примере — это компонент <code><extended-button></code>. Это — локальная объектная модель компонента, которая описывает его внутреннюю структуру, изолированный от внешнего мира CSS, и инкапсулирует детали реализации компонента.<br/>
<br/>
<h2><font color="#3AC1EF">Flattened DOM</font></h2><br/>
Дерево Flattened DOM представляет собой то, как браузер выводит компонент на экран, объединяя Light DOM и Shadow DOM. Именно такое дерево DOM можно видеть в инструментах разработчика, и именно оно выводится на страницу. Выглядеть это может примерно так:<br/>
<br/>
<pre><code><extended-button>
#shadow-root
<style>…
Launch`
Шаблоны
-------
Если вам приходится постоянно применять одни и те же структуры в HTML-разметке веб-страниц, полезно будет воспользоваться неким шаблоном вместо того, чтобы снова и снова писать один и тот же код. Подобное было возможно и раньше, но теперь всё значительно упростилось благодаря появлению HTML-тега , который пользуется отличной поддержкой современных браузеров. Этот элемент и его содержимое не выводится в DOM, но с ним можно работать из JavaScript. Рассмотрим простой пример:
```
Paragraph content.
```
Если включить такую конструкцию в состав HTML-разметки страницы, содержимое описываемого ей тега не появится на экране до тех пор, пока не будет явным образом присоединено к DOM документа. Например, это может выглядеть так:
```
var template = document.getElementById('my-paragraph');
var templateContent = template.content;
document.body.appendChild(templateContent);
```
Существуют и другие средства, позволяющие достичь того же эффекта, но, как уже было сказано, шаблоны — очень удобный стандартный инструмент, пользующийся хорошей поддержкой браузеров.
*Поддержка HTML-шаблонов современными браузерами*
Шаблоны полезны и сами по себе, но в полной мере их возможности раскрываются при использовании с пользовательскими элементами. Пользовательские элементы — это тема для отдельного материала, а сейчас, для понимания происходящего, достаточно учитывать то, что API браузеров `customElement` позволяет программисту описывать собственные HTML-теги и задавать то, как элементы, создаваемые с помощью этих тегов, будут выглядеть на экране.
Определим веб-компонент, который использует наш шаблон в качестве содержимого для своего теневого DOM. Назовём этот новый элемент :
```
customElements.define('my-paragraph',
class extends HTMLElement {
constructor() {
super();
let template = document.getElementById('my-paragraph');
let templateContent = template.content;
const shadowRoot = this.attachShadow({mode: 'open'}).appendChild(templateContent.cloneNode(true));
}
});
```
Самое важное, на что тут надо обратить внимание — это то, что мы присоединили клон содержимого шаблона, сделанный с помощью метода [Node.cloneNode()](https://developer.mozilla.org/en-US/docs/Web/API/Node/cloneNode), к теневому корню.
Так как мы присоединяем содержимое шаблона к теневому DOM, мы можем включить в шаблон некую информацию о стилизации, в элементе [</a>, которая затем будет инкапсулирована в пользовательский элемент. Вся эта схема не будет работать так, как ожидается, если вместо Shadow DOM работать с обычным DOM.<br/>
<br/>
Например, шаблон можно доработать следующим образом, включив в него сведения о стилях:<br/>
<br/>
<pre><code><template id="my-paragraph">
<style>
p {
color: white;
background-color: #666;
padding: 5px;
}
Paragraph content.
Теперь описанный нами пользовательский элемент можно использовать на обычных веб-страницах следующим образом:
Слоты
-----
У HTML-шаблонов есть несколько недостатков, главный из них заключается в том, что шаблоны содержат статическую разметку, что не позволяет, например, выводить с их помощью содержимое неких переменных для того, чтобы работать с ними так же, как работают со стандартными HTML-шаблонами. Здесь в дело вступает тег .
Слоты можно воспринимать как местозаполнители, которые позволяют включать в шаблон собственный HTML-код. Это позволяет создавать универсальные HTML-шаблоны, а затем делать их настраиваемыми, добавляя в них слоты.
Взглянем на то, как будет выглядеть вышеописанный шаблон с использованием тега :
```
Default text
```
Если содержимое слота не задано когда элемент включается в разметку, или если браузер не поддерживает работу со слотами, элемент будет включать в себя лишь стандартное содержимое `Default text`.
Для того чтобы задать содержимое слота, нужно включить в элемент HTML-код с атрибутом `slot`, значение которого эквивалентно имени слота, в который нужно поместить этот код.
Как и ранее, тут может быть всё, что угодно. Например:
```
Let's have some different text!
```
Элементы, которые можно помещать в слоты, называются [Slotable](https://developer.mozilla.org/en-US/docs/Web/API/Slotable)-элементами.
Обратите внимание на то, что в предыдущем примере мы добавили в слот элемент , он является так называемым slotted-элементом. У него есть атрибут `slot`, которому присвоено значение `my-text`, то есть — то же самое значение, которое использовано в атрибуте `name` слота, описанного в шаблоне.
После обработки вышеописанной разметки браузером будет создано следующее дерево Flattened DOM:
```
#shadow-root
Let's have some different text!
```
Обратите внимание на элемент `#shadow-root`. Это — всего лишь индикатор существования Shadow DOM.
Стилизация
----------
Компоненты, которые используют технологию Shadow DOM, можно стилизовать на общих основаниях, они могут определять собственные стили, или предоставлять хуки в форме [пользовательских свойств CSS](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables), которые позволяют пользователям компонентов переопределять стили, заданные по умолчанию.
### ▍Стили, описываемые в компонентах
Изоляция CSS — это одно из самых замечательных свойств технологии Shadow DOM. А именно, речь идёт о следующем:
* CSS-селекторы страницы, на которой размещён соответствующий компонент, не влияют на то, что имеется у него внутри.
* Стили, описанные внутри компонента, не оказывают воздействия на страницу. Они изолированы в хост-элементе.
CSS-селекторы, использованные внутри теневого DOM, применяются к содержимому компонента локально. На практике это означает возможность многократного использования одних и тех же идентификаторов и имён классов в разных компонентах и отсутствие необходимости беспокоиться о конфликтах имён. Простые CSS-селекторы означают и более высокую производительность решений, в которых они используются.
Взглянем на элемент `#shadow-root`, который определяет некоторые стили:
```
#shadow-root
#container {
background: white;
}
#container-items {
display: inline-flex;
}
```
Все вышеописанные стили являются локальными для `#shadow-root`.
Кроме того, для включения в `#shadow-root` внешних таблиц стилей можно использовать тег . Такие стили тоже будут локальными.
### ▍Псевдокласс :host
Псевдокласс `:host` позволяет обращаться к элементу, содержащему теневое дерево DOM и стилизовать этот элемент:
```
:host {
display: block; /\* по умолчанию у пользовательских элементов это display: inline \*/
}
```
Пользуясь псевдоклассом `:host` следует помнить о том, что правила родительской страницы имеют более высокий приоритет, чем те, которые заданы в элементе с использованием этого псевдокласса. Это позволяет пользователям переопределять стили хост-компонента, заданные в нём, извне. Кроме того, псевдокласс `:host` работает лишь в контексте теневого корневого элемента, за пределами теневого дерева DOM пользоваться им нельзя.
Функциональная форма псевдокласса, `:host()`, позволяет обращаться к хост-элементу, если он соответствует заданному элементу . Это — отличный способ, позволяющий компонентам инкапсулировать поведение, которое реагирует на действия пользователя или на изменение состояния компонента, и позволяет стилизовать внутренние узлы, основываясь на хост-компоненте:
```
:host {
opacity: 0.4;
}
:host(:hover) {
opacity: 1;
}
:host([disabled]) { /\* стилизация при условии наличия у хост-элемента атрибута disabled. \*/
background: grey;
pointer-events: none;
opacity: 0.4;
}
:host(.pink) > #tabs {
color: pink; /\* задаёт цвет внутреннего узла #tabs если у хост-элемента есть class="pink". \*/
}
```
### ▍Темы и элементы с псевдоклассом :host-context()
Псевдокласс `:host-context()` соответствует хост-элементу, если он или любые его предки соответствуют заданному элементу .
Обычный вариант использования этой возможности заключается в стилизации элементов с помощью тем. Например, часто темы применяют, назначая соответствующий класс тегам или :
```
…
```
Псевдокласс `:host-context(.lightheme)` будет применяться к в том случае, если этот элемент является потомком `.lightteme`:
```
:host-context(.lightheme) {
color: black;
background: white;
}
```
Конструкция `:host-context()` может быть полезной для применения тем, но для этой цели лучше использовать хуки с применением [пользовательских свойств CSS](https://developers.google.com/web/fundamentals/web-components/shadowdom#stylehooks).
### ▍Стилизация хост-элемента компонента извне
Хост-элемент компонента можно стилизовать извне, используя имя его тега в качестве селектора:
```
custom-container {
color: red;
}
```
Внешние стили имеют более высокий приоритет, чем стили, определённые в теневом DOM.
Предположим, пользователь создал следующий селектор:
```
custom-container {
width: 500px;
}
```
Он переопределит правило, заданное в самом компоненте:
```
:host {
width: 300px;
}
```
Используя этот подход можно стилизовать лишь сам компонент. Как стилизовать внутренние структуры компонента? Для этой цели используются пользовательские свойства CSS.
### ▍Создание хуков стилей с использованием пользовательских свойств CSS
Пользователи могут настраивать стили внутренних структур компонентов если автор компонента предоставляет им хуки стилей, применяя [пользовательские свойства CSS](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables).
В основе этого подхода лежит механизм, похожий на тот, которым пользуются при работе с тегами , но он, в данном случае, применяется к стилям.
Рассмотрим пример:
```
custom-container {
margin-bottom: 60px;
- custom-container-bg: black;
}
…
```
Вот что находится внутри теневого дерева DOM:
```
:host([background]) {
background: var( - custom-container-bg, #CECECE);
border-radius: 10px;
padding: 10px;
}
```
В данном случае компонент, в качестве цвета фона, использует чёрный, так как именно его задал пользователь. В противном случае цветом фона будет `#CECECE`.
В роли автора компонента вы ответственны за то, чтобы сообщить его пользователям о том, какие именно пользовательские CSS-свойства они могут использовать. Считайте это частью открытого интерфейса вашего компонента.
API JavaScript для работы со слотами
------------------------------------
API Shadow DOM предоставляет возможности работы со слотами.
### ▍Событие slotchange
Событие `slotchange` вызывается при изменении узлов, помещённых в слот. Например, если пользователь добавляет дочерние узлы в Light DOM или удаляет их из него:
```
var slot = this.shadowRoot.querySelector('#some_slot');
slot.addEventListener('slotchange', function(e) {
console.log('Light DOM change');
});
```
Для отслеживания других типов изменений в Light DOM, можно, в конструкторе элемента, использовать `MutationObserver`. Подробнее об этом читайте [здесь](https://habr.com/company/ruvds/blog/351256/).
### ▍Метод assignedNodes()
Метод `assignedNodes()` может оказаться полезным в том случае, если нужно узнать о том, какие элементы связаны со слотом. Вызов метода `slot.assignedNodes()` позволяет узнать о том, какие именно элементы выводятся средствами слота. Использование опции `{flatten: true}` позволяет получить стандартное содержимое слота (выводимое в том случае, если к нему не было присоединено никаких узлов).
Рассмотрим пример:
```
Default content
```
Представим, что этот слот размещён в компоненте .
Взглянем на различные варианты использования этого компонента, и на то, что будет выдано при вызове метода `assignedNodes()`.
В первом случае мы добавляем в слот собственное содержимое:
```
container text
```
В данном случае вызов `assignedNodes()` вернёт `[ container text ]`. Обратите внимание на то, что это значение является массивом узлов.
Во втором случае мы не заполняем слот собственным содержимым:
```
```
Вызов `assignedNodes()` вернёт пустой массив — `[]`.
Если, однако, передать этому методу параметр `{flatten: true}`, то его вызов для того же самого элемента выдаст его содержимое, выводимое по умолчанию: `[Default content
]`.
Кроме того, для того, чтобы получить доступ к элементу внутри слота, вы можете вызвать `assignedNodes()`, что позволить узнать о том, какому из слотов компонента назначен ваш элемент.
Модель событий
--------------
Поговорим о том, что происходит при всплытии события, возникшего в теневом дереве DOM. Цель события задаётся с учётом инкапсуляции, поддерживаемой технологией Shadow DOM. Когда событие перенаправляется, это выглядит так, как будто оно исходит от самого компонента, а не от его внутреннего элемента, который находится в теневом дереве DOM и является частью этого компонента.
Вот список событий, которые передаются из теневого дерева DOM (некоторым событиям такое поведение не свойственно):
* События фокуса (Focus Events): `blur`, `focus`, `focusin`, `focusout`.
* События мыши (Mouse Event)s: `click`, `dblclick`, `mousedown`, `mouseenter`, `mousemove` и другие.
* События колеса мыши (Wheel Events): `wheel`.
* События ввода (Input Events): `beforeinput`, `input`.
* События клавиатуры (Keyboard Events): `keydown`, `keyup`.
* События композиции (Composition Events): `compositionstart`, `compositionupdate`, `compositionend`.
* События перетаскивания (Drag Events): `dragstart`, `drag`, `dragend`, `drop`, и так далее.
Пользовательские события
------------------------
Пользовательские события по умолчанию не покидают пределов теневого дерева DOM. Если вы хотите вызвать событие, и требуется, чтобы оно покинуло пределы Shadow DOM, нужно снабдить его параметрами `bubbles: true` и `composed: true`. Вот как выглядит вызов подобного события:
```
var container = this.shadowRoot.querySelector('#container');
container.dispatchEvent(new Event('containerchanged', {bubbles: true, composed: true}));
```
Поддержка Shadow DOM браузерами
-------------------------------
Для того чтобы узнать, поддерживает ли браузер технологию Shadow DOM, можно проверить наличие `attachShadow`:
```
const supportsShadowDOMV1 = !!HTMLElement.prototype.attachShadow;
```
Вот сведения о поддержке этой технологии различными браузерами.
*Поддержка технологии Shadow DOM в браузерах*
Итоги
-----
Теневое дерево DOM ведёт себя не так, как обычное дерево DOM. В частности, по словам автора данного материала, в библиотеке [SessionStack](https://www.sessionstack.com/) это выражается в усложнении процедуры отслеживания изменений DOM, сведения о которых нужны для воспроизведения того, что происходило со страницей. А именно, для отслеживания изменений используется `MutationObserver`. При этом теневое дерево DOM не вызывает события `MutationObserver` в глобальной области видимости, что приводит к необходимости использования особых подходов для работы с компонентами, использующими Shadow DOM.
Практика показывает, что всё больше современных веб-приложений используют Shadow DOM, что позволяет говорить о том, что эту технологию, вероятно, ждёт дальнейшее развитие и распространение.
**Уважаемые читатели!** Пользуетесь ли вы веб-компонентами, построенными на основе технологии Shadow DOM?
[](https://ruvds.com/ru-rub/#order)](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style) | https://habr.com/ru/post/415881/ | null | ru | null |
# Как общаются машины — протокол MQTT
В предыдущей статье мы разбирали [протокол Modbus](https://habr.com/ru/company/advantech/blog/450234/), являющийся стандартом де-факто в промышленности для M2M-взаимодействия. Разработанный в далеком 1979 году, он имеет ряд существенных недостатков, которые решает MQTT.
Протокол MQTT достаточно молод (стандартизирован только в 2016 году), но уже успел получить широкое распространение в промышленности и IoT. Он был специально разработан максимально компактным, для нестабильных интернет-каналов и маломощных устройств, и позволяет гарантированно доставлять сообщения в случае потери пакетов и обрывов связи.
Главные особенности протокола MQTT:
* **Компактный и легковесный** — минимальные накладные расходы на пересылку данных, для экономии трафика.
* **Устойчивость к потерям** — гарантированная доставка в условиях нестабильных сетевых подключений.
* **Асинхронный** — позволяет обслуживать большое количество устройств, и не зависит от сетевых задержек.
* **Поддержка QoS** — возможность управлять приоритетом сообщений и гарантировать доставку сообщения адресату.
* **Динамическая конфигурация** — не требует предварительно согласования полей и форматов данных, может конфигурироваться «на лету».
* **Работает за NAT** — клиенты могут находиться за NAT, только сервер (брокер) должен иметь реальный IP. Позволяет обойтись без VPN и пробрасывания портов.
* **Удобная адресация** — поля данных имеют текстовые названия, понятные для человека. Не нужно запоминать цифровые адреса и битовые смещения.
В статье мы сравним MQTT и Modbus, разберем структуру протокола, основные понятия, попробуем на примере поработать с облачным MQTT-брокером в условиях нестабильного интернет-подключения.
История протокола MQTT
----------------------
MQTT был разработан компанией IBM в 1999 году, и поначалу использовался внутри компании, для своих решений.
В ноябре 2011 IBM совместно с компанией Eurotech объявили об участии в рабочей группе Eclipse M2M и передаче кода MQTT в проект Eclipse Paho.
В 2013 году консорциум [OASIS](https://ru.wikipedia.org/wiki/OASIS) (Organization for the Advancement of Structured Information Standards) начинает процесс стандартизации протокола MQTT. До этого момента спецификация протокола была опубликована под бесплатной лицензией, и такие компании, как Eurotech (ранее известный как Arcom), уже используют протокол в своих продуктах.
В октябре 2014 г. OASIS публикует первый официальный стандарт протокола MQTT.
В 2016 г. протокол был стандартизирован Международной организацией по стандартизации ISO и получил номер ISO/IEC 20922.
С 2014 года интерес к протоколу начинает стремительно расти и, судя по графику Google Trends, на сегодняшний день превышает интерес к Modbus.
Сравнительный график Google Trends
Основные понятия
----------------
MQTT имеет клиент-серверную архитектуру. Обмен сообщениями происходит через центральный сервер, называемый брокером. В обычных условиях клиенты не могут общаться напрямую друг с другом, и весь обмен данными происходит через брокера.
Клиенты могут выступать в роли поставщиков данных (Publisher) и в роли получателей данных (Subscriber). В русском переводе эти термины часто переводят как издатель и подписчик, но, чтобы избежать путаницы, мы будем использовать только оригинальную терминологию.
В протоколе MQTT клиенты обмениваются данными друг с другом, через центральный узел
На прикладном уровне протокол работает поверх TCP/IP и может легко связывать удаленные объекты напрямую по интернету, без необходимости использования VPN-тоннелей. Достаточно, чтобы брокер имел реальный IP-адрес и все клиенты могли к нему подключиться. При этом, клиенты могут находится за NAT. Так как в протоколе MQTT подключение инициируют клиенты, пробрасывать порты для установки соединения не требуется, в то время как в Modbus/TCP подключение инициирует сервер (master), что требует прямой сетевой доступности.
Стандартный порт MQTT-брокера для входящих TCP-соединений — **1883**. При использовании защищенного SSL-подключения используется порт **8883**.
#### Broker
Брокер — это центральный узел MQTT, обеспечивающий взаимодействие клиентов. Обмен данными между клиентами происходит только через брокера. В качестве брокера может выступать серверное ПО или контроллер. В его задачи входит получение данных от клиентов, обработка и сохранение данных, доставка данных клиентам, и контроль за доставкой сообщений.
#### Publisher/Subscriber
Для понимания разницы между Publisher и Subscriber разберем простой пример: датчик влажности измеряет влажность в помещении, и если она опустилась ниже определенного уровня, включается увлажнитель воздуха.
В данном случае датчик влажности выступает в роли **Publisher**: его задача сводится только к публикации данных в сторону брокера. Увлажнитель воздуха выступает в роли **Subscriber**: он подписывается на обновления данных о влажности и получает от брокера актуальные данные, при этом увлажнитель может сам решать, в какой момент включать увлажнение.
В этой схеме MQTT-клиенты, то есть датчик и увлажнитель, не знают о существовании друг друга, и не взаимодействуют напрямую. Брокер может получать данные из разных источников, проводить над ними манипуляции, например, рассчитывать среднее значение от нескольких датчиков, и уже обработанные данные возвращать подписчику.
Publisher посылает данные брокеру, Subscriber подписывается на обновления этих данных
При этом, асинхронность протокола MQTT предусматривает, что датчик и увлажнитель могут быть онлайн в разное время, терять пакеты, и быть недоступны. Брокер позаботится о том, чтобы сохранить в памяти последние данные, полученные от датчика, и обеспечить их доставку на увлажнитель.
#### Topic
Для идентификации сущностей в MQTT используются топики, в русском переводе их еще называют каналами. Топики состоят из UTF8-символов, и имеют древовидную структуру, похожую на файловую систему в UNIX. Это удобный механизм, позволяющий называть сущности в человекопонятном виде.
Пример топиков в MQTT
```
# Датчик температуры на кухне
home/kitchen/temperature
# Датчик температуры в спальне
home/sleeping-room/temperature
# Датчик освещенности на улице
home/outdoor/light
```
Такой подход позволяет наглядно видеть, какие данные передаются, и удобно разрабатывать и отлаживать код, без необходимости запоминать цифровой адрес размещения данных, как это сделано в Modbus.
Топики также предусматривают wildcard-синтаксис, хорошо знакомый тем, кто работал с файловой системой UNIX. Wildcard может быть одноуровневым и многоуровневым.
Одноуровневый wildcard обозначается символом "**+**".
Например, чтобы получить данные с температурных датчиков во всех помещениях в доме, подписчику нужно подписаться на такой топик:
```
home/+/temperature
```
В результате он подпишется на получение данных с таких датчиков:
```
home/kitchen/temperature
home/sleeping-room/temperature
home/living-room/temperature
home/outdoor/temperature
```
Многоуровневый wildcard обозначается символом "**#**".
Пример получения данных со всех датчиков во всех комнатах в доме:
```
home/#
```
Подписка на такой топик позволит получать данные с таких датчиков:
```
home/kitchen/temperature
home/kitchen/humidity
home/kitchen/light
home/sleeping-room/temperature
home/sleeping-room/humidity
home/sleeping-room/light
....
```
### Идентификация клиентов
Для контроля доступа в MQTT предусмотрена аутентификация клиентов, в отличие от протокола Modbus, который не имеет такой функции. Для контроля доступа используются такие поля:
**ClientId** — (обязательное поле) уникальный идентификатор клиента. Должен быть уникальным для каждого клиента. Текущая версия стандарта MQTT 3.1.1 позволяет использовать пустое поле ClientId, если не требуется сохранение состояния подключения.
**Username** — (опциональное поле) логин для аутентификации, в формате UTF-8. Может быть не уникальным. Например, группа клиентов может авторизовываться с одним и тем же логином/паролем.
**Password** — (опциональное поле) может посылаться только вместе с полем Username, при этом Username может передаваться без поля Password. Максимум 65535 байт. Важно знать, что имя и пароль передаются в открытом виде, поэтому, если данные передаются по публичным сетям, необходимо использовать SSL для шифрования подключения.
### Структура пакета
Как уже говорилось выше, в протоколе MQTT подключение всегда инициируют клиенты, вне зависимости от того, являются ли они получателями (Subscriber) или поставщиками (Publisher) данных. Разберем пакет с установкой соединения, перехваченный с помощью программы Wireshark.
Пакет с опцией MQTT, переданный по нешифрованному каналу
В TCP заголовке видно, что пакет передан по порту 1883, то есть шифрование не используется, а значит в открытом виде доступны все данные, в том числе логин и пароль.
#### Заголовок
**Тип сообщения** — Connect (команда 0x0001), установка соединения с брокером. Основные команды: Connect, Disconnect, Publish, Subscribe, Unsubscribe. Есть также команды подтверждения получения, keep alive, и т.д.
**Флаг DUP** — означает, что сообщение передается повторно, используется только в типах сообщений PUBLISH, SUBSCRIBE, UNSUBSCRIBE, PUBREL, для случаев, когда брокер не получил подтверждения получения предыдущего сообщения.
**Уровень QoS** — флаг Quality of Service. Мы разберем эту тему подробнее дальше.
**Retain** — данные, опубликованные с флагом retain, сохраняются на брокере. При последующей подписке на этот топик, брокер сразу отправит сообщение с этим флагом. Используется только в сообщениях с типом Publish.
Использование на практике
-------------------------
Теперь, ознакомившись с теорией, попробуем поработать с MQTT на практике. Для этого будем использовать открытую программу [Mosquitto](https://mosquitto.org/), которая может работать как в режиме клиента, так и в режиме сервера (брокера). Работает на Windows, macOS, Linux. Программа очень удобна для отладки и изучения протокола MQTT, при этом также широко используется в промышленной эксплуатации. Мы будем использовать ее как клиент для отправки и получения данных с удаленного облачного брокера.
Множество облачных провайдеров предоставляют услуги MQTT-брокера, например [Microsoft Azure IoT Hub](https://azure.microsoft.com/en-us/services/iot-hub/), [Amazon AWS IoT](https://aws.amazon.com/iot/), и другие. В этом примере мы будем использовать сервис Cloudmqtt.com, так как у него самая простая регистрация, и бесплатного тарифа достаточно для обучения.
После регистрации, в личном кабинете доступны реквизиты для подключения к брокеру. Так как мы подключаемся к серверу через публичные сети интернета, разумно использовать SSL-порт, для шифрования трафика.
Реквизиты доступа к MQTT-брокеру в личном кабинете облачного провайдера
Гибкость протокола MQTT позволяет клиенту передавать данные, заранее не определенные на брокере. То есть нет необходимости предварительно создавать нужные топики, в которые сможет записать данные Publisher. Используя данные, полученные из личного кабинета, попробуем вручную составить запрос для публикации данных в топик *habr/test/random* и чтения из него.
**mosquitto\_sub** — утилита-клиент subscriber
**mosquitto\_pub** — утилита-клиент publisher
Для начала подключимся к брокеру как subscriber, и подпишемся на получение данных из топика
*habr/test/random*.
```
mosquitto_sub -d --capath /etc/ssl/certs/ --url mqtts://hwjspxxt:7oYugN7Fa5Aa@postman.cloudmqtt.com:27529/habr/test/random
Client mosq/zEPZz0glUiR4aEipZA sending CONNECT
Client mosq/zEPZz0glUiR4aEipZA received CONNACK (0)
Client mosq/zEPZz0glUiR4aEipZA sending SUBSCRIBE (Mid: 1, Topic: habr/test/random, QoS: 0, Options: 0x00)
Client mosq/zEPZz0glUiR4aEipZA received SUBACK
```
Видно, что подключение прошло успешно, и мы подписались на топик **habr/test/random**, и сейчас ожидаем данных в данном топике от брокера.
> Так как используется SSL-подключение, для проверки сертификата необходимо указать путь, по которому программа будет искать корневые сертификаты шифрования. Так как у сервиса в нашем примере используется сертификат, выданный доверенным удостоверяющим центром, то мы указываем путь к системному хранилищу корневых сертификатов: ***--capath /etc/ssl/certs/***
>
>
>
> В случае с самоподписанным сертификатом, необходимо указывать путь к нужному CA. Также важно учитывать разницу в формате URI для подключения по SSL — mqtt**s**://, и подключения без шифрования — mqtt://. В случае ошибки проверки сертификата программа завершается без сообщения об ошибке. Для более подробного вывода можно использовать ключ --debug
Теперь попробуем опубликовать данные в топик, не прерывая первую программу.
```
mosquitto_pub -d --capath /etc/ssl/certs/ --url mqtt://hwjspxxt:7oYugN7Fa5Aa@postman.cloudmqtt.com:27529/habr/test/random -m "Привет хабр!"
Client mosq/sWjh9gf8DRASrRZjk6 sending CONNECT
Client mosq/sWjh9gf8DRASrRZjk6 received CONNACK (0)
Client mosq/sWjh9gf8DRASrRZjk6 sending PUBLISH (d0, q0, r0, m1, 'habr/test/random', ... (22 bytes))
Client mosq/sWjh9gf8DRASrRZjk6 sending DISCONNECT
```
Видно, что данные были успешно приняты сервером и опубликованы в нужный топик. Одновременно с этим, в первом окне, в котором запущена программа mosquitto\_sub, мы видим, как сообщение было получено, при этом даже юникод работает, видно сообщение на руском языке.
```
Client mosq/zEPZz0glUiR4aEipZA received PUBLISH (d0, q0, r0, m0, 'habr/test/random', ... (22 bytes))
Привет хабр!
```
QoS и гарантия доставки
-----------------------
Однако пересылкой сообщения в реальном времени мало кого удивишь, ведь то же самое можно сделать даже банальной утилитой **nc**. Поэтому попробуем имитировать нестабильное соединение между подписчиком и отправителем. Представим, что оба клиента работают через GPRS, с огромной потерей пакетов, и даже успешная установка TCP-соединения происходит редко, при этом нужно, чтобы подписчик гарантированно получил сообщение отправителя. В данном случае на помощь приходят опции QoS.
По умолчанию для сообщений установлен флаг **QoS в значение 0**, что значит «Fire and forget»: Publisher публикует сообщение на брокере, но при этом не требует, чтобы сообщение было гарантированно доставлено подписчику. Это подходит для данных, потеря которых не критична, например, для регулярных измерений влажности или температуры.
**QoS 1: At least once – хотя бы один**. Этот флаг означает, что пока Publisher не получит подтверждения доставки подписчику, данная публикация будет посылаться брокеру, и далее подписчику. Таким образом, подписчик должен получить данное сообщение как минимум один раз.
**QoS 2: Exactly once – гарантированно один**. Флаг QoS, обеспечивающий высшую гарантию доставки сообщений за счет использования дополнительных процедур подтверждения и завершения публикации (PUBREC, PUBREL, PUBCOMP). Применим для ситуаций, когда нужно исключить любые потери и дублирование данных от датчиков. Например, когда от полученного сообщения срабатывает сигнализация, вызов экстренных служб.
Для симуляции плохой связи отключим оба клиента и попробуем отправить сообщение с наивысшим приоритетом QoS, а также добавим опцию Retain, чтобы отправленное сообщение сохранилось на брокере.
```
mosquitto_pub --retain --qos 2 -d --capath /etc/ssl/certs/ --url mqtt://hwjspxxt:7oYugN7Fa5Aa@postman.cloudmqtt.com:27529/habr/test/random -m "Очень важный привет!"
Client mosq/Xwhua3GAyyY9mMd05V sending CONNECT
Client mosq/Xwhua3GAyyY9mMd05V received CONNACK (0)
Client mosq/Xwhua3GAyyY9mMd05V sending PUBLISH (d0, q2, r1, m1, 'habr/test/random', ... (37 bytes))
Client mosq/Xwhua3GAyyY9mMd05V received PUBREC (Mid: 1)
Client mosq/Xwhua3GAyyY9mMd05V sending PUBREL (m1)
Client mosq/Xwhua3GAyyY9mMd05V received PUBCOMP (Mid: 1, RC:0)
Client mosq/Xwhua3GAyyY9mMd05V sending DISCONNECT
```
Теперь, спустя время, наш получатель наконец смог установить соединение с интернетом и подключился к брокеру:
```
mosquitto_sub -d --capath /etc/ssl/certs/ -d --url mqtts://hwjspxxt:7oYugN7Fa5Aa@postman.cloudmqtt.com:27529/habr/test/random
Client mosq/VAzcLVMB1MiWhYxoJS sending CONNECT
Client mosq/VAzcLVMB1MiWhYxoJS received CONNACK (0)
Client mosq/VAzcLVMB1MiWhYxoJS sending SUBSCRIBE (Mid: 1, Topic: habr/test/random, QoS: 0, Options: 0x00)
Client mosq/VAzcLVMB1MiWhYxoJS received SUBACK
Subscribed (mid: 1): 0
Client mosq/r6UwPnDvx8aNInpPF6 received PUBLISH (d0, q0, r1, m0, 'habr/test/random', ... (37 bytes))
Очень важный привет!
```
Заключение
----------
MQTT — современный продвинутый протокол, лишенный множества недостатков предшественников. Его гибкость позволяет добавлять клиентские устройства без настройки на брокере, что существенно экономит время. Порог вхождения для понимания и настройки протокола достаточно низкий, а наличие библиотек под множество языков программирования позволяет выбрать любой стек технологий для разработки. Гарантия доставки сообщений существенно отличает MQTT от его предшественников, и позволяет не тратить время на лишнюю разработку собственных механизмов контроля целостности на сетевом уровне. | https://habr.com/ru/post/452904/ | null | ru | null |
# Продвинутые CSS фильтры
*Перевод [статьи advanced css filters](http://iamvdo.me/en/blog/advanced-css-filters), авторства Vincent De Oliveira, найденная мною в последнем [дайджесте](http://habrahabr.ru/company/zfort/blog/263997/).*
*Я не смог коротко перевести на русский backdrop и background, сохранив смысловую разницу между ними, поэтому поясню сейчас:
backdrop — то, что находится за элементом, и может быть видно через него, обрезано по его рамке;
background — тоже фон, но является частью элемента, к нему и относится свойство background.*
Вернемся в 2011 год, браузеры начали вводить CSS фильтры из [спецификаций](http://www.w3.org/TR/filter-effects/). В это время поддерживались в основном SVG фильтры, а Firefox был единственным браузером, который мог применить их к HTML контенту (в основном, ничего не изменилось).
CSS фильтры такие как blur(), contrast() или grayscale() — отличное дополнение к CSS, несмотря на то, что SVG может позволить сделать восхитительные вещи. Больше узнать о них вы можете на множестве ресурсов.
Сегодня я хочу пойти чуть дальше, показав новые возможности CSS.
backdrop-filter
---------------
В первую очередь — это backdrop-filter свойство, определенное в Filter Effect Level 2. Оно позволяет применять фильтры к фону(backdrop) элемента, а не к его фону(background).
Я был настроен скептически, но я начал играться в WebKit nightlies в феврале, и изменил свое мнение — это очень круто. Каждый согласится со мной, что подтверждается моим Vine (сервис, похожий на Сoub — прим. переводчика) постом, который собрал более 20 тысяч просмотров за 48 часов.
В июне, Apple анонсировала на WWDC, что эти свойства будут доступны в Safari 9. Это хорошая новость. Самое время проверить, (автор использует бету iOS 9 и Safari 9).
С этим свойством вы можете получить эфекты, которых добиться было тяжело. Самое банальное — размытие как в iOS:
```
.header {
background-color: rgba(255,255,255,.6);
backdrop-filter: blur(5px)
}
```
Каждый элемент за header`ом размыт на 5px. Это так просто.
Живой пример на [JSBin](http://jsbin.com/mokupo/embed?css,output) (только Safari 9).
В демо, я использовал
```
@supports
```
для того, чтобы применить backdrop-filter вместе с небольшими корректировками (background-color и позиционирование), чтобы сохранить читаемость header`а в неподдерживаемых браузерах.
backdrop-filter может повысить читаемость текста, наложенного поверх изображения:
```
.text {
backdrop-filter: blur(1px)
}
```
Живой пример на [JSBin](http://jsbin.com/rubofa/embed?css,output) (только Safari 9).
Комбинируя несколько фильтров, вы можете сделать простые графические эффекты, близкие к тем, которые предлагает CSS blend-modes:
```
.text {
background: rgba(0,0,0,.6);
backdrop-filter: grayscale(1) contrast(3) blur(1px);
}
```
Живой пример на [JSBin](http://jsbin.com/ninuva/embed?css,outputt) (только Safari 9).
Несколько вещей, которые надо знать:
* фон элемента, к которому применен backdrop-filter, должен быть полу-прозрачным. Если нет, то вы никогда не увидите эффект
* есть [баг](https://code.google.com/p/chromium/issues/detail?id=497522) при комбинировании backdrop-filter с любым свойством, которое обрезает элемент (border-radius, mask, clip-path, etc). Это означает, что продвинутые эффекты пока невозможны
* backdrop-filter создает новый контекст наложения, как opacity
* backdrop-filter можно анимировать
* это свойство требует префикс: -webkit-backdrop-filter
* [CanIUse](http://caniuse.com/#feat=css-backdrop-filter)
filter()
--------
Иногда, надо наложить фильтр ни на элемент, ни на фон(backdrop). Вы просто хотите применить его к фону(background), но свойства background-filter нет. Вот тут может пригодиться функция filter(), не следует путать со свойство filter. Функция принимает два параметра: изображение и фильтр, возвращает новое изображение. Это изображение можно использовать с любым CSS свойством, поддерживающим изображения. Как то так:
```
.element {
background: filter(url(path/to/img.jpg), blur(5px));
}
```
В результате, теперь можно применять фильтры для изображений, перед использование в качестве фона. Вы можете подумать, что она — вариация background-filter (или background-opacity, background-blur), но она намного мощнее.
Живой пример на [JSBin](http://jsbin.com/deroqa/embed?css,outputt) (только Safari 9).
Хорошая новость в том, что даже без упоминания Apple, она доступна в Safari 9.
Несколько вещей, которые надо знать:
* есть баг с background-size
* функцию можно анимировать
* функция требует префиксi: -webkit-filter()
Стоит отметить, что backdrop-filter и filter() можно легко анимировать с CSS transitions или анимацией, или с помощью JavaScript.
Я с нетерпением жду, когда в браузерах введут эти фичи. SVG тоже может это делать, но такие же крутые эфекты можно легко сделать с CSS. С прошлого года, много споров вокруг CSS были сфокусированы на архитектуре, методологии, инструментах. Хорошо помнить о том, что CSS так же и о графическом дизайне (вместе с SVG).
OK, сейчас поддержка минимальна, но это станет возможным на миллионах iPhone`ов и iPad`ов до конца года. | https://habr.com/ru/post/264037/ | null | ru | null |
# Организация и оптимизация стилей
В этом посте я приведу пример организации стилей на типичном проекте.
Небольшое вступление, попробую объяснить актуальность проблемы и зачем это нужно.
Рассмотрим такую ситуацию. Разработчику ставят задачу, реализовать очередной функционал на сайте. Это допустим включает добавление новых разделов, блоков, элементов. Разработчики зачастую не доверяют чужому коду, и когда доходят до верстки, находят css-файл с названием типа main.css и дописывают в конец свои новые стили.
Проходит некоторое время, приходит новый разработчик, ему ставят подобную задачу, он если и пытается разобраться в стилях, то видит, что там нет никакой закономерности, и повторяет то же, что делали предыдущие.
Руководство ставит сроки, разрабатывается все новый и новый функционал, проект растет. В итоге css файлы превращаются в мусорку, сайт грузится дольше, появляется больше дефектов и т.д..
Я думаю, многим это знакомо.
Теперь поговорим непосредственно о самой структуризации стилей.
Держать все стили в одном файле неразумно, со временем в нем довольно сложно становится ориентироваться. Плюс на каждой странице используются около 10% правил из этого файла, а весит он не мало.
Гораздо оптимальнее разделять стили по логическим блокам сайта.
Так же к проекту необходимо подключить библиотеку для работы с css (LESS, SASS, SCSS). Нам понадобится работа с переменными, функциями.
Для уменьшения запросов на сервер необходима сборка файлов. Файлы должны склеиваться по специальной конструкции, можно, например, использовать стандартную констукцию css — [import](https://habrahabr.ru/users/import/). Здесь возможно потребуется помощь разработчика для редактирования исходников выбранной вами библиотеки css.
Плюс, для уменьшения объема, файлы должны приходить клиенту сжатые. [dotLess](http://www.dotlesscss.org/), например, сжимает файлы при значении в web.config.
Каждому логическому блоку будет соответствовать отдельный css файл. Так упрощается поддержка, поиск нужных стилей, да и вообще ориентация в файлах. Все данные файлы являются исходниками, будем содержать их в папке /css/sources/. Остальные css-файлы — сборщики, они линкуются на страницы и собирают импортом исходники.
Допустим рассматриваемый проект это некая соцсеть, исходя из этого можно выделить следующую структуру:
/css
/sources *— папка для ресурсов, не выкладывается на сервер*
/global-vars *— файлы данной папки подключаются в каждый css-файл сборщик по мере необходимости*
locals.css *— глобальные переменные*
functions.css *— глобальные функции*
/common
reset.css *— думаю, объяснять не нужно, понятно, что за стили*
utils.css *— стили типа .clearfix*
/content
base.css *— основные стили для контента, а именно — h1-h6, p, буллиты для списков (ul.text, ul.dashed и т.д.), dl, dd, dt, изображения и панели в тексте (обтекание текстом), текстовые колонки и т.д.*
panels.css *— различные панели*
tables.css *— стили для таблиц в контенте (th, черезполосица)*
/controls
buttons.css *— виды кнопок*
forms.css *— общие стили для input-полей (к примеру, внутренняя тень, фокус (рамка), оформление валидационных сообщений и их скрытие по умолчанию)*
tabs.css *— табы, вкладки*
system-notifications.css *— системные сообщения, как правило бывают 3-х типов: success (зеленые), failure (красные) и info (серые, синие)*
pager.css *— пейджер*
banners.css *— баннеры на сайте*
balloons.css *— всякие баллуны, всплывающие подсказки, кастомные тултипы и т.д.*
/member
thumb.css *— аватарка пользователей*
card.css *— карточка пользователя (аватарка, имя, краткие данные)*
cards-list.css *— например, грид с карточками*
profile.css *— профиль пользователя*
/modules *— различные модули к сайту*
search.css
news-list.css
gifts.css
games.css
/not-auth *— для неавторизованных пользователей*
login.css *— форма авторизации*
registration.css *— форма регистрации*
/auth *— для авторизованных пользователей*
my-account.css
mail-system.css *— inbox сообщения, outbox и т.д.*
auth-menu.css *— меню навигации в авторизованной зоне*
my-profile.css *— просмотр своего профайла, редактирование*
/layouts
common.css
header.css
top-menu.css
footer.css
overlay.css *— например, все всплывающие поверх слои будут с затемнением 0.5*
main.css *— основной сборщик, линкуется на всех мастер-страницах*
/layouts
default.css *— основной layout сайта, собирает файлы из папки /layouts, подключается на мастере с основным layout'ом*
popup-windows.css *— стили для popup’ов, подключается на мастер-страницах для popup окон*
not-auth.css *— собирает стили из папки /sources/not-auth/*
auth.css *— собирает стили из папки /sources/auth/*
/themes *— различные тематики сайта*
new-year.css
st-valentine.css
/%section-name% *— какой-нибудь новый раздел сайта, «сайт в сайте», характерный наличием своего подменю и т.д.*
/css
%section-name%.css
layout.css
/sources
menu.css
Конечно же для каждого проекта своя уникальная структура. Важен принцип разделения файлов.
Дополнительное описание к некоторым файлам:
**main.css** — собирает файлы из папок:
/sources/global-vars
/sources/common
/sources/content
/sources/controls
/sources/member
/sources/modules
**functions.css** — содержит глобальные функции, типа:
> .rounded-corners(@radius)
>
> {
>
> border-radius: @radius;
>
> -moz-border-radius: @radius;
>
> -webkit-border-radius: @radius;
>
> \*behavior: url(/libs/progressive-IE.htc);
>
> }
**sources/layouts/common.css** — глобальные стили по layout'у:
> .columns-wrapper
>
> {
>
> display: table;
>
> \*zoom: 1;
>
> }
>
> .columns-wrapper .column
>
> {
>
> display: table-cell;
>
> \*float: left;
>
> }
Подключение файлов **not-auth.css** и **auth.css** зависит от состояния авторизации пользователя. Например, в asp.net это будет выглядеть так:
> `<asp:LoginView runat="server">
>
> <AnonymousTemplate>
>
> <link href="/css/not-auth.css" rel="stylesheet" type="text/css" />
>
> AnonymousTemplate>
>
> <LoggedInTemplate>
>
> <link href="/css/auth.css" rel="stylesheet" type="text/css" />
>
> LoggedInTemplate>
>
> asp:LoginView>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Хочу привести концепцию, которой, я считаю, следует держаться.
Новые страницы должны строиться из компонентов, «кирпичиков» — css классов. Некоторые неверно понимают данную концепцию и строят страницу из классов типа **mar-bottom-15**, **float-left** или **pad-20**, что тоже является большой ошибкой.
На всем сайте должен сохраняться единый стиль элементов, т.е. заголовок h1 на одной странице должен выглядеть так же, как и h1 на другой. Заголовки, абзацы, списки, панели, табы, пейджеры, контентные таблицы и т.д. по дизайну должны соблюдать единый стиль.
Перед тем как писать стили для новой страницы сайта следует проанализировать уже существующие css-файлы проекта, возможно там уже есть необходимые стили. Css файл не должен увеличиваться без необходимости.
В заключении скажу, что все описанное выше так же актуально и для JS. | https://habr.com/ru/post/114497/ | null | ru | null |
# Консольный проигрыватель .wav для pc-speaker в Linux
Давно хотел написать проигрыватель для pc-speaker и чтобы не только ноты и монофонические мелодии. Но в то время когда это было актуально (DOS — навсегда!) у меня не было ни знаний, ни способностей, ни помыслов. Позже я не смог пробиться к нему сквозь Windows DDK и продолжал тихо пищать в стиле QBASIC SOUND. Да и актуальность pc-speaker как звукового устройства стала нулевой, гордый speaker превратился в beeper и buzzer. Однако он никуда не исчез из ПК (попутно пережив все дисководы) по прежнему давая о себе знать при включении и сообщая об ошибках. Так можно ли в современном программно-аппаратном user-space окружении проиграть полифоническую мелодию или голос на pc-speaker? Конечно можно — Си и Linux нам в этом помогут.
Посвящается, [мужику в шляпе и очках, посылающему всех в известном направлении](http://yadi.sk/d/RJZhAZ9YpEnC) (неизвестного мне автора, всё хорошо работает в [DOSBox](http://www.dosbox.com/)).
Что представляет собой спикер с точки зрения программиста? Это устройство с двумя состояниями: включен и выключен — этим мы управляем мембраной (наверное, а может каким нибудь другим активным элементом) которая издаёт звук. Порог слышимости человека по заверениям биологов около 22КГц сверху и 20Гц снизу, поэтому мы должны переключать состояния очень быстро. Обычно спикер управляется интервальным таймером, но этим способом мы можем проигрывать звуки только заданной частоты и длительности, для чего существуют готовые программные (получать доступ к таймеру напрямую совсем не обязательно) и пользовательские интерфейсы. Например, для консоли Linux нота «До» первой октавы, длительностью 1 секунда:
>
> ```
> echo -en "\e[10;263;11;1000]\a"
> echo -en "\ec"
>
> ```
>
Вторая команда **echo** возвращает установки длительности и частоты звука в состояние по умолчанию.
Для доступа к управлению спикером напрямую надо общаться с 0x61 (шестнадцатеричные 61) портом, с его нулевым и первым битами. Нулевой бит: управляет привязкой спикера к таймеру — если 1 то управляется таймером. Первый бит: переключает состояния спикера — 1 включен, 0 выключен. Этот тот способ который мы будем использовать.
Теперь чтобы понять как играть мы должны определится что же мы будем играть. Для проигрывания будем использовать .WAV файлы. Формат данных .WAV файла может быть разнообразным, но обычно под ними подразумеваются файлы содержащие данные в [импульсно кодовой модуляции](http://ru.wikipedia.org/wiki/Импульсно-кодовая_модуляция). Это последовательность значений получаемых с заданной частотой (частотой дискретизации) с АЦП и записанных в файл как есть, для каждого из каналов. С точки зрения звука — это громкость в данный момент времени или с точки зрения динамика — положение мембраны относительно точки покоя. Максимальное значение полученное с AЦП за раз, задаёт величину битового потока (bitrate). Совокупность записей данных обо всех каналах в данный момент времени, это сэмпл. Говоря про звук надо обязательно вспомнить про [теорему Котельникова](http://ru.wikipedia.org/wiki/Теорема_Котельникова), и сказать что по этим данным мы имеем возможность восстановить исходную волну (при больших значениях частоты дискретизации и битового потока) без потерь. Но в нашем случае это не сработает, потому что у спикера нет понятие громкости, точнее она есть, но её нельзя менять — или вся громкость (включен) или её нет (выключен). Учитывая что дискретизация по громкости AЦП также имеет конечную точность, становится ясна ценность «тёплого лампового звука».
Записанные данные представлены в виде положительных и отрицательных значений (движение волны которая пересекает ось абсцисс), но несколько в ином формате: за ноль (тишину) принимается половина от максимального значения. Если у нас данные представлены однобайтными отсчётами, то ноль будет 256/2 = 128. 256 это максимальное возможное количество чисел которое может быть представлено одним байтом, или 256 = 255(0xFF, максимальное значение числа) + 1. Соответственно, если для записи используются 2-а байта, то (65535 + 1)/2 = 32768. Значения больше этого числа являются положительными, и растут от меньшего к большему, значения меньше этого числа отрицательные, и уменьшаются от большего к меньшему. Например, переведём в обычное число для однобайтных значений:
>
> ```
>
> 245(значение АЦП) => 117 = 245 - 128
> 93(значение АЦП) => -35 = 93 - 128
>
> ```
>
Как уже было сказано выше, мы можем только включить и выключить спикер, то есть из полученных данных мы сформируем прямоугольную волну, где 1 — это значения больше ноля, 0 — во всех остальных случаях. Больше подробностей про то, как играть на спикере, можно посмотреть [здесь](http://inf.1september.ru/article.php?ID=200900104), эта статья послужила отправной точкой в задуманной реализации, большое спасибо за это её автору.
Начнём осуществлять задуманное. Сразу оговорюсь, что проигрывается только один канал, максимальный размер данных для анализа 4 байта на канал (учитывая что для спикера хватить и одного бита для максимального возможного качества, то это величина избыточна в 32 раза). С самого начала, я видел две большие проблемы:
Первая, доступ к портам — как всё просто было в DOS, до такой же степени всё сложно было для меня в Windows. Однако Linux предоставляет совершенно шикарнейшую возможность прямого доступа к портам, надо только знать пароль root, или каким нибудь другим способом получить права суперпользователя, а точнее привилегию CAP\_SYS\_RAWIO для создаваемого процесса. Эта возможность называется **ioperm** и позволяет открыть доступ ко всем портам в диапазоне от 0 до 0x3FF. Хочется больше, используем другой вызов — **iopl**, нам он не пригодится.
Доступ непосредственно к портам ввода вывода, после разрешения, осуществляется с помощью макросов описывающий inline вставки на ассемблере. Можно записывать(out) и читать(in) байты(b), слова(w), двойные слова(l), строки(s), использовать паузу (\_p) после операции. MAN страница содержит крайне мало информации и больше пугает что так делать не стоит, поэтому лучше смотреть в исходники заголовочных файлов. Если использовать макросы с **\_p**, то дополнительно надо открыть доступ к 0x80 порту, потому что задержка выполняется выводом байта данных в этот порт.
В программе — сначала инициализируем доступ к портам, сохранив значение которое уже было в 0x61 порту, для восстановления после работы программы:
>
> ```
> #define SPKPORT 0x61
>
> static unsigned char old61 = 0;
> unsigned char out61 = 0;
>
> if (!ioperm(SPKPORT,1,1)){ //Разрешили доступ к 0x61 порту
> old61 = inb(SPKPORT); //Прочитали
> out61 = old61 & 0xFE; //Обнулили нулевой бит
> outb(old61,SPKPORT); //Записали, тем самым отсоединив спикер от таймера
> }
>
> ```
>
В конце, вернём как было:
>
> ```
> outb(old61,SPKPORT); //Восстановим сохранённое значение
> ioperm(SPKPORT,1,0); //Запретим сами себе разрешённый доступ к 0x61 порту
>
> ```
>
Вторая проблема — время. Linux многозадачная многопользовательская среда и на монопольное непрерывное владение ресурсом (в частности процессором) рассчитывать не приходится. Чтобы проиграть звук, максимально приближено (с учётом что это pc-speaker) к оригиналу, мы должны посылать данные в строго установленном интервале, отклонения от этого интервала мгновенно исказят звук. Если интервал будет ритмичным (одинаковым), но длиннее либо короче, проигрываемые звуки будут соответственно ниже либо выше исходных. Если интервал будет каждый раз разный, звук будет просто не узнать. Всё это осложняется тем, что минимальная частота дискретизации 8000Гц, что вынуждает нас задавать самые длинные интервалы не больше 1/8000 ~ 125микросекунд. При 22КГц, это уже 45 микросекундные интервалы. Такие задержки, если верить MAN, возможны при использовании **usleep** или **nanosleep**. Но сначала, где их надо было делать:
>
> ```
> char wavdata[0x10000]; //Буфер с данными
> unsigned int *curdata; //Указатель на текущие данные из буфера
> unsigned int bufsize; //Объём данные в буфере
>
> unsigned int cursampleraw; //Текущее значение из буфера
> unsigned int datamask; //Маска соответствующая размеру данных на значение в канале
> short int onechannelinc; //Приращение позиции данных в буфере = размер сэмпла
> unsigned int samplezero; //Значение нулевого уровня
>
> for (i = 0;i < bufsize;i += onechannelinc){
>
> curdata = (void*)(wavdata+i); //Определили указатель на текущую позицию
> cursampleraw = *curdata&datamask //Выделили значимое для нас
>
> if (cursampleraw > samplezero){ //Если положительная часть волны
> out61 |= 0x2; //Включить спикер, выставляем 1 бит = 1
> }else{
> out61 &= 0xFD; //Иначе выключить, выставляем 1 бит = 0
> }
> outb(out61,SPKPORT); //Вывели в порт
>
> //Здесь надо подождать, перед записью следующего значения
>
> }
>
> ```
>
Это и есть практически вся программа, всё остальное — чтение из файла и предварительный анализ данных.
Так вот, как же с задержками? Использование **usleep** и **nanosleep** не дало никаких результатов, точнее они дали результаты, но при значениях паузы меньше 10 микросекунд. Если пауза была больше, звук ломался непоправимо, и дело не высоте звучания, а в том что пауза не выдерживалась, не было ритмичности, то есть каждый проход цикла была разной длительности. Подумав что процесс имеет слишком низкий приоритет — используем **nice**. Но ни утилита, ни программный вызов проблему не решили. Осталось попробовать поменять политику планировщика:
>
> ```
> struct sched_param schedio;
>
> sched_getparam(0,&schedio); //Получили текущие политики
> schedio.sched_priority = sched_get_priority_max(SCHED_FIFO); //Поставили максимальный приоритет
> sched_setscheduler(0,SCHED_FIFO,&schedio); //Применили политику SCHED_FIFO
>
> ```
>
Я не уверен в правильности использования, но в таком виде не помогло (данный код остался в программе закомментированным, на случай если это всё же помогает, то его можно будет вернуть в дело, также как и **nice**). Всё это было перепробовано следуя рекомендациям с этой [страницы](http://www.faqs.org/docs/Linux-mini/IO-Port-Programming.html#s4). Оставалось попробовать только пустой цикл, вместо **usleep**… и он дал результат — можно было слышать не только музыку, но и речь.
Всё работало. Это вселяло надежду, но предвещало плохие последствия при переносе на другие машины. В последней ссылке, было пару абзацев про то, что вывод в порты даёт задержку около 1 микросекунды, я отнёсся к этому скептически, хотя макрос **outb\_p** для вывода в порт с задержкой, руководствовался тем же принципом. В главный цикл добавили паузу:
>
> ```
> short int pause;
>
> for (i = 0;i < bufsize;i += onechannelinc){
>
> curdata = (void*)(wavdata+i);
> cursampleraw = *curdata&datamask
>
> if (cursampleraw > samplezero){
> out61 |= 0x2;
> }else{
> out61 &= 0xFD;
> }
>
> for (k=0;k
> ```
>
— после чего программа была опробована на рабочем сервере, неожиданно для меня, ничего не ломалось и всё работало. Возможных проблем чтения из файла, во время проигрывания (замираний между циклами чтения), также не возникло ни на одном из испробованных компьютеров: файл читается буфером в 64КБ, при это заметного на слух искажения не происходит. Наличие любого постороннего кода в главном цикле, никак не влияет на качество звука, если только этот код не системные вызовы. В итоге, я пришёл к выводу, что чем мощнее компьютер тем лучше будет звучать наш спикер, как это не парадоксально. Если идти в сторону уменьшения мощности то в какой-то момент на многозадачных системах всё сломается, но перейдя на однозадачные, мы вновь добьёмся результата.
Честно говоря я не был уверен в каком бы то ни было положительном исходе, так как нормальных вариантов этой программы для DOS в своё время было два. Первый, запрещаем все прерывания (остаёмся монопольным владельцем всего) и выполняем код в лоб как это приведено выше, считая задержки по тактам в бесконечном цикле. Второй, настраиваем таймер на максимальную частоту (минимальный интервал как раз около 1 микросекунды), забираем себе прерывание 0x8 (IRQ0) и выдаём данные спикеру через собственные подсчитанные интервалы, не давая никому вмешиваться в этот процесс. Оба этих варианта в user-space окружении Linux неработоспособны, но я рад что всё получилось вот так странно.
Теперь несколько строк о том что в остальной части кода. В основном это разбор заголовка .WAV файла, найдя вот [это описание](https://ccrma.stanford.edu/courses/422/projects/WaveFormat/), я разобрал все поля, провёл по ним проверки, но первый же скачанный из интернета файл оказался не того формата. Затем обратившись к [этому документу](http://www-mmsp.ece.mcgill.ca/documents/audioformats/wave/wave.html) и упростив разбор, учтя новые данные, скачал из интернета второй файл, который поставил меня в тупик отсутствием поля в 2-а байта перед цепочкой **fact**, в итоге пришлось ещё сократить проверки, чтобы добиться выполнения какого-то разумного количества произвольных файлов.
В анализе заголовка .WAV содержится проверка на типы данных, с использованием конструкции **sizeof**, предполагается что используемые типы данных **int** в 4 байта, **short int** в 2 байта и **char** — 1 байт. В таком виде можно компилировать и для 64-х битных систем. Если это не так, то проверка не должна пройти, и программа выдаст ошибку о не поддерживаемом формате .WAV.
Также в коде осталась попытка визуализировать процесс, но совмещая со звуком, получаем только кваканье и треск, поэтому график можно увидеть, но без звука. Кстати можно оценить насколько медленнее происходит проигрывание (или сравнить свои визуальные и звуковые ощущения), при использовании **usleep** в качестве задержки.
Это моя первая программа специально для Linux на компилируемом языке, поэтому для тех кто ищет **conio.h** из Borland C, здесь его нет, но тут всё гораздо лучше: [ESC-последовательности](http://www.opennet.ru/base/dev/console_ctl.txt.html) (или man console\_codes) заменяют почти всё, кроме [kbhit](http://cboard.cprogramming.com/c-programming/63166-kbhit-linux.html#post449301) (это просто один из режимов чтения), и получения размеров экрана консоли, но тут надо обратиться к устройству напрямую с помощью **ioctl** (man console\_ioctl):
>
> ```
> struct winsize scrsize;
>
> ioctl(STDOUT_FILENO,TIOCGWINSZ,&scrsize);
>
> //scrsize.ws_col - размеры по горизонтали
> //scrsize.ws_row - размеры по вертикали
>
> ```
>
Программу можно забрать здесь: [playwav.zip](http://yadi.sk/d/FXX_0IPlpEma) — в архив включены также несколько .WAV файлов. Компилировать можно просто, в том числе проверено и на 64-х битных системах:
>
> ```
> gcc playwav64.c -o playwav64
> chmod +x playwav64
>
> ```
>
Запускать можно с тремя параметрами, первый — файл для проигрывания,
>
> ```
> sudo ./playwav64 file.wav
>
> ```
>
второй — умножитель времени: чем он больше тем тон ниже, если второй параметр не число или его нет, то значение используется по умолчанию 650000,
>
> ```
> sudo ./playwav64 file.wav 500000
>
> ```
>
третий — любое значение, сообщает программе что надо вывести график на экран (без звука).
>
> ```
> ./playwav64 file.wav s w
>
> ```
>
Звук только с root привилегиями. Запускать лучше не в иксах, хотя в KDE тоже работает. Если запускать в SSH сессии, то звук будет на физической машине к которой выполнено подключение.
Проверил максимально, на всех доступных мне компьютерах (работало везде), возможно в коде много напортачил, прошу за это прощения. | https://habr.com/ru/post/138144/ | null | ru | null |
# Процесcы в операционной системе Linux (основные понятия)
Основными активными сущностями в системе Linux являются процессы. Каждый процесс выполняет одну программу и изначально получает один поток управления. Иначе говоря, у процесса есть один счетчик команд, который отслеживает следующую исполняемую команду. Linux позволяет процессу создавать дополнительные потоки (после того, как он начинает выполнение).
Linux представляет собой многозадачную систему, так что несколько независимых процессов могут работать одновременно. Более того, у каждого пользователя может быть одновременно несколько активных процессов, так что в большой системе могут одновременно работать cотни и даже тысячи процессов. Фактически на большинстве однопользовательских рабочих станций (даже когда пользователь куда-либо отлучился) работают десятки фоновых процессов, называемых **демонами (daemons)**. Они запускаются при загрузке системы из сценария оболочки.
Типичным демоном является *cron*. Он просыпается раз в минуту, проверяя, не нужно ли ему что-то сделать. Если у него есть работа, то он ее выполняет, а затем отправляется спать дальше (до следующей проверки).
Этот демон позволяет планировать в системе Linux активность на минуты, часы, дни и даже месяцы вперед. Например, представьте, что пользователю назначено явиться во военкомат в 3 часа дня в следующий вторник. Он может создать запись в базе данных демона cron, чтобы тот просигналил ему, скажем, в 14:30. Когда наступает назначенный день и время, демон *cron* видит, что у него есть работа, и запускает в назначенное время программу звукового сигнала (в виде нового процесса).
Демон *cron* также используется для периодического запуска задач, например ежедневного резервного копирования диска в 4 часа ночи или напоминания забывчивым пользователям каждый год за неделю до 31 декабря купить подарки для празднования нового года. Другие демоны управляют входящей и исходящей электронной почтой, очередями принтера, проверяют, достаточно ли еще осталось свободных страниц памяти и т.д. Демоны реализуются в системе Linux довольно просто, так как каждый из них представляет собой отдельный процесс, независимый от всех остальных процессов.
Процессы создаются в операционной системе Linux очень просто. Системный вызов *fork* создает точную копию исходного процесса, называемого **родительским процессом (parent process)**. Новый процесс называется **дочерним процессом (child process)**. У родительского и у дочернего процессов есть свои собственные (приватные) образы памяти. Если родительский процесс впоследствии изменяет какие-либо свои переменные, то эти изменения остаются невидимыми для дочернего процесса (и наоборот).
Открытые файлы используются родительским и дочерним процессами совместно. Это значит, что если какой-либо файл был открыт в родительском процессе до выполнения системного вызова *fork*, то он останется открытым в обоих процессах и в дальнейшем. Изменения, произведенные с этим файлом любым из процессов, будут видны другому. Такое поведение является единственно разумным, так как эти изменения будут видны также и любому другому процессу, который тоже откроет этот файл.
Тот факт, что образы памяти, переменные, регистры и все остальное и у родительского процесса, и у дочернего идентичны, приводит к небольшому затруднению: как процессам узнать, который из них должен исполнять родительский код, а который дочерний? Секрет в том, что системный вызов fork возвращает дочернему процессу число 0, а родительскому — отличный от нуля PID (Process IDentifier — идентификатор процесса) дочернего процесса. Оба процесса обычно проверяют возвращаемое значение и действуют соответственно:
`pid = fork( ); /* если fork завершился успешно, pid > 0 в родительском процессе */
if (pid < 0) {
handle_error(); /* fork потерпел неудачу (например, память или какая-
либо таблица переполнена) */
} else if (pid > 0) {
/* здесь располагается родительский код */
} else {
/* здесь располагается дочерний код */
}`
Если дочерний процесс желает узнать свой PID, то он может воспользоваться системным вызовом *getpid*. Идентификаторы процессов используются различным образом. Например, когда дочерний процесс завершается, его родитель получает PID только что завершившегося дочернего процесса. Это может быть важно, так как у родительского процесса может быть много дочерних процессов. Поскольку у дочерних процессов также могут быть дочерние процессы, то исходный процесс может создать целое дерево детей, внуков, правнуков и более дальних потомков.
В системе Linux процессы могут общаться друг с другом с помощью некой формы передачи сообщений. Можно создать канал между двумя процессами, в который один процесс сможет писать поток байтов, а другой процесс сможет его читать. Эти каналы иногда называют **трубами (pipes**). Синхронизация процессов достигается путем блокирования процесса при попытке прочитать данные из пустого канала. Когда данные появляются в канале, процесс разблокируется.
При помощи каналов организуются конвейеры оболочки. Когда оболочка видит строку вроде
*sort
то она создает два процесса, *sort* и *head*, а также устанавливает между ними канал таким образом, что стандартный поток вывода программы sort соединяется со стандартным потоком ввода программы *head*. При этом все данные, которые пишет *sort*, попадают напрямую к head, для чего не требуется временного файла. Если канал переполняется, то система приостанавливает работу *sort* до тех пор, пока *head* не удалит из него хоть сколько-нибудь данных.
Процессы также могут общаться и другим способом — при помощи программных прерываний. Один процесс может послать другому так называемый **сигнал (signal)**. Процессы могут сообщить системе, какие действия следует предпринимать, когда придет сигнал. Варианты такие: проигнорировать сигнал, перехватить его, позволить сигналу убить процесс (действие по умолчанию для большинства сигналов). Если процесс выбрал перехват посылаемых ему сигналов, он должен указать процедуру обработки сигналов. Когда сигнал прибывает, управление сразу же передается обработчику. Когда процедура обработки сигнала завершает свою работу, то управление снова передается в то место, в котором оно находилось, когда пришел сигнал (это аналогично обработке аппаратных прерываний ввода-вывода). Процесс может посылать сигналы только членам своей **группы процессов (process group)**, состоящей из его прямого родителя (и других предков), братьев и сестер, а также детей (и прочих потомков). Процесс может также послать сигнал сразу всей своей группе за один системный вызов.
Сигналы используются и для других целей. Например, если процесс выполняет вычисления с плавающей точкой и непреднамеренно делит на 0, то он получает сигнал SIGFPE (Floating-Point Exception SIGnal — сигнал исключения при выполнении операции с плавающей точкой).* | https://habr.com/ru/post/125369/ | null | ru | null |
# Звуковые отпечатки: распознавание рекламы на радио
Из этой статьи вы узнаете, что распознавание даже коротких звуковых фрагментов в зашумленной записи — вполне решаемая задача, а прототип так вообще реализуется за 30 строчек кода на Python. Мы увидим, как тут помогает преобразование Фурье, и наглядно посмотрим, как работает алгоритм поиска и сопоставления отпечатков. Статья будет полезна, если вы сами хотите написать подобную систему, или вам интересно, как она может быть устроена.
Для начала зададимся вопросом: кому вообще нужно распознавать рекламу на радио? Это полезно рекламодателям, которые могут отслеживать реальные выходы своих рекламных роликов, ловить случаи обрезки или прерывания; радиостанции могут мониторить выход сетевой рекламы в регионах, и т.п. Та же задача распознавания возникает, если мы хотим отследить проигрывание музыкального произведения (что очень любят правообладатели), или по небольшому фрагменту узнать песню (как делают Shazam и другие подобные сервисы).
Более строго задача формулируется так: у нас есть некоторый набор эталонных аудио-фрагментов (песен или рекламных роликов), и есть аудио-запись эфира, в котором предположительно звучат какие-то из этих фрагментов. Задача — найти все прозвучавшие фрагменты, определить моменты начала и длительность проигрывания. Если мы анализируем записи эфира, то нужно чтобы система в целом работала быстрее реального времени.
### Как это работает
Все знают что звук (в узком смысле) — это волны сжатий и разрежений, распространяющиеся в воздухе. Запись звука, например в wav-файле, представляет собой последовательность значений амплитуды (физически она соответствует степени сжатия, или давлению). Если вы открывали аудио-редактор, то наверняка видели визуализацию этих данных — график зависимости амплитуды от времени (длительность фрагмента 0.025 с):
Но мы не воспринимаем эти колебания частоты непосредственно, а слышим звуки разной частоты и тембра. Поэтому часто используется другой способ визуализации звука — [спектрограмма](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0), где на горизонтальной оси представлено время, на вертикальной — частота, а цвет точки обозначает амплитуду. Например, вот спектрограмма звучания скрипки, охватывающая по времени несколько секунд:
На ней видны отдельные ноты и их гармоники, а также шумы — вертикальные полосы, охватывающие весь диапазон частот.
**Построить такую спектрограмму при помощи Python можно так:**Для загрузки данных из wav файла можно использовать библиотеку [SciPy](http://www.scipy.org/), а для построения спектрограммы использовать [matplotlib](http://matplotlib.org/). Все примеры даны для версии Python 2.7, но вероятно должны работать и для 3-ей версии. Предполагаем что в file.wav содержится запись звука с частотой дискретизации 8000 Гц:
```
import numpy
from matplotlib import pyplot, mlab
import scipy.io.wavfile
from collections import defaultdict
SAMPLE_RATE = 8000 # Hz
WINDOW_SIZE = 2048 # размер окна, в котором делается fft
WINDOW_STEP = 512 # шаг окна
def get_wave_data(wave_filename):
sample_rate, wave_data = scipy.io.wavfile.read(wave_filename)
assert sample_rate == SAMPLE_RATE, sample_rate
if isinstance(wave_data[0], numpy.ndarray): # стерео
wave_data = wave_data.mean(1)
return wave_data
def show_specgram(wave_data):
fig = pyplot.figure()
ax = fig.add_axes((0.1, 0.1, 0.8, 0.8))
ax.specgram(wave_data,
NFFT=WINDOW_SIZE, noverlap=WINDOW_SIZE - WINDOW_STEP, Fs=SAMPLE_RATE)
pyplot.show()
wave_data = get_wave_data('file.wav')
show_specgram(wave_data)
```
Задачу поиска фрагмента в эфире можно разбить на две части: сначала найти среди большого числа эталонных фрагментов кандидаты, а затем проверить, действительно ли кандидат звучит в данном фрагменте эфира, и если да, то в какой момент начинается и заканчивается звучание. Обе операции используют для своей работы «отпечаток» фрагмента звучания. Он должен быть устойчивым к шумам и быть достаточно компактным. Этот отпечаток строится так: мы разбиваем спектрограмму на короткие отрезки по времени, и в каждом таком отрезке ищем частоту с максимальной амплитудой (на самом деле лучше искать несколько максимумов в различных диапазонах, но для простоты возьмем один максимум в наиболее содержательном диапазоне). Набор таких частот (или индексов частот) и представляет собой отпечаток. Очень грубо можно сказать, что это «ноты», звучащие в каждый момент времени.
**Вот как получить отпечаток звукового фрагмента**
```
def get_fingerprint(wave_data):
# pxx[freq_idx][t] - мощность сигнала
pxx, _, _ = mlab.specgram(wave_data,
NFFT=WINDOW_SIZE, noverlap=WINDOW_OVERLAP, Fs=SAMPLE_RATE)
band = pxx[15:250] # наиболее интересные частоты от 60 до 1000 Hz
return numpy.argmax(band.transpose(), 1) # max в каждый момент времени
print get_fingerprint(wave_data)
```
Мы можем получить отпечаток фрагмента эфира и всех эталонных фрагментов, и нам останется только научиться быстро искать кандидаты и сравнивать фрагменты. Сначала посмотрим на задачу сравнения. Понятно что отпечатки никогда не совпадут в точности из-за шумов и искажений. Но оказывается что таким огрубленные таким образом частоты достаточно хорошо переживают все искажения (частоты почти никогда не «плывут»), и достаточно большой процент частот совпадает в точности — таким образом, нам остается только найти сдвиг при котором среди двух последовательностей частот много совпадений. Простой способ визуализировать этот — сначала найти все пары точек, совпавших по частоте, а потом построить гистограмму разниц во времени между совпавшими точками. Если два фрагмента имеют общий участок, то на гистограмме будет ярко выраженный пик (а положение пика говорит о времени начала совпавшего фрагмента):
Если два фрагмента никак не связаны, то никакого пика не будет:
**Построить такую замечательную гистограмму можно так:**
```
def compare_fingerprints(base_fp, fp):
base_fp_hash = defaultdict(list)
for time_index, freq_index in enumerate(base_fp):
base_fp_hash[freq_index].append(time_index)
matches = [t - time_index # разницы времен совпавших частот
for time_index, freq_index in enumerate(fp)
for t in base_fp_hash[freq_index]]
pyplot.clf()
pyplot.hist(matches, 1000)
pyplot.show()
```
Файлы, на которых можно потренироваться в распознавании, лежат [тут](https://bitbucket.org/kostialopuhin/radio-ads/).
Проблема поиска кандидатов обычно решается с использованием хэширования — по отпечатку фрагмента строится больше число хэшей, как правило это несколько значений из отпечатка идущие подряд или на некотором расстоянии. Различные подходы можно посмотреть по ссылкам в конце статьи. В нашем случае количество эталонных фрагментов было порядка сотни, и можно было вообще обойтись без этапа отбора кандидатов.
### Результаты
На тех записях, что были у нас, [F-score](http://en.wikipedia.org/wiki/F1_score) составил 98.5%, а точность определения начала — около 1 с. Как и ожидалось, большая часть ошибок была на коротких (4-5 с) роликах. Но основной вывод лично для меня — что в таких задачах решение, написанное самостоятельно, часто работает лучше чем уже готовое (например из EchoPrint, про который уже [писали](http://habrahabr.ru/post/122969/) на хабре, получалось выжать не более 50-70% из-за коротких роликов) просто потому, что у всех задач и данных есть своя специфика, и когда в алгоритме много вариаций и большой произвол по выбору параметров, то понимание всех этапов работы и визуализация на реальных данных очень способствует хорошему результату.
**Fun facts:**
* На спектрограмме одного из треков группы Aphex Twin есть [человеческое лицо](http://www.bastwood.com/?page_id=10)
* Автор статьи, который воспроизвел алгоритм Shazam на Java, получил от их юристов [письма с угрозами](http://www.royvanrijn.com/blog/2010/07/patent-infringement/)
**Литература:**
* [An Industrial-Strength Audio Search Algorithm](https://www.ee.columbia.edu/~dpwe/papers/Wang03-shazam.pdf) (pdf)
* [Краткое описание алгоритма Shazam](https://laplacian.wordpress.com/2009/01/10/how-shazam-works/) и [перевод](http://drakulavich.blogspot.ru/2010/10/shazam.html)
* [Воспроизведение алгоритма Shazam на Java](http://www.royvanrijn.com/blog/2010/06/creating-shazam-in-java/) | https://habr.com/ru/post/252937/ | null | ru | null |
# SharePoint + Reporting Services = нюансы
Я и мои коллеги занимаемся разработкой и внедрением прикладных внутрикорпоративных решений на базе платформы Microsoft SharePoint, а так же Российских СЭД, внедрение которых обосновано накопленным годами опытом и целесообразно в определенных случаях.
На своих проектах обожаю использовать Microsoft Reporting Services (далее — SSRS) для быстрой реализации отчетов и печатных форм, не требующих сложной динамики поведения.
При наличии доступности данных в структуре таблиц СУБД, а, следовательно, и DataSet отчета, с SSRS все легко и просто, если не сказать тривиально (естественно не для всех случаев). А что, если доступа к БД нет или же он запрещен лицензионной политикой или же даже применяются попытки сделать его технически сложно реализуемым? Надо готовить витрину данных средствами ETL. А что, если условия, бюджет и сроки проекта не допускают этого? Надо использовать доступные источники данных (DataSource).
Как можно было догадаться, речь пойдет о создании отчетов SSRS с ипользованием данных из списков SharePoint.
Арсенал доступных источников данных SSRS хоть и велик, но на практике можно «вляпаться» в нюансы, которые не всегда очевидны.
Итак, переходим к постановке задачи.
Исходные данные:
* Информационная система на базе Microsoft SharePoint 2010 Foundation;
* Microsoft SQL Server 2008 R2 (причем, R2 – принципиальное условие);
* Microsoft SQL Server Reporting Services в режиме интеграции с SharePoint.
Постановка задачи:
* Реализовать специализированный отчет, использующий данные, распределенные по нескольким различным спискам (Lists) SharePoint.
* Не использовать витрины данных или кастомизированные веб-сервисы (их конечно можно использовать, но в рамки задачи и трудоемкость уже не влезает дополнительная разработка).
Казалось бы, что может быть проще? На практике может оказаться печаль.
К слову, для SharePoint прямое обращение к данным в БД технически возможно, да, но затруднено, и не разрешено лицензионной политикой. И, если честно, лучше даже и не пытаться напрямую получать доступ к объектам БД SharePoint, поверьте.
Ладно, продолжим. SQL Server 2008, начиная с версии R2, подарил нам новый источник данных в виде списков SharePoint. Чудно? Да как бы не всегда!
Проблема заключается в следующем:
* Хотите Join в рамках одного DataSet? Забудьте.
* Хотите получать данные из структуры папок в списке? Забудьте.
По поводу объединения различных списков в рамках одного DataSet. Да, это невозможно. DataSet, получающий данные из списка SharePoint может содержать только данные из одного списка. Как выход – для каждого списка создавать отдельный DataSet, хитрым образом фильтровать зависимые DataSet’ы через системные параметры SSRS отчета, чтобы не забирать весь массив данных по всем объединяемым спискам, и делать Join данных из различных списков с помощью функций SSRS (Lookup, LookupSet или MultiLookup) в самом представлении отчета, например, в таблице.
По второму пункту. В списках SharePoint есть такое понятие, как Throttling, когда задается ограничение количества элементов в папке, по умолчанию оно равняется 5К элементов. Что же обычно делается для больших списков? По-простому, структура хранения элементов меняется таким образом, чтобы в списке были папки (скрытые), а данные архивировались так, чтобы в каждой конкретной папке не было более 5К элементов или же того значения, что задан в настройках списка (по опыту – лучше пусть 5К и остается).
Мы как раз и имеем дело с таким списком, где элементов много, все по папкам, данные, прошедшие свой жизненный цикл архивируются, но остаются в списке и нужны, в том числе и для отчетов.
Казалось бы, в веб-сервис RSSharePointList, из которого получаются данные, встроен CAML и достаточно `/>` для обхода нюанса, но, к сожалению, скоуп в SharePoint List Datasource не внедрен. Просто-напросто такие данные с помощью Datasource «Список SharePoint» не получить никак.
Но данные нужны же и что-то надо делать, при этом не витрину, нет времени. Возвращаемся к истокам и смотрим в сторону получения данных через веб-сервисы SharePoint, но не те, о которых речь была выше. Создаем Datasource, используем тип соединения XML, в строку соединения пишем «путь до коллекции сайтов SharePoint»+«/\_vti\_bin/Lists.asmx», указываем учетные данные служебного пользователя для отчетов. Далее интереснее – создаем DataSet с источником, описанным выше и запросом на подобии:
```
http://schemas.microsoft.com/sharepoint/soap/GetListItems
{A4AA15E5-D722-4583-AA7D-C51C86A384F4}
{231A273A-DDA2-4CA1-B8FC-54B3DC4B0816}
...
\*
```
Запрос можно формировать программно, например нужно отфильтровать только данные, которые получаются путем Inner Join с другим DataSet. И это можно, формируя динамически запрос и подставляя в него нужный фрагмент CAML-запроса.
Овладев парой-тройкой трюков получения данных и оказавшись в условиях схожих с условиями поставленной задачи, можно быстро реализовать довольно сложный отчет и задеплоить его для функционального заказчика, даже будучи в условиях ограниченных прав, когда доступ к SQL Server отсутствует и не достучаться до администратора фермы SharePoint.
Пожалуй, в рамках одной статьи все. Посмотрим, интересна ли данная тематика читателям habrahabr. Если да, возможно расписать реализацию задачи данного поста на примере конкретного отчета с раскрытием технических нюансов реализации логически объединяемых DataSet’ов на основе параметров отчета, динамического формирования запроса к веб-сервисам списков, примеры использования Lookup’ов в таблицах отчетов. | https://habr.com/ru/post/177639/ | null | ru | null |
# Разработка простой игры в Game Maker. Эпизод 0. Первые строки
Если вы любите игры, несомненно задавались вопросом о том, как их делают. Если у вас есть (или будет) желание делать игры, но нет опыта, в этой статье я расскажу о том, как это лучше начать.
Я хотел бы рассказать об игровом движке Game Maker и разместить несколько публикаций, в которых мы напишем клон не сложной игры, например, Plants vs Zombies. Возможно, добавим поддержку геймпада и сделаем, например, Android-версию.
Исходные коды будут открытыми, а вот графика, если не найдется желающего безвозмездно её нарисовать и поделиться с сообществом, будет куплена на GraphicRiver и распространяться по понятным причинам с игрой не будет. Ну и обилием анимаций игра обладать тоже не будет.
#### Вступление
Game Maker — это невероятно простой игровой движок, позволяющий создать игры для большого числа платформ — Windows, Mac OS X, Ubuntu, Android, iOS, Tizen, Windows Phone, Windows 8, PlayStation 3, PS 4, PS Vita, Xbox One и HTML 5. Есть поддержка SteamWorks. В случае успеха вашей игры, портирование на другую платформу сложной задачей не будет.
Скорость разработки даже при скромных знаниях и минимальной мотивации субъективно быстрее, чем на других движках. Установка и настройка для начинающих максимально проста и не требует особых знаний. Компиляция под другие платформы не требует смены кода игры и осуществляется одним кликом (ну почти).
YoYoGames — компания, создавшая Game Maker, недавно была приобретена Playtech, что дает уверенность в том, что Game Maker продолжит развиваться. Анонсированный Game Maker 2.0 вероятно будет еще более дружественным и простом, а также логично предположить, что будет обладать еще большими возможностями. Как пишут в пресс-релизе, GM 2.0 — одна из причин покупки компании.
В этой статье я кратко расскажу о Game Maker и мы сделаем простой набросок будущего проекта.
Для кого этот движок и с какой целью его еще можно использовать?
Для всех. Цель — любая 2D игра. Однако для тех, для кого программирование не родная стихия, а так же для быстрого прототипирования и создания игры с минимальными усилиями для любого желающего делать игры и/или заработать на них, Game Maker подойдет идеально.
#### Плюсы Game Maker
— простое вхождение;
— знакомый всем по Java/C/C#… синтаксис;
— возможность легкой компиляции на разные платформы;
— активное сообщество, которое за многие годы уже решило много проблем и написало код за вас;
— стандартный функционал, благодаря которому не нужно самому писать большое количество кода;
— расширяемость через extension'ы;
— справка (F1) очень простая и удобная с отличными объяснениями и примерами.
#### Минусы Game Maker
— платность (когда вы дорастете до публикации игры, придется купить лицензию);
— нет автоподстановки пользовательских переменных, только для стандартных и скриптов;
— высокая стоимость максимальной лицензии (впрочем, не всем нужны прямо все модули);
— техподдержка (дважды обращался в техподдержку, быстрее чем через 2 недели мне не отвечали);
— нет возможности авторефекторинга.
Теперь к созданию игры. Я думаю, установить Game Maker и создать пустой проект проблемой не является. Вообще для начала хорошо было бы продумать весь функционал, нарисовать схемки, продумать монетизацию и т.д., но это не является целью статьи, так что я покажу вам способ создания проекта для начинающего разработчика игр.
Кратко пробежимся по структуре проекта:
* Sprites — папка с спрайтами(изображения, анимации);
* Objects — объекты со своими заготовленными событиями (например, создание, отрисовка, клик и т.д.);
* Rooms — игровые комнаты (экраны). Для каждого экрана нужно делать свою комнату. Очень удобно;
* Background — фоны, которыми можно залить комнату. Так же используется как tile set'ы
Остальное нас пока не интересует.
#### Что такое спрайт в Game Maker?
Это изображение/анимация, которые используются в игре. Они обладают своей маской, формы и размеры которой можно менять. Маска — это область изображения, которая реагирует на события столкновения объектов (если этот спрайт присвоен какому-то объекту), кликов по нему. Можно задать точку отрисовки (Origin) — например, от центра, угла или любой другой точки.
Так же для спрайта можно можно задать Texture Group. Нужно для оптимизации отрисовки (например, незачем держать в памяти texture pages с изображениями, которые используются на экране меню, когда у нас сейчас игровой экран). Для каждой Texture Group можно задать платформу, на которой они будут действовать. Например, для Android можно иметь менее детальные изображения, чем для Windows 8 планшетов.
#### Что такое объект (object) в Game Maker?
Это описание некоторой сущности, обладающая своими методами (функциями). Каждый объект рисует себя сам (если не задано иное), реагирует на стандартные события — нажатия клавиши, клика по спрайту и т.д… По аналогии с ООП — это класс (class).
#### Что такое инстанс (instance) в Game Maker?
Если объект — это просто описание сущности, то инстанс — это экземпляр объекта, его реализация в самой игре. Создав инстанс вы даете ему жизнь и теперь все события, описание которых есть в объекте начнут реагировать.
По аналогии с ООП — это объект (object).
Первое, что необходимо сделать — создать новую комнату (на левой панели правый клик на Rooms — Create Room). Назовем её rm\_game. Зададим размеры окна во вкладке Settings — Width — 800, Height — 480, Speed — 60. Т.е. игра у нас будет происходить в окне 800х480, fps будет не превышать и стремиться к 60 кадрам. Сохраняем, закрываем.
Добавим несколько спрайтов. Правой кнопкой по папке Sprites -> Create Sprite. Назовем его spr\_unit\_shooter, загрузим картинку (есть на гитхабе в конце статьи), например, размера 54х54 и отцентрируем (кнопка Center). Кнопка «OK» и данные сохранились.
Теперь нам нужен первый юнит. Пусть это будет классическое стреляющее растение. Но перед этим нам желательно создать объект, который будет родительским для всех пользовательских юнитов (да, примерно тоже, что и наследование в ООП). Так можно избежать повторяющейся логики для всех юнитов, а также как вы увидите ниже, можно будет обращаться ко всем типам созданных во время игры «детям» этого объекта.
По принципу, аналогичному со спрайтами и комнатами, создаем пустой объект. Назовем его o\_unit\_parent и больше пока с ним ничего не делаем. Теперь создадим o\_unit\_shooter и в графе Parent выберем o\_unit\_parent. Зададим ему спрайт — spr\_unit\_shooter. Для этого воспользуемся кнопкой, которая находится под именем.
Называть спрайты, объекты, комнаты и т.д. можно как вам удобно, но для того, чтобы потом не путаться, лучше сразу называть вещи своими именами, например, спрайты с приставкой spr\_, объекты obj\_ или o\_, скрипты — scr\_ и т.д.
Теперь, каждый раз, когда вы будете создавать объект o\_unit\_shooter в комнате, он будет сам рисовать выбранный вами спрайт (конечно, если вы не переопределите это кодом).
Спрайт можно задавать и программно, но в таком случае он не будет отображаться в превью Project Structure слева. Теперь добавим событие, которое будет срабатывать при создании инстанса объекта. В этом событии нужно задать начальную инициализацию переменных, если они имеются. Нажмем Add Event. Как видите Game Maker позволяет каждому объекту отлавливать большое число событий. Нас интересует — Create.
Как видите справа в контейнере Actions в нескольких вкладках есть огромное количество drag'n'drop элементов, с помощью которых в теории можно создать совершенно полноценную игру не написав ни строчки кода. Но это для извращенцев и вероятно в Game Maker 2.0 этот ненужный функционал наконец уберут.
Перейдем по вкладку Control перетащим или сделаем правый клик по иконке Execute code. Откроется текстовый редактор, в котором и можно размещать игровую логику.
Как вы помните, юниты должны с определенным периодом стрелять. Сделать это можно очень легко. В событии Create напишем этот код: alarm[0] = room\_speed \* 2;
Это означает, что мы запускаем alarm под номером 0, который сработает через room\_speed\*2 шагов(кадров). room\_speed у нас равно 60, что примерно равно секунде. Так что alarm[0] сработает через 120 кадров(2 секунды). alarm — это функция, а точнее событие объекта, она срабатывает как только счетчик шагов дойдет до 0. Как и все другие событие оно добавляется через Add event. Теперь нужно прописать логику, которую мы добавим в alarm[0], но прежде давайте создадим то, чем будет стрелять наше растение.
Создаем новый спрайт spr\_bullet, размером 16х16 и центрируем. Теперь создаем новый объект o\_bullet и задаем ему только что созданный спрайт. В событии Create добавляем код hspeed = 7; точно так же как и с предыдущим объектом. Этой строчкой мы задаем, что объект будет двигаться со скоростью 7 по горизонтали (hspeed = horizontal speed, если кто не понял). Это встроенное свойство каждого объекта. Присвоив ему ненулевое значение, этот объект начнет двигаться на заданное количество пикселей(в нашем случае по 7 вправо) каждый шаг(Step). Если мы зададим hspeed = -7; — объект будет двигаться по -7 пикселей каждый шаг, т.е. будет двигаться справа налево.
Все, возвращаемся к объекту o\_unit\_shooter и создаем новое событие — Alarm 0. Код, который мы напишем в этом событии как раз и будет срабатывать когда запущенный счетчик, который мы создали в событии Create. В событии Alarm 0 мы и будем создавать «пули» (в оригинале — горох), которыми стреляет растение. Добавим такой код:
```
/// shoot
var b = instance_create(x + sprite_width/2, y, o_bullet);
b.depth = depth + 1;
alarm[0] = room_speed * 2;
```
Разберем этот код.
/// shoot — это просто комментарий, который будет отображаться при переходе на событие. По-умолчанию показывается — «Execute piece of code», что не очень-то информативно. Так что рекомендуется писать такие комментарии, чтобы не тратить время на переход в редактор кода.
var b = instance\_create(x + sprite\_width/2, y, o\_bullet);
var b — мы объявляем локальную переменную, которая будет доступна исключительно в этом событии. После завершения события память освободится и обратиться к этом переменной вы не сможете.
instance\_create(x + sprite\_width/2, y, o\_bullet); — так мы создаем новый экземпляр объекта и помещаем его в координаты по x: x + sprite\_width/2, по y — y. В данном случае x и y — это координаты материнского объекта — o\_unit\_shooter. o\_bullet — это тот объект, который мы создаем.
b.depth = depth + 1; — эта строка означает, что только что созданный экземпляр o\_bullet будет находится на 1 слой ниже чем o\_unit\_shooter.
Последняя строка означает, что мы снова запускаем alarm[0] — растение же должно постоянно стрелять.
Как вы помните, в оригинале можно расставлять растительность только в определенных ячейках. Чтобы визуально было понятно в каких пределах можно поставить растение, создадим фон и зальем им нашу комнату. Правой кнопкой по Backgrounds — Create Background — Load Background, выбираем нужную картинку, скажем, 64х64 пикселя, обзываем bg\_grass. Переходим в нашу комнату (rm\_game), вкладка Backgrounds, выбираем созданный секунду назад фон. Ставим галочки, если не стоят как на изображении.
Теперь нам нужен какой-то стартовый объект, который будет делать начальную инициализацию. Создаем новый объект и называем его, например, o\_game. Пусть этот объект и реагирует на клик по полю. Для этого добавим событие — Mouse -> Global mouse -> Global left released. Обычное mouse-событие означает непосредственный клик по объекту, но так как o\_game не имеет своего спрайта+маски и т.к. нам нужно чтобы игрок мог кликнуть по любой точке игрового поля нужно отлавливать все события клика. Именно это и делает Global Mouse. Global left released означает, что где-то внутри игрового окна был сделан клик мышью или тач на сенсорном экране(событие срабатывает когда отпустили палец).
Добавим этому событию такой код:
```
var tBgWidth = background_get_width(bg_grass);
var tBgHeight = background_get_height(bg_grass);
var iX = mouse_x - mouse_x % tBgWidth + tBgWidth;
var iX = mouse_x - mouse_x % tBgWidth + tBgWidth/2;
var iY = mouse_y - mouse_y % tBgHeight + tBgHeight/2;
if (instance_position(iX, iY, o_unit_parent) != noone){
exit;
}
instance_create(iX, iY, o_unit_shooter);
```
Точку с запятой после операции можно и не ставить, логика кода от этого не меняется и ошибок не вызовет. Но если можно ставить, почему бы и не сделать это. Да и привычнее.
В первых четырех строках мы объявляем локальные переменные. background\_get\_width, background\_get\_height — встроенные функции, возвращающие width и height нашего фона. Как видите эти данные нам понадобятся для того, что бы просчитать iX и iY. iX и iY — это будут координаты, в которых мы создадим экземпляр объекта o\_unit\_shooter. mouse\_x, mouse\_y — встроенные в Game Maker глобальные переменные (т.е. те, к которым мы может обратиться из любого места), хранящие текущие координаты курсора мыши (пальца). Т.к. мы работаем в событии Global left released, в них хранятся последние координаты где пользователь отпустил левую кнопку мыши (отпустил палец). Математические операции, результат которых присваиваются переменным iX, iY нужны для просчета координат, в которых экземпляр объекта o\_unit\_shooter будет находится ровно по средине ячейки фона bg\_grass. Т.е. помните, что в Plants Vs Zombies растение нельзя поставить где угодно, только в определенной точке, но при этом кликнуть-то можно где угодно и растение поставится как раз в нужном месте. Этим и занимается весь код выше.
Проверка instance\_position (iX, iY, o\_unit\_parent) != noone означает, что мы смотрим находится ли по координатам iX, iY любой инстанс (экземпляр объекта), родительским объектом которого является o\_unit\_parent. По скольку у нас сейчас только один наследуемый юнит — o\_unit\_shooter, то мы проверяем, нет ли экземпляров o\_unit\_shooter на игровом поле, но пишем o\_unit\_parent в проверке для того, чтобы код срабатывал и тогда, когда мы добавим новые пользовательские юниты. noone (от «no one») — некий аналог null в других языках.
exit — код, который обрывает выполнение события. Т.е. если в координатах iX, iY какой-то юнит уже есть, срабатывает exit и инстанс o\_unit\_shooter не создается, т.к. мы прерываем выполнение всего последующего кода. Это нам нужно, чтобы в одной ячейке не могло стоять 2 пользовательских юнита.
Что ж, пришло время добавить первого врага. Создаем новый объект и опять же создадим базовый родительский объект. Назовем o\_enemy\_zombie и o\_enemy\_parent, который будет ему родительским. Создадим спрайт spr\_enemy\_zombie, отцентрируем и присвоим его o\_enemy\_zombie.
По сколько свойством всех врагов является движение в сторону растений, то создадим в o\_enemy\_parent в событии Create этот код:
```
cHspeed = -4;
hspeed = cHspeed;
HP = 10;
canAttack = true;
```
cHspeed — это пользовательская переменная, значение которой мы присваиваем hspeed, с которой мы уже встречались. Почему просто не написать hspeed = -4; — увидите потом.
Ранее мы объявили пользовательские переменные через конструкцию var, но здесь мы этого не делаем. В чем же разница между cHspeed = -4; и var cHspeed = -4;?
Все просто — в первом случае переменная будет доступна из любой точки кода этого объекта и к ней можно будет обратиться из любого другого объекта, но только не забыв упомянуть, к какому именно объекту мы обращаемся. Сейчас вникать в это необязательно. Помним то, что эта переменная существует все время существования инстанса объекта с тех пор, как она объявлена. В случае же с var cHspeed = -4; она будет доступна только на время действия события, в котором она создана.
На самом деле к ней тоже можно обратиться из другого объекта, но в случае если вы обратитесь к ней из другого объекта в момент, когда событие, в котором она создана уже закончилось, это вызовет ошибку — знакомый всем null pointer, ибо из памяти она уже выгружена.
Если сам не нравятся функции hspeed, wspeed вы можете сами их реализовать изменяя значение x или y в событии Step. Эти функции просто делают это за вас.
HP — это еще одна переменная, в которой мы будем хранить количество очков жизни врагов. Этой переменной будет «владеть» каждый инстанс, но ведь максимальное количество очков жизни у разных типов врагов разные, т.е. нужно как-то переопределить/перезадать это значение. Либо можно задать всем врагам одинаковое количество жизней, скажем, 100 и ввести понятие defence от которой будет зависеть получаемый врагом урон, но сейчас нету смысла усложнять, верно? Так что обойдемся только одной переменной — HP.
Запомните, gml — язык, используемый в Game Maker регистрозависимый, HP, hP, Hp и hp — будут разными переменными.
canAttack — просто переменная, которой мы присваиваем значение true(истина). Пока просто напишем и забудем о ней.
Раз у нас значение HP у каждого врага будет разное, нужно как-то переопределить это значение. Это очень-очень просто. Переходим к объекту o\_enemy\_zombie, создаем реакцию на событие Create и пишем код:
```
event_inherited();
HP = 20;
```
Функция event\_inherited(); и занимается наследованием. Т.е. теперь o\_enemy\_zombie выполнит код:
```
cHspeed = -4;
hspeed = cHspeed;
HP = 10;
```
Который «импортирует» эта функция, а затем значение выполнится строка — HP = 20;
Т.е. по факту на конец события Create объект o\_enemy\_zombie будет иметь такие свойства:
```
cHspeed = -4;
hspeed = cHspeed;
HP = 20;
```
Если же мы забудем о функции event\_inherited(); или забудем объекту o\_enemy\_zombie указать родительский объект, враг двигаться не будет, при попытке обратиться к переменной cHspeed этого объекта появится ошибка.
Великолепно, если мы захотим создать еще один тип врага, в событии Create мы напишем тоже самое, изменив на нужно количество HP:
```
event_inherited();
HP = 100;
```
Раз у зомби есть очки жизни, они должны быть и у растения. Добавьте самостоятельно в событие Create объекта o\_unit\_parent код HP = 20; и строку event\_inherited(); в событие Create объекта o\_unit\_shooter.
#### А вы знаете?
Если вам не нужно ничего переопределять и дописывать в событии Create, добавлять код event\_inherited(); без другой логики в событие не нужно — за вас это сделаем сам Game Maker. Тоже касается любых других событий, не только Create.
Отлично, наш зомби теперь идет, однако его не берут пули и растения его не тормозят. Решим сначала первую задачу. Перейдем в o\_bullet и создадим новую реакцию на событие — Add Event -> Collision -> o\_enemy\_zombie. Это событие будет вызываться когда o\_bullet и o\_enemy\_zombie врежутся друг в друга. Коллизия проверяется по маске, о которой вы читали в начале статьи. Добавим код:
```
with(other){
HP -= 5;
if (HP <= 0){
instance_destroy();
}
}
instance_destroy();
```
Это очень интересный момент. other — это инстанс объекта, с которым в этот момент события происходит коллизия. Естественно, т.к. этот код находится в событии столкновения с экземпляром объекта o\_enemy\_zombie, то в other и будет только инстанс o\_enemy\_zombie.
С помощью конструкции with(){} мы обращаемся к этому элементу other. Все, что происходит внутри {} касается исключительно этого экземпляра объекта. Таким образом, HP -= 5; — это вычитание 5 очков жизни из врага. В if (HP <= 0){} мы сравниваем количество очков жизни тоже именно у этого объекта. Помните я немного выше говорил про разницу между обычным объявлением переменной и с переменной через var. Вот этот пример должен вам окончательно прояснить ситуацию. Т.к. переменная HP у нас объявлена не через var, то она доступна в любой момент времени. Так что с помощью конструкции with мы можем к ней получить доступ. Альтернативный способ обращения к переменной другого объекта выглядел бы так:
```
other.HP -= 5;
if(other.HP <= 0){
with(other){
instance_destroy();
}
}
}
instance_destroy();
```
Но так обращаться к переменным менее удобно, особенно, если логики будет больше, но тем не менее в некоторых случая применимо.
Не забывайте, если вы объявили переменную не в событии Create, а в коде вы обращаетесь к ней до того, как она объявлена, это вызовет ошибку, если вы попытаетесь считать какие-то данные из нее.
Не нужно обладать большими знаниями английского, что бы понять, что функция instance\_destroy(); удаляет этот экземпляр объекта(инстанс).
Таким образом весь этот код означает, что при коллизии мы отнимаем 5 очков жизни у зомби и если у него их становится 0 или меньше, то мы его уничтожаем. Независимо от результата в конце мы удаляем нашу пулю. Проще некуда. Вообще, наверное, лучше было бы заставить зомби самостоятельно следить за своим здоровьем, но пока нас это не интересует. Но это уже ~~другая история~~ вопрос оптимизации.
Было бы неправильно, если бы наши зомби могли только получать урон. Нужно же добавить возможность наносить урон. Прежде всего добавим новую переменную в событие Create объекта o\_enemy\_parent
```
isActive = true;
```
Пришло время ознакомится с событием Step, о котором я ранее рассказывал. Данное событие срабатывает каждый кадр. Все просто. Если room\_speed равно 60, то данное событие будет срабатывать примерно 60 раз в секунду. Добавим этот код в событие Step -> Step объекта o\_enemy\_zombie.
```
if (!isActive) exit;
var tBgWidth = background_get_width(bg_grass);
var leftCellCenterX = x - x % tBgWidth - tBgWidth/2;
var frontEnemy = instance_position(leftCellCenterX, y, o_unit_parent);
if (frontEnemy != noone){
var frontEnemySprtWidth;
with(frontEnemy){
frontEnemySprtWidth = sprite_width;
}
if (x - sprite_width/2 - frontEnemy.x - frontEnemySprtWidth/2 <= 12){
hspeed = 0;
if (!canAttack){
exit;
}
canAttack = false;
alarm[0] = room_speed * 1.2; // cantAttack -> true;
with(frontEnemy){
HP -= 5;
if (HP <= 0){
instance_destroy();
}
}
}
}else{
hspeed = cHspeed;
}
```
Ничего страшного в нем нет почти все конструкции вам уже знакомы.
if (!isActive) exit; — если объект не активен, т.е., скажем, отдыхает/перезаряжается/делает замах, данное событие выполнятся не будет. В следующих двух строках мы получаем координаты центра ячейки, находящейся слева от той, на которой сейчас находится центр нашего instance(помним, что x — возвращает координаты Origin-точки, а она у нас выставлена как раз по центру спрайта). Дальше мы смотрим, находится ли по координатам (leftCellCenterX, y) пользовательский юнит. Если там что-то есть происходит последующая логика, но о ней через секунду, если же там ничего нет, мы присваиваем hspeed значение переменной cHspeed, которую мы, помните, создаем в событии Create. Вот тут она и пригодилась. Смысл за этим скрывается такой — если наш зомби остановился для того, чтобы атаковать и уничтожил растение, нужно чтобы он продолжил свой путь. Можно, конечно, не вводить переменную cHspeed, но тогда нужно будет вспомнить где вы задаете скорость движения, а это забывается.
Это в случае если на пути зомби ничего нет, теперь же возвращаемся к моменту, когда нам предстоит бой. Первые же строки оказываются очень интересными, с подвохом. Дело в том, что объявив локальную переменную frontEnemySprtWidth мы в инстансе frontEnemy присваиваем ей значение. Знакомые с программированием, скажут, но ведь в таком случае мы обращаемся к переменной frontEnemySprtWidth не нашего зомби, а к переменной с таким же именем, но инстанса frontEnemy. Так да не так, дело в том, что локальные переменные(объявленные через var) становятся видимыми внутри этого события везде, даже изнутри инстанса frontEnemy. Таким образом в коде ошибки нет, мы действительно обращаемся именно к той переменной, которая была объявлена локальной внутри зомби. Если вы не поняли этого момента поэкспериментируйте или прочтите справку, там все прекрасно объяснено, а мы идем дальше.
Мы присвоили frontEnemySprtWidth значение длины(width) спрайта юнита пользователя(растения), который находится на ячейку левее нашего зомби. Вы скажете, а зачем нам городить такую сложную для первого понимания конструкцию, если можно обойтись var frontEnemySprtWidth = sprite\_get\_width(spr\_unit\_shooter);. Ответ прост — это сейчас у нас одно растение и мы знаем к какому спрайту обратиться, но при добавлении новых типов юнитов(подсолнухи и т.д.), придется городить громоздкую конструкцию switch, чтобы узнать что же за объект впереди нас, а так довольно просто решается эта проблемка.
Дальше мы проверяем, если расстояние между крайней правой точкой пользовательского юнита и крайней левой точкой нашего зомби меньше 12 пикселей, то мы останавливаем нашего зомби, проверяем может ли наш зомби атаковать(проверяем значение ранее созданной в событии Create объекта o\_enemy\_parent переменной canAttack), продолжается выполняться код, в котором мы говорим, что атаковать теперь уже нельзя и что следующий раз это можно будет сделать через room\_speed \* 1.2 кадров(через 60\*1.2) — это мы делаем в alarm[0](сами добавьте его в соответствующее событие(Alarm 0) объекта o\_enemy\_parent, где напишите код canAttack = true;). Если атаковать можно, отнимаем у инстанса растения 5 очков жизни и проверяем, живо ли оно еще, если нет — уничтожаем.
Ну вот и отлично враг готов — он двигается, атакует и продолжает движение, если уничтожил растение, но у него есть один недостаток — его не существует. Мы создали только описание нашего врага, теперь нужно же помещать зомби на игровое поле. Возвращаемся в событие Create объекта o\_game. Добавим код
alarm[0] = room\_speed; // generate enemies
Т.е. через 60 кадров сработает Alarm 0 и будет создан зомби, правильно? Нет. Мы же не создали логики для этого Alarm. А код тут тоже простой:
```
var tBgHeight = background_get_height(bg_grass);
var eY = irandom(room_height - room_height % tBgHeight);
eY = eY - eY % tBgHeight + tBgHeight/2;
instance_create(room_width + sprite_get_width(spr_enemy_zombie)/2 + 1, eY, o_enemy_zombie);
alarm[0] = room_speed * 3;
```
Все просто — мы не будем усложнять и просто каждые 3 секунды(60 кадра \* 3) создаем инстанс o\_enemy\_zombie по координатам X: room\_width + sprite\_get\_width(spr\_enemy\_zombie)/2 + 1 т.е. за ровно на один пиксель правее, чем граница экрана, т.е. зомби изначально видно не будет и Y — случайная ячейка. room\_width и room\_height, как вы уже поняли, это width и height нашей комнаты. Т.е. 800 и 480 соответственно.
Это все отлично, но инстанс объекта o\_game тоже кто-то должен создать иначе весь эпизод смысла не имеет. Но наш завершающий шаг очень прост — переходим в комнату rm\_game -> Objects -> выбираем в менюшке o\_game и помещаем его где попало в комнате. Альтернативный вариант выглядит так — вкладка Settings -> Creation Code( — это код, который будет срабатывать когда мы переходим в эту комнату). Добавляем строку instance\_create(0,0, o\_game);
Координаты можно любые. Теперь мы можете задать вопрос, а как Game Maker определит, что нужно запускать комнату rm\_game или «а что если у нас будет много комнат, с какой Game Maker начнет?». Все как всегда просто — самая верхняя комната запускается первой(их порядок можно менять перетягивая мышкой). Сейчас она у нас одна потому сразу она же и запустится.
Теперь у нас должно получиться что-то такое:
На этом первый эпизод закончен. Поздравляю, мы сделали прототип игры. Осталось совсем немного — сделать из него полноценную игру, чем и займемся в следующих частях.
В этом эпизоде мы ознакомились с базовыми понятиями Game Maker, использовав как можно больше возможностей. Некоторые моменты сделаны не очень рационально, их можно и нужно переделать, но не все сразу. Для начального понимания происходящего, я считаю, лучше все же писать по аматорски.
Как видите по уроку, в некоторых планах текущая версия Game Maker не идеальна, многое приходится держать в голове, зато в Game Maker проще делать все остальное. Небольшое неудобство стоит того.
[Исходный код](https://github.com/uraddo/pvzhabr)
В следующем эпизоде:
— /теория/ скрипты
— /теория/ отладка
— /практика/ юнит подсолнухи
— /практика/ мана(солнышки)
— /практика/ генерация врагов волнами
— /практика/ газонокосилки
— /практика/ новые юниты зомби и растений
— /теория + практика/ примитивный интерфейс
В принципе, уже сейчас все из раздела практики вы уже можете сделать сами из полученных знаний, но, наверное, в целях увеличения багажа знаний мы с вами реализуем в более усложненном виде. | https://habr.com/ru/post/255995/ | null | ru | null |
# Нечеткий динамический текстовый поиск? Не так уж и страшно
Существует устойчивое мнение, что нечеткий поиск в динамике (онлайн)
малодоступен в силу своей невероятной сложности.
Далее мы будем развеивать это досадное заблуждение и покажем,
что построить свою собственную поисковую систему со сносной производительностью
на не таких уж и маленьких данных доступно каждому.
Основных идеи таковы:
* Для словарного поиска используем триграммы
* Хранение данных мы доверим СУБД
* Для повышения скорости словарного поиска, словарь всегда находится в памяти
* Для поддержания словаря в актуальном состоянии, используем триггеры
**Тестовые данные.**
Для опытов мы возьмем немного Пушкина и Достоевского, «Божественную Комедию» Алигьери а также «Войну и мир» Толстого в английском переводе (источник — [www.lib.ru](http://www.lib.ru) & [www.gutenberg.org](http://www.gutenberg.org)). Всего 18 мб в кодировке utf8.
Каждая непустая строка текста становится одной записью в нашей базе.
Если строка длинная, она разбивается по 800 слов.
Всего выходит ~160 тысяч записей
**СУБД**
Как и [раньше](http://habrahabr.ru/post/196682/), будем использовать [OpenLink Virtuoso](http://virtuoso.openlinksw.com/dataspace/doc/dav/wiki/Main/) версии 7.0.0. Одним лишь С-плагином обойтись не удастся, т.к. функционала, доступного для плагинов недостаточно. Придется подключать сервер в качестве OEM разделяемой библиотеки (libvirtuoso-t) и при этом немного поколдовать со списком экспортированных функций.
**Схема данных**
Во первых, словарь:
```
create table MRC_WORDS (
WD_ID integer,
WD_ITSELF nvarchar,
WD_COUNT integer,
primary key (WD_ID));
```
Каждая запись содержит само слово, её идентификатор и частоту его встречаемости. Обновлять частоту при каждой вставке текста слишком дорого, поэтому она меняется в памяти и записывается периодически. Как вариант, ее можно актуализировать «по крону». Частота эта может быть полезна для ранжирования, но сейчас мы ее использовать не будем.
Триграммы:
```
create table MRC_TRIPLES (
TR_ID integer identity,
TR_DATA nvarchar,
TR_WORDID integer,
primary key(TR_DATA, TR_WORDID, TR_ID));
```
Каждая запись содержит саму триграмму, идентификатор слова, из которого она пришла и уникальный идентификатор на случай, когда триграмма встретилась в слове несколько раз (Ex: 'эвен*кий*с*кий*')
Списки встречаемости:
```
create table MRC_DATA (
DT_WORDID integer,
DT_OID integer,
DT_COL integer,
DT_POSITION integer,
primary key(DT_WORDID, DT_OID, DT_COL, DT_POSITION));
```
Здесь мы храним, где какое слово в какой позиции встретилось.
Собственно данные:
```
create table MRC_TEXT (
TX_ID integer identity,
TX_AUTHOR nvarchar,
TX_SUBJ nvarchar,
TX_STRING nvarchar,
TX_LONG_STRING long nvarchar,
TX_TS timestamp,
primary key (TX_ID));
```
Все данные в нашей тестовой задаче хранятся в одной таблице, в трех колонках — автор, произведение и текст. Если текст длиннее 500 символов, он попадает в блоб. В жизни тексты, конечно, могут оказаться в разных таблицах и наш индекс окажется многотабличным. Как с этим справляться, написано [здесь](http://habrahabr.ru/post/201474/).
**Триггер вставки**
Всю индексацию мы спрячем внутрь триггера на вставку:
```
create trigger MRC_TEXT_I after insert on MRC_TEXT
{
declare wordid integer;
declare str nvarchar;
str := coalesce(TX_STRING, cast(blob_to_string(TX_LONG_STRING)as nvarchar));
MRC_PROCESS_STR_I(str, TX_ID, 1);
str := TX_SUBJ;
MRC_PROCESS_STR_I(str, TX_ID, 2);
str := TX_AUTHOR;
MRC_PROCESS_STR_I(str, TX_ID, 3);
};
```
Т.е. мы трижды вызываем функцию *MRC\_PROCESS\_STR\_I* для каждого из индексируемых полей:
```
create procedure MRC_PROCESS_STR_I(
in str nvarchar,
in oid integer,
in col integer)
{
if (str is not null) {
declare vec any;
vec := nv_split(str);
declare n any;
declare wordid any;
if (vec <> 0 and vec is not null) {
n := length(vec);
declare i integer;
i := 0;
while (i < n) {
wordid := treat_nword(vec[i]));
if (wordid > 0) {
insert into MRC_DATA (DT_WORDID, DT_OID, DT_COL, DT_POSITION)
values (wordid, oid, col, i);
}
i := i + 1;
}
}
}
};
```
Здесь мы расщепляем строку на отдельные слова с помощью функции *nv\_split*, обрабатываем каждое слово с помощью *treat\_nword* и записываем данные о каждом слове в таблицу *MRC\_DATA*.
Упомянутые *nv\_split* и *treat\_nword* написаны (для этой задачи) на С и доступны через интерфейс плагинов.
С первой всё и так понятно, а вторая должна разобрать слово на триграммы, записать их в соответствующую таблицу, записать слово в таблицу слов и обновить словарь в памяти.
**Словарь в памяти**
Состоит из следующих сущностей:
* *ht\_dict\_* — hash-map, умеющий по utf8 представлению слова доставать его номер
* *ht\_dict\_by\_id\_* — hash-map, который по номеру слова достает его описатель
* *ht\_triples\_* — hash-map, в котором по utf8 значению триграммы мы получаем голову списка всех идентификаторов слов, в которых эта триграмма встретилась
Отдельно следует отметить, при разбиении слова на триграммы в начало и конец слова добавляются пробелы, чтобы обеспечит таким образом бонусы за правильное начало и/или конец слова.
**Словарный поиск**
Результатом словарного поиска является список кандидатов и их похожести на предъявленный образец.
Алгоритм таков:* нормализуем слово, например, приводим к верхнему регистру
* добавляем пробелы в начало и конец слова и разбиваем то что получилось на триграммы
* для каждой триграммы находим список слов где она встретилась
* и для каждого такого слова наращиваем счетчик ссылок
* после обработки триграмм мы оставляем только слова, для которых число ссылок выше некоторого порога,
порогом в данном случае является половина от максимального к-ва ссылок + 1
* для всех оставшихся слов вычисляем их похожесть на исходное слово, в данном случае используется расстояние Левенштейна с дополнительным бонусом за правильное начало слова
* сортируем список слов по идентификаторам
**Структурный поиск**
Задача структурного поиска в нашем случае — исходя из списков кандидатов, выданных словарным поиском, сформировать список идентификаторов записей, в которых встретились кандидаты всех исходных слов.
Пока данных относительно немного, как, например, у нас, можно особо не заботиться о количестве выделяемой памяти и просто загрузить все идентификаторы строк для интересующих нас словарных кандидатов. Итак:
* Для каждого слова запроса у нас есть список кандидатов
* находим идентификаторы всех записей, где встретились эти кандидаты и заносим в список
* сортируем список
* пересекаем списки всех исходных слов и получаем результат — список идентификаторов записей, где встретились все исходные слова
Предположим, данных стало слишком много для того, чтобы держать в памяти все идентификаторы. В этом случае мы:
* Пользуясь тем, что списки встречаемости отсортированы по DT\_WORDID, DT\_OID,…, имеем возможность дёшево загружать данные не целиком, а лишь в диапазоне идентификаторов
* сортировать эти частичные данные
* пересекать списки, получая частичный результат
* приниматься за следующую партию
Отметим отдельно, что если какой-либо словарный кандидат встречается везде неоднократно, возможно, это мусорное слово и его следует просто проигнорировать.
**Ранжирование**
Будем использовать достаточно примитивную схему ранжирования:
* словарную часть оценки(*SCORE*) получим, перемножая нормированные оценки по отдельным попаданиям
* позиционную часть оценки(*POS*) получим, усредняя абсолютные расстояния позиции текущего попадания от позиции предыдущего (имеется ввиду позиция попадания слова в тексте записи)
* итоговая оценка равна *SCORE/(1 + sqrt(POS/5))*
**Поиск через PL/SQL**
Чтобы организовать поток первичных идентификаторов для использования нашего поиска в регулярном SQL, нам потребуется следующая процедура и процедурное view для доступа к ней:
```
create procedure MRC_QUERY_STRING_ALL (
in query varchar)
{
declare vec any;
declare len integer;
result_names('oid','score');
vec := query_phrase(query);
if (vec <> 0 and vec is not null) {
len := length(vec);
declare i integer;
i := 0;
while(i
```
Запрос теперь может выглядеть как:
```
select a.TX_ID, a.TX_TS, b.score, a.TX_AUTHOR, a.TX_SUBJ,
coalesce (a.TX_STRING, blob_to_string(TX_LONG_STRING))
from MRC_TEXT as a, v_query_phrase_all as b
where b.str = 'Posting Date' and a.TX_ID = b.oid;
```
Использованная функция *query\_phrase* является С расширением и осуществляет всю ту низкоуровневую деятельность, о которой говорилось выше.
**Benchmark**
i7-3612QM, Win64.
Заливка 160 254 записей занимает 3 мин 2 сек или 1.14 мсек на запись.
Для тестирования поиска будем искать первые два слова в каждой записи, всего 160 254 поисковых запросов в 1, 2 и 4 потока. Искать будем только число найденных записей, чтобы не учитывать время на подъем и передачу строк. Выполнение запросов осуществляется посредством native ODBC интерфейса, TCP/IP через localhost.
| N потоков | Суммарное время | 1 запрос |
| --- | --- | --- |
| 1 | 11'7'' | 4.16 мсек |
| 2 | 11'57'' | 4.47 мсек |
| 4 | 14'51 | 5.61 мсек |
**~~Выводы~~ Мораль**
Твори, выдумывай, пробуй! (С)Маяковский
**PS**:
**Тексты С функций, вдруг кому пригодятся**#include
#include
#include
#include
#ifdef WIN32
#include
#endif
#include «sqlnode.h»
#include «sqlbif.h»
#include «wi.h»
#include «Dk.h»
#include
#include «caseutils.h»
#include «list\_sort.h»
#include
//#include
static id\_hash\_t \* ht\_dict\_ = NULL;
static dk\_hash\_t \* ht\_dict\_by\_id\_ = NULL;
static id\_hash\_t \* ht\_triples\_ = NULL;
static dk\_mutex\_t \* dict\_mtx\_ = NULL;
struct dict\_item\_s {
char \*word\_;
size\_t id\_;
size\_t count\_;
size\_t attr\_;
};
typedef struct dict\_item\_s dict\_item\_t;
struct triple\_item\_s {
size\_t wordid\_;
struct triple\_item\_s \*next\_;
};
typedef struct triple\_item\_s triple\_item\_t;
struct triple\_head\_s {
lenmem\_t lm\_;
wchar\_t data\_[4];
triple\_item\_t \*list\_;
};
typedef struct triple\_head\_s triple\_head\_t;
const wchar\_t seps\_[] = L" ,.\t\r\n'\"=\*!%^:;~`<>+|?";
const wchar\_t glues\_[] = L"()&@#$:{}/\\-[]\_";
size\_t next\_wordid (caddr\_t \* qst)
{
size\_t \_id = 0;
query\_instance\_t \*q = (query\_instance\_t \*)qst;
client\_connection\_t \*cli = q->qi\_client;
query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
char buf[1024];
sprintf (buf, «select sequence\_next ('MRC\_WORD\_ID')»);
if (NULL == (stmt = sql\_compile (buf, cli, err, 0)))
goto end;
if (NULL != (\*err =
qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL,
0)))
goto end;
end:
if (lc)
{
lc\_next (lc);
\_id = (size\_t)unbox (lc\_nth\_col (lc, 0));
}
if (lc)
{
lc\_free (lc);
lc = NULL;
}
if (stmt)
{
qr\_free (stmt);
stmt = NULL;
}
return \_id;
}
size\_t store\_triple (caddr\_t \* qst, size\_t wordid, const wchar\_t \*triple)
{
query\_instance\_t \*q = (query\_instance\_t \*)qst;
client\_connection\_t \*cli = q->qi\_client;
query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
char buf[1024];
wchar\_t wlt[4];
wcsncpy(wlt, triple, 3);
wlt[3] = 0;
sprintf (buf, "--utf8\_execs=yes\n insert into MRC\_TRIPLES (TR\_DATA, TR\_WORDID) values(?,?)");
if (NULL == (stmt = sql\_compile (buf, cli, err, 0)))
goto end;
if (NULL != (\*err =
qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL, 2,
":0", box\_wide\_string (wlt), QRP\_RAW,
":1", box\_num(wordid), QRP\_RAW
)))
goto end;
{
char\*\*place = NULL;
triple\_item\_t \*pitem = (triple\_item\_t \*)dk\_alloc\_box\_zero(sizeof(triple\_item\_t), DV\_BIN);
triple\_head\_t \*phead = (triple\_head\_t \*)dk\_alloc\_box\_zero(sizeof(triple\_head\_t), DV\_BIN);
phead->lm\_.lm\_length = sizeof(phead->data\_);
phead->lm\_.lm\_memblock = (char\*)phead->data\_;
memcpy(phead->data\_, wlt, sizeof(phead->data\_));
pitem->wordid\_ = wordid;
place = (char \*\*) id\_hash\_get (ht\_triples\_, (caddr\_t) &phead->lm\_);
if (place)
{
triple\_head\_t \*ohead = \*(triple\_head\_t\*\*)place;
pitem->next\_ = ohead->list\_;
ohead->list\_ = pitem;
}
else
{
id\_hash\_set (ht\_triples\_, (caddr\_t)(&phead->lm\_), (caddr\_t)&phead);
pitem->next\_ = pitem;
}
}
end:
if (lc)
{
lc\_free (lc);
lc = NULL;
}
if (stmt)
{
qr\_free (stmt);
stmt = NULL;
}
return 0;
}
wchar\_t \*\*
nv\_split (wchar\_t \*tmp)
{
wchar\_t \*\*arr = NULL;
size\_t len = wcslen (tmp);
size\_t ix = 0;
size\_t i;
size\_t cnt = 0;
for (i = 0; i < len; i++)
{
if (NULL != wcschr (seps\_, tmp[i]))
{
tmp[ix++] = 0;
cnt++;
}
else
{
if (NULL == wcschr (glues\_, tmp[i]))
tmp[ix++] = mrc\_toupper (tmp[i]);
}
}
tmp[ix] = 0;
cnt = 0;
for (i = 0; i < len; i++)
{
if (tmp[i])
{
cnt++;
while (i < len && 0 != tmp[++i]);
}
}
if (cnt)
{
/\* And allocate a vector of once or twice of that many elements. \*/
arr = dk\_alloc\_box ((cnt \* sizeof (caddr\_t)), DV\_ARRAY\_OF\_POINTER);
ix = 0;
for (i = 0; i < len; i++)
{
if (0 != tmp[i])
{
int loclen = wcslen(tmp+i);
((caddr\_t \*) arr)[ix] = ((char \*) dk\_alloc\_box\_zero ((loclen + 1)\*sizeof(wchar\_t), DV\_LONG\_WIDE));
memcpy (((caddr\_t \*) arr)[ix++], tmp + i, (loclen + 1)\*sizeof(wchar\_t));
while (i < len && 0 != tmp[++i]);
}
}
}
return arr;
}
caddr\_t
bif\_nv\_split (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
char \*me = «nv\_split»;
caddr\_t arr = NULL;
caddr\_t arg = bif\_arg\_unrdf (qst, args, 0, me);
dtp\_t dtp = DV\_TYPE\_OF (arg);
if (DV\_DB\_NULL == dtp || NULL == arg)
{
return (NULL);
}
if (IS\_STRING\_DTP(dtp))
{
wchar\_t \*wide = box\_utf8\_as\_wide\_char (arg, NULL, strlen(arg), 0, DV\_WIDE);
arr = (caddr\_t)nv\_split (wide);
dk\_free\_box(wide);
return arr;
}
if (IS\_WIDE\_STRING\_DTP (dtp))
{
wchar\_t \*tmp = wcsdup ((const wchar\_t \*)arg);
arr = (caddr\_t)nv\_split (tmp);
free(tmp);
return arr;
}
{
sqlr\_new\_error («22023», «SR007»,
«Function %s needs a nvstring or NULL as argument, „
“not an arg of type %s (%d)»,
me, 1, dv\_type\_title (dtp), dtp);
}
return arr;
}
caddr\_t
bif\_treat\_nword (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
char \*me = «treat\_nword»;
caddr\_t arg = bif\_arg\_unrdf (qst, args, 0, me);
int len;
const wchar\_t \*wide = (const wchar\_t \*)arg;
const wchar\_t \*newwide = NULL;
wchar\_t \*tmpbuf;
size\_t wordid = 0;
dtp\_t dtp = DV\_TYPE\_OF (arg);
if (DV\_DB\_NULL == dtp)
{
return (NULL);
}
if (!IS\_WIDE\_STRING\_DTP (dtp))
{
sqlr\_new\_error («22023», «SR007»,
«Function %s needs a nvstring or NULL as argument, „
“not an arg of type %s (%d)»,
me, 1, dv\_type\_title (dtp), dtp);
}
len = wcslen(wide);
tmpbuf = (wchar\_t \*)\_alloca (sizeof (wchar\_t) \* (len + 3));
tmpbuf[0] = L' ';
wcscpy(tmpbuf + 1, wide);
tmpbuf[len+1] = L' ';
tmpbuf[len+2] = 0;
newwide = tmpbuf;
mutex\_enter (dict\_mtx\_);
{
char\*utf8 = box\_wide\_as\_utf8\_char ((const char\*)wide, len, DV\_LONG\_STRING);
char\*\*place = NULL;
place = (char \*\*) id\_hash\_get (ht\_dict\_, (caddr\_t) &utf8);
if (place)
{
dict\_item\_t \*pitem = \*(dict\_item\_t \*\*)place;
pitem->count\_++;
dk\_free\_box(utf8);
wordid = pitem->id\_;
}
else
{
query\_instance\_t \*q = (query\_instance\_t \*)qst;
client\_connection\_t \*cli = q->qi\_client;
query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
char buf[1024];
dict\_item\_t \*pitem = dk\_alloc\_box\_zero (sizeof(dict\_item\_t), DV\_BIN);
pitem->word\_ = utf8;
pitem->count\_ = 1;
wordid = next\_wordid(qst);
pitem->id\_ = wordid;
id\_hash\_set (ht\_dict\_, (caddr\_t) &utf8, (caddr\_t) &pitem);
sethash ((void \*)wordid, ht\_dict\_by\_id\_, (void\*)pitem);
sprintf (buf, "--utf8\_execs=yes\n insert into MRC\_WORDS(WD\_ITSELF, WD\_ID) values (?, ?)");
//cast(charset\_recode ('%s', 'UTF-8', '\_WIDE\_') as nvarchar))", wordid, utf8);
if (NULL != (stmt = sql\_compile (buf, cli, err, 0)))
{
\*err =
qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL, 2,
":0", box\_wide\_string (newwide), QRP\_RAW,
":1", box\_num(wordid), QRP\_RAW
);
//\*err = qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL, 0);
}
if (lc)
lc\_free (lc);
if (stmt)
qr\_free (stmt);
{
int len = wcslen(newwide);
int i;
for (i = 0; i < len-2; i++)
{
store\_triple (qst, wordid, newwide + i);
}
}
}
}
mutex\_leave (dict\_mtx\_);
return box\_num(wordid);
}
int64
box2long (caddr\_t arg)
{
dtp\_t dtp = DV\_TYPE\_OF (arg);
if (dtp == DV\_SHORT\_INT || dtp == DV\_LONG\_INT)
return (int64)(unbox (arg));
else if (dtp == DV\_SINGLE\_FLOAT)
return (int64)(unbox\_float (arg));
else if (dtp == DV\_DOUBLE\_FLOAT)
return (int64)(unbox\_double (arg));
else if (dtp == DV\_NUMERIC)
{
int64 dt;
numeric\_to\_int64 ((numeric\_t) arg, &dt);
return dt;
}
else if (dtp == DV\_DB\_NULL)
return (int64)(0);
assert (0);
return 0;
}
void flush\_dict()
{
char \*\*key = NULL;
char \*\*val = NULL;
id\_hash\_iterator\_t hit;
id\_hash\_iterator (&hit, ht\_dict\_);
while (hit\_next (&hit, (caddr\_t\*) &key, (caddr\_t\*) &val))
{
dk\_free\_box(\*key);
dk\_free\_box(\*val);
}
id\_hash\_clear(ht\_dict\_);
}
void flush\_triples()
{
char \*\*key = NULL;
char \*\*val = NULL;
id\_hash\_iterator\_t hit;
id\_hash\_iterator (&hit, ht\_triples\_);
while (hit\_next (&hit, (caddr\_t\*) &key, (caddr\_t\*) &val))
{
triple\_head\_t \*phead = \*(triple\_head\_t\*\*)val;
triple\_item\_t \*pit = phead->list\_;
while (pit)
{
triple\_item\_t \*tmp = pit->next\_;
dk\_free\_box (pit);
pit = tmp;
}
dk\_free\_box(\*val);
}
id\_hash\_clear(ht\_triples\_);
}
size\_t reload\_triples (query\_instance\_t \*qst)
{
client\_connection\_t \*cli = qst->qi\_client;
query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
char buf[1024];
flush\_triples ();
sprintf (buf, «select TR\_DATA, TR\_WORDID from MRC\_TRIPLES»);
if (NULL != (stmt = sql\_compile (buf, cli, err, 0)))
{
\*err = qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL, 0);
if (lc)
{
int64 id = 0;
caddr\_t tmp = 0;
int64 cnt = 0;
char\*utf8 = NULL;
char\*\*place = NULL;
lenmem\_t lm;
triple\_head\_t \*phead = NULL;
triple\_head\_t \*ohead = NULL;
triple\_item\_t \*pitem = NULL;
while (lc\_next (lc))
{
if (lc->lc\_error)
{
\*err = box\_copy\_tree (lc->lc\_error);
break;
}
id = box2long (lc\_nth\_col (lc, 1));
tmp = lc\_nth\_col (lc, 0);
pitem = (triple\_item\_t \*)dk\_alloc\_box\_zero(sizeof(triple\_item\_t), DV\_BIN);
pitem->wordid\_ = (size\_t)id;
lm.lm\_length = sizeof (phead->data\_);
lm.lm\_memblock = (caddr\_t)tmp;
place = (char \*\*) id\_hash\_get (ht\_triples\_, (caddr\_t) &lm);
if (place)
{
ohead = \*(triple\_head\_t \*\*)place;
pitem->next\_ = ohead->list\_;
ohead->list\_ = pitem;
}
else
{
phead = (triple\_head\_t \*)dk\_alloc\_box\_zero(sizeof(triple\_head\_t), DV\_BIN);
phead->list\_ = pitem;
phead->lm\_.lm\_length = sizeof (phead->data\_);
phead->lm\_.lm\_memblock = (caddr\_t)phead->data\_;
memcpy(phead->data\_, tmp, sizeof (phead->data\_));
pitem->next\_ = NULL;
id\_hash\_set (ht\_triples\_, (caddr\_t) &phead->lm\_, (caddr\_t) &phead);
}
}
}
}
if (lc)
lc\_free (lc);
if (stmt)
qr\_free (stmt);
return 0;
}
caddr\_t
bif\_reload\_dict (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
query\_instance\_t \*q = (query\_instance\_t \*)qst;
client\_connection\_t \*cli = q->qi\_client;
query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
char buf[1024];
mutex\_enter (dict\_mtx\_);
flush\_dict();
sprintf (buf, «select WD\_ID, WD\_ITSELF, WD\_COUNT from MRC\_WORDS»);
if (NULL != (stmt = sql\_compile (buf, cli, err, 0)))
{
\*err = qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) qst, NULL, 0);
if (lc)
{
int64 id = 0;
caddr\_t tmp = 0;
int64 cnt = 0;
char\*utf8 = NULL;
char\*\*place = NULL;
size\_t maxid = 0;
while (lc\_next (lc))
{
if (lc->lc\_error)
{
\*err = box\_copy\_tree (lc->lc\_error);
break;
}
id = box2long (lc\_nth\_col (lc, 0));
tmp = lc\_nth\_col (lc, 1);
cnt = box2long (lc\_nth\_col (lc, 2));
utf8 = box\_wide\_as\_utf8\_char (tmp, box\_length (tmp) / sizeof (wchar\_t) — 1, DV\_LONG\_STRING);
place = (char \*\*) id\_hash\_get (ht\_dict\_, (caddr\_t) &utf8);
if (place)
{
assert(0);
}
else
{
dict\_item\_t \*pitem = dk\_alloc\_box\_zero (sizeof(dict\_item\_t), DV\_BIN);
pitem->word\_ = utf8;
pitem->count\_ = 1;
pitem->id\_ = (size\_t)id;
if (maxid < id)
maxid = id;
id\_hash\_set (ht\_dict\_, (caddr\_t) &utf8, (caddr\_t) &pitem);
sethash ((void \*)id, ht\_dict\_by\_id\_, (void\*)pitem);
}
}
}
}
if (lc)
lc\_free (lc);
if (stmt)
qr\_free (stmt);
reload\_triples(q);
mutex\_leave (dict\_mtx\_);
return 0;
}
//---------------------------------------------------------------------------
// l\_dist\_raw()
// static/local function!!!
//
// Purpose: Calculates the L Distance for the two strings (words).
//
// Inputs: char \*str1, \*str2 — input strings (words) to compair
// int len1,len2 — the shorter of the length of str1 amd str2
// respectively or MAX\_LDIST\_LEN.
// NOTE! No error checking is done.
// Array overflow on the stack will result
// if either is out of range.
// Outputs: none
//
// Returns: L Distance value is returned
//
// Note, there are two defines immediately after this comment header that
// are only used by this function.
//
// (values in all CAPS are defined in the LDIST.H header file)
//
//---------------------------------------------------------------------------
#define MAX\_LDIST\_LEN 40 // max word len to compair
#define MIN3(a,b,c) (a < b? \
(a < c? a: c): \
(b < c? b: c))
int
l\_dist\_raw(const wchar\_t \*str1, const wchar\_t \*str2, int len1, int len2)
{
int arr1[MAX\_LDIST\_LEN+1];
int arr2[MAX\_LDIST\_LEN+1];
int i, j;
if (len1 > MAX\_LDIST\_LEN)
len1 = MAX\_LDIST\_LEN;
if (len2 > MAX\_LDIST\_LEN)
len2 = MAX\_LDIST\_LEN;
for (i = 0; i <= len2; i++)
arr1[i] = i;
for (i = 1; i <= len1; i++)
{
arr2[0] = i;
for (j = 1; j <= len2; j++)
{
int score = (str1[i-1] == str2[j-1])?0:1;
int i1 = arr2[j-1]+1;
int i2 = arr1[j]+1;
int i3 = arr1[j-1] + score;
arr2[j] = MIN3 (i1, i2, i3);//arr2[j-1]+1, arr1[j]+1, arr1[j] + score);
//d[(j-1)\*n+i]+1, d[j\*n+i-1]+1, d[(j-1)\*n+i-1]+cost);
}
memcpy (arr1, arr2, sizeof (int)\*(len2+1));
}
return arr2[len2];
}
struct ipair\_s {
ptrlong id\_;
ptrlong len\_;
ptrlong pos\_;
ptrlong score\_;
};
typedef struct ipair\_s ipair\_t;
int
cmp\_pairs (const void \*a,const void \*b)
{
const ipair\_t \*pa = \*(const ipair\_t \*\*)a;
const ipair\_t \*pb = \*(const ipair\_t \*\*)b;
if (pb->id\_ == pa->id\_)
return pa->score\_ — pb->score\_;
return pa->id\_ — pb->id\_;
}
int compare\_by\_id(const void \*a, const void \*b, const void \*arg)
{
ipair\_t \*pa = (ipair\_t\*)a;
ipair\_t \*pb = (ipair\_t\*)b;
return pa->id\_ — pb->id\_;
}
int compare\_by\_score(const void \*a, const void \*b, const void \*arg)
{
ipair\_t \*pa = (ipair\_t\*)a;
ipair\_t \*pb = (ipair\_t\*)b;
return pb->score\_ — pa->score\_;
}
dk\_set\_t
load\_oid\_list (ipair\_t \*\*words, query\_instance\_t \*q, mem\_pool\_t \* mp)
{
client\_connection\_t \*cli = q->qi\_client;
/\*static\*/ query\_t \*stmt = NULL;
local\_cursor\_t \*lc = NULL;
caddr\_t lerr = NULL;
caddr\_t \* err = &lerr
dk\_set\_t out\_list = NULL;
char buf[1024];
dk\_set\_t pairs\_list = NULL;
ipair\_t \*item = NULL;
size\_t i = 0;
size\_t len = box\_length(words)/sizeof(ipair\_t\*);
size\_t cnt = 0;
if (NULL == stmt)
{
sprintf (buf, «select DT\_OID, DT\_POSITION from MRC\_DATA where DT\_WORDID =? „);
if (NULL == (stmt = sql\_compile\_static (buf, /\*bootstrap\_\*/cli, err, 0)))
return NULL;
}
for (i = 0; i< len; i++)
{
size\_t id;
ipair\_t \*pair = words[i];
//printf(“\n---%d -----\n»,pair->id\_);
\*err = qr\_rec\_exec (stmt, cli, &lc, (query\_instance\_t \*) q, NULL, 1,
":0", box\_num (pair->id\_), QRP\_RAW);
if (NULL == lc)
continue;
while (lc\_next (lc))
{
if (lc->lc\_error)
{
\*err = box\_copy\_tree (lc->lc\_error);
break;
}
id = box2long (lc\_nth\_col (lc, 0));
item = (ipair\_t\*)mp\_alloc\_box(mp, sizeof(ipair\_t), DV\_ARRAY\_OF\_LONG);
item->id\_ = id;
item->len\_ = pair->len\_;
item->pos\_ = box2long (lc\_nth\_col (lc, 1));
item->score\_ = pair->score\_;
mp\_set\_push (mp, &pairs\_list, item);
cnt++;
// printf("%d ", id);
}
if (lc)
lc\_free (lc);
}
if (stmt)
qr\_free (stmt);
//if (stmt)
// qr\_free (stmt);
//printf("+%d+", cnt);
return list\_sort (pairs\_list, compare\_by\_id, NULL);
}
ipair\_t \*\*
get\_word\_candidates (wchar\_t \*arg)
{
ipair\_t \*\*res = NULL;
dk\_set\_t ids\_list = NULL;
caddr\_t arr = NULL;
{
dk\_hash\_t \*ht\_ids = NULL;
int maxcount = 1;
size\_t i;
wchar\_t \*word = (wchar\_t\*)arg;
wchar\_t \*pbuf = NULL;
size\_t isnum = ((\*word) >= L'0' && (\*word) <= L'9');
size\_t len = wcslen (word);
//int slen = len;
if (len < 3 && !isnum)
{
return NULL;
}
word = (wchar\_t\*)box\_copy (word);
mrc\_toupper\_str (word);
pbuf = (wchar\_t \*)\_alloca (sizeof (wchar\_t) \* (len + 3));
pbuf[0] = L' ';
wcscpy (pbuf + 1, word);
pbuf[len + 1] = L' ';
pbuf[len + 2] = L'\0';
ht\_ids = hash\_table\_allocate (101);
mutex\_enter (dict\_mtx\_);
for (i = 0; i < (len); i++)
{
char\*\*place = NULL;
lenmem\_t lm;
triple\_head\_t \*phead = NULL;
triple\_item\_t \*pitem = NULL;
wchar\_t trbuf[4];
trbuf[0] = mrc\_toupper(pbuf[i]);
trbuf[1] = mrc\_toupper(pbuf[i + 1]);
trbuf[2] = mrc\_toupper(pbuf[i + 2]);
trbuf[3] = L'\0';
lm.lm\_length = sizeof (phead->data\_);
lm.lm\_memblock = (caddr\_t)trbuf;
place = (char \*\*) id\_hash\_get (ht\_triples\_, (caddr\_t) &lm);
if (place)
{
phead = \*(triple\_head\_t\*\*)place;
pitem = phead->list\_;
while(pitem)
{
int wordid = pitem->wordid\_;
int ptr = (int)gethash ((void \*)wordid, ht\_ids);
if (0 == ptr)
sethash ((void \*)wordid, ht\_ids, (void\*)1);
else
{
sethash ((void \*)wordid, ht\_ids, (void\*)(++ptr));
if (ptr > maxcount)
maxcount = ptr;
}
pitem = pitem->next\_;
}
}
}
mutex\_leave (dict\_mtx\_);
{
dk\_set\_t pairs\_list = NULL;
int nids = 0;
int mx = maxcount;
int nallids = ht\_ids->ht\_count;
void \*key, \*val;
dk\_hash\_iterator\_t hit;
maxcount = (maxcount + 1)/2;
if (maxcount >= len)
maxcount = len — 1;
for (dk\_hash\_iterator (&hit, ht\_ids);
dk\_hit\_next (&hit, (void\*\*) &key, (void\*\*) &val);
/\* \*/)
{
int wordid = (int)key;
int cnt = (int)val;
if (cnt >= maxcount)
{
dict\_item\_t \*pptr = (dict\_item\_t \*)gethash ((void \*)wordid, ht\_dict\_by\_id\_);
if(pptr)
{
ipair\_t \*item = NULL;
wchar\_t buf[128];
size\_t lbuf, dist, score;
box\_utf8\_as\_wide\_char ((caddr\_t)pptr->word\_, (caddr\_t)buf, strlen(pptr->word\_), 127, DV\_WIDE);
lbuf = wcslen(buf);
dist = l\_dist\_raw(word, buf, len, lbuf);
score = 100 — (dist \* 100)/((len > lbuf)? len: lbuf);
//score = 100 — (dist \* 200)/(len + lbuf);
if (word[0] != buf[0])
score = (score \* 3)>>2;
//score = 100 — (dist \* 100)/((len > lbuf)? len: lbuf);
//wprintf (L"%s -> %s (%d)\n", word, buf, score);
item = (ipair\_t\*)dk\_alloc\_box(sizeof(ipair\_t), DV\_ARRAY\_OF\_LONG);
item->id\_ = wordid;
item->len\_ = lbuf;
item->score\_ = score;
dk\_set\_push (&pairs\_list, item);
nids++;
}
assert(pptr);
}
}
if (pairs\_list)
{
res = (ipair\_t\*\*)dk\_set\_to\_array (pairs\_list);
dk\_set\_free (pairs\_list);
assert(nids == box\_length(res)/sizeof(void\*));
qsort (res, nids, sizeof (void\*), cmp\_pairs);
}
}
hash\_table\_free (ht\_ids);
dk\_free\_box(word);
}
return res;
}
caddr\_t
bif\_get\_word\_candidates (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
char \*me = «get\_word\_candidates»;
ipair\_t \*\*res = NULL;
dk\_set\_t ids\_list = NULL;
caddr\_t arr = NULL;
caddr\_t arg = bif\_arg\_unrdf (qst, args, 0, me);
dtp\_t dtp = DV\_TYPE\_OF (arg);
if (DV\_DB\_NULL == dtp)
{
return (NULL);
}
if (!IS\_WIDE\_STRING\_DTP (dtp))
{
sqlr\_new\_error («22023», «SR007»,
«Function %s needs a nvstring or NULL as argument, „
“not an arg of type %s (%d)»,
me, 1, dv\_type\_title (dtp), dtp);
}
if (0 == ht\_dict\_->ht\_count)
{
bif\_reload\_dict (qst, err\_ret, args);
}
res = get\_word\_candidates ((wchar\_t\*)arg);
ids\_list = load\_oid\_list (res, (query\_instance\_t \*)qst, NULL);
DO\_SET (ipair\_t \*, item, &ids\_list)
{
//printf ("%d ", item->id\_);
dk\_free\_box(item);
}
END\_DO\_SET ();
return (caddr\_t)res;
}
caddr\_t
bif\_calc\_similarity (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
char \*me = «calc\_similarity»;
caddr\_t arg1 = bif\_arg\_unrdf (qst, args, 0, me);
caddr\_t arg2 = bif\_arg\_unrdf (qst, args, 1, me);
dtp\_t dtp1 = DV\_TYPE\_OF (arg1);
dtp\_t dtp2 = DV\_TYPE\_OF (arg2);
if (DV\_DB\_NULL == dtp1 || DV\_DB\_NULL == dtp2)
{
return (NULL);
}
if ((!IS\_WIDE\_STRING\_DTP (dtp1)) || (!IS\_WIDE\_STRING\_DTP (dtp2)))
{
sqlr\_new\_error («22023», «SR007»,
«Function %s needs a nvstring or NULL as arguments, „);
}
{
wchar\_t \*str1 = (wchar\_t\*)arg1;
wchar\_t \*str2 = (wchar\_t\*)arg2;
int l1 = wcslen(str1);
int l2 = wcslen(str2);
int dist = l\_dist\_raw(str1, str2, l1, l2);
int score = 100 — (dist \* 100)/((l1 > l2)? l1: l2);
if (str1[0] != str2[0])
score = (score \* 3)>>2;
return score;
}
}
static int g\_cnt = 0;
#if defined WIN32 && defined (\_DEBUG)
static \_CrtMemState checkPt1;
#endif
long sqrt\_long(long r)
{
long t, b, c = 0;
assert (r >= 0);
for (b=0x10000000; b != 0; b >>= 2)
{
t = c + b;
c >>= 1;
if (t <= r)
{
r -= t;
c += b;
}
}
return©;
}
caddr\_t
bif\_query\_phrase (caddr\_t \* qst, caddr\_t \* err\_ret, state\_slot\_t \*\* args)
{
char \*me = “query\_phrase»;
wchar\_t \*\*words = NULL;
ptrlong \*res = NULL;
wchar\_t \*tmp = NULL;
dk\_set\_t ids\_list = NULL;
caddr\_t arr = NULL;
caddr\_t arg = bif\_arg\_unrdf (qst, args, 0, me);
dtp\_t dtp = DV\_TYPE\_OF (arg);
int len = 0;
mem\_pool\_t \*mp = mem\_pool\_alloc();
#if 0//defined WIN32 && defined (\_DEBUG)
\_CrtCheckMemory( );
\_CrtMemCheckpoint( &checkPt1 );
#endif
//if (0 == (g\_cnt%1000))
//printf ("%d ", g\_cnt);
++g\_cnt;
if (DV\_DB\_NULL == dtp)
{
return (NULL);
}
if (IS\_STRING\_DTP(dtp))
{
tmp = box\_utf8\_as\_wide\_char (arg, NULL, strlen(arg), 0, DV\_WIDE);
words = nv\_split (tmp);
dk\_free\_box(tmp);
}
else if (IS\_WIDE\_STRING\_DTP (dtp))
{
tmp = wcsdup ((const wchar\_t \*)arg);
words = nv\_split (tmp);
free(tmp);
}
else
{
sqlr\_new\_error («22023», «SR007»,
«Function %s needs a nvstring or NULL as argument, „
“not an arg of type %s (%d)»,
me, 1, dv\_type\_title (dtp), dtp);
}
if (0 == ht\_dict\_->ht\_count)
{
bif\_reload\_dict (qst, err\_ret, args);
}
//mutex\_enter (dict\_mtx\_);
if (words)
{
size\_t niters = box\_length(words)/sizeof(void\*);
dk\_set\_t results = NULL;
dk\_set\_t \*iter\_holders = mp\_alloc\_box (mp, niters \* sizeof(dk\_set\_t), DV\_ARRAY\_OF\_POINTER);
dk\_set\_t \*iters = mp\_alloc\_box (mp, niters \* sizeof(dk\_set\_t), DV\_ARRAY\_OF\_POINTER);
size\_t i = 0;
size\_t ix = 0;
size\_t cnt = 0;
size\_t cnt1 = 0;
for (i = 0; i
{
ipair\_t \*\*res = get\_word\_candidates ((wchar\_t\*)words[i]);
if (res)
{
iter\_holders[ix] = load\_oid\_list (res, (query\_instance\_t \*)qst, mp);
iters[ix] = iter\_holders[ix];
ix++;
dk\_free\_tree (res);
}
}
niters = ix;
if (niters)
{
int64 min\_elem = 0;
int fin = 0;
for (;!fin;)
{
int bfound = 1;
size\_t div = 1;
size\_t score = 1;
size\_t sumpos = 0;
size\_t oldpos = 0;
if (!iters[0])
break;
min\_elem = ((ipair\_t \*)iters[0]->data)->id\_;
for (i = 0; i
{
if (iters[i])
{
ipair\_t \*ptr = (ipair\_t \*)iters[i]->data;
div \*= 100;
score \*= ptr->score\_;
if (i)
{
sumpos += abs (oldpos — ptr->pos\_);
}
oldpos = ptr->pos\_;
if (ptr->id\_ != min\_elem)
{
bfound = 0;
}
if (ptr->id\_ < min\_elem)
{
min\_elem = ptr->id\_;
}
}
}
if (bfound)
{
ipair\_t \*item = mp\_alloc\_box(mp, sizeof(ipair\_t), DV\_BIN);
div /= 100;
score /= div;
if (niters > 1)
sumpos /= (niters — 1);
item->id\_ = min\_elem;
item->score\_ = score/(1 + (sqrt\_long(((100\*sumpos)/5))/10));
mp\_set\_push(mp, &results, item);
cnt1++;
//printf («FOUND:%I64d %d\n», min\_elem, score);
}
for (i = 0; i
{
int bf = bfound;
while (iters[i] && (bf || min\_elem == ((ipair\_t \*)iters[i]->data)->id\_))
{
bf = 0;
iters[i] = iters[i]->next;
}
if (!iters[i])
{
fin = 1;
break;
}
}
}
}
for (i = 0; i
{
DO\_SET (ipair\_t \*, item, &iter\_holders[i])
{
cnt++;
//dk\_free\_box(item);
}
END\_DO\_SET ();
}
//dk\_free\_box (iters);
//dk\_free\_box (iter\_holders);
//printf ("-%d-", cnt);
len = dk\_set\_length(results);
//if (len > 100)
{
results = list\_sort (results, compare\_by\_score, NULL);
i = 0;
DO\_SET (ipair\_t \*, entry, &results)
{
entry->len\_ = (i >= 100)? 0:1;
i++;
}
END\_DO\_SET();
len = (len>100)?100:len;
}
//results = list\_sort (results, compare\_by\_id, NULL);
i = 0;
res = dk\_alloc\_box(len \* 2 \* sizeof(ptrlong), DV\_ARRAY\_OF\_LONG);
DO\_SET (ipair\_t \*, entry, &results)
{
if (entry->len\_)
{
res[i++] = (entry->id\_);
res[i++] = (entry->score\_);
}
//dk\_free\_box(entry);
cnt1--;
}
END\_DO\_SET();
//dk\_set\_free (results);
dk\_free\_tree (words);
//printf("(%d)", cnt1);
}
//mutex\_leave (dict\_mtx\_);
mp\_free (mp);
#if 0//defined WIN32 && defined (\_DEBUG)
// \_CrtMemDumpAllObjectsSince( NULL );
\_CrtMemDumpAllObjectsSince( &checkPt1 );
\_CrtMemCheckpoint( &checkPt1 );
\_CrtMemDumpStatistics( &checkPt1 );
\_CrtCheckMemory( );
#endif
return (caddr\_t)res;
}
void
init\_dict (void)
{
dict\_mtx\_ = mutex\_allocate ();
ht\_dict\_ = id\_hash\_allocate (2039, sizeof (caddr\_t), sizeof (caddr\_t), strhash, strhashcmp);
ht\_triples\_ = id\_hash\_allocate (2039, sizeof (lenmem\_t), sizeof (caddr\_t), lenmemhash, lenmemhashcmp);
ht\_dict\_by\_id\_ = hash\_table\_allocate (2039);
bif\_define («nv\_split», bif\_nv\_split);
bif\_define («treat\_nword», bif\_treat\_nword);
bif\_define («calc\_similarity», bif\_calc\_similarity);
bif\_define («reload\_dict», bif\_reload\_dict);
bif\_define («get\_word\_candidates», bif\_get\_word\_candidates);
bif\_define («query\_phrase», bif\_query\_phrase);
}
void finit\_dict()
{
flush\_triples();
flush\_dict();
hash\_table\_free (ht\_dict\_by\_id\_);
id\_hash\_free (ht\_triples\_);
id\_hash\_free (ht\_dict\_);
mutex\_free (dict\_mtx\_);
}
extern int f\_foreground;
int
main (int argc, char \*argv[])
{
/\*f\_foreground = 1;
\* FIXME: this could not be done in that way; this is a GPF on WIN32 and
\* copy on write on linux; a fuinction from the shared object must be used
\* to set it
\*/
#ifdef MALLOC\_DEBUG
dbg\_malloc\_enable();
#endif
build\_set\_special\_server\_model («Mircalo»);
VirtuosoServerSetInitHook (init\_dict);
return VirtuosoServerMain (argc, argv);
}
**PPS**: в качестве иллюстрации использована работа Владимира Румянцева, изображение которой взято [здесь](http://blogs.privet.ru/community/Cultural_groups/103537706). | https://habr.com/ru/post/206066/ | null | ru | null |
# Преодолеваем скрытые опасности KVO в Objective C
*The major difference between a thing that might go wrong and a thing that cannot possibly go wrong is that when a thing that cannot possibly go wrong goes wrong it usually turns out to be impossible to get at or repair.
— Douglas Adams*
Objective C существует уже с 1983 года и является ровесником C++. Однако, в отличие от последнего он начал приобретать популярность только в 2008 году, после выхода iOS 2.0 — новой версии операционной системы для революционного iPhone, включавшей приложение AppStore, позволяющее пользователям приобретать приложения, создаваемые сторонними разработчиками.
Дальнейший успех Objective C обеспечивался не только популярность устройств на базе iOS и относительной легкостью продаж через AppStore, но и значительными усилиями компании Apple по совершенствованию как стандартных библиотек, так и самого языка.
Согласно [рейтингу TIOBE](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html) к началу 2013 года Objective C обогнал по популярности C++ и занял третье место, уступая только C и Java.
На сегодняшний день Objective C включает и такие относительно старые функции как [KVC](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueCoding/Articles/KeyValueCoding.html) и [KVO](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html), существовавшие еще за 4 года до выхода первого iPhone, и такие новые возможности как [блоки](https://developer.apple.com/library/ios/documentation/cocoa/Conceptual/Blocks/Articles/00_Introduction.html) (blocks, появившиеся в Mac OS 10.6 и iOS 4) и [автоматический подсчет ссылок](https://developer.apple.com/library/mac/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html) (ARC, доступный в Mac OS 10.7 и iOS 5), которые позволяют с легкостью решать задачи, вызывавшие серьезные трудности ранее.
KVO — это технология, позволяющая незамедлительно реагировать в одном объекте (наблюдателе) на изменения состояния другого объекта (наблюдаемого), без внесения знаний о типе наблюдателя в реализации наблюдаемого объекта. В Objective C, наряду с KVO, существует несколько способов решения этой задачи:
1. [Делегирование](https://developer.apple.com/library/ios/documentation/general/conceptual/CocoaEncyclopedia/DelegatesandDataSources/DelegatesandDataSources.html) — распространенный паттерн объектно-ориентированного программирования, состоящий в том, что объекту передается ссылка на произвольный объект (называемый делегатом), реализующий определенный [протокол](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html) — фиксированный набор селекторов. После этого реализация объекта «вручную» посылает своему делегату соответствующие случаю сообщения. Например, [UIScrollView](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIScrollView_Class/Reference/UIScrollView.html) оповещает своего делегата об изменении значения своего свойства contentOffset, вызывая селектор [scrollViewDidScroll](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIScrollViewDelegate_Protocol/Reference/UIScrollViewDelegate.html#//apple_ref/occ/intfm/UIScrollViewDelegate/scrollViewDidScroll:):.
Рекомендуется одним из параметров всех селекторов протокола делать ссылку на сам вызывающий его объект, чтобы в случае, когда один и тот же объект является делегатом нескольких объектов одного класса, иметь возможность различить, от кого из них пришло сообщение.
2. [Target-action](https://developer.apple.com/library/mac/documentation/General/Conceptual/CocoaEncyclopedia/Target-Action/Target-Action.html). Отличие этой техники от делегирования заключается в том, что вместо реализации «делегатом» определенного протокола, вместе с ним передается его селектор, который и будет вызван при определенном событии. Эта техника чаще всего используется наследниками [UIControl](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIControl_Class/Reference/Reference.html), например, объекту [UISwitch](https://developer.apple.com/library/ios/documentation/uikit/reference/UISwitch_Class/Reference/Reference.html) можно задать пару target-action для вызова при переключении этого контрола пользователем (событии UIControlEventValueChanged). Такое решение более удобно, нежели делегирование, в случае, когда один объект-«цель» должен реагировать на одинаковые события от разных источников (например, нескольких UISwitch).
3. Callback block. Это решение состоит в том, что наблюдаемому объекту передается ссылка не на сам объект-наблюдатель, а на блок. Как правило этот блок создается в том же месте, где и устанавливается. При этом реализация блока способна захватывать значения локальных переменных того scope, где он определен, избавляя от необходимости добавлять отдельный метод и восстанавливать контекст внутри его реализации.
Важным отличием этого подхода от предыдущих является то, что если ссылка на делегат или target является слабой (weak reference), то ссылка на блок является сильной (обычно она же оказывается единственной), и программисту нужно каждый раз при реализации блоков заботиться о том, чтобы блок захватывал объекты по слабым ссылкам. Иначе это может привести к циклическим сильным связям и утечкам памяти.
Так же, как и в первых двух техниках, одним из аргументов блока рекомендуется делать ссылку на вызывающий его объект, но по несколько иной причине. Несмотря на то, что блок и так может захватить эту ссылку из контекста, при этом легко по ошибке захватить объект по сильной ссылке, либо [захватить nil](http://stackoverflow.com/questions/8113268/how-to-cancel-nsblockoperation), которым эта ссылка была инициализирована.
4. [NSNotificationCenter](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Notifications/Introduction/introNotifications.html) позволяет из любого метода любого класса отправлять оповещения (NSNotification), состоящие из строкового имени и произвольного объекта. Такое оповещение будет получено любыми объектами, подписавшимися на оповещения с таким именем и (опционально) объектом. Подписка на оповещения реализуется либо по принципу target-action, либо при помощи callback block.
В отличие от предыдущих подходов, использование NSNotificationCenter приводит к более слабым зависимостям между объектами и позволяет без дополнительных усилий подписывать несколько объектов на одно и то же оповещение.
5. [NSKeyValueObserving](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Protocols/NSKeyValueObserving_Protocol/Reference/Reference.html) является неформальным протоколом, реализованным в классе NSObject, позволяющим подписать произвольный объект (наблюдатель) на изменения значения по указанному key path указанного другого объекта (наблюдаемого), вызвав на нем селектор addObserver:forKeyPath:options:context:. После этого при каждом изменении значения наблюдатель будет получать сообщение observeValueForKeyPath:ofObject:change:context:, аналогично паттерну делегирования.
Таким образом KVO позволяет подписывать неограниченное число объектов на изменения не только отдельного атрибута, но и значений по составному key path наблюдаемого объекта, как правило без каких-либо модификаций последнего.
Несмотря на очевидную мощь KVO, он не пользуется большой популярностью среди разработчиков, и зачастую к нему относятся как к крайней мере, прибегая только когда другие решения недоступны. Чтобы попытаться понять (и исправить) причины такой нелюбви, рассмотрим пару примеров использования KVO.
Предположим, у нас есть класс ETRDocument, имеющий атрибуты title и isFavorite
```
@interface ETRDocument : NSObject
@property (nonatomic, copy) NSString *title;
@property (nonatomic) BOOL isFavorite;
@end
```
и мы хотим реализовать табличную ячейку, отображающую информацию о документе
```
@class ETRDocument;
@interface ETRDocumentCell : UITableViewCell
@property (nonatomic, strong) ETRDocument *document;
@property (nonatomic, strong) IBOutlet UILabel *titleLabel;
@property (nonatomic, strong) IBOutlet UIButton *isFavoriteButton;
- (IBAction)toggleIsFavorite;
@end
@implementation ETRDocumentCell
- (void)updateIsFavoriteButton
{
self.isFavoriteButton.selected = self.document.isFavorite;
}
- (void)toggleIsFavorite
{
self.document.isFavorite = !self.document.isFavorite;
[self updateIsFavoriteButton];
}
- (void)setDocument:(ETRDocument *)document
{
_document = document;
self.titleLabel.text = self.document.title;
[self updateIsFavoriteButton];
}
@end
```
Предположим, мы обнаруживаем, что значение isFavorite может быть изменено не только нажатием кнопки, но и некоторым внешним по отношению к ячейке способом. Это никак не отразится на внешнем виде ячейки, что следует исправить. Мы могли бы при изменении isFavorite вручную находить ячейки и обновлять их, вызывая updateIsFavoriteButton, но это создало бы лишние связи между классами и нарушило инкапсуляцию нашей ячейки. Поэтому мы решаем подписать саму ячейку на изменения в документе. Мы могли бы сделать ее делегатом документа, или посылать нотификации при изменении isFavorite, однако если мы вместо этого используем KVO, нам не нужно будет делать в классе документа никаких изменений: вся дополнительная логика будет инкапсулирована в классе ячейки.
```
- (void)startObservingIsFavorite
{
[self.document addObserver:self
forKeyPath:@"isFavorite"
options:0
context:NULL];
}
- (void)stopObservingIsFavorite
{
[self.document removeObserver:self
forKeyPath:@"isFavorite"];
}
- (void)setDocument:(ETRDocument *)document
{
[self stopObservingIsFavorite];
_document = document;
[self startObservingIsFavorite];
self.titleLabel.text = self.document.title;
[self updateIsFavoriteButton];
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
[self updateIsFavoriteButton];
}
```
Запускаем — всё работает, ячейка реагирует на изменение isFavorite. Мы даже можем убрать вызов updateIsFavoriteButton из toggleIsFavorite. Однако стоит закрыть таблицу и изменить значение isFavorite у одного из документов, как приложение падает с EXC\_BAD\_ACCESS.
Что же произошло? Попробуем включить [NSZombieEnabled](https://developer.apple.com/library/ios/technotes/tn2239/_index.html#//apple_ref/doc/uid/DTS40010638-CH1-SUBSECTION30) и повторить действия. На этот раз мы получаем более осмысленное сообщение при падении:
\*\*\* -[ETRDocumentCell retain]: message sent to deallocated instance 0x8bcda20
Действительно, заглянув в документацию по KVO мы увидим [следующее](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueObserving/Articles/KVOBasics.html#//apple_ref/doc/uid/20002252-178352):
Note: The key-value observing addObserver:forKeyPath:options:context: method does not maintain strong references to the observing object, the observed objects, or the context. You should ensure that you maintain strong references to the observing, and observed, objects, and the context as necessary.
Наблюдение не создает сильных ссылок ни на наблюдателя, ни на наблюдаемый объект, ни на контекст. Однако документация умалчивает о том, что же произойдет, когда один из этих объектов будет удален.
Контекст для KVO является обычным указателем из языка C. Даже если он указывает на объект Objective C, KVO не будет рассматривать его как таковой: не будет слать ему сообщений или отслеживать его время жизни. Следовательно, если контекст будет удален, то в observeValueForKeyPath будет передана «висячая» ссылка, и попытка передать по ней сообщение приведет к последствиям, аналогичным тем, которые имеем мы. Однако мы не использовали в нашем примере контекст. Более того, далее станет ясно, что контекст имеет несколько иное «истинное» предназначение.
Если удаленным окажется наблюдаемый объект, то вместо того, чтобы прекратить наблюдение (ведь никакие значения меняться больше не могут), в консоль будет выведено предупреждение:
An instance 0xac62490 of class ETRDocument was deallocated while key value observers were still registered
with it. Observation info was leaked, and may even become mistakenly attached to some other object.
Set a breakpoint on NSKVODeallocateBreak to stop here in the debugger. Here's the current observation info:
(
Context: 0x0, Property: 0xabf12e0>
)
после которого приложение будет вести себя непредсказуемым образом, и рано или поздно упадет. Однако в нашем случае ячейка хранит сильную ссылку на наблюдаемый объект, и он не может быть удален раньше, чем будет удалена ячейка.
Если же будет удален наблюдатель, KVO сохранит «висячую» ссылку на него (что соответствует модификатору unsafe\_unretained в терминологии ARC), и будет посылать по ней сообщения при изменениях. Именно это и происходит в нашем примере. Возможно, в последующих версиях поведение «unsafe\_unretained» будет заменено на более безопасное «weak», и «висячие» ссылки на наблюдателей будут автоматически обнуляться.
Чтобы исправить это падение, достаточно вызвать stopObservingIsFavorite из dealloc.
Существует способ несколько упростить логику нашей ячейки. Вместо наблюдения по key path «isFavorite» документа, ячейка может наблюдать key path «document.isFavorite» на самой себе. В результате ячейка будет оповещена как при изменении атрибута isFavorite в связанном документа, так и при изменении своей ссылки на документ. При этом по-прежнему необходимо вызывать removeObserver из dealloc, но не нужно прекращать и начинать наблюдение каждый раз при смене текущего документа.
Можно пойти дальше, и наблюдать не только isFavorite, но и title. Это избавит нас от переопределения setDocument:, но столкнет с еще одним неудобством KVO:
```
@implementation ETRDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
[self addObserver:self
forKeyPath:@"document.isFavorite"
options:0
context:NULL];
[self addObserver:self
forKeyPath:@"document.title"
options:0
context:NULL];
}
- (void)dealloc
{
[self removeObserver:self
forKeyPath:@"document.isFavorite"];
[self removeObserver:self
forKeyPath:@"document.title"];
}
- (void)toggleIsFavorite
{
self.document.isFavorite = !self.document.isFavorite;
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
if ([keyPath isEqualToString:@"document.isFavorite"]) {
self.isFavoriteButton.selected = self.document.isFavorite;
} else if ([keyPath isEqualToString:@"document.title"]) {
self.titleLabel.text = self.document.title;
}
}
@end
```
Старый (но не очень добрый) разбор случаев в одном методе со сравнением строк, продублированных в двух других местах. Это не только некрасиво, но и чревато ошибками, как и любая другая «копипаста».
На этом можно бы и остановиться, понадеявшись, что ничего плохого не произойдет, и всё будет работать. И сейчас оно действительно будет работать. Но рано или поздно что-то плохое все-таки может случиться, и после пары часов в отладчике мы укрепимся в убеждении, что с KVO лучше не связываться.
Что же может произойти? Немного усложним наш пример, и предположим, что мы решили сделать еще одну таблицу для отображения наших документов, но с чуть более «навороченными» ячейками, которые так же будут содержать заголовок документа и такую же кнопку, но наряду с другими изменениями будут менять цвет фона в зависимости от того, является ли документ избранным.
Чтобы уже проделанная работа не пропала даром, мы решаем унаследовать новую ячейку от старой.
А чтобы менять фон ячейки, мы используем ту же технику KVO:
```
@implementation ETRAdvancedDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
[self addObserver:self
forKeyPath:@"document.isFavorite"
options:0
context:NULL];
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
[self updateBackgroundColor];
}
...
```
Отлично, фон меняет цвет. Вот только кнопка перестала выделяться, заголовок перестал обновляться, да и updateBackgroundColor вызывается как-то уж слишком часто. Очевидно, ETRAdvancedDocumentCell получает сообщения observeValueForKeyPath, относящиеся как к собственному наблюдению, так и к наблюдениям ETRDocumentCell. Что же на этот счет написано в документации? В комментарии внутри кода одного из примеров находим [следующие строки](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueObserving/Articles/KVOBasics.html#//apple_ref/doc/uid/20002252-179866):
Be sure to call the superclass's implementation \*if it implements it\*.
NSObject does not implement the method.
Мы, конечно же, знаем, что ETRDocumentCell реализует observeValueForKeyPath, а значит нужно вызывать
[super observeValueForKeyPath:keyPath ofObject:object change:change context:context] из ETRAdvancedDocumentCell.
Но вызовом реализации из родительского класса всё не ограничивается. Следует обработать изменения, на которые подписан сам ETRAdvancedDocumentCell, и передать родительскому классу только прочие изменения. Очевидно, одними проверками значений keyPath и object не обойтись: родительский класс подписан на точно тот же самый keyPath (document.isFavorite) того же самого объекта (self). Именно здесь проявляется то самое «истинное» предназначение аргумента context.
```
static void* ETRAdvancedDocumentCellIsFavoriteContext = &ETRAdvancedDocumentCellIsFavoriteContext
@implementation ETRAdvancedDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
[self addObserver:self
forKeyPath:@"document.isFavorite"
options:0
context:ETRAdvancedDocumentCellIsFavoriteContext];
}
- (void)dealloc
{
[self removeObserver:self
forKeyPath:@"document.isFavorite"
context:ETRAdvancedDocumentCellIsFavoriteContext];
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
if (context == ETRAdvancedDocumentCellIsFavoriteContext) {
[self updateBackgroundColor];
} else {
[super observeValueForKeyPath:keyPath
ofObject:object
change:change
context:context];
}
}
...
```
Статическая переменная ETRAdvancedDocumentCellIsFavoriteContext содержит указатель на фиксированную область памяти, содержащую собственный адрес. Это гарантирует различные значения для всех объявленных подобным образом переменных.
Очевидно, что прекращать наблюдение следует тоже с указанием контекста. Любопытен тот факт, что соответствующий метод был добавлен только в iOS 5, и до этого существовал только вариант без аргумента context. Это делало невозможным корректное прекращение одного из неотличимых по прочим параметрам наблюдений.
Но как же быть с ETRDocumentCell: нужно ли вызывать super из него? Реализует ли класс UITableViewCell селектор observeValueForKeyPath? Можно прибегнуть к методу проб и ошибок, попытаться вызвать super, получить ожидаемое падение с исключением
\*\*\* Terminating app due to uncaught exception 'NSInternalInconsistencyException',
reason: '
frame = (0 0; 320 64); autoresize = W; layer = >:
An -observeValueForKeyPath:ofObject:change:context: message was received but not handled.
Key path: document.title
Observed object:
frame = (0 0; 320 64); autoresize = W; layer = >
Change: {
kind = 1;
}
Context: 0x0'
\*\*\* First throw call stack:
(
0 CoreFoundation 0x0173b5e4 \_\_exceptionPreprocess + 180
1 libobjc.A.dylib 0x014be8b6 objc\_exception\_throw + 44
2 CoreFoundation 0x0173b3bb +[NSException raise:format:] + 139
3 Foundation 0x0118863f -[NSObject(NSKeyValueObserving) observeValueForKeyPath:ofObject:change:context:] + 94
4 ETRKVO 0x00002e35 -[ETRDocumentCell observeValueForKeyPath:ofObject:change:context:] + 229
5 Foundation 0x0110d8c7 NSKeyValueNotifyObserver + 362
6 Foundation 0x0110f206 NSKeyValueDidChange + 458
…
и убрать вызов обратно. Но где гарантия того, что родительский класс не начнет (или наоборот перестанет) реализовывать observeValueForKeyPath в следующей версии? Даже если родительский класс реализуете вы сами, вы рискуете забыть добавить или убрать вызов super в дочерних классах. Наиболее надежным решением было бы выполнять соответствующую проверку во время исполнения. Делается это вовсе не с помощью вызова [super respondsToSelector:...], который всегда вернет YES, так как наш класс не переопределяет respondsToSelector:, и вызывать его на super — все равно, что вызывать на self. Делается это с помощью чуть более длинного выражения [[ETRDocumentCell superclass] instancesRespondToSelector:...]. Но как выясняется, документация нас обманывает, и [[NSObject class] instancesRespondToSelector:@selector(observeValueForKeyPath:ofObject:change:context:)] возвращает YES, при чем соответствующая реализация как раз таки и ответственна за приведенное выше исключение. Выходит, что у нас есть два варианта: либо никогда не вызывать super и рисковать сломать логику родительского класса, либо вызывать super только для наблюдений, гарантированно не вызванных наших кодом, рискуя получить исключение, пропустив что-нибудь лишнее.
```
static void* ETRDocumentCellIsFavoriteContext = &ETRDocumentCellIsFavoriteContext
static void* ETRDocumentCellTitleContext = &ETRDocumentCellTitleContext
@implementation ETRDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
[self addObserver:self
forKeyPath:@"document.isFavorite"
options:0
context:ETRDocumentCellIsFavoriteContext];
[self addObserver:self
forKeyPath:@"document.title"
options:0
context:ETRDocumentCellTitleContext];
}
- (void)dealloc
{
[self removeObserver:self
forKeyPath:@"document.isFavorite"
context:ETRDocumentCellIsFavoriteContext];
[self removeObserver:self
forKeyPath:@"document.title"
context:ETRDocumentCellTitleContext];
}
- (void)toggleIsFavorite
{
self.document.isFavorite = !self.document.isFavorite;
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
if (context == ETRDocumentCellIsFavoriteContext) {
self.isFavoriteButton.selected = self.document.isFavorite;
} else if (context == ETRDocumentCellTitleContext) {
self.titleLabel.text = self.document.title;
} else {
[super observeValueForKeyPath:keyPath
ofObject:object
change:change
context:context];
}
}
@end
```
Из приведенного примера следует, что для корректной реализации KVO необходимо сделать множество нетривиальных и неочевидных действий. При чем они должны быть сделаны консистентным образом на всех уровнях наследования, что не находится во власти разработчика, если какие-то из этих уровней реализованы в стандартных либо сторонних библиотеках, либо если сам продукт является библиотекой, предполагающей наследование от некоторых из ее классов.
Кроме того, программисту необходимо четко отслеживать в классе наблюдателя все активные наблюдения, чтобы гарантированно обработать их в observeValueForKeyPath и остановить их в нужный момент (например, при удалении наблюдателя). Это осложняется разнесенность связанного кода по нескольким местам (определение контекстов, добавление, удаление и обработка наблюдений) и усугубляется тем фактом, что проверить наличие наблюдения невозможно, а попытка остановить несуществующее наблюдение приводит к исключению:
\*\*\* Terminating app due to uncaught exception 'NSRangeException',
reason: 'Cannot remove an observer
for the key path «document.title» from
because it is not registered as an observer.'
Зачастую можно встретить UIViewController'ы, добавляющие себя в качестве наблюдателя внутри реализации одного из методов viewDidLoad, vewDidUnload, viewWillAppear, viewDidAppear, viewWillDisappear или viewDidDisappear, и прекращающие наблюдения в другом из этих методов. При этом никто не гарантирует строгую парность этих вызовов, особенно при использовании custom container view controllers, особенно с shouldAutomaticallyForwardAppearanceMethods, возвращающим NO. В частности, логика этих вызовов для контроллеров, содержащихся в стеке UINavigationController, изменилась в iOS 7 с введением интерактивного жеста перехода назад по стеку навигации. Да и ссылка на объект, передаваемый в качестве наблюдаемого, может измениться между этими вызовами.
В результате некоторые разработчики даже всерьез предлагают использовать [решения вроде следующего](http://nshipster.com/key-value-observing/):
```
@try {
[self.document removeObserver:self
forKeyPath:@"isFavorite"
context:DocumentCellIsFavoriteContext];
}
@catch (NSException *exception) {}
```
Когда я вижу нечто подобное, я вспоминаю, как в детстве я писал на Visual Basic строчку «On Error Resume Next», и мои «творения» чудесным образом переставали падать.
Из всего написанного следует, что KVO — очень мощная технология, доступ к которой мы имеем посредством API, который не только неудобен, но и смертельно опасен для использующих его приложений. Подобные ситуации не редки в сфере программирования, и верным выходом из них служит написание более удобного и безопасного интерфейса, изолирующего и нейтрализующего все недостатки внутри своей реализации.
В случае KVO корень проблем как с наследованием, так и с removeObserver, заключается в том, что отдельно взятое наблюдение теряет для программиста свою идентичность после его добавления. Вместо того, чтобы прекращать «конкретно вот это наблюдение», разработчик оказывается вынужден требовать прекратить «какое-нибудь наблюдение, соответствующее указанным критериям». При этом таких наблюдений может быть несколько, или не быть вовсе. То же самое происходит и в реализации observeValueForKeyPath: когда недостаточно различать наблюдения по объекту и ключу, приходится прибегать к специфическим контекстам. Но даже контекст определяет не конкретный акт добавления наблюдения, а всего лишь строку кода, в которой он совершается. Если одна и та же строка кода будет вызвана два раза с теми же наблюдателем, наблюдаемым объектом и key path, нельзя будет различить последствия этих двух вызовов. Аналогичным образом, проблемы при наследовании вызываются еще и тем, что родительский и дочерний классы оказываются связаны в деталях реализации ими KVO (которые должны быть надежно инкапсулированы), поскольку их объект — это один и тот же наблюдатель с точки зрения KVO.
Из этих рассуждений следует, что для более надежного использования KVO необходимо придать идентичность каждому отдельно взятому наблюдению, а именно создавать для каждого наблюдения отдельный объект. Этот же объект должен являться наблюдателем в терминах стандартного интерфейса KVO. Наблюдая ровно один keyPath ровно одного объекта, и четко связывая это наблюдение с собственным временем жизни, этот объект будет надежно защищен от описанных выше опасностей. Получая сообщение об изменении наблюдаемого значения, единственное, что он будет делать, — это оповещать другой объект одним из первых трех указанных в начале статьи методов.
Попробуем реализовать такой объект:
```
@interface ETRKVO : NSObject
@property (nonatomic, unsafe_unretained, readonly) id subject;
@property (nonatomic, copy, readonly) NSString *keyPath;
@property (nonatomic, copy) void (^block)(ETRKVO *kvo, NSDictionary *change);
- (id)initWithSubject:(id)subject
keyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
block:(void (^)(ETRKVO *kvo, NSDictionary *change))block;
- (void)stopObservation;
@end
static void* ETRKVOContext = &ETRKVOContext
@implementation ETRKVO
- (id)initWithSubject:(id)subject
keyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
block:(void (^)(ETRKVO *kvo, NSDictionary *change))block
{
self = [super init];
if (self) {
_subject = subject;
_keyPath = [keyPath copy];
_block = [block copy];
[subject addObserver:self
forKeyPath:keyPath
options:options
context:ETRKVOContext];
}
return self;
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
if (context == ETRKVOContext) {
if (self.block)
self.block(self, change);
} // NSObject does not implement observeValueForKeyPath
}
- (void)stopObservation
{
[self.subject removeObserver:self
forKeyPath:self.keyPath
context:ETRKVOContext];
_subject = nil;
}
- (void)dealloc
{
[self stopObservation];
}
@end
```
Альтернативные решения можно найти в библиотеке [ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa), претендующей на радикальный сдвиг парадигмы программирования на Objective C, и в несколько устаревшем [MAKVONotificationCenter](https://github.com/mikeash/MAKVONotificationCenter).
Кроме того, аналогичные изменения по тем же причинами были сделаны в NSNotificationCenter: в iOS 4 был добавлен метод [addObserverForName:object:queue:usingBlock](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSNotificationCenter_Class/Reference/Reference.html#//apple_ref/occ/instm/NSNotificationCenter/addObserverForName:object:queue:usingBlock:):, возвращающий объект, идентифицирующий подписку на оповещения.
Интерфейс ETRKVO можно несколько упростить, рассмотрев поведение аргументов options и change.
NSKeyValueObservingOptions является битовой маской, которая может объединять следующие флаги:
* NSKeyValueObservingOptionNew
* NSKeyValueObservingOptionOld
* NSKeyValueObservingOptionInitial
* NSKeyValueObservingOptionPrior
Первые два указывают на то, что в аргументе change должны присутствовать старое и новое значения наблюдаемого атрибута. Никаких отрицательных последствий это вызывать не может, если не считать незначительное замедление.
Указание NSKeyValueObservingOptionInitial приводит к тому, что observeValueForKeyPath будет вызван сразу же при добавлении наблюдения, что, вообще говоря, бесполезно.
Указание NSKeyValueObservingOptionPrior приводит к тому, что observeValueForKeyPath будет вызван не только после изменения значения, но и перед ним. При этом новое значение передано не будет, даже если указан флаг NSKeyValueObservingOptionNew. Необходимость в этом можно встретить крайне редко, и скорее всего она возникает только в процессе реализации какого-нибудь «костыля».
Следовательно, можно всегда передавать в качестве опций (NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld).
Аргумент (NSDictionary \*)change может содержать следующие ключи:
* NSKeyValueChangeNewKey
* NSKeyValueChangeOldKey
* NSKeyValueChangeKindKey
* NSKeyValueChangeIndexesKey
* NSKeyValueChangeNotificationIsPriorKey
Первые два содержат те самые старое и новое значения, которые можно запросить соответствующими опциями. Значения скалярных типов оборачиваются в NSNumber либо NSValue, а вместо nil передается синглтонный объект [NSNull null].
Следующие два нужны только при наблюдении за мутабельной коллекцией, что скорее всего является плохой идеей.
Последний ключ передается только при предшествующем изменению вызове, выполняемом при наличии опции NSKeyValueObservingOptionPrior.
Следовательно, можно рассматривать только ключи NSKeyValueChangeNewKey и NSKeyValueChangeOldKey, и передавать блоку их значения в развернутом виде.
Таким образом, ETRKVO можно изменить следующим образом:
```
- (id)initWithSubject:(id)subject
keyPath:(NSString *)keyPath
block:(void (^)(ETRKVO *kvo, id oldValue, id newValue))block
{
self = [super init];
if (self) {
_subject = subject;
_keyPath = [keyPath copy];
_block = [block copy];
[subject addObserver:self
forKeyPath:keyPath
options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld)
context:ETRKVOContext];
}
return self;
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
if (context == ETRKVOContext) {
if (self.block) {
id oldValue = change[NSKeyValueChangeOldKey];
if (oldValue == [NSNull null])
oldValue = nil;
id newValue = change[NSKeyValueChangeNewKey];
if (newValue == [NSNull null])
newValue = nil;
self.block(self, oldValue, newValue);
}
} // NSObject does not implement observeValueForKeyPath
}
При желании его можно оформить в виде категории над NSObject, избавившись от первого аргумента:
- (ETRKVO *)observeKeyPath:(NSString *)keyPath
withBlock:(void (^)(ETRKVO *kvo, id oldValue, id newValue))block;
```
Поскольку часто keyPath является названием property, совпадающим с соответствующим getter'ом, вместо строки keyPath удобнее использовать селектор этого getter'а. При этом будет работать autocompletion, и меньше будет вероятность допустить ошибку при написании, либо при переименовании property.
```
- (ETRKVO *)observeSelector:(SEL)selector
withBlock:(void (^)(ETRKVO *kvo, id oldValue, id newValue))block
{
return [[ETRKVO alloc] initWithSubject:self
keyPath:NSStringFromSelector(selector)
block:block];
}
```
Перепишем наши ячейки с использованием этого класса и категории
```
@interface ETRDocumentCell ()
@property (nonatomic, strong) ETRKVO* isFavoriteKVO;
@property (nonatomic, strong) ETRKVO* titleKVO;
@end
@implementation ETRDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
typeof(self) __weak weakSelf = self;
self.isFavoriteKVO = [self observeKeyPath:@"document.isFavorite"
withBlock:^(ETRKVO *kvo, id oldValue, id newValue)
{
weakSelf.isFavoriteButton.selected = weakSelf.document.isFavorite;
}];
self.titleKVO = [self observeKeyPath:@"document.title"
withBlock:^(ETRKVO *kvo, id oldValue, id newValue)
{
weakSelf.titleLabel.text = weakSelf.document.title;
}];
}
- (void)dealloc
{
[self.isFavoriteKVO stopObservation];
[self.titleKVO stopObservation];
}
- (void)toggleIsFavorite
{
self.document.isFavorite = !self.document.isFavorite;
}
@end
@interface ETRAdvancedDocumentCell ()
@property (nonatomic, strong) ETRKVO* advancedIsFavoriteKVO;
@end
@implementation ETRAdvancedDocumentCell
- (void)awakeFromNib
{
[super awakeFromNib];
typeof(self) __weak weakSelf = self;
self.advancedIsFavoriteKVO = [self observeKeyPath:@"document.isFavorite"
withBlock:^(ETRKVO *kvo, id oldValue, id newValue)
{
[weakSelf updateBackgroundColor];
}];
}
- (void)dealloc
{
[self.advancedIsFavoriteKVO stopObservation];
}
...
```
Полную реализацию ETRKVO вместе с примером можно скачать [здесь](http://eastbanc.ru/appstore/habr/ETRKVO.zip)
Единственным неочевидным приемом здесь является использование weakSelf для предотвращения утечек памяти. Если бы блоки захватывали self по сильной ссылке, образовывался бы цикл сильных ссылок: ETRDocumentCell → isFavoriteKVO → блок → ETRDocumentCell. Однако если вы активно используете блоки, захват объектов по слабым ссылкам уже должен войти у вас в привычку.
Стоит заметить, что хотя объекты класса ETRKVO и удаляются после того, как ячейки теряют ссылки на них (удаляются сами), и при подсчете ссылок не возникает эффектов вроде ожидания сборки мусора, удаление тем не менее может произойти не сразу, если ссылка попала в autorelease pool. **Поэтому следует всегда вручную вызывать stopObservation до того, как окажутся удалены объект ETRKVO или наблюдаемый объект.** При использовании одной и той же property для последовательности различных наблюдений, удобно вызывать stopObservation в ее сеттере.
```
- (void)setIsFavoriteKVO:(ETRKVO *)isFavoriteKVO
{
[_isFavoriteKVO stopObservation];
_isFavoriteKVO = isFavoriteKVO;
}
- (void)dealloc
{
self.isFavoriteKVO = nil;
}
```
Требования по ручному прекращению наблюдений можно было бы ослабить, если бы автоматический подсчет ссылок умел обнулять слабые ссылки KVO compliant способом, то есть так, чтобы об этом оказывались оповещены объекты, наблюдающие за их значениями. На данный момент, в iOS 7, [это невозможно](http://www.mikeabdullah.net/weak-properties-kvo-compliance.html) (если не рассматривать «грязных трюков» вроде [подмены реализации](http://cocoadev.com/MethodSwizzling) метода dealloc).
Не следует забывать, что обработчик изменения вызывается в том же потоке исполнения, в котором происходит это изменение. Если наблюдение за объектом, который может быть изменен из другого потока, оправдано, а не является следствием легкомысленного отношения к многопоточности, то код обработчика обычно следует обернуть в [dispatch\_async](https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html#//apple_ref/c/func/dispatch_async). При этом следует обратить особое внимание на то, чтобы внешний блок не захватывал по сильным ссылками объекты, относящиеся к строго определенному потоку (например UIView, UIViewController или NSManagedObject), так как это может привести к так называемой [deallocation problem](https://developer.apple.com/library/ios/technotes/tn2109/_index.html#//apple_ref/doc/uid/DTS40010274-CH1-SUBSECTION11).
Если обработчик не срабатывает при изменении наблюдаемого значения, скорее всего наблюдаемый атрибут не является KVO compliant. Как сделать его таковым, исчерпывающе описано в разделах документации [KVO Compliance](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/KeyValueObserving/Articles/KVOCompliance.html#//apple_ref/doc/uid/20002178-BAJEAIEE) и [Registering Dependent Keys](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/KeyValueObserving/Articles/KVODependentKeys.html#//apple_ref/doc/uid/20002179-BAJEAIEE). Стоит отдельно оговорить, что даже если вы не используете у property стандартный (синтезированный) property setter, а определяете setter сами, эта property останется KVO compliant.
Даже будучи осведомленными о всех потенциальных опасностях KVO, и нейтрализовав часть из них, не следует бездумно использовать KVO при любом случае. Злоупотребление любой технологией приводит к явлению, называемому «[Имя технологии] hell». Хоть связи между объектами, создаваемые с помощью KVO, и выглядят очень слабыми, выйдя из-под контроля, они могут очень больно ударить. В нашем случае «KVO hell» может выражаться в непредсказуемых лавинообразных срабатываниях обработчиков наблюдений, приводящих к неожиданным последствиям и убивающих производительность, или даже в циклических вызовах, завершающихся переполнением стека.
1. [TIOBE Programming Community Index for November 2013](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)
2. [Key-Value Coding Programming Guide](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueCoding/Articles/KeyValueCoding.html)
3. [Key-Value Observing Programming Guide](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html)
4. [Blocks Programming Topics](https://developer.apple.com/library/ios/documentation/cocoa/Conceptual/Blocks/Articles/00_Introduction.html)
5. [Transitioning to ARC Release Notes](https://developer.apple.com/library/mac/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html)
6. [Concepts in Objective-C Programming: Delegates and Data Sources](https://developer.apple.com/library/ios/documentation/general/conceptual/CocoaEncyclopedia/DelegatesandDataSources/DelegatesandDataSources.html)
7. [Programming with Objective-C: Working with Protocols](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html)
8. [Concepts in Objective-C Programming: Target-Action](https://developer.apple.com/library/mac/documentation/General/Conceptual/CocoaEncyclopedia/Target-Action/Target-Action.html)
9. [stackoverflow: How to cancel NSBlockOperation](http://stackoverflow.com/questions/8113268/how-to-cancel-nsblockoperation)
10. [Notification Programming Topics](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Notifications/Introduction/introNotifications.html)
11. [NSKeyValueObserving Protocol Reference](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Protocols/NSKeyValueObserving_Protocol/Reference/Reference.html)
12. [iOS Debugging Magic](https://developer.apple.com/library/ios/technotes/tn2239/_index.html)
13. [NSHipster: Key-Value Observing](http://nshipster.com/key-value-observing/)
14. [ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa)
15. [MAKVONotificationCenter](https://github.com/mikeash/MAKVONotificationCenter)
16. [Weak properties KVO compliance](http://www.mikeabdullah.net/weak-properties-kvo-compliance.html)
17. [Method Swizzling](http://cocoadev.com/MethodSwizzling)
18. [Grand Central Dispatch (GCD) Reference](https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html)
19. [Simple and Reliable Threading with NSOperation](https://developer.apple.com/library/ios/technotes/tn2109/_index.html#//apple_ref/doc/uid/DTS40010274-CH1-SUBSECTION11) | https://habr.com/ru/post/202884/ | null | ru | null |
# Wuala отменяет «облачный коммунизм»
[Wuala](http://wuala.com/), аналог заслуженно популярного Dropbox, известный своей политикой «облачного коммунизма» (сколько дискового пространства предоставишь — столько получишь места в облаке), меняет правила. Буквально пару часов назад я получил письмо следующего содержания:
*`Hi,
We have been working hard to improve the underlying storage system of Wuala. This improvement will be included for the first time in the next Wuala update, which is coming later this week.
While this change will bring many nice improvements, it also means that we are discontinuing the "trade storage" feature, which was a very hard decision for us to make.
We are aware what this change means for you, therefore we want to give you the amount of storage you have earned for the next twelve months at no cost. We highly appreciate that you have traded your personal storage and wanted to say thank you for contributing to our system.
The new system will bring quite a few long anticipated advantages:
- Incremental file updates (so small changes in a large file do not require the whole file to be uploaded again)
- Increased file size limit up to 100 GB
- Multiple concurrent downloads
- Much faster random access
- More stability (TCP instead of UDP, less router crashes, works better in corporate networks, etc.)
- More performance (less CPU and disk usage during up- and downloads)
Generally, this makes it more convenient to work with files stored directly in Wuala, particularly when accessing multiple files at the same time.
The new system will be rolled out step by step, so these advantages won't become available immediately. In case you want to try out the new system, please visit our forum forum.wuala.com/viewtopic.php?f=39&t=2231.
Best,
Your Wuala Team`*
Краткое содержание:
Мы много работали над различными улучшениями, но нам придётся отменить фичу «торговля дисковым пространством». Это было трудное решение, но се ля ви.
Мы в курсе, что это означает для вас, поэтому в течение года всё заработанное пространство остаётся в пользовании бесплатно. Мы очень ценим, что вы предоставляли ваше личное место на диске и хотим отблагодарить вас за это.
Новая система принесёт несколько давно ожидаемых фич:
— инкрементальные апдейты (маленькие изменения большого файла не приведут к полной загрузке файла)
— максимальный размер файла увеличен до 100 гигабайт
— несколько одновременных закачек
— намного более быстрый случайный доступ
— лучшая стабильность (TCP вместо UDP)
— улучшенная производительность
Новая система будет постепенно введена в работу, поэтому не все перечисленные улучшения станут доступны сразу.
На мой взгляд, это провал. Теряется основное преимущество перед Dropbox. Конкурировать с ним теперь будет сложно. | https://habr.com/ru/post/129656/ | null | ru | null |
# И снова о кешировании в Django
Для django уже есть множество библиотек для кеширования и они уже [обсуждалось на хабре](https://habrahabr.ru/post/143789/), но, к сожалению, проблемы с производительностью не решить добавлением строчки в INSTALLED\_APPS. В библиотеках патчащих queryset кеш инвалидируется либо слишком часто, либо слишком редко и самое главное у программиста мало контроля за этим процессом. Можно написать инвалидацию вручную, но потребуется много кода, в котором легко допустить ошибку.
По этой причине я написал маленький проект, в котором при добавлении объекта в кеш можно указать зависимости, при изменении которых кеш будет автоматически инвалидирован.
В качестве зависимости можно указать:
1. **Класс модели.** При изменении/удалении любого объекта модели, вызова bulk\_create, update у queryset'а этой модели запись в кеше будет инвалидирована.
2. **Инстанс модели.** При изменении/удалении этого инстанса, запись в кеше будет инвалидирована.
3. **Related manger.** При изменении любого дочернего объекта имеющего внешний ключ на указанный объект, запись в кеше будет инвалидирована.
Рассмотрим это на примере простого блога, у которого есть список всех постов и просмотр конкретного поста.
Для начала установим clever\_cache.
```
$ pip instal django-clever-cache
```
Добавим ‘clever\_cache’ в INSTALLED\_APPS и укажем ‘clever\_cache.backend.RedisCache’ в качестве бэкенда для кеша.
```
INSTALLED_APPS += ['clever_cache']
CACHES = {
"default": {
"BACKEND": 'clever_cache.backend.RedisCache',
"LOCATION": "redis://127.0.0.1:6379/1",
"OPTIONS": {
'DB': 1,
}
}
}
```
Модели в нашем приложении-блоге выглядят следующим образом:
```
class Post(models.Model):
author = models.ForeignKey('auth.User')
title = models.CharField(max_length=128)
body = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = 'post'
verbose_name_plural = 'posts'
ordering = ['-created_at']
class Comment(models.Model):
author = models.ForeignKey('auth.User')
post = models.ForeignKey(Post, related_name='comments')
body = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = 'comment'
verbose_name_plural = 'comments'
ordering = ['-created_at']
```
Реализуем список всех постов. В запросе мы выбираем все посты, их авторов и количество комментариев к каждому посту, поэтому инвалидировать кеш нам придется при изменении любого поста, комментария или пользователя.
```
class PostListView(ListView):
context_object_name = 'post_list'
def get_queryset(self):
post_list_qs = cache.get('post_list_qs')
if not post_list_qs:
post_list_qs = Post.objects.all().select_related(
'author'
).annotate(comments_count=Count('comments'))
cache.set(
'post_list_qs',
post_list_qs,
depends_on=[Post, Comment, User]
# Запись в кеше зависит от моделей Post, Comment и User
)
return post_list_qs
```
Реализуем просмотр отдельного поста. Тут мы из базы данных получаем пост, его автора и отдельно комментарии к посту. Соответственно при изменении перечисленных объектов следует инвалидировать кеш.
```
class PostDetailView(DetailView):
model = Post
def get_context_data(self, **ctx):
post = self.get_post()
comments = self.get_comments(post)
ctx['post'] = post
ctx['comments'] = comments
return ctx
def get_post(self, *args, **kwargs):
pk = self.kwargs.get(self.pk_url_kwarg)
cache_key = "post_detail_%s" % pk
post = cache.get(cache_key)
if not post:
post = Post.objects.select_related('author').get(pk=pk)
cache.set(
cache_key, post,
depends_on=[post, post.author]
# при изменении поста или автора удалять запись из кеша
)
return post
def get_comments(self, post):
cache_key = "post_detail_%s_comments" % post.pk
comments = cache.get(cache_key)
if not comments:
comments = post.comments.all()
cache.set(
cache_key, comments,
depends_on=[post.comments]
# post.comments - это RelatedManager,
# при изменении любого комментария поста, кеш будет инвалидирован
)
return comments
```
Надеюсь, эта библиотека избавит вас от проблем с инвалидацией кеша и позволит сосредоточиться на выборе имен переменных.
Код
===
Доступен на [github](https://github.com/RafGb/django-clever-cache) | https://habr.com/ru/post/337998/ | null | ru | null |
# Импорт views из модуля
[](http://habrahabr.ru/blogs/drupal/108990/)
Штука очень удобная, т.к. позволяет запихать в модуль все что ему необходимо для работы, не нужно в ручную бегать, экспортировать/импортировать вьюхи.
Реализация мега простая, хотя для меня была не очевидной. Уверен кому-нибудь тоже будет интересно/полезно занать как это сделать.
У вьюх есть кнопочка «Export», которая позволяет скопировать текст экспортированной вьюхи.
Теперь в папке с модулем нужно создать файл **module\_name.views\_default.inc** и написать в него следующее:
`php<br/
/**
* Implementation of hook_views_default_views().
*/
function module_name_views_default_views() {
// копируем сюда тот код, что дала вьюха на экспорте
$views[$view->name] = $view;
return $views;
}`
таким образом можно вставлять любое количество нод в массив **$views**.
В самом файле модуля теперь нужно описать hook\_views\_api()
`/**
* Implementation of hook_views_api().
*/
function module_name_views_api() {
return array(
'api' => 2,
'path' => drupal_get_path('module', 'module_name'),
);
}`
Все, активируем модуль и радуемся.
**з.ы.** надеюсь все догадаются вместо **module\_name** нужно вставить имя вашего модуля. | https://habr.com/ru/post/108990/ | null | ru | null |
# Создаем оберточный HStack с помощью протокола Layout SwiftUI
Компонент, который мы собираемся создать, доступен как [Swift Package](https://github.com/ksemianov/WrappingHStack).
### Вступление
Утро понедельника, и ваш менеджер проекта дает вам задание: добавить список тегов на страницу подробной информации о продукте. Вы говорите «изи» и через 10 минут выдаете следующее.
```
HStack {
ForEach(tags) {
TagView(text: $0.text)
}
Spacer(minLength: .zero)
}.padding(.horizontal)
```
После проверки, команда QA сообщает о возникающей ошибке при большом количестве тегов.
Вы продолжаете и делаете для них горизонтальную прокрутку.
```
ScrollView(.horizontal, showsIndicators: false) {
LazyHStack {
ForEach(tags) {
TagView(text: $0.text)
}
}.padding(.horizontal)
}.frame(height: 56)
```
Недостатком является то, что вы должны заранее знать высоту вьюшек тегов.
Команда дизайнеров просит переносить теги на последующие строки, когда они не соответствуют ширине основного вью. И теперь ваше "изи" превратилось в “хардово". Один из ваших коллег предлагает обернуть пользовательский *UICollectionView*в *UIViewRepresentable*. А другой - попробовать новый протокол Layout. Вы решили продолжить с *Layout*…
### Протокол макета
Протокол имеет 2 требования:
* *sizeThatFits*определяет, сколько места требует Вью.
* *placeSubviews*управляет размещением сабвью(-шек) внутри доступного пространства.
Обратите внимание, что *sizeThatFits*может вызываться несколько раз в процессе компоновки. Он будет пробовать различные предложения по размерам. На момент написания статьи, в iOS он как обычно просто попытается передать все доступное пространство. В macOS он также попытается предложить размер *.zero*, чтобы можно было вычислить минимальный размер окна. Таким образом, для поддержки macOS нам потребуется вычислить минимальный размер вью.
### Схема подхода
За минимальный размер мы возьмем максимальный размер сабвью в предложении .*zero*. Всякий раз, когда предложение меньше минимального размера, мы просто вернем минимальный размер раньше.
```
func minSize(subviews: Subviews) -> CGSize {
subviews
.map { $0.sizeThatFits(.zero) }
.reduce(CGSize.zero) { CGSize(width: max($0.width, $1.width), height: max($0.height, $1.height)) }
}
```
Чтобы вычислить как размер, так и размещение, нам нужно сначала расположить эти сабвью в строки. Основная идея состоит в том, чтобы перебирать сабвью и увеличивать координату X на ширину сабвью + горизонтальный интервал, если он все еще умещается в ширину контейнера, или в противном случае переходить к следующей строке. Это позволит нам получить смещения X для всех сабвью. Затем мы будем перебирать строки и увеличивать координату Y на максимальную высоту сабвью + интервал по вертикали. Это позволит нам получить смещения Y для всех строк.
Как только у нас будет расположение строк, ширина заполнит все доступное пространство.
```
let width = proposal.width ?? rows.map { $0.width }.reduce(.zero) { max($0, $1) }
```
И высота будет равна вертикальному смещению последней строки + ее высота.
```
var height: CGFloat = .zero
if let lastRow = rows.last {
height = lastRow.yOffset + lastRow.height
}
```
Сабвью будут размещены на соответствующих им смещениях + точка минимального значения границ.
```
for row in rows {
for element in row.elements {
let x: CGFloat = element.xOffset
let y: CGFloat = row.yOffset
let point = CGPoint(x: x + bounds.minX, y: y + bounds.minY)
subviews[element.index].place(at: point, anchor: .topLeading, proposal: proposal)
}
}
```
### Расположение строк
Для каждой строки нам нужно знать индексы наших сабвью, размеры и смещения по оси X. Кроме того, общее смещение строки по Y, ширину и высоту строки.
```
struct Row {
var elements: [(index: Int, size: CGSize, xOffset: CGFloat)] = []
var yOffset: CGFloat = .zero
var width: CGFloat = .zero
var height: CGFloat = .zero
}
func arrangeRows(proposal: ProposedViewSize,
subviews: Subviews,
cache: inout ()) -> [Row] {
let minSize = minSize(subviews: subviews)
if minSize.width > proposal.width ?? .infinity,
minSize.height > proposal.height ?? .infinity {
return []
}
let sizes = subviews.map { $0.sizeThatFits(proposal) }
var currentX = CGFloat.zero
var currentRow = Row()
var rows = [Row]()
for index in subviews.indices {
var spacing = CGFloat.zero
if let previousIndex = currentRow.elements.last?.index {
spacing = horizontalSpacing(subviews[previousIndex], subviews[index])
}
let size = sizes[index]
if currentX + size.width + spacing > proposal.width ?? .infinity,
!currentRow.elements.isEmpty {
currentRow.width = currentX
rows.append(currentRow)
currentRow = Row()
spacing = .zero
currentX = .zero
}
currentRow.elements.append((index, sizes[index], currentX + spacing))
currentX += size.width + spacing
}
currentRow.width = currentX
rows.append(currentRow)
var currentY = CGFloat.zero
var previousMaxHeightIndex: Int?
for index in rows.indices {
let maxHeightIndex = rows[index].elements
.max { $0.size.height < $1.size.height }!
.index
let size = sizes[maxHeightIndex]
var spacing = CGFloat.zero
if let previousMaxHeightIndex {
spacing = verticalSpacing(subviews[previousMaxHeightIndex], subviews[maxHeightIndex])
}
rows[index].yOffset = currentY + spacing
currentY += size.height + spacing
rows[index].height = size.height
previousMaxHeightIndex = maxHeightIndex
}
return rows}
```
### Интервалы
Мы разрешаем переопределение горизонтального и вертикального интервалов или используем системные интервалы, если они равны *nil*. Прокси *LayoutSubview*позволяет получить системный интервал для пары сабвью.
```
func horizontalSpacing(_ lhs: LayoutSubview, _ rhs: LayoutSubview) -> CGFloat {
if let horizontalSpacing { return horizontalSpacing }
return lhs.spacing.distance(to: rhs.spacing, along: .horizontal)
}
func verticalSpacing(_ lhs: LayoutSubview, _ rhs: LayoutSubview) -> CGFloat {
if let verticalSpacing { return verticalSpacing }
return lhs.spacing.distance(to: rhs.spacing, along: .horizontal)
}
```
### Свойства макета
Протокол *Layout*имеет опциональный параметр *layoutProperties*, который позволяет управлять *StackOrientation*. Это влияет на способ обработки *Spacer*и *Divider*. Например, при *stackOrientation*= .*horizontal*, Spacer будет расширяться только по горизонтали. Таким образом, это позволит обеспечить разрыв линии (строки) в контейнере. У него есть оговорка, что между разделенными строками будет двойной интервал, а системный интервал по умолчанию будет равен нулю.
```
static var layoutProperties: LayoutProperties {
var properties = LayoutProperties()
properties.stackOrientation = .horizontal
return properties
}
```
### Выравнивание
Мы разрешим контролировать значение выравнивания внутри контейнера. Вот только протокол *Layout*не предоставляет простой способ реализации различных значений выравнивания базовой линии текста: .*leadingFirstTextBaseline*, .*centerLastTextBaseline*и т. д. Остальные значения соответствуют значениям *UnitPoint*.
```
extension UnitPoint {
init(_ alignment: Alignment) {
switch alignment {
case .leading:
self = .leading
case .topLeading:
self = .topLeading
case .top:
self = .top
case .topTrailing:
self = .topTrailing
case .trailing:
self = .trailing
case .bottomTrailing:
self = .bottomTrailing
case .bottom:
self = .bottom
case .bottomLeading:
self = .bottomLeading
default:
self = .center
}
}
}
let anchor = UnitPoint(alignment)
```
Нам нужно будет внести поправку в *placeSubviews*со значением привязки.
```
let xCorrection = anchor.x * (bounds.width - row.width)
let yCorrection = anchor.y * (row.height - element.size.height)
```
### Кэширование
Мы будем кэшировать минимальный размер контейнера и расположение строк для повышения производительности. Расположение строк зависит как от размера предложения, так и от размера сабвью. Всякий раз, когда они изменяются, расположение строк должно быть пересчитано.
```
struct Cache {
var minSize: CGSize
var rows: (Int, [Row])?
}
func makeCache(subviews: Subviews) -> Cache {
Cache(minSize: minSize(subviews: subviews))
}
func updateCache(_ cache: inout Cache, subviews: Subviews) {
cache.minSize = minSize(subviews: subviews)
}
func computeHash(proposal: ProposedViewSize, sizes: [CGSize]) -> Int {
let proposal = proposal.replacingUnspecifiedDimensions(by: .infinity)
var hasher = Hasher()
for size in [proposal] + sizes {
hasher.combine(size.width)
hasher.combine(size.height)
}
return hasher.finalize()
}
// In `arrangeRows` beginning
let hash = computeHash(proposal: proposal, sizes: sizes)
if let (oldHash, oldRows) = cache.rows,
oldHash == hash {
return oldRows
}
// In `arrangeRows` end
cache.rows = (hash, rows)
```
### Применение
После всей этой работы мы можем, наконец, переопределить наш список тегов.
```
WrappingHStack(alignment: .leading) {
ForEach(tags) {
TagView(text: $0.text)
}
}.padding()
```
### Ограничения
Контейнер по своей конструкции не поддерживает сабвью, которые бесконечно увеличиваются по вертикальной оси. Как бы вы вообще определили высоту в этом случае?
### Заключительные мысли
Мы написали наш контейнер универсальным способом, который может обрабатывать самые разные сабвью. Это определенно было непросто, и теперь мы можем оценить простоту использования стандартных *HStack*и *VStack*.
Полный код смотрите на <https://github.com/ksemianov/WrappingHStack>. | https://habr.com/ru/post/705722/ | null | ru | null |
# Введение в комлексные числа
Привет!
Выяснив, что многие знакомые программисты не помнят комплексные числа или помнят их очень плохо, я решил сделать небольшую шпаргалку по формулам.
А школьники могут что-то новое узнать ;)
// Всех кого заинтересовал прошу под кат.
Итак, комплексные числа эта такие числа, которые можно записать как
Где x, y вещественные числа(т.е привычные всем числа), а i — число, для которого
выполняется равенство 
Кстати, -i в квадрате тоже дает -1.
Так что утверждение, что если дискрименант отрицательный, то корней нет это вранье.
А точнее оно выполняется на множестве вещественных чисел.
Т.е можем записать:
x называется действительной частью, y — мнимой.
Это алгебраическая форма записи комплексного числа.
Существует также тригонометрическая форма записи комплексного числа z:
С введением, пожалуй, все.
Переходим к самому интересному — операциям над комплексными числами!
Для начала рассмотрим сложение.
У нас есть два таких комплексных числа:
Как же их сложить?
Очень просто: сложить действительную и мнимую части.
Получим число:
Все просто, не так ли?
Вычитание выполняется аналогично сложению.
Нужно просто вычесть из действительной части 1 числа действительную часть 2 числа,
а потом проделать тоже с мнимой частью.
Получим число
Умножение выполняется вот так:
Напомню, x это действительная часть, y — мнимая.
Деление выполняется вот так:
Кстати, поддержка комплексных чисел есть в стандартной библиотеке Python:
```
z1=1+2j
z2=3+5j
z3=z1+z2
print(z3) #4+7i
```
Вместо i используется j.
Кстати, это потому что Python принял конвенцию инженеров-электриков, у которых
буква i обозначает электрический ток.
Задавайте свой вопросы, если они есть, в комментариях.
Надеюсь, вы узнали для себя что-то новое.
UPD: В комментариях просили рассказать о практическом применении.
Так вот комплексные числа нашли широкое практическое применение в авиации
(подъемная сила крыла) и в электричестве.
Как видете, очень нужная вещь ;) | https://habr.com/ru/post/354548/ | null | ru | null |
# Автоматизация перезагрузки роутера CISCO RVS4000
Так уж случилось, что домашний роутер после двух лет безглючной работы начал время от времени подвисать. Проявлялось это в подвисании WAN порта и отсутствии интернета у всей подсети, LAN работает нормально. Решение оказалось не таким простым, как может показаться сначала.
**Перед использованием данного руководства сделайте резервную копию настроек вашего роутера**
Подбор правильного минимального решения требует для рассмотрения нескольких вариантов.
Первое решение, которое было в последствии отброшено по причине сложности и длительности реализации — arduino+ethernet shield/raspberry PI + реле. Это тот случай, когда не нужно решать все задачи одним и тем же привычным способом, даже если очень хочется. Как минимум пришлось бы ждать либо ethernet shield, либо raspberry PI. А ждать не хотелось. Далее логично было бы предположить, что раз нельзя сделать перезагрузку аппаратно, то может это можно сделать программно. Действительно, роутер подвисал не полностью, и предоставлял возможность без проблем войти в админку. 5 минут гугления.
```
curl -u 'login:password' 'http://192.168.1.1/setup.cgi?todo=reboot'
```
Ссылка замечательно работает в браузере, но через curl рецепт в упор не хотел работать и выдавал.
```
401 Unauthorized
#### 401 Unauthorized
Authorization required.
---
```
Вариации с post параметрами, использование библиотеки request не дали положительного результата, ответ сервера всё тот же. Разбираться в тонкостях авторизации очень не хотелось. Виртуальная машина + скрипт на sikuli — с пушки по воробьям. Окончательное решение: использовать nodejs+coffeescript+phantomjs. Так уж сложилось исторически, что домашний linux дистрибутив «для поэкспериментировать» у меня gentoo. До последнего момента в gentoo был битый ebuild для phantomjs: сначала он просто не собирался, а потом таки стал собираться, но работать при этом всё-равно отказывался. Обидно, но попытка не пытка.
Создаем рабочее окружение для поделки и устанавливаем зависимости:
```
mkdir /opt/ext/router_reboot_tool
cd /opt/ext/router_reboot_tool
npm install -g coffeescript
npm install phantomjs phpjs
```
И вот тут вскрывается интересный факт. При установке phantomjs он подтягивает готовый рабочий бинарник. Вот чудо, не надо будет плясать с бубном. Дальше уже дело техники.
check.coffee проверяет наличие интернета как умеет, и в случае падения вызывает reboot.sh:
```
#!/usr/bin/coffee
fs = require('fs')
exec= require('child_process').exec
php = require('phpjs')
_old_console_log = console.log
console.log = (t)->
_old_console_log "[#{php.date('d.m.Y H:i:s')}] #{t}"
check_internet = (get_result)->
exec 'ping -c1 8.8.8.8', (_skip,result)->
get_result /1 packets transmitted, 1 received/.test result
if fs.existsSync 'marker'
console.log 'marker detected'
fs.unlinkSync 'marker'
process.exit()
fail_count = 0
max_fail_count = 10
check_count = 0
main_loop = setInterval ()->
check_count++
if check_count > 60*5-10
console.log "wiped (new will started by cron)"
process.exit()
check_internet (r)->
return if fail_count > max_fail_count # дополнительная проверка. Лень пока-что разбираться почему нужна
# console.log r
if r
fail_count = 0
else
fail_count++
console.log "fail #{fail_count}"
if fail_count > max_fail_count
console.log "reboot"
clearInterval main_loop # как ни странно не срабатывает
fs.writeFileSync 'marker', ''
exec './reboot.sh', (_skip,result)->
console.log result
setTimeout ()->
fs.unlinkSync 'phantom_marker'
process.exit()
, 10000
, 1000
```
Дополнительная запись файла marker нужна для того, что бы случайно не отправить 2 запроса перезагрузки подряд. Такое может быть если интернет пропал как раз перед концом 5-минутного интервала. А так мы гарантировано имеем промежуток как минимум 5 минут между перезагрузками роутера.
**Сюрприз №1**. clearInterval не захотел убивать интервал и reboot.sh вызывался в некоторых случаях по 4 раза из-за чего у меня слетели настройки на роутере. Внезапно две команды reboot подряд с интервалом в секунду вызывают hard reset. Решение-костыль так и осталось в готовом решении.
reboot.sh сильно логикой не отличается умом и сообразительностью. Прост и банален. **Потом его придется поправить**.
```
#!/bin/bash
coffee -c ./phantom.coffee
./node_modules/phantomjs/bin/phantomjs ./phantom.js
```
phantom.coffee
```
console.log "start..."
# fs = require('fs')
# if fs.existsSync 'phantom_marker'
# console.log "phantom_marker"
# phantom.exit()
# fs.writeFileSync 'phantom_marker', ''
page = require('webpage').create()
page.onConsoleMessage = (msg)->
console.log msg
url = 'http://192.168.1.1/Reboot.htm'
page.settings.userName = 'login'
page.settings.password = 'password'
page.open url, ()->
page.evaluate ()->
document.getElementsByName('mtenReboot')[0].click()
console.log 'waiting...'
setTimeout ()->
console.log 'exit'
# fs.unlinkSync 'phantom_marker'
phantom.exit()
, 10000
```
В связи с тем, что хотелось добавить защиту от случайного запуска reboot.sh дважды, я добавил запись файла phantom\_marker как индикатора того, что процесс уже запущен и не надо запускать еще один. Но тут меня ждал сюрприз №2.
**Сюрприз №2**. скрипты для phantomjs не поддерживают модули для nodejs (или просто модуль fs, или поддерживают, но какую-то старую версию модулей, подробно разбираться не имело смысла). Обидно, комментируем, вносим проверку в reboot.sh, которая менее красива, но работает.
Обновленный reboot.sh:
```
#!/bin/bash
if [ -a 'phantom_marker' ]
then
echo "phantom_marker present"
exit
fi
touch phantom_marker
coffee -c ./phantom.coffee
./node_modules/phantomjs/bin/phantomjs ./phantom.js
unlink phantom_marker
```
Финальные штрихи
```
chmod +x check.coffee
chmod +x reboot.sh
crontab -e
*/5 * * * * cd /opt/ext/router_reboot_tool && ./check.coffee 2>&1 >> ./log
/etc/init.d/vixie-cron restart
```
Вносим правило уже ручками (я верю, что есть способ как это сделать из консоли, но у меня не было задачи автоматизировать установку данной поделки). После обновления crontab перезагружаем cron, иначе ничего работать не будет.
Пару тестов с ручным выключением WAN показали, что скрипт работает как нужно. В сумме на поиск решения и на решения сюрпризов было потрачено 2-4 часа, которых у кого-то может не быть, потому решил выложить решение на общее обозрение. Модифицировать скрипты под другой роутер — несложно, надо просто заменить путь к странице с кнопкой reboot и само нажатие на кнопку.
Что хотелось бы доделать, но не дошли руки: убрать костыль для лишней проверки fail\_count. | https://habr.com/ru/post/200328/ | null | ru | null |
# Как отличить хороший ремонт от плохого, или как мы в SRG сделали из Томита-парсера многопоточную Java-библиотеку
В этой статье речь пойдет о том, как мы интегрировали разработанный Яндексом Томита-парсер в нашу систему, превратили его в динамическую библиотеку, подружили с Java, сделали многопоточной и решили с её помощью задачу классификации текста для оценки недвижимости.
### Постановка задачи
В оценке недвижимости большое значение имеет анализ объявлений о продаже. Из объявления можно получить всю необходимую информацию об объекте недвижимости, в том числе и информацию о состоянии ремонта в квартире. Обычно эта информация содержится в тексте объявления. Она очень важна при оценке, так как хороший ремонт может добавить к цене за квадратный метр несколько тысяч.
Итак, у нас есть текст объявления, который необходимо классифицировать в одну из категорий согласно состоянию ремонта в квартире (без отделки, чистовой, средний, хороший, отличный, эксклюзивный). Про ремонт в объявлении может быть сказано одно-два предложения, пара слов или ничего, поэтому классифицировать текст полностью не имеет смысла. Ввиду специфичности текста и ограниченного набора слов, относящихся к контексту ремонта, единственным разумным решением стало извлечение всей необходимой информации из текста и классифицирование уже именно её.
Теперь надо научиться извлекать из текста все факты о состоянии отделки. Конкретно то, что напрямую касается ремонта, а также все, что может косвенно говорить о состоянии квартиры — наличие натяжных потолков, встроенной техники, пластиковых окон, джакузи, использование дорогих отделочных материалов и т.д.
При этом надо извлечь только информацию о ремонте в самой квартире, потому что состояние подъездов, подвалов и чердаков нас не интересует. Также надо ещё учесть то, что текст написан на естественном языке со всеми присущими ему ошибками, опечатками, сокращениями и прочими особенностями — лично я нашла три варианта написания слов “линолеум” и “ламинат” и пять вариантов написания слова “предчистовая”; некоторые люди не понимают, зачем нужны пробелы между словами, а другие не слышали про запятые. Поэтому самым простым и разумным решением стал парсер с контекстно свободными грамматиками.
Таким образом, по мере решения сформировалась вторая большая и интересная задача — научиться извлекать всю достаточную и необходимую информацию о ремонте из объявления, а именно обеспечить быстрый синтаксический и морфологический анализ текста, который сможет работать параллельно под нагрузкой в режиме библиотеки.
### Переходим к решению
Из доступных средств для извлечения фактов из текста на основе контекстно-свободных грамматик, способных работать с русским языком, наше внимание привлекли Томита-парсер и библиотека Yagry на питоне. Yagry сразу был забракован, так как написан целиком и полностью на питоне и вряд ли хорошо оптимизирован. А Томита изначально выглядела очень привлекательно: располагала подробной документацией для разработчика и большим количеством примеров, С++ обещал приемлемую скорость. Разобраться в правилах написания грамматик не составило труда, и первая версия классификатора с её использованием была готова уже на следующий день.
Примеры правил из наших грамматик, извлекающие прилагательные и глаголы, относящиеся к контексту ремонта:
```
RepairW -> "ремонт" | "состояние" | "отделка";
StopWords -> "подъезд" | "холл" | "фасад" | "вестибюль";
Repair -> RepairW Adj+ interp (Repair.AdjGroup {weight = 0.5});
Repair -> Verb Adj\* interp (Repair.Verb) RepairW {weight = 0.5};
```
Правила, служащие для того, чтобы информация о состоянии мест общего пользования не извлекалась:
```
Repair -> StopWords Verb* Prep* Adj* RepairW;
Repair -> Adj+ RepairW Prep* StopWords;
```
По умолчанию вес правила равен 1, присваивая меньший вес правилу мы устанавливаем очередность их выполнения.
Немного смущало то, что в общий доступ выложено только консольное приложение и тонна кода на С++. Но несомненным плюсом стали удобство использования и быстрый результат на экспериментах. Поэтому про возможные сложности внедрения её в нашу систему было решено подумать ближе к самому внедрению.
Практически сразу удалось добиться качественного извлечения почти всей необходимой информации о ремонте. “Почти”, потому что изначально некоторые слова не извлекались ни при каких условиях и грамматиках. Однако сразу оценить масштаб этой проблемы, насколько она сможет повлиять на качество решения задачи классификации в целом, было сложно.
Убедившись, что в первом приближении Томита обеспечивает нам необходимый функционал, мы поняли, что в виде консольного приложения использовать её не вариант: во-первых, консольное приложение оказалось нестабильным и время от времени падало по непонятным причинам, а во-вторых, не обеспечило бы необходимую нагрузку парсинга в несколько миллионов объявлений в сутки. Таким образом, стало определенно точно ясно, что надо делать из неё библиотеку.
### Как мы сделали Томиту многопоточной библиотекой и подружили её с Java
Наша система написана на Java, tomita-parser на C++. Нам необходимо было получить возможность вызвать из Java парсинг текста объявления.
Разработку java-binding-ов для Томита-парсер условно можно разделить на два составляющих — реализация возможности использования Томиты как разделяемой библиотеки и, собственно, написание слоя интеграции с jvm. Основная сложность касалась первой части. Сама Томита изначально проектировалась для исполнения в отдельном процессе. Отсюда вытекало, что основными преградами на пути использования парсера в процессе приложения выступали два фактора.
1. Обмен данных осуществлялся через разного рода IO. Требовалось реализовать возможность обмена данными с парсером через память. Причем сделать это было необходимо таким образом, чтобы минимально затронуть код самого парсера. Архитектура Томиты подсказала способ реализации чтения входных документов с памяти как реализацию интерфейсов CDocStreamBase и CDocListRetrieverBase. С выходными данными было сложнее — пришлось затронуть код xml-генератора.
2. Второй фактор, вытекающий из принципа «один парсер — один процесс», — глобальное состояние, модифицируемое из разных инстансов парсера. Если заглянуть в файл [src/util/generic/singleton.h](https://github.com/gilmullin/tomita-parser/blob/master/src/util/generic/singleton.h), виден механизм использования разделяемого состояния. Нетрудно себе представить, что при использовании двух инстансов парсера в одном адресном пространстве будет возникать состояние гонки. Чтобы не переписывать весь парсер, было принято решение модифицировать данный класс, заменив глобальное состояние на локальное по отношению к потоку (thread\_local). Соответственно, перед любым вызовом парсера в обертке JTextMiner мы выставляем эти thread\_local переменные на текущий инстанс парсера, после чего код парсера работает с адресами текущего инстанса парсера.
После устранения этих двух факторов парсер был доступен для использования в качестве разделяемой библиотеки из любого окружения. Написать jni-биндинги и java-обертку не составило уже никакого труда.
Томита-парсер перед использованием должен быть сконфигурирован. Параметры конфигурации аналогичны тем, которые используются при вызове консольной утилиты. Непосредственно парсинг заключается в вызове метода parse(), который принимает на вход документы для парсинга и возвращает xml в виде строки с результатами работы парсера.
Многопоточный вариант Томиты — TomitaPooledParser использует для парсинга пул объектов TomitaParser, одинаковым образом сконфигурированных. Для парсинга используется первый свободный парсер. Поскольку количество создаваемых парсеров равно количеству потоков в пуле, то всегда будет как минимум один доступный парсер для задачи. Метод parse выполняет асинхронный парсинг предоставленных документов в первом свободном парсере.
Пример вызова Томита-библиотеки из Java:
```
/**
* @param threadAmount number of threads in the pool
* @param tomitaConfigFilename tomita config.proto
* @param configDirname dir with configs: grammars, gazetteer, facttypes.proto
*/
tomitaPooledParser = new TomitaPooledParser(threadAmount, new File(configDirname), new String[]{tomitaConfigFilename});
Future result = tomitaPooledParser.parse(documents);
String response = result.get();
```
В response — XML-строка с результатом парсинга.
### Проблемы, с которыми мы столкнулись и как мы их решали
Итак, библиотека готова, запускаем сервис с её использованием на большом объеме данных и вспоминаем про проблему не извлечения некоторых слов, понимая, что это очень критично для нашей задачи.
Среди таких слов оказались “предчистовая”, а также “сделан”, “произведен” и другие сокращенные причастия. То есть слова, которые встречаются в объявлении очень часто, и подчас это единственная или очень важная информация о ремонте. Причина такого поведения — слово “предчистовая” оказалось словом с неизвестной морфологией, то есть Томита просто не может определить, какая это часть речи, и, соответственно, не может его извлечь. А для сокращенных причастий пришлось написать отдельное правило, и проблема решилась, но было потрачено определенное время на то, чтобы разобраться в том, что это именно сокращенные причастия, для извлечения которых нужно специальное правило. А для многострадальной “предчистовой” отделки пришлось написать отдельное правило как для слова с неизвестной морфологией.
Для того, чтобы решить проблемы парсинга с помощью грамматик, добавляем в газеттир слово с неизвестной морфологией:
```
TAuxDicArticle "adjNonExtracted"
{
key = "предчистовая" | "пред-чистовая"
}
```
Для сокращенных деепричастий используем грамматические характеристики partcp,brev.
И теперь можем написать правила для этих случаев:
```
Repair -> RepairW Word interp (Repair.AdjGroup) {weight = 0.5};
Repair -> Word interp (Repair.AdjGroup) RepairW Prep\* Adj+;
```
И последняя из обнаруженных нами проблем — сервис с многопоточным использованием Томита-библиотеки плодит процессы myStem, которые не уничтожаются и спустя некоторое время заполняют всю память. Самым простым решением оказалось ограничение максимального и минимального количества потоков в Tomcat.
### Пара слов о классификации
Итак, теперь мы имеем информацию о ремонте, извлеченную из текста. Классифицировать её с помощью одного из алгоритмов градиентного бустинга не составило труда. Не будем здесь останавливаться надолго на этой теме, об этом сказано и написано уже очень много и ничего кардинально нового в этой области нами сделано не было. Приведу только показатели качества классификации, которые были нами получены на тестах:
* Accuracy = 95%
* F1 score = 93%
### Заключение
Реализованный сервис с использованием Томита-парсера в режиме библиотеки в данный момент стабильно работает, парсит и классифицирует несколько миллионов объявлений в сутки.
### P.S.
[Весь код Томиты](https://github.com/gilmullin/tomita-parser), написанный нами в рамках этого проекта выложен на гитхаб. Надеюсь, это пригодится кому-нибудь, и этот человек сэкономит немного времени на что-нибудь ещё более полезное. | https://habr.com/ru/post/439614/ | null | ru | null |
# Ajax на мобильном браузере или мобильный Ajax (с примерами)
Ajax, судя по тенденциям, всё больше овладевает умами девелоперов. Особенно активно сейчас начинает развиваться Ajax для мобильных браузеров. Об этом собственно и поговорим.
Технология Ajax очень востребована пользователями мобильных устройств. Причина в общем-то на поверхности. Снижается потребление трафика и трата времени. Ведь подгружаются всего некоторые части страницы, а не она вся (если не в теме, что такое Ajax — рекомендую посетить Wikipedia — [Ajax](http://ru.wikipedia.org/wiki/AJAX)). Соответственно серфинг сети с мобильного устройства становиться более качественным, быстрым и менее раздражающим. Более того, он обходиться дешевле.
Мобильный Ajax всё-таки довольно разительно отличается от обычного, PC’шного. Это связано со специфической архитиктурой мобильных операционных систем, пропускной способности канала и т.п. Однако ничего невозможного нет. Стоит оглянуться только на приличную поддержку SVG и Flash — это именно те технологии, которые вы уже используете или будете использовать буквально завтра в своём телефоне или КПК.
Так, теперь мы имеем примерное представление того, какой это зверь — мобильный Ajax. Давайте немного углубимся.
Каковы же минимальные требования к мобильному браузеру? В общем эти требования не шибко о
тличаются от требований к браузерам на PC. XMLHttpRequest или ActiveX, и JS DOM для отрисовки.
Переведу на русский язык — XMLHttpRequest нужен для асинхронной загрузки данных, а минимальный JS DOM для изменения документа в браузере без перезагрузки страницы. И кто бы мог подумать — есть уже мобильные браузеры, которые могут нам помочь. И мало того, что их количество близится к десяти, так ещё в их полку прибывает с завидной регулярностью. Всё больше компаний и корпораций понимают, что мобильный Ajax — вещь полезная и нужная.
Список браузеров:
\* (Opera Mobile >= 8.x, не Opera Mini)
\* Internet Explorer Mobile (WM 5.0+/2003)
\* S60 3rd edition (WebKit/KHTML core)
\* Minimo (Gecko-based)
\* OpenWave (>=Mercury)
\* NetFront (>=3.4)
\* Safari Mobile (iPhone)
Некоторые специалисты считают, что Ajax может подвинуть такого монстра как J2ME. Правда до сих пор многие мобильные браузеры работают по разному под различными операционными системами, и как следствие, Ajax тоже или глючит, или не работает вовсе. Но это дело времени. Это на заметку девелоперам — готовьте санки, но пока не катайтесь.
Среди Ajax-платформ для мобильных устройств, есть отдельный класс, которые называют mojax или bling. Но их используют в основном для прочих девайсов, которые требуют выхода в сеть без участия человека. И как правило требуют специфического API девайса.
Ajax приложения для PC давно перестали быть чем-то таким, что требует пляски с бубном и траты нервов. Сейчас всё несколько проще — есть куча фреймворков, взять хотя бы Prototype или jQuery.
Дам ссылки на пару фреймворков в конце статьи :)
Ну что? Поехали?
Для начала проверьте связку мобильной ОС и вашего мобильного браузера тут — <http://pwmwa.com/frost/> — на предмет работы Ajax’a в системе.
Создадим объект XMLHttpRequest:
`req = new XMLHttpRequest();`
или
`req = new ActiveXObject(Microsoft.XMLHTTP);`
Для спокойствия и удобства обернём всё в функцию:
`function getXHR()
{
if(window.XMLHttpRequest)
{
req = new XMLHttpRequest();
return true;
}
else try
{
req = new ActiveXObject(‘Msxml2.XMLHTTP’);
return true;
}
catch(e)
{
try
{
req = new ActiveXObject(“Microsoft.XMLHTTP”);
return true;
}
catch(e)
{
req = false;
return false;
}
}
}`
Открываем HTTP соединение:
`req.open(‘POST’, url, true);`
Первый аргумент определяет метод передачи — GET, POST и т.п.
Второй адрес url, который собственно запрашиваем.
Третий аргумент определяет, должен ли запрос быть асинхронным, или обработка должна остановиться, пока ответ не получен. Чаще всего, естественно, используют true.
Когда запрос сформирован, надо отсылать. Сделать это можно так:
`send(”);`
После отправки запроса нам нужно контролировать его выполнение. В частности нужно узнать, ответил ли сервер кодом HTTP 200. Сделать это можно примерно так:
`function ajaxCallback()
{
if(req.readyState == 4)
{
if(req.status == 200)
{
//Do something with the response
}
}
}`
Что бы обработать то, что мы получили нам нужно использовать responseText или responseXml. Первое — представление данных, полученных с сервера, и второе — DOM-совместимая версия. Как только XMLHttpRequest выполнен, то нужно сразу обновить XHTML, основываясь на полученных данных. Удобней всего использовать innerHTML.
Так мы заменим содержимое HTML элемента с id=”someElement” на “some text”:
`document.getElementById(’someElement’).innerHTML = ’some text’;`
А что бы заменить на полученные с сервера данные:
`document.getElementById(’someElement’).innerHTML = req.responseText;`
Основываясь на написанном выше, мы можем написать Ajax-приложение, которое будет обладать следующим функционалом:
\* ссылки будут иметь реальные адреса;
\* по щелчку будет отправлен запрос на сервер, после обработки сервер отдаст данные;
\* когда браузер получит данные, он обновит содержимое страницы;
\* если аякса не будет, по причине выключенного JS или по иным причинам — то будет выполнен переход на указанный адрес
Сама страница будет выглядеть так:
`xml version=“1.0″ encoding=“UTF-8″?
/>
dev.mobi mAjax
[onclick=“return updateElm(’getTime.php’, ‘timeDiv’);” >Get server time
No ajax data yet](“fallbackTime.php”<br/)`
majax.js — сам JS код, а getTime.php — скрипт, к которому мы будем обращаться по клику.
`function updateElm(url, id)
{
if(getXHR())
{
req.open(‘POST’, url, true);
req.onreadystatechange = function()
{
if(req.readyState == 4)
{
if(req.status == 200)
{
document.getElementById(id).innerHTML = req.responseText;
}
else
{
document.getElementById(id).innerHTML = ‘Could not retrieve data’;
}
}
req.send(”);
}
else return true;
return false;
}`
Когда человек кликает на ссылку, то с помощью JS скрипта происходит асинхронное обращанеи к скрипту getTime.php. После получения данных будет заменено содержимое контейнера timeDiv.
Затем updateElem получает ссылку на объект XMLHttpRequest (getXHR ()), устанавливает связь с URL, и определяет функцию отзыва. Функция отзыва проверяет, что запрос завершён (req.readyState == 4) и что статус HTTP является 200. Эта функция также определяет, успешно ли обновлён id=’id’.
В итоге получается так: если JS есть и работает нормально, то человек получает обновлённые данные с помощью нашего Ajax-приложения. Если нет, то переходит по другому линку, получая теже данные, но с переходом на другую страницу.
Содержимое getTime.php простое:
`php<br/
echo date(‘l dS \of F Y h:i:s A’);
?>`
Разумеется заменить информацию можно чем угодно. Каквы будете формировать php — это сугубо ваша забота :)
В итоге получаем туже страницу, но с изменёнными даными в контейнере с id=”someElement”
`php echo ‘<?xml version=”1.0″ encoding=”UTF-8″?’?>
/>
dev.mobi mAjax
[”
onclick=“return updateElm(’getTime.php’, ‘timeDiv’);” >Get server time
php echo date(‘l dS \of F Y h:i:s A’); ?](“fallbackTime.php?uid=<?php)`
Функционирующий пример можно посмотреть нажав [сюда](http://dev.mobi/m/majax/1/t1.htm) ([скачать пример](http://dev.mobi/files/example1.tar.gz)).
Согласитесь, немного непохоже на привычный Ajax — я бы сказал нет атрибутов этого метода. Сейчас исправим:
`document.getElementById(id).innerHTML = ‘’;`
Как только отправлен запрос, появляется картинка, и изчезает только после получения данных с сервера.
`if(req.readyState == 4)
{
document.getElementById(id).innerHTML = req.responseText;
}
else
{
document.getElementById(id).innerHTML = ‘’;
}`
Пример после изменений можно посмотреть нажав [сюда](http://dev.mobi/m/majax/2/t1.htm) ([скачать пример](http://dev.mobi/files/example2.tar.gz)).
В качестве десерта:
[FROST framework project](http://www.pavingways.com/frost-ajax-library/)
[mAJAX FAQ](http://www.horizonchannel.com/archives/26)
Подробности, дополнения и необходимую документацию можно найти на странице **с оригиналом статьи** (которую я и перевёл) по [этому адресу](http://dev.mobi/article/getting-started-with-mobile-ajax).
Кросс-пост из моего [блога](http://absolvo.ru/2008-05-08/ajax-na-mobilnom-brauzere-ili-mobilnyj-ajax-s-primerami/). | https://habr.com/ru/post/31551/ | null | ru | null |
# Just for fun: команда PVS-Studio придумала мониторить качество некоторых открытых проектов
Статический анализ кода — это важная составляющая всех современных проектов. Еще более значимым является его правильное применение. Мы решили организовать регулярную проверку некоторых открытых проектов, чтобы увидеть эффект от частого прогона анализатора. Мы используем анализатор PVS-Studio для проверки проектов, а просматривать результаты будем при помощи SonarQube. Так наши подписчики будут узнавать о новых интересных багах в только что написанном коде. Думаем, это будет забавно.
Почему же все-таки важна регулярная проверка проектов? Если запускать статический анализ редко, например, только перед релизом, то можно "утонуть" в большом количестве предупреждений и, просматривая их все, можно пропустить действительно важные срабатывания анализатора, указывающие на серьёзные ошибки. Если же запускать анализ регулярно, например, каждый день, то количество срабатываний будет не таким большим, и можно достаточно легко выявить действительно важные проблемы. Другая причина — это цена ошибки: чем раньше проблема будет обнаружена, тем дешевле ее устранить. Например, если запускать статический анализ только перед релизом, то к этому моменту большинство ошибок будет найдено отделом тестирования и исправлено, но такие исправления стоят дороже. То есть регулярный анализ – это единственно правильный способ использования статического анализа.
Как вы, наверное, знаете, наша команда часто публикует отчёты о проверке проектов с открытым исходным кодом. Такие статьи безусловно интересно читать, и они приносят определённую пользу и самим проверяемым проектам – мы всегда отправляем отчёт о найденных подозрительных местах разработчикам. Однако, такие единичные проверки проектов имеют те же недостатки, что и описанный выше сценарий с нерегулярной проверкой кода только перед релизом. Большой отчёт сложно воспринимать, а многие ошибки, которые можно было бы найти и исправить сразу же после их попадания в код уже оказываются исправлены на других уровнях контроля качества (например, с помощью тестов).
Поэтому мы решили попробовать новый формат работы с open source проектами – регулярная, каждодневная проверка кода одного (для начала) проекта. При этом эта проверка будет настроена так, что каждый день потребуется смотреть срабатывания анализатора только на изменившемся или вновь написанном коде — это и значительно быстрее, чем просмотр полного отчёта анализатора, и, главное – позволит очень быстро обнаружить потенциальную ошибку. Когда же мы будем встречать что-то действительно интересное, мы будем делать про это небольшие заметки или даже просто записи в Twitter.
Мы надеемся, что данный формат позволит нам как лучше популяризировать более правильную практику регулярного использования статического анализа, так и принесёт дополнительную пользу open source сообществу.
В качестве первого проекта для анализа мы решили выбрать проект [Blender](https://www.blender.org/). Вы можете написать нам какие дополнительные проекты вы хотели бы, чтобы мы также регулярно анализировали и рассказывали про найденные в них ошибки.
### Настройка регулярного анализа
Для нашей задачи самым оптимальным решением для регулярного анализа мы считаем cвязку инструментов PVS-Studio – SonarQube. Далее в статье мы расскажем про настройку выбранных инструментов: как запустить и настроить SonarQube, опишем как проанализировать проект и загрузить полученные результаты для отображения.
#### Почему мы выбрали SonarQube
PVS-Studio умеет многое: анализировать, рассылать уведомления о найденных предупреждениях, фильтровать их, но также еще умеет интегрироваться в разные системы для отображения предупреждений. Чтобы не только получать результаты проверки, но и дополнительно тестировать больше режимов работы PVS-Studio, мы решили попробовать настроить отображение результатов для нашей задачи в SonarQube.
Подробности о возможностях этого приложения можно прочитать [тут](https://www.sonarqube.org/). Мы же приступим к развертыванию. Все данные SonarQube хранит в базе данных. Можно использовать разные базы, но рекомендованной является PostgreSQL. Сначала настроим ее.
#### Настройка PostgreSQL
Скачаем последнюю версию [здесь](https://www.postgresql.org/download/windows/). Устанавливаем базу данных, создадим базу данных для использования SonarQube. Для этого сначала создадим пользователя с именем sonar – в командной строке psql выполним следующую команду:
```
CREATE USER sonar WITH PASSWORD '12345';
```
Для этой и других операций также можно использовать pgAdmin. Создадим базу с именем sonarqube при помощи команды CREATE DATABASE, в нашем случае так:
```
CREATE DATABASE sonarqube OWNER sonar;
```
База данных готова, приступим к настройке SonarQube.
#### Настройка SonarQube
Скачаем и установим SonarQube. Последнюю версию можно взять [отсюда](https://www.sonarqube.org/success-download-community-edition). Сам дистрибутив представляет из себя архив. Распакуем архив в каталог C:\sonarqube\sonarqube-8.5.1.38104.
Отредактируем файл C:\sonarqube\sonarqube-8.5.1.38104\conf\sonar.properties. Добавим туда следующие данные для нашей созданной базы:
```
sonar.jdbc.username=sonar
sonar.jdbc.password=12345
sonar.jdbc.url=jdbc:postgresql://localhost/sonarqube
```
SonarQube увидит созданную нами базу и начнет с ней работать. Далее необходимо установить плагин для PVS-Studio. Плагин лежит в каталоге, где установлена PVS-Studio, по умолчанию это C:\Program Files (x86)\PVS-Studio. Нам нужен файл sonar-pvs-studio-plugin.jar. Скопируем его в каталог с SonarQube C:\sonarqube\sonarqube-8.5.1.38104\extensions\plugins. Также необходимо скачать плагин sonar-cxx-plugin, это можно сделать [тут](https://github.com/SonarOpenCommunity/sonar-cxx/releases). На момент написания статьи это sonar-cxx-plugin-1.3.2.1853.jar. Этот плагин тоже скопируем в каталог C:\sonarqube\sonarqube-8.5.1.38104\extensions\plugins.
Теперь можно запустить SonarQube, для этого запустим C:\sonarqube\sonarqube-8.5.1.38104\bin\windows-x86-64\StartSonar.bat.
Приступим к настройке через web-интерфейс. Заходим в браузере по адресу sonarServer:9000, где sonarServer — это имя машины, где установлен SonarQube.
#### Настройка Quality Profile
Профиль качества (quality profile) — это ключевой компонент SonarQube, в котором определен набор правил для кодовой базы. Плагин PVS-Studio предоставляет набор правил, соответствующий предупреждениям анализатора, в профиль качества мы можем добавить их все или отключить какие-либо правила, если в этом есть необходимость. В соответствии с настроенным профилем качества SonarQube будет отображать или не отображать предупреждения после анализа нашего кода.
Настроим Quality Profile, для этого перейдем на вкладку Quality Profiles и нажмем кнопку Create, как показано на рисунке ниже.
В появившемся окне введем имя профиля (оно может быть произвольным), в нашем случае PVS-Studio Way, и выберем язык – для нас сейчас актуален C++. После этого нажмем кнопку Create.
Потом переходим на вкладку Rules, там выбираем категорию Repository и в ней выбираем пункт PVS-Studio C++. Далее нажимаем кнопку Bulk Change и Activate In, в появившемся окне выбираем наш созданный профиль, то есть PVS-Studio Way.
SonarQube настроен и готов к работе.
### Анализ
Дальше настроим непосредственно анализ проекта с помощью анализатора PVS-Studio.
Скачаем исходники такой командой:
```
git clone https://github.com/blender/blender.git
```
затем сгенерируем проектные файлы:
```
make.bat full nobuild
```
сгенерируем необходимые дополнительные файлы, для этого скомпилируем проект build\_windows\_Full\_x64\_vc15\_Release\INSTALL.vcxproj.
Запустим анализ командой
```
"c:\\Program Files (x86)\\PVS-Studio\\PVS-Studio_Cmd.exe" \
-t build_windows_Full_x64_vc15_Release\\Blender.sln \
-o blender.plog --sonarqubedata -r
```
В результате анализа у нас появились файлы blender.plog и sonar-project.properties, и мы можем протолкнуть результаты нашего анализа в SonarQube. Для этого надо воспользоваться утилитой sonar-scanner.
### Sonar scanner
Утилиту можно скачать [отсюда](https://docs.sonarqube.org/latest/analysis/scan/sonarscanner/). По ссылке скачивается архив, его надо разархивировать, например, в нашем случае в каталог D:\sonar\sonar-scanner-4.5.0.2216-windows. Отредактируем файл D:\sonar\sonar-scanner-4.5.0.2216-windows\conf\sonar-scanner.properties, добавив в него строку:
```
sonar.host.url=http://sonarServer:9000
```
Где sonarServer – имя машины, где установлен SonarQube.
Выполним следующую команду:
```
D:\sonar\sonar-scanner-4.5.0.2216-windows\sonar-scanner.bat \
-Dsonar.projectKey=blender -Dsonar.projectName=blender \
-Dsonar.projectVersion=1.0 \
-Dsonar.pvs-studio.reportPath=blender.plog
```
Следует учесть, что команда вызывается из каталога с результатами анализа (blender.plog и sonar-project.properties).
Для регулярного запуска анализа на проекте все вышеописанные команды можно легко автоматизировать с помощью Continuous Integration сервера, например, Jenkins.
### Заключение
Регулярный анализ проекта позволяет устранять ошибки на самом раннем этапе, когда стоимость такого исправления минимальна. Мы надеемся, что такой новый формат по проверке open source проектов и рассказ об этом будет интересен нашим читателям и разбавит "обычные" статьи о проверке, а также принесёт пользу open source сообществу. Ещё раз напомню, что мы принимаем заявки на включение дополнительных проектов в регулярную проверку – мы не обещаем, что добавим проект, но обязательно рассмотрим все ваши предложения.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Evgeniy Ovsyannikov. [Just for Fun: PVS-Studio Team Came Up With Monitoring Quality of Some Open Source Projects](https://habr.com/en/company/pvs-studio/blog/541918/). | https://habr.com/ru/post/541922/ | null | ru | null |
# Коллекции объектов в PHP
На протяжении последних 5 лет я работаю с PHP. У него есть достаточно разных проблем, но это никогда не мешало создавать отлично работающие продукты.
Не смотря на это, есть ряд вещей, которые выполняются внутри достаточно «криво». Один из вопросов, который постоянно тратил мои нервы, был вопрос работы с множествами объектов с помощью массивом данных.
На мой взгляд, массивы в PHP имеют достаточно широкую функциональность, что, кстати, является одной из проблем при работе с множествами объектов.
Что не нравилось?
* [Исторически сложившиеся имена функций и отсутствие ОО интерфейса](http://php.net/manual/en/ref.array.php).
* Отсутствие возможности построить ассоциативный массив, где ключами будут объекты.
* Самостоятельный контроль типов объектов в массиве.
* Самостоятельный контроль последовательности индексов в списке.
В результате было принято решение о создании пакета, который должен работать с множествами однотипных объектов (коллекциями).
И так, представляю вашему вниманию пакет Rmk\Collection.
#### Интерфейсы
Интерфейсы коллекций предназначены для описания функциональности и классификации типов коллекций.
Базовым интерфейсом коллекций является интерфейс Collection.
Интерфейсы Map, Set, List, Queue и Deque наследуют интерфейс Collection и добавляют собственную функциональность.
Интерфейс Iterable предназначен для обхода объектов коллекции. Он поддерживается всеми интерфейсами коллекций.
**Iterable**
Данный интерфейс предоставляет возможность выполнять обход объектов коллекции и применять к каждому объекту пользовательскую функцию.
**Collection**
Данный интерфейс предназначен для описания базовых функций работы с множеством объектов. Он наследует интерфейсы Countable и Iterable, что позволяет получать количество объектов в коллекции и выполнять обход и применение пользовательской функции для каждого объекта коллекции. Интерфейс коллекции подразумевает, что в коллекции находятся объекты одного типа.
**Map**
Данный интерфейс предназначен для описания функциональности карты объектов. Карта объектов предназначена для построения ассоциативных связей между объектами, где один из объектов является ключем, а другой значением. Интерфейс карты объектов подразумевает, что в карте находятся ключи одного типа. Интерфейс карты объектов подразумевает, что в карте находятся значения одного типа. Интерфейс карты объектов наследует интерфейс Collection.
**Set**
Данный интерфейс предназначен для описания функциональности набора объектов, где объекты являются уникальными в рамках коллекции. Уникальность объектов осуществляется с помощью метода getIdentity(). Интерфейс набора объектов наследует интерфейс Collection.
**Queue**
Данный интерфейс предназначен для описания функциональности очереди объектов. Очередь объектов предназначена для описания структуры данных, когда объекты добавляются в конец очереди, а забираются с начала очереди. Интерфейс очереди объектов наследует интерфейс Collection.
**Deque**
Данный интерфейс предназначен для описания функциональности двунаправленной очереди объектов. Интерфейс двунаправленной очереди объектов наследует интерфейс очереди объектов Queue и добавляет дополнительную функциональность. Функциональность двунаправленной очереди объектов подразумевает работу с очередью с обеих сторон.
**SequentialList**
Данный интерфейс предназначен для описания функциональности списка объектов. Списком объектов является последовательность объектов, где объекты хранятся под последовательными целочисленными индексами. Кроме общей функциональности списка объектов, данный интерфейс определяет метод reverseEach() аналогичный методу Iterable::each() за исключением того, что метод reverseEach() обходит список в обратном порядке. Интерфейс списка объектов наследует интерфейс Collection.
#### Реализации карт
Карты представлены реализациями HashMap и HashStore.
Часть функциональности HashMap и HashStore наследуется от абстрактных классов AbstractCollection и AbstractMap.
Внутренняя структура карт HashMap и HashStore построена на основе сети ассоциативных связей. Это дает возможность реализовывать все операции карт с помощью ассоциативных выборок, что очень сильно повышает скорость их работы. Сложность работы алгоритмов карт равна O(1), что означает, что время установки/получения объектов не изменяется в зависимости от размера карт.
Карты HashMap и HashStore поддерживают любые типы данных для ключей и значений. Это является функциональным преимуществом по сравнению с стандартными Php массивами.
Ключи карты HashMap являются уникальными. Значения карты HashMap не являются уникальными, что позволяет ассоциировать одно значение с несколькими ключами.
Ключи и значения карты HashStore являются уникальными, что позволяет организовывать хранилище уникальных ассоциированных объектов.
Карта HashStore работает в среднем на 20% быстрее карты HashMap. Данное преимущество получено за счет уникальности объектов в HashStore, что требует меньшего количества ассоциативных связей.
#### Реализации наборов
Наборы представлены единственной реализацией UniqueStore.
Объекты в хранилище UniqueStore. Уникальность объектов обеспечивается за счет метода getIdentity(), который возвращает идентификаторы объектов. В хранилище UniqueStore не могут присутствовать несколько объектов с одинаковыми идентификаторами.
Внутренняя структура хранилища уникальных объектов UniqueStore построена на основе ассоциативных связей между объектами и их идентификаторами. Это дает возможность реализовывать все операции хранилища с помощью ассоциативных выборок, что очень сильно повышает скорость его работы. Сложность работы алгоритмов хранилища уникальных объектов равна O(1), что означает, что время установки/получения объектов не изменяется в зависимости от размера хранилища.
Хранилище уникальных объектов UniqueStore поддерживает любые типы данных для значений.
#### Реализации списков
Списки представлены реализациями ArrayList и LinkedList.
Списки объектов ArrayList и LinkedList поддерживают последовательный порядок индексов при изменении своей структуры.
Производительность списков объектов ArrayList и LinkedList зависит от количества изменений их структуры. Исходя из этого, самыми «дешевыми» являются операции работы с концом списка (добавление / удаление), а самыми «дорогими» — операции работы с началом списка (добавление / удаление). Сложность работы алгоритмов списка объектов равна O(n \* (count — index)), где n — операция; count — размер списка; index — индекс, по которому выполняется операция.
Списки объектов ArrayList и LinkedList поддерживают любые типы данных для значений.
Связанный список объектов LinkedList реализует интерфейс двунаправленной очереди объектов Deque и наследует функциональность от ArrayList.
#### Реализации очередей
Конкретные реализации очередей отсутствуют, так как связанный список LinkedList отлично покрывает их функциональность.
#### Несколько примеров использования
**Примеры использования карт:**
```
php
namespace Rmk\Collection;
use \UnexpectedValueException as UnexpectedValueException;
use \InvalidArgumentException as InvalidArgumentException;
use \stdClass as stdClass;
include '../../bootstrap.php';
$map = new HashMap('stdClass', 'string');
$obj1 = new stdClass();
$obj2 = new stdClass();
$obj3 = new stdClass();
// Установка ассоциаций ключ / значение.
$map-set('k1', $obj1);
$map->set('k2', $obj2);
$map->set('k3', $obj3);
try {
$map->set(27, $obj1);
} catch (InvalidArgumentException $exc) {
echo 'Ключ не подходит по типу.';
}
try {
$map->set('k4', new UnexpectedValueException);
} catch (InvalidArgumentException $exc) {
echo 'Значение не подходит по типу.';
}
// Обход карты.
$map->each(function($value, $key, $thisMap) {
/**
* @TODO: Обработка карты.
*/
}
);
// Удаление по значению.
$map->remove($obj1);
$map->remove($obj2);
// Удаление по ключу.
$map->removeKey('k3');
if ($map->isEmpty()) {
/**
* @TODO: Что делать, если карта пуста?
*/
}
// Преобразование в массив.
$array = $map->toArray();
// Внимание! Невозможно преобразовать в массив карту, у которой ключами
// являются объекты.
$objectMap = new HashMap('stdClass', 'stdClass');
try {
$objectArray = $objectMap->toArray();
} catch (UnexpectedValueException $exc) {
echo 'Объекты не могут являться ключами массива.';
}
```
**Примеры использования наборов:**
```
php
namespace Rmk\Collection;
use \UnexpectedValueException as UnexpectedValueException;
use \InvalidArgumentException as InvalidArgumentException;
use \stdClass as stdClass;
include '../../bootstrap.php';
$set = new UniqueStore('stdClass');
$obj1 = new stdClass();
$obj2 = new stdClass();
$obj3 = new stdClass();
// Добавление объектов в хранилище.
$set-add($obj1);
$set->add($obj2);
$set->add($obj3);
// Повторно объекты в хранилище добавлены не будут.
$set->add($obj3);
try {
$set->add(new UnexpectedValueException);
} catch (InvalidArgumentException $exc) {
echo 'Значение не подходит по типу.';
}
// Обход хранилища.
$set->each(function($value, $thisSet) {
/**
* @TODO: Обработка хранилища.
*/
}
);
// Удаление объектов из хранилища.
$set->remove($obj1);
$set->remove($obj2);
$set->remove($obj3);
// Преобразование в массив.
$array = $set->toArray();
```
**Примеры использования списков:**
```
php
namespace Rmk\Collection;
use \UnexpectedValueException as UnexpectedValueException;
use \InvalidArgumentException as InvalidArgumentException;
use \OutOfRangeException as OutOfRangeException;
use \stdClass as stdClass;
include '../../bootstrap.php';
$list = new LinkedList('stdClass');
$obj1 = new stdClass();
$obj2 = new stdClass();
$obj3 = new stdClass();
// Добавление объектов в список.
$list-add(0, $obj1);
$list->add(1, $obj2);
$list->add(2, $obj3);
try {
$list->add(4, $obj1);
} catch (OutOfRangeException $exc) {
echo 'Индекс находится за пределами списка дальше, чем на единицу.';
}
// Обход списка.
$list->each(function($value, $index, $thisList) {
/**
* @TODO: Обработка списка.
*/
}
);
// Обход списка в обратном порядке.
$list->reverseEach(function($value, $index, $thisList) {
/**
* @TODO: Обработка списка.
*/
}
);
// Удаление из списка.
$list->remove($obj1);
$list->removeIndex(0);
$list->removeFirst();
if ($list->isEmpty()) {
echo 'Список пуст.';
}
```
#### Преимущества и недостатки
* +
+ Увереность в типе объектов в коллекции.
+ ОО интерфейс вместо «функций работы с массивами» (основная причина написания данного пакета).
+ Уверенность в последовательности индексов в коллекциях типа SequentialList.
* -
+ Условно-низкая производительность. То, что можно было выжать из PHP реализации, я старался выжать. Но если бы данный пакет был реализован на С, как PECL модуль, то он бы работал значительно быстрее.
#### Исходные коды
<https://github.com/rmk135/Rmk-Framework> | https://habr.com/ru/post/144182/ | null | ru | null |
# Делаем часы из электронной книжки PRS-505
[](https://habr.com/ru/company/ruvds/blog/526546/)
Удивительно, но старинная электронная книга Sony prs-505 является очень классным конструктором всевозможных самоделок. В очередной раз взял эту книжку, чтобы сделать себе “бумажные” часы. Мне нравится это решение тем, что цифры получаются большие и яркие, при этом они не светятся в темноте и не мешают спать. Идея часов на электронной бумаге совершенно не новая, но мне просто захотелось снова поиграться с этой классной электронной книгой. В результате получился этакий проект выходного дня, потому что могу. Как обычно, собрал все возможные грабли и ошибки. Свой тернистый путь описал в этой статье.
Предыстория
-----------
Наверняка многие помнят мой пост "[Электронная книжка в качестве дисплея](https://habr.com/ru/post/274831/)" в котором я рассказывал, как работать с дисплеем электронной книги.
**Фотография из поста "[Электронная книжка в качестве дисплея](https://habr.com/ru/post/274831/)".**
Там по сути шла работа с фреймбуфером видеоустройства, в которой я выводил изображение. Основной проблемой в той статье была передача изображения на устройство. Тогда, я не нашёл в себе достаточно пороха и мотивации, чтобы довести задуманное до конца, потому книга была кому-то отдана, и идея сделать такое устройство была забыта. Но всё изменилось после выхода замечательной статьи от автора [alexshnup](https://habr.com/ru/users/alexshnup/): "[Электронные чернила для Wirenboard 5 или рисуем штрихкоды на Go](https://habr.com/ru/post/321238/)". В этой статье [alexshnup](https://habr.com/ru/users/alexshnup/) решал проблему вывода штрих кодов на экран данной книги для отладки сканера штрих кодов. И как раз решил проблему передачи изображений на книгу.
Если кратко, то [alexshnup](https://habr.com/ru/users/alexshnup/) создал модуль ядра, который при подключении книги по USB создаёт дополнительный виртуальный жёсткий диск, размером 600х800=480000 байт. Точнее, диск будет 1 МБ, но видимая область всего 480000 байт. По сути всё что попадает в память диска, попадет на экран книги. Вообще, это гениальная штука, можно даже визуально видеть как идёт разметка диска, если, например, создать там файловую систему. Например, послать изображение на книгу можно следующей командой:
```
djpeg -pnm -grayscale test.jpg | dd bs=1 skip=15 | dd of=/dev/sdx bs=480k
```
Всё описанное далее в данной статье, является идеологическим продолжением этих двух экспериментов.
Начнём, налажаем и сделаем снова
--------------------------------
После прочтения [статьи](https://habr.com/ru/post/321238/), я связался с её автором [alexshnup](https://habr.com/ru/users/alexshnup/). И он решил мне подарить одну разобранную книжку для экспериментов. В результате имея работающее оборудование на руках я радостно приступил к опытам. Первое, что мне было необходимо сделать — это поставить прошивку [prs-plus](https://code.google.com/archive/p/prs-plus/). И после этого можно пробовать создать тот виртуальный жёсткий диск, для передачи изображений по статье [alexshnup](https://habr.com/ru/users/alexshnup/). Не буду цитировать статью, она является исчерпывающим руководством. После этого пробую передать изображение с помощью команды dd.
**Изображение переданное новым способом.**
Радостно понимая, что всё, все карты мне в руки, интерфейс передачи изображений есть, можно его использовать как угодно, я стал делать кучу экспериментов. Начал писать программу часов, и отлаживать их вывод на книжку. В результате, как это обычно бывает с командой «dd» («disk destroyer») ошибся диском, и…
В результате записал вместо виртуального диска, на диск (флешку) самой книжки, превратив её в кирпич… Просто взял и записал 480000 байт fat-раздела. Даже передать не могу всех тех чувств, которые я испытал в тот момент.
**Окирпиченная книжка.**
Главное, как восстановить эту книжку, было непонятно. Понятно было, что нужно взять другую такую же книгу и заново на неё установить прошивку [prs-plus](https://code.google.com/archive/p/prs-plus/). Затем с неё взять эти первые 480000 байт и перенести на данный кирпич.
В общем, погрустил, психанул и купил на авито новую электронную книжку Sony prs-505. При этом книга была со всеми рабочими кнопками, в чехле, шлейфы были не рваные. Можно было использовать даже по прямому назначению, единственное, что аккумулятор был полумёртвый. Но для моих целей — этого было достаточно. Сейчас, с мёртвыми аккумуляторами эти книжки можно найти до тысячи рублей, по моему идеальная цена для Linux устройства, с открытыми исходниками и такой шикарной системой энергосбережения.
**Свежекупленная электронная книга.**
С этой книгой точно так же повторил процедуру установки прошивки, далее, как и планировал, перенёс 480000 байт fat-раздела с одной электронной книги на другую. Тем самым у меня получилось две книги, с которыми я уже развлекался. Правда, та которая была разобрана совсем начала безбожно глючить, и её я практически не использовал.
Пишем софт
----------
Идея часов достаточно простая. Мы просто будем формировать изображение времени на холсте, а потом отправлять его во фреймбуфер. Для этого сформируем цифры и двоеточия. Напомню, разрешение книжки у нас 600х800 (я не ошибся, именно 600х800), если смотреть на неё как на лист.
ЧЧ: ММ: СС — это как раз у нас получается восемь символов. Итого, каждая цифра получается размером 100x600. Для цифр выбрал приятный шрифт “Gideon’s-Army-”. Далее с помощью imagemagick формируем цифры и двоеточия следующими командами:
```
for i in `seq 0 9`; do convert -font Gideon’s-Army- -pointsize 150 -size 100x600\
-gravity center -rotate 90 -depth 8 caption:"$i" $i.pgm;done
convert -font Gideon’s-Army- -pointsize 150 -size 100x600 -gravity center -depth 8\
-rotate 90 caption:':' dots.pgm
```
В результате получаем цифры от 0 до 9 и двоеточие. Вот пример цифры 2:
Если у данного pgm-файла отрезать заголовок, то эти данные годятся сразу для записи в книгу. Об этом я подробно рассказывал в своей статье "[Электронная книжка в качестве дисплея](https://habr.com/ru/post/274831/)", поэтому детально на этом останавливаться не буду.
Дальше было дело техники сформировать из данных цифр битмап для записи во фреймбуфер, простым копированием матрицы с помощью отображения файла в память. Весь проект обитает в репозитории: [github.com/dlinyj/sony\_prs-505\_clock](https://github.com/dlinyj/sony_prs-505_clock).
Вся программа содержится в файле [time.c](https://github.com/dlinyj/sony_prs-505_clock/blob/master/time.c). Весь код разбирать не буду, но остановлюсь на нескольких моментах. В данной программе я делаю просто отображение файла в память (либо фрейм-буффера, либо тестового файла, либо файл-устройства виртуального диска электронной книги). Далее мы уже работаем с файлом, как с областью памяти. В неё копирую изображения символов часов в зависимости от текущего времени.
Отображаем в память файл, в котором буду формировать изображение.
```
image = mmap (0, file_lenght, PROT_WRITE, MAP_SHARED, fd, 0);
```
Копирование изображений идёт в функции print\_symbol, в которую передаю номер позиции цифры и имя файла цифры для копирования.
```
void print_symbol (unsigned int position, char * filename) {
void * numer_im;
int numer;
numer = open (filename, O_RDWR);
numer_im = mmap (0, NUMER_SIZE, PROT_WRITE, MAP_SHARED, numer, 0);
memcpy(ℑ[first_header + NUMER_PIXELS * position], &numer_im[16], NUMER_PIXELS);
munmap (numer_im, NUMER_SIZE);
close(numer);
}
```
Здесь открываю файл цифры, и копирую его в соответствующую позицию в области памяти отображённого файла image.
В принципе можно было каждый раз не открывать файл, читать его, потом закрывать, а просто сделать копию в памяти и осуществлять копирование оттуда, но хорошая мысль пришла только сейчас.
Если вы захотите эту программу запустить у себя на компе, чтобы формировать изображение, не забудьте в Makefile изменить компилятор и убрать define:
```
#Не забываем привести Makefile к следующему виду.
#CFLAGS=-D __BOOK__
CC = gcc
#CC= /opt/cross/gcc-3.2.3-glibc-2.2.5/arm-unknown-linux-gnu/bin/arm-unknown-linux-gnu-gcc
```
Компилируем программу, и запускаем без параметров. В результате получим файл “test.pgm” с текущим временем.
Если указать конкретное файл-устройство, то уже формирование изображения будет без заголовка pgm-файла, пригодное для загрузки на книжку. Так же данную программу можно залить в книгу, и далее в автоматическом режиме обновлять время.
Я запускал эту программу на ПК, с подключённой книжкой по USB, и на ней выводил время. Запускается программа просто (скрипт start.sh, принимает файл-устройство):
```
#!/bin/bash
while true;do ./time $1;done
```
В результате можно наблюдать на экране, как идут часы.
Выводы
------
Программа написана таким образом, что может быть собрана и залита в электронную книгу, чтобы её превратить в часы. Может показаться забавным использовать такое сложное техническое устройство в качестве часов, но почему бы и да. Сейчас в данных книгах дохнут аккумуляторы, и замена их достаточно трудоёмкое занятие. Если бы аккумулятор заменить на его эмулятор (болванка, которая даёт возможности книжке работать, но не хранит энергию), а книжку подключить к зарядному устройству, то она бы работала постоянно.
Мои эксперименты показали, что книжка на зарядном устройстве не переходит в спящий режим и часы могут работать непрерывно. Плюс в самой книге есть встроенные часы, и она может корректно показывать время.
Из проблем, с которыми я столкнулся, и не смог разрешить — это то как добавить программу часов в автозагрузку книжки, при этом придушив загрузку самого графического интерфейса, чтобы не было конкуренции за дисплей. В целом есть ещё место для дальнейших опытов и экспериментов. Но то уже будет совсем другая история, эту книгу я победил, часы выводит, можно приступать к другим проектам.
Какие у вас есть безумные предложения для использования электронной книги Sony prs-505?
Ссылки:
-------
1. [«Электронная книжка в качестве дисплея».](https://habr.com/ru/post/274831/)
2. [«Электронные чернила для Wirenboard 5 или рисуем штрихкоды на Go».](https://habr.com/ru/post/321238/)
3. [Репозиторий проекта.](https://github.com/dlinyj/sony_prs-505_clock)
4. История моих экспериментов [1](https://dlinyj.livejournal.com/720011.html), [2](https://dlinyj.livejournal.com/721487.html), [3](https://dlinyj.livejournal.com/734494.html), [4](https://dlinyj.livejournal.com/736464.html).
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=delaem_chasy_iz_elektronnoj_knizhki_prs_505#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=delaem_chasy_iz_elektronnoj_knizhki_prs_505) | https://habr.com/ru/post/526546/ | null | ru | null |
# Об одной уязвимости в…
Год назад, 21 марта 2019, в [баг баунти программу Mail.ru](https://hackerone.com/mailru) на HackerOne пришел очень хороший [багрепорт](https://hackerone.com/reports/513236) от [maxarr](https://hackerone.com/maxarr). При внедрении нулевого байта (ASCII 0) в POST-параметр одного из API-запросов веб-почты, который возвращал HTTP-редирект, в данных редиректа виднелись куски неинициализированной памяти, в которых чаще всего раскрывались фрагменты из GET-параметров и заголовков других запросов к тому же серверу.
Это критическая уязвимость, т.к. запросы содержат в том числе сессионные куки. Через несколько часов был сделан временный фикс, который фильтровал нулевой байт (как потом выяснилось, этого было недостаточно, т.к. оставалась возможность инъекции CRLF /ASCII 13, 10, что позволяет манипулировать заголовками и данными HTTP-ответа, это менее критично, но все равно неприятно). Одновременно с этим проблема была передана аналитикам безопасности и разработчикам для поиска и устранения причин возникновения бага.
Почта Mail.ru — это очень непростое приложение, в формировании ответа может участвовать большое количество различных фронтенд/бекенд-компонентов, как опенсорсных (большое спасибо всем разработчикам свободного ПО), так и собственной разработки. Удалось исключить все компоненты кроме nginx и openresty и локализовать проблему до вызова [ngx.req.set\_uri()](https://github.com/openresty/lua-nginx-module#ngxreqset_uri) в OpenResty-скрипте, который вел себя не так, как ожидалось (воткнуть нулевой байт или перевод строки через GET-параметры с rewrite в ngx\_http\_rewrite\_module, который, согласно документации используется и, казалось бы, должен работать абсолютно аналогично не получится). Были устранены возможные последствия, добавлена максимально строгая фильтрация и было проверено, что фильтрация устраняет все возможные векторы. Но механизм, который приводил к утечке содержимого памяти так и остался загадкой. Через месяц багрепорт закрыли как разрешенный, а разбор причин возникновения бага отложили до лучших времен.
OpenResty — это весьма популярный плагин, позволяющий писать Lua-скрипты внутри nginx, и он используется в нескольких проектах Mail.ru, поэтому проблема не считалась решенной. И спустя некоторое время к ней все-таки вернулись, чтобы понимать истинные причины, возможные последствия и составить рекомендации для разработчиков. В раскопках исходного кода участвовали [Денис Денисов](https://hackerone.com/kpebetka) и [Николай Ермишкин](https://hackerone.com/yngwie). Выяснилось что:
* В nginx при использовании rewrite с пользовательскими данными есть возможность directory traversal (и вероятно SSRF) в некоторых конфигурациях, но это известный факт, и он должен обнаруживаться статическими анализаторами конфигураций в [Nginx Amplify](https://www.nginx.com/products/nginx-amplify/) и [Gixy](https://github.com/yandex/gixy) от Яндекс (да, мы его тоже используем, спасибо). При использовании OpenResty такую возможность легко пропустить, но нашу конфигурацию это не затрагивало.
пример конфигурации:
```
location ~ /rewrite {
rewrite ^.*$ $arg_x;
}
location / {
root html;
index index.html index.htm;
}
```
результат
`curl localhost:8337/rewrite?x=/../../../../../../../etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
...`
* В nginx есть ошибка, приводящая к утечке содержимого памяти, если строка rewrite содержит нулевой байт. При отдаче редиректа nginx выделяет новый буфер памяти, соответствующий полной длине строке, но копирует туда строку через строчную функцию, в которой нулевой байт является терминатором строки, поэтому строка копируется только до нулевого байта, остаток буфера содержит неинициализированные данные. Подробный разбор можно найти [здесь](https://hackerone.com/reports/513236).
пример конфигурации (^@ нулевой байт)
```
location ~ /memleak {
rewrite ^.*$ "^@asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdasdf";
}
location / {
root html;
index index.html index.htm;
}
```
результат
`curl localhost:8337/secret -vv
...
curl localhost:8337/memleak -vv
...
Location: http://localhost:8337/secret
...`
* Nginx защищает GET-параметры от инъекции служебных символов и дает возможность использовать в rewrite только GET-параметры. Поэтому эксплуатировать инъекцию через контролируемые пользователем параметры в nginx не получается. POST параметры при этом не защищены. OpenResty позволяет работать и с GET и с POST параметрами, поэтому при использовании POST параметров через OpenResty появляется возможность инъекции специальных символов.
пример конфигурации:
```
location ~ /memleak {
rewrite_by_lua_block {
ngx.req.read_body();
local args, err = ngx.req.get_post_args();
ngx.req.set_uri( args["url"], true );
}
}
location / {
root html;
index index.html index.htm;
}
```
результат:
`curl localhost:8337 -d "url=secret" -vv
...
curl localhost:8337 -d "url=%00asdfasdfasdfasdfasdfasdfasdfasdf" -vv
...
Location: http://localhost:8337/{...может содержать secret...}
...`
#### Дальнейшая реакция
О проблеме сообщили разработчикам nginx и OpenResty, разработчики не рассматривают проблему как ошибку безопасности в nginx, т.к. в самом nginx нет возможности эксплуатации ошибки через инъекцию спецсимволов, фикс [раскрытия содержимого памяти](https://hg.nginx.org/nginx/rev/02a539522be4) был опубликован 16 декабря. За 4 месяца с момента репорта в OpenResty так же не было сделано каких-либо изменений, хотя было понимание, что необходим безопасный вариант функции ngx.req.set\_uri(). 18 марта 2020 мы опубликовали информацию, 21 марта OpenResty выпустила [версию 1.15.8.3](https://github.com/openresty/openresty/compare/v1.15.8.2...v1.15.8.3), которая добавляет проверку URI.
Portswigger [написал](https://portswigger.net/daily-swig/email-security-mail-ru-patches-critical-memory-disclosure-flaw) хорошую статью и взял комментарии у OpenResty и Nginx (правда комментарий о том, что раскрывается только небольшой фрагмент памяти является неверной и вводит в заблуждение, это определяется длиной строки, следующей за нулевым байтом и, при отсутствии явных ограничений на длину может контролироваться атакующим).
#### Так в чем же была ошибка и что делать, чтобы ее предотвратить?
*Была ли ошибка в nginx?* Да, была, потому что утечка содержимого памяти это в любом случае ошибка.
*Были ли ошибка в OpenResty?* Да, как минимум не был исследован и документирован вопрос о безопасности предлагаемой OpenResty функциональности.
*Была ли допущена ошибка конфигурации / использования OpenResty?* Да, потому что в отсутствии явного указания, было сделано непроверенное предположение о безопасности используемой функциональности.
*Какая из этих ошибок является уязвимостью безопасности с баунти на $10000?* Для нас это в общем-то не важно. В любом ПО, особенно на стыке нескольких компонент, особенно предоставляемых разными проектами и разработчиками никто и никогда не может гарантировать, что все особенности их работы известны и документированы и отсутствуют ошибки. Поэтому любая уязвимость безопасности возникает именно там, где она влияет на безопасность.
В любом случае, хорошей практикой будет нормализовать или максимально ограничивать/фильтровать входные данные, которые уходят в любой внешний модуль/API, если нет явных указаний и однозначного понимания, что этого не требуется.
#### Errata
По опыту [предыдущей статьи](https://habr.com/en/company/mailru/blog/492094/), ради сохранения чистоты языка:
*баг баунти* — конкурс охоты за ошибками
*багрепорт* — уведомление об ошибке
*редирект* — перенаправление
*опенсорсный* — с открытым кодом
*errata* — работа над ошибками | https://habr.com/ru/post/493920/ | null | ru | null |
# Как понять свойство clip-path в CSS
В те далёкие времена, когда я впервые столкнулся со свойством CSS `clip-path`, мне потребовалось больше времени, чем я ожидал, и я изо всех сил старался запомнить, как работает свойство. Не знаю точно, почему так получилось, но, может быть, потому, что я не пользовался им часто? Во всяком случае, я изучу его снова вместе с вами. В этой статье я стремлюсь дать чёткое, детальное объяснение того, как работает clip-path, когда его использовать и как вы можете воспользоваться им в своих проектах веб-разработки. Вы готовы?
[](https://habr.com/ru/company/skillfactory/blog/539064/)
Вступление
----------
Свойство `clip-path` создаёт область отсечения: внутри неё контент видно, а вне её – нет. Вот простой пример круга с применением `clip-path`.
```
.card {
background-color: #77cce9;
clip-path: circle(80px at 50% 50%);
}
```
Когда применяется `clip-path`, видимой областью оказывается только синий круг. **Мы не видим ничего за пределами круга**. Вот анимация, которая показывает отсечение круга из примера выше:
Система координат
-----------------
Прежде чем углубляться в детали clip-path, стоит упомянуть о том, как работает система координат. Начало координат – это верхний левый угол, ось x направлена вправо, а ось y – вниз.
Учитывая это, чтобы увидеть, как обрезается элемент, давайте возьмём простой пример. В нём обрезанная область – это круг размером 100 px, его центр расположен в точке 0,0 (вверху слева).
Обратите внимание, что пользователь видит только выделенную тёмно синюю область. Оставшаяся часть круга **обрезана**. Вопрос в том, как сделать видимым весь круг? Для этого нужно изменить точки осей `x` и `y`.
Центр круга расположен в 100 px левее и 100 px выше. Теперь, когда вы понимаете, как работает система координат, я расскажу о возможных значениях свойства `clip-path`.
Значения `clip-path`
--------------------
### `inset`
Значение `inset` определяет вставляемый прямоугольник. Мы можем контролировать четыре края, точно так же, как это делается с краями или отступом. В примере ниже `.card` имеет свойство `inset` `20px` со всех краёв (сверху, справа, снизу и слева).
```
.card {
clip-path: inset(20px);
}
```
Если нужно, подправьте `inset` с одного из краёв. Вот пример, как это сделать:
```
.card {
clip-path: inset(20 px 20 px 50 px 20 px);
}
```
Выше класс `.card` имеет свойство `inset` со значением `50px` снизу.
Вопрос в том, возможна ли округлая вставка? Да! Благодаря ключевому слову round. Добавление ключевого слова слева от радиуса округляет углы, вот так: `round` .
```
.card {
clip-path: inset(20px 20px 50px round 15px);
}
```
Кроме того, мы даже можем настроить радиус каждой стороны отдельно. Вот пример с нулевым радиусом верхнего правого и нижнего левого углов.
```
.card {
clip-path: inset(20px 20px 50px round 15px 0);
}
```
#### `circle()`
Чтобы использовать значение circle(), нам понадобится радиус и его положение. Вот пример:
```
.card {
clip-path: circle(80px at 50% 50%);
}
```
Радиус окружности равен `80px`, и она позиционирована так: `50%` на оси x, `50%` на оси y.
### `ellipse()`
С помощью функции `ellipse()` мы можем установить ширину и высоту, чтобы сделать отсечение овальным.
```
.card {
clip-path: ellipse(100px 80px at center);
}
```
### `polygon()`
Самое интересное для меня значение – polygon(). Можно управлять несколькими наборами значений по осям x и y.
```
.card {
clip-path: polygon(x y, x y, x y, x y);
}
```
Вот пример, где `polygon()` используется, чтобы обрезать прямоугольник. Обратите внимание, что я сопоставил каждый набор точек с его координатами на осях.
```
.card {
clip-path: polygon(5% 5%, 95% 5%, 95% 95%, 5% 95%);
}
```
Используя значение `polygon()`, можно рисовать сложные фигуры с несколькими точками.
### `path()`
Значение `path()` позволяет использовать элемент SVG, чтобы обрезать определённую область. Сейчас его поддержка браузером непоследовательна. Чтобы заставить это свойство работать в разных браузерах, нам нужно использовать встроенный SVG, а затем функцию `url()` как значение для `clip-path`.
```
```
В коде CSS нужно добавить путь к `clipPath` при помощи `url()`.
```
.card {
clip-path: url("#triangle");
}
```
Теперь, когда мы рассмотрели теорию `clip-path` и возможные значения этого свойства, пришло время воспользоваться свойством по-настоящему и исследовать некоторые варианты его применения. Вы готовы?
Примеры применения
------------------
### Эффект разворота плоскости
Так или иначе, нечто с подобной структурой вы уже видели. Это идеальный пример того, как использовать `clip-path`.
Можете ли вы предположить, как реализовать поворот? Здесь поможет `polygon()`.
```
.section {
clip-path: polygon(0 0, 100% 0, 100% 80%, 0 100%);
}
```
Иногда надоедает прописывать 8 значений полигона. На этот случай у меня есть для вас небольшой трюк: пусть положение точек зависит от браузера. Во-первых, добавим такой код:
```
.section {
clip-path: polygon(0 0, 100% 0, 100% 100%, 0 100%);
}
```
Исследуем эту часть с помощью DevTools. Открыв «Исследовать элемент», обратите внимание на маленький значок полигона в левой части значения `polygon()`.
Нажав его, вы сможете отредактировать полигон в браузере. Посмотрите картинку ниже:
### Угол относительно ширины видового экрана
Можно воспользоваться функцией `calc()` вместе с единицами viewport, чтобы угол зависел от ширины видового экрана. Я узнал об этом из замечательной [статьи](https://kilianvalkhof.com/2017/design/sloped-edges-with-consistent-angle-in-css/) Килиана Валькхофа.
```
.section {
clip-path: polygon(0 0, 100% 0, 100% calc(100% - 5vw), 0 100%);
}
```
#### Несколько углов
У меня в голове возник вопрос: захочется ли нам иметь несколько угловых секций? Посмотрите на рисунок ниже.
Первое, о чем я подумал, – просто добавить `box-shadow` или `border`. К сожалению, они будут обрезаны, так что, даже если добавить их, мы не увидим того, что хотим увидеть. Решение в таком случае – использовать несколько элементов, причём точка отсечения будет у каждого своя:
```
```
```
.hero {
position: relative;
min-height: 350px;
}
.hero img {
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
clip-path: polygon(0 0, 100% 0, 100% 80%, 0 90%);
}
.hero:after {
content: "";
position: absolute;
left: 0;
bottom: -20%;
z-index: -1;
width: 100%;
height: 100%;
background-color: #4545a0;
clip-path: polygon(0 0, 100% 0, 100% 80%, 0 90%);
}
```
У нас есть псевдоэлемент с тем же размером и clip-path, что и у другого элемента. Разница в том, что он расположен под ним с `bottom:-20%` и `z-index:-1`. Я написал значение `20%`, потому что это то же, что 100 − 80.
### Появление при прокрутке
Используя API [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API), мы можем проявлять определённые элементы на странице во время прокрутки.
### *Значение* *`inset`*
Самое полезное значение clip-path для этого эффекта – inset. Почему? Посмотрите на рисунок ниже.
Обратите внимание, что синий прямоугольник может стать полностью невидимым, если написать `inset(50%)`. Да, значение, которое сделает элемент невидимым, составляет 50%: мы применяем inset с четырёх сторон. Другими словами, `inset` применяется от края к центру прямоугольника. На рисунке ниже inset используется для показа изображений во время прокрутки:
Приведённый ниже код javascript добавляет класс `is-visible` к каждому изображению, которое находится в области просмотра. При этом мы можем увидеть изображение с помощью прокрутки.
```
const images = document.querySelectorAll("img");
function check(entries) {
entries.map((entry) => {
if (entry.isIntersecting) {
entry.target.classList.add("is-visible");
observer.unobserve(entry.target);
}
});
}
const observer = new IntersectionObserver(check);
images.forEach((image) => observer.observe(image));
```
```
img {
clip-path: inset(50%);
transition: 1.2s ease-in;
}
img.is-visible {
clip-path: inset(0);
}
```
Всё просто. Мы создали простой эффект прокрутки с помощью нескольких строк CSS и JavaScript.
Кроме того, возможно контролировать **направление перехода появления**. Для этого нам нужно использовать одно из четырёх значений. Например, если нам нужен переход сверху вниз, нижнее значение должно быть изменено со 100% на 0. Посмотрите на картинку с объяснением:
А вот интерактивная демонстрация:
### Эффекты наведения и анимации
`clip-path` – это безграничные возможности, чтобы создавать анимации. Вот ещё один пример:
Что нам нужно сделать – это добавить эффект наведения, который масштабируется из уже указанной позиции. Здесь давайте выберем значение `circle()`.
Чтобы код поддерживался и читался проще, давайте воспользуемся переменными CSS. Так нам не нужно дублировать весь `clip-path`. Изменим только необходимые переменные CSS.
```
:root {
--pos: left center;
--size: 0;
}
.stats__item:before {
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background-color: #7777e9;
clip-path: circle(var(--size) at var(--pos));
transition: 0.4s linear;
}
.stats__item:hover:before {
--size: 300px;
}
```
Посмотрите ниже как это работает.
Мало того, мы можем очень легко изменить положение анимации. Я создал интерактивную демонстрацию, где можно изменять позиции в выпадающем меню.
Если вам захотелось углубиться в эффекты анимации, мистер Адам Аргайл написал крайне полезную библиотеку анимации CSS, которая абсолютно полностью полагается на `clip-path`. [Вот она](http://transition.style/).
### Эффект пульсации
Эффект ряби обрёл популярность с релиза Material Design. С помощью `clip-path` этот эффект легко воспроизводится, вот так:
```
Sign up now
```
```
.button {
position: relative;
}
.button span {
position: relative;
z-index: 1;
}
.button:before {
content: "";
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background-color: #fff;
opacity: 0.1;
clip-path: circle(0 at center);
transition: 0.3s ease-out;
}
.button:hover:before {
clip-path: circle(100px at center);
}
```
Полезно знать
-------------
**Невидимые области не получают события указателя.**
Когда область обрезана, всё, что находится за её пределами, не получает никаких событий указателя. Это означает, что пользователь не сможет навести курсор на обрезанную часть.
**Можно пользоваться относительными значениями.**
Хочется привязать позицию `clip-path` к `font-size`? Это можно сделать! Воспользуйтесь единицами em или `rem` для `clip-path` – и всё готово.
### Ресурсы и связанные статьи
* [CSS Shapes Module Level 1](https://drafts.csswg.org/css-shapes-1/#typedef-basic-shape)
* [Getting Started with CSS Shapes](https://www.html5rocks.com/en/tutorials/shapes/getting-started/)
* [CSS clip-path maker](https://bennettfeely.com/clippy/)
Я рад сообщить вам, что написал электронную книгу об отладке CSS. Если вам интересно, отправляйтесь на [debuggingcss.com](https://debuggingcss.com/), чтобы прочитать бесплатный фрагмент. Если вам нравится мой контент, то вы можете поддержать меня, [заплатив за мой кофе](https://www.buymeacoffee.com/EmbDfQoF6). Большое спасибо!
---
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=250121)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=250121)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=250121)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=250121)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=250121)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=250121)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=250121)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=250121)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=250121)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=250121)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=250121)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=250121)
---
**КУРСЫ**
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=250121)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=250121)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=250121)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=250121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=250121)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=250121)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=250121) | https://habr.com/ru/post/539064/ | null | ru | null |
# Создаем GAN с помощью PyTorch
### Реалистичные изображения из ничего?
Генеративно-состязательные сети (Generative Adversarial Networks — **GAN**), предложенные Goodfellow и др. в 2014 году, произвели революцию в области создания изображений в компьютерном зрении — никто не мог поверить, что эти потрясающие живые изображения на самом деле создаются машинами с нуля. И даже больше — люди раньше думали, что задача генерации невозможна, и были поражены мощью GAN, потому что традиционно в этой области просто не существует каких-либо эталонных данных, с которыми мы могли бы сравнить наши сгенерированные изображения.
В этой статье представлена простая идея, лежащая в основе создания GAN, за которой следует реализация сверточной GAN с помощью PyTorch и процедура ее обучения.
Идея, лежащая в основе GAN
--------------------------
В отличие от традиционной задачи классификации, где прогнозы нашей сети можно напрямую сравнить с правильным ответом из эталонных данных, «правильность» сгенерированного изображения трудно определить и измерить. Goodfellow и др. в своей оригинальной статье *Generative Adversarial Networks*,предложили интересную идею: использовать хорошо обученный классификатор, чтобы различать сгенерированное изображение и реальное изображение. Если у нас есть такой классификатор, мы можем создать и обучить сеть-генератор, пока она не сможет производить изображения, которые могут полностью обмануть классификатор.
Рисунок 1. Конвейер GAN. Изображение создано автором.GAN является продуктом этой процедуры: она содержит генератор, который генерирует изображение на основе заданного набора данных, и дискриминатор (классификатор), чтобы различать, является ли изображение реальным или сгенерированным. Разбор конвейера GAN можно увидеть на рисунке 1.
### Функция потерь
Оптимизировать одновременно и генератор, и дискриминатор сложно, потому что, как вы могли догадаться, две сети преследуют совершенно противоположные цели: генератор хочет создать что-то как можно более реалистичное, а дискриминатор хочет различать сгенерированные материалы.
Чтобы проиллюстрировать это, пусть *D(x)* будет выходом дискриминатора, который представляет собой вероятность того, что *x* является реальным изображением, а *G(z)* будет выходом нашего генератора. Дискриминатор аналогичен бинарному классификатору, поэтому цель дискриминатора — максимизировать функцию:
По сути, это бинарная перекрестная потеря энтропии без отрицательного знака в начале. С другой стороны, целью генератора было бы минимизировать шансы дискриминатора сделать правильное определение, поэтому его целью было бы минимизировать функцию. Следовательно, окончательная функция потерь будет минимаксной игрой между двумя классификаторами, которую можно проиллюстрировать следующим образом:
которая теоретически сходится к дискриминатору, предсказывающему все с вероятностью 0,5.
Однако на практике минимаксная игра часто приводит к тому, что сеть не сходится, поэтому важно тщательно настроить процесс обучения. Гиперпараметры, такие как скорость обучения, значительно более важны при обучении GAN — небольшие изменения могут привести к тому, что GAN будет генерировать один и тот же выходной сигнал независимо от входных шумов.
Вычислительное окружение
------------------------
### Библиотеки
Вся программа построена с помощью библиотеки PyTorch (включая torchvision). Визуализация результатов, сгенерированных GAN, строится с использованием библиотеки Matplotlib. Следующий код импортирует все библиотеки:
```
"""
Импортируем необходимые библиотеки для создания генеративно-состязательной сети
Код разработан в основном с использованием библиотеки PyTorch
"""
import time
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import transforms
from model import discriminator, generator
import numpy as np
import matplotlib.pyplot as plt
```
### Наборы данных
Наборы данных являются важным аспектом при обучении GAN. Неструктурированная природа изображений подразумевает, что любой данный класс (например, собаки, кошки или рукописные цифры) может иметь распределение возможных данных, и такое распределение в конечном итоге является основой контента, генерируемого GAN.
Для демонстрации GAN в этой статье будет использоваться простейший [набор данных MNIST](https://gas.graviti.com/dataset/hellodataset/MNIST?utm_medium=0708Taying_2), который содержит 60000 изображений рукописных цифр от 0 до 9. Неструктурированные наборы данных, такие как MNIST, можно найти на [Graviti](https://graviti.com/?utm_medium=0708Taying_2). Это достаточно молодой стартап, который стремится помочь сообществу с неструктурированными наборами данных, и на их [платформе](https://gas.graviti.com/open-datasets/?utm_medium=0708Taying_2) уже можно найти одни из лучших общедоступных неструктурированных наборов данных, включая MNIST.
### Требования к оборудованию
Обучать нейронную сеть предпочтительнее на графических процессорах, так как они значительно увеличивают скорость обучения. Однако, даже если доступны только обычные процессоры, вы все равно можете протестировать программу. Чтобы позволить вашей программе самой определить оборудование, просто используйте следующее:
```
"""
Определяем, доступны ли какие-либо графические процессоры
"""
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
```
Реализация
----------
### Архитектура сети
Из-за простоты чисел две архитектуры — дискриминатор и генератор — построены из полностью связанных слоев. Обратите внимание, что полностью связанная GAN также иногда легче сходится, чем DCGAN.
Ниже приведены реализации PyTorch обеих архитектур:
```
"""
Сетевые архитектуры
Ниже приведены архитектуры дискриминатора и генератора
"""
class discriminator(nn.Module):
def __init__(self):
super(discriminator, self).__init__()
self.fc1 = nn.Linear(784, 512)
self.fc2 = nn.Linear(512, 1)
self.activation = nn.LeakyReLU(0.1)
def forward(self, x):
x = x.view(-1, 784)
x = self.activation(self.fc1(x))
x = self.fc2(x)
return nn.Sigmoid()(x)
class generator(nn.Module):
def __init__(self):
super(generator, self).__init__()
self.fc1 = nn.Linear(128, 1024)
self.fc2 = nn.Linear(1024, 2048)
self.fc3 = nn.Linear(2048, 784)
self.activation = nn.ReLU()
def forward(self, x):
x = self.activation(self.fc1(x))
x = self.activation(self.fc2(x))
x = self.fc3(x)
x = x.view(-1, 1, 28, 28)
return nn.Tanh()(x)
```
### Обучение
При обучении GAN мы оптимизируем результаты дискриминатора и, в то же время, улучшаем наш генератор. Следовательно, будут две потери, которые противоречат друг другу во время каждой итерации их одновременной оптимизации. То, что мы вводим в генератор, — это случайные шумы, а генератор предположительно должен создавать изображения на основе незначительных различий данных шумов:
```
"""
Процедура обучения сети.
Каждый шаг потери обновляется как для дискиминатора, так и для генератора.
Дискриминатор стремится классифицировать реальные и fakes
Генератор стремится генерировать как можно более реалистичные изображения
"""
for epoch in range(epochs):
for idx, (imgs, _) in enumerate(train_loader):
idx += 1
# Обучаем дискриминатор
# real_inputs - изображения из набора данных MNIST
# fake_inputs - изображения от генератора
# real_inputs должны быть классифицированы как 1, а fake_inputs - как 0
real_inputs = imgs.to(device)
real_outputs = D(real_inputs)
real_label = torch.ones(real_inputs.shape[0], 1).to(device)
noise = (torch.rand(real_inputs.shape[0], 128) - 0.5) / 0.5
noise = noise.to(device)
fake_inputs = G(noise)
fake_outputs = D(fake_inputs)
fake_label = torch.zeros(fake_inputs.shape[0], 1).to(device)
outputs = torch.cat((real_outputs, fake_outputs), 0)
targets = torch.cat((real_label, fake_label), 0)
D_loss = loss(outputs, targets)
D_optimizer.zero_grad()
D_loss.backward()
D_optimizer.step()
# Обучаем генератор
# Цель генератора получить от дискриминатора 1 по всем изображениям
noise = (torch.rand(real_inputs.shape[0], 128)-0.5)/0.5
noise = noise.to(device)
fake_inputs = G(noise)
fake_outputs = D(fake_inputs)
fake_targets = torch.ones([fake_inputs.shape[0], 1]).to(device)
G_loss = loss(fake_outputs, fake_targets)
G_optimizer.zero_grad()
G_loss.backward()
G_optimizer.step()
if idx % 100 == 0 or idx == len(train_loader):
print('Epoch {} Iteration {}: discriminator_loss {:.3f} generator_loss {:.3f}'.format(epoch, idx, D_loss.item(), G_loss.item()))
if (epoch+1) % 10 == 0:
torch.save(G, 'Generator_epoch_{}.pth'.format(epoch))
print('Model saved.')
```
Результаты
----------
После 100 эпох мы можем построить наборы данных и увидеть результаты — цифры сгенерированные из случайных шумов:
Рисунок 2. Результаты, генерируемые GAN. Изображение создано автором.Как вы можете увидеть выше, полученные результаты действительно похожи на настоящие. Учитывая, что сети довольно просты, результаты действительно кажутся многообещающими!
Помимо создания контента
------------------------
GAN сильно отличалось от предыдущих работ в области компьютерного зрения. Последовавшие за этим многочисленные применения удивили академическое сообщество тем, на что способны глубокие сети. Некоторые удивительные работы описаны ниже.
### CycleGAN
CycleGAN, автор Zhu и др. вводит концепцию, которая переводит изображение из домена *X* в домен *Y* без необходимости парных выборок. Результаты CycleGAN были удивительными и точными: лошади превратились в зебр, а летнее солнце превратилось в снежную бурю.
Рисунок 3. Результаты CycleGAN, представленные Zhu и др. Изображение получено с их страницы на Github.### GauGAN
Nvidia применила GAN для преобразования примитивных рисунков в элегантные и реалистичные фотографии на основе семантики кистей. Хотя обучающие ресурсы были дорогостоящими в вычислительном отношении, они создают совершенно новую область исследований и применений.
Рисунок 3. Результаты сгенерированные GaoGAN. Слева - исходный рисунок, справа - сгенерированный результат. Изображение создано автором.### AdvGAN
Также существует расширение генеративно-состязательных сетей, которое очищает состязательные изображения и преобразовывает их в чистые примеры, которые не обманывают классификации. Более подробную информацию о состязательных атаках и защите можно найти [здесь](https://towardsdatascience.com/adversarial-attack-and-defense-on-neural-networks-in-pytorch-82b5bcd9171).
Заключение
----------
На этом все! Надеюсь, в этой статье представлен вполне достаточный обзор для понимания того, как самостоятельно построить GAN. Полную реализацию можно найти в этом Github репозитории: <https://github.com/ttchengab/MnistGAN>
---
> Материал подготовлен в рамках курса ["Компьютерное зрение"](https://otus.pw/mOdL/). Если вам интересно узнать больше о формате обучения и программе, познакомиться с преподавателем — приглашаем на день открытых дверей онлайн. Регистрация [**здесь**](https://otus.pw/McSx/).
>
> | https://habr.com/ru/post/569858/ | null | ru | null |
# Облачный гейминг в браузере
В облако сегодня перебирается всё больше категорий приложений, в том числе игры. У VK Play Cloud уже есть свои нативные приложения под Windows, Mac, Android и Android TV, которые позволяют играть в облаке в современные требовательные игры даже на слабых компьютерах. А теперь мы добавили ещё и веб-клиент — запускать можно прямо в браузере.
Меня зовут Александр, я работаю в команде клиентской разработки для игры в облаке — VK Play Cloud. Заваривайте чай, запасайтесь печеньками, и расскажу, как сделать облачный гейминг в браузере. Предупреждаю сразу, статья срубает технические верхушки ёлок и рассказывает «как это было», поехали.
### Как работает наше облако
Для игры в облаке необходима клиентская часть, которая:
* подключается к менеджер-серверу;
* получает и воспроизводит видео- и аудиопотоки с сервера;
* считывает данные с устройств ввода пользователя для передачи на сервер;
* с помощью различных алгоритмов отправляет, обрабатывает и восстанавливает данные;
* взаимодействует с пользователем с помощью графического интерфейса.
А вся нагрузка ложится на серверную часть, которая:
* кодирует аудио- и видеоданные с помощью кодеков;
* подготавливает данные с помощью различных алгоритмов для отправки клиентской части;
* принимает и обрабатывает данные с устройств ввода.
### Первый блин комом или первый прототип
Для нашей команды это было в новинку, поэтому первым делом решили запустить только поток видео. Провести ряд тестов, в том числе на пропускную способность и устойчивость к потерям, и сделать выводы. За основу взяли *WebRTC* технологию. Набросали план действий/задач на клиент и сервер.
#### Клиент
Для клиентской части на вебе выбрали связку *react*’*а* + *typescript*. Так как нативные клиенты написаны с использованием *С99* и *С++14*, то появилась идея по-максимуму перенести код в веб-приложение. Проанализировав кодовую базу, мы выделили модули, которые возможно перенести — (аудио/видео/устройства ввода), а какие придется переписать на *typescipt* — (подключения к менеджеру и серверу).
Подключение к менеджеру реализовали с помощью *websocket’ов* и *protobuf*. А вот подключение к серверу, уже через *WebRTC* с помощью пирингового подключения и дата каналов. Теперь начальное подключение было готово, можно было приступать дальше — компиляция *С/C++* в *WebAssembly* и оценка производительности.
Первым на очереди был модуль для работы с видео. Чтобы собрать модуль взяли инструмент *Emscripten* — он позволяет скомпилировать наш C/C++ код в модуль *WebAssembly*, который в дальнейшем может быть запущен в веб-браузере. Подготовили необходимые классы для *Embind* — в заголовочные файлы C++ было добавлено описания класса/enum’ов/структур для вызова из *JavaScript*.
Что-то похожее на это
```
#ifdef BUILD_EMSCRIPTEN
#include
#include
EMSCRIPTEN\_BINDINGS(em\_video\_class) {
emscripten::class\_("video\_class")
.function("process\_packet", emscripten::optional\_override(
[](video\_class& self, uintptr\_t addr, uint32\_t size, long long microseconds)
{
auto ptr = reinterpret\_cast(addr);
auto us = std::chrono::microseconds(microseconds);
self.video\_class::process\_packet(ptr, size, us);
}))
.function("status", &video\_class::status)
.function("frame\_size", &video\_class::frame\_size)
.function("frame\_data", emscripten::optional\_override(
[](video\_class& self, uint32\_t id, uintptr\_t addr, size\_t size)
{
auto ptr = reinterpret\_cast(addr);
self.video\_class::frame\_data(id, ptr, size);
}))
}
#endif
```
В конечном итоге *Emscripten* успешно интегрировался в наш *Cmake* и на выходе выдавал video\_module.js. Загрузили модуль видео в отдельном потоке — *Web Worker'е* (привет многопоточность из мира *C++*). Полученные данные с помощью дата канала отдавали в модуль, и на выходе получали кадр.
Но радоваться было рано, у нас потихоньку утекала память при вызове *C++* метода из *JavaScript*, как оказалось при создании *std::vector’а*...
#### Сервер
Со стороны сервера взяли библиотеку *WebRTC* на *С++*, скомпилировали, подключили и реализовали все необходимые интерфейсы. Это тоже была боль и о подключении *WebRTC* *С++* библиотеки со стороны сервера есть множество интересных статей на [хабре [webrtc server]](https://habr.com/ru/search/?target_type=posts&order=relevance&q=%5Bwebrtc%20server%5D).
Реализованные интерфейсы
```
rtc::MessageHandler
webrtc::PeerConnectionObserver
webrtc::DataChannelObserver
webrtc::CreateSessionDescriptionObserver
webrtc::SetSessionDescriptionObserver
webrtc::VideoTrackSource
webrtc::FakeAudioDeviceModule
webrtc::Notifier
```
Ещё одна трудность была в том, что клиент и сервер не общаются напрямую, потому что серверная часть защищена сетевым экраном (*firewall*), а клиентская находится за какими-нибудь маршрутизаторами. И для пирингового подключения необходим посредник — STUN-сервер. С его реализацией пришлось разбираться и даже подключать админов. После всех разбирательств видео поток наконец-то заработал.
Так как у нас было мало опыта работы с *WebRTC*, мы выбрали неверный путь — передачу видео/аудио данных по data-каналам (*SCTP* протокол). В итоге пропускная способность нашего видеопотока не превышала 8-10 Мбит/сек, буферизовалась и мы получали почти все прелести *TCP* протокола. Нас это категорически не устраивало, и тогда мы решили перевести data-канал на протокол *RTP*. Но к тому времени его поддержку из *WebRTC* уже убрали.
### Работа над ошибками
Data-каналы работают по протоколу *SCTP*, предлагающему встроенное управление потока передачи данных с контролем перегрузки. А в своих нативных клиентах мы брали обычный протокол *UDP* и накручивали туда свои разработки.Технология *WebRTC* содержит в себе возможность передачи видео/аудио через медиапотоки.
Пришлось выбросить почти всё, что мы компилировали с помощью *Emscripten* в *WebAssembly* — алгоритмы восстановления данных и регулировки битрейта, шифрование — остался только модуль конвертации курсора (он необходим для отрисовки курсора на клиенте), потому что браузеры не дают возможность работы с сырыми данными из медиапотоков. Data-потоки нам это позволяли: мы брали из них сырые данные и отправляли в свой скомпилированный код, который потом работал как в нативных приложениях. Также мы полностью убрали *Web Worker'ы*. *WebRTC* для инициализации видео, протоколов и различных алгоритмов использует *SDP*-диаграммы (протокол описания сеанса связи), поэтому нам пришлось ещё и с ними поработать: задать кодек *H.264*, профиль *HIGH*, стартовый/минимальный и максимальный битрейт, и оптимальные настройки встроенных алгоритмов восстановления данных.
В результате сервер кодирует картинку и с помощью медиапотока отправляет на клиент. Клиент принимает поток и внутри браузера его декодирует и показывает. Результаты прогона тестов нас устроили. Конечно не производительность, как на нативных приложениях, но пропускной способности видео оказалось достаточно для комфортной игры. Теперь уже можно было дописать всё необходимое для работы со звуком и устройствами ввода.
Общий список задач, которые мы решили при создании игры в облаке через браузер:
С клиентской стороны:
* подключение и взаимодействие с менеджером-сервером;
* отрисовка курсора;
* снятие нажатий с устройств ввода пользователя — клавиатуры, мыши, джойстика;
* работа в полноэкранного режиме браузера (ох уж эти браузеры с F11);
* виртуальная клавиатура;
* различные информационные сообщения и ошибки;
* работа с буфером обмена;
* локализация;
* использование микрофона;
* логирование;
* сбор статистики.
С серверной стороны:
* собрали и подключили библиотеку *WebRTC*;
* отрефакторили код для использования интерфейсов *WebRTC*;
* реализовали все необходимые интерфейсы библиотеки *WebRTC*.
### Что получилось
Теперь у нас видео- и аудиоданные передаются в медиапотоках, а информация от устройств ввода, буфер обмена и текстура курсора через data-каналы. Мы ещё не всё перенесли на *WebRTC* — это *Beta*, и да, мы всё ещё боремся с *Jitter Buffer*.
Список поддерживаемых платформ и браузеров на данный момент:
| | | | |
| --- | --- | --- | --- |
| | Windows | MacOS | Linux |
| Chrome | + | + | в разработке |
| Yandex | + | - | - |
| Opera | + | - | - |
| Edge | + | - | - |
| Safari | - | в разработке | - |
| Firefox | - | - | - |
А если вы поклонник нативных клиентов, то можете скачать наше приложение под [Windows](https://static.gc.vkplay.ru/VKPlayLoader.exe) / [MacOS](https://static.gc.vkplay.ru/gcmac/distrib/GameCenterShowcase.dmg) / [Android](https://play.google.com/store/apps/details?id=games.my.cloud) / [Android TV](https://play.google.com/store/apps/details?id=games.my.cloud.tv). Для тех у кого нету Google Play можно скачать apk напрямую [VK-Play-Cloud.apk](https://cdn.cloud.vkplay.ru/vkplay/Release/android-Phone/VK-play-cloud.apk?_ga=2.18080497.93275653.1673526651-333937233.1673526651) / [VK-Play-Cloud-TV.apk](https://cdn.cloud.vkplay.ru/vkplay/Release/android-TV/VK-play-cloud-TV.apk?_ga=2.18080497.93275653.1673526651-333937233.1673526651)
Помимо обширного каталога игр вы также можете запустить «Виртуальный компьютер» и делать всё, что захотите прямо в браузере [cloud.vkplay.ru](https://cloud.vkplay.ru/). Попробуйте облачный гейминг со скидкой 20% по промокоду **FOR\_WEBRTC\_HABR** (промокод действителен до 16.02.2023). | https://habr.com/ru/post/710760/ | null | ru | null |
# External Interrupts in the x86 system. Part 2. Linux kernel boot options
In the [last part](https://habr.com/ru/post/446312/) we discussed evolution of the interrupt delivery process from the devices in the x86 system (PIC → APIC → MSI), general theory, and all the necessary terminology.
In this practical part we will look at how to roll back to the use of obsolete methods of interrupt delivery in Linux, and in particular we will look at Linux kernel boot options:
* pci=nomsi
* noapic
* nolapic
Also we will look at the order in which the OS looks for interrupt routing tables (ACPI/MPtable/$PIR) and what the impact is from the following boot options:
* pci=noacpi
* acpi=noirq
* acpi=off
You've probably used some combination of these options when one of the devices in your system hasn't worked correctly because of an interrupt problem. We'll go through these options and find out what they do and how they change the kernel '/proc/interrupts' interface output.
### Boot without any extra options
In this article for our interrupt investigation we will be using custom board with the Intel Haswell i7 CPU with the LynxPoint-LP chipset which runs [coreboot](https://www.coreboot.org/).
We will be getting information about interrupts in the Linux system through the command:
```
cat /proc/interrupts
```
Here is the output when the kernel was booted without any external options:
```
CPU0 CPU1 CPU2 CPU3
0: 15 0 0 0 IO-APIC-edge timer
1: 0 1 0 1 IO-APIC-edge i8042
8: 0 0 0 1 IO-APIC-edge rtc0
9: 0 0 0 0 IO-APIC-fasteoi acpi
12: 0 0 0 1 IO-APIC-edge
23: 16 247 7 10 IO-APIC-fasteoi ehci_hcd:usb1
56: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
57: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
58: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
59: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
60: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
61: 0 0 0 0 PCI-MSI-edge aerdrv,PCIe PME
62: 3118 1984 972 3454 PCI-MSI-edge ahci
63: 1 0 0 0 PCI-MSI-edge eth59
64: 2095 57 4 832 PCI-MSI-edge eth59-rx-0
65: 6 18 1 1309 PCI-MSI-edge eth59-rx-1
66: 13 512 2 1 PCI-MSI-edge eth59-rx-2
67: 10 61 232 2 PCI-MSI-edge eth59-rx-3
68: 169 0 0 0 PCI-MSI-edge eth59-tx-0
69: 14 14 4 205 PCI-MSI-edge eth59-tx-1
70: 11 491 3 0 PCI-MSI-edge eth59-tx-2
71: 20 19 134 50 PCI-MSI-edge eth59-tx-3
72: 0 0 0 0 PCI-MSI-edge eth58
73: 2 1 0 152 PCI-MSI-edge eth58-rx-0
74: 3 150 2 0 PCI-MSI-edge eth58-rx-1
75: 2 34 117 2 PCI-MSI-edge eth58-rx-2
76: 153 0 2 0 PCI-MSI-edge eth58-rx-3
77: 4 0 2 149 PCI-MSI-edge eth58-tx-0
78: 4 149 2 0 PCI-MSI-edge eth58-tx-1
79: 4 0 117 34 PCI-MSI-edge eth58-tx-2
80: 153 0 2 0 PCI-MSI-edge eth58-tx-3
81: 66 106 2 101 PCI-MSI-edge snd_hda_intel
82: 928 5657 262 224 PCI-MSI-edge i915
83: 545 56 32 15 PCI-MSI-edge snd_hda_intel
NMI: 0 0 0 0 Non-maskable interrupts
LOC: 4193 3644 3326 3499 Local timer interrupts
SPU: 0 0 0 0 Spurious interrupts
PMI: 0 0 0 0 Performance monitoring interrupts
IWI: 290 233 590 111 IRQ work interrupts
RTR: 3 0 0 0 APIC ICR read retries
RES: 1339 2163 2404 1946 Rescheduling interrupts
CAL: 607 537 475 559 Function call interrupts
TLB: 163 202 164 251 TLB shootdowns
TRM: 48 48 48 48 Thermal event interrupts
THR: 0 0 0 0 Threshold APIC interrupts
MCE: 0 0 0 0 Machine check exceptions
MCP: 3 3 3 3 Machine check polls
ERR: 0
MIS: 0
```
File '/proc/interrupts' is the procfs Linux interface to the interrupt subsystem, and it presents a table about the number of interrupts on every CPU core in the system in the following form:
* First column: interrupt number
* CPUx columns: interrupt counters for every CPU core in the system
* Next column: interrupt type:
+ IO-APIC-edge — edge-triggered interrupt for the I/O APIC controller
+ IO-APIC-fasteoi — level-triggered interrupt for the I/O APIC controller
+ PCI-MSI-edge — MSI interrupt
+ XT-PIC-XT-PIC — interrupt for the PIC controller (we will see it later)
* Last column: device (driver) associated with this interrupt
Everything here is like it is supposed to be in the modern system. For the devices and drivers which support MSI/MSI-X, this is the type of interrupt that they use. The rest of the interrupt routing is done through the APIC controller.
Simplistically, the interrupt routing schematics can be drawn like this: (red lines are active routing paths and black lines are unused routing paths)
A device that supports MSI/MSI-X interrupts should have that particular capability listed in its [PCI configuration space](https://en.wikipedia.org/wiki/PCI_configuration_space).
As an example of that let's look at a little fragment of the lspci output for the devices that declare they use MSI/MSI-X. In our case it is a SATA controller (interrupt 'ahci'), two ethernet controllers (interrupts 'eth58\*' and 'eth59\*'), graphical controller ('i915'), and two HD Audio controllers ('snd\_hda\_intel').
```
lspci -v
```
```
00:02.0 VGA compatible controller: Intel Corporation Haswell-ULT Integrated Graphics Controller (rev 09) (prog-if 00 [VGA controller])
...
Capabilities: [90] MSI: Enable+ Count=1/1 Maskable- 64bit-
Capabilities: [d0] Power Management version 2
Capabilities: [a4] PCI Advanced Features
Kernel driver in use: i915
00:03.0 Audio device: Intel Corporation Haswell-ULT HD Audio Controller (rev 09
...
Capabilities: [60] MSI: Enable+ Count=1/1 Maskable- 64bit-
Capabilities: [70] Express Root Complex Integrated Endpoint, MSI 00
Kernel driver in use: snd_hda_intel
00:1b.0 Audio device: Intel Corporation 8 Series HD Audio Controller (rev 04)
...
Capabilities: [60] MSI: Enable+ Count=1/1 Maskable- 64bit+
Capabilities: [70] Express Root Complex Integrated Endpoint, MSI 00
Capabilities: [100] Virtual Channel
Kernel driver in use: snd_hda_intel
00:1f.2 SATA controller: Intel Corporation 8 Series SATA Controller 1 [AHCI mode] (rev 04) (prog-if 01 [AHCI 1.0])
...
Capabilities: [80] MSI: Enable+ Count=1/1 Maskable- 64bit-
Capabilities: [70] Power Management version 3
Capabilities: [a8] SATA HBA v1.0
Kernel driver in use: ahci
05:00.0 Ethernet controller: Intel Corporation I350 Gigabit Network Connection (rev 01)
...
Capabilities: [50] MSI: Enable- Count=1/1 Maskable+ 64bit+
Capabilities: [70] MSI-X: Enable+ Count=10 Masked-
Capabilities: [a0] Express Endpoint, MSI 00
Kernel driver in use: igb
05:00.1 Ethernet controller: Intel Corporation I350 Gigabit Network Connection (rev 01)
...
Capabilities: [50] MSI: Enable- Count=1/1 Maskable+ 64bit+
Capabilities: [70] MSI-X: Enable+ Count=10 Masked-
Capabilities: [a0] Express Endpoint, MSI 00
Kernel driver in use: igb
```
As we see, all of these devices either have a string «MSI: Enable+» or «MSI-X: Enable+».
Let's downgrade our system! For a start let's boot with the kernel option 'pci=nomsi'.
### pci=nomsi
Because of this option MSI interrupts become IO-APIC/XT-PIC depending on the interrupt controller in use.
In this case the priority choice is still modern APIC controller, so the interrupt picture will be:
Output of /proc/interrupts:
```
CPU0 CPU1 CPU2 CPU3
0: 15 0 0 0 IO-APIC-edge timer
1: 0 1 0 1 IO-APIC-edge i8042
8: 0 0 1 0 IO-APIC-edge rtc0
9: 0 0 0 0 IO-APIC-fasteoi acpi
12: 0 0 0 1 IO-APIC-edge
16: 1314 5625 342 555 IO-APIC-fasteoi i915, snd_hda_intel, eth59
17: 5 0 1 34 IO-APIC-fasteoi eth58
21: 2882 2558 963 2088 IO-APIC-fasteoi ahci
22: 26 81 2 170 IO-APIC-fasteoi snd_hda_intel
23: 23 369 8 8 IO-APIC-fasteoi ehci_hcd:usb1
NMI: 0 0 0 0 Non-maskable interrupts
LOC: 3011 3331 2435 2617 Local timer interrupts
SPU: 0 0 0 0 Spurious interrupts
PMI: 0 0 0 0 Performance monitoring interrupts
IWI: 197 228 544 85 IRQ work interrupts
RTR: 3 0 0 0 APIC ICR read retries
RES: 1708 2349 1821 1569 Rescheduling interrupts
CAL: 520 554 509 555 Function call interrupts
TLB: 187 181 205 179 TLB shootdowns
TRM: 102 102 102 102 Thermal event interrupts
THR: 0 0 0 0 Threshold APIC interrupts
MCE: 0 0 0 0 Machine check exceptions
MCP: 2 2 2 2 Machine check polls
ERR: 0
MIS: 0
```
As expected, all MSI/MSI-X interrupts have disappeared. Instead of them devices now use interrupts of 'IO-APIC-fasteoi' type.
Let us draw our attention to the fact that earlier, before enabling this kernel boot option, each of the 'eth58' and 'eth59' had nine interrupts! But now each of them has only one interrupt. Recall that without the MSI, one function in the PCI device can have only one interrupt!
Here is a little info from the 'dmesg' command about the ethernet controllers' initialization:
— boot without the 'pci=nomsi' option:
```
igb: Intel(R) Gigabit Ethernet Network Driver - version 5.0.5-k
igb: Copyright (c) 2007-2013 Intel Corporation.
acpi:acpi_pci_irq_enable: igb 0000:05:00.0: PCI INT A -> GSI 16 (level, low) -> IRQ 16
igb 0000:05:00.0: irq 63 for MSI/MSI-X
igb 0000:05:00.0: irq 64 for MSI/MSI-X
igb 0000:05:00.0: irq 65 for MSI/MSI-X
igb 0000:05:00.0: irq 66 for MSI/MSI-X
igb 0000:05:00.0: irq 67 for MSI/MSI-X
igb 0000:05:00.0: irq 68 for MSI/MSI-X
igb 0000:05:00.0: irq 69 for MSI/MSI-X
igb 0000:05:00.0: irq 70 for MSI/MSI-X
igb 0000:05:00.0: irq 71 for MSI/MSI-X
igb 0000:05:00.0: irq 63 for MSI/MSI-X
igb 0000:05:00.0: irq 64 for MSI/MSI-X
igb 0000:05:00.0: irq 65 for MSI/MSI-X
igb 0000:05:00.0: irq 66 for MSI/MSI-X
igb 0000:05:00.0: irq 67 for MSI/MSI-X
igb 0000:05:00.0: irq 68 for MSI/MSI-X
igb 0000:05:00.0: irq 69 for MSI/MSI-X
igb 0000:05:00.0: irq 70 for MSI/MSI-X
igb 0000:05:00.0: irq 71 for MSI/MSI-X
igb 0000:05:00.0: added PHC on eth0
igb 0000:05:00.0: Intel(R) Gigabit Ethernet Network Connection
igb 0000:05:00.0: eth0: (PCIe:5.0Gb/s:Width x1) 00:15:d5:03:00:2a
igb 0000:05:00.0: eth0: PBA No: 106300-000
igb 0000:05:00.0: Using MSI-X interrupts. 4 rx queue(s), 4 tx queue(s)
acpi:acpi_pci_irq_enable: igb 0000:05:00.1: PCI INT B -> GSI 17 (level, low) -> IRQ 17
igb 0000:05:00.1: irq 72 for MSI/MSI-X
igb 0000:05:00.1: irq 73 for MSI/MSI-X
igb 0000:05:00.1: irq 74 for MSI/MSI-X
igb 0000:05:00.1: irq 75 for MSI/MSI-X
igb 0000:05:00.1: irq 76 for MSI/MSI-X
igb 0000:05:00.1: irq 77 for MSI/MSI-X
igb 0000:05:00.1: irq 78 for MSI/MSI-X
igb 0000:05:00.1: irq 79 for MSI/MSI-X
igb 0000:05:00.1: irq 80 for MSI/MSI-X
igb 0000:05:00.1: irq 72 for MSI/MSI-X
igb 0000:05:00.1: irq 73 for MSI/MSI-X
igb 0000:05:00.1: irq 74 for MSI/MSI-X
igb 0000:05:00.1: irq 75 for MSI/MSI-X
igb 0000:05:00.1: irq 76 for MSI/MSI-X
igb 0000:05:00.1: irq 77 for MSI/MSI-X
igb 0000:05:00.1: irq 78 for MSI/MSI-X
igb 0000:05:00.1: irq 79 for MSI/MSI-X
igb 0000:05:00.1: irq 80 for MSI/MSI-X
igb 0000:05:00.1: added PHC on eth1
igb 0000:05:00.1: Intel(R) Gigabit Ethernet Network Connection
igb 0000:05:00.1: eth1: (PCIe:5.0Gb/s:Width x1) 00:15:d5:03:00:2b
igb 0000:05:00.1: eth1: PBA No: 106300-000
igb 0000:05:00.1: Using MSI-X interrupts. 4 rx queue(s), 4 tx queue(s)
```
— boot with the 'pci=nomsi' option:
```
igb: Intel(R) Gigabit Ethernet Network Driver - version 5.0.5-k
igb: Copyright (c) 2007-2013 Intel Corporation.
acpi:acpi_pci_irq_enable: igb 0000:05:00.0: PCI INT A -> GSI 16 (level, low) -> IRQ 16
igb 0000:05:00.0: added PHC on eth0
igb 0000:05:00.0: Intel(R) Gigabit Ethernet Network Connection
igb 0000:05:00.0: eth0: (PCIe:5.0Gb/s:Width x1) 00:15:d5:03:00:2a
igb 0000:05:00.0: eth0: PBA No: 106300-000
igb 0000:05:00.0: Using legacy interrupts. 1 rx queue(s), 1 tx queue(s)
acpi:acpi_pci_irq_enable: igb 0000:05:00.1: PCI INT B -> GSI 17 (level, low) -> IRQ 17
igb 0000:05:00.1: added PHC on eth1
igb 0000:05:00.1: Intel(R) Gigabit Ethernet Network Connection
igb 0000:05:00.1: eth1: (PCIe:5.0Gb/s:Width x1) 00:15:d5:03:00:2b
igb 0000:05:00.1: eth1: PBA No: 106300-000
igb 0000:05:00.1: Using legacy interrupts. 1 rx queue(s), 1 tx queue(s)
```
Because of the decreased number of interrupts per device, enabling this option can lead to a significant performance limitation of the device driver, and that is not even counting that according to the Intel research ['Reducing Interrupt Latency Through the Use of Message Signaled Interrupts'](https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/msg-signaled-interrupts-paper.pdf), MSI interrupts 3 times faster than the IO-APIC interrupts and 5 times faster than the PIC interrupts.
### noapic
This option disables I/O APIC. MSI interrupts can still find their way to all of the CPUs, but the rest of interrupts from the devices can go only to CPU0, because PIC is only connected to CPU0. However, LAPIC is working and all other CPUs can still work and handle interrupts.
```
CPU0 CPU1 CPU2 CPU3
0: 5 0 0 0 XT-PIC-XT-PIC timer
1: 2 0 0 0 XT-PIC-XT-PIC i8042
2: 0 0 0 0 XT-PIC-XT-PIC cascade
8: 1 0 0 0 XT-PIC-XT-PIC rtc0
9: 0 0 0 0 XT-PIC-XT-PIC acpi
12: 172 0 0 0 XT-PIC-XT-PIC ehci_hcd:usb1
56: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
57: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
58: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
59: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
60: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
61: 0 0 0 0 PCI-MSI-edge aerdrv, PCIe PME
62: 2833 2989 1021 811 PCI-MSI-edge ahci
63: 0 1 0 0 PCI-MSI-edge eth59
64: 301 52 9 3 PCI-MSI-edge eth59-rx-0
65: 12 24 3 178 PCI-MSI-edge eth59-rx-1
66: 14 85 6 2 PCI-MSI-edge eth59-rx-2
67: 17 24 307 1 PCI-MSI-edge eth59-rx-3
68: 70 18 8 10 PCI-MSI-edge eth59-tx-0
69: 7 0 0 23 PCI-MSI-edge eth59-tx-1
70: 15 227 2 2 PCI-MSI-edge eth59-tx-2
71: 18 6 27 2 PCI-MSI-edge eth59-tx-3
72: 0 0 0 0 PCI-MSI-edge eth58
73: 1 0 0 27 PCI-MSI-edge eth58-rx-0
74: 1 22 0 5 PCI-MSI-edge eth58-rx-1
75: 1 0 22 5 PCI-MSI-edge eth58-rx-2
76: 23 0 0 5 PCI-MSI-edge eth58-rx-3
77: 1 0 0 27 PCI-MSI-edge eth58-tx-0
78: 1 22 0 5 PCI-MSI-edge eth58-tx-1
79: 1 0 22 5 PCI-MSI-edge eth58-tx-2
80: 23 0 0 5 PCI-MSI-edge eth58-tx-3
81: 187 17 70 7 PCI-MSI-edge snd_hda_intel
82: 698 1647 247 129 PCI-MSI-edge i915
83: 438 135 16 59 PCI-MSI-edge snd_hda_intel
NMI: 0 0 0 0 Non-maskable interrupts
LOC: 1975 2499 2245 1474 Local timer interrupts
SPU: 0 0 0 0 Spurious interrupts
PMI: 0 0 0 0 Performance monitoring interrupts
IWI: 132 67 429 91 IRQ work interrupts
RTR: 3 0 0 0 APIC ICR read retries
RES: 1697 2178 1903 1541 Rescheduling interrupts
CAL: 561 496 534 567 Function call interrupts
TLB: 229 254 170 137 TLB shootdowns
TRM: 78 78 78 78 Thermal event interrupts
THR: 0 0 0 0 Threshold APIC interrupts
MCE: 0 0 0 0 Machine check exceptions
MCP: 2 2 2 2 Machine check polls
ERR: 0
MIS: 0
```
As we see, all IO-APIC-\* interrupts have turned into XT-PIC-XT-PIC, and all of these interrupts have been routed to CPU0 only. MSI interrupts on the other hand have remained unchanged and go to all of the CPUs.
### nolapic
This kernel boot option disables LAPIC. MSI interrupts can't work without LAPIC, and I/O APIC can't work without LAPIC either. All of the device interrupts can only go to the PIC, and it works with the CPU0 only. And without LAPIC the rest of the CPUs besides CPU0 won't work.
Output of /proc/interrupts:
```
CPU0
0: 6416 XT-PIC-XT-PIC timer
1: 2 XT-PIC-XT-PIC i8042
2: 0 XT-PIC-XT-PIC cascade
3: 5067 XT-PIC-XT-PIC aerdrv, aerdrv, PCIe PME, PCIe PME, i915, snd_hda_intel, eth59
4: 32 XT-PIC-XT-PIC aerdrv, aerdrv, PCIe PME, PCIe PME, eth58
5: 0 XT-PIC-XT-PIC aerdrv, PCIe PME
6: 0 XT-PIC-XT-PIC aerdrv, PCIe PME
8: 1 XT-PIC-XT-PIC rtc0
9: 0 XT-PIC-XT-PIC acpi
11: 274 XT-PIC-XT-PIC snd_hda_intel
12: 202 XT-PIC-XT-PIC ehci_hcd:usb1
15: 7903 XT-PIC-XT-PIC ahci
NMI: 0 Non-maskable interrupts
LOC: 0 Local timer interrupts
SPU: 0 Spurious interrupts
PMI: 0 Performance monitoring interrupts
IWI: 0 IRQ work interrupts
RTR: 0 APIC ICR read retries
RES: 0 Rescheduling interrupts
CAL: 0 Function call interrupts
TLB: 0 TLB shootdowns
TRM: 0 Thermal event interrupts
THR: 0 Threshold APIC interrupts
MCE: 0 Machine check exceptions
MCP: 1 Machine check polls
ERR: 0
MIS: 0
```
### Combinations of options:
Actually there is only one combination for the new variant of routing: «noapic pci=nomsi». In this case all interrupts from the devices only go to the CPU0 through the PIC controller. But the LAPIC system is still working, so all the other CPUs can work and handle interrupts.
You cannot combine any other options with «nolapic» since it makes I/O APIC and MSI unaccessible. Therefore, if you've ever added Linux kernel boot options like «noapic nolapic» (or the most common case «acpi=off noapic nolapic») it seems like you've written some extra letters.
Finally, here is the result of the options «noapic pci=nomsi» to our interrupt routing picture:
And the output of /proc/interrupts is:
```
CPU0 CPU1 CPU2 CPU3
0: 5 0 0 0 XT-PIC-XT-PIC timer
1: 2 0 0 0 XT-PIC-XT-PIC i8042
2: 0 0 0 0 XT-PIC-XT-PIC cascade
3: 5072 0 0 0 XT-PIC-XT-PIC i915, snd_hda_intel, eth59
4: 32 0 0 0 XT-PIC-XT-PIC eth58
8: 1 0 0 0 XT-PIC-XT-PIC rtc0
9: 0 0 0 0 XT-PIC-XT-PIC acpi
11: 281 0 0 0 XT-PIC-XT-PIC snd_hda_intel
12: 200 0 0 0 XT-PIC-XT-PIC ehci_hcd:usb1
15: 7930 0 0 0 XT-PIC-XT-PIC ahci
NMI: 0 0 0 0 Non-maskable interrupts
LOC: 2595 2387 2129 1697 Local timer interrupts
SPU: 0 0 0 0 Spurious interrupts
PMI: 0 0 0 0 Performance monitoring interrupts
IWI: 159 90 482 135 IRQ work interrupts
RTR: 3 0 0 0 APIC ICR read retries
RES: 1568 1666 1810 1833 Rescheduling interrupts
CAL: 431 556 549 558 Function call interrupts
TLB: 124 184 156 274 TLB shootdowns
TRM: 116 116 116 116 Thermal event interrupts
THR: 0 0 0 0 Threshold APIC interrupts
MCE: 0 0 0 0 Machine check exceptions
MCP: 2 2 2 2 Machine check polls
ERR: 0
MIS: 0
```
### Interrupt routing tables and the options «acpi=noirq», «pci=noacpi», «acpi=off»
How does the operating system get information about the device interrupt routing? The BIOS prepares such info for the OS in the form of:
* ACPI tables (\_PIC/\_PRT functions)
* \_MP\_ table (MPtable)
* $PIR table
* Registers 0x3C/0x3D of the device's PCI configuration space
It is worth to note for the MSI interrupts declaration that the BIOS doesn't need to do anything extra (beside declaring the use of the LAPIC): all the aforementioned routing information is needed only for the APIC/PIC interrupt lines.
Tables in the list above are presented in the order of priority. Let's examine it in detail.
Let's assume the BIOS has presented all this data and we boot our OS without any extra boot options:
* OS finds ACPI tables.
* ОS executes ACPI function "\_PIC", passing it the argument stating that the boot should happen in APIC mode. Here there is function code that usually saves the chosen mode in a variable (for example, PICM=1).
* To access interrupt routing info the OS calls ACPI function "\_PRT". This checks the PICM variable and returns routing for the APIC mode case.
In the case when we boot with the option **noapic**:
* OS finds ACPI tables
* ОS executes ACPI function "\_PIC", passing it the argument stating that the boot should happen in PIC mode. Here there is function code that usually saves the chosen mode in a variable (for example, PICM=0)
* To access interrupt routing info the OS calls ACPI function "\_PRT". This checks the PICM variable and returns routing for the PIC mode case.
If ACPI tables aren't present or interrupt routing with ACPI is disabled through the option **acpi=noirq** or **pci=noacpi** (or ACPI subsystem is completely disabled with the **acpi=off** option), then the OS looks for the MPtable (\_MP\_) to get all the interrupt routing information:
* OS can't find/doesn't look at the ACPI tables
* OS finds MPtable (\_MP\_)
If ACPI tables aren't present or interrupt routing with ACPI is disabled through the option **acpi=noirq** or **pci=noacpi** (or ACPI subsystem is completely disabled with the **acpi=off** option), and if the MPtable (\_MP\_) is not present either (or there is a boot option **noapic** or **nolapic**):
* OS can't find/doesn't look at the ACPI tables
* OS can't find/doesn't look at the MPtable (\_MP\_)
* OS finds $PIR table
If there is no $PIR table or it is not full, then the OS will look at the registers 0x3C/0x3D of the device's PCI configuration space to guess interrupt routing.
Here is a picture summarizing all of this:
One should remember that not every BIOS provides all of these three tables (ACPI/MPtable/$PIR), so if you've passed an option to your bootloader (e.g. GRUB) that disables the use of ACPI or ACPI and MPtable for the interrupt routing, it is possible that your system won't boot.
**Note 1**: In the case when we try to boot in APIC mode with the option 'acpi=noirq' and without MPtable present, the picture of interrupts will be like in the case of normal booting with only the 'noapic' option. The operating system will go to PIC mode by itself. In the case when you try to boot without any ACPI tables at all ('acpi=off') and without MPtable present, then the picture will be like this:
```
CPU0
0: 6 XT-PIC-XT-PIC timer
1: 2 XT-PIC-XT-PIC i8042
2: 0 XT-PIC-XT-PIC cascade
8: 0 XT-PIC-XT-PIC rtc0
12: 373 XT-PIC-XT-PIC ehci_hcd:usb1
16: 0 PCI-MSI-edge PCIe PME
17: 0 PCI-MSI-edge PCIe PME
18: 0 PCI-MSI-edge PCIe PME
19: 0 PCI-MSI-edge PCIe PME
20: 0 PCI-MSI-edge PCIe PME
21: 0 PCI-MSI-edge PCIe PME
22: 8728 PCI-MSI-edge ahci
23: 1 PCI-MSI-edge eth59
24: 1301 PCI-MSI-edge eth59-rx-0
25: 113 PCI-MSI-edge eth59-tx-0
26: 0 PCI-MSI-edge eth58
27: 45 PCI-MSI-edge eth58-rx-0
28: 45 PCI-MSI-edge eth58-tx-0
29: 1280 PCI-MSI-edge snd_hda_intel
NMI: 2 Non-maskable interrupts
LOC: 24076 Local timer interrupts
SPU: 0 Spurious interrupts
PMI: 2 Performance monitoring interrupts
IWI: 2856 IRQ work interrupts
RTR: 0 APIC ICR read retries
RES: 0 Rescheduling interrupts
CAL: 0 Function call interrupts
TLB: 0 TLB shootdowns
TRM: 34 Thermal event interrupts
THR: 0 Threshold APIC interrupts
MCE: 0 Machine check exceptions
MCP: 2 Machine check polls
ERR: 0
MIS: 0
```
This happens because without the ACPI MADT table ([Multiple APIC Description Table](https://wiki.osdev.org/MADT)) and the necessary info from the MPtable, the operating system doesn't know APIC identifiers (APIC IDs) for the other CPUs and can't work with them. But the LAPIC of the main CPU0 works because we haven't disabled it, and MSI interrupts can still go to it. So the interrupt picture would be:
**Note 2**: In general, interrupt routing with the use of ACPI in an APIC case should match the interrupt routing with the MPtable. Also, the interrupt routing with the use of ACPI in a PIC case should match the interrupt routing with the $PIR table. Therefore the '/proc/interrupts' output should not differ. But in my investigation I've noticed one strange fact. For some reason in the case of interrupt routing through the MPtable there is a cascade interrupt «XT-PIC-XT-PIC cascade» in the output:
```
CPU0 CPU1 CPU2 CPU3
0: 15 0 0 0 IO-APIC-edge timer
1: 2 0 0 0 IO-APIC-edge i8042
2: 0 0 0 0 XT-PIC-XT-PIC cascade
8: 0 1 0 0 IO-APIC-edge rtc0
9: 0 0 0 0 IO-APIC-edge acpi
...
```
It is a little bit strange that it happens like that, but it seems like [the kernel source documentation](https://elixir.bootlin.com/linux/latest/source/Documentation/x86/i386/IO-APIC.txt) says that it is OK.
### Сonclusion
In conclusion we review for one more time the discussed options.
Interrupt controller choice options:
* **pci=nomsi** — MSI interrupts become IO-APIC/XT-PIC depending on the interrupt controller in use.
* **noapic** — Disables I/O APIC. MSI interrupts can still go to all the other CPUs, the rest of the device interrupts can only go to the PIC, and it works with the CPU0 only. But LAPIC still works and other CPUs can work and handle interrupts.
* **noapic pci=nomsi** — All of the device interrupts can only go to the PIC, and it works with the CPU0 only. But LAPIC works and other CPUs can work and handle interrupts.
* **nolapic** — Disables LAPIC. MSI interrupts can't work without LAPIC, and I/O APIC can't work without LAPIC. All of the device interrupts can only go to the PIC, and it works with the CPU0 only. And without LAPIC the rest of the CPUs besides CPU0 won't work.
Interrupt tables priority options:
* **no options** — routing through the APIC with the help of ACPI tables
* **noapic** — routing through the PIC with the help of ACPI tables
* **acpi=noirq** (**pci=noacpi**/**acpi=off**) — routing through the APIC with the help of MPtable
* **acpi=noirq** (**pci=noacpi**/**acpi=off**) **noapic** (**nolapic**) — routing through the PIC with the help of $PIR
In the next part we will look at how coreboot configures the chipset for the interrupt routing.
#### Acknowledgments
Special thanks to Jacob Garber from the coreboot community for helping me with this article translation | https://habr.com/ru/post/501660/ | null | en | null |
# Построение нейронных сетей в php используя FANN, пример реализации
Передо мной предстала задача анализа большого количества информации и выявления закономерностей. И первое, что пришло в голову — построить математическую модель с помощью [нейронной сети](http://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C).
Поскольку данные для анализа формируются в php и мне этот язык сейчас ближе всего, то искалась библиотека с интерфейсом для php. В связи с этим мне порекомендовали [FANN (Fast Artificial Neural Network)](http://leenissen.dk/) — открытое программное обеспечение для построения сетей. У этого решения есть апи для 15 языков, так что почти каждый сможет выбрать что-то для себя.
##### Пример. Распознавание языка текста на странице
Для примера возьмем задачу легкую, но недалекую от нашей реальности и от серьезных задач. Допустим есть 1000 документов, на 3-х разных языках. Пусть это будут французский, английский и польский. Наша задача научить нейронную сеть распознавать язык документа. Для этого мы используем самый простой частотный механизм. Но тем не менее его результаты неплохи. Его суть в том, что у каждого языка с разной частотой в тексте встречаются одни и те же символы. Мы подготавливаем 3 больших куска текста для каждого из языков (английский, французкий, польский), посчитаем для каждого символа частоты. Эти данные мы передадим в нейронную сеть, с указанием какой набор частот принадлежит каждому из языков. Дальше нейронная сеть все сделает сама.
###### Начнем с установки FANN
Пример, установки привожу для Ubuntu.
1) Нужно установить пакеты libfann1 и libfann1-dev
```
apt-get install libfann*
```
2) Добавить поддержку fann в php
У меня стоит Apache и установлен модуль php5-dev, поэтому я делаю так
```
# wget http://pecl.php.net/get/fann
# tar xvfz fann
# cd fann-0.1.1
# phpize
# ./configure
# make
```
Если при компиляции появиться ошибки и среди них будет вот такая
`fann.c:393: error: ‘zif_fannOO___set’ undeclared (first use in this function)`
то следует отредактировать файл php\_fann.h и за комментировать строчку 28 #define PHP\_FANN\_OO 1
После этого заново скомпилировать.
В итоге у нас генерируются модули которые нужно подключить к php
```
sudo cp -R ./modules/* /usr/lib/php5/20090626+lfs/
```
И в php.ini дописать
```
extension=fann.so
```
Перегрузили апач и проверили что все ок
```
php -m | grep fann
```
###### Решение задачи
Для этого нужно выполнить 2 шага:
1) Обучить сеть (первый листинг)
2) И использовать готовую модель для классификации (второй листинг)
Приведу пример для первого этапа и сразу укажу ссылку на [документацию](http://leenissen.dk/fann/fann.html)
Код я максимально снабдил комментариями, что бы было понятно что к чему и не разбирать его отдельно.
**Файл train.php**
```
php
/*
* Задаем параметры сети. 256 - это количество входов, оно должно равняться количеству ваших параметров,
* По хорошему в этом примере должно быть намного меньне, равно количесству букв в алфавитах.
* 128 - это количество нейронов в промежуточном слое. Здесь нуужно экспериментальным путем подбирать это число.
* 3 это количество выходящих сигналов. По скольку у нас 3 языка, то для каждого будет возвращена вероятность
* 1.0 - connection_rate - его лучше не менять
* 0.7 - learning_rate - описано здесь хорошо http://www.basegroup.ru/glossary/definitions/learning_rate/
* */
$ann = fann_create(array(256, 128, 3), 1.0, 0.7);
/*
* Первый параметр - указатель на нашу сеть, второй - обучающие данные.
* Мы загружаем 3 порции данных.Каждая порция состоит их входящих показателей и эталонных результирующих.
* В нем мы сообщаем, что при таких показателях, как мы сейчас передаем, нужно весь вес
* отдавать на первы нейрон (array(1, 0, 0) // Outputs). при загрузке других типов данный мы смещаем вес на другой нейрон
* generate_frequencies - просто расчитывает частоты.
*
* Последние 3 параметра это
* - максимальное кол-во итераций
* - максимальное кол-во ошибок
* - промежуток между выводами информации
*
* В файлах en.txt, fr.txt, pl.txt хранится текс размером где-то в 10000 символов для конкретного языка
* */
fann_train($ann,
array(
array(
generate_frequencies(file_get_contents("en.txt")), // Inputs
array(1, 0, 0) // Outputs
),
array(
generate_frequencies(file_get_contents("fr.txt")), // Inputs
array(0, 1, 0) // Outputs
),
array(
generate_frequencies(file_get_contents("pl.txt")), // Inputs
array(0, 0, 1) // Outputs
),
),
100000,
0.00001,
1000
);
/*
* Сохранить нашу модель в файл. в дальнейшем ее можно использовать для класификации
* */
fann_save($ann,"classify.txt");
/*
* Функция расчета частот
* */
function generate_frequencies($text){
// Удалим все кроме букв
$text = preg_replace("/[^\p{L}]/iu", "", strtolower($text));
// Найдем параметры для расчета частоты
$total = strlen($text);
$data = count_chars($text);
// Ну и сам расчет
array_walk($data, function (&$item, $key, $total){
$item = round($item/$total, 3);
}, $total);
return array_values($data);
}
?
```
В коде выше мы только сгенерили модель. А теперь проверим ее в деле, код ниже анализирует текст и выдает оценку принадлежности к тому или иному языку.
Файл run.php
```
php
/*
* Загружаем модель из файла. Эту модель мы создали на предыдущем шаге.
* */
$ann = fann_create("classify.txt");
/*
* Ниже я в нашу сеть передаю 3 текста на разных языках
* Смотрим результат
* */
$output = fann_run($ann, generate_frequencies("ANN are slowly adjusted so as to produce the same output as in
the examples. The hope is that when the ANN is shown a new
X-ray images containing healthy tissues"));
var_dump($output);
$output = fann_run($ann, generate_frequencies("Voyons, Monsieur, absolument pas, les camions d’aujourd’hui ne se traînent pas, bien au contraire. Il leur arrive même de pousser les voitures. Non, croyez moi, ce qu’il vous faut, c’est un camion !
- Vous croyez ? Si vous le dites. Est-ce que je pourrais l’avoir en rouge ?
- Bien entendu cher Monsieur,vos désirs sont des ordres, vous l’aurez dans quinze jours clé en main. Et la maison sera heureuse de vous offrir le porte-clé. Si vous payez comptant. Cela va sans dire, ajouta Monsieur Filou.
- Ah, si ce "));
var_dump($output);
$output = fann_run($ann, generate_frequencies("tworząc dzieło literackie, pracuje na języku. To właśnie język stanowi tworzywo, dzięki któremu powstaje tekst. Język literacki ( lub inaczej artystyczny) powstaje poprzez wybór odpowiednich środków i przy wykorzystaniu odpowiednich zabiegów technicznych.
Kompozycja - jest to układ elementów treściowych i formalnych dzieła dokonanych według określonych zasad konstrukcyjnych.
Kształtowanie tworzywa dzieła literackiego jest procesem skomplikowanym i przebiegającym na wielu poziomach.
Składa się na nie:"));
var_dump($output);
?
```
###### Результат
Наша модель сгенерировала следующие ответы по текстам.
В первом случае модель решила что ей на вход передали английский язык (98%) и она права
```
array(3) {
[0]=>
float(0.98745632171631)
[1]=>
float(0.0094089629128575)
[2]=>
float(0)
}
```
Во втором тексте она приняла решение в пользу французского и снова оказалась права
```
array(3) {
[0]=>
float(0)
[1]=>
float(0.99334162473679)
[2]=>
float(0)
}
```
Третий текст она тоже правильно распознала, как польский
```
array(3) {
[0]=>
float(0.015697015449405)
[1]=>
float(0)
[2]=>
float(1)
}
```
Некоторые пользователи жалуются что нейронные сети выдают вероятности, а не конкретный ответ. Для тех кто в танке добавлю, что в нашем мире все основано на вероятностях. За правильный ответ нужно считать тот который верен хотя бы на 90%, если меньше то сеть нужно до обучать, что бы улучшить классификацию.
Не смотря на такую простую систему нейронная сеть дает хорошие показатели. Можно сделать n-граммы и по ним классифицировать, это будет еще надежнее, можно оба варианта комбинировать. Нейронные сети мощный инструмент, нужно лишь научиться им пользоваться
[Перейти на сайт FANN](http://leenissen.dk/) | https://habr.com/ru/post/158729/ | null | ru | null |
# Neo4j. Вместо тысячи join-ов…
Если вы столкнулись с задачей хранения сильно связанных данных, то отличным вариантом будет использовать графовую модель данных. Мы в Текфорс сделали именно так. Почему - разберем в этой статье, где я:
* приведу общую информацию о том, где применяются графовые БД;
* расскажу про Neo4j как один из примеров такой БД;
* покажу на примере как использовать Neo4j через Spring Data.
Статья будет полезна тем, кто:
* хочет расширить кругозор в плане графовых БД;
* сомневается в правильности выбора типа БД;
* ищет вводный материал по работе с Spring Data Neo4J.
### Введение
Долгое время стандартом хранения данных были реляционные базы данных. Со временем разнообразных по структуре данных становилось все больше и стандартные способы хранения стали неудобными. В начале 2010-х стали появляться альтернативные варианты хранения, так называемые NoSql базы данных. Каждая имеет свои особенности: скорость выполнения операций, возможность хранить огромные объемы данных, линейная масштабируемость, отказоустойчивость.
*Так, документо-ориентированная база данных MongoDB предназначена для хранения слабосвязанных данных, поступающих в виде документов; колоночная база данных ClickHouse быстро работает на вставку и получение данных, но не подразумевает их удаление и изменение.*
При выборе базы данных могут возникнуть трудности### Применение графовых БД
Связи многие-ко-многим между объектами есть почти в каждой системе и реляционная база отлично справляется с их хранением. Но что делать, если:
* связей так много, что таблицы связей больше таблиц данных,
* запросы получения данных сложны и состоят из множества join-ов,
* есть необходимость в частом получении данных или глубина поиска достаточно большая (>3)?
*Например, в системе по типу социальной сети нужно проверить теорию шести рукопожатий.*
Такие операции в реляционных базах стоят очень дорого. И если на небольших наборах данных проблема с производительностью будет не столь очевидна, то с ростом их объема время выполнения запроса существенно возрастет.
В таком случае разумно представить данные в виде графа. Моделирование графами выглядит вполне естественным, так как аналитическая модель очень близка к модели данных, реализуемой в графической базе данных.
Даже типичное изображение проблемы на доске выглядит как графЕсть много систем применения графовой структуры данных. Я поделюсь несколькими типичными примерами использования графовых баз данных:
1. **Система рекомендаций.** В качестве исходных данных используются данные о продуктах, брендах, а также связи между людьми (например, детьми и родителями) и купленными ими продуктами. Имея граф таких данных можно давать пользователю рекомендации по бренду и товарам, а также строить комплексные сложные запросы и рекомендации.
2. **Социальные сети** являются разновидностью систем рекомендаций. Они особенно актуальны в наше время, поскольку социальные сети получили колоссальное распространение и популярность. Очевидно, что если нужно предложить пользователю новые связи в социальном кругу, то необходимы рекомендации, предложенные по принципу "друг моего друга - мой друг".
Также графовые БД могут использоваться в системах контроля доступа, анализа влияния (чтобы понять, как бизнес отреагирует на сбои или для выбора оптимального сценария) и других системах.
Больше информации можно найти, например, в книге “Learning Neo4j” (Rik Van Bruggen), где подробно расписаны кейсы использования графовых БД.
Надеюсь, этот краткий обзор помог определиться, нужны ли вам графовые БД. В следующем разделе я расскажу про устройство графовых БД, СУБД Neo4j и работу с ней через Spring.
### Графовая модель данных
Формально граф – это система объектов произвольной природы (вершин) и связок (ребер), соединяющих некоторые пары этих объектов.
Графовая модель данных имеет следующие особенности:
* состоит из набора вершин (узлов) и ребер;
* каждая вершина имеет идентификатор, список ребер и список свойств (пары ключ-значение, где ключ - это строка);
* каждое ребро также имеет идентификатор, ссылку на начальную и конечную вершину (стрелки из ниоткуда или вникуда быть не может) и список свойств;
* вершины и ребра в графовой модели данных необязательно должны быть одного типа - они могут представлять различные объекты.
Графическая модель данных (Источник: https://neo4j.com/)*В качестве примера создадим модель данных для системы рекомендаций, которая хранит информацию о людях и фильмах, которые они посмотрели. Каждый фильм также может относиться к нескольким жанрам.*
Простая модель графа в виде схемы*По этой модели легко определить, что Вова - друг Маши, Маша смотрела фильм Титаник, который является драмой.*
В графовой БД нет join-ов: при создании узлов и ребер вы задаете им свойства, что позволяет построить граф из данных, которые связаны непосредственно с данными. Для выполнения запроса нужно только найти стартовый узел и от него перемещаться по ребрам. Для любой вершины можно найти как ее входящие, так и исходящие ребра и таким образом выполнить обход графа, что также упрощает написание запросов на выборку данных. Таким образом, учет взаимосвязей на больших объемах данных не ухудшает производительность графовых баз данных, поскольку запросы локализуются в определенной части графа.
Neo4j является популярной графовой базой данных с открытым исходным кодом. Посмотрим, как с помощью нее реализовать описанную выше структуру данных.
### Описание Neo4j
После установки Neo4j вам будет доступен Neo4j-browser (по дефолту <http://localhost:7474/browser/>) – инструмент для выполнения CRUD-операций в БД Neo4j. Он имеет богатый пользовательский интерфейс для визуализации данных в виде графиков.
Граф в браузере Neo4j после выполнения команды CypherДля базы данных Neo4j был создан декларативный язык запросов Cypher, обеспечивающий эффективное чтение и запись данных в Neo4j. Пользоваться им очень удобно, потому что он выразительный и компактный.
Рассмотрим некоторые примеры запросов для описанной выше модели данных.
Вот как выглядит запрос операции добавления узлов и связей для нашего примера (добавим людей и пару фильмов с жанрами):
```
CREATE
(igor: Person {name:'Igor'}),
(misha: Person {name:'Misha'}),
(olya: Person {name:'Olya'}),
(am_pie: Movie {name:'American Pie'}),
(saw: Movie {name:'Saw'}),
(home_alone: Movie {name:'Home Alone'}),
(comedy: Genre {name:'Comedy'}),
(horror: Genre {name:'Horror'}),
(olya) -[:WATCHED]-> (am_pie) -[:HAS_GENRE]-> (comedy),
(olya) -[:WATCHED]-> (saw),
(olya) -[:WATCHED]-> (home_alone),
(misha) -[:WATCHED]-> (saw),
(igor) -[:WATCHED]-> (am_pie),
(home_alone) -[:HAS_GENRE]-> (comedy),
(igor) -[:IS_FRIEND]-> (misha),
(misha) -[:IS_FRIEND]-> (olya)
```
С помощью запроса MATCH (n) RETURN n можно получить все имеющиеся данные. В Neo4j-browser они будут представлены так:
Добавление новых типов узлов или связей не затронет существующую модель и запросы, что позволяет безопасно расширять данные при необходимости. Это является неоспоримым преимуществом графовых баз данных.
Теперь напишем запрос, который получает все фильмы-комедии, которые смотрели друзья друзей пользователя, но которые он не смотрел сам.
```
MATCH (igor:Person{name:'Igor'})-[:IS_FRIEND*2]->()-[:WATCHED*0..1]->
(m:Movie)-[]->(comedy: Genre {name:'Comedy'})
WHERE not (igor)-[:WATCHED]->(m)
RETURN m
```
Запрос получился достаточно компактным и простым для понимания.
Подобный запрос для реляционной базы данных выглядел бы громоздким:
```
select m.*
from person p
left join person_friend pF1 on p.id = pF1.person_id
left join person_friend pF2 on pF1.friend_id = pF2.person_id
left join watched watched on pF2.friend_id = watched.person_id
left join movie_genre mG on watched.movie_id = mG.movie_id
left join genre genre on mG.genre_id = genre.id
left join movie m on m.id = mG.movie_id
where p.name = 'Igor' and p.id<> pF2.friend_id and genre.name='Comedy'
except select m2.* from watched w2
left join person p2 on w2.person_id = p2.id
left join movie m2 on m2.id = w2.movie_id
where p2.name = 'Igor'
```
Для обхода графа в глубину в реляционной базе пришлось бы применять рекурсивные функции, которые усложняют синтаксис и увеличивают время выполнения запроса, тогда как в языке Cypher существует компактная запись ()-[\*0..]->(), которая означает 0 или более ребер до узла.
Далее я расскажу о работе с БД Neo4j через Spring Data.
### Использование Spring data neo4j
Spring Data Neo4j является частью Spring Data и предлагает настройку объектов на основе аннотаций, а затем сопоставляет их с узлами и отношениями в базе данных Neo4j. Не так давно вышла новая версия Spring Data Neo4j 6, которая содержит принципиальные изменения. Рассмотрим отличия этой версии.
**Spring Data Neo4j 5 (SDN 5)** и ранние версии использовали Neo4j-OGM под капотом.
*Neo4j-OGM (Object Graph Mapper) сопоставляет узлы и отношения в графе с объектами и ссылками в доменной модели. Экземпляры объектов сопоставляются с узлами, а ссылки на объекты сопоставляются с помощью отношений или сериализуются в свойства.*
**Spring Data Neo4j 6** является standalone решением без использования Neo4j-OGM.
*В новой версии мы по прежнему можем работать со связями (relationships), которые имеют свойства (properties), но не напрямую через @RelationshipEntity, а через сущности (@Node), определяющие отношения (@Relationship) для их загрузки, изменения и сохранения.*
Вот пример использования **Spring Data Neo4j 6** для созданного ранее запроса.
1. Создаем класс для каждого типа узла:
```
Node("Person")
public class PersonNeo4jEntity {
@Id
@GeneratedValue(GeneratedValue.UUIDGenerator.class)
private UUID id;
@Property("name")
private UUID name;
@Relationship(type = "IS_FRIEND", direction = Relationship.Direction.OUTGOING)
private List friends;
}
```
2. Описываем каждый тип связи в отдельном классе, помеченном аннотацией @RelationshipProperties:
```
@RelationshipProperties
public class EdgeFriendNeo4j {
@Id
@GeneratedValue
private Long id;
@TargetNode
private PersonNeo4jEntity friend;
private String property1;
private String property2;
}
```
3. Для работы с базой создадим репозиторий, который наследуется от одного из интерфейсов Spring Data, например от CrudRepository.
```
public interface PersonNeo4jRepository extends CrudRepository {}
```
Это позволяет нам выполнять основные CRUD-запросы к Neo4j, а также дописывать дополнительные методы запросов в терминах Spring Data.
4. При необходимости создаем методы получения узла:
```
Optional findOneByPersonName(String name);
```
Результатом выполнения такого метода будет узел с загрузкой всех связей.
Если нужны не все связи, а только потомки первого уровня, можно создать такой метод:
```
@Query("match (n:Person)-[r]->(m) \n" +
"where n.person_name=$name\n" +
"return n, COLLECT(r), COLLECT(m)")
List getNodeByName(String name);
```
Если нужен только сам узел без связей, подойдет такой метод:
```
@Query("match (n:Person {person_name: $name })-[r]->()\n" +
" return n")
PersonNeo4jEntity getNodeByName(String name);
```
Пара важных рабочих моментов:
1. Только стрелки с помощью SDN вернуть нельзя, мы должны вернуть связанный объект-узел, а из него уже получить связи.
2. В Cypher мы можем написать такой рабочий запрос, который вернет только связи:
```
match (n)-[r]-(m) return r
```
Таким нехитрым образом можно работать с базой данных Neo4j через Spring Data Neo4j, что позволяет добиться единообразия в приложении, использующем Spring.
### Заключение
Итак, графовые БД – отличное решение для хранения данных, связанных отношениями многие-ко-многим. Они предназначены для сценариев, в которых любые данные потенциально могут быть взаимосвязаны.
Мы в Текфорс использовали базу данных Neo4j для хранения данных, необходимых для отчетной подсистемы. Они хранились в реляционной базе и по мере наполнения необходимые для отчета данные складывались в Neo4j. При запросе отчета оставалось только обратиться к заранее подготовленным данным из Neo4j. Использование специализированной базы данных позволило избежать ограничений конкретного хранилища данных и эффективно реализовать разнородные запросы. Мартин Фаулер называет такой подход polyglot persistence.
Любая модель данных будет показывать хорошие результаты, если разумно применять ее для подходящий задачи. Надеюсь, что моя статья дала вам понимание того, когда следует использовать графовые базы, а также как работать с БД Neo4j, используя Spring Data Neo4j.
Подведем итоги:
* Графовые базы подойдут, если в вашем приложении данные связаны иерархически, Neo4j - пример такой БД;
* Neo4j-browser - удобный инструмент для выполнения операций над данными и визуализации;
* БД Neo4j имеет собственный язык запросов Cypher. Запросы на нем выглядят лаконичнее и понятнее, чем аналогичные запросы для реляционной БД;
* Spring Data Neo4j как часть Spring Data позволяет работать с Neo4j из java-кода привычным способом.
Спасибо за внимание! | https://habr.com/ru/post/711646/ | null | ru | null |
# jl-sql: SQL-запросы по JSON-логами в командной строке
Вступление никому не интересно, поэтому начну сразу с примеров использования
```
% cat log.json
```
```
{"type": "hit", "client": {"ip": "127.1.2.3"}}
{"type": "hit", "client": {"ip": "127.2.3.4"}}
{"type": "hit", "client": {"ip": "127.3.4.5"}}
{"type": "hit", "client": {"ip": "127.3.4.5"}}
{"type": "hit", "client": {"ip": "127.1.2.3"}}
{"type": "click", "client": {"ip": "127.1.2.3"}}
{"type": "click", "client": {"ip": "127.2.3.4"}}
```
Выполняем запрос:
```
% cat log.json | jl-sql 'SELECT client.ip, COUNT(*) AS count WHERE type = "hit" GROUP BY client.ip'
```
```
{"client":{"ip":"127.1.2.3"},"count":2}
{"client":{"ip":"127.2.3.4"},"count":1}
{"client":{"ip":"127.3.4.5"},"count":2}
```
---
Краткое описание
================
Как вы могли заметить, для выполнения запроса используется утилита [jl-sql](https://github.com/avz/jl-sql), которая принимает на вход поток JSON-объектов, разделённых символом перевода строки (`"\n"`).
Тут стоит отметить, что утилита основана на библиотеке [jl-sql-api](https://github.com/avz/node-jl-sql-api), на базе которой можно достаточно просто реализовать обработку данных в произвольном формате, не ограничиваясь только JSON.
SQL-движок поддерживает `WHERE`, `GROUP BY`, `HAVING`, `ORDER BY` и `{LEFT|INNER} JOIN`. Что касается `JOIN`ов, то тут есть ограничение на выражение в `ON`: реализована поддержка объединений только по точному соответствию двух полей, так называемый [Equi Join](https://en.wikipedia.org/wiki/Join_(SQL)#Equi-join):
```
SELECT id, @town.name AS townName JOIN `towns.json` ON @towns.id = townId
```
---
Примеры
=======
Определение уникальных ip-адресов
---------------------------------
```
% cat log.json | jl-sql 'SELECT DISTINCT client.ip AS ip'
```
```
{"ip":"127.1.2.3"}
{"ip":"127.2.3.4"}
{"ip":"127.3.4.5"}
```
Подсчёт количества уникальных адресов для каждой группы
-------------------------------------------------------
```
% cat log.json | jl-sql 'SELECT type, COUNT(DISTINCT client.ip) AS ipCount GROUP BY type'
```
```
{"type":"click","ipCount":2}
{"type":"hit","ipCount":3}
```
Перестройка объектов
--------------------
С помомощью альясов (`AS`) можно не только назначать псевдонимы для полей, но и создавать сложные структуры внутри объекта:
```
% echo '{"a": 1, "b": 2}' | jl-sql 'SELECT a AS sub.bar.first, b AS sub.foo.second'
```
```
{"sub":{"bar":{"first":1},"foo":{"second":2}}}
```
Удаление и изменение
--------------------
Помимо `SELECT` поддерживается так же `DELETE` и `UPDATE`
```
% cat log.json | jl-sql -b :ip=127.1.2.3 'DELETE WHERE client.ip = :ip'
```
```
% cat log.json | jl-sql -b :ip=127.1.2.3 'UPDATE SET banned = true WHERE client.ip = :ip'
```
В этих примерах показывается ещё и использование биндингов (опция `-b` / `--bind`), более подробно о них рассказывается в [соответствующем разделе](#bindingi).
Работа с датами
---------------
```
% echo '{"ts": "2017-01-18 00:00:00"}' | jl-sql 'SELECT ts - INTERVAL 2 MONTH 3 DAY 4 HOUR 5 MINUTE 6 SECOND AS past'
```
Ключевое слово `INTERVAL` позволяет "добавлять" и "отнимать" отрезки времени от какой-то даты. Всё это аналогично использованию `INTERVAL` в MySQL.
Так как в JSON не предусмотен отдельный тип данных под даты, то для их сохранения используются строки. Утилита понимает форматы из [RFC2822](https://tools.ietf.org/html/rfc2822#page-14) или [ISO 8601](https://ru.wikipedia.org/wiki/ISO_8601). Могут использоваться и другие, но результаты в таком случае будут непредсказуемые.
Следует отметить, что для парсинга и манипуляции датами используется системная временная зона. Если вас это не устраивает, то вы можете установить переменную окружения `TZ` с нужной временной зоной перед запуском `jl-sql`.
Более подробное описание работы с датами можете прочитать в [документации на GitHub](https://github.com/avz/node-jl-sql-api#dates).
Объединения (`JOIN`)
--------------------
Для `JOIN` требуется как минимум ещё один источник данных, в терминах SQL это называется "таблица", в качестве таких источников выступают обычные файлы:
```
% cat banned.json
```
```
{"ip": "127.1.2.3"}
```
```
% cat log.json | jl-sql -b :banned=banned.json 'SELECT * INNER JOIN {:banned} ON @banned.ip = client.ip'
```
```
{"type":"hit","client":{"ip":"127.1.2.3"}}
{"type":"hit","client":{"ip":"127.1.2.3"}}
{"type":"click","client":{"ip":"127.1.2.3"}}
```
В этом примере было введено новое понятие — источник данных (`@banned`), более подробно об этом и вообще о JOIN можно прочитать в [соответствующем разделе](#join).
---
Производительность и потребляемые ресурсы
=========================================
Утилита рассчитана на обработку больших логов. В зависимости от типа, запрос может выполняться либо в *потоковом режиме*, либо в *режиме использования временного хранилища*. Огромным плюсом *потокового режима* является возможность выполнять [jl-sql](https://github.com/avz/jl-sql) в связке, например, с `tail -f` для фильтрации и переформатирования логов в реальном времени.
* *потоковый режим* — режим, в котором запрос обрабатывает входящие данные сразу же, не дожидаясь завершения входящего потока. Вычислительная сложность такой обработки `O(n)` по CPU и `O(1)` по памяти. В таком режиме могут исполняться только самые простые запросы, которые не требуют сортировок: `SELECT` , `SELECT ... WHERE expression`.
* *режим использования временного хранилища* — для выполнения запроса требуется сортировка входящего потока. Это означает, что может потребоваться временное хранилище в ФС. К этой категории относятся запросы с `GROUP BY`, `ORDER BY` и `JOIN`. Размеры внутренних буферов задаются опциями `-B` и `-S` (смотри [описание опций](#opcii-komandnoy-stroki)).
Для сортировки больших объёмов [jl-sql](https://github.com/avz/jl-sql) использует системную утилиту `sort`, что позволяет использовать более производительную нативную сортировку.
---
Установка
=========
 Код написан на JavaScript под Node.js, поэтому проще всего установить пакет через `npm`:
```
# npm install -g jl-sql
```
**Внимание:** требуется версия Node.js не менее 6.0.0
---
Грязные подробности
===================
Сортировка
----------
Сортировку можно задать стандартным выражением `ORDER BY expression [{DESC|ASC}]`, поддерживается сортировка сразу по нескольким полям, в том числе и разнонаправленно.
Неструктурированность данных на входе вносит свои коррективы: поле, по которому идёт сортировка, может отсутствовать в некоторых объектах или иметь разные типы данных в разных объектах. Поэтому, желательно всегда явно указывать тип данных функциями `STRING()` и `NUMBER()`:
Сортировка по строкам
```
ORDER BY STRING(field)
```
Сортировка по числам
```
ORDER BY NUMBER(field)
```
Если не указать явно тип сортировки, то утилита попытается определить тип по правилам, описанным [здесь](https://github.com/avz/node-jl-sql-api#type-casting). Если тип определить не удалось, то сортировка будет происходить по строкам.
Значения преобразуются в строку по следующим правилам:
| Тип данных | Строковое представление |
| --- | --- |
| строка | исходная строка |
| число | десятичная строка |
| boolean | `"true"` / `"false"` |
| null | `"null"` |
| отсутствующее поле | `""` (пустая строка) |
| объект | N/A\* |
| массив | N/A\* |
\* — преобразование строк и массивов к строке не специфицируется, поэтому полагаться на порядок этих значений в итогом множестве не следует.
*Рекомендую всегда явно задавать тип данных т.к. нынешнее поведение по-умолчанию может быть изменено или вовсе удалено, как потенциально опасное.*
---
Биндинги
--------
Для того, чтобы решить проблему экранирования данных в командной строке, утилита позволяет использовать биндинги (подстановки):
```
jl-sql -b :type=hit jl-sql 'SELECT client.ip, COUNT(*) AS count WHERE type = :type GROUP BY client.ip'
```
Здесь опция `-b :type=hit` задаёт подстановку с именем `:type` и значением `"hit"`. Это делает возможным использовать обычное экранирование на уровне shell для составления SQL-запросов.
Аналогично, можно использовать подстановки для имён файлов, используемых в `JOIN`:
```
jl-sql -b :towns=towns.json 'SELECT id, @town.name AS townName JOIN {:towns} ON @towns.id = townId'
```
Это позволит использовать автодополнение имён файлов в вашем любимом shell.
Более подробно конкретно про `JOIN` можно почитать в соответствующем разделе [JOIN](#join).
---
`JOIN`
======
Поддержка `JOIN` потребовала введения в синтаксис новой сущности — название источника данных (можно назвать это "таблицей"). Проблема здесь возникает в том, что в "классическом" SQL всегда можно определить, где в идентификаторе `ident1.ident2` название таблицы, а где название поля. С JSON всё сложнее: объекты могут иметь разную вложенность, поэтому без специального синтаксиса невозможно точно сказать, что имел в виду пользователь, когда ввёл `ident1.ident2` т.к. `ident1` может быть как названием поля, так и названием "таблицы".
Для решения этой неоднозначности был введён синтаксис `@ident`, где `@` — префикс, указывающий, что следующий за ним идентификатор — это название "таблицы".
Вернёмся к примеру из начала статьи и разберём его более подробно:
```
% cat log.json | jl-sql -b :banned=banned.json 'SELECT * INNER JOIN {:banned} ON @banned.ip = client.ip'
```
Итак, начнём с начала:
**`-b :banned=banned.json`** — создаём биндинг с названием файла источника, это не обязательный шаг, но он даёт возможность вашему shell делать автодополнение петей, а так же избавляет от необходимости экранирование специальных символов в пути
**`INNER JOIN {:banned}`** — здесь `{:banned}` — это специальный синтаксис для подстановки биндинга в `JOIN`. Без использования биндингов эта строка выглядела бы как **`INNER JOIN `banned.json``**. Использование обратных кавычек здесь обязательно т.к. иначе точка (`.`) будет интерпретироваться специальным образом.
**`@banned.ip`** — здесь `@banned` — это название таблицы. В данном случае название вывелось автоматически из названия биндинга, но вы можете задать его явно через альяс: **`INNER JOIN {:banned} AS @someName`**, тогда обращение к этой таблице будет происходить как `@someName.ip`
*Рекомендую всегда использовать биндинги, как для файлов, так и для обычных данных т.к. это избавляет от множества проблем.*
На данный момент поддерживаются только два вида JOIN: `INNER JOIN` и `LEFT JOIN`. Если не указать тип JOIN в запросе, то будет использоваться `INNER JOIN`.
Кау уже было сказано ранее, выражение в `ON` должно иметь вид `ON @table.primary = foreign`, то есть точное соответствие поля `@table.primary` (подключаемая таблица) полю `foreign` (главная таблица).
---
Операторы сравнения
===================
Для удобства, оператор `=` (и его псевдоним `==`) не учитывает тип значения и пытается сравнивать значения максимально либерально, поэтому значение выражения `1 = "1"` будет равно `true`. В противоположность этому, оператор `===` учитывает при сравнении ещё и тип, поэтому выражение `1 === "1"` уже будет равно `false`. Правила сравнений аналогичны принятым в JavaScript, более подробно можно посмотреть [здесь](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%D1%8B_%D1%81%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F).
Сравнение объектов и массивов
-----------------------------
Поведение операторов `=` и `===` не определено для массивов и объектов, поэтому на данный момент такого сравнения следует избегать. В будущем сравнение объектов и массивов будет реализовано.
---
Опции командной строки
======================
```
% jl-sql -h
```
```
Usage: jl-sql [OPTIONS] SQL
OPTIONS:
-h, --help show this help
-I, --ignore-json-error ignore broken JSON
-v, --verbose display additional information
-B, --sort-in-memory-buffer-length=ROWS save up to ROWS rows for in-memory sort
-S, --sort-external-buffer-size=SIZE use SIZE bytes for `sort` memory buffer
-T, --temporary-directory=DIR use DIR for temporaries, not $TMPDIR or /tmp
-b, --bind=BIND=VALUE+ bind valiable
See full documentation at https://github.com/avz/jl-sql
```
Более подробно по интересным опциям
* `-I`: игнорировать ошибки в JSON. По умолчанию `jl-sql` завершается с ошибкой (ненулевым кодов возврата) после обнаружения первой же ошибки в JSON. Эта опция позволяет переопределить это поведение и просто игнорировать подобные ошибки. Вывод предупреждений в stderr остаётся
* `-B`: установить лимит на количество строк/объектов, которые будут сортироваться в оперативной памяти без использования внешней сортировки через системную утилиту `sort`
* `-S`: установить лимит на количество RAM, используемых утилитой `sort` в качестве буфера (смотри описание опции `-S` в `man sort`)
* `-T`: каталог для размещения временных файлов сортировки
Ссылки
======
* <https://github.com/avz/jl-sql> — основной репозиторий утилиты
* <https://github.com/avz/node-jl-sql-api> — репозиторий SQL-движка
Спасибо за внимание. | https://habr.com/ru/post/319722/ | null | ru | null |
# Модуль Mock: макеты-пустышки в тестировании
*Mock* на английском значит «имитация», «подделка». Модуль с таким названием помогает сильно упростить тесты модулей на Питоне.
Принцип его работы простой: если нужно тестировать функцию, то всё, что не относится к ней самой (например, чтение с диска или из сети), можно подменить макетами-пустышками. При этом тестируемые функции не нужно адаптировать для тестов: Mock подменяет объекты в других модулях, даже если код не принимает их в виде параметров. То есть, тестировать можно вообще без адаптации под тесты.
Такое поведение — уже не надувные ракетные установки, а целая надувная земля, вокруг которой могут летать испытуемые ракеты и самолёты.
На Хабре пакет [Mock](http://www.voidspace.org.uk/python/mock/) упоминали только в [одном комментарии](http://habrahabr.ru/post/122156/#comment_3998034). В принципе, подменять объекты в других модулях, что называется monkey patch, нам иногда в работе приходится. Но в отличие от ручных патчей, Mock умеет делать очень сложные подстановки, пачками и цепочками вызова, а также убраться за собой, не оставляя побочных эффектов.
Пакет занимает меньше 1 мегабайта и устанавливается очень просто:
`$ pip install mock`
или
`$ easy_install mock`
И теперь им можно пользоваться.
#### Подмена функции
Скажем, наша функция считает что-то, причём очень долго:
```
from itertools import permutations
def real(name):
if len(name) < 10:
raise ValueError('String too short to calculate statistics.')
y = 0
for i in permutations(xrange(len(name)), 10):
y += i
print y
```
Пример надуманный и примитивный, но что-то подобное может встретиться: внутри делаются большие вычисления, которые не хотелось бы повторять в тесте. И в данном примере хочется ввести строку покороче (чтобы число повторений в permutations, len(name), было меньше), но это запрещено. Можно было бы разбить функцию на две, вынести вызов permutations наружу, и в функцию передавать её вывод, но можно сделать по-другому.
Вместо переписывания кода, мы можем просто «пропатчить» функцию permutations на время вызова, задать только определённый вывод и вызвать какой-то код:
```
from mock import patch
import itertools # важно: мы импортируем модуль, не сам метод
name = 'достаточно длинное имя'
>>> with patch('itertools.permutations') as perm_mock:
... perm_mock.return_value = xrange(3)
... real(name)
1
3
6
```
Заметьте: print вызван вместо [*42! / (42 — 10)!*](http://docs.python.org/library/itertools.html#itertools.permutations) раз всего 3, то есть цикл пробежался по xrange(3), который мы подставили.
Кроме того, после выхода из контекста **with** функция itertools.permutations вернулась в своё нормальное состояние.
#### Отладочная информация
Допустим, нужно проверить, что происходит с объектом, который мы передали функции. В той ли последовательности, с теми ли параметрами вызываются методы, к тем ли атрибутам обращаются. Для нужно просто запустить в неё объект Mock, который запишет всё, что происходит.
Похожий пример из жизни: когда шли аэродинамические испытания Бурана, весь корабль не продували в трубе (таких не бывает) и не запускали в атмосферу. В воздухе летал специальный прототип БТС-002, а для отработок посадки использовался переоборудованный Ту-154 в обвесе, повторяющем аэродинамику Бурана.
[](http://commons.wikimedia.org/wiki/File:Orbiter.jpg?uselang=ru)
У объекта Mock есть несколько атрибутов с информацией о вызовах:
* called — вызывался ли объект вообще
* call\_count — количество вызовов
* call\_args — аргументы последнего вызова
* call\_args\_list — список всех аргументов
* method\_calls — аргументы обращений к вложенным методам и атрибутам (о них — ниже)
* mock\_calls — то же самое, но вместе и для самого объекта, и для вложенных
В нашем примере выше можно убедиться, что функция real() правильно вызывает permutations. Чтобы ещё точнее проверить, например, в автоматических тестах, можно вызвать один из [методов assert\_\*](http://www.voidspace.org.uk/python/mock/mock.html#mock.Mock.assert_called_with):
```
perm_mock.assert_called_with(xrange(len(name)), 10)
```
#### Синтаксический сахар
Для юнит-тестов в Джанго пригодится то, что patch работает как декоратор:
```
@patch('itertools.permutations')
def test(ip):
ip.return_value = range(5)
print list(itertools.permutations(xrange(10), 10))
>>> test()
[0, 1, 2, 3, 4]
```
#### Макеты атрибутов и цепочек вызова
Иногда в Джанго нужно делать что-то с файлами, и лучше обойтись без сохранения их на диск или другое хранилище. Обычным путём мы бы наследовали от класса File и перезаписали бы некоторые свойства, что было бы громоздко. Но в Mock можно описать сразу и атрибуты, и цепочки вызова:
```
mock_file = Mock()
mock_file.name = 'my_filename.doc'
mock_file.__iter__.return_value = ['строка 1', 'строка 2', 'строка 3']
stat = mock_file.stat.return_value
stat.size, stat.access_time = 1000, datetime(2012, 1, 1)
```
Вот сколько тестового кода было сэкономлено. Кстати, передавая объект как аргумент или ожидая объект из функции, полезно дать им имена, чтобы отличать:
```
>>> mock_a = Mock(name='макет файла')
>>> mock_a
```
Как же эти цепочки атрибутов работают?
```
>>> m = Mock()
>>> m
>>> m.any\_attribute
>>> m.any\_attribute
>>> m.another\_attribute
```
Как видите, обращение к атрибуту выдаёт ещё один экземпляр класса Mock, а повторное обращение к тому же атрибуту — снова тот же экземпляр. Атрибут может быть чем угодно, в том числе и функцией. Наконец, любой макет можно вызвать (скажем, вместо класса):
```
>>> m()
>>> m() is m
False
```
Это будет другой экземпляр, но если вызвать ещё раз, экземпляр будет тем же самым. Так мы можем назначить этим объектам некоторые свойства, после чего передать этот объект в тестируемый код, и они там будут считаны.
Если мы назначим атрибуту значение, то никаких сюрпризов: при следующем обращении получим именно это значение:
```
>>> m.any_attribute
>>> m.any\_attribute = 5
>>> m.any\_attribute
5
```
Полезно прочесть в [документации класса](http://www.voidspace.org.uk/python/mock/mock.html), какие атрибуты у него родные, чтобы не случалось коллизии названий.
#### Как ограничить гибкость макета
Как видите, можно обращаться к любому атрибуту макета, не вызывая ошибки AttributeError. У этого удобства есть обратная сторона: что если мы поменяем API, например, переименуем метод, а функция, работающая с нашим классом, будет обращаться к прежнему методу? Код на самом деле не работает, а тест выполняется без ошибок. Для этого можно задать спецификацию объекта в параметре **spec** (либо классу Mock, либо patch), и макет будет вызывать ошибку при обращении к несуществующим свойствам:
```
class Tanchik(object):
model = 'T80'
def shoot(self, target):
print 'Бдыщь!'
def tank_sugar(target):
print '%s стреляет' % tank.model
tank.shoot(target)
return tank
==================
import tanks
@patch('tanks.Tanchik', spec=tanks.Tanchik) # <<== задано свойство spec
def test_tank(tank_mock):
assert isinstance(tank_sugar(tank_mock), tanks.Tanchik)
```
Теперь если мы переименуем model или shoot у танчика, но забудем исправить tank\_sugar, тест не выполнится.
#### Как сделать макет умнее
Хорошо, допустим, Mock умеет заменять нужные объекты на ненужные и подменять вывод. А можно ли подменить функцию на что-то более сложное, чем значение (return\_value)? Есть 2 пути:
* если нужно переопределить много методов у экземпляра или класса, наследуем от класса Mock
* если нужно заменить только один вызов (метод или сам класс), используем **side\_effect**.
```
def simple_function(args):
do_something_useful()
with patch('module.BigHeavyClass', side_effect=simple_function) as mock_class:
another_class.take(mock_class)
```
Кстати, не нужно писать в simple\_function контрольный вывод, потому что, как сказано выше, в конце кода в объекте mock\_class можно считать method\_calls.
#### Подмена встроенных функций
Сам по себе Mock не может заменить встроенные в язык функции (len, iter), но может сделать [макет с нужными «волшебными» функциями](http://www.voidspace.org.uk/python/mock/magicmock.html#mocking-magic-methods). Например, вот мы делаем макет файла:
```
>>> mock = Mock()
>>> mock_bz2module.open.return_value.__enter__ = Mock(return_value='foo')
>>> mock_bz2module.open.return_value.__exit__ = Mock(return_value=False)
>>> with mock_bz2module.open('test.bz2') as m:
... assert m == 'foo'
```
Для множества подобных случаев, когда требуется эмулировать стандартный объект (список, файл, число), есть класс [**MagicMock**](http://www.voidspace.org.uk/python/mock/magicmock.html#magic-mock) с набором значений, пригодных для тестов.
#### Где Mock не работает
Сам автор модуля, Майкл Фурд, говорит, что принцип, где нужны макеты, а где нет, простой: если с макетами тестировать проще, их надо использовать, а если с ними труднее, надо отказаться.
Бывает так, что нужно тестировать связку двух модулей, нового и старого, и в связке много перекрёстных вызовов. Нужно внимательно смотреть: если мы постепенно начинаем переписывать поведение целого модуля, пора остановиться — код теста жёстко сввязан с кодом модуля, и при каждом изменении в рабочем коде придётся менять и тесты. Кроме того не стоит пытаться написать целый модуль-макет вместо старого.
По моему личному опыту, Mock может конфликтовать с отладчиками, например, в [PuDB](http://pypi.python.org/pypi/pudb) случалась бесконечная рекурсия. [IPDB](http://pypi.python.org/pypi/ipdb) работал нормально, поэтому тесты проекта мы выполняли с IPDB, а просто код — на PuDB.
#### Выводы
Макеты в Mock можно подставлять всюду и как угодно. Ваш код не придётся подстраивать под тестирование, что значит быстрее разработка, и, возможно, быстрее прототипирование.
Можно выбросить из тестов всё лишнее, всё занимающее время и ресурсы, оставив работать только тот код, который нужно проверить.
Настройки макетов где нужно жёсткие (spec), где нужно гибкие, и патчи не оставляют за собой следов.
#### Ссылки
* [Домашняя страница проекта](http://www.voidspace.org.uk/python/mock/)
* [Testing with Mock](http://blip.tv/pycon-us-videos-2009-2010-2011/pycon-2011-testing-with-mock-4899484), автор модуля Майкл Фурд рассказывает о нём на PyCon 2011. | https://habr.com/ru/post/141209/ | null | ru | null |
# Сравнение алгоритмов вычисления чисел Фибоначчи
В комментариях к статьям [N-е число Фибоначчи за O(log N)](http://habrahabr.ru/post/148336/) и [Еще один алгоритм вычисления чисел Фибоначчи](http://habrahabr.ru/post/148531/) указывалось на тот факт, что уже 100-е число Фибоначчи не помещается в 4 байта, а в «длинной» арифметике скорость выполнения умножения резко просядет. Более того, были предположения, что примитивное сложение может оказаться быстрее. Я решил сравнить 2 алгоритма — простое сложение и алгоритм с логарифмическим количеством операций — и написал тестовую программу на С. Для «длинной» арифметики использовал библиотеку [GMP](http://gmplib.org/).
**Текст тестовой программы**
```
#include
#include
#include
#include
void fibonachi1(unsigned int n, mpz\_t result);
void fibonachi2(unsigned int n, mpz\_t result);
void dump(unsigned int n);
int main(int argc, char\* argv[])
{
unsigned int n, test\_count;
clock\_t t1, t2;
mpz\_t result;
scanf("%u", &test\_count);
while (test\_count--) {
scanf("%u", &n);
mpz\_init(result);
t1 = clock();
fibonachi1(n, result);
t2 = clock();
printf("%u\t%u\n", n, (unsigned int)(t2 - t1));
mpz\_clear(result);
}
scanf("%u", &test\_count);
while (test\_count--) {
scanf("%u", &n);
mpz\_init(result);
t1 = clock();
fibonachi2(n, result);
t2 = clock();
printf("%u\t%u\n", n, (unsigned int)(t2 - t1));
mpz\_clear(result);
}
// dump(10000);
return 0;
}
void fibonachi1(unsigned int n, mpz\_t result)
{
mpz\_t last, current;
if (n < 2) {
mpz\_init\_set\_ui(result, n);
} else {
mpz\_init\_set\_ui(last, 0);
mpz\_init\_set\_ui(current, 1);
while (--n > 0) {
mpz\_swap(last, current);
mpz\_add(current, current, last);
}
mpz\_swap(current, result);
mpz\_clear(last);
mpz\_clear(current);
}
}
void fibonachi2(unsigned int n, mpz\_t result)
{
mpz\_t fn, fn1, gn, gn1;
if (n < 2) {
mpz\_init\_set\_ui(result, n);
} else {
unsigned mask = 1, m = n;
while (m > 1) {
m >>= 1;
mask <<= 1;
}
mpz\_init\_set\_ui(fn, 1);
mpz\_init\_set\_ui(fn1, 1);
mpz\_init(gn);
mpz\_init(gn1);
while (mask > 3) {
mask >>= 1;
mpz\_swap(fn, gn);
mpz\_swap(fn1, gn1);
if (n & mask) {
mpz\_mul(fn, gn1, gn1);
mpz\_set(fn1, fn);
mpz\_addmul(fn, gn, gn);
mpz\_mul(gn, gn, gn1);
mpz\_add(fn1, fn1, gn);
mpz\_add(fn1, fn1, gn);
} else {
mpz\_mul(fn, gn, gn1);
mpz\_add(fn, fn, fn);
mpz\_mul(gn, gn, gn);
mpz\_sub(fn, fn, gn);
mpz\_mul(fn1, gn1, gn1);
mpz\_add(fn1, fn1, gn);
}
}
if (mask > 1) {
mask >>= 1;
mpz\_swap(fn, gn);
mpz\_swap(fn1, gn1);
if (n & mask) {
mpz\_mul(fn, gn1, gn1);
mpz\_addmul(fn, gn, gn);
} else {
mpz\_mul(fn, gn, gn1);
mpz\_add(fn, fn, fn);
mpz\_submul(fn, gn, gn);
}
}
mpz\_swap(result, fn);
mpz\_clear(fn1);
mpz\_clear(gn);
mpz\_clear(gn1);
}
}
void dump(unsigned int n)
{
FILE\* output;
mpz\_t result;
mpz\_init(result);
fibonachi1(n, result);
output = fopen("alg1.output", "w");
if (output) {
mpz\_out\_str(output, 16, result);
fclose(output);
}
mpz\_clear(result);
mpz\_init(result);
fibonachi2(n, result);
output = fopen("alg2.output", "w");
if (output) {
mpz\_out\_str(output, 16, result);
fclose(output);
}
mpz\_clear(result);
}
```
Примитивный скрипт для запуска тестов
```
#!/bin/bash
./main test1.txt
./main test2.txt
./main test3.txt
```
Входные данные:
```
15
200000
400000
600000
800000
1000000
1200000
1400000
1600000
1800000
2000000
2200000
2400000
2600000
2800000
3000000
13
50000000
100000000
200000000
300000000
400000000
500000000
600000000
700000000
800000000
900000000
1000000000
1100000000
1200000000
```
Тестовая среда: VirtualBox, Athlon II X3 3,4 ГГц, 1Гб ОЗУ, Xubuntu 12.04 64bit, компилятор GCC 4.6.3, оптимизация O2
Второй алгоритм оказался намного быстрее. Я так и не смог дождаться, когда первый алгоритм посчитает миллиардное число Фибоначчи. Алгоритму №2 на это понадобилась 21 секунда.
Результаты (указано время, возвращаемое функцией clock()):
Второй график сильно похож на O(N). График первого алгоритма больше похож на O(N^2).
**UPD** Добавил совмещенный график. Второй алгоритм работает так быстро, что время его работы сравнимо с погрешностью функции clock()
Данные, на которых построен график:
 | https://habr.com/ru/post/148667/ | null | ru | null |
# К вопросу о константах
### Есть ли в мире что либо более постоянное, чем временные переменные
Просматривая тематический форум, увидел традиционное «Не работает скетч, подскажите, в чем дело» — таких постов чуть меньше, чем все, но в заголовке фигурировала работа с SD карточкой, поэтому решил глянуть. Больше всего порадовала фраза, что «скорее всего, дело в карточке, но решил попросить посмотреть код, может, что интересного увидите» — не ручаюсь за точность цитаты, но смысл передал верно. Действительно, интересного там наблюдалось много, мой взгляд зацепился за выражение
```
unsigned long Interval = 2000; ....
while (micros() < StartInterval + Interval) {};
```
причем дальше эта переменная использовалась, как константа в запуске задержки. Оставим за скобками способ обращения с временем, сейчас речь не об этом.
Сначала я, действуя на автомате, написал, что следует применять #define, «да призадумалась, а сыр во рту держала». Может быть, я чего-то не знаю, и применение констант в таком формате может быть выгодно при определенных условиях? Вдумчивое чтение мануалов на разные микроконтроллеры (МК) привело к интересным находкам, которыми (вместе с ответом на мой вопрос) и собираюсь поделиться под катом.
Для начала зафиксируем ряд положений относительно архитектуры современных МК, на которых будем опираться в дальнейших рассуждениях.
Первое — в МК существуют, по меньшей мере, два вида памяти — память программ и память данных и обращение к ним осуществляется разными способами. Как правило, мы имеем две физически разделенные шины, даже если адресное пространство совмещено и линейно, часто мы имеем и различные команды обращения к разным видам памяти и адресное пространство может перекрываться.
Второе — эти два вида памяти могут иметь разную ширину слова (этим термином я называю количество битов в слове) и она совершенно не обязана быть равной ширине регистров МК (которая в свою очередь может меняться путем объединения регистров в группы), что придает особую пикантность дальнейшему обсуждению предмета.
Проиллюстрируем вышесказанное конкретными примерами архитектур, на которых мы далее будем опираться.
Номер ноль — вероятнее всего, чемпион по красоте архитектуры, но не по эффективности, к сожалению (моя первая любовь в технике), PDP 11 от DEC. К сожалению, она уже давно не с нами, но память о ней всегда сохранится в наших сердцах (не только память, многие современные архитектуры явно вдохновлялись ее идеями, например MSP430 от TI). Ширина регистров (Р)- 16 разрядов, слова программ (П) — 16 бит, слова данных (Д) — 16 бит (возможен доступ к старшему и младшему байту слова отдельно), шины адреса (А)- 16 бит (20 в расширенном режиме), адресное пространство линейное и совмещенное, все команды однородны.
Первая архитектура — 8051 от Intel, несомненная классика (причем до сих пор не умершая), так что это отличный кандидат. Ширина регистров — 8 разрядов, слова программ — 8 разрядов, слова данных — 8 разрядов, шины адреса — 16 разрядов, адресное пространство перекрывается и имеет 3 секции (программ, данных, расширенных данных), есть три различные команды для чтения из разных секций, регистры могут образовывать регистровые пары.
Вторая архитектура — AVR (Tiny, Classic,Mega) от Atmel — широко распространена (Ардуино), весьма неплоха, так что не вижу причин не рассмотреть ее, тем более что для нее программа как раз и была написана. Ширина регистров — 8 разрядов, слова программ — 16, слова данных — 8, шины адреса — 16, адресное пространство перекрывается и имеет две секции (программ и данных), есть две различные команды для чтения из разных секций, регистры могут образовывать регистровые пары.
Третья архитектура — несомненный лидер в настоящее время, Cortex-M от фирмы ARM, так что не вижу возможности ее не рассмотреть. Не буду уточнять конкретную реализацию, тысячи их. Ширина регистров — 32 разряда, слова программы — 32 разряда (16 в режиме Thumb), слова данных — 32 разряда, шины адреса — 32 разряда, адресное пространство линейное и совмещенное, все команды однородны.
Несомненно, существует еще множество достойных рассмотрения архитектур, но одни из них представляют только исторический интерес (i8048, PDP8), другие не столь распространены (Sparc, MIPS, PDP11/78), третьи я знаю весьма поверхностно (PIC,Scenix), а четвертые мне откровенно не нравятся (HC08, х86). Тем не менее, интересные решения из этих МК также будут упоминаться, но основное внимание будет уделено четырем ранее перечисленным.
Итак, сформулируем задачу точно — нам необходимо поместить в регистр процессора некоторое наперед заданное число, причем его значение статически определено в момент компиляции (константу). Каким образом мы это можем сделать и какие преимущества и недостатки каждого из возможных методов — рассмотрим подробнее.
Первый и очевидный способ — прямая загрузка — константа является частью команды непосредственно, то есть собственно слово команды состоит из кода операции и самой константы в чистом виде. Данный способ лишен каких-либо недостатков, которые так или иначе свойственны другим методам, но… он должен быть применим практически, а это означает, что ширина слова программы должна быть больше ширины регистра (П>Р), иначе реализовать такие команды мы просто не сможем. Причем не просто больше, а значительно больше, чтобы можно было реализовать более, чем одну команду загрузки (или, по крайней мере, загрузки более чем в один регистр). Этим способом прекрасно пользуется МК типа 2, но для остальных рассматриваемых он просто невозможен, поскольку у них главное условие не выполняется.
Чтобы изменить соотношение ширины регистра и слова программ, и обеспечить условие Р<П, у нас есть два способа (и оба очевидны) — либо уменьшить первое значение, либо увеличить второе.
Для начала пойдем первым путем и предложим непрямую загрузку — когда в команде вместо константы «в чистом виде» шириной Р лежит, занимающая меньше места, информация о ее формировании Р'<Р — в той или иной форме такой метод применяют все архитектуры. Ведь команда очистки (CLR) является командой загрузки специального значения 0, причем сама константа в неявном виде присутствует в коде команды. В некоторых архитектурах также имеется команда установки всех битов регистра (SET), а команда увеличения на единицу позволяет провести операцию с константой 1 и есть практически повсюду. Далее возможны различные модификации метода, связанные с особенностями конкретного МК и уровнем фантазии его разработчиков.
Например, в STM8 (кстати, великолепный МК, особенно учитывая его цену, и мне непонятно, почему он не стал стандартом де-факто в свое время) введен специальный регистр констант и, в сочетании с разными способами адресации, это позволяет задать 5 наиболее часто встречающихся констант (-1,0,1,2,4).
Другой подход показала фирма ARM, которая кодирует в поле константы два двух-битовых поля XX и YY, а также кодирует способ их использования, что позволяет сформировать множество констант, начиная от простейших (0,1,2,-1,2) и заканчивая полосатиками (010101...). При этом надо понимать, что количество возможных констант не превосходит 2^(длина поля кодировки). Метод непрямой загрузки сохраняет все преимущества прямой загрузки, такие, как однородность потока исполнения, равномерность загрузки конвейера и также почти не имеет недостатков, за исключением ограниченности.
Продолжаем двигаться первым путем и уменьшим ширину регистра Р. На первый взгляд, абсурдная идея, ведь мы не можем этого сделать – оказывается, можем, но для этого нам надо представить регистр в виде набора сегментов меньшей ширины и оперировать поочередно с ними по отдельности.
Яркий пример такого подхода — архитектура MIPS, в которой есть команды загрузки младшей и старшей половины регистра. За счет чего мы можем выиграть, ведь для загрузки всего регистра нам потребуется выполнить целых две команды? А выигрыш достигается за счет того, что многие типовые константы можно получить, загрузив только младшую половину слова и расширив ее старший бит в старшую половину, то есть любое число от -2^(Р/2) до 2^(Р/2)-1 можно получить за одну команду. А если еще и добавить двух-битовое поле и закодировать в нем одну из 4 возможных операций для старшей части (очистить, установить, расширить знак, повторить младшую), то количество формируемых констант увеличится еще больше. Но тут главное — вовремя остановиться поскольку любое такое расширение сокращает количество остальных команд.
Теперь двинемся по второму пути и начнем увеличивать ширину памяти П. Поскольку мы не желаем существенно менять параметры архитектуры, то у нас остается единственный способ — сформировать новую общность из более, чем одной команды, и интерпретировать ее как команду расширенной длины П'>П. Назовем данный способ непосредственной загрузкой, как назывался аналогичный способ адресации в архитектуре 0. То есть команда остается стандартной длины и в ее теле нет никакой информации собственно о константе, но следующее за данной командой слово программ рассматривается как сама константа. Отметим, что для применимости данного способа необходимо условие П>=Р и это накладывает ограничения на архитектуру МК, но существенно менее слабые, чем для прямой загрузки. Кроме того, никто не мешает нам расширить данный подход и, при необходимости, использовать более, чем одно слово программ для представления константы.
Поскольку такой способ используется чуть менее, чем всегда, рассмотрим его подробнее. Конкретная реализация возможна как в виде обычной команды пересылки со специальным способом адресации (027 в моей любимой архитектуре), так и в виде специальных команд загрузки (LDI). Преимущество очевидно — мы можем сформировать абсолютно любую константу произвольной длины, и реализация в железе такого подхода весьма несложна. Недостатки не столь очевидны, но они есть — увеличивается время исполнения команды (по крайней мере на время выборки второго и последующих слов программы), нарушается регулярность команд (что затрудняет де-ассемблирование), возникает неоднородность загрузки конвейера исполнения (если он есть). И последний (не уверен, что он последний, но я больше придумать не могу), но не последний недостаток — избыточность по памяти, то есть всякий раз при появлении константы в коде под нее отводится место в памяти программ. Оно отводится и в случае с ранее описанными методами, но там мы все равно не могли использовать часть команды, применяемую для хранения константы, для других целей (честно говоря, утверждение спорное для VLIW архитектур, но мы такие не рассматриваем), так что все было не так плохо, но тут мы должны всякий раз выделить дополнительное слово памяти и этот недостаток начинает резко бросаться в глаза. Но никуда не деться, «за все в этом мире нужно платить».
На этом тему с прямой и непосредственной загрузкой константы в регистр можно считать завершенной — мы рассмотрели все возможные способы ее реализации и видим, что наряду с несомненными достоинствами данный метод либо имеет ограниченное применение либо выдвигает существенные требования к параметрам архитектуры МК, либо вызывает увеличение объема программы.
Но у тех, кто знакомился с МК на примере архитектуры 0 (еще раз настоятельно рекомендую с ней ознакомиться, более прозрачной и чистой реализации, а равно и понятного описания, мне не встречалось), сразу же возникнет вопрос, а не может ли нам помочь косвенная адресация (код 037) в ее различных формах? Разумеется, правильный ответ «да», иначе бы я этот вопрос не задавал, но все не так просто. Прежде всего, немного по сути данного метода — в команде содержится информация не об операнде (в данном случае константе), а о ее расположении в адресном пространстве, откуда собственно константа и может быть извлечена. Разумеется, данный метод в применении к константам может быть приемлем только в том случае, если эта адресная информация имеет меньшую ширину (и существенно меньшую) нежели ширина регистра. То есть мы можем (в архитектуре 0) вместо собственно константы шириной 16 бит указать ее адрес той же самой ширины, но в том случае мы сохраняем все недостатки прямого способа, и даже несколько усугубив проблемы с временем исполнения команды, и при этом совсем ничего не имея взамен. Если мы рассмотрим упомянутые мной архитектуры, то ни в одной из их условие А<Р не выполняется, поэтому способ представляется слабо реализуемым. Но, как всегда, есть нюансы.
Во-первых, можно уменьшить ширину адреса выделением специальных регионов (и созданием специальных команд для работы с этими регионами), как сделано в уже опоминавшейся STM8, где адрес в общем случае имеет ширину 24 разряда, но есть специальный префикс работы с младшими 64Кбайтами (мда, младшие 64 кило в кристалле МК, как бы я смеялся над подобным предположением в годы своей юности, когда расширитель адреса присутствовал только в СМ4, где процессорный модуль занимал половину двухметровой стойки) и в этом случае ширина адреса составляет только 16 бит, а при работе с первыми 256 байтами адресного пространства и вообще 8 бит. Но этот способ представляет более теоретический интерес, поскольку так доступ к константам в рассматриваемых архитектурах не реализован.
Второй способ значительно более перспективен и в архитектуре 0 имеет название «индексная» либо «косвенная со смещением» (код 06х). Как всегда, немного подробностей — в данном способе адрес операнда (для нас константы) формируется путем сложения значения индексного регистра (иногда в роли последнего может выступать любой из РОН — архитектура 0, иногда только некоторые из них — 1,3, иногда специальные регистровые пары — 2) и значения смещения, которое и задается собственно в команде. Конечно, если нам потребуется предварительно задать значение индексного регистра, то мы ничего не можем выиграть в принципе, но есть два варианта, которые делают такой подход приемлемым. Первый из них — организация пула констант, установка указателя на него в некоторый регистр и дальнейшая адресация при помощи смещения, что нам даст выигрыш при значительном количестве констант, но ценой занятия регистра, что не всегда может быть приемлемо. А вот второй путь значительно интереснее — использование в качестве индексного регистра счетчика команд, поскольку мы (ну не мы а компилятор, но какая разница) точно знаем его значение в момент исполнения любой команды, поэтому применение к нему смещения даст совершенно однозначный результат, причем совершенно бесплатно, ведь мы не собирались (а часто и не могли) использовать счетчик команд, как регистр общего назначения. Конечно, у данного способа есть свои ограничения, поскольку мы (в целях экономии) используем не слишком длинное смещение, поэтому такой локальный пул констант будет доступен не из всего кода программы, но мы существенно сэкономим, по крайней мере в длине команды, а вот со временем исполнения все не столь однозначно.
Чтобы прояснить свое последнее утверждение, рассмотрим еще раз организацию памяти в МК, и вспомним, что имеется по меньшей мере два вида памяти — программ и данных, причем отличаются они не названием и не расположением в адресном пространстве, а физическими принципами функционирования (существует и ряд реализаций, например для MSP430, в которых оба вида памяти реализованы на одном универсальном носителе FRAM и принципиально не различимы, но особо успешными такие семейства пока назвать трудно, что напоминает об известной фразе «Кто такой универсал? Это человек, который умеет делать множество разнообразных дел одинаково плохо», поэтому мы не будем внимательно подобные реализации рассматривать). А раз у нас есть различные физические носители, то и обращение к ним осуществляется по-разному и они могут (и будут) иметь различные параметры, характеризующие, в том числе, и время доступа к ним.
Поскольку память программ (или часть ее) должна быть энергонезависимой, иначе мы не сможем обеспечить функционирование устройства, и это несомненное преимущество, а существует еще и память данных, было бы логично предположить, что последняя тоже имеет какие-то преимущества, иначе ее применение трудно объяснить. Действительно, память данных существенно быстрее с точки зрения записи (вернее будет сказать, что память программ существенно медленнее, но на результате сравнения это не сказывается), физический размер ячейки памяти данных существенно меньше, она проще интегрируется с собственно МК с точки зрения технологии изготовления и так далее, но есть еще одно преимущество, важное для обсуждаемого вопроса — она, как правило, быстрее на операциях чтения (последнее верно только для статической памяти, но мне пока внутри МК динамическая память не встречалась, хотя кто знает, что ждет нас впереди). Разные производители прибегают к различным ухищрениям, чтобы такой несомненный недостаток памяти программ не оказывал влияния на быстродействие МК в целом, но тут на так много вариантов и практически единственный реально реализуемый — буфер в том или ином виде, своего рода кэш программ. Он может быть реализован в явном виде, может быть скрытым, может быть просто реализован в виде увеличенной ширины слова чтения из памяти программ, но все эти методы увеличивают скорость считывания для последовательно расположенных ячеек памяти и в случае произвольного доступа не слишком эффективны.
Возвращаясь к рассматриваемой методике размещения констант и индексной их адресации, видим, что, поскольку мы используем индексную адресацию относительно счетчика команд, то и константы будет расположена в памяти программ и нам придется ее читать именно оттуда. Поэтому после дешифровки команды и формирования исполнительного адреса нас ожидает утомительная процедура считывания из памяти программ константы. Конечно если у нас обращение к памяти программ идет словом расширенной ширины и мы хорошо выровняли свою константу, то мы можем сразу прочитать ее всю, например в режиме Thumb в архитектуре 3, но задержка на первое чтение неизбежна. Конечно, можно совместить фазу адресации с декодированием следующей команды, поскольку она уже двигается по конвейеру и нам не придется пропускать фазу, как в случае непосредственного представления, но тут мои рассуждения носят несколько умозрительный характер. Поэтому мне не очень понятны резоны, подвигнувшие ARM на подобное решение, вполне возможно, что при нахождении программы в специальном разделе памяти данных будет существенный выигрыш за счет загрузки конвейера, который компенсирует ожидаемые потери.
Немного расширим тему обсуждения и поговорим о размещении в памяти не просто одиночной константы, а набора их, например, текстовой строки либо дескриптора устройства. Мы можем организовать такой набор в виде массива и разместить данный массив либо в памяти программ, либо в памяти данных. Последняя фраза подразумевает, что у нас есть возможность сделать свой осознанный выбор, а не полагаться на мнение компилятора. Одна из моих претензий к системе Ардуино — то, что в ней данный выбор сделать, конечно, можно, но уж больно неудобным способом, который заставляет вспомнить фразу «Есть три способа сделать что-либо — способ правильный, способ неправильный и способ военно-морского флота». Я бы предпочел, чтобы такой выбор делался языковыми средствами, на худой конец, над-языковой прагмой, но никоим образом не созданием специальной функции для чтения константы. Конечно, когда у нас линейное адресное пространство, то реализация обращения к разным областям памяти сводится к передаче информации компоновщику, а в случае архитектур 1 и 2 все намного сложнее, но это еще не повод делать плохо (ну или, скажем мягче, недостаточно хорошо).
Покончив с процессом размещения, давайте подробнее рассмотрим плюсы и минусы обоих подходов. Константы в памяти программ:
1+. Они находятся на своем месте (в постоянной памяти) и не могут быть модифицированы никоим образом, а, если у Вас хорошая и развитая архитектура, то Вы можете отследить попытки их модифицировать (в случае программного сбоя) и получить исключение.
2+. Они занимают минимально возможное место в памяти данных (не занимают вовсе, меньше уже никак не сделать), а это часто дефицитный ресурс и занимают минимально возможное место в памяти программ (ровно столько, сколько действительно необходимо), этот ресурс обычно не столь дефицитен, но все равно память программ — она как Москва, не резиновая.
3+. Они готовы к работе сразу после включения устройства, что бывает немаловажно при выводе диагностических сообщений.
1-. Они, как правило, медленнее в работе сами по себе и часто обращение к ним организуется при помощи более медленных команд, нежели обращение к памяти данных, что процесс работы с ними не ускоряет.
2-. Они находятся в постоянной памяти и не могут быть модифицированы в принципе (обратите внимание, только что я это хвалил), вот такой я непостоянный.
Константы в памяти данных:
1-. Они находятся не на своем месте и могут быть модифицированы при сбое программы (надеюсь, вы не возлагаете особых надежд на ключевое слово const, если возлагаете, то должен вас огорчить — существует множество способов изменить значение переменных с таким атрибутом), и только если Вы имеете дело с очень хорошей архитектурой, то Вы получите исключение.
2-. Они занимают вдвое больше адресного пространства, чем необходимо (и даже еще больше), поскольку они не могут просто так появиться в памяти данных, а должны первоначально располагаться в памяти программ (вот оно вдвое) и переноситься из одной памяти в другую программой инициализации (а вот оно и больше).
3-. Они недоступны после включения.
1+. Они, как правило, быстрее в доступе и обращение к ним может сэкономить память программ за счет отказа от дублирования часто встречающихся констант.
2+. Они могут быть модифицированы при необходимости, что может потребовать аккуратного программирования, если у Вас очень хорошая архитектура (наконец то объясню, что я имел в виду под этим сочетанием слов — наличие механизма защиты сегментов адресного пространства и контроля доступа к ним).
3+. Они используются по умолчанию во многих архитектурах и системах программирования, и, в определенном смысле, естественны.
Рассмотрев все плюсы и минусы, мы можем определить, когда набор констант в памяти программ однозначно предпочтительнее: если у Вас дефицит памяти данных или если этот набор используется только один раз в программе (например, для выдачи приветственной строки). Если Вам необходима модификация набора, то единственное возможное решение — набор констант в памяти программ. Все остальные случаи можно отдать на усмотрение компилятора, ведь теперь Вы делаете это вполне осознанно, зная возможные последствия.
Ну а теперь вернемся к случаю, с которого начался данный пост, то есть одиночная, однократно встречающаяся и редко используемая константа шириной в целое (но с различными значениями) и рассмотрим приемлемость подхода с константой в памяти данных против памяти программ для разных архитектур. Сразу оговоримся, что считаем количество переменных значительным, чтобы избежать ситуации с размещением константы (или указателя на нее) в РОН, что кардинально меняет оценку применимости метода.
Настоятельно рекомендую проверить следующие мои высказывания путем просмотра кода, сгенерированного С компилятором, для чего можно обратится к ресурсу godbolt.org, установив режим оптимизации -О2 и выбирая архитектуры msp430, mips, avr, arm.
Архитектура 0. Размещение в памяти данных потребует больше места в памяти программ, больше места в памяти данных и будет исполняться однозначно медленнее — никаких оснований для подобного решения нет.
Архитектура 1. Можно переписать предыдущую фразу слово в слово.
Архитектура 2. Ситуация даже становится еще хуже для предлагаемого метода, поскольку для констант, умещающихся в байт, существует команда adiw, что улучшает быстродействие другого способа.
Архитектура 3. А вот тут есть шансы — если программа размещена в памяти данных (многие реализации этой архитектуры поддерживают такую возможность), то индексное обращение к памяти данных может оказаться быстрее, чем извлечение константы из памяти программ, так что быстродействие можно повысить, правда, за счет увеличения размера секции данных и программы. Но если константа может быть образована путем кодирования, то вариантов нет — размещение в памяти программ выигрывает безоговорочно.
Подведем итог — размещать одиночные константы в памяти данных не следует практически никогда (за исключением возможности использования регистров), в общем, мы об этом догадывались и раньше, но теперь можем утверждать это с полной уверенностью, и по дороге узнали немного интересных вещей. Тогда зачем же это сделано в рассматриваемом коде — единственное, придуманное мною объяснение — так получилось, ну или еще один вариант «ну работает же». Возможно, у автора есть религиозные обеты, например, не использовать дефайны, или он где то прочитал, что макросы есть зло и их следует избегать (тоже вид религиозного обета). В общем, у него были свои мотивы, я в них проникнуть не могу, но надеюсь, что после прочтения настоящего текста Вы на эту стезю не вступите.
И в заключение — небольшое напоминание на тот случай, если Вы решитесь модифицировать константы «на месте», без создания копии. В этом случае Вы можете наблюдать весьма забавное явление (ну это на взгляд внешнего наблюдателя забавное, Вам будет не столь весело).
Заключается оно в том, что некоторые компиляторы для идентичных констант, особенно строковых, выделяют место только один раз, поэтому, изменив одну из них, Вы можете обнаружить, что изменилась и другая. Конечно, если у вас хорошая архитектура, то Вы получите ошибку времени исполнения, но если у Вас ее нет, то увлекательные поиски обеспечены. «Всего лишь неделя отладки может сэкономить Вам час на продумывание архитектуры программы». Возможно, существуют опции, предотвращающие подобное поведение компилятора, но лично я их не знаю, и, скорее всего, они будут непереносимы. Поэтому к данной методике, несмотря на ее привлекательность в некоторых аспектах, следует относиться, как к грязному трюку и всячески ее избегать, если у Вас нет веских оснований для иного поведения. «Да не убьет одно животное другое… без веской причины».
Кстати, я все таки созрел для написания большой работы по проектированию библиотеки для периферийного устройства в МК, и в настоящий момент нахожусь перед непростым выбором, что взять, как пример для реализации: UART с переходом в Modbus, SPI с переходом в SD карточки, либо USB с переходом повсюду. Мои читатели меня крайне обяжут, если помогут мне с этим нелегким выбором.
Краткий план развития сюжета по любому из направлений:
1. Служба времени в МК (задержки),
2. Служба памяти в МК (буферы),
3. Реализация физического уровня интерфейса,
4. Программная реализация канального уровня,
5. Аппаратная реализация канального уровня,
6. Опрос, прерывания, ПДП,
7. Скрытие деталей реализации при помощи HAL,
8. Компромисс между переносимостью и эффективностью,
9. Модульная организация middleware,
10. Сопутствующие вопросы.
В настоящий момент я заканчиваю первые две части, которые не зависят от конкретного интерфейса, и раздумываю, в каком направлении двигаться дальше. Опрос Вас ждет, если эта тема Вам интересна. | https://habr.com/ru/post/329546/ | null | ru | null |
# Ясные печеньки
Привет, Хабр! В свете информации, посвященной безопасности аккаунтов крупных порталов, появившейся в последнее время, я решила немного пересмотреть cookie авторизацию в своих проектах. В первую очередь был допрошен с пристрастием гугл на тему готовых решений. Ничего толкового не нашлось, хотя может статься и так, что я не умею пользоваться поиском. После этого я решила посмотреть, что же вообще пишут про то, как правильно жевать печенье. Моему удивлению не было границ, когда в основной массе оказались статьи из разряда «вредные советы», и то что я читала более 5-и лет назад.
Эта статья — попытка исправить сложившуюся ситуацию.
Для многих нижеизложенное покажется очевидным, но, думаю, найдется и не мало тех, для кого эта информация окажется полезной. В ходе изысканий и размышлений на тему: «как поступать простым смертным, не имеющим субдоменов», был придуман ~~велосипед~~ подход, на авторство которого я не претендую, ибо, как сказано выше, существует отличная от нуля вероятность того, что я не умею пользоваться поиском. В примерах будет использоваться PHP, так как это самый популярный среди меня язык, но и у людей с более тонкой душевной организацией не должно возникнуть проблем с пониманием происходящего. Итак, приступим.
Печенье мы будем хранить как в лучших домах Филадельфии: в красивой жестяной коробочке. То есть при авторизации устанавливается сookie для единственного каталога, отличного от document root. В дальнейшем эта cookie используется только в том случае, когда сессия не установлена, или данные (IP-адрес ~~жерт~~пользователя) не валидны. На странице проверки cookie не должно быть никакого динамического содержимого.
Теперь давайте рассмотрим алгоритм подробнее.
Для начала нам понадобится SQL таблица со следующей структурой:
```
CREATE TABLE `user_auth_cookies` (
`key` char(32) NOT NULL,
`user_id` int(10) unsigned NOT NULL,
`logged_in` datetime NOT NULL,
PRIMARY KEY (`key`),
KEY `user_id` (`user_id`),
KEY `logged_in` (`logged_in`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
кое-какие предустановки, и небольшой класс User:
```
$db = new mysqli('localhost', 'test', '', 'test');
if ($db->connect_errno) die('Не удалось подключиться к MySQL: ('.$db->connect_errno.') '.$db->connect_error);
// думаю тут все понятно
define('DOMAIN', ($_SERVER['HTTP_HOST'] !== 'localhost' ? $_SERVER['HTTP_HOST'] : false));
// Доменное имя сайта. Если localhost, то false (в противном случае куки не выставятся как надо)
define('AUTO_AUTH_URL', '/auth/auto'); // ссылка на страницу автоматической авторизации
define('AUTH_URL', '/auth'); // ссылка на форму авторизации
define('AUTH_COOKIE_DURATION', 20); // временной интервал в днях, на который следует устанавливать куки
define('USE_HTTPS', false); // использовать HTTPS для передачи кук (для счастливых обладателей подписанных сертификатов)
class User {
private $_id;
public $isGuest = true;
public $name = 'Гость';
public function __construct() {
GLOBAL $db;
if (!isset($_SESSION['user']) || $_SESSION['user']['ip'] !== $_SERVER['REMOTE_ADDR'])
return;
$query = 'SELECT * FROM users WHERE `id` = '.(int)$_SESSION['user']['id'];
if (($res = $db->query($query)) !== false && $res->num_rows) {
$user = $res->fetch_assoc();
$this->_id = $user['id'];
$this->name = $user['name'];
$this->isGuest = false;
if (isset($_SESSION['last_request'])) {
$_POST = $_SESSION['last_request']['data'];
unset($_SESSION['last_request']);
}
} else {
unset($_SESSION['user']);
}
}
public function getId() {
return $this->_id;
}
}
```
Как видно, используются две сессионные переменные, одна из них (user) непосредственно для авторизации, а вторая (last\_request) для сохранения URI, с которого потребовался запрос авторизации, и параметров POST, чтобы не потерялись данные отправляемые формы, если таковые имелись.
Для авторизации используется класс Auth, содержащий 4 статических метода.
```
class Auth {
public static function loginRequired() {
$_SESSION['last_request'] = array(
'url' => $_SERVER['REQUEST_URI'],
'data' => $_POST
);
header('Location: '.AUTO_AUTH_URL);
die('Перенаправление...');
}
public static function login($login, $password, $remember = false) {
GLOBAL $db;
$query = "SELECT * FROM users WHERE `login` = '".$db->real_escape_string($login)."';";
if (($res = $db->query($query)) === false || !$res->num_rows)
return false;
$user = $res->fetch_assoc();
// это для примера, проверка может быть абсолютно любой
if ($user['password'] !== md5($login.md5($password)))
return false;
if ($remember) {
do {
$key = md5(mcrypt_create_iv(30));
$query = "SELECT COUNT(*) AS `cnt` FROM user_auth_cookies WHERE `key` = '".$key."';";
$count = 0;
if (($res = $db->query($query)) !== false && $res->num_rows) {
$row = $res->fetch_assoc();
$count = (int)$row['cnt'];
} else
die('Ошибка запроса к БД.');
} while ($count > 0);
$db->query("INSERT INTO user_auth_cookies VALUES ('".$key."', ".$user['id'].", NOW());");
setcookie('key', $key, strtotime('+'.AUTH_COOKIE_DURATION.' days'), AUTO_AUTH_URL, DOMAIN, USE_HTTPS, true);
}
$_SESSION['user'] = array(
'id' => $user['id'],
'ip' => $_SERVER['REMOTE_ADDR'],
);
return true;
}
public static function loginByCookie() {
GLOBAL $db;
$location = AUTH_URL;
if (isset($_COOKIE['key'])) {
$query = "SELECT user_id FROM user_auth_cookies WHERE `key` = '".$db->real_escape_string($_COOKIE['key'])."';";
if (($res = $db->query($query)) !== false && $res->num_rows) {
$row = $res->fetch_assoc();
$_SESSION['user'] = array(
'id' => $row['user_id'],
'ip' => $_SERVER['REMOTE_ADDR']
);
$location = '/';
if (isset($_SESSION['last_request']))
$location = $_SESSION['last_request']['url'];
}
}
header('X-Frame-Options: DENY'); // защита от встраивания в FRAME/IFRAME
header('Location: '.$location);
die('Перенаправление...');
}
public static function logout() {
if (!isset($_SESSION['user']))
return;
if (mb_strlen($_SESSION['user']['key']) === 32)
$db->query("DELETE FROM user_auth_cookies WHERE `key` = '".$db->real_escape_string($_SESSION['user']['key'])."';");
setcookie('key', '', 0, AUTO_AUTH_URL, DOMAIN, USE_HTTPS, true);
unset($_SESSION['user']);
header('Location: /');
die('Перенаправление...');
}
}
```
Auth::loginRequired() вызывается, если пользователь не авторизован и переходит на страницу, требующую авторизацию. Метод сохраняет текущий URI и параметры POST запроса в сессионную переменную (сохранение POST данных нужно, если пользователь писал длинный гневный пост, и у него в этот момент сменился IP), и перенаправляет на страницу автоматической авторизации по cookie.
В контексте класса User:
```
……
$user = new User();
if ($user->isGuest)
Auth::loginRequired();
……
```
Auth::login($login, $password, $remember = false) вызывается, если получена форма авторизации. Параметр $login внезапно содержит полученный логин, $password не менее внезапно — пароль, $remember – флаг отвечающий за установку куки.
Пример использования:
```
……
if (isset($_POST['login']) && Auth::login($_POST['login'], $_POST['password'], !!$_POST['remember_me'])) {
$location = '/';
if (isset($_SESSION['last_request']))
$location = $_SESSION['last_request']['url'];
header('Location: '.$location);
die('Перенаправление...');
}
……
```
Auth::loginByCookie() вызывается на странице автоматической авторизации. Напомню, что во избежание неприятных ситуаций на этой странице не должно быть никакого динамического вывода, и не надо ничего подгружать из других директорий, тем более доменов. И вообще на директорию скрипта не плохо бы установить RewriteRule, перенаправляющее абсолютно все запросы на этот скрипт. Допустим так:
*.htaccess*
```
RewriteEngine On
RewriteCond %{REQUEST\_FILENAME} !-U
RewriteRule ^.\*$ index.php [L,QSA]
```
Auth::logout() вызывается для «разлогинивания» пользователя. Очищает куку и сессионную перемнную, удаляет за ненадобностью ключ из базы, и перенаправляет на главную.
Остался последний штрих. Необходимо периодический (по cron) очищать таблицу от устаревших ключей.
```
……
$db->query("DELETE FROM user_auth_cookies WHERE `logged_in` < DATE_SUB(NOW(), INTERVAL ".AUTH_COOKIE_DURATION." DAYS);");
……
```
Также можно добавить на сайт кнопку типа: «Разлогинить меня на всех устройствах», при нажатии на которую удаляются все ключи авторизации из таблицы user\_auth\_cookies по user\_id. Это нужно если пользователь, например, забыл нажать на «Выход» на чужом компьютере, или у него украли мобильное устройство, с которого он посещал ваш сайт.
```
……
if (isset($_POST['signout_all']) {
$db->query("DELETE FROM user_auth_cookies WHERE `user_id` = ".$user->getId());
Auth::logout();
}
……
```
На любителя можно добавить проверку user agent, или еще чего-то подобного, но, на мой взгляд, от этого не будет никакого толку потому, что, если куку решат угнать, то делать это будут вместе с user agent, и прочими подобными атрибутами.
На этом все, желаю вашему печенью оставаться всегда свежим и хрустящим. | https://habr.com/ru/post/210416/ | null | ru | null |
# Как я решил защищать документы от подделки и «изобрел» электронную цифровую подпись
О чем это
---------
На идею создать свой маленький интернет-проект по защите документов от подделки, меня натолкнула дискуссия на форуме дефектоскопистов, посвященная повальной подделке выданных ими заключений по контролю качества.
В ходе реализации своего проекта я понял, что пришел к концепции электронной цифровой подписи, то есть велосипед, я, конечно, не изобрел, но рассказ о моем пути может оказаться поучительным.
Актуальность задачи защиты от подделок
--------------------------------------
Дело в том, что в наш век безбумажной информации ни одно капитальное строительство, будь то газопровод или торговый центр, не обходится без подготовки полного комплекта исполнительной документации (as built), частью которой являются заключения по неразрушающему контролю (визуальному, радиографическому, ультразвуковому).
Это заключение — оформленный на определенном бланке документ с выводом о годности или негодности, к примеру, сварного шва. Услуги по неразрушающему контролю стоят денег и часто весьма немалых. Недобросовестный заказчик/посредник может нанять аккредитованную лабораторию, получить от нее несколько заключений и прекратить или приостановить работу.
Каково же может быть удивление дефектоскописта или начальника лаборатории, когда они узнают о том, что и после прекращения работы от их имени выдаются заключения, на них ставятся поддельные печати и подделываются подписи. Страдает репутация лаборатории, да и по сути нарушается законодательство. Просто в ряде случае об этом так никто и не узнает.
В рамках дискуссии — как защитить свои документы, была высказана идея наносить на документ QR-код, в котором будет записан номер заключения, дата и вывод о годности или не годности объекта контроля. Чем хорош такой способ — QR-код останется хорошо различим при сканировании, копировании документа.
Однако, просто сгенерировать QR-код с нужным содержимым точно также смогут и мошенники.
Рождение идеи
-------------
И тут меня осенила мысль — а почему бы не шифровать содержимое такого QR-кода надежным алгоритмом. Раз так — надо придумать способ его расшифровывать при сканировании, например через камеру смартфона. Здесь родилась идея расшифровку делать на стороне web-сервиса, который будет хранить ключ для расшифровки.
В последний раз я делал сайт в 2000 году в notepad и не слишком хорошо знаком с современными технологиями сайтостроительства, поэтому выбрал Wix, подумав, что с помощью сервиса я получу красивую картинку и минимальные возможности работы с базой данных, а с помощью Wix code закодирую то что мне нужно.
Сразу скажу, что это у меня получилось без особого труда и за несколько вечеров я, будучи дилетантом, вполне смог собрать из более-менее готовых блоков нужное мне решение.
Шифрование
----------
Готовый [алгоритм](https://github.com/ricmoo/aes-js) AES 128-битного шифрования с реализацией на Java Script я взял на Github и разместил в backend разделе сайта.
Это была, пожалуй, самая простая часть работы. Как работает само шифрование мне было не совсем неинтересно. Меня волновала грандиозность задуманного.
Главное не забыть перевести кодируемый текст в Bytes, а результат шифрования в HEX.
```
// Convert text to bytes
var textBytes = aesjs.utils.utf8.toBytes(text);
// The counter is optional, and if omitted will begin at 1
var aesCtr = new aesjs.ModeOfOperation.ctr(key, new aesjs.Counter(5));
var encryptedBytes = aesCtr.encrypt(textBytes);
// To print or store the binary data, you may convert it to hex
var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
```
Генерация QR-кода
-----------------
Я воспользовался готовым [API](http://goqr.me/api).
Для работы достаточно создать объект html1 — для отображения произвольного html кода и вызвать фунцию API
```
let val = “Шифруемый текст"
$w("#html1").src = "https://api.qrserver.com/v1/create-qr-code/?size=100x100&data=" + val.toString();
$w("#html1").show();
```
Работа с пользователями
-----------------------
Wix поддерживает базовые функции регистрации пользователей и редактирования профиля. Инструмент, несколько глючный, но работоспособный.
Мне лишь потребовалось добавить поле, которое описывает наименование организации, которую представляет зарегистрированный пользователь, но это поле read only и его заполняет администратор сервиса, когда получает подтверждение, что зарегистрированный пользователь действительно представляет указанную организацию.
Потребовалось также прикрутить простейшую логику, связанную с платным/бесплатным доступом к функциям (до 20 документов в месяц можно защитить бесплатно) и сроком оплаты услуг.
Принцип работы
--------------
К аккаунту пользователя привязывается уникальный закрытый ключ шифрования.
Залогиненый пользователь заполняет форму с информацией о заключении (номер, дата, результат):
Затем алгоритм выдает URL, содержащий зашифрованный текст TEXT и, выступающий в виде открытого ключа USER\_ID, как на примере ниже:
`https://*\*имя сервиса\**/checkqr?user=3b01b0aa-68a0-4521-ab12-f17b86d3eabc&v=1.0&text=8a026594c26be959f4280e28fe8402c1acef233e369a31613d654d3b0a5bbaca206f3058d27d2fde66b65cb64a5a6caecb69b07ad39c0015e923dad89eb723`
URL превращается в QR-код, который пользователь уже наносит на свой документ, скопировав в буфер обмена (можно включить в исходный файл или же налепить как стикер на готовый напечатанный документ).
[](https://protectmydoc.com/checkqr?user=3b01b0aa-68a0-4521-ab12-f17b86d3eabc&v=1.0&text=8a026594c26be959f4280e28fe8402c1acef233e369a31613d654d3b0a5bbaca206f3058d27d2fde66b65cb64a5a6caecb69b07ad39c0015e923dad89eb723)
Что здесь важно — как таковая информация не попадает в базу данных сайта, а остается лишь в виде этой ссылки и QR-кода, содержащего эту ссылку. Таким образом, никакая информация о содержимом защищаемого документа на сервере не хранится.
Проверка кода выполняется сайтом при распарсивании ссылки
---------------------------------------------------------
Для распарсивания при распознавании сайтом ссылки я воспользовался справкой по Wix code
[www.wix.com/code/reference/wix-http-functions.html](https://www.wix.com/code/reference/wix-http-functions.html)
Если при расшифровке что-то пошло не так, а это может быть, если в оригинальный QR-код попытались внести какие-то изменения
> «Код документа расшифрован с ошибкой. Возможна подделка. Обратитесь в организацию, подготовившую документ для получения пояснений»
Если расшифровка завершена успешно, то выдается расшифрованный текст, содержащий название лаборатории, номер документа, дату выдачи и результат, а пользователю предлагается сопоставить результат расшифровки с тем, что он видит на реальном документе.
Заключение
----------
От рождения идеи я с помощью ряда готовых кирпичиков пришел к работающей реализации.
Приглашаю к дискуссии по придуманной мной идее, попытке протестировать/взломать мой сервис.
#### Что еще осталось доделать
* ~~Написать по итогам реализации на habr~~
* Разобраться как сбросить query, если один раз уже была проверка ссылки
* Придумать как ужать зашифрованный текст, потому что когда длинный URL кодируется, то размер QR-кода чересчур большой
* Добавить возможность копирования кода в буфер обмена или отправлять на почту по щелчку на кнопку (пока не разобрался как сделать это в javascript)
* Улучшить работу с мобильной версией
#### Предварительный ответ на возможную критику:
> Не проще лаборатории вести реестр заключений на своем сайте, а подобная QR метка будет вести на этот реестр или даже выводить копию заключения?
Это можно сделать, но потребуется значительная ручная работа или внедрение собственного IT решение наподобие разработанного мной, но это явно обойдется дороже чем воспользоваться готовым решением.
Сделать такой реестр полностью общедоступным нельзя, потому что информация не является открытой, а может быть рассмотрена лишь исполнителем, заказчиком и Ростехнадзором. | https://habr.com/ru/post/442210/ | null | ru | null |
# Реализации машины в qemu
В процессе обратной разработки прошивок иногда возникает задача по ее эмуляции, например, для фаззинг тестирования или детального изучения поведения в динамике. На практике обычно для этого хватает фреймворков avatar2, unicorn, qiling и подобных. Однако они поддерживают далеко не все платформы и имеют ряд ограничений для решения таких задач. При разработке эмулятора PLC я столкнулся с тем, что ни один фреймворк для эмуляции не поддерживал требуемую платформу.
Частично эти ограничения снимает разработка эмулятора на базе qemu, однако статей по этой тематике в сети достаточно мало, а официальная документация не содержит примеров реализации простых девайсов. В этой статье я хотел бы восполнить этот недостаток и поделиться своим небольшим опытом по реализации машины в qemu, чтобы сэкономить время начинающих разработчиков и исследователей безопасности, сталкивающихся с похожей задачей.
Полезные статьи по теме:
<https://habr.com/ru/post/522378/>
<https://habr.com/ru/post/466549/>
<https://airbus-seclab.github.io/qemu_blog/>
<https://github.com/Gyumeijie/qemu-object-model>
<https://qemu.readthedocs.io/en/latest/devel/index.html>
Для начала соберем свежий образ qemu
```
git clone https://github.com/qemu/qemu.git
```
В качестве примера будем писать машину под платформу aarch64, поэтому собираем только ее
```
cd qemu
mkdir build
cd build
../configure --target-list=aarch64-softmmu --without-default-devices
make -j 4
```
Для проверки доступных машин можно выполнить следующую команду
```
./qemu-system-aarch64 -M ?
```
Итак, приступим. Для начала в файл конфигурации Kconfig в основной папке платформы добавляем новый тип, описывающий конфигурацию нашей машины, сюда в дальнейшем будем добавлять зависимости самой машины
```
config EDU_AARCH64
bool
```
В файл meson.build допишем строчку с параметрами сборки
```
arm_ss.add(when: '{CONFIG_EDU_AARCH64}', if_true: files('edu_aarch64.c'))
```
Далее реализуем саму машину в простейшем варианте:
```
#include "qemu/osdep.h"
#include "hw/boards.h"
static void arm_edu_init(MachineState *mcs)
{
}
static void arm_edu_machine_init(MachineClass *mc)
{
mc->desc = "Education machine";
mc->init = arm_edu_init;
}
DEFINE_MACHINE("arm_edu", arm_edu_machine_init)
```
В этом фрагменте кода происходит примерно следующее: при помощи макроса `DEFINE_MACHINE`, объявленного в заголовке `"hw/boards.h"`, объявляется новая машина. Макрос регистрирует новый тип данных наследуемый от`TYPE_MACHINE`, объявляет подобие базового конструктора класса, в котором преобразует переданную область памяти к структуре `MachineClass` и передает управление в функицю `arm_edu_machine_init`, где в дальнейшем мы имеем возможность заполнить эту структуру.
Приведу наиболее интересный ее фрагмент с небольшими комментариями:
```
struct MachineClass {
...
char *name; // Имя машины, заполняется макросом DEFINE_MACHINE
const char *alias;
const char *desc; // Описание отображаемое при выводе списка машин
...
// Таблица с виртуальными функциями под каждое событие
void (*init)(MachineState *state);
void (*reset)(MachineState *state);
void (*wakeup)(MachineState *state);
...
ram_addr_t default_ram_size; // Размер RAM по умолчанию, передается в класс MachineStatetate
// если пользователь не указал другой размер в параметрах
const char *default_cpu_type; // CPU по умолчанию, передается в класс MachineState
...
};
```
Подробнее с этой структурой можно ознакомиться в том же заголовочном файле где объявлен макрос.
Для того, чтобы скрипт сборки добавил и нашу машину, ее необходимо включить в файле конфигурации, например в `configs/devices/aarch64-softmmu/default.mak`. После этого можно повторно собирать qemu.
После сборки проверяем наличие нашей машины в списке доступных. Если все прошло хорошо, результат будет примерно такой:
```
$./qemu-system-ppc -M ? |grep arm_edu
arm_edu Education machine
```
Если попытаться запустить машину, то ничего не произойдет, поскольку отсутствует реализация инициализации, т.е. машины как таковой пока еще не существует. Попробуем это исправить дополнив исходный файл с машиной:
```
...
#include "qapi/error.h"
#include "hw/arm/arm_edu.h"
#include "hw/boards.h"
#include "exec/memory.h"
#include "hw/loader.h"
static void arm_edu_init(MachineState *machine)
{
MemoryRegion *rom = g_new(MemoryRegion, 1);
hwaddr firmware_addr = ROM_START_ADDR;
ARMCPU *cpu = NULL;
int res;
info_report("Loading cpu %s", machine->cpu_type);
cpu = ARM_CPU(cpu_create(machine->cpu_type)); // Создаем процессор
// подробнее о работе с регионами памяти в include/exec/memory.h
memory_region_add_subregion(get_system_memory(), RAM_START_ADDR,
machine->ram); // Добавляем инициализированную qemu RAM
memory_region_init_rom(rom, NULL, "ROM", MAX_FIRMWARE_SIZE,
&error_fatal); //инициализируем новый регион памяти
memory_region_add_subregion(get_system_memory(), firmware_addr,
rom);
if(!machine->firmware){
error_report("Firmware filename is required, use -bios option");
exit(EXIT_FAILURE);
}
info_report("Loading firmware %s", machine->firmware);
res = load_image_targphys(machine->firmware, firmware_addr, // include/hw/loader.h
MAX_FIRMWARE_SIZE); // Просим qemu загрузить файл в память
if (res < 0) {
error_report("Failed to load firmware from %s", machine->firmware);
exit(EXIT_FAILURE);
}
cpu->rvbar = ROM_START_ADDR; // Выставляем регистр RVBAR содержащий адрес
}
static void arm_edu_machine_init(MachineClass *mc)
{
...
mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-a72");
mc->default_cpus = 1;
mc->max_cpus = 1;
mc->default_ram_size = 256 * MiB;
mc->default_ram_id = "dram";
}
```
В заголовочный файл поместим объявление констант и архитектурные зависимости
```
#include "target/arm/cpu.h"
#define RAM_START_ADDR 0x10000000
#define ROM_START_ADDR 0x0
#define MAX_FIRMWARE_SIZE 0x8000000
```
Часть кода я по возможности постарался прокомментировать, однако более подробно с каждой из используемых функций рекомендую ознакомиться в заголовочных файлах.
Теперь, когда наша машина умеет полноценно запускать код, напишем небольшую прошивку для ее тестирования. Собирать при помощи gcc-aarch64 будем вот такой простенький код
```
.text
.globl entry
entry:
mov x1, #356
mov x2, #478
mul x0, x1, x2
b entry
```
Чтобы не лезть лишний раз в гугл
```
sudo apt install gcc make gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
aarch64-linux-gnu-as test.S -o test.o
aarch64-linux-gnu-objcopy test.o test -O binary
```
Наконец, запускаем qemu для теста
```
./qemu-system-aarch64 -M arm_edu \
-bios ~/firmware/test \
-s -S \
-nographic
```
Параметры `-s -S` используются для запуска gdb сервера на порту 1234, `-nographic` отключает графический дисплей. Для машин собранных с поддержкой такового qemu запускает его автоматически.
В соседнем окне подключаем gdb
```
gdb-multiarch -q
(gdb) target remote tcp::1234
```
Готово. На выходе имеем полноценно работающую машину, в которой уже можно частично отлаживать кусочки ассемблерного кода на уровне EL3.
В следующих статьях рассмотрим реализацию MMIO регистров, UART интерфейса, сетевой карты и виртуального таймера. | https://habr.com/ru/post/593495/ | null | ru | null |
# MU-MIMO: один из алгоритмов реализации
Предисловие
===========
В качестве дополнения к моей [недавней статье](https://habr.com/ru/post/448570/) хотелось бы также поговорить о теме MU (**M**ulti **U**ser) MIMO. Есть у мною уже упомянутого профессора Хаардта одна очень известная [статья](https://www.researchgate.net/publication/3318811_Zero-Forcing_Methods_for_Downlink_Spatial_Multiplexing_in_Multiuser_MIMO_Channels), где он вместе со своими коллегами предлагает алгоритм разделения пользователей по нисходящему каналу (Down Link) на основе линейных методов, а именно *блоковой диагонализации* (Block Diagonalization) канала. Статья имеет внушающее [количество цитирований](https://scholar.google.ru/scholar?hl=ru&as_sdt=0%2C5&q=Zero-Forcing+Methods+for+Downlink+Spatial+Multiplexing+in+Multiuser+MIMO+Channels&btnG=), а также является краеугольной публикацией для одного из заданий экзамена. Поэтому почему бы и не разобрать основы предлагаемого алгоритма?
Постановка задачи
=================
Во-первых, давайте определимся в какой области в тематике MIMO мы будем сейчас работать.
Условно, все методы передачи в рамках MIMO технологии можно разделить на две основные группы:
* **Пространственное разнесение** (spatial diversity).
Основной целью является увеличение помехоустойчивости передачи. Пространственные каналы, если упрощенно, дублируют друг друга, за счет чего мы получаем лучшее **качество** передачи.
Примеры:
— Блочные коды (например, [схема Аламути](https://nbviewer.jupyter.org/github/kirlf/CSP/blob/master/MIMO/Alamouti.ipynb));
— Коды, основанные на алгоритме Витерби.
* **Пространственное мультиплексирование** ([spatial multiplexing](https://www.mathworks.com/help/comm/examples/spatial-multiplexing.html)).
Основной целью является увеличение **скорости** передачи. Мы уже обсуждали в [предыдущей статье](https://habr.com/ru/post/448570/), что при определенных условиях канал MIMO можно рассматривать как ряд параллельных каналов SISO. Собственно говоря, это и есть центральная идея пространственного мультиплексирования: добиться максимального количества независимых информационных потоков. Главная проблема в данном случае — это подавление *межканальной интерференции (inter-channel interference)*, для чего существуют несколько классов решений:
— горизонтальное разделение каналов;
— вертикальное (например, алгоритм V-BLAST);
— диагональное (например, алгоритм D-BLAST).
Но и это, конечно, не всё.
Идею пространственного мультиплексирования можно расширить: разделять не только каналы, но и пользователей (SDMA — Space Division Multiple Access).
([ссылка на источник иллюстрации](https://wifi-solutions.ru/news/20170912/))
Следовательно, и бороться в этом случае уже нужно с интерференцией **межпользовательской (inter-user interference)**. Именно для этого и был предложен алгоритм под названием **Block diagonalization Zero-Forcing**, который мы сегодня и рассматриваем.
Математическое описание
=======================
Начнем, как и прежде, с модели принятого сигнала (received signal). А точнее, покажем на схеме что куда и из чего происходит:
Канальная матрица в этом случае имеет вид:
при общем числе передающих антенн , и общем числе приёмных антенн .
> **Важно**:
>
> Данный алгоритм может быть применён только при условии того, что количество передающих антенн больше или равно общему количеству приёмных антенн:
>
> 
>
>
>
> Это условие напрямую влияет на свойства диагонализации.
Итак, модель принятых символов (сигналов) можно записать в векторном виде как:
Однако, интереснее посмотреть на формулу для конкретного пользователя:
Собственно говоря:
*  — это полезный сигнал для k-ого пользователя,
*  — это интерференция от других пользователей,
*  — аддитивный шум.
Вот мы и подошли к формулировке главной задачи:
> Можно ведь найти такие матрицы , чтобы интерференционная часть обращалась в ноль!
Этим мы и займемся.
Описание алгоритма
==================
Описание проведем на примере, а в качестве иллюстрации я буду приводить скриншоты [из первых рук](https://web.stanford.edu/group/sarg/Presentations/FAM2_Martin_Haardt.pdf), немного их комментируя.
Рассмотрим первого пользователя:
Проговорим основные шаги:
* Составляем некоторую матрицу  из канальных матриц всех остальных пользователей.
* Раскладываем её методом [SVD](https://en.wikipedia.org/wiki/Singular_value_decomposition).
* В матрице  находим шумовое подпространство (null-subspace) — матрицу  (т.е. всё что выходит за **ранг** матрицы  — обозначим его ).
* Составляем из этой шумовой матрицы и её эрмитового сопряжения некоторую матрицу проекции .
Идём дальше:
* Теперь уже оригинальную часть канальной матрицы  перемножаем с полученной матрицей проекции .
* Раскладываем результат через SVD.
* В матрице  выбираем  строк, где  — ранг .
* Транспонируем их и получаем матрицу  (или  — где как обозначают).
И так эта процедура будет повторяться для каждого пользователя. Не это ли магия математики: используя методы линейной алгебры, решаем вполне технические задачи!
> Отметим, что на практике используются не только полученные матрицы пре-кодирования, но, и матрицы пост-обработки, и матрицы сингулярных значений (см. [слайды](https://web.stanford.edu/group/sarg/Presentations/FAM2_Martin_Haardt.pdf)). Последние, например, для балансировки мощности по уже знакомому нам алгоритму [**Water-pouring**](https://habr.com/ru/post/448570/).
Моделируем алгоритм
===================
Я думаю, не будет лишним провести небольшое моделирование, чтобы закрепить результат. Для этого будем использовать Python 3, а именно:
```
import numpy as np
```
для основных расчетов, и:
```
import pandas as pd
```
для отображения результата.
**Чтобы не нагромождать, помещу исходники сюда**
```
class ZeroForcingBD:
def __init__(self, H, Mrs_arr):
Mr, Mt = np.shape(H)
self.Mr = Mr
self.Mt = Mt
self.H = H
self.Mrs_arr = Mrs_arr
def __routines(self, H, mr, shift):
# used in self.process() - See example above for illustration
# inputs:
# H - the whole channel matrix
# mr - number of receive antennas of the i-th user
# shift - how much receive antennas were considered before
# outputs:
# Uidx, Sigmaidx, Vhidx - SVD decomposition of the H_iP_i
# d - rank of the hat H_i
# Hidx - H_i (channel matrix for the i-th user)
# r - rank of the H_i
Hidx = H[0+shift:mr+shift,:] # H_i (channel matrix for the i-th user)
r = np.linalg.matrix_rank(Hidx) # rank of the H_i
del_idx = [i for i in range(0+shift, mr+shift, 1)] # row indeces of H_i in H
H_hat_idx = np.delete(H, del_idx, 0) # hat H_i
d = np.linalg.matrix_rank(H_hat_idx) # rank of the hat H_i
U, Sigma, Vh = np.linalg.svd(H_hat_idx) # SVD
Vhn = Vh[d:, :] # null-subspace of V^H
Vn = np.matrix(Vhn).H # null-subspace of V
Pidx = np.dot(Vn, np.matrix(Vn).H) # projection matrix
Uidx, Sigmaidx, Vhidx = np.linalg.svd(np.dot(Hidx, Pidx)) # SVD of H_iP_i
return Uidx, Sigmaidx, Vhidx, d, Hidx, r
def process(self):
# used in self.obtain_matrices()
# outputs:
# F - whole filtering (pre-coding) matrix (array of arrays)
# D - whole demodulator (post-processing) matrix (array of arrays)
# H - the whole channel matrix (array of arrays)
shift = 0
H = self.H
F = []
D = []
Hs = []
for mr in self.Mrs_arr:
Uidx, Sigmaidx, Vhidx, d, Hidx, r = self.__routines(H, mr, shift)
Vhidx1 = Vhidx[:r,:] # signal subspace
Fidx = np.matrix(Vhidx1).H
F.append(Fidx)
D.append(Uidx)
Hs.append(Hidx)
shift = shift + mr
return F, D, Hs
def obtain_matrices(self):
# used to obtain pre-coding and post-processing matrices
# outputs:
# FF - whole filtering (pre-coding) matrix
# DD - whole demodulator (post-processing) matrix (array of arrays)
F, D, Hs = self.process()
FF = np.hstack(F)
# Home Task: calculation of the demodulator matrices :)
return FF
```
Пусть, у нас имеются 8 передающих антенн и 3 пользователя, у которых 3, 2 и 3 приёмных антенны соответственно:
```
Mrs_arr = [3,2,3]
# 1st user have 3 receive antennas, 2nd user - 2 receive antennas, 3d user - 3 receive antennas
Mr = sum(Mrs_arr) # total number of the receive antennas
Mt = 8 # total number of the transmitt antennas
H = (np.random.randn(Mr,Mt) + 1j*np.random.randn(Mr, Mt))/np.sqrt(2); #Rayleigh flat faded channel matrix (MrxMt)
```
Инициализируем наш класс и применяем соответствующие методы:
```
BD = ZeroForcingBD(H, Mrs_arr)
F, D, Hs = BD.process()
FF = BD.obtain_matrices()
```
Приводим к читабельному виду:
```
df = pd.DataFrame(np.dot(H, FF))
df[abs(df).lt(1e-14)] = 0
```
И немного подрихтуем для наглядности (хотя можно и без этого):
```
print(pd.DataFrame(np.round(np.real(df),100)))
```
Должно получиться нечто такое:
Собственно, вот они и блоки, вот она и диагонализация. И минимизация интерференции.
Такие дела.
Литература
==========
1. Spencer, Quentin H., A. Lee Swindlehurst, and Martin Haardt. "Zero-forcing methods for downlink spatial multiplexing in multiuser MIMO channels." IEEE transactions on signal processing 52.2 (2004): 461-471.
2. Martin Haard "[Robust Transmit Processing for Multi-User MIMO Systems](https://web.stanford.edu/group/sarg/Presentations/FAM2_Martin_Haardt.pdf)"
**P.S.**
Преподавательскому составу и студенческой братии [родной специальности](https://griat.kai.ru/communications-and-signal-processing) передаю привет! | https://habr.com/ru/post/450948/ | null | ru | null |
# Транслируем видеопоток с веб-страницы по WebRTC на Facebook и YouTube одновременно
Facebook и YouTube предоставляют сервисы трансляций, которые позволяют вещать Live-видеопотоки на широкую аудиторию зрителей. В этой статье мы расскажем, как захватить видеопоток с веб-страницы по технологии WebRTC и отправить этот видеопоток одновременно в Facebook и на YouTube для прямой трансляции — сразу в два сервиса.
Перед тем как начать трансляцию, выясним, какие RTMP endpoints предоставляют Facebook и Youtube для стриминга. Далее нам нужно будет послать по этим RTMP адресам видеопотоки.
Facebook
--------
Начнем, пожалуй с Facebook. Первым делом нужно отыскать кнопку **Начать прямой эфир**. Эта кнопка может выглядеть так:
Или вот так:
Далее нужно еще раз нажать кнопку **В эфир**
И кликнуть по ссылке **Click here** для трансляции с внешних устройств, а не с самого Facebook.
Далее кликаем **Создать стрим**
В результате, Facebook дает данные RTMP потока:
Из скриншота видно, что адрес сервера: **rtmp://rtmp-api.facebook.com:80/rtmp/**
А имя RTMP потока — это длинная уникальная строка:
**1489000000111961?ds=1&s\_l=1&a=ATj9giGjaTTfgpNHBP**
Именно эти два параметра нам потребуются для трансляции. Давайте их пока отложим и узнаем RTMP параметры для YouTube.
YouTube
-------
Чтобы начать стримить с YouTube, нужно зайти на сайт <https://youtube.com/live> и нажать на кнопочку **Upload**
Далее выбираем Live Streaming и жмем **Get Started**.
Должна показаться панель стриминга, плеер и RTMP-настройки:
Из настроек видим, что RTMP адрес сервера **rtmp://a.rtmp.youtube.com/live2**, а имя потока скрыто и становится видимым по нажатию на кнопку **Reveal**.
Имя RTMP-потока для YouTube выглядит так: **8r0t-z4d-9xyj-2bcd**
В итоге мы точно знаем куда слать RTMP-потоки:
| | | |
| --- | --- | --- |
| | **Facebook** | **YouTube** |
| RTMP-адрес | rtmp://rtmp-api.facebook.com:80/rtmp/ | rtmp://a.rtmp.youtube.com/live2 |
| Имя потока | 1489000000111961?ds=1&s\_l=1&a=ATj9giGjaTTfgpNHBP | 8r0t-z4d-9xyj-2bcd |
Web Call Server
---------------
Сервер будет отвечать за прием видеопотока с вебкамеры по WebRTC и доставку на Facebook и YouTube по RTMP.
**Делай раз**
Сначала отправляем на сервер видеопоток с веб-камеры из браузера Google Chrome.
Для этой цели можно скачать пример HTML-страницы и скрипта для стриминга [здесь](https://flashphoner.com/downloads/examples/webrtc-broadcasting-example-0.5.15.1977.2088.tar.gz) и развернуть на своем веб-сервере три файла из этого архива:
* streamer.html
* streamer.js
* flashphoner.js
**flashphoner.js** — это файл API. Его последнюю версию можно скачать в сборке [Web SDK](https://flashphoner.com/wcs-web-sdk).
Код стандартного демо-примера для стриминга доступен [здесь](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/streaming/two_way_streaming). Допустим мы открыли демо. Коннектимся к серверу и отправляем на сервер WebRTC видеопоток с именем **5dfd**. Это работает так:
Видео захватывается с камеры браузера (в данном случае с виртуальной), и уходит на сервер WCS5 по технологии WebRTC, в кодеках VP8+Opus или H.264+Opus в зависимости от устройства и версии браузера.
Следующим шагом будет перенаправление этого видео на Facebook.
**Делай два**
Web Call Server имеет REST API, которое позволяет, зная имя потока, перенаправить WebRTC видеопоток на RTMP.
Для этого нужно отправить серверу REST / HTTP запрос следующего содержания:
| | |
| --- | --- |
| URL |
```
https://wcs5-eu.flashphoner.com:8888/rest-api/push/startup
```
|
| Content-Type | application/json |
| Method | POST |
| Body |
```
{
streamName: "5dfd",
rtmpUrl: "rtmp://rtmp-api.facebook.com:80/rtmp/1489000000111961?ds=1&s_l=1&a=ATj9giGjaTTfgpNHBP"
}
```
|
Такой запрос можно протестировать из тулы [Advanced REST Console](https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo), которая выглядит так:
В результате WCS перенаправляет WebRTC видеопоток на Facebook по длинному адресу:
**rtmp://rtmp-api.facebook.com:80/rtmp/1489000000111961?ds=1&s\_l=1&a=ATj9giGjaTTfgpNHBP**
В этом адресе совмещены RTMP URL и имя видеопотока.
Через несколько секунд в Facebook появится видео:
**Делай три**
Высылаем аналогичный запрос для YouTube
| | |
| --- | --- |
| URL |
```
https://wcs5-eu.flashphoner.com:8888/rest-api/push/startup
```
|
| Content-Type | application/json |
| Method | POST |
| Body |
```
{
streamName: "5dfd",
rtmpUrl: "rtmp://a.rtmp.youtube.com/live2/8r0t-z4d-9xyj-2bcd"
}
```
|
Или из REST-консоли:
Сервер вернет 200 OK и заберет поток на YouTube:
В итоге видим, что стрим транслируется и раздается на оба сервиса: и на Facebook и на YouTube.
Теперь можно запросить список всех транслируемых потоков из того же REST API:
| | |
| --- | --- |
| URL |
```
https://wcs5-eu.flashphoner.com:8888/rest-api/push/find_all
```
|
| Content-Type | application/json |
| Method | POST |
| Body |
```
{}
```
|
Сервер вернет список потоков, которые в данный момент ретранслируются на Facebook и YouTube:
Останавливаем ретрансляции двумя вызовами **/push/terminate**
Отключаемся от Facebook:
| | |
| --- | --- |
| URL |
```
https://wcs5-eu.flashphoner.com:8888/rest-api/push/terminate
```
|
| Content-Type | application/json |
| Method | POST |
| Body |
```
{
"mediaSessionId": "8omef99f40674tcfi4pm87npbb"
}
```
|
Отключаемся от YouTube:
| | |
| --- | --- |
| URL |
```
https://wcs5-eu.flashphoner.com:8888/rest-api/push/terminate
```
|
| Content-Type | application/json |
| Method | POST |
| Body |
```
{
"mediaSessionId": "e13p1gc10bgsk3me49cest9gv2"
}
```
|
Таким образом, мы организовали трансляцию с веб-страницы по технологии WebRTC на сервер Web Call Server 5, затем одним REST-запросом **/push/startup** ре-транслировали видеопоток на Facebook, а вторым запросом **/push/startup** ре-транслировали поток на YouTube Live. После этого проверили воспроизведение видеопотоков через стандартные плееры сервисов и вывели список ре-транслируемых потоков запросом **/push/find\_all**. Закончили тестирование, завершив текущие трансляции двумя запросами **/push/terminate**.
Пишем JavaScript / HTML код
---------------------------
Работать с REST API, пожалуй, приходилось каждому или почти каждому разработчику. Поэтому мы не будем здесь описывать код, реализующий отправку REST/HTTP запросов.
Вместо этого расскажем как видеопоток с веб-страницы и вебкамеры доходит до сервера.
Как мы упоминали выше, для создания минимального клиента, захватывающего видео, необходимо три скрипта:
* streamer.html
* streamer.js
* flashphoner.js
**flashphoner.js** — это файл, который находится в сборке [Web SDK](https://flashphoner.com/wcs-web-sdk) и описывать его смысла нет.
**streamer.html**
Эта страница содержит div-элемент **localVideo**, в котором будет отображаться захват с камеры, и кнопку **Start** для начала трансляции.
```
The streamer
============
```
**streamer.js**
Скрипт трансляции работает с четырьмя основными функциями API:
* Flashphoner.init(); //отвечает за инициализацию API.
* Flashphoner.createSession(); //отвечает за подключение к серверу
* session.createStream(); //отвечает за создание видеопотока
* session.createStream().publish(); //отвечает за отправку видеопотока
В результате устанавливается подключение к серверу по протоколу Websocket и захват видео с веб-камеры браузера с последующей отправкой на сервер по WebRTC.
```
var localVideo;
function init(){
Flashphoner.init();
localVideo = document.getElementById("localVideo");
}
function start() {
Flashphoner.createSession({urlServer: "wss://wcs5-eu.flashphoner.com:8443"}).on(Flashphoner.constants.SESSION_STATUS.ESTABLISHED, function (session) {
//session connected, start streaming
startStreaming(session);
}).on(Flashphoner.constants.SESSION_STATUS.DISCONNECTED, function () {
setStatus("DISCONNECTED");
}).on(Flashphoner.constants.SESSION_STATUS.FAILED, function () {
setStatus("FAILED");
});
}
function startStreaming(session) {
session.createStream({
name: "stream222",
display: localVideo,
cacheLocalResources: true,
receiveVideo: false,
receiveAudio: false
}).on(Flashphoner.constants.STREAM_STATUS.PUBLISHING, function (publishStream) {
setStatus(Flashphoner.constants.STREAM_STATUS.PUBLISHING);
}).on(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED, function () {
setStatus(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED);
}).on(Flashphoner.constants.STREAM_STATUS.FAILED, function () {
setStatus(Flashphoner.constants.STREAM_STATUS.FAILED);
}).publish();
}
function setStatus(status) {
document.getElementById("status").innerHTML = status;
}
```
Скачать архив с скриптами **streamer.html** и **streamer.js** можно [здесь](https://flashphoner.com/downloads/examples/webrtc-broadcasting-example-0.5.15.1977.2088.tar.gz).
Чтобы трансляция заработала из Google Chrome, нужно выложить скрипты трансляции на веб-хостинг, который работает по https.
Web Call Server может быть установлен на отдельном Linux-хосте. Скачать сервер для тестов можно [здесь](https://flashphoner.com/download). После того, как сервер установлен и запущен, он будет принимать входящие вебсокет-соединения по адресам: ws://host:8080 и wss://host:8443
Таким образом, мы показали как захватить видео с вебкамеры и доставить видеопоток до сервера с помощью трех скриптов. Если все было сделано правильно, скрипт должен вывести статус PUBLISHING. Это означает, что WebRTC поток успешно доставляется на сервер и может быть ре-транслирован на YouTube или Facebook с помощью REST API.
Ссылки
------
[Web Call Server](https://flashphoner.com/) — WebRTC сервер с возможностью ретрансляции на YouTube и Facebook
[Web SDK](https://flashphoner.com/wcs-web-sdk) — JavaScript API для внедрения кода трансляции в веб-страницу.
[REST API](https://flashphoner.com/docs/wcs5/wcs_docs/html/en/wcs-rest-api/) — управление ретрансляциями WebRTC видеопотоков
[Source](https://flashphoner.com/downloads/examples/webrtc-broadcasting-example-0.5.15.1977.2088.tar.gz) — исходный код примера трансляции потока с веб-страницы на сервер.
[YouTube Live](http://youtube.com/live) — сервис живых трансляций от YouTube
[Facebook Live](https://live.fb.com/) — сервис живых трансляций от Facebook | https://habr.com/ru/post/327986/ | null | ru | null |
# Упрощаем работу с CloudKit, или синхронизация в духе Zen
### Введение
Облачная синхронизация — закономерный тренд нескольких последних лет. Если вы разрабатываете под одну или несколько Apple платформ (iOS, macOS, tvOS, watchOS) и задачей является реализация функционала синхронизации между приложениями, то в вашем распоряжении есть очень удобный инструмент, или даже целый сервис — CloudKit.
Нашей команде постоянно приходится прикручивать функционал синхронизации данных с CloudKit, в том числе в проектах, которые используют CoreData в качестве хранилища данных. Поэтому возникла, а затем была реализована идея — написать универсальный интерфейс для синхронизации.
CloudKit — это не просто фреймворк. Это полноценный BaaS (Backend as a Service), т.е. комплексный сервис с полноценной инфраструктурой, включающей в себя облачное хранилище, пуш-уведомления, политики доступа и многое другое, а также предлагающий универсальный кросс-платформенный программный интерфейс (API).
CloudKit прост в использовании и сравнительно доступен. Только за то, что вы являетесь участником [Apple Developer Program](https://developer.apple.com), в вашем распоряжении совершенно бесплатно:
* 10Gb хранилище под ресурсы
* 100MB под базу данных
* 2GB трафика в день
* 40 запросов в секунду
И эти цифры могут быть увеличены, если есть такая потребность. Стоит отметить, что CloudKit не использует iCloud-хранилище пользователя. Последний используется только для аутентификации.
Эта статья — не реклама CloudKit и даже не очередной обзор основ работы с ним. Здесь не будет ничего о настройке проекта, конфигурировании App ID в вашем профиле разработчика, создании CK-контейнера или Record Type в дэшборде CloudKit. Кроме того, за рамками статьи остаётся не только backend составляющая, но и вся программная, относящаяся непосредственно к CloudKit API. Если вы хотели бы разобраться именно в основах работы с CloudKit, то для этого уже есть прекрасные вводные статьи, повторять которые нет никакого смысла.
* [CloudKit Tutorial: Getting Started](https://www.raywenderlich.com/134694/cloudkit-tutorial-getting-started)
* [CloudKit](http://nshipster.com/cloudkit/)
* [How to Work With CloudKit](https://yalantis.com/blog/work-cloudkit/)
* [Working with CloudKit in iOS 8](http://www.appcoda.com/cloudkit-introduction-tutorial/)
Эта статья — в некотором смысле следующий шаг.
Когда вы уже освоились с чем-то, что давно используете, рано или поздно возникает вопрос: как автоматизировать процесс, сделать его ещё более удобным и более унифицированным? Так возникли паттерны проектирования. Так возник наш фреймворк, облегчающий работу с CloudKit — ZenCloudKit, который уже был успешно применен в ряде проектов. О нём, а именно, о новом техническом способе работы с CloudKit, и пойдет речь дальше.
### Универсальный интерфейс
Создавая фреймворк, нашей конечной целью была реализация такого интерфейса, который был бы совместим с сущностями CoreData, позволяя при минимуме усилий синхронизировать — сохранять, удалять и получать данные — с учетом имеющихся связей БД, вне зависимости от сложности имеющейся архитектуры.
Фреймворк написан на Swift 3 и именно Swift-разработчики в полной мере сумеют ощутить преимущества, которые даёт его использование. Для Objective-C возможен вполне полноценный bridge, но по известным причинам аналогичные вещи будут выглядеть в нём избыточными и более громоздкими в реализации. Примеры кода в данной статье будут написаны на Swift.
Перейдём к обзору, параллельно рассматривая пример реализации.
### Пример реализации
Рассмотрим в качестве введения некоторые типичные операции синхронизации: методы сохранения и удаления. Конечная реализация выглядит следующим образом:
Что же здесь происходит?
Положим, у нас есть объект **event** со свойством **entity**, где **entity** — это NSManagedObject. У этого NSManagedObject, как и у всякого объекта базы данных, есть поля, некоторые из которых являются свойствами, некоторые — ссылками, *reference*, на другие объекты NSManagedObject, образуя связи один-к-одному или один-ко-многим.
Чтобы сохранить этот объект (или удалить соответствующий ему) синхронно или асинхронно в базу данных CloudKit, пробросив при этом все связи, используется прокси-объект — iCloud, который содержит в себе соответствующие методы. Достаточно вызывать entity.iCloud.save() (асинхронное) или entity.iCloud.saveAndWait() (синхронное сохранение), чтобы все поля entity были записаны в соответствующие поля объекта CloudKit, а уникальный UUID от вновь сохраненного CKRecord (т.е. строковое свойство recordName объекта CKRecordID) был автоматически записан обратно в специально отведенное для этого поле объекта entity, образовав тем самым связь между локальным и удаленным объектом.
Если вы никогда не использовали CloudKit и всё это звучит непонятно, то проще сказать, что на любую сущность есть .iCloud.save() и этого достаточно, чтобы сохранить как сам объект, так и все его связи. Никакого больше множества идентичных методов для разных сущностей и грязи в клиентском коде. Удобно, не правда ли?
### Настройка объектов синхронизации
Для того чтобы это работало, необходимо выполнить несколько условий.
В основе работы лежит широко применяемая схема маппинга свойств, которая используется во многих библиотеках, в различных веб-парсерах (таких как RestKit) и т.д. Маппинг же реализован в классической манере — посредством KVC, который поддерживается только наследниками NSObject. Отсюда, первое условие:
1) Каждый синхронизируемый объект должен быть наследником NSObject (к примеру, NSManagedObject – это отличный выбор).
2) Каждый синхронизируемый объект должен реализовать протокол ZKEntity, который выглядит следующим образом:
Если вы работаете с CoreData, то реализовывать нужно прямо в вашем (sub-)классе:
Как видно из протокола, обязательными полями являются recordType и mappingDictionary. Рассмотрим оба.
**// REQUIRED (обязательные поля)**
1) **recordType** — соответствующий тип записи, Record Type, в CloudKit.
Пример: класс Person содержит свойство recordType = “Person”. После вызова save() у его экземпляра, в дэшборде CloudKit именно в этой таблице (“Person”) будет заведена запись.
Реализация:
```
static var recordType = "Person"
```
2) **mappingDictionary** — словарь маппинга свойств.
Схема: [локальный ключ: удаленный ключ (поле в таблице CloudKit) ].
Пример: класс Person содержит поля firstName и lastName. Чтобы сохранять их в таблицу Person в CloudKit под теми же именами, необходимо написать следующее:
```
static var mappingDictionary = [ "firstName" : “firstName”, “lastName” : “lastName” ]
```
**// OPTIONAL (необязательные поля)**
Остальные поля протокола являются опциональными,
3) **syncIdKey** — имя локального свойства, которое будет хранить ID удаленного объекта. ID — это паспорт объекта, необходимый для связи локальный<—>удаленный.
Поле является условно опциональным. При инициализации контроллера фреймворка, о которой будет написано ниже, есть возможность указать имя свойства для всех сущностей. Однако, указанное индивидуально в классе сущности, оно имеет более высокий приоритет и при парсинге будет проверяться сначала именно оно. И лишь затем, если реализация пустая, будет использоваться универсальный ключ (см. далее).
Реализация:
```
static var syncId: String = "cloudID"
```
**changeDateKey** — имя локального свойства, которое будет хранить дату изменения объекта. Ещё одно служебное свойство, необходимое для синхронизации.
Аналогично предыдущему, оно условно опционально. Есть возможность опустить реализацию и указать имя свойства для всех синхронизируемых объектов во время инициализации ZenCloudKit (см. далее).
Реализация:
```
static var changeDateKey: String = "changeDate"
```
**references** — словарь, содержащий ключи, реализующие связь \*-к-одному.
Схема: [“локальный ключ”: “удаленный ключ”]
Требованием здесь является то, чтобы свойство “локальный ключ” своим типом имело класс, который удовлетворяет базовым требованиям (наследует NSObject и реализует протокол ZKEntity).
При вызове save() у локального объекта ZenCloudKit попытается также сохранить все связанные с ним.
Реализация:
```
static var references : [String : String] =
["homeAddress" : "address"]
```
**referenceLists** — словарь, содержащий массив объектов ZKRefList, каждый из которых несёт в себе информацию о конкретной связи \*-ко-многим: тип объектов и название ключа, по которому необходимо запрашивать и сохранять этот список.
Схема: ZKRefList(entityType: ZKEntity.Type,
localSource: локальное свойство, которое возвращает массив объектов ZKEntity,
remoteKey: ключ в CloudKit для хранения массива ссылок (CKReference))
Реализация:
```
static var referenceLists: [ZKRefList] = [ZKRefList(entityType: Course.self,
localSource: "courseReferences",
remoteKey: "courses")]
```
**courseReferences** – это user-defined свойство, возвращающее массив объектов ZKEntity, которые вы хотели бы сохранить и ссылки на которые необходимо поместить в перечень ссылок корневого объекта.
Код (продолжение):
```
var courseReferences : [Course]? {
get {
return self.courses?.allObjects as? [Course]
}
set {
DispatchQueue.main.async {
self.mutableSetValue(forKey: "courses").removeAllObjects()
self.mutableSetValue(forKey: "courses").addObjects(from: newValue!)
}
}
```
Реализация соответствующего сеттера также необходима чтобы приложение могло сохранить объекты, полученные из CloudKit. Таким образом, поле localSource объекта ZKRefList в сущности является ссылкой на обработчик (хэндлер), который управляет операциями ввода и вывода.
**isWeak** — опциональный флаг, который, будучи установленным (true), указывает на то, что любой другой объект, ссылающийся на экземпляр данного типа, образует слабую ссылку (аналогия с модификатором weak) в CloudKit. Это означает, что запись о нём будет удалена каскадно, как только будет удален объект, который содержит ссылку на него.
Пример: есть объект A, ссылающийся на объект B.
Если установить B.isWeak = true, объект А будет сохранен в CloudKit со “слабой ссылкой” на B. Объект B будет удален автоматически, как только вы удалите объект A.
Этот флаг является реализацией нативного API CloudKit и апеллирует к конструктору CKReference с флагом .deleteSelf:
```
CKReference.init(record: , action: .deleteSelf)
```
Поэтому механика удаления — целиком прерогатива CloudKit, фреймворк же просто предлагает более удобный интерфейс. В дальнейшем этот функционал может быть расширен, чтобы каскадное удаление можно было настраивать для разных сущностей.
Реализация:
```
static var isWeak = true
```
**referencePlaceholder** — свойство, которое, будучи объявленным, позволяет избежать значения nil при получении объекта из CloudKit, подменяя его значением по умолчанию.
Если предполагается, что объект сущности CoreData должен всегда содержать какое-либо значение, отличное от nil, в качестве ссылки на другой объект, то всякий раз, когда данный объект будет отсутствовать в CloudKit при синхронизации, локальному свойству может быть автоматически задано значение по умолчанию.
Пример: есть класс A со свойством b и, зеркально ему, такой же Record Type в CloudKit.
В CloudKit имеется объект A, который отсутствует локально, имеющий пустую ссылку на B (значение отсутствует). При обычном сценарии в результате синхронизации вы бы получили объект A, у которого свойство b было бы nil. Но с установленным значением по умолчанию в локальном классе (**referencePlaceholder =** …) ZenCloudKit автоматически присвоит свойству b указанное вами значение:
A.b = referencePlaceholder,
где последний является экземпляром B.
Так, в результате полного цикла синхронизации в вашем приложении всегда будут создаваться объекты с заполненными ссылками, даже в том случае, если на всех остальных устройствах они сохранялись пустыми.
Реализация:
```
static var referencePlaceholder: ZKEntity = B.defaultInstance()
```
Обратите внимание, что referencePlaceholder указывается именно в таргет-классе. Если нужно, чтобы свойство b объекта A не оказывалось nil (A.b != nil), то именно в классе B необходимо реализовать referencePlaceholder, а не в корневом классе A, который мы получили в результате синхронизации.
**// SUMMARY**
На момент написания статьи это весь функционал, поддерживаемый ZKEntity. Подытожим изложенное ещё раз в виде конкретного примера.
Положим, есть класс Event:
Реализация ZKEntity может выглядеть, например, так:
Здесь:
* словарь для маппинга свойств.
* словарь для маппинга ссылок (опционально)
* CloudKit Record Type
Опущены syncIdKey и changeDateKey. В примере им соответствуют свойства syncID и changeDate. Поскольку аналогичные свойства (changeDate, syncID) присутствуют в интерфейсе других классов, они были записаны на фазе инициализации ZenCloudKit (о чём пойдёт речь далее) как универсальные, поэтому частная имплементация была опущена.
### Настройка контроллера и делегата
После того, как сущности были настроены, необходимо проинициализировать контроллер и назначить его делегат. Сделать это можно различными способами, но лучше всего — отвести для этого отдельный класс и написать вызываемый инициализатор.
Для начала можно завести глобальную переменную, которая будет хранить ссылку на статический экземпляр контроллера.
Класс-делегат должен будет реализовать следующий протокол:
Прежде чем рассматривать каждый метод в отдельности, попробуем взглянуть на вариант готовой реализации (за исключением метода zenSyncDIdFinish).
Класс CloudKitPresenter в приведенном примере является делегатом ZenCloudKit. Здесь происходит инициализация и вызов callback-функций, необходимых для реализации полного цикла синхронизации. Полный цикл синхронизации — это последовательность закадровых операций, при которых осуществляется сравнение локальных и удаленных объектов по времени изменения и их актуализация на обоих концах. Для этого по каждому типу, т.е. по каждой зарегистрированной сущности ZKEntity, фреймворку необходимо предоставить три функции, реализующие соответственно создание, запрос объекта по ID (fetch) и запрос всех доступных объектов. В каждой из трёх функций в качестве параметра выступает класс ZKEntity (ofType T: ZKEntity.Type). В результате выполнения ZenCloudKit ожидает получить объекты именно данного типа.
**zenAllEntities(ofType T: ZKEntity.Type)**
— ожидает получить массив всех сущностей типа T
**zenCreateEntity(ofType T: ZKEntity.Type)**
— ожидает получить новый экземпляр T.
**zenFetchEntity(ofType T: ZKEntity.Type, syncId: String)**
— ожидает получить существующий экземпляр T по данному syncId (или nil если таковой отсутствует).
Например, если вы работаете с сущностями Person и Home, то параметр T в данных функциях будет равен одному из этих двух типов. Ваша задача — предоставить результат по каждому из них (новый объект, существующий и все). Сделать это можно либо осуществив проверку типа и написав код для каждого, либо при помощи интерфейсного полиморфизма.
В приведенном примере для осуществления перечисленных операций используются стандартные методы MagicalRecord для поиска существующего, создания нового и запроса всех объектов, которые работают как extension-методы (или методы категорий, выражаясь в духе Objective-C) для NSManagedObject. Это значительно упрощает реализацию. Код становится универсальным, поскольку пропадает нужда делать type-check для каждого случая T.
Функции являются конкретной реализацией generic-абстракции, хотя, строго говоря, обобщения в сигнатуре функций не используются в целях обеспечения совместимости с Objective-C.
В последней функции используется инструкция T.predicateForId(…). Это метод расширения, предоставленный ZenCloudKit, который возвращает корректный предикат поиска для данного типа T по данному syncId (чтобы избежать хард-кода и связанных с ним возможных ошибок в названии свойства, локально хранящего ID).
**zenEntityDidSaveToCloud (entity: ZKEntity, record: CKRecord?, error: Error?)**
— вызывается каждый раз при завершении сохранения в CloudKit. На этой фазе объект entity уже получил ID удаленного объекта, поэтому здесь можно, например, сохранить главный контекст базы данных.
Делегат реализует закрытый Singleton (sharedInstance не виден клиенту). Для того, чтобы проинициализировать и контроллер, и его делегат, достаточно где-либо извне в нужный момент вызвать метод:
В методе инициализации происходит настройка фреймворка:
Задаются стандартные для CloudKit параметры:
* имя контейнера (container)
* тип базы данных (ofType: .public/.private)
Далее следуют уже рассмотренные выше ключи syncIdKey и changeDateKey — имена свойств, хранящих ID записей и дату изменения. Необходимо отметить, что эти значения могут быть оставлены пустыми (nil). В таком случае при вызове соответствующих методов у экземпляров ZKEntity (например, save()) ZenCloudKit будет искать их имплементацию среди объявлений каждого класса. И наоборот, достаточно указать эти ключи только здесь, чтобы опустить специфичную реализацию. Если пустой окажется и общая, и частная имплементация, то вызов cloudKit.setup() выдаст в лог ошибку, и синхронизация работать не будет.
В параметр entities мы передаем массив всех типов, с которыми собираемся работать.
ignoreKeys — массив строковых ключей, обнаружив которые, ZenCloudKit должен проигнорировать объект (например, не сохранять или не удалять его).
deviceId — ID устройства. Очень важный параметр, если в синхронизации будет задействовано несколько устройств. Об уникальности этого параметра должен позаботиться разработчик. Стандартно, берётся Hardware UUID, но возможны и другие варианты.
**// RECAP**
Реализация настроек, описанных до сих пор, является необходимым и достаточным условием для того, чтобы работал базовый функционал, предоставленный прокси-объектом iCloud, который, в свою очередь, реализует протокол ZKEntityFunctions:
За исключением функции update(), назначение которой — обновить локальный объект из удаленного, представленного в коде как CKRecord. Эту функцию следует использовать в методе делегата zenSyncDIdFinish, который вызывается по окончании полного цикла синхронизации, который, в свою очередь, запускается следующим образом:
Первый вариант — синхронизация в стандартном режиме. Каждый последующий цикл синхронизации фиксируется ZenCloudKit; в случае успеха, сохраняется дата последней синхронизации (всё это берёт на себя фреймворк). Сохранение даты очень важно: оно позволяет отбирать только те объекты, дата изменения которых — позже даты последнего успешного цикла. В противном случае, если, скажем, у вас в БД 100 объектов, то каждый цикл включал бы бессмысленную проверку давно уже синхронизированных, не изменяющихся объектов. Это совершенно не нужная и, к тому же, ресурсозатратная операция.
Второй вариант — принудительная синхронизация (forced: true). Могут быть случаи, когда целостность данных оказывается нарушенной. Тогда вы можете в принудительном порядке проверить каждый синхронизируемый объект, игнорируя дату последнего успешного цикла, и актуализировать данные локально и удаленно. Локальные объекты будут обновлены тем, что лежит в CloudKit (если по каким-то причинам этого не произошло ранее). А в CloudKit могут быть сохранены локальные объекты, которые также почему-то не были сохранены. В зависимости от специфики вашего приложения, вы сами можете определить, в каком месте вызывать принудительную синхронизацию (например, при старте, во время длительного простоя или же отвести эту функцию в настройки). В общем случае в этом вызове нет нужды и, скорее всего, вам не придётся к нему прибегать.
Вызов метода syncEntities() на уровне контроллера делает то же самое, только применительно ко всем зарегистрированным сущностям. Параметр specific принимает конкретные типы, которые вы бы хотели синхронизовать (nil — если нужно применить ко всем).
Осталось разобрать метод zenSyncDIdFinish, сигнатура которого выглядит так:
Параметры:
**T** — тип сущности, объекты которой необходимо создать или обновить.
**newRecords**, **updatedRecords** — массивы CKRecord, объектов, которые необходимо создать или обновить локально. Ориентиром при поиске локального соответствия выступает уникальный ID, который стандартно хранится в свойстве CKRecord.recordID.recordName. Сущность, среди объектов которой нужно искать соответствия и экземпляр которой создать, является T.
**deletedRecords** — массив объектов **ZKDeleteInfo**, каждый из которых хранит информацию об удаляемом объекте: локальный ZKEntity-тип и ID объекта. Эти объекты могут быть различных типов, поэтому ориентироваться на тип T в данном случае не нужно. Тип удаляемого объекта следует смотреть в свойстве entityType, а ID объекта — в свойстве syncId объекта ZKDeleteInfo. Класс выглядит следующим образом:
ZenCloudKit формирует этот список перед тем, как завершить удаление, отправляя его в обработчик zenSyncDidFinish в массиве deletedRecords, чтобы вы смогли произвести необходимую локальную очистку. Как только локально всё будет успешно удалено, необходимо вызвать callback-метод finishSync(). Если этого не сделать, то в базе данных CloudKit не будет произведено никаких изменений. Такая схема принята в целях безопасности: лишь удостоверившись в том, что локальная база данных актуализирована, вы вызываете финализатор — finishSync().
**Всегда вызывайте finishSync() в конце синхронизации.**
Это относится не только к фазе удаления, описанной выше, но и к фазам создания и обновления.
Подытожим сказанное, рассмотрев фрагмент реализации функции zenSyncDIdFinish:
Сразу после данного фрагмента должны следовать:
— вызов finishSync()
— функции обновления UI, которые бы отразили изменившееся состояние БД (если требуется).
При помощи следующей инструкции:
мы заполняем поля локального объекта полями CKRecord, который нам доступен как аргумент в одном из массивов. Флаг fetchReferences позволяет загрузить все связи. Под загрузкой связей подразумевается реальная загрузка соответствующих объектов (приведенных в массивах **references** и **referenceLists**, описанных в протоколе ZKEntity) из CloudKit и их привязка к данному объекту **entity**. Если при загрузке связи обнаружится, что соответствующий локальный объект не существует (**zenFetchEntity == nil**), он будет автоматически создан в локальной базе данных путём вызова метода делегата **zenCreateEntity**.
Если образование этих связей предполагает изменение UI, об этом необходимо позаботиться дополнительно (updateEntity — в части заполнения связей — работает асинхронно и дожидаться его выполнения не стоит). В обработчике **ZKRefList** это можно сделать в сеттере, о чём уже говорилось:
Здесь происходит следующее:
При получении связей \*-ко-многим (в результате вызова updateEntity с флагом fetchReferences = true) в сеттер teacherReferences попадает массив объектов Teacher. В главном потоке мы обновляем этот список у корневого объекта NSManagedObject, а затем вызываем методы обновления UI.
Маппинг связей \*-к-одному (массив references, содержащий название свойств-ссылок на другие сущности ZKEntity) не предполагает обработчиков (get/set), поэтому, если требуется отслеживать образование этих связей, необходимо прибегнуть либо к аналогичному методу — в качестве ключей в массиве references указывать обработчики и переопределять их геттер и сеттер, — либо использовать ReactiveCocoa или иные средства для наблюдения за свойствами.
Работа со ссылками кажется богатой нюансами, и это действительно так, однако эти нюансы — закономерное следствие обвязки и автоматизации работы двух систем — CoreData и CloudKit.
Если вам нужно иметь более прямой контроль над образованием связей, обновлением UI или другими sync-related процессами, по усмотрению вы можете совместить средства ZenCloudKit и нативный CloudKit API. В методе zenSyncDidFinish передаются массивы объектов CKRecord, которые, помимо свойств, содержат объекты CKReference. Это значит, что вы можете кастомизировать парсинг, а также вручную загрузить те объекты, которые вам нужны.
На этом настройка ZenCloudKit окончена.
### Нюансы использования
Стандартный способ обращения к функционалу фреймворка — через экземпляр (singleton) ZenCloudKit контроллера:
В качестве аргументов — всё те же экземпляры и классы ZKEntity.
Сокращенный вариант (через прокси-класс .iCloud) в данный момент доступен только в Swift.
### Push-уведомления
Обработка push-уведомлений также может быть передана в ZenCloudKit:
Результатом его работы будет вызов метода делегата zenSyncDIdFinish, с одним из трёх заполненных массивов (newRecords, updatedRecords, deletedRecords), выполнение которого автоматически приведет к обновлению базы данных и UI (если вы позаботились об этом в теле данной функции). Напомню, что обычный сценарий обработки push-уведомлений предполагает ряд довольно монотонных действий: проверка типа уведомления (CKNotification), причины нотификации (queryNotificationReason), парсинг — определение сущности, к которой относится уведомление и лишь затем вызов соответствующего обработчика. ZenCloudKit берёт всё это на себя.
### Блокировка синхронизации
Рано или поздно код вашего приложения будет наполнен инструкциями .save() или .delete() в разных местах. Если вы предполагаете возможность отключения синхронизации изнутри приложения (а не в свойствах системы), то вместо того чтобы в каждом месте клиентского кода делать проверку какого-нибудь флага, вы можете отключить синхронизацию на уровне фреймворка:
Возобновление синхронизации, как можно догадаться, достигается передачей false. И ваш код остается чистым.
### Логгирование
Все основные этапы работы фреймворка логгируются. Включение/отключение флага debugMode позволяет управлять выводом в консоль служебной информации (по умолчанию true):
Настройка контейнера:
Для успешной работы приложению и ZenCloudKit необходим доступ на чтение и запись всех используемых Record Type, включая query-права на ключ modifiedDate (CKRecord). Не забудьте включить всё это в дэшборде. Кроме того, фреймворком в базе данных будут созданы таблицы под названием Device и DeleteQueue. Первая будет содержать список зарегистрированных устройств, которые обращаются к вашей базе данных. Вторая — очередь на удаление — представляет собой таблицу с мета-информацией об удаленных объектах, которые необходимо удалить на каждом устройстве (для каждого устройства — соответствующая запись). После того, как это устройство осуществит локальное удаление соответствующего объекта, запись из DeleteQueue также будет стёрта. Эти две таблицы являются служебными, к ним должен быть полный доступ на чтение и запись для каждого устройства.
### Безопасность
Последним достойным внимания моментом работы ZenCloudKit является безопасность.
Процедура сохранения объектов в CloudKit стандартно сводится к двум этапам: (1) проверка на наличие искомого объекта, и только затем — (2) сохранение. Рассмотрим ситуацию, когда в кратчайший промежуток времени вы атомарно сохраняете 15 новых объектов (или один и тот же несколько раз подряд), или же это происходит в результате сбоя. В стандартном сценарии работы CloudKit это может произойти так: сначала несколько раз сработает хэндлер поиска (fetch), возвратив nil, а затем столько же раз будет вызвана команда сохранения (ведь объект не найден). В результате, не желая того, вы получите несколько экземпляров одного и того же объекта в CloudKit. Без дополнительных мер (см. GCD), это неизбежно, потому что CloudKit API основан на асинхронных блоках, последовательность которых сложно предугадать, даже выставив флаги приоритета и QoS у CKQueryOperation.
Описанного выше сценария гарантированно не случится с ZenCloudKit, который на этапе инициализации создает очередь для каждого зарегистрированного типа ZKEntity, обеспечивая строгую последовательность в выполнении операций сохранения. Если среди 15 объектов — по 3 объекта разных типов (итого 5 типов), то при их одновременном сохранении, “в одно время” будет запущен процесс сохранения для 5 объектов, без какой-либо угрозы. Также схема сводит на нет возможность отказа (DoS).
### Заключение
Фреймворк создавался одним человеком в течение примерно двух месяцев. Значительная часть времени была потрачена не столько на программирование, сколько на дизайн и рефакторинг. Цель стояла простая — упростить и унифицировать выполнение типовых операций синхронизации с CloudKit, обеспечив приемлемый уровень совместимости с CoreData. Кардинальных неисправностей и серьезных багов в ходе применения на сегодняшний день обнаружено не было.
Некоторые функции в данной статье не описаны (например, управление потерянным соединением и автоматический запуск полного цикла синхронизации, по мере его восстановления). Известны также некоторые нюансы: например, на данный момент отсутствует поддержка CKAssets (однако её реализовать не сложно).
В данный момент фреймворк вместе с демо-проектом готовится на выкладку. Если вы хотели бы получить исходной код ZenCloudKit или у вас есть какие-либо вопросы или комментарии, будем рады узнать о них в комментариях к данной статье или через ЛС. | https://habr.com/ru/post/326050/ | null | ru | null |
# Защищаем веб-сервер на Linux
Привет, Хабр!
У нас давно не выходило новых книг по Linux для начинающих — и вот мы беремся за перевод новинки именно такого плана. Книга "[Linux in Action](https://www.manning.com/books/linux-in-action)" Дэвида Клинтона вышла в издательстве Manning и рассказывает не только о [внутреннем устройстве Linux](https://www.piter.com/product_by_id/48311657), но и о наиболее распространенных проблемах, и о способах их устранения.
Автор опубликовал на сайте Hackernoon отрывок из 9-й главы, который мы и предлагаем вам оценить.
Собрать LAMP-сервер, как следует его сконфигурировать, обеспечить надежную обработку данных, настроить предметную область и озаботиться TLS-сертификатом – лишь половина пути к победе. Также необходимо убедиться, что ваша инфраструктура защищена от многочисленных устрашающих угроз Интернета.
В этой статье мы исследуем безопасность веб-сайта, научившись правильно работать с системными группами, обеспечивать изоляцию процессов и регулярный аудит системных ресурсов. Разумеется, этот рассказ не полный (в книге Linux в действии рассмотрены и другие темы, например, установка TLS-сертификатов и работа с SELinux), но для начала и этого будет вполне достаточно.
### Системные группы и принцип минимальных привилегий
Разработчики, поддержкой которых вы занимаетесь, (наконец-то) начинают осознавать, что необходимо ограничивать общий доступ к данным и конфигурационным файлам, расположенным на сервере приложений, но, в то же время, оставлять такой доступ открытым для различных программерских и прочих айтишных команд.
Первая часть решения – это *группы*. Группа – это объект в системе (примерно как и пользователь) с той оговоркой, что ни один пользователь никогда не зайдет в систему как группа. Сила групп заключается в том, что их, как и пользователей, можно «присваивать» файлам или каталогам, позволяя каждому члену группы пользоваться предусмотренными для нее полномочиями. Это проиллюстрировано ниже.
Разработчики, входящие в состав группы Developers, могут получить доступ к конкретному каталогу, а для пользователей, не относящихся к данной группе, каталог будет закрыт
Попробуйте сами: создайте в текстовом редакторе новый файл. Запишите в него простой текст, например, «Hello World», чтобы сразу было видно, когда к файлу удалось успешно обратиться. Затем отредактируйте права доступа при помощи `chmod 770`, так, чтобы владелец файла и члены группы, к которой он относится, имели полные права на работу с файлом, а другие не могли его читать.
```
$ nano datafile.txt
$ chmod 770 datafile.txt
```
Если в вашей системе пока нет других пользовательских аккаунтов кроме вашего собственного – создайте такой аккаунт либо при помощи `adduser` — так делается в Debian/Ubuntu — либо при помощи `useradd`, как принято в CentOS. Команда `useradd` сработает и в Ubuntu.
Команда `useradd` в отличие от `adduser` из Debian требует, чтобы пользовательский пароль генерировался отдельно:
```
# useradd otheruser
# passwd otheruser
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
```
При помощи команды `su` переключаемся на нового пользователя. После того, как мы введем его пароль, все следующие команды будут выполняться от имени этого пользователя. Вы будете работать от лица именно этого пользователя; ни больше, ни меньше. Если вы попытаетесь считать файл данных `datafile.txt` (при помощи `cat`), то ничего у вас больше не выйдет; как вы помните, права на чтение есть только у членов группы. Когда закончите, введите `exit`, чтобы выйти из оболочки нового пользователя, и вернитесь в свою исходную оболочку.
```
$ su otheruser
Password:
$ cat /home/ubuntu/datafile.txt
cat: /home/ubuntu/datafile.txt: Permission denied
$ exit
```
Все это ожидаемо и вполне понятно. Как видите, когда не можешь прочесть файл, принадлежащий другому пользователю – это порой проблема. Давайте посмотрим, что можно сделать, связав файл с группой, а затем правильно сконфигурировав права доступа к файлу.
Создадим новую группу, при помощи которой сможем управлять данными нашего приложения, а затем отредактируем свойства нашего файла с данными при помощи команды `chown`. Аргумент ubuntu:app-data-group оставляет права на владение файлом пользователю Ubuntu, но группа его меняется на новую: app-data-group.
```
# groupadd app-data-group
# chown ubuntu:app-data-group datafile.txt
```
Запустите ls, чтобы получить «развернутый» вывод этого файла и просмотреть его новые права доступа и статус. Обратите внимание: как и следовало ожидать, файлом владеет пользователь `ubuntu`, относящийся к группе `app-data-group`.
```
$ ls -l | grep datafile.txt
-rwxrwx — — 1 ubuntu app-data-group 6 Aug 9 22:43 datafile.txt
```
Можно применить `usermod`, чтобы добавить вашего пользователя к `app-data-group`, а затем – команду `su`, чтобы переключиться на оболочку, в которой развернут аккаунт другого пользователя. Теперь, даже несмотря на то, что права доступа к файлу закрывают его от всех «других» — а вы на данный момент определенно «другой» пользователь — вы должны свободно читать этот файл, поскольку относитесь к нужной группе.
```
# usermod -aG app-data-group otheruser
$ su otheruser
$ cat datafile.txt
Hello World
```
При помощи команды `su` переключаемся между пользовательскими аккаунтами. Они и записаны в моем файле `datafile.txt`. Такая организация – правильный и эффективный способ устранения разнообразных сложных проблем с правами доступа, которые могут возникать в многопользовательской системе.
На самом деле, она применяется не только для предоставления нужных прав доступа отдельным пользователям – многие системные процессы также не могли бы выполнять своих задач, если бы для них не была прописана принадлежность к нужным группам. Можете по диагонали просмотреть файл /etc/group – обратите внимание, как много системных процессов относятся к собственным группам…
Сокращенный листинг содержимого /etc/group file:
```
$ cat /etc/group
root:x:0:
daemon:x:1:
bin:x:2:
sys:x:3:
adm:x:4:syslog
tty:x:5:
disk:x:6:
lp:x:7:
mail:x:8:
news:x:9:
uucp:x:10:
man:x:12:
proxy:x:13:
[…]
```
### Изоляция процессов в контейнерах
Возможно, вы беспокоитесь, что множество служб, работающих у вас на одном сервере, окажутся под угрозой, если хотя бы одна из этих служб окажется взломана? Один из вариантов сгладить такой ущерб, который могут причинить беспечные или злонамеренные пользователи – изолировать системные ресурсы и процессы. Таким образом, даже если кто-то пожелает расширить свои полномочия сверх установленных пределов, он не получит физического доступа к данным.
Ранее эту проблему было принято решать так: на каждую службу выделяли свою физическую машину. Однако, благодаря виртуализации становится гораздо проще и дешевле выстроить «ячеистую» архитектуру. Сегодня такая архитектура часто именуется *микросервисной* и позволяет запускать сразу множество контейнеров, в одном из которых может работать, к примеру, база данных, в другом — Apache, а в третьем – медиа-файлы, которые могут встраиваться в ваши веб-страницы. Микросервисная архитектура позволяет не только значительно повысить производительность и эффективность, но и значительно снижают риск взлома каждого отдельного компонента.
«Контейнеры», о которых я говорю, не обязательно должны обладать убедительностью LXC. Сегодня гораздо популярнее становятся и другие контейнерные технологии, например, Docker.
### Проверяем наличие опасных значений пользовательского ID
Конечно, любой пользователь с правами администратора может временно предоставить рут-доступ командой `sudo`, но лишь админ — подлинный админ. Как вы уже знаете, небезопасно выполнять регулярные функции под рут-доступом. Однако, может так произойти – либо чисто случайно, либо из-за злонамеренной подделки данных — что обычный пользователь фактически без перерывов будет обладать административными правами.
В данном случае хорошо, что выявить таких самозванцев не составляет труда: их пользовательский и/или групповой ID, как и у админа, будет «0». Взгляните на файл passwd в каталоге /etc/. В этом файле содержится по записи для каждого обычного и системного пользовательского аккаунта, уже существующего в системе. В первом поле содержится имя аккаунта (в данном случае — root и ubuntu), а во втором вместо пароля может стоять x (если пароль существует – он будет в зашифрованном виде находиться в файле/etc/shadow). Но в следующих двух полях содержатся пользовательский и групповой ID. В случае с `ubuntu` в данном примере оба ID равны 1000. А у администратора, как видите, здесь стоят нули.
```
$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
[…]
ubuntu:x:1000:1000::/home/ubuntu:/bin/bash
```
Если когда-нибудь встретите обычного пользователя с пользовательским или групповым ID = 0, то можете не сомневаться, что дело тут нечисто, и ситуацию нужно исправить. Быстрый и легкий способ выявить такую проблему – проверить файл `passwd` командой `awk`, которая выведет все строки, в третьем поле которых нет ничего кроме 0. В моем случае (можно выдохнуть) нашлась всего одна такая строка – рут. Можете запустить ее повторно, заменив $4 на $3 – так вы проверите поле группового ID.
```
$ awk -F: ‘($3 == “0”) {print}’ /etc/passwd
root:x:0:0:root:/root:/bin/bash
```
### Аудит ресурсов системы
Чем больше всякой всячины работает у вас в системе, тем выше вероятность, что что-нибудь в ней сломается. Поэтому разумно отслеживать, что и как работает. Речь в данном случае идет о сетевых портах (если порт «открыт», то в него по определению должен быть вход), службах (если служба активна, то должна быть возможность ее использовать) и об установленных программах (если программа установлена, то должна быть возможность ее выполнять).
Чтобы аудит приносил пользу, он должен быть более-менее регулярным. Поскольку все мы забывчивы, гораздо лучше записать инструменты аудита в специальный скрипт, который будет не только регулярно выполняться, но и в идеале парсить результаты, чтобы они получались более удобочитаемыми.
Здесь, однако, я познакомлю вас с тремя ключевыми инструментами аудита, которые помогут вам просматривать открытые порты, активные службы и ненужные программные пакеты. Ваша задача – все это автоматизировать.
### Сканирование портов
Порт считается «открытым», если на хосте работает какой-то процесс, слушающий запросы на этом порте. Присматривая за своими открытыми портами, вы будете лучше представлять, что именно происходит у вас на сервере.
Вы уже знаете, что на обычном веб-сервере, вероятно, должны быть открыты порты HTTP (80) и SSH (22), поэтому они вас не удивят. Но гораздо важнее обращать внимание и на другие, неожиданные результаты. Команда netstat выводит все открытые порты, а также массу информации о том, как именно они используются.
В данном примере мы проверяем совершенно типичный многоцелевой сервер, и команда `-n` приказывает `netstat` включить все числовые порты и адреса. `-l` включает лишь слушающие сокеты, а `-p` добавляет ID процесса слушающей программы. Естественно, если что-то видите — действуйте.
```
# netstat -npl
Active Internet connections (only servers)
Proto Local Address Foreign Address State PID/Program name
tcp 127.0.0.1:3306 0.0.0.0:* LISTEN 403/mysqld
tcp 0.0.0.0:139 0.0.0.0:* LISTEN 270/smbd
tcp 0.0.0.0:22 0.0.0.0:* LISTEN 333/sshd
tcp 0.0.0.0:445 0.0.0.0:* LISTEN 270/smbd
tcp6 :::80 :::* LISTEN 417/apache2
[…]
```
В последние годы вместо `netstat` все чаще применяется `ss`. Просто на всякий случай: если когда-нибудь вечером окажетесь в компании, и кто-то спросит вас о ss, то этот пример (в котором перечислены все установленные SSH-соединения) должен быть достаточно информативен, чтобы вы могли не ударить в грязь лицом:
```
$ ss -o state established ‘( dport = :ssh or sport = :ssh )’
Netid Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp 0 0 10.0.3.1:39874 10.0.3.96:ssh
timer:(keepalive,18min,0)
```
### Проверяем активные службы
Если сделать быстрый мгновенный снимок служб, управляемых `system` и в настоящее время активных на вашем компьютере, то машина поможет выявить любую нежелательную активность. Команда `systemctl` может вывести список всех существующих служб, а потом их список можно сузить до тех, в описании которых содержится `enabled`. Так будут возвращены лишь активные службы.
```
# systemctl list-unit-files — type=service — state=enabled
autovt@.service enabled
bind9.service enabled
cron.service enabled
dbus-org.freedesktop.thermald.service enabled
docker.service enabled
getty@.service enabled
haveged.service enabled
mysql.service enabled
networking.service enabled
resolvconf.service enabled
rsyslog.service enabled
ssh.service enabled
sshd.service enabled
syslog.service enabled
systemd-timesyncd.service enabled
thermald.service enabled
unattended-upgrades.service enabled
ureadahead.service enabled
```
Если вы найдете что-то такое, чему тут явно не место – можете воспользоваться командой `systemctl`, и чтобы остановить службу, и чтобы убедиться, что она не перезапускается при следующей загрузке.
```
# systemctl stop haveged
# systemctl disable haveged
```
На самом деле, нет ничего темного и мрачного в службе `haveged`, которую я останавливаю в этом примере: это такой инструментик, который я часто запускаю для создания случайной фоновой системной активности, когда создаю ключи шифрования.
Поиск установленных программ
Мог ли кто-то установить в системе программы без вашего ведома? Ну, чтобы узнать – нужно посмотреть. Команда `yum list installed` или, в случае Debian/Ubuntu, `dpkg — list` выдаст вам подробную сводку, а команда remove должна удалить все пакеты, которые нам не нужны.
```
# yum list installed
# yum remove packageName
```
Вот как то же самое делается в Ubuntu:
```
# dpkg --list
# apt-get remove packageName
```
Также полезно следить за изменениями, которые вносятся в ваши системные конфигурационные файлы – об этом мы поговорим в главе 11. | https://habr.com/ru/post/425571/ | null | ru | null |
# Skype For Linux перестал поддерживать процессоры AMD старше 5 лет
Вот уже несколько месяцев, как вход в программу для владельцев многих AMD процессоров знаменуется белым окном, и никак не реагирующими пунктами меню. Насколько известно, пользователей Windows и Mac данная проблема пока не коснулась. Радость от выпуска нового Skype для GNU/Linux не была долгой…
Проблема была идентифицирована, как использование SSSE3 *(не путать с SSE3)* расширения, отсутствующего на предыдущих моделях AMD процессоров *(не исключительная ситуация, например расширение SSE4a отсутствует на Intel)*.
На запуске Skype создает три процесса, и тот, что отвечает за рендеринг, очень быстро исчезает. Приаттачится к нему, чтобы посмотреть в чем дело, довольно просто:
```
$ gdb --pid=$(pgrep -f "skypeforlinux --type=renderer")
```
Дальнейшее исполнение процесса прерывается строками:
```
Thread 17 "skypeforlinux" received signal SIGILL, Illegal instruction.
[Switching to Thread 0x7fd117f91700 (LWP 12265)]
0x00007fd11c335bc1 in ?? () from /usr/share/skypeforlinux/resources/app.asar.unpacked/node_modules/slimcore/bin/slimcore.node
(gdb) x/5i $pc
=> 0x7fd11c335bc1: pshufb %xmm1,%xmm0
0x7fd11c335bc6: movdqa 0x270(%rsp),%xmm1
0x7fd11c335bcf: cmp $0x1,%eax
0x7fd11c335bd2: pand %xmm0,%xmm1
0x7fd11c335bd6: por 0x130(%rsp),%xmm1
```
Можно лицезреть, как Skype пытается воспользоваться `pshufb` инструкцией, которую вам предоставляет SSSE3 *(или не предоставляет, если вам не повезло)*.
При наличии исходного кода, данная проблема чинится в течении пары секунд — достаточно добавить опцию `-mno-ssse3` в конфигурацию компилятора. Тем не менее, разработчикам Microsoft потребовалось пару месяцев, чтобы суметь отреагировать на такую одновременно простую и распространенную проблему. На [28 странице комментариев](https://answers.microsoft.com/en-us/skype/forum/skype_linux-skype_startms-skype_installms/skype-preview-the-most-expressive-skype-ever-is/fc717d17-03ad-4946-bb24-08b131da1840?auth=1) к статье о выпуске Skype они наконец дали официальный ответ:
> Could you please check if you have a processor without SSSE3 instruction set support? (mostly 5+ years old AMDs).
>
> If that is the case, the system is unfortunately [unsupported by Skype](https://support.skype.com/en/faq/FA10328/what-are-the-system-requirements-for-skype). In any other case, please provide us more details, so we can investigate your issue further.
*перевод:*
> Не могли бы вы, пожалуйста, проверить отсутствие поддержки вашим процессором набора инструкций SSSE3 (в основном AMD возрастом 5+ лет)?
>
> В данном случае, система, к сожалению, не [поддерживается Skype](https://support.skype.com/en/faq/FA10328/what-are-the-system-requirements-for-skype). В любом другом случае, пожалуйста снабдите нас большими деталями, чтобы мы могли расследовать проблему.
По ссылке, данной работниками Skype, в табе "Skype for Linux system requirements", можно увидеть новое требование:
> An Intel Pentium 4 processor or later that's SSE2 and SSSE3 capable
Забавно, что разработчики не только не догадались, как обойти проблему, но даже не сумели поставить обнаружение отсутствия инструкций при запуске Skype с целью показа окна о неподдерживаемой конфигурации, и элегантным выходом.
Пока неизвестно, что послужило причиной такого удара в спину пользователям, и будет ли этот удар нанесен по другим системам.
Данную проблему можно, однако, обойти, если использовать бета-версию SkypeForLinux. Но очевидно, что в долгосрочной перспективе отсутствие обновлений безопасности и патчей к возможным изменениям протокола делает это непривлекательным. Альтернативно, можно перейти на другие видео клиенты.
А что вы бы посоветовали пользователям? Дайте знать в комментариях. | https://habr.com/ru/post/407729/ | null | ru | null |
# Дорог ли native метод? «Секретное» расширение JNI
Для чего Java-программисты прибегают к native методам? Иногда, чтобы воспользоваться сторонней DLL библиотекой. В других случаях, чтобы ускорить критичный алгоритм за счет оптимизированного кода на C или ассемблере. Например, для обработки потокового медиа, для сжатия, шифрования и т.п.
Но вызов native метода не бесплатен. Порой, накладные расходы на JNI оказываются даже больше, чем выигрыш в производительности. А всё потому, что они включают в себя:
1. создание stack frame;
2. перекладывание аргументов в соответствии с [ABI](http://en.wikipedia.org/wiki/Application_binary_interface);
3. оборачивание ссылок в JNI хендлы (`jobject`);
4. передачу дополнительных аргументов `JNIEnv*` и `jclass`;
5. захват и освобождение монитора, если метод `synchronized`;
6. «ленивую» линковку нативной функции;
7. трассировку входа и выхода из метода;
8. перевод потока из состояния `in_Java` в `in_native` и обратно;
9. проверку необходимости safepoint;
10. обработку возможных исключений.
Но зачастую native методы просты: они не бросают исключений, не создают новые объекты в хипе, не обходят стек, не работают с хендлами и не синхронизованы. Можно ли для них не делать лишних действий?
Да, и сегодня я расскажу о недокументированных возможностях HotSpot JVM для ускоренного вызова простых JNI методов. Хотя эта оптимизация появилась еще с первых версий Java 7, что удивительно, о ней еще никто нигде не писал.
#### JNI, каким мы его знаем
Рассмотрим для примера простой native метод, получающий на вход массив `byte[]` и возвращающий сумму элементов. Есть несколько способов работы с массивом в JNI:
* `GetByteArrayRegion` – копирует элементы Java массива в указанное место нативной памяти;
**Пример GetByteArrayRegion**
```
JNIEXPORT jint JNICALL
Java_bench_Natives_arrayRegionImpl(JNIEnv* env, jclass cls, jbyteArray array) {
static jbyte buf[1048576];
jint length = (*env)->GetArrayLength(env, array);
(*env)->GetByteArrayRegion(env, array, 0, length, buf);
return sum(buf, length);
}
```
* `GetByteArrayElements` – то же самое, только JVM сама выделяет область памяти, куда будут скопированы элементы. По окончании работы с массивом необходимо вызвать ReleaseByteArrayElements.
**Пример GetByteArrayElements**
```
JNIEXPORT jint JNICALL
Java_bench_Natives_arrayElementsImpl(JNIEnv* env, jclass cls, jbyteArray array) {
jboolean isCopy;
jint length = (*env)->GetArrayLength(env, array);
jbyte* buf = (*env)->GetByteArrayElements(env, array, &isCopy);
jint result = sum(buf, length);
(*env)->ReleaseByteArrayElements(env, array, buf, JNI_ABORT);
return result;
}
```
* Зачем, спросите вы, делать копию массива? Но ведь работать с объектами в Java Heap напрямую из натива нельзя, так как они могут перемещаться сборщиком мусора прямо во время работы JNI метода. Однако есть функция `GetPrimitiveArrayCritical`, которая возвращает прямой адрес массива в хипе, но при этом запрещает работу GC до вызова `ReleasePrimitiveArrayCritical`.
**Пример GetPrimitiveArrayCritical**
```
JNIEXPORT jint JNICALL
Java_bench_Natives_arrayElementsCriticalImpl(JNIEnv* env, jclass cls, jbyteArray array) {
jboolean isCopy;
jint length = (*env)->GetArrayLength(env, array);
jbyte* buf = (jbyte*) (*env)->GetPrimitiveArrayCritical(env, array, &isCopy);
jint result = sum(buf, length);
(*env)->ReleasePrimitiveArrayCritical(env, array, buf, JNI_ABORT);
return result;
}
```
#### Critical Native
А вот и наш секретный инструмент. Внешне он похож на обычный JNI метод, только с приставкой `JavaCritical_` вместо `Java_`. Среди аргументов отсутствуют `JNIEnv*` и `jclass`, а вместо `jbyteArray` передаются два аргумента: `jint length` – длина массива и `jbyte* data` – «сырой» указатель на элементы массива. Таким образом, Critical Native методу не нужно вызывать дорогие JNI функции `GetArrayLength` и `GetByteArrayElements` – можно сразу работать с массивом. На время выполнения такого метода GC будет отложен.
```
JNIEXPORT jint JNICALL
JavaCritical_bench_Natives_javaCriticalImpl(jint length, jbyte* buf) {
return sum(buf, length);
}
```
Как видим, в реализации не осталось ничего лишнего.
Но чтобы метод мог стать Critical Native, он должен удовлетворять строгим ограничениям:
* метод должен быть `static` и не `synchronized`;
* среди аргументов поддерживаются только примитивные типы и массивы примитивов;
* Critical Native не может вызывать JNI функции, а, следовательно, аллоцировать Java объекты или кидать исключения;
* и, самое главное, метод должен **завершаться за короткое время**, поскольку на время выполнения он блокирует GC.
Critical Natives задумывался как приватный API Хотспота для JDK, чтобы ускорить вызов криптографических функций, реализованных в нативе. Максимум, что можно найти из описания – [комментарии к задаче в багтрекере](https://bugs.openjdk.java.net/browse/JDK-7013347). Важная особенность: `JavaCritical_` функции вызываются только из горячего (скомилированного) кода, поэтому помимо `JavaCritical_` реализации у метода должна быть еще и «запасная» традиционная JNI реализация. Впрочем, для совместимости с другими JVM так даже лучше.
#### Сколько будет в граммах?
Давайте, измерим, какова же экономия на массивах разной длины: 16, 256, 4KB, 64KB и 1MB. Естественно, с помощью [JMH](http://openjdk.java.net/projects/code-tools/jmh/).
**Бенчмарк**
```
@State(Scope.Benchmark)
public class Natives {
@Param({"16", "256", "4096", "65536", "1048576"})
int length;
byte[] array;
@Setup
public void setup() {
array = new byte[length];
}
@GenerateMicroBenchmark
public int arrayRegion() {
return arrayRegionImpl(array);
}
@GenerateMicroBenchmark
public int arrayElements() {
return arrayElementsImpl(array);
}
@GenerateMicroBenchmark
public int arrayElementsCritical() {
return arrayElementsCriticalImpl(array);
}
@GenerateMicroBenchmark
public int javaCritical() {
return javaCriticalImpl(array);
}
static native int arrayRegionImpl(byte[] array);
static native int arrayElementsImpl(byte[] array);
static native int arrayElementsCriticalImpl(byte[] array);
static native int javaCriticalImpl(byte[] array);
static {
System.loadLibrary("natives");
}
}
```
**Результаты**
```
Java(TM) SE Runtime Environment (build 1.7.0_51-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.51-b03, mixed mode)
Benchmark (length) Mode Samples Mean Mean error Units
b.Natives.arrayElements 16 thrpt 5 7001,853 66,532 ops/ms
b.Natives.arrayElements 256 thrpt 5 4151,384 89,509 ops/ms
b.Natives.arrayElements 4096 thrpt 5 571,006 5,534 ops/ms
b.Natives.arrayElements 65536 thrpt 5 37,745 2,814 ops/ms
b.Natives.arrayElements 1048576 thrpt 5 1,462 0,017 ops/ms
b.Natives.arrayElementsCritical 16 thrpt 5 14467,389 70,073 ops/ms
b.Natives.arrayElementsCritical 256 thrpt 5 6088,534 218,885 ops/ms
b.Natives.arrayElementsCritical 4096 thrpt 5 677,528 12,340 ops/ms
b.Natives.arrayElementsCritical 65536 thrpt 5 44,484 0,914 ops/ms
b.Natives.arrayElementsCritical 1048576 thrpt 5 2,788 0,020 ops/ms
b.Natives.arrayRegion 16 thrpt 5 19057,185 268,072 ops/ms
b.Natives.arrayRegion 256 thrpt 5 6722,180 46,057 ops/ms
b.Natives.arrayRegion 4096 thrpt 5 612,198 5,555 ops/ms
b.Natives.arrayRegion 65536 thrpt 5 37,488 0,981 ops/ms
b.Natives.arrayRegion 1048576 thrpt 5 2,054 0,071 ops/ms
b.Natives.javaCritical 16 thrpt 5 60779,676 234,483 ops/ms
b.Natives.javaCritical 256 thrpt 5 9531,828 67,106 ops/ms
b.Natives.javaCritical 4096 thrpt 5 707,566 13,330 ops/ms
b.Natives.javaCritical 65536 thrpt 5 44,653 0,927 ops/ms
b.Natives.javaCritical 1048576 thrpt 5 2,793 0,047 ops/ms
```
Оказывается, для маленьких массивов стоимость JNI вызова в разы превосходит время работы самого метода! Для массивов в сотни байт накладные расходы сравнимы с полезной работой. Ну, а для многокилобайтных массивов способ вызова не столь важен – всё время тратится собственно на обработку.
#### Выводы
Critical Natives – приватное расширение JNI в HotSpot, появившееся с JDK 7. Реализовав JNI-подобную функцию по определенным правилам, можно значительно сократить накладные расходы на вызов native метода и обработку Java-массивов в нативном коде. Однако для долгоиграющих функций такое решение не подойдет, поскольку GC не сможет запуститься, пока исполняется Critical Native. | https://habr.com/ru/post/222997/ | null | ru | null |
# Ускоренная сборка Kotlin с помощью Kotlin Symbol Processing 1.0
[Kotlin Symbol Processing](https://github.com/google/ksp) (KSP), наш новый инструмент для создания легких плагинов компилятора на языке Kotlin, теперь стабилен! KSP обладает функциональностью, схожей с Kotlin Annotation Processing Tool ([KAPT](https://kotlinlang.org/docs/reference/kapt.html)), однако работает в 2 раза быстрее, предоставляет прямой доступ к конструкциям языка Kotlin и поддерживает многоплатформенные задачи.
За последние несколько месяцев KSP пережил 32 релиза, в которых было исправлено более 162 ошибок, о которых сообщили представители сообщества и которые были исправлены нашей командой. Если вы ждали, когда сможете перейти на использование KSP, сейчас пришло самое время проверить его.
### Почему мы создали KSP
В команде Android мы регулярно спрашиваем разработчиков: "Что вас больше всего раздражает в написании приложений на сегодняшний день? Один из главных вопросов, который неоднократно поднимается, — это скорость сборки. На протяжении многих лет мы постоянно улучшали инструментарий сборки Android, и сегодня мы рады добавить к этим улучшениям KSP. KSP — это следующее поколение обработки аннотаций в Kotlin: он значительно повысит скорость сборки для разработчиков Kotlin, и в отличие от KAPT, он предлагает поддержку Kotlin/Native и Kotlin/JS.
> «Добавление поддержки KSP в Room улучшило скорость компиляции, а также позволило Room лучше понимать код Kotlin, например, способность дженериков принимать нулевые значения, что было невозможно с KAPT. Это также открывает новые возможности, такие как генерация кода Kotlin, что позволит Room в будущем иметь лучший пользовательский опыт работы с Kotlin.» — Игит Бояр, инженер-программист, Android
>
>
### Почему KSP работает быстрее?
Kotlin Annotation Processing Tool ([KAPT](https://kotlinlang.org/docs/reference/kapt.html)) работает с инфраструктурой обработки аннотаций Java, чтобы большинство процессоров аннотаций языка Java работали в Kotlin "из коробки". Для этого KAPT компилирует код Kotlin в Java-заглушки, сохраняющие информацию, которая важна процессорам аннотаций Java. Однако создание таких заглушек требует больших затрат и означает, что компилятор должен разрешить все символы в вашей программе несколько раз (один раз для генерации заглушек, а затем еще раз для фактической компиляции).
KSP уходит от модели генерации заглушек, работая как плагин для компилятора Kotlin — он позволяет процессорам аннотаций читать и анализировать исходные программы и ресурсы непосредственно в Kotlin, вместо того чтобы требовать зависимости от инфраструктуры обработки аннотаций Java. Это значительно повышает скорость сборки (до 2 раз быстрее для Room, [тестового приложения на Kotlin](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:room/integration-tests/kotlintestapp/)) и означает, что KSP можно использовать в средах, отличных от Android и JVM, таких как Kotlin/Native и Kotlin/JS.
### Как начать работу
Чтобы начать применение KSP, загрузите [проект KSP playground](https://github.com/google/ksp/releases/download/1.5.30-1.0.0/artifacts.zip) с GitHub, который показывает, как использовать KSP и как процессор аннотаций, и в виде пользовательского приложения/библиотеки:
* **Процессор аннотаций**: Библиотека test-processor, использует шаблон конструктора в виде процессора KSP.
* **Библиотека пользователя**: Каталог workload, который показывает, как использовать процессор конструктора (builder processor) в Kotlin-проекте.
Если вы разработчик приложений, ознакомьтесь со [списком поддерживаемых библиоте](https://github.com/google/ksp#supported-libraries)к и руководством по [быстрому запуску](https://github.com/google/ksp/blob/main/docs/quickstart.md) для переноса модуля из KAPT в KSP.
### Использование Moshi или Room с KSP
Если вы используете Moshi или Room в своем проекте, то уже сейчас можете попробовать KSP, внеся быстрое исправление в файл сборки вашего модуля. Например, чтобы использовать KSP-версию Room в модуле Gradle, достаточно заменить плагин KAPT на KSP и поменять местами зависимости KSP:
```
apply plugin: 'com.google.devtools.ksp'
dependencies {
...
implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"
ksp "androidx.room:room-compiler:$room_version"
}
```
Ознакомьтесь с [примечаниями к релизу Room](https://developer.android.com/jetpack/androidx/releases/room#2.3.0-beta02) для получения дополнительной информации.
### Заключение
С выходом версии 1.0 KSP скорость сборки ваших Kotlin-проектов будет возрастать по мере перехода от библиотек, основанных на KAPT. Мы также обновили ряд библиотек для Android, доступных уже сегодня и обеспечивающих значительное повышение производительности.
---
> Материал подготовлен в рамках курса ["Kotlin QA Engineer"](https://otus.pw/Exab/). Всех желающих приглашаем на demo-занятие **«Тестирование нативных приложений на Kotlin Native»**. На занятии рассмотрим основы нативной разработки для Android/iOS, попробуем сделать и протестировать простое приложение по работе с данными на стороне платформы, а также научимся подключать сторонние библиотеки для Android/iOS (на примере OpenCV).
> [**>> РЕГИСТРАЦИЯ**](https://otus.pw/116o/)
>
> | https://habr.com/ru/post/583234/ | null | ru | null |
# Как устроен Kubernetes as a Service на платформе VK Cloud Solutions
Российские провайдеры давно умеют делать облачные платформы сами, а не только реселлить зарубежные. Это снижает стоимость сервисов, но их пользователям бывает интересно узнать, какая у них начинка и что обеспечивает их надёжность.
Я Дмитрий Лазаренко, директор по продуктам облачной платформы VK Cloud Solutions (ранее — Mail.ru Cloud Solutions). Сегодня я расскажу, что под капотом [у нашего Kubernetes aaS](https://mcs.mail.ru/containers/), как обеспечивается его надёжность и какие у него есть интересные функциональности, которыми любят пользоваться наши клиенты. Это автомасштабирование, интеграция с другими PaaS нашей платформы и многое другое.
Главные фичи Kubernetes на платформе VK CS
------------------------------------------
Наш Kubernetes aaS включает:
* Интерфейс управления для создания кластера в несколько кликов, масштабирования и настройки.
* Автоматическое масштабирование узлов кластера в большую или меньшую сторону, то есть добавление или удаление нод (Cluster Autoscaler).
* Встроенный мониторинг на основе Prometheus Operator и Grafana. Многие наши пользователи начинают с базовых инсталляций, где запускается приложение. Когда оно выходит в продуктив, это позволяет им мониторить сервисы и сам кластер.
* Свой Terraform-провайдер для Kubernetes. Он полностью поддерживает API VK CS.
* Интеграция с Docker Registry для хранения и управления образами.
* Автоматизированное развёртывание федеративных кластеров Kubernetes на базе AWS и VK Cloud Solutions (о чём [мы писали тут](https://habr.com/ru/company/mailru/news/t/509684/)).
* Возможность сделать Start/Stop для кластера целиком — экономия для тестовых сред. Вы можете выключить кластер одним кликом в интерфейсе и платить только за диски в случае остановленных кластеров.
* Поддержка создания Node Pools, пулов виртуальных машин разных размеров: можно запускать тяжелые задачи на больших машинах, веб-приложения на маленьких. Масштабировать группы можно независимо и размещать их в разных регионах либо зонах доступности (для большей надежности и доступности).
* Persistent Volumes интегрированы с системой хранения OpenStack.
* Поддержка приватных кластеров, доступных только через VPN-соединение.
* Поддерживается Cluster Policy: Local, которая позволяет получать реальные IP пользователей внутри кластеров.
* Создание и масштабирование кластеров Kubernetes с помощью UI или API VK CS, управление сущностями через Kubernetes dashboard и kubectl.
* Плавное обновление (rolling update) в один клик без простоя как для минорных, так и для мажорных версий. Обновления кластеров до 1.16.
* На момент написания статьи мы поддерживаем Kubernetes вплоть до версии 1.21.
*Создание кластера Kubernetes в несколько кликов*
Дальнейшее развитие сервиса:
* **CI/CD aaS**, интегрированный с Kubernetes и другими сервисами платформы: дополнительные сервисы, которые обеспечивают CI/CD, на базе наших собственных доработок OpenStack.
* **Логирование aaS** для приложений приложений, которые работают в нашем Kubernetes. Логирование будет реализовано на базе нескольких решений OpenStack.
* **Service mesh:** у нас появятся плагины для Kubernetes, которые в рамках реализации service mesh будут выполнять шифрование, бэкапирование и другие функции.
Сертификация дистрибутива в Cloud Native Computing Foundation
-------------------------------------------------------------
VK Cloud Solutions входит в CNCF (Cloud Native Computing Foundation). Дистрибутив Kubernetes от VK CS получил сертификат Certified Kubernetes — Hosted. Его проверили на надежность и соответствие стандартам, он отвечает всем функциональным требованиям сообщества и совместим со стандартным Kubernetes API. VK CS — пока единственный в России облачный провайдер, получивший такую сертификацию.
Место Kubernetes в инфраструктуре облачной платформы
----------------------------------------------------
Самый нижний слой — типовые физические серверы (compute nodes). Сейчас их несколько тысяч, они используются под вычисления и хранение. Для хранения мы предоставляем файловые и блочные хранилища на базе Ceph и S3-совместимые объектные хранилища. Серверы распределены по дата-центрам, между которыми проложена сеть 40 Gbps.
Поверх уровня серверов работает OpenStack, который обеспечивает виртуализацию для пользовательских окружений. А уже поверх виртуальных машин, сетей и балансировщиков работают PaaS-решения: Kubernetes, базы данных, DWH на базе ClickHouse, Hadoop, Spark и другие.
Аналогичную схему мы строим и в приватных инсталляциях Kubernetes как сервиса в дата-центрах наших заказчиков в формате частного облака.
*Архитектура облачной платформы*
Интеграция Kubernetes с облаком не односторонняя. Kubernetes не просто развертывается на виртуальных машинах, он полностью интегрируется с IaaS OpenStack.
На основе провайдера Cloud Provider OpenStack мы сделали Cloud Provider для VK CS, который в рамках вашего проекта (тенанта) OpenStack соединяется с API VK CS и создает, конфигурирует, удаляет диски, балансеры, внешние IP-адреса, подключает их к нодам Kubernetes, конфигурирует security-группы (фактически виртуальный firewall). Без Cloud Provider создание тех же Persistent Volumes — головная боль для всех, кто запускает Kubernetes on-premise, на железе либо просто в облаке.
*Интеграция Kubernetes с IaaS OpenStack*
Какие инструменты мы используем
-------------------------------
1. **Операционная система**. Сейчас на хостах работает Fedora Atomic (1.14-1.15) и CentOS (1.16). Но эти дистрибутивы больше не будут развиваться, поэтому скоро мы перейдем на Oracle Linux.
2. **Сеть** — Calico. Сети Kubernetes зависят от облачной сети, которая обеспечивается SDN всего облака. В основе нашей SDN изначально был OpenStack Neutron. Но год назад мы начали разработку модуля Sprut — нашего собственного SDN-решения, которое поддерживает API Neutron, но работает по другим принципам. Подход Sprut решил наши проблемы масштабируемости, возникающие из-за десятков тысяч сетевых сущностей (портов) у нас в облаке, когда при падении сетевых нод в сети такого размера начинался процесс полной синхронизации (fullsync). Сейчас Sprut мы задействуем для тех клиентов, для которых в силу особенностей нагрузки на сеть использовать его целесообразнее, чем Calico, в перспективе мы его откроем для всех.
3. **Кластерный DNS** на базе CoreDNS, со всеми его Service Discovery, метриками Prometheus и другими стандартными фичами.
4. **Ingress Controller**. Сейчас это Nginx, но мы также планируем добавить Envoy, как дополнительный Ingress Controller. Наши тесты показывают, что Envoy часто быстрее. Ingress Controller интегрирован с облачным балансировщиком нагрузки на базе OpenStack Octavia и поддерживает Proxy Protocol.
5. **Мониторинг** на базе Prometheus Operator. Раньше использовали просто Prometheus, но сейчас все хотят автоматизацию и сервис-мониторы, поэтому мы уже несколько месяцев предлагаем Prometheus Operator + Grafana, в рамках которой можно добавлять сервис-мониторы и выполнять мониторинг кластеров.
6. **Аддоны (опциональные расширения)**. В один клик можно установить Docker registry, интегрированный с нашим S3-хранилищем, ingress controller, различные системы мониторинга (Heapster, Prometheus).
Multi Master и сетевая топология
--------------------------------
Kubernetes от VK CS поддерживает деплой в формате Multi Master, при этом каждая пользовательская группа нод уже находится в конкретной зоне доступности.
*Multi Master в облаке*
В Multi Master etcd работает в кластерном режиме, так что если что-то случается с одним из мастеров, другие продолжают работать. Под каждый etcd выделен отдельный SSD-диск, что обеспечивает хороший latency и быструю работу API-сервера, т.к. в etcd находится служебная информация о всех ресурсах кластера Kubernetes.
Для доступа извне используется балансировщик нагрузки API сервера Kubernetes, который имеет внешний IP-адрес. При этом все ноды — и мастера, и миньоны — находятся в приватной сети (фактически в виртуальном частном облаке) и не имеют публичных адресов.
Доступ к кластеру Kubernetes из публичной сети: запуск трафика и балансировка нагрузки
--------------------------------------------------------------------------------------
В общем случае способы доступа к сервисам внутри кластера [перечислены здесь](https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types). Подробности нашей реализации:
**NodePort** открывает публичный порт на ноде. Однако есть ограничение: в целях безопасности по умолчанию публичные IP-адреса не установлены ни на мастера, ни на миньоны, кластеры создаются без белых IP-адресов. Пользователь может их сам установить.
**Load Balancer**. Наш Kubernetes интегрирован с облачной платформой VK CS, так что платформа предоставляет Load Balancer как сервис и может сама создавать балансировщики. Для сравнения, если пользователь настраивает Kubernetes (например, в он премисе), нужно самостоятельно поднимать и настраивать софтверные балансеры. На платформе VK CS балансировщики поднимаются сразу в отказоустойчивом режиме active-standby. Когда поднимается основной балансер (на HAProxy), у него всегда есть standby, спящий балансер. Между ними настроен VRRP. Если основной балансер отказывает, весь трафик мгновенно переключается на standby, при этом IP-адрес не меняется.
*Отказоустойчивый Load Balancer как сервис на платформе VK CS. Kubernetes создаёт nodeport на каждой ноде и балансировщик*
В настройке балансировки для Kubernetes помогает наш Cloud Provider. Нужно создать манифест, в котором пользователь указывает тип манифеста «сервис» и тип сервиса «Load Balancer». После деплоя этого манифеста Kubernetes (точнее, Cloud Provider, который работает в Kubernetes) обращается к OpenStack API, создаёт балансировщик и внешний IP-адрес, если это необходимо. Если внешний адрес не нужен, нужно поставить аннотацию, что требуется внутренний балансировщик, и можно пускать трафик на кластер, не открывая публичный IP-адрес на каждой ноде.
```
apiVersion: v1
kind: Service
metadata:
name: nginx
labels:
k8s-app: nginx-backend
annotations:
service.beta.kubernetes.io/openstack-internal-load-balancer:"true"
spec:
type: LoadBalancer
externalTrafficPolicy: Cluster
selector:
k8-app: nginx-backend
ports:
-port: 80
name: http
targetPort: http
-port: 443
name: https
targetPort: httpn
```
*Сервисный манифест для создания балансировщика нагрузки с помощью Cloud Provider*
Не всегда удобно создавать по балансеру на каждый сервис, 10 сервисов — есть 10 балансировщиков, 50 сервисов — 50 балансировщиков. Ими потом также приходится управлять, это тяжелые сущности. Эту проблему решает Ingress.
**Ingress**. Чтобы можно было не создавать много балансировщиков, мы добавили поддержку Ingress Controller. Ingress Controller интегрирован с балансировщиком OpenStack. То есть в декларации сервиса конкретного Ingress Controller указан тип Load Balancer. Для кластера создается один балансировщик, по которому Ingress Controller работает и дальше распределяет трафик по сервисам. Ingress Controller балансирует по DNS-именам.
*Схема работы Ingress*
Для некоторых клиентов было важно, чтобы в подах было видно IP-адреса клиентов, получающих доступ в кластер. При балансировке теряются заголовки IP-пакетов: приложение не получает реальный IP-адрес клиента. Балансировщик OpenStack ещё видит заголовок X-Forwarded-For, но Ingress Controller и под его уже не получают. Это не позволяет настроить доступ пользователей по White Lists, не работают сервисы типа GeoIP или anti-DDoS, которым нужно видеть реальные IP-адреса клиентов.
*IP-адрес клиента не доходит до пода*
И здесь у нас оказалось два решения:
**Сделать режим proxy-протокола как в Amazon**. Ради этой возможности мы перешли на балансировщик OpenStack Octavia, так как в стандартном балансировщике OpenStack нет такой опции. В итоге мы сделали новый балансировщик, который поддерживал как TCP-балансировку, так и HTTP с терминацией SSL.
При этом поддержку proxy-протокола нужно включать как на самом балансировщике (HAproxy), так и на Nginx Ingress Controller, который выступает таким приемником. Иначе схема пропускания трафика ломается. Также важно, что SSL-терминация, если у вас стандартный веб-трафик, должна проходить на Ingress:
**Терминация SSL на балансировщике**. Здесь на балансер приходит HTTPS, он расшифровывается, и в кластер идет HTTP. Если всё это сделать и активировать в сервисе ExternalTrafficPolicy: Local, вы будете видеть заголовки IP-пакетов:
Storage и Kubernetes
--------------------
Если разворачивать Kubernetes локально или в облаке просто на виртуальных машинах, то по умолчанию в нем нет нормальной работы с постоянными дисками. Можно использовать Host Path, Local volume (no-provisioner), либо прямо в кластере Kubernetes разворачивать экзотические программно-определяемые системы хранения типа Linstor или OpenEBS. Но что произойдет с данными или очередью данных, которая размещается в кластере, если умрет нода или под?
При самостоятельном подключении блочных устройств к кластеру есть проблемы: CSI-драйверы не идеальны для многих типов стораджей, и автоматическое перемонтирование может не произойти. Мы сделали работу с блочными устройствами автоматизированной. Чтобы при отключении пода блочное устройство переподключалось к новому поду само.
Мы используем Ceph. Главное, что они работают через OpenStack, который предоставляет специальные модули, абстрагирующие Kubernetes (или любые виртуальные машины, работающие в облаке), на конкретных драйверах — OpenStack Cinder.
У нас несколько разных storage-классов, которые работают в Kubernetes: SSD Ceph, HDD Ceph, геораспределенные Ceph между нашими ЦОДами. Есть storage-класс, отвечающий за блочные диски: фактически это дисковые шкафы с SSD, они подключаются к хост-машинам по iSCSI.
*Несколько Storage-классов в MCS*
При необходимости мы **используем NFS**, когда клиенты не могут переписать приложения в микросервисную архитектуру. У нас есть аналог сервиса EFS от Amazon — файловое хранилище с NFS-протоколом, доступное как сервис. Оно подходит, если у вас legacy-приложение, которое вы переводите в Kubernetes.
Кроме того, у нас есть **локальные SSD**, но здесь сложно гарантировать их доступность и переезд данных, поскольку они доступны только с физических серверов, к которым подключены.
Всё это подключается через единый модуль OpenStack — OpenStack Cinder, к каждой ноде Kubernetes и обеспечивает возможность переезда стораджа в случае падения ноды. А также когда повышается нагрузка чтения/записи и Kubernetes решает перевозить неважные поды на другие ноды — тогда он автоматически переводит монтирование этого диска к другим Kubernetes-нодам.
*Так происходит автоматическое перемонтирование*
Можно использовать storage class, написав декларации PersistentVolumeClaim. На примере, который изображён ниже, Cloud Provider выделит в заданной зоне доступности новый Persistent Volume, размером 30 ГБ с типом диска SSD, подключит его к ноде и примонтирует к подам. Также он будет следить, чтобы этот диск переезжал между нодами в случае переезда подов:
```
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: nginx-pvc-ssd
spec:
accessModes:
-ReadWriteOnce
storageClassName: dp1-ssd
resources:
requests:
storage: 30Gi
```
Автоматическое масштабирование
------------------------------
В VK CS есть Cluster Autoscaler. Это не просто автоскейлинг подов внутри кластера, а автоскейлинг самого кластера по необходимости: новые ноды добавляются, когда нагрузка выросла, и удаляются, если нагрузка упала. Масштабирование происходит автоматически — до 100 узлов и обратно за несколько минут.
Автоскейлинг позволяет для каждой группы узлов задать свои правила автомасштабирования, например максимальное и минимальное число нод, которое может задать автоскейлер.
Cluster Autoscaler лучше настраивать совместно с Horizontal Pod Autoscaler. Различие использования двух вариантов Autoscaler:
* Cluster Autoscaler позволяет расширять сами выделенные для кластера ресурсы. По сути он может автоматически арендовать дополнительные ресурсы или сократить их использование через Cloud Provider.
* Horizontal Pod Autoscaler позволяет расширять ресурсы подов в рамках существующих выделенных ресурсов кластера, чтобы оптимально их использовать.
*Настройка автоскейлинга*
Функциональности
----------------
### Совместимость со стандартными инструментами Kubernetes
Так как наш Kubernetes aaS полностью совместим со стандартным Kubernetes API, вы можете свободно пользоваться всеми возможностями экосистемы Kubernetes.
* Хранение и обработка serverless-функций в контейнерах: OpenFaaS, OpenWhisk, Kubeless.
* Инструменты Service Mesh: Istio, Consul, Linkerd.
* Мониторинг, аналитика, логирование: Prometheus, Fluentd, Jaeger, OpenTracing.
* CI/CD: Gitlab, CircleCI, Travis CI.
* IaC (описание приложений): Terraform, Helm.
И многие другие инструменты.
Про Terraform отдельно стоит сказать, что стандартный провайдер OpenStack не был полностью совместим с API платформы VK CS, так что мы сделали собственный Terraform-провайдер, который полностью совместим с последней версией API VK CS. Поддержка API включает:
* листинг ресурсов VK CS (cluster, cluster template, node group)
* поддержку managed node groups
* поддержку действий через API: создание/удаление, горизонтальное и вертикальное масштабирование, включение/выключение кластера, обновление версии.
### Безопасность
* Kubernetes использует аутентификацию по сертификатам.
* Систему безопасности кластеров можно интегрировать с LDAP/Active Directory для аутентификации пользователей. При этом ролевую модель безопасности в Kubernetes можно настроить на проверку прав доступа на основе принадлежности пользователя к группам в LDAP-каталоге.
* Для сетевой безопасности можно применять Calico Network Policy.
* В наш Kubernetes aaS интегрирован Docker Registry, защищённый SSL.
* Планируем реализовать SSO (single sign-on) в интеграции с нашим IAM (identity and access management) на уровне OpenStack.
### Резервное копирование и миграция
* Мы поддерживаем интеграцию с Velero. Velero выполняет резервное копирование, которое позволяет бэкапить манифесты etcd и Persistent Volumes, вот [гайд по тому, как это сделать](https://mcs.mail.ru/help/velero-backup-k8?kb_language=ru_RU).
* Также с помощью Velero можно мигрировать кластеры on-premises и других провайдеров на наш Kubernetes.
* Или запросите миграцию на наш Kubernetes «под ключ». Поможем.
### Работа с большими данными
Kubernetes по сути можно использовать для любых микросервисных приложений, работающих с данными. Чем Kubernetes на платформе MCS интересен для data scientist’ов:
* Автомасштабирование позволяет выдерживать большие вычислительные нагрузки.
* Можно создавать событийные (event-triggered) обработчики данных.
* Приложения на Kubernetes легко интегрировать с другими нашими PaaS для Big Data, машинного обучения, в рамках одной сети.
* Если хочется поэкспериментировать, то для ускорения обучения к очереди событий или событийному обработчику на базе Kubernetes можно напрямую подключить GPU.
Ещё о нашем Kubernetes aaS
--------------------------
1. Попробовать бесплатно наш Kubernetes aaS [можно тут](https://mcs.mail.ru/app/services/containers/).
2. В этих двух Telegram-каналах вас ждут [новости нашего Kubernetes aaS](https://t.me/mcsnews) и анонсы [мероприятий @Kubernetes meetup](https://t.me/k8s_mail). | https://habr.com/ru/post/519366/ | null | ru | null |
# Canvas & SVG: работаем с графикой
В HTML5 представлено два элемента для работы с web графикой: Canvas и SVG. Две эти технологии достаточно сильно отличаются друг от друга. Важно знать об их преимуществах и недостатках, чтобы выбрать наиболее подходящую для конкретной задачи технологию. Элемент SVG позволяет создавать векторную графику, а элемент Canvas предназначен для создания растровых изображений. Элемент Сanvas также используется технологией WebGL для аппаратного ускорения 3D-графики.
### **SVG**
Масштабируемая векторная графика (Scalable Vector Graphics — SVG) является языком разметки, расширенным из XML для описания двухмерной векторной графики.
Для создания изображения в векторной графике используются геометрические примитивы (точки, линии, кривые, многоугольники). С их помощью можно создавать масштабируемые изображения, которые не теряют в качестве при масштабировании.
SVG — технология рисования с хранением объектов в памяти (Retained mode graphics). Как и HTML, SVG имеет объектную модель документа (DOM). DOM в SVG, как и в HTML, имеется модель событий. Это значит, что при использовании этой технологии для реализации интерактивных действий (таких как управление мышью и т.п.) со стороны программиста требуется меньше усилий, поскольку события привязываются непосредственно к элементам DOM.
SVG имеет как обычные атрибуты, так и атрибуты представления. Ключевым моментом является то, что к атрибутам представления можно применять стили в соответствии с правилами использования стилей CSS. К примеру, для изменения цвета фигуры можно применять свойство fill.
Для встраивания SVG в документ используется элемент .
Пример 1: Рисование линии
```
```
Пример 2: Рисование круга с заливкой
HTML:
```
```
CSS:
```
svg {
fill: blue;
}
```
### **Canvas 2d**
<Сanvas> — это HTML элемент, который используется для создания растровой графики при помощи JavaScript. Элемент предоставляет удобный API для рисования 2D графики с помощью JavaScript.
В отличии от svg, canvas работает с растровой графикой. Это технология мгновенного рисования, она не хранит свои элементы в дереве DOM, следовательно нет никакого способа изменить существующий рисунок или реагировать на события. Это означает, что, когда потребуется новый кадр, необходимо будет отрисовать всю сцену заново.
Элемент имеет только два атрибута — ширину и высоту. Если атрибуты высоты и ширины не установлены, то согласно [спецификации html5](https://www.w3.org/TR/2012/WD-html5-author-20120329/the-canvas-element.html#the-canvas-element) ширина элемента canvas будет равна 300 пикселям, а высота 150. При изменении этих атрибутов canvas очищается.
Также можно выставить размеры произвольно в CSS, но во время рендеринга изображение будет масштабироваться в соответствии с его размером и ориентацией. Это может привести к тому, что изображение будет выглядеть искаженным.
Для рисования в первую очередь необходимо получить доступ к контексту, который предоставляет API для создания графики. Контекст можно получить при помощи метода getContext() элемента canvas. В качестве первого параметра необходимо указать тип контекста, который мы хотим использовать. На данный момент большинство современных браузеров поддерживает 2 типа контекста «2d» ( позволяет создавать 2-х мерную графику) и «webgl» (позволяет использовать технологию WebGL для создания трехмерной графики). Если указанный тип контекста не поддерживается браузером, метод getContext() возвращает null.
Пример: Рисование линии
```
const canvas = document.getElementById('canvas');
const context = canvas.getContext('2d');
context.beginPath();
context.moveTo(5, 5);
context.lineTo(500, 60);
context.lineWidth = 3;
context.strokeStyle = '#b4241b';
context.stroke();
```
### **WebGL**
WebGL — это еще одна новая технология, которая использует элемент canvas для создания графики. WebGL позволяет веб-контенту использовать API, основанный на OpenGL ES 2.0, для визуализации трехмерной графики, но возможно работать и с двухмерной графикой.
Для начала рисования так же, как и в предыдущем случае, необходимо получить доступ к контексту. Это делается при помощи метода getContext. В качестве типа контекста необходимо указать webgl либо experimental-webgl. Контекст, именуемый как «experimental-webgl» — это временное имя для контекста, используемое на время процесса разработки спецификации.
WebGL работает с растровой графикой, соответственно, особенности описанные в предыдущем абзаце, применимы и к этой технологии. Но для WebGL характерна более высокая производительность (сравнимая с производительностью нативных приложений), поскольку WebGL использует средства аппаратного ускорения графики.
### **Сравнение технологий**
Выбор конкретной технологии зависит от задач и целей конкретного проекта. На одном из проектов была поставлена задача отриcовки графиков с большим количеством точек (порядка 10 000 точек), должна была быть предусмотрена возможность масштабирования и перемещения графиков, а также перерисовка графиков в случае изменения данных на сервере.
Один из самых важных параметров, который учитывался при выборе технологии, была производительность. Этот параметр зависит от количества объектов и площади поверхности. В общем случае, по мере увеличения числа объектов на экране производительность SVG падает, поскольку объекты постепенно добавляются в модель DOM, тогда как производительность canvas почти не изменяется. WebGL имеет очень хорошую производительность, однако не все современные браузеры поддерживают данную технологию, к примеру IE начал поддерживать webGL начиная только с 11 версии. Поддержка WebGL на мобильных браузерах достаточно ограниченна, большинство мобильных браузеров начали поддерживать WebGL только с 2017 года. Некоторые мобильные браузеры на данный момент вообще не поддерживают данную технологию.
К тому же, помимо поддержки WebGL браузером, необходима также его поддержка графическим процессором клиента. Некоторые браузеры могут отключить поддержку WebGL на устройствах со старыми графическими процессорами. Подробнее об этих ограничениях можно узнать в [этой статье.](https://www.khronos.org/webgl/wiki/BlacklistsAndWhitelists)
По причине слабой поддержки технологии WebGL далее будут рассматриваться только две технологии: canvas 2d и svg.
*Рис.1 Время рендеринга(y) в зависимости от количества объектов(х).*
Так как работа с SVG требует много манипуляций с DOM эта технология не подходит для тяжелой анимации, к примеру для построения быстро изменяющихся детализированных графиков.
Однако canvas не очень хорошо подходит для экранов с высоким разрешением. Из графика ниже видно, что по мере увеличения размера экрана производительность Canvas падает, поскольку требуется обработать больше пикселей.
*Рис.2 Время рендеринга(y) в зависимости от высоты области рисования(х).*
Также необходимо учитывать, что при увеличении изображения, созданные при помощи canvas, сильно теряют качество. На рисунке ниже показаны линии, нарисованные при помощи svg и canvas.
*Рис.3 Линии нарисованные при помощи SVG(сверху) и Canvas(снизу) при увеличении.*
Еще одна проблема с которой можно столкнуться при работе с canvas — ограниченные возможности отслеживания событий и определения расположения указателя мыши на изображении. Существует встроенный API isPointInPath, который позволяет определить попадает ли указанная точка в последний нарисованный элемент path.\* Существуют сторонние библиотеки, позволяющие достаточно комфортно работать с событиями.
Несмотря на перечисленные выше недостатки, было принято решение использовать именно canvas, в первую очередь из-за его высокой производительности по сравнению с svg при отрисовке большого количества объектов.
\* Существует экспериментальный интерфейс Path2D, который можно использовать для создания пути, который в дальнейшем можно будет переиспользовать. К примеру этот объект можно передать в качестве первого аргумента метода isPointInPath. На данный момент эта технология поддерживается браузерами Firefox, Google Chrome и Opera.
### **Особенности работы с Canvas**
При работе с сanvas в первую очередь необходимо учитывать то, что мы работаем с растровым изображением. В первую очередь это значит, то что при изменении размера области отрисовки (к примеру при изменении размеров окна) изображение на canvas масштабируется, что приводит к искажениям и потере качества. На рисунке ниже в первом случае css свойства width и height элемента canvas в два раза больше соответствующих атрибутов указанных изначально. Рядом изображен тот же график без масштабирования. Для избежания подобных проблем следует при изменении размеров окна выставлять необходимые значения для атрибутов width и height элемента canvas и перерисовывать текущую сцену с учетом новых размеров.
С похожей проблемой можно столкнуться при работе с экранами с увеличенной плотностью пикселей. Изображения на canvas могут выглядеть размытыми. Причиной этого является разница между разрешением дисплея в физических пикселях и разрешением в логических (CSS) пикселях. Отношение двух этих величин можно получить при помощи свойства window.devicePixelRatio. К примеру при devicePixelRatio равным двум ширина канваса в физических пикселях в 2 раза больше, чем его ширина в логических пикселях (указанная в атрибуте width). То есть мы получим тот же эффект, что и в первом случае. Один из возможных способов решения этой проблемы: указывать значения в атрибутах canvas большее чем в стилях в величину devicePixelRatio.
Пример:
```
canvas.width = canvasWidth * window.devicePixelRatio;
canvas.height = canvasHeight * window.devicePixelRatio;
canvas.style.width = canvasWidth + 'px';
canvas.style.height = canvasHeight + 'px';
```
В этом случае при отрисовке необходимо учитывать, что такие величины, как толщина линии и размер шрифта уменьшаться на величину devicePixelRatio. Следовательно, при задании размера шрифта его необходимо умножать на devicePixelRatio, чтобы текст не казался слишком мелким на дисплеях с увеличенной плотностью пикселей.
Оптимизация работы canvas:
Одной из самых дорогих операций при работе с canvas является рисование. Следовательно лучше избегать перерисовки больших изображений.
Один из способов это сделать — применять элементы canvas в несколько слоев. Это позволяет перерисовывать только те части сцены, которые необходимо, а не всю сцену целиком.
Пример: Расположение элементов canvas в 2 слоя:
```
```
Еще один способ уменьшить время затрачиваемое на отрисовку — это отказ от координат с плавающей запятой и использование целочисленных координат. При использовании дробных координат на элементе canvas применяется субпиксельный рендеринг. Это приводит к тому, что для создания эффекта сглаживания производятся дополнительные вычисления.
Существует достаточно много приемов оптимизации элемента canvas. Их эффективность зависит от особенностей проекта и желаемого результата. Подробнее о различных подходах к оптимизации можно прочитать в этой [статье](https://www.html5rocks.com/ru/tutorials/canvas/performance/).
### **Заключение**
SVG хорошо подходит для создания статических изображений, высококачественных сложных векторных документов (к примеру чертежей, схем) интерактивных графиков. Но стоит учитывать, что при возрастании количества объектов, скорость отрисовки будет сильно снижаться. Использование элемента canvas позволяет достаточно быстро отрисовывать изображения на экране, именно поэтому эта технология хорошо подходит для отображения сложных сцен и анимации в режиме реального времени. Canvas может применяться для создания различных визуальных эффектов и сложных 3D сцен. Но при использовании данной технологии достаточно сложно сделать изображение или график интерактивным. | https://habr.com/ru/post/332750/ | null | ru | null |
# Полуфабрикат Windows-службы
Один из способов доморощенной классификации служб основывается на времени их жизни: некоторые из них запускаются сразу же при старте ОС, оставаясь активными постоянно (сюда, скажем, можно отнести веб-серверы и СУБД), другие же запускаются лишь при необходимости, делают свои архиважные дела и сразу завершаются; при этом, ни один из вариантов сам по себе не делает реализацию службы сложнее, однако второй требует от разработчика как минимум ещё и умения *программно* стартовать, а при необходимости и досрочно останавливать её работу. Именно указанный аспект управления службой, плюс добавление некоторых отсутствующих в штатной поставке Delphi возможностей, и сподвиг автора на данный опус.
Чтобы статья воспринималась максимально полезной и практичной, в ней предлагается заготовка (почти готовый к употреблению шаблон) службы, обрабатывающей *очередь неких задач* (или заданий – кому как больше нравится); после того, как все из них обработаны, служба тут же завершается. Если представить графически, то читатель познакомится со следующей конструкцией:
Техническое задание
-------------------
Предложенное решение будет обладать перечисленными возможностями, а также предполагать следующее:
* **Очередь** рассматривается как некая *абстрактная* структура, то есть кем она реализована, где хранится (в файле, БД или где-то ещё) и как конкретно с ней взаимодействовать (в виде программного кода) – всё это непринципиально и слабо пересекается с темой материала, однако предполагается, что задачи в ней обладают как минимум двумя свойствами:
+ Приоритетом, задающим порядок обработки.
+ Статусом, допускающим три значения:
1. Ожидает обработки.
2. Успешно обработана.
3. Ошибка (не удалось обработать).
* **Служба**:
+ Сразу после старта принимается за тяжкие труды и начинает, с учётом приоритета, извлекать из очереди задачи с первым статусом (который «ожидающий»), после чего, в зависимости от результата обработки, обновляет статус у каждой из них; работа прекращается после того, как в очереди не осталось необработанных элементов.
+ Если поступает команда на остановку, то обработка текущей задачи прерывается и служба завершается.
+ Во время работы может принять особую (нестандартную) команду от управляющего приложения (УП), суть которой описана чуть ниже.
+ Дабы не наделять службу чрезмерным набором прав, из-за которых может пострадать безопасность всей ОС, вместо обычно применяемого аккаунта [LocalSystem](https://docs.microsoft.com/en-us/windows/win32/services/localsystem-account) станет использоваться специальный пользователь, создаваемый на лету.
+ При установке происходит автоматическое назначение *минимально* необходимых прав как пользователю самой службы (от имени которого она должна запускаться – о нём шла речь в предыдущем пункте), так и пользователю управляющего приложения.
* **Управляющее приложение**:
+ Подаёт команды на запуск и остановку службы, т. е. примерно то, что вручную делается через Диспетчер служб:
+ Также, когда служба *уже активна*, может подать ей команду заново обработать «ошибочные» задачи (те, что с [третьим статусом](#Task_status_property)) – необходимость в этом обычно возникает после устранения внешних проблем, помешавших штатно справиться с такими задачами в прошлом.
Служба
------
В данном случае, веских причин изобретать велосипед для реализации службы не имеется, поэтому основа дальнейшего кода – это стандартный для IDE подход к созданию, основанный на классе `[TService](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService)`. Также необходимо отметить, что автор использует не самую новую версию Delphi (10.1 Berlin), в связи с чем в иных выпусках могут иметься свои особенности (в более свежих, к примеру, часть предложенного функционала может быть уже реализована, однако подобное маловероятно, учитывая стойкое нежелание разработчиков Delphi развивать `TService`).
Описание кода службы логично вести в соответствии с циклом её жизни в системе – то есть начать с момента установки (регистрации).
### Установка
Собственно самостоятельно реализовывать регистрацию и не требуется, т. к. запуск исполняемого файла службы с ключом *[/install](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TServiceApplication)* сделает всё необходимое – программист от данной рутины избавлен. Намного интересней выглядит момент сразу после установки (чему соответствует событие `[AfterInstall](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.AfterInstall)`), где и удобно приступить к воплощению части означенного в ТЗ; однако, хотелось бы начать с малого и показать на простом примере как происходит изменение параметра установленной службы – будет сделано то, чего уже так давно не добавляют в Delphi – реализована возможность указать *описание*, отображаемое, например, в Диспетчере:
Основа обработчика указанного события, постепенно расширяемая далее, выглядит так:
```
interface
uses
System.SysUtils, Vcl.SvcMgr;
...
implementation
uses
Winapi.WinSvc;
resourcestring
ServiceDescription = 'Шаблон (заготовка) службы, обрабатывающей очередь неких задач.';
procedure TQueueService.ServiceAfterInstall(Sender: TService);
var
ManagerHandle, ServiceHandle: SC_HANDLE;
Description: SERVICE_DESCRIPTION;
begin
ManagerHandle := OpenSCManager(nil, nil, 0);
if ManagerHandle = 0 then
RaiseLastOSError;
try
ServiceHandle := OpenService( ManagerHandle, PChar(Name), SERVICE_CHANGE_CONFIG );
if ServiceHandle = 0 then
RaiseLastOSError;
try
Description.lpDescription := PChar(ServiceDescription);
Win32Check( ChangeServiceConfig2(ServiceHandle, SERVICE_CONFIG_DESCRIPTION, @Description) );
finally
CloseServiceHandle(ServiceHandle);
end;
finally
CloseServiceHandle(ManagerHandle);
end;
end;
```
Здесь, прежде всего, выполняется получение дескриптора Менеджера служб ([Service Control Manager](https://docs.microsoft.com/en-us/windows/win32/services/service-control-manager)), после чего у него запрашивается дескриптор уже нашей (только что установленной) службы по её имени; доступ к обоим объектам выбран минимально необходимый – `[SC\_MANAGER\_CONNECT](https://docs.microsoft.com/en-us/windows/win32/services/service-security-and-access-rights#access-rights-for-the-service-control-manager)` и `[SERVICE\_CHANGE\_CONFIG](https://docs.microsoft.com/en-us/windows/win32/services/service-security-and-access-rights#access-rights-for-a-service)`, причём `SC_MANAGER_CONNECT` не требуется указывать, т. к. он подразумевается неявно (именно поэтому последний параметр функции `[OpenSCManager](https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-openscmanagerw)` равен нулю).
#### Пользователь
Далее, чтобы непосредственно перейти к реализации описанных в начале [требований](#Service_requirements), определимся с пользователем, от имени которого служба станет выполняться: до Windows 7 и Windows Server 2008 R2, если требовалось максимально ограничить службу в правах, дав ей исключительно те, что действительно нужны, было необходимо самостоятельно создавать обычного пользователя ОС – а теперь же появился [виртуальный пользователь](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-r2-and-2008/dd367859(v=ws.10)) (virtual account), все заботы по управлению которым берёт на себя Windows. Применительно к службе (если делать это вручную через Диспетчер), для создания такого пользователя нужно лишь при указании его имени добавить префикс *NT Service\*, а пароль оставить пустым:
Казалось бы, чего проще – действуем аналогично в Инспекторе объектов Delphi и получаем тот же результат:
Но не тут-то было! В случае виртуального пользователя, WinAPI-функция `[CreateService](https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-createservicew)`, применяемая в модуле `[Vcl.SvcMgr](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr)` для установки службы, в последнем параметре, содержащем пароль, должна получить значение `nil`, а не пустую строку,
**как имеет место быть сейчас.**
```
Svc := CreateService(SvcMgr, PChar(Name), PChar(DisplayName),
SERVICE_ALL_ACCESS, GetNTServiceType, GetNTStartType, GetNTErrorSeverity,
PChar(Path), PChar(LoadGroup), PTag, PChar(GetNTDependencies),
PSSN, PChar(Password));
```
Собственно подобное даже нельзя назвать ошибкой – скорее всего, разработчики Delphi просто-напросто не стали улучшать `TService` и добавлять распознавание префикса *NT Service\* в имени, ведь до Windows 7 такой особенности элементарно не существовало. Поэтому, дабы не править стандартный модуль, ограничимся заданием пользователя уже после установки службы (т. е. предполагается, что свойства `[ServiceStartName](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.ServiceStartName)` и `[Password](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.Password)` оставлены пустыми), для чего достаточно вызова лишь одной функции (часть ранее приводимого кода, ответственного за получение дескрипторов, опущена):
```
procedure TQueueService.ServiceAfterInstall(Sender: TService);
const
VirtualAccountPrefix = 'NT Service\';
var
ManagerHandle, ServiceHandle: SC_HANDLE;
Description: SERVICE_DESCRIPTION;
VirtualAccount: string;
begin
...
Description.lpDescription := PChar(ServiceDescription);
Win32Check( ChangeServiceConfig2(ServiceHandle, SERVICE_CONFIG_DESCRIPTION, @Description) );
VirtualAccount := VirtualAccountPrefix + Name;
Win32Check
(
ChangeServiceConfig
(
ServiceHandle,
SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
nil, nil, nil, nil,
PChar(VirtualAccount), nil,
nil
)
);
...
end;
```
Надо сказать, что имя виртуального пользователя, указываемое после префикса, совсем не обязательно должно совпадать с именем службы – главное обеспечить его уникальность.
#### Права
На следующем этапе необходимо позаботиться о правах двух пользователей:
* Первым из них идёт вышеупомянутый виртуальный, проблема с которым такова: если попробовать запустить службу в текущем виде, то система сообщит об отказе в доступе, ибо только что созданный аккаунт не имеет прав на запуск исполняемого файла службы (их у него вообще кот наплакал – за это и выбран). Другими словами, требуется добавить вот такую запись:
* Вторым пользователем является тот, от имени которого запускается управляющее приложение, – дело в том, что любая команда (запуск, приостановка и т. п.) проверяется на наличие соответствующих прав у её инициатора, пока их, увы, не имеющего. Хотя в общем случае про УП служба может ничего не знать (оно, скажем, создаётся другим программистом на ином ЯП), но ситуация в статье иная и позволяет возложить на службу и данное бремя, а чтобы она знала какому пользователю выдать такие права, добавим новый ключ запуска */ControlUser*, где после двоеточия необходимо указать имя; если привести конкретный пример, то теперь установку службы следует производить с такими ключами – */install /ControlUser:SomeUser1*.
Доработки события под описанное выглядят следующим образом:
```
interface
uses
System.SysUtils, Winapi.Windows, Vcl.SvcMgr;
...
implementation
uses
Winapi.WinSvc, Winapi.AccCtrl, Winapi.AclAPI;
procedure TQueueService.ServiceAfterInstall(Sender: TService);
procedure GrantAccess(const UserName, ObjectName: string; const ObjectType: SE_OBJECT_TYPE; const Rights: ACCESS_MASK);
begin
// Реализация процедуры приведена чуть ниже в статье.
...
end;
const
VirtualAccountPrefix = 'NT Service\';
ControlUserSwitch = 'ControlUser';
var
ManagerHandle, ServiceHandle: SC_HANDLE;
Description: SERVICE_DESCRIPTION;
VirtualAccount, ControlUserName: string;
begin
...
Description.lpDescription := PChar(ServiceDescription);
Win32Check( ChangeServiceConfig2(ServiceHandle, SERVICE_CONFIG_DESCRIPTION, @Description) );
VirtualAccount := VirtualAccountPrefix + Name;
Win32Check
(
ChangeServiceConfig
(
ServiceHandle,
SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
nil, nil, nil, nil,
PChar(VirtualAccount), nil,
nil
)
);
GrantAccess( VirtualAccount, ParamStr(0), SE_FILE_OBJECT, GENERIC_READ or GENERIC_EXECUTE );
if FindCmdLineSwitch(ControlUserSwitch, ControlUserName) then
GrantAccess(ControlUserName, Name, SE_SERVICE, SERVICE_START or SERVICE_STOP or SERVICE_USER_DEFINED_CONTROL);
...
end;
```
Константа `SERVICE_USER_DEFINED_CONTROL` у пользователя УП отвечает за право на передачу [нестандартной команды](#Control_application_reset_errors_command), указанной в требованиях. Реализация же `GrantAccess` основана на [C++-примере](https://docs.microsoft.com/en-us/windows/win32/secauthz/modifying-the-acls-of-an-object-in-c--) из документации Microsoft:
```
procedure GrantAccess(const UserName, ObjectName: string; const ObjectType: SE_OBJECT_TYPE; const Rights: ACCESS_MASK);
var
SecurityDescriptor: PSECURITY_DESCRIPTOR;
OldDACL, NewDACL: PACL;
UserAccess: EXPLICIT_ACCESS;
begin
CheckOSError
(
GetNamedSecurityInfo
(
PChar(ObjectName),
ObjectType,
DACL_SECURITY_INFORMATION,
nil,
nil,
@OldDACL,
nil,
SecurityDescriptor
)
);
try
BuildExplicitAccessWithName( @UserAccess, PChar(UserName), Rights, SET_ACCESS, NO_INHERITANCE );
CheckOSError( SetEntriesInAcl(1, @UserAccess, OldDACL, NewDACL) );
try
CheckOSError
(
SetNamedSecurityInfo
(
PChar(ObjectName),
ObjectType,
DACL_SECURITY_INFORMATION,
nil,
nil,
NewDACL,
nil
)
);
finally
LocalFree( HLOCAL(NewDACL) );
end;
finally
LocalFree( HLOCAL(SecurityDescriptor) );
end;
end;
```
Завершая изыскания с `AfterInstall`, необходимо отметить, что любое исключение в этом событии приведёт к удалению только что установленной службы (с записью текста исключения в журнал Windows), а в приведённом коде его может сгенерировать, к примеру, функция `[Win32Check](http://docwiki.embarcadero.com/Libraries/Berlin/en/System.SysUtils.Win32Check)`.
В заключение подраздела также хочется остановиться на моменте, связанном с правами, назначенными выше пользователю УП: если, предположим в целях отладки, их необходимо поменять, то совершенно не обязательно для этого удалять и заново устанавливать службу – достаточно воспользоваться всем известной утилитой [Process Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer): когда служба запущена, следует открыть её свойства и перейти на вкладку Services, после чего пройтись по показанным шагам:
[](https://habrastorage.org/webt/wp/cx/au/wpcxauytvcncqhyr-unyshslpvo.png)
### Обработка очереди
Как известно, Delphi предлагает два подхода к реализации службы (подробнее о них можно узнать в материале на другом ресурсе в разделе [«3. События службы»](http://www.delphikingdom.com/asp/viewitem.asp?catalogid=1348)):
1. На основе событий `[OnStart](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.OnStart)` и `[OnStop](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.OnStop)`, что подразумевает самостоятельное создание потоков, содержащих нужный функционал.
2. На основе события `[OnExecute](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.OnExecute)`, обработчик которого выполняется в заранее заботливо созданном `TService` потоке, причём служба сразу же остановится после выхода из события; именно данный вариант хорошо подходит под поставленную в статье цель – как только в очереди обработаны все задачи, делать больше нечего и необходимо завершиться.
#### Основа события
В первом приближении код `OnExecute` прост и незатейлив – идёт извлечение задач до тех пор, пока они имеются в очереди:
```
procedure TQueueService.ServiceExecute(Sender: TService);
type
TTask = ...; // Конкретный тип зависит от деталей Вашей реализации.
TTaskList = array of TTask; // Массив использован лишь для иллюстрации, допустимы любые другие структуры данных (TList, например).
function ExtractTaskPortion(out Tasks: TTaskList): Boolean;
begin
// Функция вернёт True в случае, если в очереди ещё есть задачи для обработки (при этом
// содержаться они будут в параметре Tasks).
...
Result := Length(Tasks) > 0;
end;
procedure ProcessTask(const Task: TTask);
begin
// После обработки задачи, процедура должна обновить её статус (на 2-й или 3-й).
...
end;
var
Task: TTask;
Tasks: TTaskList;
begin
while ExtractTaskPortion(Tasks) do
for Task in Tasks do
ProcessTask(Task);
end;
```
Стоит пояснить, что задачи берутся не по одиночке, а именно порциями исходя из соображения, что в реальном мире обычно затраты на получение сразу нескольких элементов из хранилища значительно ниже, чем их выборка по одному (именно так, скажем, обстоит дело с базами данных).
#### Прерывание обработки
Несложно заметить, что в текущем виде не предусмотрено никакого механизма по прекращению цикла извлечения задач, а ведь причин такого прерывания, согласно ТЗ, может быть две:
1. [Команда на остановку](#Service_stop_command) службы, после которой никакого ожидания обработки *текущей* задачи быть не должно – она прерывается как можно быстрее, после чего все оставшиеся в порции задачи тоже отбрасываются и служба завершается.
2. [Команда на повторную обработку](#Control_application_reset_errors_command) задач с третьим статусом, для чего необходимо прервать работу по текущей (как и в случае команды на остановку), обновить статус всех означенных задач на первый, запросить новую порцию и далее действовать как обычно; надобность прерывать обработку текущей порции связана с тем, что среди задач с только что установленным первым статусом могут иметься обладающие бо́льшим [приоритетом](#Task_priority_property).
В качестве решения данной проблемы предлагается воспользоваться исключениями – они в этом случае выступят в полном соответствии со своим названием, то есть будут сигнализировать не об ошибке, а именно об исключительной, прерывающей нормальное течение алгоритма ситуации (в нашем случае таковой являются команды от Менеджера служб и УП). Для этого сначала объявим новый класс исключения, содержащий поле с причиной прерывания:
```
...
implementation
...
type
EInterruption = class(Exception)
public
type
TReason = (irStop, irErrorsReset);
public
Reason: TReason;
constructor Create(const Reason: TReason);
end;
constructor EInterruption.Create(const Reason: TReason);
begin
inherited Create(string.Empty);
Self.Reason := Reason;
end;
...
```
Это исключение станет генерироваться в новой локальной процедуре `CheckInterruption` (как – об этом чуть позже), а реакция на него имеет следующий вид:
```
procedure TQueueService.ServiceExecute(Sender: TService);
type
TTask = ...;
TTaskList = array of TTask;
function ExtractTaskPortion(out Tasks: TTaskList): Boolean;
begin
...
end;
procedure CheckInterruption;
begin
// Отвечает за возбуждение исключения EInterruption.
...
end;
procedure ProcessTask(const Task: TTask);
begin
...
end;
procedure ResetQueueErrors;
begin
// Меняет 3-й статус на первый у всех задач в очереди.
...
end;
var
Task: TTask;
Tasks: TTaskList;
begin
while ExtractTaskPortion(Tasks) do
try
for Task in Tasks do
ProcessTask(Task);
except
on E: EInterruption do
case E.Reason of
irStop: Break;
irErrorsReset: ResetQueueErrors;
else raise;
end;
end;
end;
```
От разработчика требуется лишь вставлять вызов `CheckInterruption` периодически, через небольшие этапы обработки задачи в `ProcessTask`, навроде такого:
```
procedure ProcessTask(const Task: TTask);
begin
// Некие действия (например инициализация обработки).
CheckInterruption;
...
// Ещё какой-то этап.
CheckInterruption;
...
// Некий этап-цикл.
for ... to ... do
begin
CheckInterruption;
...
end;
// Обновление статуса задачи.
CheckInterruption;
...
end;
```
#### Взаимодействие с Менеджером служб
В рассматриваемом событии осталось реализовать ещё три вещи, две из которых удобно объединить в одной `CheckInterruption` – во-первых, требуется наконец уже реальная генерация исключения, а во-вторых, служба обязана периодически извещать Менеджер о своём статусе, а также получать пришедшие от него же сообщения и реагировать на них. Если сообщение об остановке службы `TService` в основном обрабатывает сам, то вот [специальная команда](#Reset_errors_interruption_reason) от УП требует дополнительного кодирования, заключающегося, прежде всего, в переопределении виртуального метода `DoCustomControl` – в нашем случае там достаточно всего лишь сохранять переданный службе целочисленный код команды в заведённом для этой цели поле `FCustomCode`:
```
interface
...
type
TQueueService = class(TService)
procedure ServiceAfterInstall(Sender: TService);
procedure ServiceExecute(Sender: TService);
private
FCustomCode: DWORD;
protected
function DoCustomControl(CtrlCode: DWord): Boolean; override;
...
end;
...
implementation
...
function TQueueService.DoCustomControl(CtrlCode: DWord): Boolean;
begin
Result := inherited;
FCustomCode := CtrlCode;
end;
```
Теперь можно полностью реализовать процедуру:
```
procedure CheckInterruption;
begin
ReportStatus;
FCustomCode := 0;
ServiceThread.ProcessRequests(False); // Внутри вызывается DoCustomControl.
if Terminated then
raise EInterruption.Create(irStop);
case FCustomCode of
RESET_QUEUE_ERRORS_CONTROL_CODE: raise EInterruption.Create(irErrorsReset);
end;
end;
```
Здесь методы `[ReportStatus](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.ReportStatus)` и `[ProcessRequests](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TServiceThread.ProcessRequests)` отвечают за взаимодействие с Менеджером, а константа `RESET_QUEUE_ERRORS_CONTROL_CODE` (её допустимые значения см. в описании параметра `[dwControl](https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-controlservice#parameters)`) объявлена в новом модуле `Services.Queue.Constants`:
```
unit Services.Queue.Constants;
interface
const
RESET_QUEUE_ERRORS_CONTROL_CODE = 128;
implementation
end.
```
Полезность добавления модуля проистекает из того факта, что управляющее приложение в нашем случае тоже написано на Delphi и при отправке специальной команды эта константа в нём тоже потребуется:
Кстати, если читатель задаётся вопросом о целесообразности добавления поля `[FCustomCode](#FCustomCode_field)`, когда, казалось бы, можно сгенерировать исключение прямо в методе `DoCustomControl`,
**скажем так,**
```
function TQueueService.DoCustomControl(CtrlCode: DWord): Boolean;
begin
Result := inherited;
case CtrlCode of
RESET_QUEUE_ERRORS_CONTROL_CODE: raise EInterruption.Create(irErrorsReset);
end;
end;
```
то ответ довольно прост – в модуле `Vcl.SvcMgr` вызов `DoCustomControl` окружён конструкцией `try...except`, перехватывающей любые исключения без разбора (а вся обработка сводится к добавлению записей с их текстом в Windows-лог).
#### Окончательный вариант
В качестве последнего штриха к реализации службы, необходимо разобраться хоть и с небольшой (в плане устранения), но всё же загвоздкой, а именно: в текущем виде, если в очереди все задачи обработаны, но некоторые из них имеют третий статус (завершились ошибкой), то заново такие взять в работу не получится – служба после старта станет сразу завершаться, а, соответственно, и не сможет никогда принять команду от УП на повторную обработку ошибок. К счастью, при запуске службы можно передать ей произвольное количество текстовых параметров, хотя в данном случае достаточно одного параметра-флага – факт его наличия будет говорить о том, что ещё перед циклом по очереди требуется вызвать уже применявшуюся процедуру `ResetQueueErrors`:
```
procedure TQueueService.ServiceExecute(Sender: TService);
...
procedure ResetQueueErrors;
begin
// Меняет 3-й статус на первый у всех задач в очереди.
...
end;
var
I: Integer;
Task: TTask;
Tasks: TTaskList;
begin
for I := 0 to ParamCount - 1 do
if Param[I] = ResetQueueErrorsParam then
begin
ResetQueueErrors;
Break;
end;
while ExtractTaskPortion(Tasks) do
try
for Task in Tasks do
ProcessTask(Task);
except
on E: EInterruption do
case E.Reason of
irStop: Break;
irErrorsReset: ResetQueueErrors;
else raise;
end;
end;
end;
```
Важно понимать, что эти параметры не имеют ничего общего с ключами, использующимися при установке и удалении, – те применяются при самостоятельном запуске исполняемого файла службы, а свойство `[Param](http://docwiki.embarcadero.com/Libraries/Berlin/en/Vcl.SvcMgr.TService.Param)` содержит то, что было передано специальной WinAPI-функции, предназначенной для старта служб (она будет упомянута в следующем разделе). Что касается константы `ResetQueueErrorsParam`, то она объявлена в модуле `Services.Queue.Constants`:
```
unit Services.Queue.Constants;
interface
const
RESET_QUEUE_ERRORS_CONTROL_CODE = 128;
ResetQueueErrorsParam = 'ResetErrors';
implementation
end.
```
Управляющее приложение
----------------------
В целях сосредоточения на главном, и дабы не отвлекаться на второстепенные нюансы, УП представляет собой обычный VCL-проект из одной простейшей формы, состоящей из 4-х кнопок; вместе с тем, весь приводимый код использует только WinAPI, поэтому применять его можно где угодно – хоть в другой службе, хоть вообще поместить в DLL.
Кнопки отвечают за уже знакомые действия:
1. Запуск без изысков (как будто через Диспетчер служб).
2. Аналогично первой кнопке, но с [параметром](#Service_start_parameters), отвечающим за предварительный сброс у задач третьего статуса.
3. Передача службе специальной команды (см. константу `[RESET\_QUEUE\_ERRORS\_CONTROL\_CODE](#RESET_QUEUE_ERRORS_CONTROL_CODE_declaration)`).
4. Остановка службы (как будто через Диспетчер служб).
### Предварительные действия
В дальнейшем довольно часто будет требоваться дескриптор Менеджера служб, поэтому, чтобы не получать его каждый раз заново, сделаем это при создании формы; также сотворим полезный метод `OpenService`, избавляющий далее от дублирования кода и возвращающий дескриптор службы:
```
interface
uses
Winapi.Windows, System.SysUtils, ..., Winapi.WinSvc;
type
TForm1 = class(TForm)
...
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
private
FSCMHandle: SC_HANDLE;
function OpenService(const Access: DWORD): SC_HANDLE;
end;
...
implementation
procedure TForm1.FormCreate(Sender: TObject);
begin
FSCMHandle := OpenSCManager(nil, nil, 0);
if FSCMHandle = 0 then
RaiseLastOSError;
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
CloseServiceHandle(FSCMHandle);
end;
function TForm1.OpenService(const Access: DWORD): SC_HANDLE;
begin
Result := Winapi.WinSvc.OpenService( FSCMHandle, PChar('QueueService'), Access );
if Result = 0 then
RaiseLastOSError;
end;
```
### Основной код
Запуск службы – без параметров и с ними – отличается незначительно (и там и там применяется одна и та же WinAPI-функция), поэтому видится разумным создать у формы метод, который затем и вызывать при нажатии на первые две кнопки:
```
interface
...
type
TForm1 = class(TForm)
...
private
...
procedure RunService(const Parameters: array of string);
end;
...
implementation
...
procedure TForm1.RunService(const Parameters: array of string);
var
ServiceHandle: SC_HANDLE;
Arguments: array of PChar;
I: Integer;
begin
ServiceHandle := OpenService(SERVICE_START);
try
if Length(Parameters) = 0 then
Win32Check( StartService(ServiceHandle, 0, PPChar(nil)^) )
else
begin
SetLength( Arguments, Length(Parameters) );
for I := Low(Parameters) to High(Parameters) do
Arguments[I] := PChar(Parameters[I]);
Win32Check( StartService(ServiceHandle, Length(Arguments), Arguments[0]) );
end;
finally
CloseServiceHandle(ServiceHandle);
end;
end;
```
Параметр-массив `Parameters` позволяет указать как раз тот набор параметров запуска службы, о которых шла речь [выше](#Service_start_parameters). Итак, имея новый метод, очень легко закодировать обработчики у первой половины кнопок:
```
...
implementation
uses
Services.Queue.Constants;
...
procedure TForm1.bStartClick(Sender: TObject);
begin
RunService([]);
end;
procedure TForm1.bStartAndResetErrorsClick(Sender: TObject);
begin
RunService([ResetQueueErrorsParam]);
end;
```
Две последние кнопки тоже позволяют обойтись вызовом одного и того же дополнительного метода, с совсем уж простой реализацией:
```
interface
...
type
TForm1 = class(TForm)
...
private
...
procedure SendCommandToService(const Access, ControlCode: DWORD);
end;
...
implementation
...
procedure TForm1.SendCommandToService(const Access, ControlCode: DWORD);
var
ServiceHandle: SC_HANDLE;
ServiceStatus: TServiceStatus;
begin
ServiceHandle := OpenService(Access);
try
Win32Check( ControlService(ServiceHandle, ControlCode, ServiceStatus) );
finally
CloseServiceHandle(ServiceHandle);
end;
end;
```
Здесь в переменной `ServiceStatus` возвращается последнее, самое свежее состояние службы, однако оно в данном контексте неинтересно, поэтому полученное значение просто игнорируется. Таким образом, 3-я и 4-я кнопки на нажатие реагируют так:
```
...
implementation
...
procedure TForm1.bResetErrorsClick(Sender: TObject);
begin
SendCommandToService(SERVICE_USER_DEFINED_CONTROL, RESET_QUEUE_ERRORS_CONTROL_CODE);
end;
procedure TForm1.bStopClick(Sender: TObject);
begin
SendCommandToService(SERVICE_STOP, SERVICE_CONTROL_STOP);
end;
```
Последнее, о чём хочется сказать, касается нестандартных команд (рассмотренная служба реагирует только на одну – `RESET_QUEUE_ERRORS_CONTROL_CODE`): если они в Вашем случае являются более сложными, требующими для выполнения *дополнительную информацию*, а не просто факт получения службой одного числового кода, то для передачи таких сведений придётся задействовать механизмы [межпроцессного обмена](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BD%D0%BE%D0%B5_%D0%B2%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D0%B5) – [разделяемую память](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B5%D0%BC%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C), [неименованные каналы](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B8%D0%BC%D0%B5%D0%BD%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BA%D0%B0%D0%BD%D0%B0%D0%BB) и т. п.
---
Весь показанный исходный код можно скачать [здесь](https://disk.yandex.ru/d/alEMFiG7VlUtLw). | https://habr.com/ru/post/661697/ | null | ru | null |
# В тестовой сборке Windows 10 появилась утилита Disk Usage — анализатор дискового пространства из командной строки
По [информации](https://www.bleepingcomputer.com/news/microsoft/windows-10-to-get-a-built-in-command-line-disk-space-analyzer/) портала Bleeping Computer, Microsoft без официального представления начала тестировать новое встроенное приложение для Windows 10. Утилиту под названием DiskUsage пользователи обнаружили в вышедших на прошлой неделе сборках Windows 10 Insider build 20277 и build 21277. Это встроенный в систему анализатор дискового пространства из командной строки.
Фактически, новая утилита DiskUsage является расширенной версией [DU (Disk Usage)](https://docs.microsoft.com/en-us/sysinternals/downloads/du) от Марка Руссиновича.
**Инструкция по использованию утилиты DiskUsage.**
>
> ```
> DiskUsage - Disk Usage
>
> Description: Summarize disk usage recursively for the given directory.
> Usage : diskusage [Options] [Directory]
> Options :
> /a, /systemAndReserve displays size for system files and reserved space
> /c, /csv displays in csv format
> /d, /maxDepth=N displays directory information only if it is N or
> fewer levels below command line argument
> /e, /minFileSize=SIZE displays directory information only if its FileSize
> is greater or equal than SIZE
> /f, /minSizeOnDisk=SIZE displays directory information only if its SizeOnDisk
> is greater or equal than SIZE
> /g, /displayFlag=FLAG specifies the flags value to determin which column(s) to display
> column value description
> SizeOnDisk 0x001 the on disk size
> FileSize 0x002 the end of file size
> SizePerDir 0x004 sum of SizeOnDisk for top level child
> Files 0x008 number of child files
> ChildDirs 0x010 number of child directories
> FilesPerDir 0x020 number of top level child files
> DirsPerDir 0x040 number of top level child directories
> CreationTime 0x080 file creation timestamp
> LastAccessTime 0x100 file last access timestamp
> LastWriteTime 0x200 file last write timestamp
> Attributes 0x400 file attributes
> /h, /humanReadable displays size in human readable format
> /i, /iniFile=FILE takes all the parameters from an INI file.
> NOTE: SCENARIO name must be speificed via /j (/scenario)
> /j, /secnario=SCENARIO specifies the scenario name for the INI file
> /l, /allLinks count all hardlinks separately (By default, files with multiple
> hardlinks are counted only once towards the first link name)
> /m, /multipleName count only files with more than one link names
> /n, /nameFilter=FILTER count only files whose name matches the name filter
> /p, /preferredPath=PATH count files with multiple link names towards the first link that is
> under PATH if it exists
> NOTE: This options must not be specified togerther with /l (/allLinks)
> /q, /virtual recurse into virtual directories
> /r, /skipReparse skip recursing into reparse directories
> /s, /skipResurse skip recursing into child directories when calculating sizes
> /t, /TopDirectory=N displays Top N directories by SizeOnDisk in descending order
> /u, /TopFile=N displays Top N files by SizeOnDisk in descending order
> /v, /verbose displays verbose error information
> /x, /clearDefault do not display the default selected columns
>
> ```
>
Утилита еще находится в начальной стадии разработки. Сейчас некоторые ее функции работают не так, как заявлено, также присутствуют орфографические ошибки в ее описании.
Эксперты Bleeping Computer изучили возможности утилиты Disk Usage. Для запуска утилиты необходимы административные привилегии.
По умолчанию при запуске DiskUsage размер файлов и папок отображается в байтах, что не так удобно, как отображение размеров в МБ и ГБ. Microsoft добавила в утилиту опцию /h (humanReadable) для отображения удобочитаемых размеров файлов и папок для пользователей.
*Пример поиска с помощью DiskUsage в директории «C:\Windows» папок, размер которых превышает 1 ГБ. Для этого была использована команда:
```
diskusage /minFileSize=1073741824 /h c:\windows
```*
В инструкции DiskUsage заявлено, что можно вывести список, ограничив его количество, самых больших папок на диске или в указанной папке. Для этого нужно использовать опцию /t (TopDirectory=N).
*Пример поиска с помощью DiskUsage в директории «C:\Windows» 5 папок, размер которых самый большой. Для этого была использована команда:
```
diskusage /t=5 /h c:\windows
```*
К сожалению, результат этой команды оказался не таким, как ожидалось. В итоге был показан отсортированный список из 5 папок, но, судя по первому поиску в этой папке, утилитой были выведены на экран строки не с теми папками, которые ожидались. Скорее всего, приведенная выше команда работает корректно, но она отображает самые большие папки без учета файлов в их подпапках.
DiskUsage также можно использовать для поиска файлов с наибольшими размерами. Для это нужно использовать опцию /u (/TopFile=N).
*Пример поиска с помощью DiskUsage в директории «C:\Windows» 5 самых больших файлов. Для этого была использована команда:
```
diskusage /u=5 /h c:\windows
```*
Также в DiskUsage можно сделать настройку вывода данных в csv, там есть возможность пропускать различные типы папок, анализировать папки и файлы по timestamp.
Microsoft на данный момент не предоставила информацию, когда утилита DiskUsage будет доступна всем пользователям.
> См. также:
>
>
>
> * «[Microsoft выпустила утилиту ProcMon (Process Monitor) для Linux](https://habr.com/ru/news/t/511876/)»
> * «[Microsoft выпустила собственный инструмент для восстановления удалённых файлов — Windows File Recovery](https://habr.com/ru/news/t/508942/)»
> * «[В Windows 10 появился собственный сниффер трафика pktmon, как запустить и пользоваться](https://habr.com/ru/news/t/502546/)»
> | https://habr.com/ru/post/533094/ | null | ru | null |
# Идея будильника, или как объединить для этого книжку, CD-ROM, фен, старую нокию и немного shell'a?
Если интересно — прошу под кат!
#### Книжный выключатель.
Откройте ваш любимый текстовый редактор и напишите в нем такой sh скрипт:
```
#!/bin/bash
eject /dev/cdrom
sleep 5
eject -t /dev/cdrom
```
Поставьте рядом с CDROM книжку, а под ней — сетевой фильтр (вот так).
Запустите скрипт и смотрите, как книжка падает на кнопку выключения сетевого фильтра от выехавшевого лотка сидирома. Установите запуск скрипта по cron и включайте в сетевой фильтр все, что необходимо выключить или включить по расписанию.
Мало? Согласен.
#### Дополнительная свобода.
В сетевой фильтр, очевидно, нужно что-то включать. К примеру, можно сделать будильник.
Берем обычный маленький фен и вставляем его в фильтр. Вешаем над кроватью. Программируем включение на 7 утра и просыпаемся под бодрящий теплый ветерок в лицо. (вот так)
Мало? Тогда идем дальше.
#### Управляй мечтой.
Что мешает сделать включение «будильника — фена» удаленно по нашему желанию? Ничего. Конечно, можно заморочится с командами, принимаемыми через сеть. Но вдруг произойдет что-то страшное и Интернет исчезнет (к примеру, я регулярно забываю оплатить свой собственный, да и тупо отваливается он часто)?
Значит, надо делать программирование его включения через входящую смску. Я уже писал [тут](http://habrahabr.ru/post/151698/) на эту тему, но повторюсь для конкретно этого случая.
Вкратце: Берете старую нокию с блютузом, сопрягаете ее по этому самому синему зубу с компьютером с установленным драйвером gnokii на Линуксе и, далее, создаете что-то типа такого скрипта:
```
#!/bin/bash
inp=$(gnokii --getsms IN 1 end)
echo $inp>/home/light204/Desktop/inp.txt
# приказ по смс
counter_seven=$(grep -c 7 /home/light204/Desktop/inp.txt)
counter_eight=$(grep -c 8 /home/light204/Desktop/inp.txt)
counter_nine=$(grep -c 9 /home/light204/Desktop/inp.txt)
killall gnokii
#текущая дата
$time='date +%H'
if [ "$counter_seven" == "1" AND "$time" == "07"]; then
eject /dev/cdrom
sleep 5
eject -t /dev/cdrom
elif [ "$counter_eight" == "1" AND "$time" == "08"]; then
eject /dev/cdrom
sleep 5
eject -t /dev/cdrom
elif [ "$counter_nine" == "1" AND "$time" == "09"]; then
eject /dev/cdrom
sleep 5
eject -t /dev/cdrom
fi
sleep 3
killall gnokii
gnokii --deletesms IN 1 end
sleep 700
```
(предполагается, что в смске приходит число, означающее час срабатывания будильника)
Пусть этот скрипт автоматом по крону проверяет новые сообщения хотя бы каждые 3-4 минуты (чтобы не проспать даже при самом неудачном раскладе).
Теперь вы (особенно, если допилите представленный скрипт под свои нужды), даже находясь вне дома, можете давать другому человеку спокойно спать в вашей постели, удаленно, по смс, программируя момент его просыпания под мягкий ветерок фена в лицо.
Удачи и приятного wake up :)
UPD 1.0
0. Благодаря avalak'у уточняю, что действительно sleep 700 во втором скрипте не нужен. Он остался с отладки.
1. Книжка и вправду не всегда нажимает на кнопку. Это потому, что она не монолитна, а состоит из страниц (да ладно!). Но, если ее обжать, то частоту несрабатываний можно сильно понизить. Вот так:
 | https://habr.com/ru/post/156151/ | null | ru | null |
# Глубокое обучение с R и Keras на примере Carvana Image Masking Challenge
Привет, Хабр!
Пользователи R долгое время были лишены возможности приобщиться к deep learning-у, оставаясь в рамках одного языка программирования. С выходом **[MXNet](https://github.com/apache/incubator-mxnet)** ситуация стала меняться, но своеобразная документация и частые изменения, ломающие обратную совместимость, все еще ограничивают популярность данной библиотеки.
Гораздо привлекательнее выглядит использование R-интерфейсов к **[TensorFlow](https://tensorflow.rstudio.com/)** и **[Keras](https://keras.rstudio.com/)** с бекендами на выбор (TensorFlow, Theano, CNTK), подробной документацией и множеством примеров. В этом сообщении будет разобрано решение задачи сегментации изображений на примере соревнования [Carvana Image Masking Challenge](https://www.kaggle.com/c/carvana-image-masking-challenge) ([победители](https://www.linkedin.com/feed/update/urn:li:activity:6320656461345226752/)), в котором требуется научиться отделять автомобили, сфотографированные с 16 разных ракурсов, от фона. "Нейросетевая" часть полностью реализована на **Keras**, за обработку изображений отвечает **[magick](https://github.com/ropensci/magick#readme)** (интерфейс к **ImageMagick**), параллельная обработка обеспечивается **parallel**+**doParallel**+**foreach** (Windows) или **parallel**+**doMC**+**foreach** (Linux).
### Содержание:
1. [Установка всего необходимого](#section1)
2. [Работа с изображениями: **magick** как альтернатива **OpenCV**](#section2)
3. [Параллельное выполнение кода на R в ОС Windows и Linux](#section3)
4. [**reticulate** и итераторы](#section4)
5. [Задача сегментации и функция потерь для нее](#section5)
6. [Архитектура U-Net](#section6)
7. [Обучение модели](#section7)
8. [Предсказания на основе модели](#section8)
#### 1. Установка всего необходимого
Будем считать, что у читателя уже есть GPU от Nvidia с ≥4 Гб памяти (можно и меньше, но будет не так интересно), а также установлены библиотеки CUDA и cuDNN. Для Linux установка последних происходит просто ([одно из многочисленных руководств](http://guanghan.info/blog/en/my-works/building-our-personal-deep-learning-rig-gtx-1080-ubuntu-16-04-cuda-8-0rc-cudnn-7-tensorflowmxnetcaffedarknet/)), а для Windows — еще проще (см. раздел "CUDA & cuDNN" [руководства](https://mpopov.com/blog/r-win-gpu-tensorflow)).
Далее желательно установить дистрибутив [Anaconda](https://www.continuum.io/downloads) с Python 3; для экономии места можно выбрать минимальный вариант Miniconda. Если вдруг версия Python в дистрибутиве опережает последнюю поддерживаемую со стороны Tensorflow версию, заменить ее можно командой вида `conda install python=3.6`. Также все будет работать с обычным Python-ом и виртуальными окружениями.
Список используемых R-пакетов выглядит следующим образом:
**Список пакетов для Windows**
```
library(keras)
library(magick)
library(abind)
library(reticulate)
library(parallel)
library(doParallel)
library(foreach)
```
**Список пакетов для Linux**
```
library(keras)
library(magick)
library(abind)
library(reticulate)
library(parallel)
library(doMC)
library(foreach)
```
Все они устанавливаются с CRAN, но **Keras** лучше брать с Github: `devtools::install_github("rstudio/keras")`. Последующий запуск команды `install_keras()` создаст conda-окружение и установит в нем правильные версии Python-овских **Tensorflow** и **Keras**. Если эта команда по какой-то причине отказалась корректно работать (например, не смогла найти нужный дистрибутив Python), или же требуются специфические версии используемых библиотек, следует [создать](https://conda.io/docs/user-guide/tasks/manage-environments.html) conda-окружение самому, установить в нем нужные пакеты, а затем в R [указать](https://rstudio.github.io/reticulate/articles/versions.html) пакету **reticulate** это окружение командой `use_condaenv()`.
Список используемых далее параметров:
```
input_size <- 128 # Ширина и высота изображений, подаваемых на вход нейросети
epochs <- 30 # Число эпох
batch_size <- 16 # Размер батча
orig_width <- 1918 # Ширина исходных изображений
orig_height <- 1280 # Высота исходных изображений
train_samples <- 5088 # Размер обучающей выборки
train_index <- sample(1:train_samples, round(train_samples * 0.8)) # 80%
val_index <- c(1:train_samples)[-train_index]
# Папки с картинками
images_dir <- "input/train/"
masks_dir <- "input/train_masks/"
```
#### 2. Работа с изображениями: **magick** как альтернатива **OpenCV**
При решении задач машинного обучения на графических данных нужно уметь, как минимум, читать изображения с диска и передавать их в нейросетку в виде массивов. Обычно требуется также уметь выполнять разнообразные трансформации изображений, чтобы реализовать так называемую аугментацию — дополнение обучающей выборки искусственными примерами, созданными из фактически присутствующих в самой обучающей выборке образцов. Аугментация (почти) всегда способна дать прирост качества модели: базовое понимание можно получить, например, из [этого сообщения](https://habrahabr.ru/company/smartengines/blog/264677/). Забегая вперед, отметим, что все это нужно делать быстро и многопоточно: даже на относительно быстром CPU и относительно медленной видеокарте подготовительный этап может оказаться более ресурсоемким, чем собственно обучение нейросети.
В Python для работы с изображениями традиционно используется **OpenCV**. Версии этой мегабиблиотеки для R пока не создали, вызов ее функций посредством **reticulate** выглядит неспортивным решением, поэтому будем выбирать из имеющихся альтернатив.
Топ-3 самых мощных графических пакетов выглядит следующим образом:
* **[EBImage](https://www.bioconductor.org/packages/devel/bioc/vignettes/EBImage/inst/doc/EBImage-introduction.html)** — пакет создан с использованием S4-классов и размещен в репозитории Bioconductora-а, что подразумевает самые высокие требования к качеству как самого пакета, так и его документации. К сожалению, насладиться обширными возможностями данного программного продукта мешает его крайне низкая скорость работы.
* **[imager](https://cran.r-project.org/web/packages/imager/vignettes/gettingstarted.html)** — этот пакет выглядит поинтереснее в плане производительности, поскольку основную работу в нем выполняет скомпилированный код в лице сишной библиотеки **[CImg](http://www.cimg.eu/)**. Среди достоинств можно отметить поддержку "конвейерного" оператора `%>%` (и других операторов из **magrittr**), тесную интеграцию с пакетами из т.н. **[tidyverse](https://www.tidyverse.org/)**, включая **ggplot2**, а также поддержку идеологии split-apply-combine. И лишь непонятный баг, делающий неработоспособными функции для чтения картинок на некоторых ПК, помешал автору этого сообщения остановить свой выбор на данном пакете.
* **[magick](https://cran.r-project.org/web/packages/magick/vignettes/intro.html)** — пакет-оболочка для **[ImageMagick](https://www.imagemagick.org/Magick++/STL.html)**, разработанный и активно развиваемый участниками сообщества [rOpenSci](https://github.com/ropensci). Сочетает в себе все плюсы предыдущего пакета, стабильность, безглючность и киллер-фичу (бесполезную в рамках нашей задачи) в виде интеграции с OCR-библиотекой **[Tesseract](https://ropensci.org/technotes/2017/08/17/tesseract-16/)**. Замеры скорости при выполнении чтения и трансформации картинок на разном числе ядер приведены ниже. Из минусов можно отметить местами эзотерический синтаксис: например, для обрезки или изменения размера нужно передать функции строку вида `"100x150+50"` вместо привычных аргументов типа `height` и `width`. А поскольку наши вспомогательные функции для препроцессинга будут параметризованы как раз по этим величинам, придется использовать некрасивые конструкции `paste0(...)` или `sprintf(...)`.
Здесь и далее мы будем в общих чертах воспроизводить решение [Kaggle Carvana Image Masking Challenge solution with Keras](https://github.com/petrosgk/Kaggle-Carvana-Image-Masking-Challenge) от Peter-а Giannakopoulos-а.
Читать файлы нужно парами — изображение и соответствующую ему маску, также к изображению и маске нужно применять одинаковые преобразования (повороты, сдвиги, отражения, изменения масштаба) при использовании аугментации. Реализуем чтение в виде одной функции, которая сразу же будет уменьшать картинки под нужный размер:
```
imagesRead <- function(image_file,
mask_file,
target_width = 128,
target_height = 128) {
img <- image_read(image_file)
img <- image_scale(img, paste0(target_width, "x", target_height, "!"))
mask <- image_read(mask_file)
mask <- image_scale(mask, paste0(target_width, "x", target_height, "!"))
list(img = img, mask = mask)
}
```
Результат работы функции с наложением маски на изображение:
```
img <- "input/train/0cdf5b5d0ce1_01.jpg"
mask <- "input/train_masks/0cdf5b5d0ce1_01_mask.png"
x_y_imgs <- imagesRead(img,
mask,
target_width = 400,
target_height = 400)
image_composite(x_y_imgs$img,
x_y_imgs$mask,
operator = "blend",
compose_args = "60") %>%
image_write(path = "pics/pic1.jpg", format = "jpg")
```
Первым видом аугментации будет изменение яркости (brightness), насыщенности (saturation) и тона (hue). По понятным причинам применяется она к цветному изображению, но не к черно-белой маске:
```
randomBSH <- function(img,
u = 0,
brightness_shift_lim = c(90, 110), # percentage
saturation_shift_lim = c(95, 105), # of current value
hue_shift_lim = c(80, 120)) {
if (rnorm(1) < u) return(img)
brightness_shift <- runif(1,
brightness_shift_lim[1],
brightness_shift_lim[2])
saturation_shift <- runif(1,
saturation_shift_lim[1],
saturation_shift_lim[2])
hue_shift <- runif(1,
hue_shift_lim[1],
hue_shift_lim[2])
img <- image_modulate(img,
brightness = brightness_shift,
saturation = saturation_shift,
hue = hue_shift)
img
}
```
Это преобразование применяется с вероятностью 50% (в половине случаев будет возвращено исходное изображение:`if (rnorm(1) < u) return(img)`), величина изменения каждого из трех параметров выбирается случайным образом в пределах диапазона значений, заданного в процентах от исходной величины.
Также с вероятностью 50% будем использовать горизонтальные отражения изображения и маски:
```
randomHorizontalFlip <- function(img,
mask,
u = 0) {
if (rnorm(1) < u) return(list(img = img, mask = mask))
list(img = image_flop(img), mask = image_flop(mask))
}
```
Результат:
```
img <- "input/train/0cdf5b5d0ce1_01.jpg"
mask <- "input/train_masks/0cdf5b5d0ce1_01_mask.png"
x_y_imgs <- imagesRead(img, mask,
target_width = 400,
target_height = 400)
x_y_imgs$img <- randomBSH(x_y_imgs$img)
x_y_imgs <- randomHorizontalFlip(x_y_imgs$img,
x_y_imgs$mask)
image_composite(x_y_imgs$img,
x_y_imgs$mask,
operator = "blend",
compose_args = "60") %>%
image_write(path = "pics/pic2.jpg", format = "jpg")
```
Остальные преобразования для дальнейшего изложения не принципиальны, поэтому на них останавливаться не будем.
Последний этап — превращение картинок в массивы:
```
img2arr <- function(image,
target_width = 128,
target_height = 128) {
result <- aperm(as.numeric(image[[1]])[, , 1:3], c(2, 1, 3)) # transpose
dim(result) <- c(1, target_width, target_height, 3)
return(result)
}
mask2arr <- function(mask,
target_width = 128,
target_height = 128) {
result <- t(as.numeric(mask[[1]])[, , 1]) # transpose
dim(result) <- c(1, target_width, target_height, 1)
return(result)
}
```
Транспонирование нужно для того, чтобы строки изображения оставались строками в матрице: изображение формируется построчно (как движется луч развертки в кинескопе), в то время как матрицы в R заполняются по столбцам (column-major, или Fortran-style; для сравнения, в **numpy** можно переключаться между column-major и row-major форматами). Можно обойтись и без него, но так понятнее.
#### 3. Параллельное выполнение кода на R в ОС Windows и Linux
Общее представление о параллельных вычислениях в R можно получить из руководств [Package ‘parallel’](https://stat.ethz.ch/R-manual/R-devel/library/parallel/doc/parallel.pdf), [Getting Started with doParallel and foreach](https://cran.r-project.org/web/packages/doParallel/vignettes/gettingstartedParallel.pdf) и [Getting Started with doMC and foreach](https://cran.r-project.org/web/packages/doMC/vignettes/gettingstartedMC.pdf). Алгоритм работы следующий:
Запускаем кластер с нужным числом ядер:
```
cl <- makePSOCKcluster(4) # doParallel
```
SOCK-кластеры являются универсальным решением, позволяющим в том числе использовать CPU нескольких ПК. К сожалению, наш пример с итераторами и обучением нейронной сети работает под Windows, но отказывается работать под Linux. В Linux можно воспользоваться альтернативным пакетом **doMC**, который создает кластеры с использованием форков исходного процесса. Остальные шаги выполнять не нужно:
```
registerDoMC(4) # doMC
```
И **doParallel**, и **doMC** служат посредниками между функциональностью **parallel** и **foreach**.
При использовании `makePSOCKcluster()` нужно подгрузить внутрь кластера необходимые пакеты и функции:
**Загрузка пакетов и функций**
```
clusterEvalQ(cl, {
library(magick)
library(abind)
library(reticulate)
imagesRead <- function(image_file,
mask_file,
target_width = 128,
target_height = 128) {
img <- image_read(image_file)
img <- image_scale(img, paste0(target_width, "x", target_height, "!"))
mask <- image_read(mask_file)
mask <- image_scale(mask, paste0(target_width, "x", target_height, "!"))
return(list(img = img, mask = mask))
}
randomBSH <- function(img,
u = 0,
brightness_shift_lim = c(90, 110), # percentage
saturation_shift_lim = c(95, 105), # of current value
hue_shift_lim = c(80, 120)) {
if (rnorm(1) < u) return(img)
brightness_shift <- runif(1,
brightness_shift_lim[1],
brightness_shift_lim[2])
saturation_shift <- runif(1,
saturation_shift_lim[1],
saturation_shift_lim[2])
hue_shift <- runif(1,
hue_shift_lim[1],
hue_shift_lim[2])
img <- image_modulate(img,
brightness = brightness_shift,
saturation = saturation_shift,
hue = hue_shift)
img
}
randomHorizontalFlip <- function(img,
mask,
u = 0) {
if (rnorm(1) < u) return(list(img = img, mask = mask))
list(img = image_flop(img), mask = image_flop(mask))
}
img2arr <- function(image,
target_width = 128,
target_height = 128) {
result <- aperm(as.numeric(image[[1]])[, , 1:3], c(2, 1, 3)) # transpose
dim(result) <- c(1, target_width, target_height, 3)
return(result)
}
mask2arr <- function(mask,
target_width = 128,
target_height = 128) {
result <- t(as.numeric(mask[[1]])[, , 1]) # transpose
dim(result) <- c(1, target_width, target_height, 1)
return(result)
}
})
```
Регистрируем кластер в качестве параллельного бекенда для **foreach**:
```
registerDoParallel(cl)
```
После этого можно запускать код в параллельном режиме:
```
imgs <- list.files("input/train/",
pattern = ".jpg",
full.names = TRUE)[1:16]
masks <- list.files("input/train_masks/",
pattern = ".png",
full.names = TRUE)[1:16]
x_y_batch <- foreach(i = 1:16) %dopar% {
x_y_imgs <- imagesRead(image_file = batch_images_list[i],
mask_file = batch_masks_list[i])
# augmentation
x_y_imgs$img <- randomBSH(x_y_imgs$img)
x_y_imgs <- randomHorizontalFlip(x_y_imgs$img,
x_y_imgs$mask)
# return as arrays
x_y_arr <- list(x = img2arr(x_y_imgs$img),
y = mask2arr(x_y_imgs$mask))
}
str(x_y_batch)
# List of 16
# $ :List of 2
# ..$ x: num [1, 1:128, 1:128, 1:3] 0.953 0.957 0.953 0.949 0.949 ...
# ..$ y: num [1, 1:128, 1:128, 1] 0 0 0 0 0 0 0 0 0 0 ...
# $ :List of 2
# ..$ x: num [1, 1:128, 1:128, 1:3] 0.949 0.957 0.953 0.949 0.949 ...
# ..$ y: num [1, 1:128, 1:128, 1] 0 0 0 0 0 0 0 0 0 0 ...
# ....
```
В конце не забываем остановить кластер:
```
stopCluster(cl)
```
При помощи пакета **microbenchmark** проверим, каков выигрыш от использования нескольких ядер/потоков. На GPU c 4 Гб памяти можно работать с батчами по 16 пар изображений, значит, целесообразно использовать 2, 4, 8 или 16 потоков (время указано в секундах):
На 16 потоках проверить не было возможности, но видно, что при переходе от 1 к 4 потокам скорость возрастает примерно втрое, что очень радует.
#### 4. **reticulate** и итераторы
Чтобы работать с данными, не помещающимися в памяти, воспользуемся итераторами из пакета **reticulate**. Основой является обычная функция-замыкание (closure), т.е.функция, при вызове возвращающая другую функцию вместе с окружением вызова:
**train\_generator**
```
train_generator <- function(images_dir,
samples_index,
masks_dir,
batch_size) {
images_iter <- list.files(images_dir,
pattern = ".jpg",
full.names = TRUE)[samples_index] # for current epoch
images_all <- list.files(images_dir,
pattern = ".jpg",
full.names = TRUE)[samples_index] # for next epoch
masks_iter <- list.files(masks_dir,
pattern = ".gif",
full.names = TRUE)[samples_index] # for current epoch
masks_all <- list.files(masks_dir,
pattern = ".gif",
full.names = TRUE)[samples_index] # for next epoch
function() {
# start new epoch
if (length(images_iter) < batch_size) {
images_iter <<- images_all
masks_iter <<- masks_all
}
batch_ind <- sample(1:length(images_iter), batch_size)
batch_images_list <- images_iter[batch_ind]
images_iter <<- images_iter[-batch_ind]
batch_masks_list <- masks_iter[batch_ind]
masks_iter <<- masks_iter[-batch_ind]
x_y_batch <- foreach(i = 1:batch_size) %dopar% {
x_y_imgs <- imagesRead(image_file = batch_images_list[i],
mask_file = batch_masks_list[i])
# augmentation
x_y_imgs$img <- randomBSH(x_y_imgs$img)
x_y_imgs <- randomHorizontalFlip(x_y_imgs$img,
x_y_imgs$mask)
# return as arrays
x_y_arr <- list(x = img2arr(x_y_imgs$img),
y = mask2arr(x_y_imgs$mask))
}
x_y_batch <- purrr::transpose(x_y_batch)
x_batch <- do.call(abind, c(x_y_batch$x, list(along = 1)))
y_batch <- do.call(abind, c(x_y_batch$y, list(along = 1)))
result <- list(keras_array(x_batch),
keras_array(y_batch))
return(result)
}
}
```
**val\_generator**
```
val_generator <- function(images_dir,
samples_index,
masks_dir,
batch_size) {
images_iter <- list.files(images_dir,
pattern = ".jpg",
full.names = TRUE)[samples_index] # for current epoch
images_all <- list.files(images_dir,
pattern = ".jpg",
full.names = TRUE)[samples_index] # for next epoch
masks_iter <- list.files(masks_dir,
pattern = ".gif",
full.names = TRUE)[samples_index] # for current epoch
masks_all <- list.files(masks_dir,
pattern = "gif",
full.names = TRUE)[samples_index] # for next epoch
function() {
# start new epoch
if (length(images_iter) < batch_size) {
images_iter <<- images_all
masks_iter <<- masks_all
}
batch_ind <- sample(1:length(images_iter), batch_size)
batch_images_list <- images_iter[batch_ind]
images_iter <<- images_iter[-batch_ind]
batch_masks_list <- masks_iter[batch_ind]
masks_iter <<- masks_iter[-batch_ind]
x_y_batch <- foreach(i = 1:batch_size) %dopar% {
x_y_imgs <- imagesRead(image_file = batch_images_list[i],
mask_file = batch_masks_list[i])
# without augmentation
# return as arrays
x_y_arr <- list(x = img2arr(x_y_imgs$img),
y = mask2arr(x_y_imgs$mask))
}
x_y_batch <- purrr::transpose(x_y_batch)
x_batch <- do.call(abind, c(x_y_batch$x, list(along = 1)))
y_batch <- do.call(abind, c(x_y_batch$y, list(along = 1)))
result <- list(keras_array(x_batch),
keras_array(y_batch))
return(result)
}
}
```
Здесь в окружении вызова хранятся уменьшающиеся в ходе каждой эпохи списки обрабатываемых файлов, а также копии полных списков, которые используется в начале каждой следующей эпохи. В данной реализации не нужно беспокоиться о случайном перемешивании файлов — каждый батч получается путем случайной выборки.
Как было показано выше, `x_y_batch` представляет собой список из 16 списков, каждый из которых является списком из 2 массивов. Функция `purrr::transpose()` выворачивает вложенные списки наизнанку, и мы получаем список из 2 списков, каждый из которых является списком из 16 массивов. `abind()` объединяет массивы вдоль указанного измерения, `do.call()` передает во внутреннюю функцию произвольное число аргументов. Дополнительные аргументы (`along = 1`) задаются весьма причудливым способом: `do.call(abind, c(x_y_batch$x, list(along = 1)))`.
Осталось превратить эти функции в объекты, понятные для **Keras**, при помощи `py_iterator()`:
```
train_iterator <- py_iterator(train_generator(images_dir = images_dir,
masks_dir = masks_dir,
samples_index = train_index,
batch_size = batch_size))
val_iterator <- py_iterator(val_generator(images_dir = images_dir,
masks_dir = masks_dir,
samples_index = val_index,
batch_size = batch_size))
```
Вызов `iter_next(train_iterator)` вернет результат выполнения одной итерации, что полезно на этапе отладки.
#### 5. Задача сегментации и функция потерь для нее
Задачу сегментации можно рассматривать как попиксельную классификацию: предсказывается принадлежность каждого пикселя к тому или иному классу. Для случая двух классов результат будет представлять собой маску; если классов больше двух, число масок будет равно числу классов минус 1 (аналог one-hot encodind). В нашем соревновании классов всего два (машина и фон), метрикой качества выступает [dice-коэффициент](https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient). Рассчитывает он так:
```
K <- backend()
dice_coef <- function(y_true, y_pred, smooth = 1.0) {
y_true_f <- K$flatten(y_true)
y_pred_f <- K$flatten(y_pred)
intersection <- K$sum(y_true_f * y_pred_f)
result <- (2 * intersection + smooth) /
(K$sum(y_true_f) + K$sum(y_pred_f) + smooth)
return(result)
}
```
Оптимизировать будем функцию потерь, являющуюся суммой перекрестной энтропии и `1 - dice_coef`:
```
bce_dice_loss <- function(y_true, y_pred) {
result <- loss_binary_crossentropy(y_true, y_pred) +
(1 - dice_coef(y_true, y_pred))
return(result)
}
```
#### 6. Архитектура U-Net
[U-Net](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/) — классическая архитектура для решения задач сегментации. Принципиальная схема:
*Источник: <https://www.researchgate.net/figure/311715357_fig3_Fig-3-U-NET-Architecture>*
Реализация для картинок 128х128:
**U-Net 128**
```
get_unet_128 <- function(input_shape = c(128, 128, 3),
num_classes = 1) {
inputs <- layer_input(shape = input_shape)
# 128
down1 <- inputs %>%
layer_conv_2d(filters = 64, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 64, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
down1_pool <- down1 %>%
layer_max_pooling_2d(pool_size = c(2, 2), strides = c(2, 2))
# 64
down2 <- down1_pool %>%
layer_conv_2d(filters = 128, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 128, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
down2_pool <- down2 %>%
layer_max_pooling_2d(pool_size = c(2, 2), strides = c(2, 2))
# 32
down3 <- down2_pool %>%
layer_conv_2d(filters = 256, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 256, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
down3_pool <- down3 %>%
layer_max_pooling_2d(pool_size = c(2, 2), strides = c(2, 2))
# 16
down4 <- down3_pool %>%
layer_conv_2d(filters = 512, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 512, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
down4_pool <- down4 %>%
layer_max_pooling_2d(pool_size = c(2, 2), strides = c(2, 2))
# 8
center <- down4_pool %>%
layer_conv_2d(filters = 1024, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 1024, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
# center
up4 <- center %>%
layer_upsampling_2d(size = c(2, 2)) %>%
{layer_concatenate(inputs = list(down4, .), axis = 3)} %>%
layer_conv_2d(filters = 512, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 512, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 512, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
# 16
up3 <- up4 %>%
layer_upsampling_2d(size = c(2, 2)) %>%
{layer_concatenate(inputs = list(down3, .), axis = 3)} %>%
layer_conv_2d(filters = 256, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 256, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 256, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
# 32
up2 <- up3 %>%
layer_upsampling_2d(size = c(2, 2)) %>%
{layer_concatenate(inputs = list(down2, .), axis = 3)} %>%
layer_conv_2d(filters = 128, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 128, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 128, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
# 64
up1 <- up2 %>%
layer_upsampling_2d(size = c(2, 2)) %>%
{layer_concatenate(inputs = list(down1, .), axis = 3)} %>%
layer_conv_2d(filters = 64, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 64, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu") %>%
layer_conv_2d(filters = 64, kernel_size = c(3, 3), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation("relu")
# 128
classify <- layer_conv_2d(up1,
filters = num_classes,
kernel_size = c(1, 1),
activation = "sigmoid")
model <- keras_model(
inputs = inputs,
outputs = classify
)
model %>% compile(
optimizer = optimizer_rmsprop(lr = 0.0001),
loss = bce_dice_loss,
metrics = c(dice_coef)
)
return(model)
}
model <- get_unet_128()
```
Фигурные скобки в `{layer_concatenate(inputs = list(down4, .), axis = 3)}` нужны для подстановки объекта в виде нужного аргумента, а не в виде первого по счету, как в противном случае делает оператор `%>%`. Можно предложить много модификаций этой архитектуры: использовать `layer_conv_2d_transpose` вместо `layer_upsampling_2d`, применить раздельные свертки `layer_separable_conv_2d` вместо обычных, поэкспериментировать с числов фильтров и с настройками оптимизаторов. По ссылке [Kaggle Carvana Image Masking Challenge solution with Keras](https://github.com/petrosgk/Kaggle-Carvana-Image-Masking-Challenge) имеются варианты для разрешений вплоть до 1024х1024, которые так же легко портируются на R.
В нашей модели достаточно много параметров:
```
# Total params: 34,540,737
# Trainable params: 34,527,041
# Non-trainable params: 13,696
```
#### 7. Обучение модели
Тут все просто. Запускаем Tensorboard:
```
tensorboard("logs_r")
```
В качестве альтернативы доступен пакет **[tfruns](https://tensorflow.rstudio.com/tools/tfruns/articles/overview.html)**, который добавляет в IDE RStudio некий аналог Tensorboard и позволяет упорядочить работу по обучению нейросетей.
Указываем callback-и. Будем использовать раннюю остановку, уменьшать скорость обучения при выходе на плато и сохранять веса лучшей модели:
```
callbacks_list <- list(
callback_tensorboard("logs_r"),
callback_early_stopping(monitor = "val_python_function",
min_delta = 1e-4,
patience = 8,
verbose = 1,
mode = "max"),
callback_reduce_lr_on_plateau(monitor = "val_python_function",
factor = 0.1,
patience = 4,
verbose = 1,
epsilon = 1e-4,
mode = "max"),
callback_model_checkpoint(filepath = "weights_r/unet128_{epoch:02d}.h5",
monitor = "val_python_function",
save_best_only = TRUE,
save_weights_only = TRUE,
mode = "max" )
)
```
Запускаем обучение и ждем. На GTX 1050ti одна эпоха занимает порядка 10 минут:
```
model %>% fit_generator(
train_iterator,
steps_per_epoch = as.integer(length(train_index) / batch_size),
epochs = epochs,
validation_data = val_iterator,
validation_steps = as.integer(length(val_index) / batch_size),
verbose = 1,
callbacks = callbacks_list
)
```
#### 8. Предсказания на основе модели
Под спойлером приводится демо-версия кода для предсказания с использованием run-length encoding.
**Предсказания на основе модели**
```
test_dir <- "input/test/"
test_samples <- 100064
test_index <- sample(1:test_samples, 1000)
load_model_weights_hdf5(model, "weights_r/unet128_08.h5") # best model
imageRead <- function(image_file,
target_width = 128,
target_height = 128) {
img <- image_read(image_file)
img <- image_scale(img, paste0(target_width, "x", target_height, "!"))
}
img2arr <- function(image,
target_width = 128,
target_height = 128) {
result <- aperm(as.numeric(image[[1]])[, , 1:3], c(2, 1, 3)) # transpose
dim(result) <- c(1, target_width, target_height, 3)
return(result)
}
arr2img <- function(arr,
target_width = 1918,
target_height = 1280) {
img <- image_read(arr)
img <- image_scale(img, paste0(target_width, "x", target_height, "!"))
}
qrle <- function(mask) {
img <- t(mask)
dim(img) <- c(128, 128, 1)
img <- arr2img(img)
arr <- as.numeric(img[[1]])[, , 2]
vect <- ifelse(as.vector(arr) >= 0.5, 1, 0)
turnpoints <- c(vect, 0) - c(0, vect)
starts <- which(turnpoints == 1)
ends <- which(turnpoints == -1)
paste(c(rbind(starts, ends - starts)), collapse = " ")
}
cl <- makePSOCKcluster(4)
clusterEvalQ(cl, {
library(magick)
library(abind)
library(reticulate)
imageRead <- function(image_file,
target_width = 128,
target_height = 128) {
img <- image_read(image_file)
img <- image_scale(img, paste0(target_width, "x", target_height, "!"))
}
img2arr <- function(image,
target_width = 128,
target_height = 128) {
result <- aperm(as.numeric(image[[1]])[, , 1:3], c(2, 1, 3)) # transpose
dim(result) <- c(1, target_width, target_height, 3)
return(result)
}
qrle <- function(mask) {
img <- t(mask)
dim(img) <- c(128, 128, 1)
img <- arr2img(img)
arr <- as.numeric(img[[1]])[, , 2]
vect <- ifelse(as.vector(arr) >= 0.5, 1, 0)
turnpoints <- c(vect, 0) - c(0, vect)
starts <- which(turnpoints == 1)
ends <- which(turnpoints == -1)
paste(c(rbind(starts, ends - starts)), collapse = " ")
}
})
registerDoParallel(cl)
test_generator <- function(images_dir,
samples_index,
batch_size) {
images_iter <- list.files(images_dir,
pattern = ".jpg",
full.names = TRUE)[samples_index]
function() {
batch_ind <- sample(1:length(images_iter), batch_size)
batch_images_list <- images_iter[batch_ind]
images_iter <<- images_iter[-batch_ind]
x_batch <- foreach(i = 1:batch_size) %dopar% {
img <- imageRead(image_file = batch_images_list[i])
# return as array
arr <- img2arr(img)
}
x_batch <- do.call(abind, c(x_batch, list(along = 1)))
result <- list(keras_array(x_batch))
}
}
test_iterator <- py_iterator(test_generator(images_dir = test_dir,
samples_index = test_index,
batch_size = batch_size))
preds <- predict_generator(model, test_iterator, steps = 10)
preds <- foreach(i = 1:160) %dopar% {
result <- qrle(preds[i, , , ])
}
preds <- do.call(rbind, preds)
```
Ничего нового этот код не содержит, кроме функции `qrle`, которая выдает предсказания в требуемом организаторами соревнования формате (за нее спасибо **skoffer**-у):
**Результаты**
Гифка со сравнением оригинальной и предсказанной маски:
Отсутствие мелких деталей объясняется использованием картинок низкого разрешения — всего 128х128. При работе в более высоком разрешении результат будет, разумеется, лучше.
При нехватке памяти можно делать предсказания порциями по несколько тысяч наблюдений, а затем сохранять их в один файл.
**Итого**
В этом сообщении было показано, что и сидя на R можно не отставать от модных тенденций и успешно обучать глубокие нейросетки. Причем даже ОС Windows не в силах этому помешать.
Продолжение, как обычно, следует. | https://habr.com/ru/post/340212/ | null | ru | null |
# Cloud-AI – искусственный интеллект в облаке, нашедший 10 уязвимостей LinkedIn
В 2015 году команда проекта CloudSek задалась целью разработки системы искусственного интеллекта, которая сможет взаимодействовать с интернетом как разумный человек. Первый прототип системы был представлен публике в марте 2016 года на конференции NullCon. С тех пор в проекте было несколько прорывных открытий, о которых мы хотим сегодня рассказать.
[](https://habrahabr.ru/company/cloud4y/blog/326212/)
Cloud-AI от CloudSek
--------------------
Люди ~~(на самом деле, не все)~~ понимают, что делать на сайте или в мобильном приложении, основываясь на предыдущем опыте и с помощью визуальных подсказок. Мы понимаем, где «кнопка» по надписи на ней, по её форме и даже по размеру и цвету объектов. Компьютерные системы старого типа не используют прежний опыт в решение новых задач. Этот вызов приняли разработчики из CloudSek. Они разработали систему на основе искусственного интеллекта, которая перемещается по веб-сайтам как человек, развивающийся на собственном опыте.
В CloudSek используется обучение с частичным привлечением учителя (Semi-supervised learning) — для части прецедентов задается пара «ситуация, требуемое решение», а для части — только «ситуация». Люди создали огромное количество способов и обозначений механизмов взаимодействия с веб-интерфейсами. Эти данные используются для тренировки системы Cloud-AI от CloudSek, до тех пор пока модель самостоятельно не выполняет необходимые задачи успешно. Такой подход помогает справляться со сложными ситуациями. Обучение с подкреплением сигналами только от среды взаимодействия (reinforcement learning), а не от учителя, как в CloudSek, было бы менее эффективным по затратам времени при решении подобных задач. Спустя 14 месяцев обучения расстановкой тегов на различные варианты веб-интерфейсов и создания контрольного набора данных, команда проекта получила поразительные результаты.
*Cloud-AI успешно распознает и классифицирует формы ввода, кнопки и ссылочную навигацию с минимальной погрешностью. С Cloud-AI возможно эффективное взаимодействие с мобильными, веб или практически любыми приложениями, в которых использован графический пользовательский интерфейс.*
Введение
--------
В 2015 Amazon выпустила Amazon Echo, персональный ассистент с искусственным интеллектом, который может услышать, понять и ответить на любой вопрос. Google уже тестирует автомобили на автопилоте в нескольких городах. Компании создают технологии, которые помогают людям в их повседневной деятельности. В CloudSek используют искусственный интеллект, чтобы создать агентов, которые могут перемещаться по интернет-паутине и выполнять сложные, но скучные и отнимающие много времени задачи.
В идее автоматизации веб-задач ничего нового. Однако, развивающаяся автоматизированная система, которая может взаимодействовать и перемещаться по любому пользовательскому интерфейсу в сети – это нечто совершенно иное, и игра стоит свеч. Amazon Echo может сделать заказ для вас через портал покупок Amazon. Но Echo не в состояние заказать для вас товар через Alibaba или другой сервис с неизвестным ему API. В будущем мы сможем использовать Cloud-AI для заказа чего угодно где угодно через интернет и выполнения прочих сложных задач, экономя время.
Cloud-AI быстр и точен, он используется CloudSek для создания продуктов x-Vigil и CloudMon.
* x-Vigil просматривает различные Интернет-ресурсы, социальные медиа-платформы и форумы, распознавая широкий спектр угроз информационной безопасности и оповещая об этом в режиме реального времени без ручного вмешательства.
* CloudMon проводит мониторинг незащищенности интернет-инфраструктуры (облачные приложения, веб-сайты) с целью выявления критически важных проблем безопасности.
CloudSek использует Cloud-AI в качестве автоматизированного мониторинга безопасности веб-приложений и облачной инфраструктуры вместо ручного тестирования, наращивая при этом потенциал системы после каждого теста.
Cloud-AI: Кейсы и результаты в сфере информационной безопасности приложений
---------------------------------------------------------------------------
Небезопасные прямые ссылки на объекты (Insecure Direct Object References) были одной из наиболее известных проблем безопасности на Facebook. Приложения часто используют реальное имя или ключ объекта при создании веб-страниц, не всегда выполняя проверку авторизации пользователя для целевого действия. Это создает брешь в безопасности приложений.
Например, функция удаления учетной записи:
```
http://domain.com/delete-account.php?userid=5555
```
Атакующий `User-id = 5555`, легко заменяется значением User-id жертвы для обнаружения таких уязвимостей. Задача поиска таких известных ошибок безопасности сложна для автоматизированного инструмента из-за труднодоступности целевого действия. Причина этого — необходимость многошагового взаимодействия с интерфейсом. Ручное тестирование каждого такого бага отнимет очень много времени.
CloudSek использовала систему Cloud-AI для взаимодействия со многими популярными и современными веб-приложениями для автоматического тестирования уязвимостей. Основной целью были небезопасные прямые ссылки на объекты. В числе тестируемых платформ был LinkedIn, выбранный по причине известности и простоты интерфейса.
### Тестирование утечек данных в LinkedIn
Команда проекта обнаружила 10 уязвимостей через небезопасные прямые ссылки на объекты в LinkedIn. Эти баги было бы очень трудоемко найти вручную и практически невозможно с помощью традиционных автоматизированных средств. Команда LinkedIn была уведомлена об этих уязвимостях. Вот несколько уже исправленных:
1. Утечка email для id любого пользователя.
2. Утечка email пользователей, телефонных номеров и резюме.
3. Удаление всех пользовательских приглашений.
4. Скачивание субтитров ко всем видео в библиотеке онлайн-курсов Lynda.
5. Загрузка всех файлов с упражнениями без покупки премиального аккаунта Lynda.
Хотя все баги были довольно простыми, потребовались большие усилия, чтобы их найти. Cloud-AI заполнял многочисленные пользовательские формы и следовал поведенческим моделям для достижения уязвимостей. Такие уязвимости часто упускаются существующими автоматизированными средствами и при ручном тестировании.
#### **1) Утечка email для id любого пользователя**
Существует возможность, позволяющая рекрутерам делиться контактами отобранных кандидатов с другими менеджерами по найму. Запрос ниже отправит профиль кандидата другому пользователю. Изменение значения id в запросе на id жертвы позволяет получить email для этого id.
```
POST /cap/candidate/forwardProfilesAjax HTTP/1.1
Host: www.linkedin.com
csrfToken=ajax&newHiringManagerMemberIds=&forwardTo=&msgBody=Hello&_action_forwardProfilesAjax&projectId=&memberIds=[Victim ID]
```
Для нахождения этого запроса Cloud-AI успешно выполнил несколько действий:
a) Залогинился в LinkedIn;
b) Дошел по ссылкам до возможности делиться резюме;
c) Открыл правильную форму для заполнения;
d) Написал сообщение и нажал нужную кнопку для подтверждения.
*Cloud-AI самостоятельно заполняет необходимые формы*
Ответ содержал адреса электронной почты других пользователей.
*Утечка имен и email-адресов жертв*
Другие баги относительно схожи. Важно, что Cloud-AI успешно выполнял цепочку действия с графическим интерфейсом для достижения уязвимости.
#### **2) Утечка email пользователей, телефонных номеров и резюме**
Изменение memberIds в следующем запросе позволяет взломщику посмотреть резюме жертвы.
```
GET /cap/applicant/profileExportPdf?trackingSearchId=[id]&memberIds=[Victim IDs]
```
Только люди, которые искали работу через LinkedIn, были уязвимы. Следовательно, это затрагивало не всех пользователей.
#### **3) Удаление всех пользовательских приглашений**
Запрос, позволяющий удалять все приглашения на LinkedIn путем изменения request-id.
```
POST /people/invites/withdraw?isInvite=true HTTP/1.1
Host: www.linkedin.com
Connection: close
csrfToken=[]&Ids={victims request-id }
```
#### **4) Скачивание субтитров ко всем видео в библиотеке онлайн-курсов Lynda**
Запрос, скачивающий субтитры (стенограммы) всех видео без какой-либо аутентификации.
```
GET /ajax/player/transcript?courseId=496475&videoId=509328
```
#### **5) Загрузка всех файлов с упражнениями без покупки премиального аккаунта Lynda**
```
GET /ajax/course/518763/download/exercise/543328
```
После получения сообщения о найденных уязвимостях Команда LinkedIn устранила их в течение 24 часов. Поэтому обо всех описанных возможностях для взлома следует читать в прошедшем времени.
Метод и OpenSource код
----------------------
*Модуль мутации HTTP*
Все данные, полученные Cloud-AI, пропускались через прокси-сервер, который разбирал HTTP-запрос по переменным. Отправка запросов с измененными в модуле мутации переменными позволяла найти проблемы с безопасностью. Перед оповещением разработчиков LinkedIn команда CloudSek вручную проверяла найденные уязвимости.
Модуль системы, который действует как прокси-сервер и выполняет мутации, сейчас находится в [открытом доступе](https://github.com/cloudsek/Mutator).
Будущее Cloud-AI
----------------
Cloud-AI собирает всё больше информации о том, как люди взаимодействуют с веб-интерфейсами. Это позволяет команде настраивать систему на более сложные действия. В планах интеграция возможностей обучения с подкреплением сигналами от среды взаимодействия (reinforcement learning). Это позволит достичь максимального числа действий, которые Cloud-AI сможет выполнить как обычный пользователь.
Также ожидается появления API, позволяющего каждому автоматизировать выполнение своих задач, используя Cloud-AI. Мы должны помнить, что новые технологии не приходят без опасностей. Cloud-AI может стать опасным оружием, если попадет не в те руки. | https://habr.com/ru/post/326212/ | null | ru | null |
# Заменяем встроенный поиск по Хабру на гугловский
В последнее время активно ищу на Хабре заметки, связанные с VoIP. «Родной» поисковик меня давно разочаровал, а каждый раз обращаться к Гуглы стало лениво. Т.к. для вырезания нежелательного контента давно использую [Proxomitron](http://ru.wikipedia.org/wiki/Proxomitron), решил добавить еще один фильтр (выдержка из default.cfg):
`Name = "Habrahabr.ru - search hack"
Active = TRUE
URL = "*habrahabr.ru*"
Limit = 512
Match = ""
Replace = ""
""
Name = "Habrahabr.ru - search hack"
Active = TRUE
URL = "\*habrahabr.ru\*"
Limit = 512
Match = ""
Replace = ""`
Прошу не рассматривать как демарш, а лишь как вынужденную меру. | https://habr.com/ru/post/46841/ | null | ru | null |
# HashiСorp Vault & Kubernetes Secret: используем vault-secrets-operator
[Vault](https://www.vaultproject.io/) от HashiСorp — довольно известное open-source-решение для хранения секретов и неплохая альтернатива реализации секретов в Kubernetes. Vault использует свой сайдкар-контейнер на каждом поде, который получает секреты из хранилища и доставляет их в под или же реализует доступ к секретам через csi-драйвер.
Но как быть, если необходимо положить секреты из Vault в секреты Kubernetes? Например, мы хотим хранить и обновлять свой tls-сертификат для ингресса из Vault. Или мы решили использовать gitops и хотим, чтобы в репозитории безопасно хранилось все описание инфраструктуры, в том числе и секретов Kubernetes?
Разберем этот сценарий на практике и реализуем его с помощью [vault-secrets-operator](https://github.com/ricoberger/vault-secrets-operator).
Схема работы vault-secrets-operator
-----------------------------------
При использовании оператора у нас появляется возможность создать CRD-объект с описанием kubernetes-секрета. Cамо это описание мы можем безопасно хранить в репозитории, а его данные будут находиться в Vault:
**Установка и настройка Vault**. На эту тему написано уже много мануалов, так что подробно останавливаться не буду. Например, можно положиться на официальную документацию [установки через helm-чарт в кластер Kubernetes](https://www.vaultproject.io/docs/platform/k8s/helm).
С его помощью несложно сделать HA-установку c базой PostgreSQL и настроенным ингрессом. Главное в этом случае — не забыть создать в базе таблицы для HA-режима. После необходимо проинициализировать под командой vault operator init, если хотите вручную распечатывать Vault при перезапусках подов.
Итак, у нас на руках токен доступа, наш Vault настроен и доступен извне. Ставим себе консольную утилиту Vault на десктоп и создаем переменные окружения (у вас, конечно, будут свои значения).
```
export VAULT_ADDR=https://vault.example.cloud
VAULT_TOKEN=s.cyVpg9kDV10CQt9fEaIhdo
```
Проверяем статус нашего vault-сервера.
```
vault status
```
```
Key Value
--- -----
Seal Type shamir
Initialized true
Sealed false
Total Shares 5
Threshold 3
Version 1.7.3
Storage Type postgresql
Cluster Name vault-cluster-d487efe3
Cluster ID 11aa752a-d492-8784-6c26-e9a3e05952f9
HA Enabled true
HA Cluster https://vault-0.vault-internal:8201
HA Mode active
Active Since 2021-07-08T09:30:53.565132822Z
```
Здесь мы также можем обратить внимание на:
* Sealed — запечатан ли наш Vault;
* HA Enabled — включен ли HA-режим работы;
* Total shares — общее количество ключей;
* Threshold — количество ключей, необходимое для распечатывания.
**Отправка сертификата в Vault**. В нашем примере для простоты воспроизведения будем использовать самоподписанный tls-сертификат.
Генерируем его для домена site.example.cloud:
```
openssl req -x509 -newkey rsa:4096 -keyout tls.key -out tls.crt -nodes -days 365 -subj '/CN=site.example.cloud'
```
Создаем key-value хранилище в Vault и закидываем в него сгенерированный сертификат:
```
vault secrets enable -path=ingress-tls kv
```
```
vault write ingress-tls/site.example.cloud tls.crt=@tls.crt tls.key=@tls.key
```
На всякий случай проверим наш сертификат в Vault:
```
vault read ingress-tls/site.example.cloud
```
**Cоздание политики на чтение секретов и генерация токена**. Сертификат на месте. Теперь создадим политику и сгенерируем на ее основе токен доступа к хранилищу, где лежит сертификат.
```
cat <
```
```
vault token create -period=720h -policy=vault-secrets-operator
```
Настройка vault-secrets-operator
--------------------------------
Сначала устанавливаем репозиторий с чартом:
```
helm repo add ricoberger https://ricoberger.github.io/helm-charts
helm repo update
```
Предполагается, что наш токен доступа к Vault в процессе работы будет продлеваться. Создаем kubernetes-секрет для его хранения.
Переводим токен в формат base64 и описываем секрет.
```
cat <> operator-secrets.yaml
apiVersion: v1
kind: Secret
metadata:
name: vault-secrets-operator
namespace: vault-operator
type: Opaque
data:
VAULT\_TOKEN: $(echo -n s.W4ndAJbuoDMsoLDZyVBG18F2 | base64)
EOF
```
Описываем конфигурацию нашего helm-чарта:
```
cat <> values.yaml
environmentVars:
- name: VAULT\_TOKEN
valueFrom:
secretKeyRef:
name: vault-secrets-operator # указываем наш секрет
key: VAULT\_TOKEN
- name: VAULT\_TOKEN\_LEASE\_DURATION
value: "720"
vault:
address: "https://vault.example.cloud"
authMethod: token
reconciliationTime: 15 #Время в секундах, через которое оператор будет обновлять секрет
EOF
```
Создаем неймспейс и применяем созданную конфигурацию:
```
kubectl create ns vault-operator
kubectl create -f operator-secrets.yaml
```
Устанавливаем helm-chart:
```
helm install vault-secrets-operator ricoberger/vault-secrets-operator -n vault-operator -f values.yaml
```
Установка закончена.
Теперь с помощью оператора посмотрим, как будет выглядеть наш секрет.
```
cat <
```
В дальнейшем при работе проверить взаимодействие секрет-оператора с vault-сервером можно в логах пода.
Там мы увидим, как по тайм-ауту синхронизируются наши секреты, а также происходит процесс продления токена (renew token):
```
{"level":"info","ts":1627985973.7251098,"logger":"vault","msg":"Renew Vault token"}
{"level":"info","ts":1627985978.8396158,"logger":"controllers.VaultSecret","msg":"Use shared client to get secret from Vault","vaultsecret":"default/ingress-tls"}
{"level":"info","ts":1627985978.839656,"logger":"vault","msg":"Read secret ingress-tls/site.example.cloud"}
{"level":"info","ts":1627985978.90391,"logger":"controllers.VaultSecret","msg":"Updating a Secret","vaultsecret":"default/ingress-tls","Secret.Namespace":"default","Secret.Name":"ingress-tls"}
{"level":"info","ts":1627985993.925628,"logger":"controllers.VaultSecret","msg":"Use shared client to get secret from Vault","vaultsecret":"default/ingress-tls"}
{"level":"info","ts":1627985993.9256816,"logger":"vault","msg":"Read secret ingress-tls/site.example.cloud"}
{"level":"info","ts":1627985993.9865305,"logger":"controllers.VaultSecret","msg":"Updating a Secret","vaultsecret":"default/ingress-tls","Secret.Namespace":"default","Secret.Name":"ingress-tls"}
```
Проверяем kubernetes-секрет в кластере:
```
kubectl get secrets ingress-tls -o yaml
```
Секрет на месте. Все готово!
В дальнейшем мы можем применить tls-сертификат, к примеру, на нашем тестовом ингрессе. Не забудьте перед запуском отредактировать под себя.
```
kubectl create -f https://raw.githubusercontent.com/xor222xor/habr-ingress/main/manifest.yml
```
Смотрим наш сертификат снаружи:
```
openssl s_client -showcerts -connect site.example.cloud:443 /dev/null | openssl x509 -noout -text | grep Issuer
```
Что в результате
----------------
Я разобрал простой способ использования HashiCorp Vault для хранения секретов Kubernetes. В дальнейшем манифест c описанием секрета можно безопасно хранить в git-репозитории и использовать в своих интеграциях, а данные централизованно держать в Vault.
Конечно, не стоит забывать, что при получении полного доступа к кластеру даже Vault не решит проблем с безопасностью. | https://habr.com/ru/post/571356/ | null | ru | null |
# Vulkan. Руководство разработчика. Window surface
Я из IT-компании CGTribe и здесь я перевожу руководство к Vulkan API. Ссылка на оригинал — [vulkan-tutorial.com](https://vulkan-tutorial.com/).
Моя следующая публикация посвящена переводу главы Window surface из раздела Drawing a triangle, подраздела Presentation.
**Содержание**
1. [Вступление](http://habr.com/ru/post/462137/)
2. [Краткий обзор](http://habr.com/ru/post/524992/)
3. [Настройка окружения](https://habr.com/ru/post/526320/)
4. [Рисуем треугольник](https://habr.com/ru/post/531196/)
1. [Подготовка к работе](https://habr.com/ru/post/531196/)
* [Базовый код](https://habr.com/ru/post/531196/#base)
* [Экземпляр (instance)](https://habr.com/ru/post/531196/#two)
* [Слои валидации](https://habr.com/ru/post/535342/)
* [Физические устройства и семейства очередей](https://habr.com/ru/post/537208/#phys)
* [Логическое устройство и очереди](https://habr.com/ru/post/537208/#logic)
2. Отображение на экране
* [Window surface](https://habr.com/ru/post/539174/)
* [Swap chain](https://habr.com/ru/post/542942/)
* [Image views](https://habr.com/ru/post/543288/)
3. [Графический конвейер (pipeline)](https://habr.com/ru/post/547576/)
* [Вступление](https://habr.com/ru/post/547576/)
* [Шейдерные модули](https://habr.com/ru/post/547576/#shader)
* [Непрограммируемые стадии конвейера](https://habr.com/ru/post/554492/)
* [Проходы рендера (Render passes)](https://habr.com/ru/post/560816/)
* [Заключение](https://habr.com/ru/post/560816/#conclusion)
4. Отрисовка
* [Фреймбуферы](https://habr.com/ru/post/564100/#frame)
* [Буферы команд](https://habr.com/ru/post/564100/#buffer)
* [Рендеринг и отображение на экране](https://habr.com/ru/post/567754/)
5. [Пересоздание swap chain](https://habr.com/ru/post/569912/)
5. [Вершинные буферы](https://habr.com/ru/post/571944/)
1. [Описание входных данных вершин](https://habr.com/ru/post/571944/)
2. [Создание вершинного буфера](https://habr.com/ru/post/573920/)
3. [Промежуточный буфер](https://habr.com/ru/post/578956/)
4. [Индексный буфер](https://habr.com/ru/users/alexandra_sky/posts/)
6. Uniform-буферы
1. [Layout дескрипторов и буфер](https://habr.com/ru/post/582838/)
2. Пул дескрипторов и сеты дескрипторов
7. Текстурирование
1. Изображения
2. Image view и image sampler
3. Комбинированный image sampler
8. Буфер глубины
9. Загрузка моделей
10. Создание мип-карт
11. Multisampling
FAQ
Политика конфиденциальности
Window surface
--------------
* [Создание window surface](#one)
* [Проверка поддержки отображения](#two)
* [Создание очереди отображения](#three)
Поскольку Vulkan API полностью независим от платформы, он не может напрямую взаимодействовать с оконной системой. Чтобы Vulkan мог выводить результат на экран, необходимо использовать стандартизованные расширения WSI (Window System Integration). В этой главе мы расскажем про одно из них — **`VK_KHR_surface`**. Расширение предоставляет объект **`VkSurfaceKHR`** — абстрактный тип поверхности для показа отрендеренных изображений. Эта поверхность будет создана при поддержке окна GLFW, полученного нами ранее.
**`VK_KHR_surface`** – это расширение Vulkan уровня экземпляра. У нас оно уже подключено, поскольку находится в списке расширений, возвращаемых функцией **`glfwGetRequiredInstanceExtensions`**. В списке есть и другие расширения WSI, которые мы будем использовать в следующих главах.
Window surface нужно создать сразу после VkInstance, поскольку это может повлиять на выбор физического устройства. Нужно помнить, что window surfaces — полностью опциональный компонент Vulkan. Вы можете обойтись без него, если вам нужен offscreen рендеринг. Это позволяет избежать таких хаков, как, например, создание невидимого окна для OpenGL.
Создание window surface
-----------------------
Начнем с того, что добавим новый член класса **`surface`** сразу после вызова **`debugMessenger`**.
```
VkSurfaceKHR surface;
```
Процесс создания объекта **`VkSurfaceKHR`** зависит от платформы. Так, например, для создания в Windows нужны дескрипторы **`HWND`** и **`HMODULE`**. Для разных платформ у Vulkan есть платформенно-зависимое дополнение к расширению, которое в Windows называется **`VK_KHR_win32_surface`**. Оно также автоматически включено в список расширений, возвращаемых функцией **`glfwGetRequiredInstanceExtensions`**.
Мы покажем, как можно использовать это расширение для создания surface в Windows, однако в руководстве оно нам не понадобится. В библиотеке GLFW, которую мы используем, есть функция-обертка **`glfwCreateWindowSurface`**, содержащая специфичный для платформы код. Но было бы не плохо увидеть, что происходит за кулисами.
Window surface – это объект Vulkan, поэтому мы должны заполнить структуру **`VkWin32SurfaceCreateInfoKHR`**, чтобы создать его. В ней есть два важных параметра: **`hwnd`** и **`hinstance`** — дескрипторы окна и текущего процесса.
```
VkWin32SurfaceCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
createInfo.hwnd = glfwGetWin32Window(window);
createInfo.hinstance = GetModuleHandle(nullptr);
```
Здесь для получения сырого **`HWND`** используется функция **`glfwGetWin32Window`**, а для получения **`HINSTANCE`** - функция **`GetModuleHandle`**.
После этого мы можем создать surface с помощью функции **`vkCreateWin32SurfaceKHR`**, в которую передаются следующие параметры: экземпляр Vulkan, информация о surface, кастомный аллокатор и указатель для записи результата. Технически это функция расширения WSI, но она используется так часто, что была включена в стандартный загрузчик Vulkan, поэтому вам не нужно загружать ее явно.
```
if (vkCreateWin32SurfaceKHR(instance, &createInfo, nullptr, &surface) != VK_SUCCESS) {
throw std::runtime_error("failed to create window surface!");
}
```
Для других платформ подход аналогичен. Для Linux, например, используется функция **`vkCreateXcbSurfaceKHR`**.
Функция **`glfwCreateWindowSurface`** делает именно эту работу, но имеет свою реализацию для каждой платформы. Интегрируем ее в нашу программу. Для этого добавим функцию **`createSurface`**, которая вызывается из **`initVulkan`** сразу после **`createInstance`** и **`setupDebugMessenger`**.
```
void initVulkan() {
createInstance();
setupDebugMessenger();
createSurface();
pickPhysicalDevice();
createLogicalDevice();
}
void createSurface() {
}
```
Вместо структуры для вызова GLFW нужны простые параметры, что упрощает реализацию функции:
```
void createSurface() {
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
throw std::runtime_error("failed to create window surface!");
}
}
```
В функцию передаются следующие параметры: **`[VkInstance](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html)`**, указатель на окно GLFW, кастомный аллокатор и указатель для записи результата. Функция возвращает **`[VkResult](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResult.html)`**.
У GLFW нет специальной функции для уничтожения surface, но это легко можно сделать непосредственно с помощью Vulkan:
```
void cleanup() {
...
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyInstance(instance, nullptr);
...
}
```
Не забудьте уничтожить surface до VkInstance.
Проверка поддержки отображения
------------------------------
Хотя конкретная реализация Vulkan может поддерживать интеграцию с оконной системой, это не значит что каждое из устройств в системе это тоже поддерживает. Поэтому нам нужно расширить **`isDeviceSuitable`**, чтобы быть уверенными, что устройство может отображать изображения на surface, которую мы создали. Поскольку отображение — это процесс, происходящий через очереди команд, то задача заключается в том, чтобы найти семейство очередей, которое поддерживает отображение в созданную surface.
Вполне возможно, что семейства, поддерживающие команды рисования, и семейства, поддерживающие отображение, не будут совпадать. Поэтому мы должны изменить структуру **`QueueFamilyIndices`**, чтобы учитывать этот факт.
```
struct QueueFamilyIndices {
std::optional graphicsFamily;
std::optional presentFamily;
bool isComplete() {
return graphicsFamily.has\_value() && presentFamily.has\_value();
}
};
```
Изменим функцию **`findQueueFamilies`**, чтобы найти семейство очередей с поддержкой отображения на surface нашего окна. Для проверки используем функцию **`vkGetPhysicalDeviceSurfaceSupportKHR`**, которая принимает следующие параметры: физическое устройство, индекс семейства очередей и surface. Добавим вызов функции в тот же цикл, в котором находится проверка **`VK_QUEUE_GRAPHICS_BIT`**:
```
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
```
Затем проверим значение типа **`VkBool32`** и сохраним индекс нужного нам семейства:
```
if (presentSupport) {
indices.presentFamily = i;
}
```
Обратите внимание, что очень вероятно, что в конечном итоге это будет одно и то же семейство очередей, но мы будем рассматривать их, как если бы они были отдельными очередями. Однако вы можете отдать предпочтение физическому устройству с поддержкой графических операций и с поддержкой отображения в одной очереди.
Создание очереди отображения
----------------------------
Осталось изменить процесс создания логического устройства, чтобы создать очередь с поддержкой отображения и получить дескриптор **`[VkQueue](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html)`**. Добавим переменную класса:
```
VkQueue presentQueue;
```
Нам нужно несколько **`[VkDeviceQueueCreateInfo](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateInfo.html)`**, чтобы создать очередь для каждого из семейств. Элегантный способ это сделать — использовать **`std::set`**, чтобы выделить уникальные семейства из найденных:
```
#include
...
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
std::vector queueCreateInfos;
std::set uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
float queuePriority = 1.0f;
for (uint32\_t queueFamily : uniqueQueueFamilies) {
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK\_STRUCTURE\_TYPE\_DEVICE\_QUEUE\_CREATE\_INFO;
queueCreateInfo.queueFamilyIndex = queueFamily;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority
queueCreateInfos.push\_back(queueCreateInfo);
}
```
Изменим структуру **`[VkDeviceCreateInfo](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateInfo.html)`**, чтобы она указывала на наш вектор:
```
createInfo.queueCreateInfoCount = static_cast(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
```
В результате, если семейство для рисования и отображения одно и тоже, то его индекс будет передан один раз.
Наконец добавим вызов для получения дескриптора очереди. Если семейство очередей одно, дескрипторы должны иметь одинаковое значение.
```
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
```
В следующей главе мы рассмотрим swap chains и расскажем, как они помогают выводить изображения на экран.
[Код C++](https://vulkan-tutorial.com/code/05_window_surface.cpp) | https://habr.com/ru/post/539174/ | null | ru | null |
# Веб-приложение на Kotlin + Spring Boot + Vue.js (дополнение)
Добрый день, дорогие обитатели Хабра!
Как и следует из названия, данная статья является дополнением к написанной ранее [Веб-приложение на Kotlin + Spring Boot + Vue.js](https://habr.com/ru/post/467161/), позволяющим усовершенствовать скелет будущего приложения и сделать удобнее работу с ним.
Прежде чем приступить к повествованию, позвольте поблагодарить всех, кто оставлял комментарии в предыдущей статье.
### Содержание
* [Настройка CI/CD (Heroku)](#cicd)
* [Защита от ботов (reCAPTCHA)](#recaptcha)
* [Отправка электронной почты](#email)
* [Миграция на Gradle](#gradle)
* [Хранение токена JWT в Cookies](#cookies)
* [Подтверждение регистрации по электронной почте](#confirmation)
* [Полезные ссылки](#links)
Настройка CI/CD (Heroku)
------------------------
Рассмотрим реализацию непрерывной интеграции и доставки на примере облачной PaaS-платформы [Heroku](https://www.heroku.com).
Первое, что нам необходимо сделать — разместить код приложения в репозитории на [GitHub](https://github.com). Для того, чтобы в репозитории не оказалось ничего лишнего, рекомендую следующее содержание файла *.gitignore*:
**.gitignore**
```
*.class
# Help #
backend/*.md
# Package Files #
*.jar
*.war
*.ear
# Eclipse #
.settings
.project
.classpath
.studio
target
# NetBeans #
backend/nbproject/private/
backend/nbbuild/
backend/dist/
backend/nbdist/
backend/.nb-gradle/
backend/build/
# Apple #
.DS_Store
# Intellij #
.idea
*.iml
*.log
# logback
logback.out.xml
backend/src/main/resources/public/
backend/target
backend/.mvn
backend/mvnw
frontend/dist/
frontend/node/
frontend/node_modules/
frontend/npm-debug.log
frontend/target
!.mvn/wrapper/maven-wrapper.jar
```
Важно: перед тем, как начать работу с Heroku, добавьте в корневую директорию файл с названием *Procfile* (без какого-либо расширения) со строкой:
`web: java -Dserver.port=$PORT -jar backend/target/backend-0.0.1-SNAPSHOT.jar`, где *backend-0.0.1-SNAPSHOT.jar* — имя собирающегося JAR-файла. И обязательно сделайте commit и push.
Примечание: также в корневую директорию можно добавить файл travis.yaml, чтобы сократить время сборки и развёртывания приложения на Heroku:
**travis.yaml**
```
language: java
jdk:
- oraclejdk8
script: mvn clean install jacoco:report coveralls:report
cache:
directories:
- node_modules
```
Затем:
**#1** Зарегистрируйтесь на [Heroku](https://www.heroku.com).
**#2** Создайте новое приложение:
**Создание нового приложения**
**#3** Heroku позволяет подключать к приложению дополнительные ресурсы, например, базу данных PostreSQL. Для того, чтобы сделать это, выполните: *Application -> Resources -> Add-ons -> Heroku Postgres*:
**Heroku Postgres**
**#4** Выберите план:
**Выбор плана**
**#5** Теперь вы можете увидеть подключённый ресурс:
**Подключённый ресурс**
**#6** Посмотрите учётные данные, они понадобятся для настройки переменных окружения: *Settings -> View Credentials*:
**View Credentials**
**#7** Настройте переменные окружения: *Application -> Settings -> Reveal Config Vars*:
**Переменные окружения**
**#8** Задайте переменные окружения для подключения в следующем формате:
```
SPRING_DATASOURCE_URL = jdbc:postgresql://*hostname:port*/*db\_name*
SPRING_DATASOURCE_USERNAME = *username*
SPRING_DATASOURCE_PASSWORD = *password*
```
**Как это выглядит**
**#9** Создайте все необходимые таблицы в новой базе данных.
**#10** Файл application.properties, соотвественно, должен иметь примерно такой вид:
**application.properties**
```
spring.datasource.url=${SPRING_DATASOURCE_URL}
spring.datasource.username=${SPRING_DATASOURCE_USERNAME}
spring.datasource.password=${SPRING_DATASOURCE_PASSWORD}
spring.jpa.generate-ddl=true
spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults = false
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL9Dialect
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true
```
**#11** Создайте новый пайплайн — *Create new pipeline*:
**Create new pipeline**
**#12** Deployment method — *GitHub* (нажмите *Connect to GitHub* и следуйте инструкциям в новом окне).
**#13** Активируйте автоматическое развёртывание — *Enable Automatic Deploys*:
**Enable Automatic Deploys**
**#14** Manual Deploy — нажмите *Deploy Branch* для первого развёртывания. Прямо в браузере вы увидите вывод командной строки.
**Manual Deploy**
**#15** Нажмите *View* после успешной сборки, чтобы открыть развёрнутое приложение:
**View**
Защита от ботов (reCAPTCHA)
---------------------------
Первый шаг для подключения проверки reCAPTCHA в нашем приложении — создание новой reCAPTCH'и в [администраторской панели Google](https://www.google.com/recaptcha/intro/v3.html). Там создаём новый сайт (Add new site / Create) и устанавливаем следующие настройки:
**Настройки reCAPTCHA**
В разделе *Domains* стоит указать помимо адреса, по которому будет жить приложение, следует указать `localhost`, чтобы при отладке избежать неприятностей в виде невозможности авторизоваться в своём же приложении.
**Бэкенд**
Сохраним *site key* и *secret key*…
**site key / secret key**
… чтобы потом присвоить их переменным окружения, а названия переменных, в свою очередь, присвоить новым свойствам *application.properties*:
```
google.recaptcha.key.site=${GOOGLE_RECAPTCHA_KEY_SITE}
google.recaptcha.key.secret=${GOOGLE_RECAPTCHA_KEY_SECRET}
```
Добавим новую зависимость в *pom.xml* для верификации на стороне Google reCAPTCHA-токенов, которые будет присылать нам клиент:
```
com.mashape.unirest
unirest-java
1.4.9
```
Теперь самое время обновить сущности, которые мы используем для авторизации и регистрации пользователей, добавив в них строковое поле для того самого reCAPTCHA-токена:
**LoginUser.kt**
```
import com.fasterxml.jackson.annotation.JsonProperty
import java.io.Serializable
class LoginUser : Serializable {
@JsonProperty("username")
var username: String? = null
@JsonProperty("password")
var password: String? = null
@JsonProperty("recapctha_token")
var recaptchaToken: String? = null
constructor() {}
constructor(username: String, password: String, recaptchaToken: String) {
this.username = username
this.password = password
this.recaptchaToken = recaptchaToken
}
companion object {
private const val serialVersionUID = -1764970284520387975L
}
}
```
**NewUser.kt**
```
import com.fasterxml.jackson.annotation.JsonProperty
import java.io.Serializable
class NewUser : Serializable {
@JsonProperty("username")
var username: String? = null
@JsonProperty("firstName")
var firstName: String? = null
@JsonProperty("lastName")
var lastName: String? = null
@JsonProperty("email")
var email: String? = null
@JsonProperty("password")
var password: String? = null
@JsonProperty("recapctha_token")
var recaptchaToken: String? = null
constructor() {}
constructor(username: String, firstName: String, lastName: String, email: String, password: String, recaptchaToken: String) {
this.username = username
this.firstName = firstName
this.lastName = lastName
this.email = email
this.password = password
this.recaptchaToken = recaptchaToken
}
companion object {
private const val serialVersionUID = -1764970284520387975L
}
}
```
Добавим небольшой сервис, который будет транслировать reCAPTCHA-токен специальному сервису Google и сообщать в ответ, прошёл ли токен верификацию:
**ReCaptchaService.kt**
```
import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Service
import org.springframework.web.client.RestOperations
import org.springframework.beans.factory.annotation.Autowired
import com.mashape.unirest.http.HttpResponse
import com.mashape.unirest.http.JsonNode
import com.mashape.unirest.http.Unirest
@Service("captchaService")
class ReCaptchaService {
val BASE_VERIFY_URL: String = "https://www.google.com/recaptcha/api/siteverify"
@Autowired
private val restTemplate: RestOperations? = null
@Value("\${google.recaptcha.key.site}")
lateinit var keySite: String
@Value("\${google.recaptcha.key.secret}")
lateinit var keySecret: String
fun validateCaptcha(token: String): Boolean {
val url: String = String.format(BASE_VERIFY_URL + "?secret=%s&response=%s", keySecret, token)
val jsonResponse: HttpResponse = Unirest.get(url)
.header("accept", "application/json").queryString("apiKey", "123")
.asJson()
return (jsonResponse.getStatus() == 200)
}
}
```
Этот сервис необходимо задействовать в контроллере регистрации и авторизации пользователей:
**AuthController.kt**
```
import com.kotlinspringvue.backend.service.ReCaptchaService
…
@Autowired
lateinit var captchaService: ReCaptchaService
…
if (!captchaService.validateCaptcha(loginRequest.recaptchaToken!!)) {
return ResponseEntity(ResponseMessage("Validation failed (ReCaptcha v2)"),
HttpStatus.BAD_REQUEST)
}
else [if]...
…
if (!captchaService.validateCaptcha(newUser.recaptchaToken!!)) {
return ResponseEntity(ResponseMessage("Validation failed (ReCaptcha v2)"),
HttpStatus.BAD_REQUEST)
} else...
```
**Фронтенд**
Первым шагом установим и сохраним пакет `reCAPTHA`:
```
$ npm install --save vue-recaptcha
```
Затем подключим в скрипт в *index.html*:
```
```
В любое свободное место на странице добавим саму капчу:
```
```
А кнопка целевого действия (авторзации или регистрации) теперь будет сначала вызывать метод валидации:
```
Login
```
Добавим зависимость в компоненты:
```
import VueRecaptcha from 'vue-recaptcha'
```
Отредактируем *export default*:
```
components: { VueRecaptcha },
…
data() {
…
siteKey: *наш ключ сайта*
…
}
```
И добавим новые методы:
* `validateCaptcha()` — который вызывается кликом на кнопку
* `onCapthcaVerified(recaptchaToken) и onCaptchaExpired()` — которые вызывает сама капча
**Новые методы**
```
validateCaptcha() {
this.$refs.recaptcha.execute()
},
onCapthcaVerified(recaptchaToken) {
AXIOS.post(`/auth/signin`, {'username': this.$data.username, 'password': this.$data.password, 'recapctha_token': recaptchaToken})
.then(response => {
this.$store.dispatch('login', {'token': response.data.accessToken, 'roles': response.data.authorities, 'username': response.data.username});
this.$router.push('/home')
}, error => {
this.showAlert(error.response.data.message);
})
.catch(e => {
console.log(e);
this.showAlert('Server error. Please, report this error website owners');
})
},
onCaptchaExpired() {
this.$refs.recaptcha.reset()
}
```
**Результат**
Отправка электронной почты
--------------------------
Рассмотрим возможность отправки писем нашим приложением через публичный почтовый сервер, например Google или Mail.ru.
Первым шагом, соотвественно, станет создание аккаунта на выбранном почтовом сервере, если его ещё нет.
Вторым шагом нам необходимо добавить следующие зависимости в *pom.xml*:
**Зависимости**
```
org.springframework.boot
spring-boot-starter-mail
org.springframework.boot
spring-boot-starter-thymeleaf
commons-io
commons-io
2.4
```
Также необходимо добавить новые свойства в *application.properties*:
**SMTP-свойства**
```
spring.mail.host=${SMTP_MAIL_HOST}
spring.mail.port=${SMTP_MAIL_PORT}
spring.mail.username=${SMTP_MAIL_USERNAME}
spring.mail.password=${SMTP_MAIL_PASSWORD}
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.ssl.enable=true
spring.mail.properties.mail.smtp.connectiontimeout=5000
spring.mail.properties.mail.smtp.timeout=5000
spring.mail.properties.mail.smtp.writetimeout=5000
```
Настройки SMTP можно уточнить тут: [Google](https://support.google.com/mail/answer/7126229?hl=ru) и [Mail.ru](https://help.mail.ru/mail-help/mailer/popsmtp)
Создадим интерфейс, где объявим несколько методов:
* Для отправки обычного текстового письма
* Для отправки HTML-письма
* Для отправки письма с использованием шаблона
**EmailService.kt**
```
package com.kotlinspringvue.backend.email
import org.springframework.mail.SimpleMailMessage
internal interface EmailService {
fun sendSimpleMessage(to: String,
subject: String,
text: String)
fun sendSimpleMessageUsingTemplate(to: String,
subject: String,
template: String,
params:MutableMap)
fun sendHtmlMessage(to: String,
subject: String,
htmlMsg: String)
}
```
Теперь создадим реализацию этого интерфейса — сервис отправки электронных писем:
**EmailServiceImpl.kt**
```
package com.kotlinspringvue.backend.email
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.core.io.FileSystemResource
import org.springframework.mail.MailException
import org.springframework.mail.SimpleMailMessage
import org.springframework.mail.javamail.JavaMailSender
import org.springframework.mail.javamail.MimeMessageHelper
import org.springframework.stereotype.Component
import org.thymeleaf.spring5.SpringTemplateEngine
import org.thymeleaf.context.Context
import java.io.File
import javax.mail.MessagingException
import javax.mail.internet.MimeMessage
import org.apache.commons.io.IOUtils
import org.springframework.core.env.Environment
@Component
class EmailServiceImpl : EmailService {
@Value("\${spring.mail.username}")
lateinit var sender: String
@Autowired
lateinit var environment: Environment
@Autowired
var emailSender: JavaMailSender? = null
@Autowired
lateinit var templateEngine: SpringTemplateEngine
override fun sendSimpleMessage(to: String, subject: String, text: String) {
try {
val message = SimpleMailMessage()
message.setTo(to)
message.setFrom(sender)
message.setSubject(subject)
message.setText(text)
emailSender!!.send(message)
} catch (exception: MailException) {
exception.printStackTrace()
}
}
override fun sendSimpleMessageUsingTemplate(to: String,
subject: String,
template: String,
params:MutableMap) {
val message = emailSender!!.createMimeMessage()
val helper = MimeMessageHelper(message, true, "utf-8")
var context: Context = Context()
context.setVariables(params)
val html: String = templateEngine.process(template, context)
helper.setTo(to)
helper.setFrom(sender)
helper.setText(html, true)
helper.setSubject(subject)
emailSender!!.send(message)
}
override fun sendHtmlMessage(to: String, subject: String, htmlMsg: String) {
try {
val message = emailSender!!.createMimeMessage()
message.setContent(htmlMsg, "text/html")
val helper = MimeMessageHelper(message, false, "utf-8")
helper.setTo(to)
helper.setFrom(sender)
helper.setSubject(subject)
emailSender!!.send(message)
} catch (exception: MailException) {
exception.printStackTrace()
}
}
}
```
* Мы используем автоматически конфигурируемый JavaMailSender от Spring для отправки писем
* Отправка обычных писем предельно проста — необходимо только добавить текст в тело письма и отправить его
* HTML-письма определяются как сообщения Mime Type, а их содержание — как `text/html`
* Для обработки HTML-шаблона сообщения мы используем Spring Template Engine
Давайте же создадим простенький шаблон для письма с использованием фреймворка [Thymeleaf](https://www.thymeleaf.org), поместив его в *src/main/resources/templates/*:
**emailTemplate.html**
```
Hello
### Hello!
Hello, dear:
![]()
```
Изменяющиеся элементы шаблона (в нашем случае — имя адресата и путь картинки для подписи) объявлены с помощью плейсхолдеров.
Теперь создадим или обновим контроллер, который будет посылать письма:
**BackendController.kt**
```
import com.kotlinspringvue.backend.email.EmailServiceImpl
import com.kotlinspringvue.backend.web.response.ResponseMessage
import org.springframework.beans.factory.annotation.Value
import org.springframework.http.ResponseEntity
import org.springframework.http.HttpStatus
…
@Autowired
lateinit var emailService: EmailService
@Value("\${spring.mail.username}")
lateinit var addressee: String
…
@GetMapping("/sendSimpleEmail")
@PreAuthorize("hasRole('USER')")
fun sendSimpleEmail(): ResponseEntity<*> {
try {
emailService.sendSimpleMessage(addressee, "Simple Email", "Hello! This is simple email")
} catch (e: Exception) {
return ResponseEntity(ResponseMessage("Error while sending message"),
HttpStatus.BAD_REQUEST)
}
return ResponseEntity(ResponseMessage("Email has been sent"), HttpStatus.OK)
}
@GetMapping("/sendTemplateEmail")
@PreAuthorize("hasRole('USER')")
fun sendTemplateEmail(): ResponseEntity<*> {
try {
var params:MutableMap = mutableMapOf()
params["addresseeName"] = addressee
params["signatureImage"] = "https://coderlook.com/wp-content/uploads/2019/07/spring-by-pivotal.png"
emailService.sendSimpleMessageUsingTemplate(addressee, "Template Email", "emailTemplate", params)
} catch (e: Exception) {
return ResponseEntity(ResponseMessage("Error while sending message"),
HttpStatus.BAD\_REQUEST)
}
return ResponseEntity(ResponseMessage("Email has been sent"), HttpStatus.OK)
}
@GetMapping("/sendHtmlEmail")
@PreAuthorize("hasRole('USER')")
fun sendHtmlEmail(): ResponseEntity<\*> {
try {
emailService.sendHtmlMessage(addressee, "HTML Email", "Hello!
======
This is HTML email
")
} catch (e: Exception) {
return ResponseEntity(ResponseMessage("Error while sending message"),
HttpStatus.BAD\_REQUEST)
}
return ResponseEntity(ResponseMessage("Email has been sent"), HttpStatus.OK)
}
```
Примечание: Чтобы убедиться, что всё работает, для начала будем посылать письма самим себе.
Также, чтобы убедиться, что всё работает, можем создать скромный веб-интерфейс, который будет просто дёргать методы веб-сервиса:
**Email.vue**
```
Simple Email
Template Email
HTML Email
import {AXIOS} from './http-common'
export default {
name: 'EmailPage',
data() {
return {
counter: 0,
username: '',
header: {'Authorization': 'Bearer ' + this.$store.getters.getToken}
}
},
methods: {
sendSimpleMessage() {
AXIOS.get('/sendSimpleEmail', { headers: this.$data.header })
.then(response => {
console.log(response);
alert("OK");
})
.catch(error => {
console.log('ERROR: ' + error.response.data);
})
},
sendEmailUsingTemplate() {
AXIOS.get('/sendTemplateEmail', { headers: this.$data.header })
.then(response => {
console.log(response);
alert("OK")
})
.catch(error => {
console.log('ERROR: ' + error.response.data);
})
},
sendHTMLEmail() {
AXIOS.get('/sendHtmlEmail', { headers: this.$data.header })
.then(response => {
console.log(response);
alert("OK")
})
.catch(error => {
console.log('ERROR: ' + error.response.data);
})
}
}
}
#email {
margin-left: 38%;
margin-top: 50px;
}
button {
width: 150px;
}
```
Примечание: не забудьте обновить `router.js` и добавить ссылку в панель навигации `App.vue`, если создаёте новый компонент.
Миграция на Gradle
------------------
Сразу уточню: считать ли этот пункт усовершенствованием, пусть каждый решает сам для своего проекта. Мы же просто рассмотрим, как это сделать.
Вообще, можно воспользоваться инструкцией [Moving from Maven to Gradle in under 5 minutes](http://www.rationaljava.com/2016/02/moving-from-maven-to-gradle-in-under-5.html), но вряд ли результат оправдает ожидания. Я бы порекомендовал всё-таки осуществлять миграцию вручную, это займёт не намного больше времени.
Первое, что нам нужно сделать — [установить Gradle](https://gradle.org/install/).
Затем нам необходимо выполнить следующий порядок действий для обоих подпроектов — `backend` и `fronted`:
**#1** Удалить файлы Maven — *pom.xml*, *.mvn*.
**#2** В каталоге подпроект выполнить gradle init и ответить на вопросы:
* *Select type of project to generate:* **basic**
* *Select implementation language:* **Kotlin**
* *Select build script DSL:* **Kotlin** (раз уж мы пишем проект на Kotlin)
**#3** Удалить *settings.gradle.kts* — этот файл нужен только для корневого проекта.
**#4** Выполнить `gradle wrapper`.
Теперь обратимся к нашему корневому проекту. Для него нужно выполнить шаги 1, 2 и 4 описанные выше для под проектов — всё то же самое, кроме удаления *settings.gradle.kts*.
Конфигурация сборки для проекта *backend* будет выглядеть следующим образом:
**build.gradle.kts**
```
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins {
id("org.springframework.boot") version "2.1.3.RELEASE"
id("io.spring.dependency-management") version "1.0.8.RELEASE"
kotlin("jvm") version "1.3.50"
kotlin("plugin.spring") version "1.3.50"
id("org.jetbrains.kotlin.plugin.jpa") version "1.3.50"
}
group = "com.kotlin-spring-vue"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_1_8
repositories {
mavenCentral()
maven {
url = uri("https://plugins.gradle.org/m2/")
}
}
dependencies {
runtimeOnly(project(":frontend"))
implementation("org.springframework.boot:spring-boot-starter-actuator:2.1.3.RELEASE")
implementation("org.springframework.boot:spring-boot-starter-web:2.1.3.RELEASE")
implementation("org.springframework.boot:spring-boot-starter-data-jpa:2.1.3.RELEASE")
implementation("org.springframework.boot:spring-boot-starter-mail:2.1.3.RELEASE")
implementation("org.springframework.boot:spring-boot-starter-security:2.1.3.RELEASE")
implementation("org.postgresql:postgresql:42.2.5")
implementation("org.springframework.boot:spring-boot-starter-thymeleaf:2.1.3.RELEASE")
implementation("commons-io:commons-io:2.4")
implementation("io.jsonwebtoken:jjwt:0.9.0")
implementation("io.jsonwebtoken:jjwt-api:0.10.6")
implementation("com.mashape.unirest:unirest-java:1.4.9")
implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")
runtimeOnly("org.springframework.boot:spring-boot-devtools:2.1.3.RELEASE")
implementation("org.jetbrains.kotlin:kotlin-reflect")
implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
implementation("org.jetbrains.kotlin:kotlin-noarg:1.3.50")
testImplementation("org.springframework.boot:spring-boot-starter-test") {
exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
}
}
tasks.withType {
kotlinOptions {
freeCompilerArgs = listOf("-Xjsr305=strict")
jvmTarget = "1.8"
}
}
```
* Следует указать все необходимые плагины Kotlin и Spring
* Не следует забывать про плагин *org.jetbrains.kotlin.plugin.jpa* — он необходим для подключения к базе данных
* В зависимостях необходимо указать `runtimeOnly(project(":frontend"))` — нам нужно собирать проект *frontend* в первую очередь
Конфигурация сборки для проекта *frontend*:
**build.gradle.kts**
```
plugins {
id("org.siouan.frontend") version "1.2.1"
id("java")
}
group = "com.kotlin-spring-vue"
version = "0.0.1-SNAPSHOT"
java {
targetCompatibility = JavaVersion.VERSION_1_8
}
buildscript {
repositories {
mavenCentral()
maven {
url = uri("https://plugins.gradle.org/m2/")
}
}
}
frontend {
nodeVersion.set("10.16.0")
cleanScript.set("run clean")
installScript.set("install")
assembleScript.set("run build")
}
tasks.named("jar", Jar::class) {
dependsOn("assembleFrontend")
from("$buildDir/dist")
into("static")
}
```
* В моём примере для сборки проекта используется плагин `org.siouan.frontend`
* В разделе `frontend {...}` следует указать версию Node.js, а также команды, вызывающие скрипты очистки, установки и сборки, прописанные в `package.json`
* Теперь мы упаковываем наш подпроект frontend в JAR-файл и используем его как зависимость (`runtimeOnly(project(":frontend"))` в *backend*'е), так что нам необходимо описать задание (`task`), которое копирует файлы из сборочной директории в */public* и создаёт JAR-файл
Примечание:
* Отредактируйте `vue.config.js`, изменив директорию сборки на *build/dist*.
* Укажите в файле `package.json` *build script* — `vue-cli-service build` или убедитесь, что он указан
Файл settings.gradle.kts в корневом проекте должен содержать следующий код:…
```
rootProject.name = "demo"
include(":frontend", ":backend")
```
… — название проекта и подпроектов.
И теперь мы можем собрать проект, выполнив команду: `./gradlew build`
Примечание: если для плейсхолдеров, указанных в *application.properties* (например, `${SPRING_DATASOURCE_URL}`) нет соответствующих переменных среды, сборка завершится неудачно. Чтобы этого избежать, следует использовать `**/gradlew build -x**`
Проверить структуру проектов можно с помощью команды `gradle -q projects`, результат должен выглядеть подобным образом:
```
Root project 'demo'
+--- Project ':backend'
\--- Project ':frontend'
```
И, наконец, чтобы запустить приложение, необходимо выполнить `./gradlew bootRun`.
#### .gitignore
В файл *.gitignore* следует добавить следующие файлы и папки:
* backend/build/
* frontend/build/
* build
* .gradle
Важно: не следует добавлять файлы `gradlew` в *.gitignore* — ничего опасного в них нет, однако они нужны для успешной сборки на удалённом сервере.
#### Деплой на Heroku
Давай рассмотрим изменения, которые нам необходимо внести, чтобы приложение благополучно разворачивалось на Heroku.
**#1 Procfile**
Нам необходимо задать Heroku новые инструкции для запуска приложения:
```
web: java -Dserver.port=$PORT -jar backend/build/libs/backend-0.0.1-SNAPSHOT.jar
```
**#2 Переменные среды**
Heroku способна переделать тип приложения (например, приложение Spring Boot) и выполнять соотвествующие инструкции для сборки. Но наше приложение (корневой проект) не выглядит для Heroku как приложение Spring Boot. Если мы оставим всё, как есть, Heroku попросит нас определить таску `stage`. Честно говоря, не знаю, где заканчивается этот путь, потому что я по нему не шёл. Проще определить переменную `GRADLE_TASK` со значением `build`:
**#3 reCAPTCHA**
При размещении приложения в новом домене не забудьте обновить капчу, переменные среды `GOOGLE_RECAPTCHA_KEY_SITE` и `GOOGLE_RECAPTCHA_KEY_SECRET`, а также обновить Site Key в подпроекте фронтенда.
Хранение токена JWT в Cookies
-----------------------------
Прежде всего, настоятельно рекомендую ознакомиться со статьей [Please Stop Using Local Storage](https://www.rdegges.com/2018/please-stop-using-local-storage/), особенно с разделом *Why Local Storage is Insecure and You Shouldn’t Use it to Store Sensitive Data*.
Давайте рассмотрим, как можно хранить токен JWT в более безопасном месте — куках в флагом `httpOnly`, где он будет недоступен для чтения/изменения с помощью JavaScript'а.
**#1** Удаление всей логики, относящейся к JWT из фронтенда:
Поскольку с новым способом хранения токен всё равно не доступен для JavaScript'а, можно смело удалить все упоминания о нём из нашего подпроекта.
А вот роль пользователя без привязки к каким-либо другим данных — не столь не столь важная информация, её можно по-прежнему хранить в Local Storage и определять, авторизован пользователь или нет, в зависимости от того, определена ли эта роль.
**store/index.js**
```
import Vue from 'vue';
import Vuex from 'vuex';
Vue.use(Vuex);
const state = {
role: localStorage.getItem('user-role') || '',
username: localStorage.getItem('user-name') || '',
authorities: localStorage.getItem('authorities') || '',
};
const getters = {
isAuthenticated: state => {
if (state.role != null && state.role != '') {
return true;
} else {
return false;
}
},
isAdmin: state => {
if (state.role === 'admin') {
return true;
} else {
return false;
}
},
getUsername: state => {
return state.username;
},
getAuthorities: state => {
return state.authorities;
}
};
const mutations = {
auth_login: (state, user) => {
localStorage.setItem('user-name', user.username);
localStorage.setItem('user-authorities', user.roles);
state.username = user.username;
state.authorities = user.roles;
var isUser = false;
var isAdmin = false;
for (var i = 0; i < user.roles.length; i++) {
if (user.roles[i].authority === 'ROLE_USER') {
isUser = true;
} else if (user.roles[i].authority === 'ROLE_ADMIN') {
isAdmin = true;
}
}
if (isUser) {
localStorage.setItem('user-role', 'user');
state.role = 'user';
}
if (isAdmin) {
localStorage.setItem('user-role', 'admin');
state.role = 'admin';
}
},
auth_logout: () => {
state.token = '';
state.role = '';
state.username = '';
state.authorities = [];
localStorage.removeItem('user-role');
localStorage.removeItem('user-name');
localStorage.removeItem('user-authorities');
}
};
const actions = {
login: (context, user) => {
context.commit('auth_login', user)
},
logout: (context) => {
context.commit('auth_logout');
}
};
export const store = new Vuex.Store({
state,
getters,
mutations,
actions
});
```
Будьте осторожны при рефакторинге `store/index.js`: если авторизация и деавторизация не будут работать корректно, в консоль будут назойливо сыпаться сообщения об ошибках.
**#2** Возвращение JWT как cookie в контроллере авторизации (не в теле ответа):
**AuthController.kt**
```
@Value("\${ksvg.app.authCookieName}")
lateinit var authCookieName: String
@Value("\${ksvg.app.isCookieSecure}")
var isCookieSecure: Boolean = true
@PostMapping("/signin")
fun authenticateUser(@Valid @RequestBody loginRequest: LoginUser, response: HttpServletResponse): ResponseEntity<*> {
val userCandidate: Optional = userRepository.findByUsername(loginRequest.username!!)
if (!captchaService.validateCaptcha(loginRequest.recaptchaToken!!)) {
return ResponseEntity(ResponseMessage("Validation failed (ReCaptcha v2)"),
HttpStatus.BAD\_REQUEST)
}
else if (userCandidate.isPresent) {
val user: User = userCandidate.get()
val authentication = authenticationManager.authenticate(
UsernamePasswordAuthenticationToken(loginRequest.username, loginRequest.password))
SecurityContextHolder.getContext().setAuthentication(authentication)
val jwt: String = jwtProvider.generateJwtToken(user.username!!)
val cookie: Cookie = Cookie(authCookieName, jwt)
cookie.maxAge = jwtProvider.jwtExpiration!!
cookie.secure = isCookieSecure
cookie.isHttpOnly = true
cookie.path = "/"
response.addCookie(cookie)
val authorities: List = user.roles!!.stream().map({ role -> SimpleGrantedAuthority(role.name)}).collect(Collectors.toList())
return ResponseEntity.ok(SuccessfulSigninResponse(user.username, authorities))
} else {
return ResponseEntity(ResponseMessage("User not found!"),
HttpStatus.BAD\_REQUEST)
}
}
```
Важно: обратите внимание, что я поместил параметры `authCookieName` и `isCookieSecure` в *application.properties* — отправка куков с флагом `secure` возможна только по https, что делает крайне затруднительным отладку на localhost. НО в продакшене, конечно, лучше использовать куки с этим флагом.
Также ответов контроллера теперь целесообразно использовать сущность без специального поля для JWT.
**#3** Обновление `JwtAuthTokenFilter`:
Раньше мы брали токен из заголовка запроса, теперь мы берём его из куки:
**JwtAuthTokenFilter.kt**
```
@Value("\${ksvg.app.authCookieName}")
lateinit var authCookieName: String
...
private fun getJwt(request: HttpServletRequest): String? {
for (cookie in request.cookies) {
if (cookie.name == authCookieName) {
return cookie.value
}
}
return null
}
```
**#4** Включение [CORS](https://ru.wikipedia.org/wiki/Cross-origin_resource_sharing)
Если в предыдущей моей статье ещё можно было незаметно пропустить этот вопрос, то сейчас было бы странно защищать JWT-токен, так и не включив CORS на стороне бэкенда.
Исправить это можно отредактировав `WebSecurityConfig.kt`:
**WebSecurityConfig.kt**
```
@Bean
fun corsConfigurationSource(): CorsConfigurationSource {
val configuration = CorsConfiguration()
configuration.allowedOrigins = Arrays.asList("http://localhost:8080", "http://localhost:8081", "https://kotlin-spring-vue-gradle-demo.herokuapp.com")
configuration.allowedHeaders = Arrays.asList("*")
configuration.allowedMethods = Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS")
configuration.allowCredentials = true
configuration.maxAge = 3600
val source = UrlBasedCorsConfigurationSource()
source.registerCorsConfiguration("/**", configuration)
return source
}
@Throws(Exception::class)
override fun configure(http: HttpSecurity) {
http
.cors().and()
.csrf().disable().authorizeRequests()
.antMatchers("/**").permitAll()
.anyRequest().authenticated()
.and()
.exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
http.addFilterBefore(authenticationJwtTokenFilter(), UsernamePasswordAuthenticationFilter::class.java)
http.headers().cacheControl().disable()
}
```
И теперь можно удалить все аннотации `@CrossOrigin` из контроллеров.
Важно: параметр *AllowCredentials* необходим для отправки запросов со стороны фронтенда. Подробнее об этом можно почитать [здесь](https://stackoverflow.com/questions/45004354/when-should-i-really-set-access-control-allow-credentials-to-true-in-my-resp).
**#5** Актуализация заголовков на стороне фронтенда:
**http-commons.js**
```
export const AXIOS = axios.create({
baseURL: `/api`,
headers: {
'Access-Control-Allow-Origin': ['http://localhost:8080', 'http://localhost:8081', 'https://kotlin-spring-vue-gradle-demo.herokuapp.com'],
'Access-Control-Allow-Methods': 'GET,POST,DELETE,PUT,OPTIONS',
'Access-Control-Allow-Headers': '*',
'Access-Control-Allow-Credentials': true
}
})
```
#### Проверка
Давайте попробуем авторизоваться в приложении, зайдя с хоста, не входящего в список разрешённых в `WebSecurityConfig.kt`. Для этого запустим бэкенд на порту `8080`, а фронтенд, например, на `8082` и попробуем авторизоваться:
**Результат**
Запрос авторизации отклонён политикой CORS.
Теперь давайте посмотрим, как вообще работаю куки с флагом `httpOnly`. Для этого зайдём, например, на сайт <https://kotlinlang.org> и выполним в консоли браузера:
```
document.cookie
```
**Результат**
В консоли появятся не-`httpOnly` куки, относящиеся к этому сайту, которые, как мы видим, доступны через JavaScript.
Теперь зайдём в наше приложение, авторизуемся (чтобы браузер сохранил куку с JWT) и повторим то же самое:
**Результат**
Примечание: такой способ хранения JWT-токена является более надёжным, чем с использованием Local Storage, но стоит понимать, что он не является панацеей.
Подтверждение регистрации по электронной почте
----------------------------------------------
Краткий алгоритм выполнения этой задачи таков:
1. Для всех новых пользователей атрибуту `isEnabled` в базе данных присваивается значение `false`
2. Из произвольных символов генерируется строковый токен, который будет служить ключом для подтверждения регистрации
3. Токен отправляется пользователю на почте как часть ссылки
4. Атрибут `isEnabled` принимает значение *true*, если пользователь переходит по ссылке в течение установленного периода времени
Теперь рассмотрим этот процесс более детально.
Нам понадобится таблица для хранения токен для подтверждения регистрации:
```
CREATE TABLE public.verification_token
(
id serial NOT NULL,
token character varying,
expiry_date timestamp without time zone,
user_id integer,
PRIMARY KEY (id)
);
ALTER TABLE public.verification_token
ADD CONSTRAINT verification_token_users_fk FOREIGN KEY (user_id)
REFERENCES public.users (id) MATCH SIMPLE
ON UPDATE CASCADE
ON DELETE CASCADE;
```
И, соотвественно, новая сущность для объектно-реляционного отображения…:
**VerificationToken.kt**
```
package com.kotlinspringvue.backend.jpa
import java.sql.*
import javax.persistence.*
import java.util.Calendar
@Entity
@Table(name = "verification_token")
data class VerificationToken(
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
val id: Long? = 0,
@Column(name = "token")
var token: String? = null,
@Column(name = "expiry_date")
val expiryDate: Date,
@OneToOne(targetEntity = User::class, fetch = FetchType.EAGER, cascade = [CascadeType.PERSIST])
@JoinColumn(nullable = false, name = "user_id")
val user: User
) {
constructor(token: String?, user: User) : this(0, token, calculateExpiryDate(1440), user)
}
private fun calculateExpiryDate(expiryTimeInMinutes: Int): Date {
val cal = Calendar.getInstance()
cal.time = Timestamp(cal.time.time)
cal.add(Calendar.MINUTE, expiryTimeInMinutes)
return Date(cal.time.time)
}
```
… и репозиторий:
**VerificationTokenRepository.kt**
```
package com.kotlinspringvue.backend.repository
import com.kotlinspringvue.backend.jpa.VerificationToken
import org.springframework.data.jpa.repository.JpaRepository
import java.util.*
interface VerificationTokenRepository : JpaRepository {
fun findByToken(token: String): Optional
}
```
Теперь нам нужно реализовать средства для управления токенами — создания, верификации и отправки по электронной почте. Для этого модифицируем `UserDetailsServiceImpl`, добавив методы для создания и верификации токена:
**UserDetailsServiceImpl.kt**
```
override fun createVerificationTokenForUser(token: String, user: User) {
tokenRepository.save(VerificationToken(token, user))
}
override fun validateVerificationToken(token: String): String {
val verificationToken: Optional = tokenRepository.findByToken(token)
if (verificationToken.isPresent) {
val user: User = verificationToken.get().user
val cal: Calendar = Calendar.getInstance()
if ((verificationToken.get().expiryDate.time - cal.time.time) <= 0) {
tokenRepository.delete(verificationToken.get())
return TOKEN\_EXPIRED
}
user.enabled = true
tokenRepository.delete(verificationToken.get())
userRepository.save(user)
return TOKEN\_VALID
} else {
return TOKEN\_INVALID
}
}
```
Теперь добавим метод для отправки письма с ссылкой для подтверждения в `EmailServiceImpl`:
**EmailServiceImpl.kt**
```
@Value("\${host.url}")
lateinit var hostUrl: String
@Autowired
lateinit var userDetailsService: UserDetailsServiceImpl
...
override fun sendRegistrationConfirmationEmail(user: User) {
val token = UUID.randomUUID().toString()
userDetailsService.createVerificationTokenForUser(token, user)
val link = "$hostUrl/?token=$token&confirmRegistration=true"
val msg = "Please, follow the link to complete your registration:
[$link](\"$link\")
"
user.email?.let{sendHtmlMessage(user.email!!, "KSVG APP: Registration Confirmation", msg)}
}
```
Примечание:
* Я бы рекомендовал хранить URL хоста в *application.properties*
* В нашей ссылке мы передаём два GET-параметра (`token` и `confirmRegistration`) на адрес, где развёрнуто приложение. Чуть позже я объясню, для чего.
Модифицируем контроллер регистрации следующим образом:
* Всем новым пользователям будем выставлять значение `false` для поля `isEnabled`
* После создания нового аккаунта будем отправлять электронное письмо для подтверждения регистрации
* Создадим отдельный контроллер для валидация токена
* Важно: при авторизации будем проверять, подтверждена ли учётная запись:
**AuthController.kt**
```
package com.kotlinspringvue.backend.controller
import com.kotlinspringvue.backend.email.EmailService
import javax.validation.Valid
import java.util.*
import java.util.stream.Collectors
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.security.authentication.AuthenticationManager
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.ui.Model
import com.kotlinspringvue.backend.model.LoginUser
import com.kotlinspringvue.backend.model.NewUser
import com.kotlinspringvue.backend.web.response.SuccessfulSigninResponse
import com.kotlinspringvue.backend.web.response.ResponseMessage
import com.kotlinspringvue.backend.jpa.User
import com.kotlinspringvue.backend.repository.UserRepository
import com.kotlinspringvue.backend.repository.RoleRepository
import com.kotlinspringvue.backend.jwt.JwtProvider
import com.kotlinspringvue.backend.service.ReCaptchaService
import com.kotlinspringvue.backend.service.UserDetailsService
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.web.bind.annotation.*
import org.springframework.web.context.request.WebRequest
import java.io.UnsupportedEncodingException
import javax.servlet.http.Cookie
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
import com.kotlinspringvue.backend.service.UserDetailsServiceImpl.Companion.TOKEN_VALID
import com.kotlinspringvue.backend.service.UserDetailsServiceImpl.Companion.TOKEN_INVALID
import com.kotlinspringvue.backend.service.UserDetailsServiceImpl.Companion.TOKEN_EXPIRED
@RestController
@RequestMapping("/api/auth")
class AuthController() {
@Value("\${ksvg.app.authCookieName}")
lateinit var authCookieName: String
@Value("\${ksvg.app.isCookieSecure}")
var isCookieSecure: Boolean = true
@Autowired
lateinit var authenticationManager: AuthenticationManager
@Autowired
lateinit var userRepository: UserRepository
@Autowired
lateinit var roleRepository: RoleRepository
@Autowired
lateinit var encoder: PasswordEncoder
@Autowired
lateinit var jwtProvider: JwtProvider
@Autowired
lateinit var captchaService: ReCaptchaService
@Autowired
lateinit var userService: UserDetailsService
@Autowired
lateinit var emailService: EmailService
@PostMapping("/signin")
fun authenticateUser(@Valid @RequestBody loginRequest: LoginUser, response: HttpServletResponse): ResponseEntity<*> {
val userCandidate: Optional = userRepository.findByUsername(loginRequest.username!!)
if (!captchaService.validateCaptcha(loginRequest.recaptchaToken!!)) {
return ResponseEntity(ResponseMessage("Validation failed (ReCaptcha v2)"),
HttpStatus.BAD\_REQUEST)
}
else if (userCandidate.isPresent) {
val user: User = userCandidate.get()
if (!user.enabled) {
return ResponseEntity(ResponseMessage("Account is not verified yet! Please, follow the link in the confirmation email."),
HttpStatus.UNAUTHORIZED)
}
val authentication = authenticationManager.authenticate(
UsernamePasswordAuthenticationToken(loginRequest.username, loginRequest.password))
SecurityContextHolder.getContext().setAuthentication(authentication)
val jwt: String = jwtProvider.generateJwtToken(user.username!!)
val cookie: Cookie = Cookie(authCookieName, jwt)
cookie.maxAge = jwtProvider.jwtExpiration!!
cookie.secure = isCookieSecure
cookie.isHttpOnly = true
cookie.path = "/"
response.addCookie(cookie)
val authorities: List = user.roles!!.stream().map({ role -> SimpleGrantedAuthority(role.name)}).collect(Collectors.toList())
return ResponseEntity.ok(SuccessfulSigninResponse(user.username, authorities))
} else {
return ResponseEntity(ResponseMessage("User not found!"),
HttpStatus.BAD\_REQUEST)
}
}
@PostMapping("/signup")
fun registerUser(@Valid @RequestBody newUser: NewUser): ResponseEntity<\*> {
val userCandidate: Optional = userRepository.findByUsername(newUser.username!!)
if (!captchaService.validateCaptcha(newUser.recaptchaToken!!)) {
return ResponseEntity(ResponseMessage("Validation failed (ReCaptcha v2)"),
HttpStatus.BAD\_REQUEST)
} else if (!userCandidate.isPresent) {
if (usernameExists(newUser.username!!)) {
return ResponseEntity(ResponseMessage("Username is already taken!"),
HttpStatus.BAD\_REQUEST)
} else if (emailExists(newUser.email!!)) {
return ResponseEntity(ResponseMessage("Email is already in use!"),
HttpStatus.BAD\_REQUEST)
}
try {
// Creating user's account
val user = User(
0,
newUser.username!!,
newUser.firstName!!,
newUser.lastName!!,
newUser.email!!,
encoder.encode(newUser.password),
false
)
user.roles = Arrays.asList(roleRepository.findByName("ROLE\_USER"))
val registeredUser = userRepository.save(user)
emailService.sendRegistrationConfirmationEmail(registeredUser)
} catch (e: Exception) {
return ResponseEntity(ResponseMessage("Server error. Please, contact site owner"),
HttpStatus.SERVICE\_UNAVAILABLE)
}
return ResponseEntity(ResponseMessage("Please, follow the link in the confirmation email to complete the registration."), HttpStatus.OK)
} else {
return ResponseEntity(ResponseMessage("User already exists!"),
HttpStatus.BAD\_REQUEST)
}
}
@PostMapping("/registrationConfirm")
@CrossOrigin(origins = ["\*"])
@Throws(UnsupportedEncodingException::class)
fun confirmRegistration(request: HttpServletRequest, model: Model, @RequestParam("token") token: String): ResponseEntity<\*> {
when(userService.validateVerificationToken(token)) {
TOKEN\_VALID -> return ResponseEntity.ok(ResponseMessage("Registration confirmed"))
TOKEN\_INVALID -> return ResponseEntity(ResponseMessage("Token is invalid!"), HttpStatus.BAD\_REQUEST)
TOKEN\_EXPIRED -> return ResponseEntity(ResponseMessage("Token is invalid!"), HttpStatus.UNAUTHORIZED)
}
return ResponseEntity(ResponseMessage("Server error. Please, contact site owner"), HttpStatus.SERVICE\_UNAVAILABLE)
}
@PostMapping("/logout")
fun logout(response: HttpServletResponse): ResponseEntity<\*> {
val cookie: Cookie = Cookie(authCookieName, null)
cookie.maxAge = 0
cookie.secure = isCookieSecure
cookie.isHttpOnly = true
cookie.path = "/"
response.addCookie(cookie)
return ResponseEntity.ok(ResponseMessage("Successfully logged"))
}
private fun emailExists(email: String): Boolean {
return userRepository.findByUsername(email).isPresent
}
private fun usernameExists(username: String): Boolean {
return userRepository.findByUsername(username).isPresent
}
}
```
Теперь поработаем на фронтендом:
**#1** Создадим компонент `RegistrationConfirmPage.vue`
**#2** Добавим новый путь в `router.js` с параметром `:token`:
```
{
path: '/registration-confirm/:token',
name: 'RegistrationConfirmPage',
component: RegistrationConfirmPage
}
```
**#3** Обновим `SignUp.vue` — после успешной отправки данных с форм будем сообщать им, что для завершения регистрации необходимо перейти по ссылке в письме.
**#4** Важно: увы, мы не можем дать фиксированную ссылку на отдельный компонент, который выполнял бы валидацию токена и сообщал бы об успехе или неуспехе. Ссылки с прописанными через слэш путями всё равно приведут нас на исходную страницу приложения. Но мы можем сообщить нашему приложению о необходимости подтвердить регистрацию с помощью передаваемого GET-параметра `confirmRegistration`:
```
methods: {
confirmRegistration() {
if (this.$route.query.confirmRegistration === 'true' && this.$route.query.token != null) {
this.$router.push({name: 'RegistrationConfirmPage', params: { token: this.$route.query.token}});
}
},
...
mounted() {
this.confirmRegistration();
}
```
**#5** Создадим компонент, выполняющий валидацию токена и сообщающий о результате валидации:
**RegistrationConfirmPage.vue**
```
Account is successfully verified!
Login
Verification failed:
{{ errorMessage }}
import {AXIOS} from './http-common'
export default {
name: 'RegistrationConfirmPage',
data() {
return {
isSuccess: false,
isError: false,
errorMessage: ''
}
},
methods: {
executeVerification() {
AXIOS.post(`/auth/registrationConfirm`, null, {params: { 'token': this.$route.params.token}})
.then(response => {
this.isSuccess = true;
console.log(response);
}, error => {
this.isError = true;
this.errorMessage = error.response.data.message;
})
.catch(e => {
console.log(e);
this.errorMessage = 'Server error. Please, report this error website owners';
})
}
},
mounted() {
this.executeVerification();
}
}
.confirm-form {
margin-left: 38%;
margin-top: 50px;
}
.success {
color: green;
}
.fail {
color: red;
}
```
**Результат**
### Вместо заключения
В завершение этого материала хотелось бы сделать небольшое лирическое отступление и сказать, что сама концепция приложения, рассмотренного в этой и предыдущей статье, не была нова уже на момент начала написания. Задачу быстрого создания full stack приложений на Spring Boot с использованием современных JavaScript-фреймворков Angular/React/Vue.js изящно решает [Hipster](https://www.jhipster.tech).
Однако, идеи, описанные в данной статье вполне можно реализовать даже используя JHipster, так что, надеюсь, читатели, дошедшие до этого места, найдут этот материал полезным хотя бы в качестве пищи для размышлений.
Полезные ссылки
---------------
* [GitHub репозиторий (до шага «Миграция на Gradle»)](https://github.com/DrLeprechaun/kotlin-spring-vue)
* [GitHub репозиторий (после шага «Миграция на Gradle»)](https://github.com/DrLeprechaun/kotlin-spring-vue-gradle)
* [Приложение (до шага «Миграция на Gradle»)](https://kotlin-spring-vue-demo.herokuapp.com)
* [Приложение (после шага «Миграция на Gradle»)](https://kotlin-spring-vue-gradle-demo.herokuapp.com)
* [Тот же материал, написанный мной же, только на английском языке](https://vaadimblog.blogspot.com/p/kotlin-spring-boot-vuejs.html)
* [How to use Google reCaptcha with Vuejs](https://itnext.io/how-to-use-google-recaptcha-with-vuejs-7756244400da)
* [Google ReCAPTCHA component for Vue.js](https://vuejsexamples.com/google-recaptcha-component-for-vue-js/)
* [Guide to Spring Email](https://www.baeldung.com/spring-email)
* [Send Email using Spring Boot and Thymeleaf](https://medium.com/@raviswapna1/send-email-using-spring-boot-and-thymeleaf-b0f62786bd8e)
* [Migrating Builds From Apache Maven](https://docs.gradle.org/5.6.3/userguide/migrating_from_maven.html)
* [Migrating build logic from Groovy to Kotlin](https://guides.gradle.org/migrating-build-logic-from-groovy-to-kotlin/)
* [Integrate Angular in Spring Boot Using Gradle](https://ordina-jworks.github.io/architecture/2018/10/12/spring-boot-angular-gradle.html)
* [Getting Started with Gradle on Heroku](https://devcenter.heroku.com/articles/getting-started-with-gradle-on-heroku)
* [Deploying Gradle Apps on Heroku](https://devcenter.heroku.com/articles/deploying-gradle-apps-on-heroku)
* [Deploying multi-project builds](https://devcenter.heroku.com/articles/deploying-gradle-apps-on-heroku#deploying-multi-project-builds)
* [Please Stop Using Local Storage](https://www.rdegges.com/2018/please-stop-using-local-storage/)
* [Authentication in SPA (ReactJS and VueJS) the right way](https://medium.com/@jcbaey/authentication-in-spa-reactjs-and-vuejs-the-right-way-e4a9ac5cd9a3)
* [Stateless Authentication using JWT to secure a Spring Boot REST API](https://www.ninjadevcorner.com/2018/09/stateless-authentication-jwt-secure-spring-boot-rest-api.html)
* [Registration – Activate a New Account by Email](https://www.baeldung.com/registration-verify-user-by-email) | https://habr.com/ru/post/482222/ | null | ru | null |
# Кроссплатформенный IoT: Операции с устройствами
Привет, Хабр! IoT Hub Explorer — это кроссплатформенный инструмент на базе node.js по управлению устройствами в использующемся IoT Hub, который может работать в среде Windows, Mac или Linux. Сегодня поговорим о нем в рамках диагностики и усовершенствования IoT Hub Azure. Заглядывайте под кат за подробностями!
> Цикл статей «Кроссплатформенный IoT»
> ------------------------------------
>
>
>
> 1. [Кроссплатформенный IoT: Использование Azure CLI и Azure IoT Hub](https://habrahabr.ru/company/microsoft/blog/333530/)
>
> 2. [Кроссплатформенный IoT: Операции с устройствами](https://habrahabr.ru/company/microsoft/blog/343802/)
>
> 3. [Кроссплатформенный IoT: Выявление неисправностей](https://habrahabr.ru/company/microsoft/blog/343794/)
>
> 3. Loading…
[IoT Hub Explorer](https://github.com/Azure/iothub-explorer) упрощает выполнение таких операций в IoT Hub, как: создание устройства, отправка сообщений на существующее устройство и т. д. При тестировании разработки или даже демонстрации возможностей Интернета вещей Azure эта функция оказывается особенно полезной. Теоретически, ее можно использовать и для диагностики рабочей среды. Однако для выполнения этих сценариев нужны подходящие данные телеметрии, а также канал операционного управления. Одна из моих любимых функций инструмента — проведение мониторинга сообщений об устройствах IoT Hub, получение данные о событиях и статистики по операциям устройств центра. Мы будем использовать этот инструмент для создания устройства и просмотра сообщений IoT Hub. IoT Hub Explorer доступен в GitHub [здесь](https://github.com/Azure/iothub-explorer).
Следует учесть, что Azure IoT CLI, которому была посвящена предыдущая публикация, также поддерживает управление устройствами и его функциональные возможности будут частично совпадать с возможностями IoT Hub Explorer. Если такое произойдет, Azure CLI будет считаться главным инструментом для работы со всеми операциями IoT Hub.
Давайте воспользуемся обозревателем IoT Hub для создания и мониторинга устройства. Прежде чем сделать это, его необходимо установить. Так как это пакет node, его можно установить с помощью npm.
```
npm install -g iothub-explorer
```
Так как IoT Hub Explorer является отдельной программой, нам необходимо сначала выполнить вход, используя для этого строку подключения нашего IoT Hub. Откройте терминал bash и введите следующее:
```
iothub-explorer login "HostName=yourhub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=yourkey"
```
Если у вас под рукой нет строки подключения, вы можете ввести команду `az iot hub show-connection-string -g youresourcegroup`, описанную в предыдущем разделе, и получить строку подключения вашего IoT Hub. Команда авторизации должна открыть временную сессию с закрепленной политикой права доступа к центру IoT. По умолчанию срок жизни данной сессии составляет 1 час.
```
Session started, expires on Wed Mar 15 2017 19:59:05 GMT-0500 (CDT)
Session file: /Users/niksac/Library/Application Support/iothub-explorer/config
```
Учтите, что приведенная выше команда использует строку подключения для политики iothubowner, которая предоставляет полное управление вашим центром IoT.
Создание нового устройства
--------------------------
Чтобы создать новое устройство с помощью IoT Hub Explorer введите следующую команду:
```
iothub-explorer create -a
```
Символ -a служит для автоматического генерирования Id и учетных данных устройства при его создании. Вы также можете указать самостоятельно Id устройства или добавить JSON-файл устройства, чтобы индивидуально настроить процесс его создания. Есть и другие способы указать учетные данные, например, симметричный ключ и сертификаты X.509. Мы опубликуем отдельную статью о безопасности IoT Hub, в которой рассмотрим эти способы. На данный момент используем стандартные учетные данные, сгенерированные IoT Hub.
Если все прошло успешно, вы должны увидеть ответ следующего содержания:
```
deviceId: youdeviceId
generationId: 63624558311459675
connectionState: Disconnected
status: enabled
statusReason: null
connectionStateUpdatedTime: 0001-01-01T00:00:00
statusUpdatedTime: 0001-01-01T00:00:00
lastActivityTime: 0001-01-01T00:00:00
cloudToDeviceMessageCount: 0
authentication:
symmetricKey:
primaryKey: symmetrickey1=
secondaryKey: symmetrickey2=
x509Thumprint:
primaryThumbprint: null
secondaryThumbprint: null
connectionString: HostName=youriothub.azure-devices.net;DeviceId=youdeviceId;SharedAccessKey=symmetrickey=
```
Здесь есть несколько важных вещей, и одна из них, очевидно, это `connectionString`. Она предоставляет уникальную строку подключения устройства и позволяет связываться с ним. Привилегии для строки подключения устройства основаны на политике, определенной для устройства в центре IoT, права ограничиваются только функцией `DeviceConnect`. Доступ, основанный на политике, защищает наши конечные точки и ограничивает область использования конкретным устройством. Подробнее о безопасности устройства IoT Hub можно узнать здесь. Также обратите внимание, что устройство активировано, а статус — отключено. Это означает, что устройство было успешно зарегистрировано в центре IoT, но у него нет активных подключений.
Отправка и получение сообщений
------------------------------
Давайте инициируем подключение, отправив запрос на прием устройства. В обозревателе IoT Hub доступно несколько способов отправки и получения сообщений. Один из эффективных вариантов — команда `simulate-device`. Команда `simulate-device` позволяет инструменту выполнять роль имитатора команды устройству и имитатора приема устройством. Это может применяться для отправки определенных пользователем телеметрических сообщений или команд от имени устройства. Удобство данных функциональных возможностей проявляется при тестировании интегрированности разработок на вашем устройстве, так как это позволит сократить объем кода. Вы можете одновременно создавать сообщения и отслеживать поток отправки / получения. Команда также предоставляет такие возможности, как `send-interval, send-count` и `receive-count`, позволяющие конфигурировать симуляцию. Стоит учесть, что это не инструмент для тестирования нагрузки или проникновения, с его помощью можно провести начальные тесты, предваряющие более углубленные испытания. Давайте отправим набор сообщений на созданное нами устройство (из части 1) и затем примем сообщение с командой.
Отправка сообщения
------------------
Следующая команда отправляет 5 сообщений каждые 2 минуты на устройство с определенным Id.
```
niksac$ iothub-explorer simulate-device --send "Hello from IoT Hub Explorer" --device-connection-string "HostName=youriothubname.azure-devices.net;DeviceId=D1234;SharedAccessKey==" --send-count 5 --send-interval 2000
```
Конечное сообщение будет выглядеть следующим образом:
```
Message #0 sent successfully
Message #1 sent successfully
Message #2 sent successfully
Message #3 sent successfully
Message #4 sent successfully
Device simulation finished.
```
Мониторинг сообщений
--------------------
Другой полезной функцией IoT Hub Explorer является возможность производить мониторинг события вашего устройства или IoT Hub в целом. Это очень удобно, если вы хотите провести диагностику экземпляра вашего IoT Hub. Например, вы хотите проверить корректность доставки сообщений в IoT Hub. Вы можете использовать команду monitor-events для регистрирования всех событий, связанных с устройством, в терминале; вы также можете применить команду monitor-ops для отслеживания конечной точки операций в центре IoT.
Для мониторинга событий введите следующее:
```
iothub-explorer monitor-events --login "HostName=youriothub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=="
```
В результате создается прослушиватель, фиксирующий активность во всем центре IoT. Как отмечалось ранее, вы можете указать строку подключения устройства для мониторинга конкретного устройства.
Теперь при отправке сообщения или команды на любое устройство вашего IoT Hub конечный результат будет отображаться в терминале. Например, если вы открыли прослушиватель monitor-event в окне терминала и затем повторно выполнили команду `simulate-device --send`, следующий результат должен отобразиться в терминале:
```
Monitoring events from all devices...
==== From: D1234 ====
Hello from IoT Hub Explorer
====================
==== From: D1234 ====
Hello from IoT Hub Explorer
====================
==== From: D1234 ====
Hello from IoT Hub Explorer
====================
==== From: D1234 ====
Hello from IoT Hub Explorer
====================
==== From: D1234 ====
Hello from IoT Hub Explorer
====================
```
В IoT Hub Explorer доступно множество других команд, таких как: импорт / экспорт устройств, повторное создание прав доступа в SAS, команды по управлению устройством. Вам необходимо в ознакомительных целях попробовать применить различные опции и команды IoT Hub Explorer; это поможет вам избежать прописывания кода для стандартных операций. | https://habr.com/ru/post/343802/ | null | ru | null |
# JavaScript ES6: оператор расширения
JavaScript постоянно развивается, в нём появляются различные новшества и улучшения. Одно из таких новшеств, появившееся в ES6 — оператор расширения. Он выглядит как троеточие (`...`). Этот оператор позволяет разделять итерируемые объекты там, где ожидается либо полное отсутствие, либо наличие одного или нескольких аргументов. Сухие определения обычно бывает непросто понять без практических примеров. Поэтому рассмотрим несколько вариантов использования оператора расширения, которые помогут вникнуть в его сущность.
[](https://habrahabr.ru/company/ruvds/blog/348612/)
Пример №1: вставка массивов в другие массивы
--------------------------------------------
Взгляните на этот код. Тут оператор расширения не используется:
```
var mid = [3, 4];
var arr = [1, 2, mid, 5, 6];
console.log(arr);
```
Выше мы создали массив `mid`. Затем создан второй массив, `arr`, который содержит массив `mid`. В конце программы массив `arr` выводится в консоль. Как вы думаете, каким станет этот массив после добавления в него массива `mid`? Взглянем на то, что выведет программа:
```
[1, 2, [3, 4], 5, 6]
```
Вы думали, что так и будет?
Вставляя массив `mid` в массив `arr`, мы получили в итоге один массив, вложенный в другой. Если это именно то, что было нужно, то придираться тут не к чему. Однако, что если целью написания вышеприведённого кода было получение массива чисел от 1 до 6? Для того чтобы достичь этой цели, можно использовать оператор расширения. Вспомните о том, что этот оператор позволяет разделять массивы на отдельные элементы.
Рассмотрим следующий пример. Всё тут, за исключением одного места, точно такое же, как и в предыдущем фрагменте кода. Разница заключается в том, что теперь для того, чтобы вставить содержимое массива `mid` в массив `arr`, применяется оператор расширения:
```
var mid = [3, 4];
var arr = [1, 2, ...mid, 5, 6];
console.log(arr);
```
Если этот код выполнить, то в результате будет выведено следующее:
```
[1, 2, 3, 4, 5, 6]
```
Вспомните описание оператора расширения, приведённое в самом начале материала. Только что вы увидели его в действии. Как можно заметить, когда мы создаём массив `arr` и используем оператор расширения, применяя его к массиву `mid`, то, вместо вставки в один массив другого массива, как объекта, этот другой массив «разбивается на части». Разделение вставляемого массива в нашем случае означает, что все элементы этого массива, поодиночке, будут добавлены в массив `arr`. В результате, вместо конструкции из вложенных массивов, получился один массив, содержащий числа от 1 до 6.
Пример №2: математические вычисления
------------------------------------
В JavaScript есть встроенный объект `Math`, который позволяет выполнять математические вычисления. В данном примере нас интересует метод `Math.max()`. Если вы с этим методом не знакомы, сообщаем, что он возвращает самое большое из переданных ему чисел, причём допустимо использовать его как без аргументов, так и с одним или несколькими аргументами. Вот несколько примеров:
```
Math.max();
// -Infinity
Math.max(1, 2, 3);
// 3
Math.max(100, 3, 4);
// 100
```
Как видите, если требуется найти максимальное значение нескольких чисел, `Math.max()` нужно несколько параметров. К сожалению, если надо найти максимальный элемент числового массива, сам массив методу `Math.max()` передать нельзя. До появления в JS оператора расширения самым простым способом поиска максимального элемента в массиве с помощью `Math.max()` было использование метода `apply()`:
```
var arr = [2, 4, 8, 6, 0];
function max(arr) {
return Math.max.apply(null, arr);
}
console.log(max(arr));
```
Выше представлена работающая конструкция, но выглядит всё это не очень-то приятно.
А вот как то же самое делается с помощью оператора расширения:
```
var arr = [2, 4, 8, 6, 0];
var max = Math.max(...arr);
console.log(max);
```
Вместо того, чтобы создавать функцию и использовать метод `apply()` для возвращения результата работы метода `Math.max()`, тут нужно лишь две строки кода. Оператор расширения «вытаскивает» из массива все его элементы и они поступают на вход метода `Math.max()`.
Пример №3: копирование массивов
-------------------------------
В JS нельзя скопировать массив, просто приравняв новую переменную той, которая уже содержит существующий массив. Рассмотрим пример:
```
var arr = ['a', 'b', 'c'];
var arr2 = arr;
console.log(arr2);
```
Если его выполнить, можно увидеть следующее:
```
['a', 'b', 'c']
```
На первый взгляд всё работает как надо, может показаться, что мы скопировали значения массива из переменной `arr` в переменную `arr2`. Однако на самом деле произошло совсем другое. В JavaScript, в операциях присваивания объектов переменным (а массивы — это тоже объекты), оперируют ссылками на них, а не их значениями. Это означает, что в `arr2` была записана та же ссылка, которая хранилась в `arr`. Другими словами, всё, что мы сделаем после этого с `arr2`, повлияет и на `arr` (и наоборот). Взгляните на это:
```
var arr = ['a', 'b', 'c'];
var arr2 = arr;
arr2.push('d');
console.log(arr);
```
Тут мы поместили новый элемент, строку `d`, в конец массива `arr2`. Однако, выведя в консоль `arr`, можно увидеть, что массив, на который ссылается эта переменная, также изменился:
```
['a', 'b', 'c', 'd']
```
Надо заметить, что ничего страшного тут не происходит. Перед нами — стандартное поведение JS. А для того, чтобы действительно создать копию массива, можно воспользоваться оператором расширения. Вот пример использования этого оператора для копирования массивов. Код выглядит практически так же, как и в вышеприведённом примере. Однако здесь используется оператор расширения, применённый к исходному массиву, а вся эта конструкция помещена в квадратные скобки:
```
var arr = ['a', 'b', 'c'];
var arr2 = [...arr];
console.log(arr2);
```
Выполнив этот код, можно увидеть, что выводит он то, чего мы от него и ожидаем:
```
['a', 'b', 'c']
```
В этом примере массив `arr` «разворачивается», в нашем распоряжении оказываются его отдельные элементы, которые попадают в новый массив, ссылка на который записывается в `arr2`. Теперь можно делать с `arr2` что угодно и это не повлияет на `arr`:
```
var arr = ['a', 'b', 'c'];
var arr2 = [...arr];
arr2.push('d');
console.log(arr);
```
Опять же, причина, по которой это всё работает, заключается в том, что оператор расширения «вытаскивает» значения элементов массива `arr` и они попадают в новый массив `arr2`. Таким образом, мы записываем в `arr2` ссылку на новый массив, содержащий элементы из массива `arr`, а не ссылку на тот массив, на который ссылается переменная `arr`. Это и отличает данный пример от предыдущего.
Дополнительный пример: преобразование строки в массив
-----------------------------------------------------
Напоследок — вот один интересный пример использования оператора расширения для преобразования строк в массивы. Здесь достаточно применить этот оператор к нужной строке, поместив всю эту конструкцию в пару квадратных скобок:
```
var str = "hello";
var chars = [...str];
console.log(chars);
```
Итоги
-----
Сегодня мы рассмотрели особенности работы с оператором расширения. Это — одна из новых возможностей JavaScript ES6, полезная мелочь, которая вполне способна улучшить читаемость кода и немного сократить его размер.
**Уважаемые читатели!** Пользуетесь ли вы оператором расширения в JavaScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/348612/ | null | ru | null |
# Программирование необычных шахмат
Написание своего шахматного движка - обширная тема, про которую пишут целые книги.
Однако очень многие шахматные программы работают со "стандартными" правилами шахмат и не могут работать при других правилах, хотя существуют [сотни вариаций](https://en.wikipedia.org/wiki/List_of_chess_variants) шахмат.
В этой заметке я покажу, каким образом можно написать достаточно быстрый и гибкий шахматный движок на **С++**, в котором можно задавать произвольный размер доски, расположение фигур, и создавать новые типы шахматных фигур.
Я запрограммировал **15** шахматных вариаций - для каждой опишу неожиданные ходы и результаты партий компьютера друг с другом.
Другие шахматные движки
-----------------------
Прежде чем сделать что-то свое, надо понять, как работают другие шахматные движки.
Есть Вики, посвященная программированию шахмат - [https://www.chessprogramming.org/](https://www.chessprogramming.org/Main_Page). В ней описаны основные концепции - представление доски, поиск, оценка позиции, базы дебютов и эндшпилей.
На Хабре по теме можно почитать эту отличную статью - <https://habr.com/ru/post/329528/>, там также покрыты важные темы.
Каждую концепцию в движке можно обсудить по порядку. Для реализации я использовал язык программирования **C++**.
Представление доски (часть 1)
-----------------------------
Первое, что нужно обдумать - каким образом мы будем представлять [доску](https://www.chessprogramming.org/Board_Representation) (т.е. позицию в шахматной игре)?
"Доска" это объект, который должен закодировать в себе такую информацию:
* Местоположение фигур
* "Память" фигур: для пешек - можем ли походить на 2 шага вперед, может ли пешка быть взята на проходе; для короля - право на рокировку, и т.д.
* Кто сейчас ходит: белые или черные (но это не обязательно, в моем движке "доска" про это не знает)
Так как в процессе поиска лучшего хода перебирается сумасшедшее количество досок, нужно сразу сделать их так, чтобы они как можно быстрее работали.
Не будем тратить время на очевидно неоптимальные варианты (например, хранение фигур в виде списка `std::list`).
Я выбрал путь [bitboard](https://www.chessprogramming.org/Bitboards) - это когда каждая клетка доски представлено одним числом. Для стандартной доски 8x8 это будет массив из 64 чисел. Таким образом, вся доска занимает цельный участок в памяти на стеке, что довольно важно для быстродействия движка.
В статье на Хабре (на которую ссылался в прошлом разделе) показано, что в стандартных шахматах хватает 14 бит на клетку (значит, тип числа может быть short или int). У каждого бита есть свое значение, в случае той статьи это **AHIIIIEWB0MFFF**, где **F** - тип фигуры, **A** - была ли длинная рокировка, и так далее. Это представление жестко привязано к существующим шахматным правилам и для шахмат с другими правилами не годится (конечно, такой задачи и не стояло, это просто констатация факта).
Bit storage
-----------
Так как каждая клетка на доске будет закодирована в одном числе, мы должны уметь удобно управлять битами в этом числе.
Для этого можно сделать "битовый контейнер".
В моей реализации тип для "битового контейнера" должен быть целочисленным: [concept TPossibleStorageType](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/bit_storage/bit_storage.h#L7-L9).
"Битовый контейнер" работает поверх одного числа: [class TBitStorage](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/bit_storage/bit_storage.h#L51-L69).
Как видим, у "контейнера" можно запросить хэндлер над группой последовательных битов (`GetView()`), и через него читать/записывать в биты значения без ручной возни с битовыми сдвигами: [class TBitView](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/bit_storage/bit_storage.h#L11-L49).
В [юнит-тестах](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/bit_storage/bit_storage_ut.cc) к "контейнеру" можно посмотреть, как происходит работа с ним.
Представление фигуры
--------------------
В моей реализации для bitboard используются 32-битные целые числа: [class TPiece](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/piece/piece.h#L10-L13).
Этот объем предназначен для хранения данных. Каждый под-класс класса `TPiece` будет определять сам, какие данные он хочет хранить: для короля это возможность рокировки, для пешки это возможность походить на 2 клетки вперед, и так далее.
Как выглядит определение фигуры, можно посмотреть на примере пешки `class TPawnPiece`:
* [Константы](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/vanilla_pieces/pawn_piece.h#L9-L14): id фигуры, стоимость фигуры, символы для вывода в консоль, изображения.
* ["Память" фигуры](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/vanilla_pieces/pawn_piece.h#L16-L32): у пешки есть 4 состояния (т.е. для их записи достаточно 2 битов), на основании которых проверяется возможность взятия на проходе и хода на 2 клетки вперед. Вообще "память" это редкое свойство, в подавляющем большинстве фигуры (в том числе из нестандартных шахмат) всегда двигаются одинаково.
* [Генерация ходов](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/vanilla_pieces/pawn_piece.h#L34-L35): об этом будет свой раздел ниже.
* [Регистрация класса фигуры](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/vanilla_pieces/pawn_piece.h#L38): техническая вещь, чтобы по piece id можно было получить данные класса.
Хоть мы и используем всего лишь одно 32-битное число, понятно что нет такой фигуры, которая действительно сможет утилизировать такой объем данных. То есть старшие биты числа всегда будут неиспользуемыми.
Особенность таких "битовых контейнеров" в том, что их можно "упаковать" внутрь других битовых контейнеров.
Например, чтобы использовать более оптимальный аналог `std::optional`, можно завести другой 32-битный битовый контейнер, где нулевым битом будет флаг "пустоты", а начиная с первого бита будет исходный битовый контейнер. Посмотрите как сделан [class TPieceOrEmpty](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/piece/piece_or_empty.h#L7-L31).
Представление доски (часть 2)
-----------------------------
Каждая клетка доски, как уже упоминалось, должна быть представлена в виде 32-битного числа.
Для этого создан битовый контейнер [class TBoardPiece](https://github.com/Izaron/FairyChess/blob/6b7a4322ab7318c729c8534396d20a3ed42a4f89/src/piece/board_piece.h#L17-L59), его состав:
* 1 бит - цвет фигуры (если есть).
* 10 битов - id фигуры (если клетка пустая, то эти биты равняются 0).
* остальные биты - битовый контейнер фигуры (то есть какой-нибудь подкласс `TPiece`).
Сама доска представляется так:
```
using TBoardPiecesContainer = std::array;
```
То есть это массив из  объектов `TBoardPiece`.
Для объекта доски можно сделать удобные методы для обновления клеток: [class TBoard](https://github.com/Izaron/FairyChess/blob/74f09552c95ba78944a595dfabfe0054611ff9bc/src/board/board.h#L76-L83).
Для позиции есть своя структура:
```
struct TBoardPosition {
int Column;
int Row;
};
```
Дамп доски в поток вывода
-------------------------
Желательно писать тестируемый код. На данный момент в программе 77 юнит-тестов. Так как проверять позицию на доске через список фигур очень неудобно, я это делаю через [дамп доски в поток вывода](https://github.com/Izaron/FairyChess/blob/main/src/pretty_printer/pretty_printer.cc) (в тестах это `std::stringstream`). Стандартная доска дампится в такую строку (в моем редакторе кода зазоров между строк нет):
```
╔════════╗
║♜♞♝♛♚♝♞♜║
║♟︎♟︎♟︎♟︎♟︎♟︎♟︎♟︎║
║ ║
║ ║
║ ║
║ ║
║♙♙♙♙♙♙♙♙║
║♖♘♗♕♔♗♘♖║
╚════════╝
```
Как это выглядит в тестах в моем редакторе кодаТаким методом можно достаточно просто тестировать всё, что связано с разными позициями (расстановку фигур, генерацию ходов, выбор лучшего хода, ...). Также дамп можно писать в консоль во время игры компьютера с самим собой.
Основы генерации ходов
----------------------
В первую очередь нужно понять - что такое "ход", что меняется после его свершения? Один "ход" это несколько "обновлений". Одно "обновление" заменяет в какой-то клетке одну фигуру на другую. Как обычно, сразу сделаем достаточно оптимизированный вариант - держим все "обновления" на стеке (а не в `std::vector`/`std::list`):
```
struct TBoardUpdate {
TBoardPosition Position;
TBoardPiece NewBoardPiece;
};
struct TMove {
std::array Updates;
std::size\_t UpdatesCount = 0;
};
```
Тут мы рассчитываем, что за один ход не будет больше 10 обновлений.
В генерации ходов можно столкнуться с проблемой - у белых и у черных фигур разная "точка зрения": у белых пешка идет "вперед", а у черных она идет как бы "назад". Чтобы не дублировать код для двух цветов, надо создать [class TOrientedBoardWrapper](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/board/board.h#L111-L132) - обертку над объектом `TBoard`, которая проксирует метод `GetBoardPiece` с флагом инвертированности. Таким образом, генерацию ходов надо писать один раз, с "точки зрения белых".
Ходы (`struct TMove`) нужно хранить в каком-нибудь контейнере. Немного забегая вперед - иногда движку нужно знать не все ходы, а только их количество. Поэтому "контейнер" выглядит в виде интерфейса так:
```
struct IMoveContainer {
~IMoveContainer() = default;
virtual void Add(const TMove& move) = 0;
virtual void InverseMoves(const TBoard& board) = 0;
};
```
Метод `Add` добавляет ходы, метод `InverseMoves` инвертирует позиции во всех "обновлениях" в зависимости от размера доски.
У интерфейса есть две реализации - один действительно сохраняет ходы, другой только их количество:
```
struct TMoveContainer : IMoveContainer {
std::array Moves;
std::size\_t MovesCount = 0;
void Add(const TMove& move) override {
Moves[MovesCount++] = move;
}
void InverseMoves(const TBoard& board) override;
};
struct TDummyMoveContainer : IMoveContainer {
std::size\_t MovesCount = 0;
void Add(const TMove& move) override {
MovesCount++;
}
void InverseMoves(const TBoard& /\* board \*/) override {}
};
```
Если собрать все, что фигуре нужно для того, чтобы сгенерировать ходы, получится такая структура:
```
struct TMoveContext {
// new moves should be written here
IMoveContainer& Moves;
// used to "look around" to see other pieces
TOrientedBoardWrapper Board;
// additional info about current piece
const TBoardPosition Position;
};
```
Поэтому для каждой фигуры, находящейся на поле, вызывается метод ее класса
```
void FillMoves(TMoveContext& moveContext);
```
В этом методе фигура должна добавлять ходы в контейнер.
Генерация ходов у стандартных фигур
-----------------------------------
Среди всех стандартных фигур самая сложная "бизнес"-логика - у пешек. Можно посмотреть код в [TPawnPiece::FillMoves](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/vanilla_pieces/pawn_piece.cc#L118-L140), где описывается генерация ходов. В процессе этого используется "память" фигуры и доска.
Если у фигуры определен метод `AfterMoveApply`, то он вызывается после того, как на доску "применится" новый ход. У пешки есть метод [TPawnPiece::AfterMoveApply](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/vanilla_pieces/pawn_piece.cc#L142-L157), который меняет "статус" пешки. Это связано с тем, что по правилу "взятий на проходе" пешку можно взять только сразу после хода, иначе право на такое взятие теряется.
Для стандартных типов ходов есть вспомогательный метод:
```
enum class EMoveType {
Leaper,
Rider,
Hopper,
};
void AddStandardMoves(TMoveContext& ctx, TBoardPiece boardPiece, EMoveType moveType, TBoardPosition deltaPosition);
```
Тип хода `Leaper` - ходы как у коня: единичный фиксированный сдвиг на позицию.
Тип хода `Rider` - ходы как у слона/ладьи/ферзя: фигура может переместиться на определенный сдвиг сколько угодно раз, пока не встретит "препятствие" (край доски/другая фигура).
Все ходы проверяются на корректность: нельзя выпрыгнуть за край доски или съесть фигуру одного цвета.
Тип хода `Hopper` рассмотрим в следующий разделах - такой тип есть у "нестандартной" фигуры.
Вот так выглядит генерация ходов у коня:
```
void TKnightPiece::FillMoves(TMoveContext& moveContext) {
TBoardPiece boardPiece = moveContext.Board.GetBoardPiece(moveContext.Position);
for (int colMult : {-1, 1}) {
for (int rowMult : {-1, 1}) {
AddStandardMoves(moveContext, boardPiece, EMoveType::Leaper,
{.Column = colMult * 2, .Row = rowMult * 1});
AddStandardMoves(moveContext, boardPiece, EMoveType::Leaper,
{.Column = colMult * 1, .Row = rowMult * 2});
}
}
}
```
Вот так у слона:
```
void TBishopPiece::FillMoves(TMoveContext& moveContext) {
TBoardPiece boardPiece = moveContext.Board.GetBoardPiece(moveContext.Position);
for (int colDelta : {-1, 1}) {
for (int rowDelta : {-1, 1}) {
AddStandardMoves(moveContext, boardPiece, EMoveType::Rider,
{.Column = colDelta, .Row = rowDelta});
}
}
}
```
Ходы покрыты тестами, например для слона: [bishop\_piece\_ut.cc](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/vanilla_pieces/bishop_piece_ut.cc).
Оценка позиции
--------------
"Оценка позиции" это функция, которая определяет относительную "стоимость" доски.
На [Chessprogramming Wiki](https://www.chessprogramming.org/Evaluation) можно почитать, как выглядят такие функции. Я выбрал для оценки простую функцию, которая выглядит так:
```
f(p) = 20000(K-K')
+ 900(Q-Q')
+ 500(R-R')
+ 300(B-B' + N-N')
+ 100(P-P')
+ 10(M-M')
K,Q,R,B,N,P - количество белых королей, ферзей, ладей,
слонов, коней, пешек соответственно
K',Q',R',B',N',P' - то же самое у черных
M - мобильность (количество доступных ходов)
```
Этого достаточно, чтобы компьютер пытался "выводить" фигуры в бой, и предпринимал попытки победить противника и объявить мат. Так как функция целочисленная, то стоимость фигур делится на 100 (пешка стоит 100 баллов, ферзь стоит 900 баллов). Условно считается, что если у противника на одну пешку меньше, но возможных ходов на 10 больше, то позиции равноценны.
Для белых выгоднее, чтобы функция `f(p)` была как можно выше, для черных наоборот - как можно ниже.
Минимакс
--------
Алгоритм поиска лучшего хода основан на "минимаксе". Допустим, что сейчас ход белых. Они должны выбрать наиболее оптимальный ход: чтобы `f(p)` был как можно выше через N ходов. Черные также выбирают ход оптимально: чтобы `f(p)` был как можно ниже.
Этот алгоритм достаточно известный, о нем подробнее можно почитать в статье ["Минимакс на примере игры в зайца и волков"](https://habr.com/ru/post/146088/).
Для быстрой игры минимакс жизненно необходимо оптимизировать, главным образом путем отсечения некоторых веток из поиска в глубину. Алгоритм поиска хода должен смотреть на N ходов вперед, чтобы "понимать", какие есть опасности или перспективы.
Если мы будем смотреть все возможные ходы, то далеко на этом уехать нельзя. В начале партии есть 20 доступных ходов. У ферзя на пустой доске есть 27 доступных ходов. Можно прикинуть, что число порядка растет очень быстро.
Описание всех факторов, влияющих на поиск:
#### Альфа-бета отсечение
Это стандартное отсечение, рассмотренное в статье про минимакс (чуть выше). Его суть в том, чтобы выкинуть из рассмотрения ветки поиска, которые гарантированно не улучшат результат.
#### Сортировка ходов по интересности
Успех альфа-бета отсечения еще зависит от того, насколько "хорошие" ходы мы рассматриваем в начале. Если быстро найти хороший ход, то остальные не такие хорошие ходы выкидываются почти сразу. Логично сделать быструю сортировку ходов по влиянию на стоимость фигур (без учета мобильности - ее "дорого" считать).
Сортировка в коде есть тут - [ссылка](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/minimax/minimax.cc#L126-L140).
#### Пролонгация поиска
Если в текущем ходе произошло взятие фигуры, то рассматривать все следующие ходы нужно, даже если достигнут "предел" глубины, так как обычно на взятие прилетает "ответка", то есть происходит обычный размен фигур. Если не продлевать поиск, то минимакс за горизонтом не увидит плохие последствия.
На пролонгацию поиска есть тест, где лучше понятно, что происходит. В "обычных" условиях, при поиске на глубину 1, если можно взять коня или ладью, то происходит взятие ладьи - [minimax\_ut.cc](https://github.com/Izaron/FairyChess/blob/944bfca3548929191ec960941ad2a977dff0a63f/src/minimax/minimax_ut.cc#L25-L60). Если взятая фигура защищена, то это влияет на поиск - [minimax\_ut.cc](https://github.com/Izaron/FairyChess/blob/main/src/minimax/minimax_ut.cc#L62-L99).
Однако для пролонгации по взятию есть свой отдельный предел глубины - если его не поставить, то поиск может смотреть хоть на 30 ходов вперед.
Ситуации, когда король под шахом, не пролонгируются, потому что определение шаха "дорогое", поэтому алгоритм избегает мата обычным образом (в пределах стандартной глубины).
#### Zobrist-хэширование
[Zobrist hashing](https://www.chessprogramming.org/Zobrist_Hashing) это хэширование всей доски в одно число (в моем случае 32-битное). Его особенность - похожие позиции должны иметь кардинально разный хэш.
Попытки добавить хэширование выпило мне много крови. Планировалось, что хэшировать можно уже рассмотренные в минимаксе доски (точнее, их оценку), чтобы не повторять работу по вычислению. В действительности компьютер после хэширования заметно отупел и выбирал плохие ходы. После дебага выяснилось, что из-за альфа-бета отсечения, где многие ходы на доске "в глубине" выбрасываются, в хэш попадала неправильная оценка. Все попытки добавить нормальный хэш провалились из-за неполного перебора.
Сейчас хэш используется, чтобы компьютер не делал повторяющиеся ходы, потому что в игре с самим собой он любит попадать в вечный цикл повторяющихся ходов - [minimax.cc](https://github.com/Izaron/FairyChess/blob/main/src/minimax/minimax.cc#L110-L114).
#### Неиспользованные оптимизации
Так как я не ставил целью победить популярные шахматные движки (как Stockfish), в программе нет других сложных оптимизаций. Оптимизации разделяются на две группы: оптимизация самого кода и отсечение дерева поиска. Обе группы я описал выше.
Из-за того, что шахматы будут не только "стандартные", в движке нет базы данных дебютов или особой логики для эндшпиля. То есть штуки, полагающиеся на стандартные шахматные правила, намеренно не внесены в движок.
Графика
-------
Для отрисовки шахматной доски я использовал библиотеку [SFML](https://www.sfml-dev.org/). Я сделал два режима - показ доски в окне, и сохранение в картинку. В этом деле нет ничего интересного для статьи.
Варианты шахмат
---------------
Всего запрограммировано **15** шахматных вариантов. В порядке возрастания необычности есть такие разновидности: обычные шахматы (**1** вариант), обычные фигуры на обычной доске с необычным набором фигур (**4** варианта), необычные фигуры на обычной доске (**6** вариантов), необычная доска и фигуры (**4** варианта). Список вариантов:
1. Стандартные шахматы (Vanilla Chess)
2. Атака легкой кавалерии (Charge of the Light Brigade)
3. Орда (Horde)
4. Крестьянское восстание (Peasants' Revolt)
5. Weak!
6. Беролина (Berolina)
7. Бешеный король (Mad King)
8. Тутти-фрутти (Tutti-Frutti)
9. Королевский конь (Knightmate)
10. Попрыгунчик (Grasshopper)
11. Атомные шахматы (Atomic)
12. Шахматы Капабланки (Capablanca Chess)
13. Антилопа Гну (Wildebeest)
14. Шахматы гарантированного возмездия (Stratomic)
15. Действительно большие шахматы (Really Big Board)
Эти варианты я взял с Википедии: <https://en.wikipedia.org/wiki/List_of_chess_variants>.
Также в Википедии доступен огромный список необычных шахматных фигур: <https://en.wikipedia.org/wiki/Fairy_chess_piece>.
По умолчанию движок рассматривает полный перебор для **4** ходов, пролонгация взятий действует еще на **6** дополнительных ходов. То есть "вперед" мы смотрим на 10 ходов (из них на первые 4 - в полном объеме). Это довольно много - попробуйте сделать 10 ходов на доске, чтобы почувствовать. Эта настройка выбрана в большинстве вариантов (если не указано иное).
Картинки партий (а также логи) для всех шахматных вариантов можно смотреть в репозитории движка [в этой директории](https://github.com/Izaron/FairyChess/tree/main/gameplay). Например, для стандартных шахмат это под-директория [vanilla](https://github.com/Izaron/FairyChess/tree/main/gameplay/vanilla). В статье будут склейки по интересным местам (склейки кликабельны). Внимание - описание склейки находится **под** склейкой (чтобы не путаться)!
Стандартные шахматы (Vanilla Chess)
-----------------------------------
Запускаем игру компьютера с самим собой.
Первые ходыВ стандартном дебюте белые выводят ферзя, потому что именно такой ход дает наибольший вклад в функцию оценки по параметру "мобильности". Так как в движке нет базы данных дебютов, то он не "знает" заведомо, что в шахматах так обычно не ходят.
Ходы 4-7Черные также выводят ферзя, так как у них такая же оценка позиции.
Ходы 8-15После вывода фигур происходит размен ферзей.
Ходы 16-19Далее партия развивается обычным образом. Пропустим несколько ходов...
Ходы 42-45В партиях иногда встречаются артефакты функции оценки - например, компьютер считает, что можно пожертвовать пешкой, чтобы разменять фигуры и уменьшить мобильность противника.
Ходы 51-54Стратегическое преимущество осталось за белыми. Ладья ходом на a4 создала угрозу - в будущем она может походить на f4 и создать "вилку", атакуя одновременно коня и пешку. Черные закрывают дорогу ладье ходом пешки на c4, но безрезультатно - белые разваливают остаток пешечного фронта и инициатива окончательно переходит к белым.
Ходы 123-126Черные отдают ладью, чтобы отсрочить поражение.
Ходы 142-143Черные предвидели мат и "сдали" партию, так как не нашли ни одного хода, где у них не съедают короля (мат в два хода: ♚b6 - ♕b8).
Эта партия состоит из **143** ходов, было проанализировано **18 355 708** досок, общее время расчета **92.3627** секунд (средняя скорость **198 735** досок/секунду).
Атака легкой кавалерии (Charge of The Light Brigade)
----------------------------------------------------
Начальная позицияВ этом варианте у белых есть 3 ферзя и 8 пешек, у черных есть 7 коней и 8 пешек. Автор этого варианта хотел показать, что не всегда "стоимость" позиции определяется ценностью фигур: если конь стоит 300 баллов, а ферзь 900 баллов, то у черных отставание в 600 баллов, но тем не менее у них превосходящая армия.
Посмотрим, правда ли, что конная кавалерия победит ферзей?
Ходы 2-5Белые пытаются сразу вывести ферзей, чтобы была лучшая мобильность. Это не очень хорошая тактика, потому что черные начинают выводить коней, одновременно с атаками на ферзей.
Ходы 22-25У черных намного более лучшая мобильность.
Ходы 86-90Белый ферзь берет коня на f4, чтобы избежать мгновенного мата (♞d3), но спустя пару шахов белые сдают партию, так как мат неизбежен (♔d3 - ♞c5).
Эта партия состоит из **89** ходов, было проанализировано **288 695 116** досок, общее время расчета **1467.55** секунд (средняя скорость **196 719** досок/секунду).
Орда (Horde)
------------
Начальная позицияВ этом варианте у белых 36 пешек. Черные для победы должны съесть все пешки. Этот вариант достаточно популярный, поддержан в многих онлайн-шахматах и про него даже есть [книга](https://www.amazon.com/dp/B092XPNNVS).
Тактика для этого варианта заключается в том, что черным надо "освободить" какую-нибудь вертикаль, тогда все белые пешки будут съедены, так как они не имеют защиты "сзади".
Ходы 20-22На склейке выше пример, как можно ломиться сквозь пешечную вертикаль.
Ходы 55-57После 57 хода участь белых пешек предрешена - ладья теперь может съесть все пешки на первой горизонтали.
Ход 108 - белые сдалисьЭта партия состоит из **108** ходов, было проанализировано **128 196 318** досок, общее время расчета **672.735** секунд (средняя скорость **190 559** досок/секунду).
Крестьянское восстание (Peasants' Revolt)
-----------------------------------------
Начальная позицияВ этом варианте у белых есть только 8 пешек, у черных есть 1 пешка и 4 коня. У черных есть преимущество.
Так как дерево поиска очень маленькое, то можно было запускать полный перебор не только на 4 хода вперед, но и на 5 ходов, и на 6 ходов вперед. Во всех партиях белые проиграли.
Результаты партий с полным перебором на 4, 5, 6 ходовВ переборе на 4 хода игра заняла **50** ходов, **2.64479** секунды на анализ (со скоростью **358 324** досок/секунду).
В переборе на 5 ходов игра заняла **56** ходов, **10.5065** секунды на анализ (со скоростью **376 271** досок/секунду).
В переборе на 6 ходов игра заняла **86** ходов, **371.099** секунды на анализ (со скоростью **334 532** досок/секунду).
Weak!
-----
Начальная позицияЭто вариант средней интересности, с пешками и конями у черных.
Ходы 90-93Черные разменяли коней на фигуры белых, но не смогли добиться выигрыша своими лишними пешками. Белые не попадали в "вилки" и не давали прохода черным пешкам.
Эта партия состоит из **143** ходов, было проанализировано **66 753 398** досок, общее время расчета **358.131** секунд (средняя скорость **186 393** досок/секунду).
Беролина (Berolina)
-------------------
Начальная позицияТеперь пора добавлять необычные фигуры. [Шахматы Беролина](https://en.wikipedia.org/wiki/Berolina_chess) - это вариант с "инвертированными пешками": пешки могут ходить только по диагонали (в любую сторону), а брать фигуры только по вертикали. Если пешка ходит в первый раз, она может походить на 2 диагонали вперед.
Ходы 1-4Стороны выводят свои ферзевые пешки.
Ходы 21-24Белая ладья атакует незащищенного коня, слон закрывает ладье ход. Затем белая пешка опять атакует черного коня, и он отходит.
Ходы 42-46На склейке выше происходит необычный размен одной пешки и легкой фигуры - белая ладья становится немного мобильнее.
Ходы 82-85Белые выиграли партию - они смогли довести пешку до последней диагонали.
Игра довольно острая, можно посмотреть полную игру на [github](https://github.com/Izaron/FairyChess/tree/main/gameplay/berolina).
Эта партия состоит из **107** ходов, было проанализировано **101 661 065** досок, общее время расчета **571.838** секунд (средняя скорость **177 779** досок/секунду).
Бешеный король (Mad King)
-------------------------
Начальная позицияВводится новая фигура - [**амазонка**](https://en.wikipedia.org/wiki/Amazon_(chess)), она может ходить как **ферзь** и как **конь**. Эта фигура может поставить мат королю в одиночку. Вариант [Mad King](https://en.wikipedia.org/wiki/Maharajah_and_the_Sepoys) - у белых есть только одна амазонка, и надо поставить мат черным. Это "решенная" игра с выигрышом для черных, посмотрим что про это думает шахматный движок.
Ходы 51-54Черные гоняли амазонку по всей доске, не давая съесть ни одной фигуры. Единственное, чего добилась амазонка - съела пешку, но потом белые сдали партию, увидев неминуемое взятие амазонки.
Эта партия состоит из **54** ходов, было проанализировано **37 140 321** досок, общее время расчета **183.855** секунд (средняя скорость **202 008** досок/секунду).
Тутти-фрутти (Tutti-Frutti)
---------------------------
Начальная позиция[Тутти-фрутти](https://en.wikipedia.org/wiki/Tutti-frutti_chess) это вариант с "усиленными" фигурами. Кроме **амазонки**, на доске стоят [**императрицы**](https://en.wikipedia.org/wiki/Empress_(chess)) (ладья+конь) и [**принцессы**](https://en.wikipedia.org/wiki/Princess_(chess)) (слон+конь).
Для новых фигур нужно определить их "стоимость". Я решил это так - если ладья стоит **500** баллов, слон стоит **300** баллов, ферзь (ладья+слон) стоит **900** баллов, то и императрица (ладья+конь) и принцесса (слон+конь) должны стоить **900** баллов. Амазонка (ладья+слон+конь) у меня стоит **1300** баллов.
Ходы 1-4Игроки сразу выводят сильные фигуры.
Ходы 34-38Черные красиво отжимают ладью: их слон атаковал ферзя и одновременно позволил императрице сделать "вилку".
Черные заставили белых разменять фигуры, после чего с перевесом в ладью довели игру до своей победы.
Эта партия состоит из **120** ходов, было проанализировано **23 325 618** досок, общее время расчета **134.167** секунд (средняя скорость **173 855** досок/секунду).
Королевский конь (Knightmate)
-----------------------------
Начальная позицияВ этом варианте конь и король меняются местами. Вместо двух коней есть две фигуры **манн** (от немецкого "Mann" - человек) - они двигаются как король, но являются обычными фигурами (могут быть съедены). Вместо короля есть **королевский конь** - он двигается как конь, но для победы ему нужно объявить мат. Я поставил "стоимость" манна в 150 баллов (как полторы пешки).
Ходы 18-22Здесь алгоритм очень крупно подставился - белые вывели королевского коня вперед, и черные стали выводить фигуры с помощью атаки на коня.
Ходы 95-98Белые забрали черную ладью, но не смогли защитить белую ладью - на 98 ходе черная ладья прогнала королевского коня. В итоге черные победили, загнав королевского коня в угол.
Эта партия состоит из **104** ходов, было проанализировано **20 463 291** досок, общее время расчета **119.934** секунд (средняя скорость **170 621** досок/секунду).
Попрыгунчик (Grasshopper)
-------------------------
Начальная позицияУ каждого игрока кроме стандартных фигур есть восемь [**попрыгунчиков**](https://en.wikipedia.org/wiki/Grasshopper_(chess)) (англ. grasshopper). Эти фигуры могут двигаться в любом направлении, но лишь "перепрыгивая" через другие фигуры (любого цвета).
Возможные ходы попрыгунчикаНа изображении видны возможные ходы белого попрыгунчика - их 5 штук, в одном из ходов он может съесть черную пешку. Я поставил стоимость попрыгунчика в 200 баллов (как две пешки).
Ходы 6-9Попрыгунчики выводятся на доску и размениваются.
Ходы 54-57Белый попрыгунчик объявляет шах королю, от которого он избавляется ходом коня.
Ходы 74-77Белые понесли потери и им чуть не объявили мат - пришлось пожертвовать попрыгунчиком. На 120-м ходе белые сдали партию.
Эта партия состоит из **120** ходов, было проанализировано **116 240 217** досок, общее время расчета **963.316** секунд (средняя скорость **120 666** досок/секунду).
Атомные шахматы (Atomic)
------------------------
[Атомные шахматы](https://en.wikipedia.org/wiki/Atomic_chess) - имеют стандартные правила, но при взятии какой-либо фигуры происходит "взрыв": атаковавшая фигура и все фигуры на соседних 8 клетках (независимо от цвета, и кроме пешек) убираются. По ссылке есть гифка, которая показывает это правило. Король тоже убирается, поэтому если взять фигуру рядом с ним, то противник выигрывает.
Ходы 1-8Партия сразу имеет острый характер. Уже на 3 ходу слон грозит взять пешку и взорвать короля, поэтому путь преграждается конем. То же самое делает ферзь, ход преграждается пешкой. Затем ферзь ходит ♕d5, и черные не могут его съесть, потому что этим взорвется черный конь, и белый слон в свою очередь взорвет короля, поэтому снова ход преграждается пешкой.
Ходы 22-25На склейке выше показан размен через взрывы в миттельшпиле. Обратите внимание - после 25 хода черная ладья может съесть белую, но это будет взаимное уничтожение и не поменяет баланс материала.
Игра довольно острая и стороны ходят очень осторожно. Единственные фигуры, которыми можно сравнительно безопасно играть - пешки, потому что взрывы на них не действуют. Кстати, король совершенно безоружен и никого съесть не может, потому что в таком случае он взорвется и автоматически проиграет.
Ходы 87-90Черные не могут спокойно съесть пешки из-за взрывов, поэтому белые без проблем проводят их вперед, а черные сдают партию на 90-м ходе.
Эта партия состоит из **90** ходов, было проанализировано **1 792 579** досок, общее время расчета **12.8841** секунд (средняя скорость **139 131** досок/секунду).
Так как дерево перебора меньше, то можно посмотреть на партию с полным перебором в 5 ходов [на github](https://github.com/Izaron/FairyChess/tree/main/gameplay/atomic/depth5), там ходят поумнее, но разбирать партию не буду, чтобы не раздувать статью.
Реализация атомных фигур сделана в шаблонном стиле без копипаста - [atomic\_pieces.h](https://github.com/Izaron/FairyChess/blob/main/src/fairy_pieces/atomic_pieces.h).
Шахматы Капабланки (Capablanca Chess)
-------------------------------------
Начальная позицияНастало время для шахмат с досками необычных размеров. [Шахматы Капабланки](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B_%D0%9A%D0%B0%D0%BF%D0%B0%D0%B1%D0%BB%D0%B0%D0%BD%D0%BA%D0%B8) - довольно известный вариант на доске 10x8 с уже знакомыми нам фигурами **императрица** и **принцесса**.
Ходы 22-25Игра идет в нормальном темпе, из заметок по варианту - ход пешками на вертикали d открывает угрозу для взятия пешек f2/f7.
Ходы 54-56Белые проиграли ладью, и после размена все стало плохо. Белые сдали партию на 84 ходу.
Эта партия состоит из **84** ходов, было проанализировано **46 067 073** досок, общее время расчета **308.699** секунд (средняя скорость **149 229** досок/секунду).
Антилопа Гну (Wildebeest)
-------------------------
Начальная позиция[Wildebeest](https://en.wikipedia.org/wiki/Wildebeest_chess) - это вариант средней интересности на доске 11x10. Там добавляются две фигуры, которые называются "верблюд" и "антилопа гну", но я не нашел для них иконки, поэтому у меня это две фигуры **зебра** и **единорог**.
Ходы зебры и единорогаХоды зебры напоминают ходы коня, но "вектор" прыжков (3,1) вместо (2,1). Зебра ограничена одним цветом (как слон). Единорог может ходить как зебра и как конь. Я поставил стоимость зебры в **300** баллов, единорога в **600** баллов.
Ходы 34-37Белый единорог съедает пешку в миттельшпиле.
Каких-то интересных ходов не было, партия прошла вяло, белые постепенно проиграли. Эта партия состоит из целых **190** ходов, было проанализировано **235 850 073** досок, общее время расчета **2083.96** секунд (средняя скорость **113 173** досок/секунду).
Шахматы гарантированного возмездия (Stratomic)
----------------------------------------------
Начальная позицияВариант [Stratomic](https://en.wikipedia.org/wiki/Stratomic) на доске 10x10 добавляет каждому игроку две **ядерные ракеты**. В игре есть "протокол эскалации" - ядерные ракеты можно запускать после того, как будет взята любая фигура кроме пешки. При запуске ядерной ракеты уничтожается сама ракета и все фигуры любого цвета, кроме короля, в выбранном игроком квадрате 3х3. Также ядерная ракета может ходить как король (чтобы обезопасить себя, если ее атакуют).
Ходы 16-20Размены не-пешечных фигур откладывались, но на 17 ходу произошла эскалация - был взят слон с шахом. После эскалации игроки обменялись ядерными ударами.
Ходы 33-36Так как я поставил стоимость ядерных ракет в 500 баллов, то, видимо, алгоритм посчитал неразумным тратить весь потенциал, и следующий ядерный удар произошел на 36 ходу.
Ходы 42-45Последний ядерный удар произошел на 45 ходу.
К эндшпилю у черных появилось преимущество - ладья против коня. Белые постепенно проиграли.
Эта партия состоит из **122** ходов, было проанализировано **113 019 048** досок, общее время расчета **2348.6** секунд (средняя скорость **48 121** досок/секунду).
Действительно большие шахматы (Really Big Board)
------------------------------------------------
Начальная позиция[Действительно большие шахматы](https://en.wikipedia.org/wiki/Chess_on_a_really_big_board) - вариант на доске 16x16. Пешки в первом ходе могут двигаться до 6 клеток вперед. Кроме рассмотренных ранее необычных фигур, добавилось еще четыре (названия мои): **волшебник**, **чемпион**, **шут**, **дракон**.
Ходы волшебника, чемпиона, шутаВолшебник ограничен своим цветом. Чемпион "протыкает" диагонали на две клетки. Шут называется так, потому что он бьёт не туда, куда "смотрит" (т.е. не по вертикали/горизонтали/диагонали). Стоимости фигур соответственно 300, 300, 500 баллов.
Ходы драконаДракон летает по "кругам" странным образом. Он может прилететь на исходное место, то есть игрок фактически может пропустить свой ход, если у него есть дракон. Стоимость дракона 500 баллов.
Вычисление на такой доске происходит в несколько раз медленнее, поэтому полный перебор был в 3 хода.
Ход 62За мешаниной необычных фигур было довольно сложно следить за стратегией движка. Все закончилось внезапно, когда черные смогли объявить белым мат фактически в дебюте на 62 ходу.
Эта партия состоит из **62** ходов, было проанализировано **84 055 631** досок, общее время расчета **1969.06** секунд (средняя скорость **42 688** досок/секунду). | https://habr.com/ru/post/654745/ | null | ru | null |
# htop и многое другое на пальцах
На протяжении долгого времени я не до конца понимал htop. Я думал, что средняя загрузка [load average] в 1.0 означает, что процессор загружен на 50%, но это не совсем так. Да и потом, почему именно 1.0?
Затем я решил во всём разобраться и написать об этом. Говорят, что лучший способ научиться новому — попытаться это объяснить.
htop на Ubuntu Server 16.04 x64
===============================
Ниже скриншот htop, который я буду рассматривать в статье.
Uptime
======
Uptime показывает время непрерывной работы системы. Это можно узнать и командой **uptime**.
```
$ uptime
12:17:58 up 111 days, 31 min, 1 user, load average: 0.00, 0.01, 0.05
```
Где же программа **uptime** это берёт? Она считывает информацию из файла **/proc/uptime**.
```
9592411.58 9566042.33
```
Первое число — количество секунд работы системы. Второе же показывает сколько секунд система находилась в бездействии. Стоит отметить, что на системах с несколькими процессорами, второй показатель может оказаться больше, чем первый, так как это сумма по процессорам.
Как я об этом узнал? Я посмотрел какие файлы открывает **uptime** при запуске. Для этого, можно воспользоваться утилитой **strace**.
```
strace uptime
```
Будет много вывода, лучше сделать **grep** для поиска системного вызова **open**. Но это не совсем сработает, т.к. по умолчанию он выводит в стандартный поток ошибок (stderr). Можно перенаправить stderr в стандартный поток с помощью **2>&1**.
Результат таков:
```
$ strace uptime 2>&1 | grep open
...
open("/proc/uptime", O_RDONLY) = 3
open("/var/run/utmp", O_RDONLY|O_CLOEXEC) = 4
open("/proc/loadavg", O_RDONLY) = 4
```
Тут содержится упомянутый файл **/proc/uptime**. Оказалось, что достаточно запустить **strace -e open uptime** и не мучиться с **grep**ом.
Если можно взять это прямо из файла, то зачем нужна утилита **uptime**? Дело в том, что **uptime** форматирует вывод в читаемом виде, тогда как секунды в файле удобно использовать при написании собственных скриптов и программ.
Load average
============
Помимо времени непрерывной работы, uptime показывает и среднюю загрузку системы, они отображены как 3 числа.
```
$ uptime
12:59:09 up 32 min, 1 user, load average: 0.00, 0.01, 0.03
```
А взяты они из файла **/proc/loadavg**. Если еще раз посмотреть на вывод **strace**, то можно заметить, что этот файл тоже был открыт.
```
$ cat /proc/loadavg
0.00 0.01 0.03 1/120 1500
```
Первые 3 числа измеряют среднюю загрузку системы за последние 1, 5 и 15 минут. 4-ый параметр это количество активных процессов и их общее число. Последнее число это ID последнего использованного процесса.
Начнём с конца.
Когда запускается процесс, ему присваивается ID. Как правило, они идут в возрастающем порядке, за исключением случаев, когда число исчерпалось и системе приходится начинать отсчёт заново. ID 1 присваивается процессу **/sbin/init**, который запускается при старте.
Взглянем ещё раз на **/proc/loadavg** и попробуем запустить команду **sleep** в фоновом режиме. При запуске в фоновом режиме, можно увидеть ID процесса.
```
$ cat /proc/loadavg
0.00 0.01 0.03 1/123 1566
$ sleep 10 &
[1] 1567
```
Таким образом, **1/123** означает, что 1 процесс выполняется или готов к выполнению, а всего их 123.
Когда при запуске **htop**, вы видите, что выполняется только один процесс, это сам процесс htop.
Если запустить **sleep 30** и открыть **htop**, то число выполняющихся процессов всё равно будет 1. Это потому, что процесс **sleep** не выполняется, а «спит», т.е. находится в состоянии покоя, иными словами ждёт определённого события. Выполняющийся или активный процесс, это процесс который на данный момент обрабатывается в процессоре (CPU), либо ждёт своей очереди в процессоре.
Попробуйте запустить **cat /dev/urandom > /dev/null**, где генерируемые случайные байты записываются в особый файл, считывание из которого невозможно. Тогда вы увидите, что выполняющихся процессов теперь уже 2.
```
$ cat /dev/urandom > /dev/null &
[1] 1639
$ cat /proc/loadavg
1.00 0.69 0.35 2/124 1679
```
Так, активных процессов ровно 2 (генератор случайных чисел и утилита **cat**, которая читает файл **/proc/loadavg**), еще можно заметить что средняя загрузка возросла.
**load average** это средняя загрузка системы на протяжении определённого периода времени.
Число загрузки считается как сумма количества процессов, которые запущены (выполняются или находятся в ожидании запуска) и непрерываемых процессов (о видах процессов будет рассказано ниже). Т.е. это просто число процессов.
А средняя загрузка получается просто усреднённое значение за 1, 5 и 15 минут, так?
Оказывается, не всё так просто.
Говоря математическим языком, все три значения усредняют среднюю загрузку за всё время работы системы. Они устаревают экспоненциально, но с разной скоростью. Таким образом, средняя загрузка за 1 минуту это сумма 63% загрузки за последнюю минуту + 37% загрузки с момента запуска без учёта последней минуты. То же соотношение верно и для 5, 15 минут. Поэтому не совсем верно, что средняя загрузка за последнюю минуту включает активность только за последнюю минуту, но бОльшей частью за последнюю минуту.
Вы это знали?
Вернёмся к генератору случайных чисел.
```
$ cat /proc/loadavg
1.00 0.69 0.35 2/124 1679
```
Хотя это не совсем правильно, но вот как я упростил для понимания показатель средней загрузки.
В данном случае генератор использует процессор, средняя загрузка за последнюю минуту **1.00**, другими словами в среднем 1 выполняющийся процесс.
В моей системе это означает что процессор загружен на 100%, т.к. процессор один, а выполнять он может только один процесс за раз.
Если бы процессоров было 2, то загрузка соответственно была бы 50%, т.к. можно было бы одновременно выполнять 2 процесса. Максимальная средняя загрузка (100% использования CPU) системы с двумя процессорами составляет **2.00**.
Количество процессоров в системе можно узнать в левом верхнем углу **htop** или при помощи **nproc**.
Процессы
========
В правом верхнем углу, **htop** показывает общее количество процессов и сколько из них активны. Но почему там написано задания [Tasks], а не процессы?
Задание это синоним процесса. В ядре Linux процессы это и есть задания. **htop** использует термин задания, возможно, потому, что это название короче и экономит немного места.
В **htop** можно увидеть и потоки [threads]. Для переключения этой опции нужно использовать комбинацию *Shift+H*. Если отображается что то вроде **Tasks: 23, 10 thr**, то это значит они видимы.
Отображение потоков выполнения ядра [kernel threads] можно включить комбинацией *Shift+K*, и тогда задания будут выглядеть как **Tasks: 23, 40 kthr**.
ID процесса / PID
=================
При каждом запуске процесса, ему присваивается идентификатор (ID), сокращенно PID.
Если запускать программу в фоновом режиме (**&**) из **bash**, то номер задачи[job] выводится в квадратных скобках, а рядом с ним PID процесса.
```
$ sleep 1000 &
[1] 12503
```
Ещё один способ, это использовать переменную **$!** в **bash**, которая хранит PID последнего процесса, запущенного в фоне.
```
$ echo $!
12503
```
ID процесса очень полезна. С помощью него можно узнать подробности процесса и управлять им.
Существует псевдо файловая система **procfs**, с помощью которой программы могут получить информацию от ядра системы путём чтения файлов. Чаще всего она монтируется в **/proc/** и для пользователя выглядит как обычный каталог, который можно смотреть командами, такими как **ls** и **cd**.
Вся информация о процессе находится в **/proc/<рid>/**.
$ ls /proc/12503
```
attr coredump_filter fdinfo maps ns personality smaps task
auxv cpuset gid_map mem numa_maps projid_map stack uid_map
cgroup cwd io mountinfo oom_adj root stat wchan
clear_refs environ limits mounts oom_score schedstat statm
cmdline exe loginuid mountstats oom_score_adj sessionid status
comm fd map_files net pagemap setgroups syscall
```
Например в **/proc/<рid>/cmdline** содержится команда при помощи которой процесс запустился.
```
$ cat /proc/12503/cmdline
sleep1000$
```
Эмм..., не совсем так. Разделителем тут служит байт **\0**,
```
$ od -c /proc/12503/cmdline
0000000 s l e e p \0 1 0 0 0 \0
0000013
```
который можно заменить пробелом, либо переводом строки
```
$ tr '\0' '\n' < /proc/12503/cmdline
sleep
1000
$ strings /proc/12503/cmdline
sleep
1000
```
В каталоге процесса могут быть и ссылки! Для примера, **cwd** ссылается на текущий рабочий каталог, а **exe** на запущенный исполняемый файл.
```
$ ls -l /proc/12503/{cwd,exe}
lrwxrwxrwx 1 ubuntu ubuntu 0 Jul 6 10:10 /proc/12503/cwd -> /home/ubuntu
lrwxrwxrwx 1 ubuntu ubuntu 0 Jul 6 10:10 /proc/12503/exe -> /bin/sleep
```
Таким образом утилиты **htop**, **top**, **ps** и другие показывают информацию о процессе, они просто читают **/proc/<рid>/<файл>**.
Дерево процессов
================
Когда запускается новый процесс, процесс который его запускает принято называть родительским или просто родителем. Таким образом новый процесс это дочерний процесс родительского. Эти отношения образуют структуру в виде дерева.
Если нажать *F5* в **htop**, то можно увидеть иерархию процессов.
Тот же эффект и от флага **f** команды **ps**.
```
$ ps f
PID TTY STAT TIME COMMAND
12472 pts/0 Ss 0:00 -bash
12684 pts/0 R+ 0:00 \_ ps f
```
Либо **pstree**.
```
$ pstree -a
init
├─atd
├─cron
├─sshd -D
│ └─sshd
│ └─sshd
│ └─bash
│ └─pstree -a
…
```
Если вы когда нибудь задумывались, почему **bash** или **sshd** являются родительскими для некоторых процессов, то вот почему.
Ниже я написал, что происходит, если вы, к примеру, вызовите **date** из консоли **bash**.
* **bash** создаст новую копию своего процесса (используя системный вызов **fork**)
* Затем он переместит исполняемый файл **/bin/date** в память (при помощи системного вызова **exec**).
* **bash**, как родительский процесс будет ожидать окончания работы дочернего.
Таким образом, **/sbin/init**, у которого ID 1, начал выполняться при старте системы и породил демона SSH **sshd**. После подключения к системе, **sshd** породит процесс для текущей сессии, который в свою очередь запустит консоль **bash**.
Я предпочитаю использовать древовидную структуру в **htop** когда хочется увидеть все потоки.
Владелец процесса
=================
У каждого процесса есть владелец — пользователь. У пользователей, в свою очередь, существуют численные ID.
```
$ sleep 1000 &
[1] 2045
$ grep Uid /proc/2045/status
Uid: 1000 1000 1000 1000
```
Можно воспользоваться командой **id**, чтобы узнать имя этого пользователя.
```
$ id 1000
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm)
```
Как выяснилось, **id** берёт эту информацию из файлов **/etc/passwd** и **/etc/group**.
```
$ strace -e open id 1000
open("/etc/passwd", O_RDONLY|O_CLOEXEC) = 3
open("/etc/group", O_RDONLY|O_CLOEXEC) = 3
```
Это обычные текстовые файлы, в которых ID привязаны к именам пользователей.
```
$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/bin/bash
$ cat /etc/group
root:x:0:
adm:x:4:syslog,ubuntu
ubuntu:x:1000:
```
**passwd**? Но где пароли? А они на самом деле в **/etc/shadow**.
```
$ sudo cat /etc/shadow
root:$6$mS9o0QBw$P1ojPSTexV2PQ.Z./rqzYex.k7TJE2nVeIVL0dql/:17126:0:99999:7:::
daemon:*:17109:0:99999:7:::
ubuntu:$6$GIfdqlb/$ms9ZoxfrUq455K6UbmHyOfz7DVf7TWaveyHcp.:17126:0:99999:7:::
```
Если вы запустите программу, то она запустится от вашего имени, даже если вы не являетесь её владельцем. Если же вам нужно запустить её как **root**, то нужно использовать **sudo**.
```
$ id
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm)
$ sudo id
uid=0(root) gid=0(root) groups=0(root)
$ sudo -u ubuntu id
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm)
$ sudo -u daemon id
uid=1(daemon) gid=1(daemon) groups=1(daemon)
```
Но что, если нужно запустить несколько программ от имени других пользователей? Можно запустить консоль от их имени, если воспользоваться командами **sudo bash** или **sudo -u user bash**.
Если не хочется каждый раз вводить пароль администратора при запуске программ, то можно отключить эту функцию, добавив своё имя пользователя в файл **/etc/sudoers**.
Давайте попробуем.
```
$ echo "$USER ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
-bash: /etc/sudoers: Permission denied
```
Да, точно, это можно сделать только с привилегиями **root**.
```
$ sudo echo "$USER ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
-bash: /etc/sudoers: Permission denied
```
Что за…?
Тут мы пытаемся вызвать **echo** от имени администратора, но при этом пишем в файл **/etc/sudoers** всё так же от нашего имени.
Как правило, есть 2 выхода из данной ситуации:
* echo "$USER ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers
* sudo bash -c «echo '$USER ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers»
В первом случае, **tee -a** запишет из стандартного потока ввода в файл от имени администратора.
Во втором случае, мы запускаем консоль от имени администратора и просим выполнить команды (**-c**) и все команды выполнятся от имени root. Обратите внимание на расстановку кавычек **"**/**’**, при помощи которых переменная $USER разыменуется правильно.
Допустим, вы захотели поменять свой пароль. Команда **passwd** вам в помощь. Она сохранит пароль в файле **/etc/shadow**, который мы видели выше.
Этот файл доступен для записи только для root:
```
$ ls -l /etc/shadow
-rw-r----- 1 root shadow 1122 Nov 27 18:52 /etc/shadow
```
Как же это возможно, что программа запускаемая от имени пользователя может записывать в защищённый файл?
Я уже говорил, что при вызове, программа запускается от имени пользователя, запускающего её, даже если она принадлежит другому пользователю.
Оказывается, это поведение можно изменить правками разрешения файла. Давайте посмотрим.
```
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 54256 Mar 29 2016 /usr/bin/passwd
```
Обратите внимание на символ **s**. Она была добавлена при помощи **sudo chmod u+s /usr/bin/passwd**. И означает, что исполняемый файл будет всегда запускаться от имени владельца, в данном случае это root.
Так называемые исполняемые файлы **setuid** можно искать при помощи **find /bin -user root -perm -u+s**.
Так же это можно осуществить и для групп (**g+s**).
Состояния процесса
==================
Дальше, мы будем разбираться со столбцом состояния процессов в **htop**, в котором, на примере, находятся символы **S**.
Возможные значения состояния:
* R — [running or runnable] запущенные или находятся в очереди на запуск
* S — [interruptible sleep] прерываемый сон
* D — [uninterruptible sleep] непрерываемый сон (в основном IO)
* Z — [zombie] процесс зомби, прекращенный, но не забранный родителем
* T — Остановленный сигналом управления заданиями
* t — Остановленный отладчиком
* X — Мёртвый (не должен показываться)
Они отсортированы по тому, как часто я их обычно вижу.
Заметьте, что при запуске **ps**, он может ещё показывать подсостояния как **Ss**, **R+**, **Ss+** и т.д.
```
$ ps x
PID TTY STAT TIME COMMAND
1688 ? Ss 0:00 /lib/systemd/systemd --user
1689 ? S 0:00 (sd-pam)
1724 ? S 0:01 sshd: vagrant@pts/0
1725 pts/0 Ss 0:00 -bash
2628 pts/0 R+ 0:00 ps x
```
### R — Запущенные или в очереди
Процессы в этом состоянии либо запущены, либо находятся в очереди для запуска.
Что это значит?
Когда вы компилируете код, то на выходе получаете исполняемый файл в виде инструкций для процессора. При запуске, этот файл помещается в память, где процессор выполняет эти инструкции, проще говоря занимается вычислениями.
### S — Прерываемый сон
При этом состоянии инструкции программы не исполняются в процессоре, проще говоря спят. Процесс ждёт события или какого нибудь условия для продолжения. После того, как событие произошло, состояние меняется на запущенное.
Для примера можно взять утилиту **sleep** из coreutils. Он будет находится в состоянии сна определенное количество секунд.
```
$ sleep 1000 &
[1] 10089
$ ps f
PID TTY STAT TIME COMMAND
3514 pts/1 Ss 0:00 -bash
10089 pts/1 S 0:00 \_ sleep 1000
10094 pts/1 R+ 0:00 \_ ps f
```
Так это *прерываемый* сон, как же его можно прервать? С помощью сигнала.
Послать сигнал с помощью **htop** можно нажав клавишу *F9* и выбрав нужный вид сигнала в меню.
Передача сигнала, так же известна как команда **kill**, потому что это на самом деле системный вызов, который может послать сигнал процессу. Существует одноимённая программа **/bin/kill**, которая может исполнить системномный вызов из пользовательского окружения и по умолчанию посылает сигнал **TERM**, который уничтожает процесс, убивает его.
Сигнал это всего лишь число. Числа сложно запомнить, поэтому их назвали именами. Их имена обычно пишут заглавными буквами и могут быть с префиксом **SIG**.
Часто используемые сигналы, это: **INT**, **KILL**, **STOP**, **CONT**, **HUP**.
Попробуем прервать спящий процесс, послав ему сигнал **INT**, он же **SIGINT**, просто **2**, или **сигнал прерывания с терминала**.
```
$ kill -INT 10089
[1]+ Interrupt sleep 1000
```
Этот же сигнал посылается, если нажать комбинацию *CTRL+C*. **bash** пошлёт сигнал **SIGINT** процессу на переднем плане, точно так же, как мы это сделали вручную.
Кстати, в **bash** команда **kill** встроена, хотя во многих системах есть программа **/bin/kill**. Почему? Чтобы можно было «убить» процесс даже если превышен лимит на количество создаваемых процессов.
Следующие команды идентичны:
* kill -INT 10089
* kill -2 10089
* /bin/kill -2 10089
Другой полезный сигнал это **SIGKILL** или **9**. Вы, возможно, использовали его, когда не могли завершить процесс безудержным кликаньем *CTRL+C*.
При написании программы, можно эти сигналы ловить и создавать функции, которые будут запускаться когда соответствующий сигнал получен. Например, можно очищать память или же аккуратно завершить работу. Поэтому отправка сигнала, такого как сигнал прерывания с терминала, не означает что процесс будет прекращён.
Возможно, вы встречали такое исключение при запуске скриптов на Python:
```
$ python -c 'import sys; sys.stdin.read()'
^C
Traceback (most recent call last):
File "", line 1, in
KeyboardInterrupt
```
Но существует сигнал способный остановить процесс, не дав ему возможности на него ответить. Это сигнал **KILL**.
```
$ sleep 1000 &
[1] 2658
$ kill -9 2658
[1]+ Killed sleep 1000
```
### D — непрерываемый сон
В отличии от прерываемого сна, процессы в таком состоянии невозможно остановить с помощью сигналов. Поэтому многие не любят это состояние.
При этом состоянии процесс ожидает и не может быть прерван, например, если событие продолжения вот вот наступит, такое как чтение/запись на диск. Как правило, это происходит за доли секунды.
[На StackOverflow](http://stackoverflow.com/questions/223644/what-is-an-uninterruptable-process) есть хороший ответ:
> Непрерываемые процессы обычно находятся в ожидании IO после page fault. Процесс не может быть прерван в это время сигналом, потому что не сможет их обработать. Если бы он мог, то снова возник бы page fault и всё бы осталось как есть.
Другими словами, это может случиться, если, например, использовать протокол сетевого доступа NFS и требуется время для чтения/записи с/на него.
По своему опыту могу сказать, что такое случается когда процесс часто подкачивается, т.е. для него недостаточно свободной памяти.
Попробуем вызвать это состояние.
**8.8.8.8** это публичный DNS от Google. Там нет NFS, но это нас не остановит.
```
$ sudo mount 8.8.8.8:/tmp /tmp &
[1] 12646
$ sudo ps x | grep mount.nfs
12648 pts/1 D 0:00 /sbin/mount.nfs 8.8.8.8:/tmp /tmp -o rw
```
Как же узнать, что заставляет процесс оказаться в таком состоянии? **strace**!
Вызовим **strace** для команды **ps** выше.
```
$ sudo strace /sbin/mount.nfs 8.8.8.8:/tmp /tmp -o rw
...
mount("8.8.8.8:/tmp", "/tmp", "nfs", 0, ...
```
И тут мы увидим, что системный вызов **mount** блокирует процесс.
А **mount**, кстати можно вызвать с опцией **intr**, чтобы его можно было прерывать: **sudo mount 8.8.8.8:/tmp /tmp -o intr**.
### Z — Зомби процесс
Когда процесс заканчивает свою работу с помощью **exit** и у неё остаются дочерние процессы, дочерние процессы становятся в состоянии зомби.
* Абсолютно нормально, если зомби процесс существует недолго
* Зомби процессы которые существуют долгое время, могут говорить о баге в программе
* Зомби процессы не используют память, только лишь ID процесса
* Зомби процесс нельзя «убить»
* Можно вежливо попросить родительский процесс избавиться от зомби (послав **SIGCHLD**)
* Можно завершить родительский процесс, чтобы избавиться от обоих
Я продемонстрирую это, написав небольшой код на С.
```
#include
#include
#include
int main() {
printf("Running\n");
int pid = fork();
if (pid == 0) {
printf("Я родительский процесс\n");
printf("Родительский процесс завершает работу\n");
exit(0);
} else {
printf("Я дочерний процесс\n");
printf("Дочерний процесс спит\n");
sleep(20);
printf("Дочерний процесс завершён\n");
}
return 0;
}
```
Устанавливаем компилятор С, GNU C Compiler (GCC).
```
sudo apt install -y gcc
```
Скомпилируем и запустим программу
```
gcc zombie.c -o zombie
./zombie
```
Посмотрим на иерархию процессов
```
$ ps f
PID TTY STAT TIME COMMAND
3514 pts/1 Ss 0:00 -bash
7911 pts/1 S+ 0:00 \_ ./zombie
7912 pts/1 Z+ 0:00 \_ [zombie]
1317 pts/0 Ss 0:00 -bash
7913 pts/0 R+ 0:00 \\_ ps f
```
У нас есть зомби! Когда родительский процесс завершается, зомби исчезает.
```
$ ps f
PID TTY STAT TIME COMMAND
3514 pts/1 Ss+ 0:00 -bash
1317 pts/0 Ss 0:00 -bash
7914 pts/0 R+ 0:00 \_ ps f
```
Если заменить **sleep(20)** инструкцией **while (true)**, зомби исчезнет сразу.
При вызове **exit**, освобождается вся занимаемая память и ресурсы, чтобы они были доступны другим. Почему же нужны тогда процессы зомби?
У родительских процессов есть возможность узнать код завершения работы дочерних процессов (в обработчике сигналов) с помощью системного вызова **wait**. Если дочерний процесс спит, то родительский сперва подождёт.
Почему же тогда принудительно не разбудить процесс и завершить его? По той же причине, по которой вы не избавитесь от своего ребёнка, если он вас не слушается. Всё может закончится плохо.
### T — Остановлен сигналом управления заданиями
Я открыл два терминала и могу посмотреть на свои процессы командой **ps u**.
```
$ ps u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
ubuntu 1317 0.0 0.9 21420 4992 pts/0 Ss+ Jun07 0:00 -bash
ubuntu 3514 1.5 1.0 21420 5196 pts/1 Ss 07:28 0:00 -bash
ubuntu 3528 0.0 0.6 36084 3316 pts/1 R+ 07:28 0:00 ps u
```
Ниже я опущу упоминание процессов **-bash** и **ps**.
Теперь в одном из терминалов запустим **cat /dev/urandom > /dev/nul**. Его состояние будет **R+**, из чего следует что он активен.
```
$ ps u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
ubuntu 3540 103 0.1 6168 688 pts/1 R+ 07:29 0:04 cat /dev/urandom
```
Нажмём *CTRL+Z*, чтобы остановить процесс.
```
$ # CTRL+Z
[1]+ Stopped cat /dev/urandom > /dev/null
$ ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
ubuntu 3540 86.8 0.1 6168 688 pts/1 T 07:29 0:15 cat /dev/urandom
```
Сейчас, он в состоянии **T**. Если нужно продолжить процесс, то можно вызвать **fg** в первом терминале.
Есть и другой способ останова процессов, для этого нужно послать им сигнал **STOP** с помощью **kill**, а для продолжения, соответственно, сигнал **CONT**.
### t — Остановлен отладчиком
Для начала установим отладчик GNU Debugger (gdb)
```
sudo apt install -y gdb
```
Запустим программу для прослушивания порта 1234.
```
$ nc -l 1234 &
[1] 3905
```
Он находится в состоянии сна, потому как ждёт входящих сообщений.
```
$ ps u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
ubuntu 3905 0.0 0.1 9184 896 pts/0 S 07:41 0:00 nc -l 1234
```
Запустим отладчик и привяжем его к процессу с PID 3905.
```
sudo gdb -p 3905
```
Теперь процесс будет прослеживаться [trace] в отладчике и его состояние изменится на **t**.
```
$ ps u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
ubuntu 3905 0.0 0.1 9184 896 pts/0 t 07:41 0:00 nc -l 1234
```
Время обработки процесса
========================
Linux — многозадачная операционная система, это означает что даже если процессор один, то можно одновременно запускать на нём несколько заданий. Например, можно подключиться к удалённому серверу через SSH и посмотреть на вывод **htop**, а при этом сам сервер будет показывать ваш блог читателям в интернете.
Как же возможно, что единственный процессор может одновременно выполнять несколько заданий?
Разделением времени.
Каждый процесс выполняется определённый интервал времени, при котором другие приостановлены, затем выполняется следующий процесс и т.д.
Как правило, интервал времени выполнения составляет миллисекунды, поэтому пользователь этого и не заметит, если, конечно же, система не нагружена.
Любезность и приоритет процессов
================================
Когда количество заданий превышает количество процессоров, но выполнить их все необходимо, нужно каким то образом определить порядок их выполнения. За это отвечает планировщик заданий.
Планировщик в ядре Linux решает какой процесс выбрать из очереди на запуск и это зависит от результата алгоритма, заложенного в ядре.
Пользователь, как правило, не может прямо влиять на планирование, но может подсказать какой из процессов ему особо важен и планировщик, возможно, прислушается к нему.
Любезность или приоритет nice (**NI**) это приоритет процесса в пространстве пользователя, варьирующаяся от -20, что есть самый высокий приоритет, до 19, соответственно наименьший приоритет. Это может запутать, но представьте это именно как любезность, т.е. чем процесс любезнее, тем он уступчивее другим процессам.
Из того, что я прочёл на StackOverflow и других сайтах, следует что увеличение любезности процесса на 1 ведёт к уступке 10% времени работы процессора.
Приоритет (**PRI**) же в свою очередь это параметр приоритета в пространстве ядра. Приоритет варьируется от 0 до 139. Приоритеты от 0 до 99 зарезервированы для процессов реального времени, а выше, т.е от 100 до 139, для пользовательских.
Можно изменить любезность процесса, и тогда, возможно, ядро примет это к сведению, но сам приоритет менять нельзя.
Соотношение любезности и приоритета следующее: **PR = 20 + NI.**
Таким образом область определения **PR = 20 + (-20 to +19)** лежит в отрезке от 100 до 139.
Можно установить любезность процесса непосредственно перед запуском.
```
nice -n любезность program
```
А менять любезность во время выполнения можно с помощью **renice**.
```
renice -n niceness -p PID
```
<http://askubuntu.com/questions/656771/process-niceness-vs-priority>
Память — VIRT/RES/SHR/MEM
=========================
У процессов создаётся иллюзия, что память кроме них никто не использует. Такая иллюзия — результат работы виртуальной памяти.
Процессы не имеют прямого доступа к физической памяти. Для них выделяется участок виртуальной памяти, адреса в которой, проецируются ядром уже на адреса в физической памяти, либо на диск. Поэтому, иногда кажется, что процессы используют больше памяти, чем установлено в системе.
Я хочу сказать, что из-за этого не совсем легко понять сколько же именно памяти использует процесс. А что насчёт общих [shared] библиотек и памяти, выгруженной на диск? Но, к счастью, ядро и, в частности, **htop** позволяют извлечь некоторую информацию чтобы понять аппетит процесса по отношению к памяти.
### VIRT/VSZ — Виртуальный образ
Общее количество памяти, занимаемая процессом. Оно включает в себя весь код, данные, общие библиотеки, страницы которые были перемещены на диск, а также страницы, которые проецировались ядром, но не были использованы.
Таким образом **VIRT** это всё, что используется процессом.
Если приложение запрашивает 1 Гб памяти, но использует при этом только 1 Мб, то память **VIRT** будет отображаться всё равно как 1 Гб. Даже если оно вызовет mmap для файла весом в 1 Гб и никогда им не воспользуется, то **VIRT** всё равно останется 1 Гб.
В большинстве случаев этот показатель бесполезен.
### RES/RSS — Резидентная память
Память **RSS** [resident set size] это область, которая не выгружена на диск и находится в оперативной памяти.
**RES**, возможно, лучше отображает реальное использование памяти процессора чем **VIRT**, но нужно иметь ввиду:
* Туда не включена память, выгруженная на диск
* Некоторая память может быть совместно используемой несколькими процессами
Если процесс использует 1 Гб памяти и вызывает **fork()**, то в результате у обоих процессов значение **RES** будет 1 Гб, в то время как в оперативной памяти будет занято только 1 Гб, потому что в Linux есть механизм копирования при записи [copy-on-write].
### SHR — Разделяемая память
Объём памяти, который может быть совместно использован другими процессами.
```
#include
#include
#include
int main() {
printf("Запуск\n");
sleep(10);
size\_t memory = 10 \* 1024 \* 1024; // 10 MB
char\* buffer = malloc(memory);
printf("Выделено 10M\n");
sleep(10);
for (size\_t i = 0; i < memory/2; i++)
buffer[i] = 42;
printf("Использовано 5M\n");
sleep(10);
int pid = fork();
printf("Новый поток\n");
sleep(10);
if (pid != 0) {
for (size\_t i = memory/2; i < memory/2 + memory/5; i++)
buffer[i] = 42;
printf("доп. 2M потомку\n");
}
sleep(10);
return 0;
}
```
Затем
```
fallocate -l 10G
gcc -std=c99 mem.c -o mem
./mem
```
И
```
Процесс Сообщение VIRT RES SHR
главный Запуск 4200 680 604
главный Выделено 10M 14444 680 604
главный Использовано 5M 14444 6168 1116
главный Новый поток 14444 6168 1116
потомок Новый поток 14444 5216 0
главный доп. 2M потомку 8252 1116
потомок доп. 2M потомку 5216 0
```
*(прим. Этот раздел не дописан до конца, как только статья обновится, я опубликую обновления)*
### MEM% — Использование памяти
Процент использования физической памяти. Это **RES**, делённый на общий объём оперативной памяти.
Если, например, **RES** составляет 200М и в системе установлено 8 Гб памяти, то **MEM%** будет 200/8192\*100 = **2.4%**
Процессы
========
Я запустил виртуальную машину с Ubuntu Server в Digital Ocean. Какие же процессы запускаются при старте системы? Необходимы ли они?
Ниже приведён анализ процессов, которые запускаются на чистой версии машины с Ubuntu Server 16.04.1 LTS x64 в Digital Ocean.
### До
### /sbin/init
Эта программа координирует все остальные приложения при запуске и конфигурирует окружение пользователя. После запуска, она становится родителем или прародителем всех автоматически запускающихся процессов.
Это же **systemd**?
```
$ dpkg -S /sbin/init
systemd-sysv: /sbin/init
```
Да, он самый. Что произойдёт, если его остановить? Ничего.
### /lib/systemd/systemd-journald
**systemd-journald** это системная служба, которая собирает и сохраняет логи. Она создаёт структурированные, проиндексированный журналы на основе информации, полученной с разных источников и управляет ими.
Другими словами,
Одним из основных преимуществ **journald** является замена обычных текстовых файлов логов специально отформатированными структурированными сообщениями. Это позволяет администраторам эффективнее работать с журналами событий.
Если нужно найти событие, лучше использовать **journalctl**.
* **journalctl \_COMM=sshd** поиск по sshd
* **journalctl \_COMM=sshd -o json-pretty** поиск по sshd в JSON
* **journalctl --since «2015-01-10» --until «2015-01-11 03:00»**
* **journalctl --since 09:00 --until «1 hour ago»**
* **journalctl --since yesterday**
* **journalctl -b** история с момента запуска системы
* **journalctl -f** чтобы следить за логами
* **journalctl --disk-usage**
* **journalctl --vacuum-size=1G**
Впечатляюще. Этот процесс, кажется, нельзя остановить или убрать, можно лишь отключить ведение истории.
### /sbin/lvmetad -f
Демон **lvmetad** кэширует метаданные LVM, чтобы команды LVM получали доступ к метаданным без сканирования диска. Кэширование помогает избежать возможного вмешивания в работу других приложений и сэкономить время сканирования диска.
Но что такое LVM [Logical Volume Management] (Менеджер логических томов)? Можно считать, что LVM это динамические разделы, что подразумевает создание/изменение/удаление разделов, так называемых «логических томов» из командной строки на лету, без надобности перезагрузки системы.
Звучит так, что нужен он только если пользоваться LVM.
```
$ lvscan
$ sudo apt remove lvm2 -y --purge
```
### /lib/systemd/udevd
**systemd-udevd** следит за событиями **uevents** ядра. Для каждого события, **systemd-udevd** запускает соответствующую инструкцию на основе правил в **udev**.
**udev** это диспетчер устройств ядра Linux. Как преемник **devfsd** и **hotplug**, **udev** в основном работает с устройствами в каталоге **/dev**.
Я не уверен о его необходимости в виртуальной среде.
### /lib/systemd/timesyncd
**systemd-timesyncd** это системная служба которая синхронизирует локальное время с удалённым сервером NTP.
Он заменил **ntpd**.
```
$ timedatectl status
Local time: Fri 2016-08-26 11:38:21 UTC
Universal time: Fri 2016-08-26 11:38:21 UTC
RTC time: Fri 2016-08-26 11:38:20
Time zone: Etc/UTC (UTC, +0000)
Network time on: yes
NTP synchronized: yes
RTC in local TZ: no
```
Посмотрим на открытые порты системы:
```
$ sudo netstat -nlput
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 2178/sshd
tcp6 0 0 :::22 :::* LISTEN 2178/sshd
```
Красота! В Ubuntu 14.04 это выглядело так:
```
$ sudo apt-get install ntp -y
$ sudo netstat -nlput
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 1380/sshd
tcp6 0 0 :::22 :::* LISTEN 1380/sshd
udp 0 0 10.19.0.6:123 0.0.0.0:* 2377/ntpd
udp 0 0 139.59.256.256:123 0.0.0.0:* 2377/ntpd
udp 0 0 127.0.0.1:123 0.0.0.0:* 2377/ntpd
udp 0 0 0.0.0.0:123 0.0.0.0:* 2377/ntpd
udp6 0 0 fe80::601:6aff:fxxx:123 :::* 2377/ntpd
udp6 0 0 ::1:123 :::* 2377/ntpd
udp6 0 0 :::123 :::* 2377/ntpd
```
Брр.
### /usr/sbin/atd -f
**atd** запускает задания, назначенные в определённое время с помощью **at**.
В отличии от **cron**, который исполняет задания с периодичностью, **at** единовременно выполняет задание в определённое время.
```
$ echo "touch /tmp/yolo.txt" | at now + 1 minute
job 1 at Fri Aug 26 10:44:00 2016
$ atq
1 Fri Aug 26 10:44:00 2016 a root
$ sleep 60 && ls /tmp/yolo.txt
/tmp/yolo.txt
```
Кстати, я ни разу не использовал его до этого момента.
```
sudo apt remove at -y --purge
```
### /usr/lib/snapd/snapd
Snappy Ubuntu Core это новое исполнение Ubuntu с обновлёнными решениями — минимальный образ сервера с теми же библиотеками что и Ubuntu, но приложения предоставляются через более простой механизм.
Что?
Разработчики нескольких дистрибутивов Linux и компании призвали к сотрудничеству для создания универсального формата «snap» для пакетов Linux, чтобы один и тот же бинарный пакет успешно и безопасно работал на любом компьютере, сервере, облаке и устройстве с Linux.
Оказывается, это упрощенный пакет **deb**, где нужно прикреплять все зависимости. Я никогда не пользовался snappy для установки или создания приложений на серверах.
```
sudo apt remove snapd -y --purge
```
### /usr/bin/dbus-daemon
D-Bus — система межпроцессного взаимодействия, которая позволяет приложениям в операционной системе общаться друг с другом.
Я так понимаю, что это нужно только для домашнего окружения, но зачем это серверу веб приложений?
```
sudo apt remove dbus -y --purge
```
Интересно, который сейчас час и синхронизируется ли время с NTP?
```
$ timedatectl status
Failed to create bus connection: No such file or directory
```
Упс, возможно, это стоило оставить.
### /lib/systemd/systemd-logind
**systemd-logind** это системная служба, управляющая авторизациями в систему.
### /usr/sbin/cron -f
**cron** — демон для запуска заданий по расписанию (Vixie Cron)
**-f** — не демонизировать процесс.
С помощью **cron** можно запускать задания с периодичностью.
Чтобы редактировать расписание, можно использовать **crontab -e**, я предпочитаю каталоги **/etc/cron.hourly**, **/etc/cron.daily**, и т.д.
А историю запуска можно найти так:
* **grep cron /var/log/syslog** или
* **journalctl \_COMM=cron** или даже так
* **journalctl \_COMM=cron --since=«date» --until=«date»**
Наверняка, **cron** вам понадобится.
Но если нет, то перед удалением, его нужно остановить и отключить
```
sudo systemctl stop cron
sudo systemctl disable cron
```
Иначе при попытке удаления командой **apt remove cron**, он попытается установить **postfix**!
```
$ sudo apt remove cron
The following packages will be REMOVED:
cron
The following NEW packages will be installed:
anacron bcron bcron-run fgetty libbg1 libbg1-doc postfix runit ssl-cert ucspi-unix
```
Похоже, что cron нужен сервер почты для рассылки.
```
$ apt show cron
Package: cron
Version: 3.0pl1-128ubuntu2
...
Suggests: anacron (>= 2.0-1), logrotate, checksecurity, exim4 | postfix | mail-transport-agent
$ apt depends cron
cron
...
Suggests: anacron (>= 2.0-1)
Suggests: logrotate
Suggests: checksecurity
|Suggests: exim4
|Suggests: postfix
Suggests:
...
exim4-daemon-heavy
postfix
```
### /usr/sbin/rsyslogd -n
Rsyslogd — утилита помогающая вести логи.
Другими словами, это то, что создаёт файлы в **/var/log/**, такие как **/var/log/auth.log** для сообщений о попытках аутентификации пользователя через SSH.
Файлы конфигурации тут **/etc/rsyslog.d**.
Можно настроить **rsyslogd** таким образом, что он будет отправлять файлы на удалённый сервер, создав тем самым централизованную систему логирования.
Командой **logger** можно сохранить сообщение в **/var/log/syslog** в фоновых скриптах, таких как автозагрузчики.
```
#!/bin/bash
logger Starting doing something
# NFS, get IPs, etc.
logger Done doing something
```
Да, но у нас уже есть **systemd-journald**. Нужен ли ещё и **rsyslogd**?
**Rsyslog** и **Journal**, это два приложения протоколирования в системе. У них есть несколько различающихся функций, которые более предпочтительны в той или иной ситуации. В большинстве случаев лучше сочетать возможности обоих, например, для создания структурированных сообщений и сохранения их в файлах. Интерфейс связи для кооперирования предоставляется модулями ввода и вывода **Rsyslog** и сокетом **Journal**.
И всё же? На всякий случай, я его оставлю.
### /usr/sbin/acpid
**acpid** — демон для усовершенствованного интерфейса управления конфигурацией и питанием.
**acpid** нужен чтобы уведомлять пользовательские программы о событиях ACPI. По умолчанию, он запускается при старте системы в фоновом режиме.
**ACPI** это интерфейс с открытым стандартом, который используют операционные системы чтобы управлять аппаратными средствами, чтобы, например, отключать неиспользуемые девайсы для экономии энергии.
Но у меня виртуальная машина и я не собираюсь отключать устройства. Ради эксперимента я попробую удалить его.
```
sudo apt remove acpid -y --purge
```
Мне удалось успешно перезагрузить машину при помощи **reboot**, но после **halt**, Digital Ocean всё ещё думал, что машина включена и мне пришлось выключить её через веб интерфейс провайдера.
Поэтому, я бы оставил эту службу.
### /usr/bin/lxcfs /var/lib/lxcfs/
**Lxcfs** это своего рода предохраняющая файловая система. В Ubuntu 15.04 она используется по двум причинам: первое, визуализировать некоторые файлы в **/proc** и второе, ограничить доступ к файловой системе **cgroup** хоста.
В итоге, можно создавать контейнеры привычным образом с **lxc-create** и у контейнера будут правильные значения **uptime**, **top**, и т.д. Файловая система позволяет контейнеру больше вести себя как отдельная система, нежели без данной файловой системы.
Если не используете контейнеры LXC, то можно удалить с помощью
```
sudo apt remove lxcfs -y --purge
```
### /usr/lib/accountservice/accounts-daemon
**AccountsService** предоставляет интерфейсы D-Bus для манипуляций с учётными данными пользователей. Использование интерфейсов реализовано в командах **usermod(8)**, **useradd(8)** и **userdel(8)**.
Когда я удалил D-Bus, это сломало **timedatectl**. Мне интересно, что сломается, когда я удалю эту службу.
```
sudo apt remove accountsservice -y --purge
```
Время покажет.
### /sbin/mdadm
**mdadm** это утилита Linux для администрирования и мониторинга программных **RAID** устройств.
RAID — технология виртуализации данных, которая объединяет несколько дисков в один логический элемент. У RAID есть 2 основные задачи: 1) увеличения объёма логического диска: RAID 0. Если объединить 2 диска по 500 Гб, то получится 1 Тб. 2) Избежать потерю данных если один из дисков откажет: например, RAID 1, RAID 5, RAID 6, и RAID 10.
Можно удалить с помощью:
```
sudo apt remove mdadm -y --purge
```
### /usr/lib/policykit-1/polkitd --no-debug
**polkit** это фреймворк авторизации. Я так понимаю, что это своего рода **sudo** и он позволяет непривилегированным пользователям выполнять определённые команды от имени администратора, например, перезагружать систему.
Но у меня сервер. Можно удалить с помощью
```
sudo apt remove policykit-1 -y --purge
```
Мне до сих пор интересно, что из-за него сломается.
### /usr/sbin/sshd -D
**sshd** (OpenSSH Daemon) демон для ssh. С **-D** он не будет переведен в режим работы демона. Это позволит легче осуществлять мониторинг **sshd**.
### /sbin/iscsid
**iscsid** это системная служба, запускаемая в фоновом режиме, работающая с конфигурацией iSCSI и управляющая подключениями.
Я никогда не слышал о iSCSI:
iSCSI — протокол, который базируется на TCP/IP и разработан для установления взаимодействия и управления системами хранения данных, серверами и клиентами.
Можно удалить с
```
sudo apt remove open-iscsi -y --purge
```
### /sbin/agetty --noclear tty1 linux
**agetty** — Linux альтернатива **getty**.
**getty** это Unix программа, работающая на системах с физическими или виртуальными терминалами. При подключении, она запрашивает имя пользователя и запускает программу **login** для аутентификации.
Это позволяет войти в систему при физическом доступе к нему. В Digital Ocean, например, можно открыть консоль из браузера и подключиться к этому терминалу (кажется через VNC).
Раньше, можно было наблюдать как несколько терминалов стартовали систему (настроенных в **/etc/inittab**), но сейчас всё делает **systemd**.
Ради эксперимента, я удалил файл конфигурации, который запускает и создаёт **agetty**:
```
sudo rm /etc/systemd/system/getty.target.wants/getty@tty1.service
sudo rm /lib/systemd/system/getty@.service
```
При перезагрузке сервера, я по прежнему мог аутентифицироваться через SSH, но не через веб консоль провайдера.
### sshd: root@pts/0, -bash и htop
**sshd: root@pts/0** означает, что была установлена SSH сессия для пользователя **root** в псевдотерминале (**pts**) №**0**.
**bash** это командная оболочка, которую я использую. Но почему перед **bash** стоит дефис? Пользователь Reddit под ником hirnbrot объяснил:
Там стоит дефис, потому что запуск его как "-bash", активирует login-оболочку. Login-оболочка это такая оболочка, у которой первый символ аргумента под номером 0 дефис, либо он запущен с параметром --login. В результате используются разные файлы настроек.
**htop** — интерактивная программа для просмотра процессов, которая изображена на скриншоте.
После
=====
```
sudo apt remove lvm2 -y --purge
sudo apt remove at -y --purge
sudo apt remove snapd -y --purge
sudo apt remove lxcfs -y --purge
sudo apt remove mdadm -y --purge
sudo apt remove open-iscsi -y --purge
sudo apt remove accountsservice -y --purge
sudo apt remove policykit-1 -y --purge
```
Крайняя степень:
================
```
sudo apt remove dbus -y --purge
sudo apt remove rsyslog -y --purge
sudo apt remove acpid -y --purge
sudo systemctl stop cron && sudo systemctl disable cron
sudo rm /etc/systemd/system/getty.target.wants/getty@tty1.service
sudo rm /lib/systemd/system/getty@.service
```
Я так же попробовал установить программное обеспечение по своей инструкции [об автоматической установке WordPress на Ubuntu Server](https://peteris.rocks/blog/unattended-installation-of-wordpress-on-ubuntu-server/) и всё работало.
Тут nginx, PHP7 и MySQL.
За кадром
=========
Исходный код
------------
Иногда не достаточно только **strace**. Другой способ посмотреть, что же программа делает это взглянуть на исходный код
Сперва, надо найти где начать искать.
```
$ which uptime
/usr/bin/uptime
$ dpkg -S /usr/bin/uptime
procps: /usr/bin/uptime
```
Тут видно, что **uptime** находится в **/usr/bin/uptime** и что в Ubuntu это часть пакета **procps**.
Затем, можно зайти на [packages.ubuntu.com](http://packages.ubuntu.com/) и найти этот пакет.
Страница **procps**: <http://packages.ubuntu.com/source/xenial/procps>
Внизу есть ссылки на репозитории с исходными кодами:
* Debian Package Source Repository git://git.debian.org/collab-maint/procps.git
* Debian Package Source Repository (для браузера) <https://anonscm.debian.org/cgit/collab-maint/procps.git/>
Дескрипторы файлов и перенаправление
------------------------------------
Если нужно перенаправить стандартный поток ошибок (**stderr**) в стандартный выходной поток, нужно это делать с **2&>1** или **2>&1**?
Можно запомнить положение амперсанда пониманием того, что **echo нечто > файл** запишет **нечто** в файл **файл**. Это тоже самое, что **echo нечто 1> файл**. А вот **echo нечто 2> файл** запишет поток ошибок в **файл**.
Если написать **echo нечто 2> 1**, то поток ошибок перенаправится в файл, с именем **1**.
Если поставить перед **1** амперсанд **&**, то это будет означать, что **1** это не имя файла, а идентификатор потока. Поэтому правильно **echo нечто 2>&1**.
Цвета в PuTTY
-------------
Если некоторые элементы сверху не отображаются при использовании PuTTY, то можно это исправить так.
1. Нажмите правой кнопкой на заголовок окна
2. Выберите *Change settings*
3. Перейдите в *Window → Colours*
4. Отметьте опцию *Both*
5. Нажмите *Apply*
Командная оболочка на C
-----------------------
Попробуем написать очень простую командную оболочку на C, которая бы использовала системные вызовы **fork**/**exec**/**wait**. Программа **shell.c**:
```
#include
#include
#include
#include
#include
int main() {
printf("Добро пожаловать\n");
char line[1024];
while (1) {
printf("> ");
fgets(line, sizeof(line), stdin);
line[strlen(line)-1] = '\0'; // strip \n
if (strcmp(line, "exit") == 0) // shell built-in
break;
int pid = fork();
if (pid == 0) {
printf("Запуск: %s\n", line);
if (execlp(line, "", NULL) == -1) {
printf("Ошибка!\n");
exit(1);
}
} else if (pid > 0) {
int status;
waitpid(pid, &status, 0);
printf("Потомок вышел с кодом %d\n", WEXITSTATUS(status));
} else {
printf("Ошибка!\n");
break;
}
}
return 0;
}
```
Скомпилируем программу:
```
gcc shell.c -o shell
```
И запустим её:
```
$ ./shell
Добро пожаловать
> date
Запуск: date
Thu Dec 1 14:10:59 UTC 2016
Потомок вышел с кодом 0
> true
Запуск: true
Потомок вышел с кодом 0
> false
Запуск: false
Потомок вышел с кодом 1
> exit
```
Вы когда нибудь интересовались почему при запуске программы в фоновом режиме вы видите, что она завершила свою работу, только после нажатия **Enter**?
```
$ sleep 1 &
[1] 11686
$ # нажали Enter
[1]+ Done sleep 1
```
Это потому, что оболочка ждёт ввода. Только после ввода команды, оболочка проверяет состояния процессов в фоне и выводит, что они завершились.
От себя
=======
Спасибо, если дочитали перевод до конца. Статья мне показалась очень интересной и полезной. Хочу отметить, что лично мне нравятся статьи, в которых описывается то, о чём в них идёт речь и ещё объясняется всё, что около. Тут много текста, и, возможно, я что либо упустил, приврал или заставил вас съежиться от корявого перевода. Буду рад, если Вы сообщите об этом в личном сообщении, а комментарии останутся только для обсуждения по теме статьи. | https://habr.com/ru/post/316806/ | null | ru | null |
# Пагинация во Vue.js
Привет, Хабр! Представляю вашему вниманию перевод статьи "[Pagination in Vue.js](https://medium.com/@denny.headrick/pagination-in-vue-js-4bfce47e573b)" автора Denny Headrick.
Пагинация увеличивает UX, позволяя пользователям визуализировать данные в небольших блоках или на страницах. Вот и компонент Vue.js можно сделать с разбивкой по страницам, который позволит нам просматривать только часть наших данных за раз.
Сначала я буду добавлять кусочек за кусочком в свой JavaScript объект. А затем покажу **template** (шаблон)
Из всех локальных данных, мне нужны, только данные - номер страницы.
```
data(){
return {
pageNumber: 0 // по умолчанию 0
}
}
```
Для **props** (свойств), передача данных является обязательной, но я также возьму **size** аргумент для максимального количества записей.
```
props:{
listData:{
type:Array,
required:true
},
size:{
type:Number,
required:false,
default: 10
}
}
```
Для моей реализации я буду использовать методы для перехода на **previous** (предыдущую) и **next** (следующую) страницы:
```
methods:{
nextPage(){
this.pageNumber++;
},
prevPage(){
this.pageNumber--;
}
}
```
Быстрое вычисляемое свойство **computed**, чтобы выяснить, сколько есть страниц:
```
pageCount(){
let l = this.listData.length,
s = this.size;
// редакция переводчика спасибо комментаторам
return Math.ceil(l/s);
// оригинал
// return Math.floor(l/s);
}
```
Теперь вычисленное свойство (**computed**) **paginatedData** - это место, где все объединяется. Это отфильтрованные данные, которые будут отображаться.
```
paginatedData(){
const start = this.pageNumber * this.size,
end = start + this.size;
return this.listData.slice(start, end);
}
```
*Редакция*: я изначально делал что-то ужасное и громоздкое, чтобы скопировать массив. Использование **.slice** - лучший подход. Спасибо, [Alexander Karelas](https://medium.com/@karjala?source=responses---------0----------------).
И наш **template** (шаблон)
```
* {{p.first}}
{{p.last}}
{{p.suffix}}
Previous
Next
```
Я хочу, чтобы кнопки работали, когда они только должны. Для кнопки **prevPage** я добавлю:
> :disabled=«pageNumber==0»
а для кнопки **nextPage** добавлю:
> :disabled=«pageNumber >= pagecount -1»
Рабочая демонстрация моего компонента:
Иногда бывает трудно переоценить ситуацию, но разбиение на страницы - это простая функция, которую мы можем предложить нашим пользователям без особых усилий.
Спасибо за прочтение!
*Denny Headrick - веб-разработчик USAF, который слишком сильно любит свою работу. В дополнение к разработке на различных платформах и Vue.js, когда он может, он любит вести блог изредка. Вы можете следить за ним в Twitter на @dennythecoder.* | https://habr.com/ru/post/417119/ | null | ru | null |
# Рисование собственных представлений (View) в Android
### Получите полный контроль над представлением и оптимизируйте его производительность
> **В преддверии старта курса** [**"Android Developer. Professional"**](https://otus.pw/QY0e/) **приглашаем всех желающих принять участие в открытом вебинаре на тему** [**"Пишем gradle plugin"**](https://otus.pw/0PXz/)**.**
>
> А пока делимся переводом полезного материала.
>
>
---
### Введение
Разработчики постоянно проектируют различные виды пользовательских интерфейсов с помощью XML, но в дополнение к этому можно довольно легко освоить создание собственных представлений, которые открывают новые преимущества и позволяют избежать повторного использования шаблонного кода.
В Android доступен широкий набор готовых виджетов и макетов для создания пользовательского интерфейса, однако они не могут удовлетворить все требования наших приложений. И здесь на помощь приходит возможность создания собственных представлений. Создав собственный подкласс представления, можно получить максимально полный контроль за внешним видом и функционалом экранного элемента.
Прежде чем приниматься за работу с собственными представлениями, полезно изучить [жизненный цикл представления](https://medium.com/@pavan.careers5208/the-life-cycle-of-a-view-in-android-6a2c4665b95e).
Зачем создавать собственные представления?
Чтобы реализовать собственное представление, в большинстве случаев понадобится больше времени, чем если использовать обычные представления. Создавать собственные представления стоит лишь в том случае, если нет другого, более простого способа реализовать нужную вам возможность или если у вас есть какие-либо из указанных ниже проблем, которые можно устранить за счет создания собственного представления.
1. Производительность: в вашем макете много представлений и вы хотите оптимизировать их, нарисовав одно, более легкое собственное представление.
2. Имеется сложная иерархия представлений, которую трудно использовать и поддерживать.
3. Необходимо создать специализированное представление, требующее рисования вручную.
#### Общий подход
Чтобы приступить к созданию компонентов для реализации собственных представлений, необходимо выполнить следующие основные шаги.
1. Создать класс, расширяющий базовый класс или подкласс представления.
2. Реализовать конструкторы, использующие атрибуты из XML-файла.
3. Переопределить некоторые методы родительского класса (onDraw(), onMeasure() и т. д.) в соответствии с нашими требованиями.
4. После выполнения этих шагов созданный расширяющий класс можно использовать вместо представления, на основе которого он был создан.
**Пример**
В одном из моих проектов мне нужно было создать круглый виджет TextView для отображения количества уведомлений. Чтобы достичь этой цели, нужно создать подкласс `TextView.`
Шаг 1. Создадим класс с именем `CircularTextView`.
Шаг 2. Расширим класс виджетаTextView. Здесь под `TextView` в IDE выдается ошибка, в которой сообщается, что у этого типа есть конструктор и он должен быть инициализирован.
Шаг 3. Добавим конструкторы в класс.
Это можно сделать двумя способами.
Первый способ добавления конструкторов в класс показан ниже.
Другой способ заключается в добавлении аннотации `@JvmOverloads` к вызову конструктора, как показано ниже.
Часто нас сбивает с толку то, что у представления есть несколько разных типов конструкторов.
**View(Context context)**
Простой конструктор для динамического создания представления из программного кода. Здесь параметр `context` — это контекст, в котором работает представление и через который можно получить доступ к текущей теме, ресурсам и т. д.
**View(Context context, @Nullable AttributeSet attrs)**
Конструктор, который вызывается при формировании представления из XML-файла. Он вызывается, когда представление создается из XML-файла, содержащего атрибуты представления. В этом варианте конструктора используется стиль по умолчанию (0), поэтому применяются только те значения атрибутов, которые есть в теме контекста и заданном наборе `AttributeSet`.
Шаг 4. Самый важный шаг в отрисовке собственного представления — это переопределение метода `onDraw()` и реализация необходимой логики отрисовки внутри этого метода.
Метод `OnDraw`(canvas: Canvas?) имеет параметр `Canvas` (холст), с помощью которого компонент представления может отрисовывать себя. Для рисования на холсте необходимо создать объект Paint.
Как правило, процесс рисования определяется двумя аспектами:
* что рисовать (определяется объектом Canvas);
* как рисовать (определяется объектом Paint).
Например, Canvas предоставляет метод для рисования линии, а Paint предоставляет методы для определения цвета этой линии. В нашем случае объект Canvas в классе `CircularTextView` предоставляет метод для рисования окружности, а объект Paint заполняет ее цветом. Проще говоря, Canvas определяет, какие фигуры можно нарисовать на экране, а Paint определяет свойства нарисованных фигур — цвет, стиль, шрифт и т. д.
Давайте займемся кодом. Мы создаем объект Paint и присваиваем ему некоторые свойства, а затем рисуем фигуру на холсте (объект Canvas), используя наш объект Paint. Метод `onDraw()` будет выглядеть так:
IDE показывает предупреждение о том, что следует избегать выделения объектов во время операций отрисовки или операций с макетом. Это предупреждение возникает потому, что метод `onDraw()` много раз вызывается при отрисовке представления, в котором каждый раз создаются ненужные объекты. Поэтому, чтобы избежать ненужного создания объектов, мы вынесем соответствующую часть кода за пределы метода `onDraw()`, как показано ниже.
При выполнении отрисовки всегда помните о том, что следует повторно использовать объекты вместо создания новых. Ваша IDE может указать на потенциальные проблемы, но полагаться на нее не стоит. Например, она не сможет отследить случай, когда объекты создаются внутри методов, вызываемых из метода `onDraw()`. Поэтому лучше проверять все самостоятельно.
Шаг 5. Мы закончили с рисованием. Теперь давайте внесем этот класс представления в XML.
Добавьте этот XML-макет в вашу активность (Activity) и запустите приложение. Вот что будет на экране.
Выглядит неплохо, правда? Теперь сделаем так, чтобы значение динамическому свойству цвета в `circlePaint` назначалось из активности, а также добавим контур к кружку. Для этого в классе `CircularTextView` необходимо создать несколько методов-сеттеров, чтобы можно было вызывать эти методы и устанавливать свойства динамически.
Для начала давайте реализуем настройку цвета отрисовки. Для этого создадим сеттер, как показано ниже.
```
fun setSolidColor(color: String) {
solidColor = Color.parseColor(color)
circlePaint?.color = solidColor
}
```
Теперь мы можем устанавливать цвет из нашей активности динамически, вызывая этот метод.
```
circularTextView.setSolidColor("#FF0000")
```
Неплохо, правда? Теперь давайте добавим контур к кружку. Контур будет задаваться двумя входными параметрами: шириной линии контура и ее цветом. Чтобы задать цвет линии контура, нам нужно создать объект Paint точно так же, как мы это делали для кружка. Чтобы задать ширину линии контура, мы создадим переменную, установим для нее нужное значение и используем его в методе `onDraw()`. Полный код будет выглядеть так:
Теперь в активности можно динамически настраивать эти атрибуты нужным образом.
Далее давайте запустим приложение, устанавливая различные цвета для нашего виджета.
Итак, теперь стало ясно, как динамически устанавливать свойства из активности, но возникает вопрос о том, как устанавливать атрибуты из XML. Продолжим наше исследование.
Для начала создадим файл с именем *attrs.xml* в папке *values*. Этот файл будет содержать все атрибуты для различных представлений, которые мы создаем сами. В приведенном ниже примере у нашего представления под названием `CircularTextView`имеется атрибут `ct_circle_fill_color`*, который принимает значение цвета. Аналогичным образом мы можем добавить и другие атрибуты.*
Затем нам нужно будет прочитать эти свойства в классе, который мы создали для реализации собственного представления. В блоке инициализации мы считываем набор атрибутов, как показано ниже.
```
val typedArray = getContext().obtainStyledAttributes(attrs, R.styleable.CircularTextView)
circlePaint?.color = typedArray.getColor(R.styleable.CircularTextView_ct_circle_fill_color,Color.BLUE)
typedArray.recycle()
```
*Теперь просто переходим к XML-макету и устанавливаем значение свойства, соответствующее нужному цвету, после чего запускаем приложение. На выходе мы увидим нужный результат.*
```
app:ct_circle_fill_color="@color/green"
```
В моем случае результат был таким:
*Примечание.* При рисовании не задавайте жестко размер вашего представления, так как им могут воспользоваться другие разработчики с применением других размеров. Рисуйте представление в соответствии с его текущим размером.
### Обновление представления
Итак, мы задали собственное представление. Если мы хотим обновлять представление при изменении какого-нибудь свойства или по какой-то другой причине, этого можно добиться двумя основными способами.
#### invalidate()
`invalidate()` — это метод, который инициирует принудительную перерисовку определенного представления. Проще говоря, метод `invalidate()` следует вызывать в случае, когда требуется изменение внешнего вида представления.
#### requestLayout()
Если в какой-то момент происходит изменение состояния представления, то метод `requestLayout()` сообщает системе представлений, что необходимо сделать перерасчет фаз «измерение» (Measure) и «макет» (Layout) для данного представления (измерение → макет → рисование). Проще говоря, метод `requestLayout()` следует вызывать в случае, когда требуется изменение границ представления.
Теперь, я надеюсь, вы знаете в общих чертах, как создавать собственные представления. Чтобы они демонстрировали отличную производительность, необходимо освоить все описанные здесь методы.
Благодарю за внимание!
---
> - [Узнать подробнее о курсе](https://otus.pw/QY0e/) "Android Developer. Professional".
>
>
> - [Записаться на открытый вебинар](https://otus.pw/0PXz/) "Пишем gradle plugin".
>
> | https://habr.com/ru/post/530618/ | null | ru | null |
# И снова про App Transport Security: что это и зачем
Привет, Хабр!
Меня зовут Юрий Шабалин, и, как я пишу в начале каждой своей статьи, мы разрабатываем платформу анализа защищенности мобильных приложений iOS и Android.
В этой статье мне бы хотелось затронуть тему безопасной конфигурации сетевого взаимодействия, а также немного расширить [предыдущую статью по SSL Pinning](https://habr.com/ru/company/swordfish_security/blog/661093/) для механизма защиты канала связи в iOS. А именно, я расскажу про App Transport Security: для чего он нужен, использовать ли его или отключать в приложениях, в чем его польза.
На эту тему существуют статьи на англоязычных ресурсах (здесь можно многие из них найти в разделе “[Ссылки](#%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)“), достаточно подробно эта тема раскрыта в документации Apple, но на русском я статей практически не встречал. Но даже если они есть, я с удовольствием добавлю свой материал с практическими примерами в эту небольшую копилку.
Оглавление
----------
* [Введение](#%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)
* [Проверка сервера](#%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0)
+ [ATS-совместимые шифры](#ATS-%D1%81%D0%BE%D0%B2%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D0%BC%D1%8B%D0%B5%20%D1%88%D0%B8%D1%84%D1%80%D1%8B)
+ [Тестирование серверной части](#%D0%A2%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%BD%D0%BE%D0%B9%20%D1%87%D0%B0%D1%81%D1%82%D0%B8)
* [App Transport Security](#App%20Transport%20Security)
+ [NSAllowsArbitraryLoads](#NSAllowsArbitraryLoads)
+ [NSAllowsLoadsForMedia](#NSAllowsLoadsForMedia)
+ [NSAllowsArbitraryLoadsInWebContent](#NSAllowsArbitraryLoadsInWebContent)
+ [NSAllowsLocalNetworking](#NSAllowsLocalNetworking)
+ [NSExceptionDomains](#NSExceptionDomains)
- [NSIncludesSubdomains](#NSIncludesSubdomains)
- [NSExceptionAllowsInsecureHTTPLoads](#NSExceptionAllowsInsecureHTTPLoads)
- [NSExceptionMinimumTLSVersion](#NSExceptionMinimumTLSVersion)
- [NSExceptionRequiresForwardSecrecy](#NSExceptionRequiresForwardSecrecy)
- [NSRequiresCertificateTransparency](#NSRequiresCertificateTransparency)
+ [Certificate Pinning](#Certificate%20Pinning)
* [Идеальная конфигурация](#%D0%98%D0%B4%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F%20%D0%BA%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D1%8F)
* [Примеры](#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B)
+ [Отключение ATS](#%D0%9E%D1%82%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20ATS)
+ [Работа с исключениями](#%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%20%D1%81%20%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8)
- [Отключение ATS для всех соединений кроме одного](#%D0%9E%D1%82%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20ATS%20%D0%B4%D0%BB%D1%8F%20%D0%B2%D1%81%D0%B5%D1%85%20%D1%81%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D0%B9%20%D0%BA%D1%80%D0%BE%D0%BC%D0%B5%20%D0%BE%D0%B4%D0%BD%D0%BE%D0%B3%D0%BE)
- [Отключение PFS для всех поддоменов](#%D0%9E%D1%82%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20PFS%20%D0%B4%D0%BB%D1%8F%20%D0%B2%D1%81%D0%B5%D1%85%20%D0%BF%D0%BE%D0%B4%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD%D0%BE%D0%B2)
- [Совмещение исключений](#%D0%A1%D0%BE%D0%B2%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B9)
* [Заключение](#%D0%97%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
* [Ссылки](#%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
Введение
--------
Apple от версии к версии iOS продолжает радовать нас различными нововведениями в части безопасности. В последнее время это больше связано с приватностью пользователей, их данными, местоположением и т.д. А для нас особый интерес представляет обновление механизма конфигурации безопасного сетевого соединения - App Transport Security - в iOS 9.0 в 2015 году.
Это событие можно рассматривать как попытку Apple сделать мобильные приложения более защищенными, точнее, дать разработчикам инструмент для самостоятельного управления настройками сетевого соединения, и не через код приложения, а посредством конфигурации специального домена в основном файле `Info.plist`. Ключевыми задачами данного механизма являются отключение для приложения возможности общаться по незащищенному протоколу HTTP, а также обязательная поддержка последних версий TLS на сервере для обеспечения Perfect Forward Secrecy (про это можно подробно почитать в нашей [статье про SSL Pinning](https://habr.com/ru/company/swordfish_security/blog/661093/)). Изначально компания Apple собиралась сделать применение App Transport Security обязательным для всех приложений, представленных в App Store, начиная с января 2017 года. Однако, за несколько недель до этой даты [решение изменили](https://developer.apple.com/news/?id=12212016b). И, хотя было анонсировано назначение новой даты, до сих пор использование ATS является необязательным.
Нечто подобное предложили в дальнейшем и в Android 7 в 2016 году, в виде файла настройки Network Security Config.
Что интересно, различные рекламные сервисы, например, Google AdMob, для своей корректной работы рекомендуют просто [полностью отключить ATS](https://developers.google.com/admob/ios/app-transport-security) в вашем приложении. Классный совет, спасибо, Google! Мы всегда знали, что ты - за безопасность!
Проверка сервера
----------------
Не всякий сервер подойдет для подключения с использованием ATS. Если ваш не удовлетворяет необходимым требованиям, то соединение завершится с ошибкой
`An SSL error has occurred and a secure connection to the server cannot be made.`
Вот каким должен быть сервер, чтобы применять ATS:
* Все шифронаборы должны использовать алгоритмы, поддерживающие Perfect Forward Secrecy;
* Наличие TLS версии не ниже 1.2;
* Для всех сертификатов необходимо использовать, как минимум, отпечаток SHA256 с ключом RSA (2048 или выше) или с ключом 256 бит или более.
### ATS-совместимые шифры
Для успешного подключения к серверу с использованием ATS на клиенте подойдут следующие шифронаборы:
* `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
* `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
* `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`
* `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`
* `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`
* `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`
* `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
* `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
* `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`
* `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`
* `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA`
### Тестирование серверной части
Но даже если ваш сервер не удовлетворяет заданным требованиям безопасности для использования ATS, конфигурацию можно настроить. Хотя можно и задуматься о доработке серверной части.
Для того, чтобы определить, какие настройки необходимо проделать с ATS, чтобы он корректно работал, можно использовать команду `nscurl` с параметром `--ats-diagnostics`. Результатом вывода команды будут успешные и неуспешные проверки по всем пунктам ATS:
```
$ nscurl --ats-diagnostics https://stingray-mobile.ru/
Starting ATS Diagnostics
<...>
Default ATS Secure Connection
---
ATS Default Connection
Result : PASS
---
================================================================================
Allowing Arbitrary Loads
---
Allow All Loads
Result : PASS
---
================================================================================
Configuring TLS exceptions for stingray-mobile.ru
---
TLSv1.3
Result : PASS
---
---
TLSv1.2
Result : PASS
---
---
TLSv1.1
Result : PASS
---
---
TLSv1.0
Result : PASS
---
<...>
```
Если все проверки пройдены успешно, соединение может быть беспрепятственно установлено из приложения. А в случае каких-либо ошибок можно настроить соответствующее исключение в файле конфигурации.
К примеру, если не отработала проверка на [Perfect Forward Secrecy](https://en.wikipedia.org/wiki/Forward_secrecy):
```
$ nscurl --ats-diagnostics http://test.com
<...>
Default ATS Secure Connection
---
ATS Default Connection
2015-08-28 11:51:06.868 nscurl[7019:8960694] NSURLSession/
NSURLConnection HTTP load failed (kCFStreamErrorDomainSSL, -9802)
Result : FAIL
---
<...>
Configuring PFS exceptions for test.com
---
Disabling Perfect Forward Secrecy
Result : PASS
---
<...>
```
В этом примере видно, что успешно установить соединение будет возможно, только если отключить [Perfect Forward Secrecy](https://en.wikipedia.org/wiki/Forward_secrecy). Поэтому в `Info.plist` файле для домена `test.com` необходимо указать `NSExceptionRequiresForwardSecrecy=NO`.
Для того, чтобы проверить, какие шифронаборы используются и включены на вашем сервере, можно запустить `nmap` со специальными параметрами
```
$ nmap --script ssl-enum-ciphers -p 443 www.cnn.com
```
Будет создан отчет, аналогичный приведенному ниже, в котором показано, какие версии TLS поддерживаются и какие шифронаборы можно применять.
```
$ nmap --script ssl-enum-ciphers -p 443 www.cnn.com
Starting Nmap 7.91 ( https://nmap.org ) at 2022-03-14 15:43 MSK
Nmap scan report for www.cnn.com (151.101.65.67)
Host is up (0.040s latency).
Other addresses for www.cnn.com (not scanned): 151.101.129.67 151.101.193.67 151.101.1.67
PORT STATE SERVICE
443/tcp open https
| ssl-enum-ciphers:
| TLSv1.0:
| ciphers:
| TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (ecdh_x25519) - A
| TLS_RSA_WITH_AES_128_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_AES_256_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_3DES_EDE_CBC_SHA (rsa 2048) - C
| compressors:
| NULL
| cipher preference: server
| warnings:
| 64-bit block cipher 3DES vulnerable to SWEET32 attack
| TLSv1.1:
| ciphers:
| TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (ecdh_x25519) - A
| TLS_RSA_WITH_AES_128_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_AES_256_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_3DES_EDE_CBC_SHA (rsa 2048) - C
| compressors:
| NULL
| cipher preference: server
| warnings:
| 64-bit block cipher 3DES vulnerable to SWEET32 attack
| TLSv1.2:
| ciphers:
| TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (ecdh_x25519) - A
| TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (ecdh_x25519) - A
| TLS_RSA_WITH_AES_128_GCM_SHA256 (rsa 2048) - A
| TLS_RSA_WITH_AES_128_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_AES_256_CBC_SHA (rsa 2048) - A
| TLS_RSA_WITH_3DES_EDE_CBC_SHA (rsa 2048) - C
| compressors:
| NULL
| cipher preference: server
| warnings:
| 64-bit block cipher 3DES vulnerable to SWEET32 attack
|_ least strength: C
Nmap done: 1 IP address (1 host up) scanned in 11.38 seconds
```
Кроме того, существуют сайты, например, <http://ssllabs.com/ssltest/analyze.html>, позволяющие проверить, совместимы ли общедоступные веб-сайты с ATS.
App Transport Security
----------------------
Секция по настройке App Transport Security в `Info.plist` называется `NSAppTransportSecurity` и имеет следующую структуру:
```
NSAppTransportSecurity : Dictionary {
NSAllowsArbitraryLoads : Boolean
NSAllowsArbitraryLoadsForMedia : Boolean
NSAllowsArbitraryLoadsInWebContent : Boolean
NSAllowsLocalNetworking : Boolean
NSExceptionDomains : Dictionary {
: Dictionary {
NSIncludesSubdomains : Boolean
NSExceptionAllowsInsecureHTTPLoads : Boolean
NSExceptionMinimumTLSVersion : String
NSExceptionRequiresForwardSecrecy : Boolean
NSRequiresCertificateTransparency : Boolean
}
}
}
```
Далее мы разберем детально каждый из этих параметров: за что отвечает, какое значение имеет по умолчанию. Также поговорим о том, что может произойти, если эти параметры будут настроены небезопасным образом, и посмотрим на примерах, как автоматически это определять.
### NSAllowsArbitraryLoads
Ключ `NSAllowsArbitraryLoads` определяет состояние ATS в целом, видит включено или выключено оно для приложения. По умолчанию, для ключа `NSAllowsArbitraryLoads` установлено значение `NO`, то есть App Transport Security включен полностью. Установка ключа в значение `YES`приведет к полному отключению всех проверок. Это означает, что система не будет запрещать приложению взаимодействовать с любыми доменами по протоколу HTTP, а также не будет применять никаких дополнительных проверок к установке сетевого соединения. Крайне не рекомендуется отключать ATS на уровне всего приложения. Лучше потратить немного времени и разобраться, что не работает и как это можно исправить.
Если вы все-таки решите отключить ATS, то рекомендую проконтролировать несколько моментов, которые автоматически проверяются при его использовании:
* Шифры для сетевого взаимодействия приложения (и их надежность);
* Протоколы, применяемые для отправки и получения данных (и их безопасность);
* Наличие в приложении уязвимостей для перехода на более раннюю версию протокола шифрования;
* Осуществление проверок приложения сертификатами, используемыми для TLS-подключений.
Как верно заметили в комментариях, поведение этого ключа зависит от используемой версии iOS:
* **iOS 9.0**
ATS использует заданное значение `NSAllowsArbitraryLoads` (или `NO` по умолчанию) и игнорирует другие глобальные исключения.
* **iOS 10.0 и более старшие версии**ATS игнорирует установленное значение NSAllowsArbitraryLoads, если какой-либо из следующих ключей присутствует в конфигурации:
+ `NSAllowsArbitraryLoadsForMedia`
+ `NSAllowsArbitraryLoadsInWebContent`
+ `NSAllowsLocalNetworking`
### NSAllowsLoadsForMedia
Это исключение относится к мультимедийному контенту, защищенному системой управления цифровыми правами (DRM) или шифрованием. По умолчанию, для ключа `NSAllowsLoadsForMedia` установлено значение `NO`. Если для него установлено значение `YES`, ATS отключается для контента, отправляемого с использованием [фреймворка AVFoundation](https://developer.apple.com/documentation/avfoundation). Обычно это происходит с приложениями, включающими в себя возможность работы с видео/аудио контентом.
Если по какой-то причине необходимо отключить ATS, рекомендуется дополнительно обратить внимание на то, чтобы мультимедийные данные, отправляемые приложением, не содержали конфиденциальных данных и были защищены с помощью DRM или шифрования.
По опыту: я не очень часто встречал подобные исключения и подобный контент в приложениях. Уверен, что они есть, но в моей практике они достаточно редки.
### NSAllowsArbitraryLoadsInWebContent
Есть один интересный нюанс: если WebView (а именно, компоненты `UIWebView` и `WKWebView`) используется для отображения произвольных адресов, то невозможно составить весь их список и понять, правильно ли они настроены для соединения при помощи ATS. Apple предоставила два возможных решения данной проблемы.
Первое из них - это использование ключа `NSAllowsArbitraryLoadsInWebContent`. Он определяет, возможно ли соединение по небезопасным протоколам из компонентов WebView. По умолчанию, для этого ключа установлено значение `NO`. Если установить значение `YES`, ATS будет отключен для WebView. Этот ключ появился только в десятой версии iOS. Есть несколько нюансов, относящихся к старым версиям iOS, но их мы рассматривать не будем, поскольку они уже неактуальны.
Второй, и более адекватный вариант, - использование `SFSafariViewController`, который был специально разработан для этих целей. Обратимся к документации Apple:
> “Используйте класс `SFSafariViewController`, если ваше приложение позволяет пользователям открывать произвольные Web-сайты. Используйте класс `WKWebView` для контента, который находится под вашим управлением”.
>
>
Применяя `SFSafariViewController`, нужно помнить о некоторых специфических вещах:
* ATS в данном компоненте отключен. Это позволяет загружать и отображать любой веб-контент с любых источников независимо от конфигурации HTTPS;
* Cookies и данные Web-сайтов передаются Safari. Это позволяет, например, оставаться аутентифицированным на различных ресурсах, в которых пользователь логинился из браузера;
* Способов контроля и управления по сравнению с `WKWebView` существенно меньше.
Из этих двух вариантов, при возможности, лучше использовать компонент `SFSafariViewController` для отображения произвольных веб-сайтов вместо отключения ATS для всех WebView.
### NSAllowsLocalNetworking
Ключ `NSAllowsLocalNetworking` определяет работу ATS в локальной сети.
По умолчанию, для `NSAllowsLocalNetworking`установлено значение `NO`. Обычно это исключение используют приложения, подключающиеся к локальным устройствам для работы Интернета вещей (IoT). При отключении ATS убедитесь, что во время взаимодействия в локальной сети не передаются конфиденциальные данные, а также используется безопасное TLS-соединение.
### NSExceptionDomains
При применении ключа `NSExceptionDomains` появляется возможность настраивать исключения ATS для отдельных доменов. При этом не стоит забывать, что подразделы ATS внутри `NSExceptionDomains`заменяют другие первичные ключи. Например, если приложение загружает мультимедиа из определенного домена, для которого используются и исключение `NSAllowsLoadsForMedia` на верхнем уровне, и конфигурация `NSExceptionDomains`, то параметры `NSExceptionDomains` имеют приоритет. Другими словами, они заменяют значение ключа `NSAllowsLoadsForMedia` верхнего уровня. Фактически, для конкретного домена силу имеют только настройки, указанные в исключениях для него. В разделе с примерами мы рассмотрим это чуть подробнее.
Вторая особенность заключается в том, что если домен в исключениях указан без какой-либо конфигурации, то он получит полную защиту ATS, даже если для параметра `NSAllowsArbitraryLoads`установлено значение `YES`. Таким образом, разработчик может отключить ATS глобально, но включить его для определенных доменов, указав их в ключе `NSExceptionDomains`. Это еще один способ позволить приложению осуществлять загрузку данных с произвольных серверов без их проверки на совместимость с ATS (при включенном ATS для выбранных доменов).
Но, на самом деле, это достаточно плохая практика и, возможно, стоит еще раз посмотреть на архитектуру вашего приложения.
> Если вы указываете исключения для доменов, ATS игнорирует любые ключи глобальной конфигурации, включая NSAllowsArbitraryLoads, для этого домена. Это работает, даже если вы оставите словарь для домена пустым и полностью доверитесь значениям его ключей по умолчанию.
>
>
#### NSIncludesSubdomains
Данный ключ определяет, будет ли применяться политика ATS для поддоменов.
По умолчанию, для ключа `NSIncludesSubdomains` установлено значение `NO`. Если установлено значение `YES`, любая конфигурация ATS, включенная для определенного домена, будет использоваться для всех поддоменов. И, если установлен домен, но не настроено никаких дополнительных ключей, кроме `NSIncludesSubdomains`, этот домен и его поддомены будут использовать ATS.
#### NSExceptionAllowsInsecureHTTPLoads
Ключ `NSExceptionAllowsInsecureHTTPLoad`определяет, возможна ли передача незащищенного трафика HTTP на указанный домен.
По умолчанию, для этого ключа установлено значение `NO`. Если установлено значение `YES`, приложению будет разрешено отправлять HTTP-трафик на этот домен.
#### NSExceptionMinimumTLSVersion
Этот ключ позволяет снизить минимально допустимую версию TLS. По умолчанию, к таким версиям принадлежат TLS 1.2 и выше.
#### NSExceptionRequiresForwardSecrecy
Данный ключ определяет использование свойства Forward Secrecy для конкретного домена.
По умолчанию, для этого ключа установлено значение `YES`. Если выставлено значение `NO`, свойство Forward Secrecy будет отключено для этого домена.
#### NSRequiresCertificateTransparency
Данный ключ определяет использование свойства Certificate Transparency (прозрачность сертификатов) для конкретного домена.
По умолчанию, для этого ключа установлено значение `NO`. Если для ключа установлено значение `YES`, для сертификата домена потребуется метка времени Certificate Transparency.
[Certificate Transparency](https://www.certificate-transparency.org/) - это проект Google, ориентированный на повышение безопасности системы выпуска сертификатов SSL. Если ваша организация или рассматриваемый домен поддерживает Certificate Transparency, рекомендуется включить данную опцию. Это помогает выявлять мошеннические центры сертификации и предотвращать атаки типа «человек посередине», уведомляя владельца, если его сертификат был скомпрометирован. Когда этот ключ включен, проверки сертификатов, связанные с Certificate Transparency, выполняются до установления соединения.
### Certificate Pinning
Начиная с iOS 14, в AppTransport Security появился нативный механизм реализации прикрепления сертификатов (certificate pinning). В документации о нем сказано не много, основным источником информации является [новость на портале](https://developer.apple.com/news/?id=g9ejcf8y). Резюмируем ее содержание:
* В Info.plist можно указать набор сертификатов, которые App Transport Security (ATS) ожидает при подключении к указанным доменам
* Закрепленный открытый ключ должен присутствовать либо в промежуточном, либо в корневом сертификате
* Приложение не сможет подключиться к указанному в настройках домену, если проверка цепочки сертификатов окажется неуспешной
* Можно связать несколько открытых ключей с одним доменным именем.
Для начала поговорим о том, как нам получить отпечаток, который нужно указать в настройках. Чтобы определить всю цепочку сертификатов (то, что будем закреплять), можно воспользоваться OpenSSL:
```
# servername is used to ensure SNI is requested
/usr/local/opt/openssl/bin/openssl s_client -showcerts -verify 5 -servername www.example.com -connect www.example.com:443 < /dev/null
# Output
verify depth is 5
CONNECTED(00000005)
depth=2 C = US, O = DigiCert Inc, OU = www.digicert.com, CN = DigiCert Global Root CA
verify return:1
depth=1 C = US, O = DigiCert Inc, CN = DigiCert TLS RSA SHA256 2020 CA1
verify return:1
depth=0 C = US, ST = California, L = Los Angeles, O = Internet Corporation for Assigned Names and Numbers, CN = www.example.org
verify return:1
---
Certificate chain
0 s:C = US, ST = California, L = Los Angeles, O = Internet Corporation for Assigned Names and Numbers, CN = www.example.org
i:C = US, O = DigiCert Inc, CN = DigiCert TLS RSA SHA256 2020 CA1
-----BEGIN CERTIFICATE-----
MIIG1TCCBb2gAwIBAgIQD74IsIVNBXOKsMzhya/uyTANBgkqhkiG9w0BAQsFADBP
<...>
vUzLnF7QYsJhvYtaYrZ2MLxGD+NFI8BkXw==
-----END CERTIFICATE-----
1 s:C = US, O = DigiCert Inc, CN = DigiCert TLS RSA SHA256 2020 CA1
i:C = US, O = DigiCert Inc, OU = www.digicert.com, CN = DigiCert Global Root CA
-----BEGIN CERTIFICATE-----
MIIE6jCCA9KgAwIBAgIQCjUI1VwpKwF9+K1lwA/35DANBgkqhkiG9w0BAQsFADBh
<...>
8ks5T1KESaZMkE4f97Q=
-----END CERTIFICATE-----
2 s:C = US, O = DigiCert Inc, OU = www.digicert.com, CN = DigiCert Global Root CA
i:C = US, O = DigiCert Inc, OU = www.digicert.com, CN = DigiCert Global Root CA
-----BEGIN CERTIFICATE-----
MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
<...>
CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
-----END CERTIFICATE-----
---
Server certificate
subject=C = US, ST = California, L = Los Angeles, O = Internet Corporation for Assigned Names and Numbers, CN = www.example.org
issuer=C = US, O = DigiCert Inc, CN = DigiCert TLS RSA SHA256 2020 CA1
---
No client certificate CA names sent
Peer signing digest: SHA256
Peer signature type: RSA-PSS
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 4654 bytes and written 747 bytes
Verification: OK
---
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Server public key is 2048 bit
Secure Renegotiation IS NOT supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
Early data was not sent
Verify return code: 0 (ok)
---
DONE
```
Из вывода команды можно определить, что для [http://www.example.com](http://www.example.com/) есть один конечный сертификат, сертификат промежуточного центра сертификации, а затем корневой сертификат.
Для получения отпечатка SPKI, можно сохранить любой сертификат в виде файла формата PEM, а затем передать его на вход в следующий скрипт (пример для MacOS):
```
#!/usr/bin/env bash
set -Eeuo pipefail
# Homebrew location of OpenSSL (built-in version is too out of date)
OPENSSL="/usr/local/opt/openssl/bin/openssl"
CERTHASH=$($OPENSSL x509 -inform pem -noout -outform pem -pubkey < "$1" | $OPENSSL pkey -pubin -inform pem -outform der | $OPENSSL dgst -sha256 -binary | $OPENSSL enc -base64)
echo -e "\nFingerprint for pinning: $CERTHASH"
```
Или же воспользоваться командой из документации:
```
$ cat ca.pem | openssl x509 -inform pem -noout -outform pem -pubkey | openssl pkey -pubin -inform pem -outform der | openssl dgst -sha256 -binary | openssl enc -base64
```
Результирующий отпечаток конечного сертификата в приведенном выше примере — `mM294xslEgmvDODAxWWH2DeH4/bNgPBpgZvd7SfciuA=`, а центр сертификации — `RQeZkB42znUfsDIIFWIRiYEcKl7nHwNFwWCrnMMJbVc=`.
Теперь мы можем добавить эти значения в Info.plist:
```
NSAppTransportSecurity
NSPinnedDomains
example.com
NSIncludesSubdomains
NSPinnedCAIdentities
SPKI-SHA256-BASE64
RQeZkB42znUfsDIIFWIRiYEcKl7nHwNFwWCrnMMJbVc=
NSPinnedLeafIdentities
SPKI-SHA256-BASE64
mM294xslEgmvDODAxWWH2DeH4/bNgPBpgZvd7SfciuA=
```
В приведенном выше примере мы указываем, что отпечаток открытого ключа связан с доменом `example.org` и его поддоменами, например `test.example.org`. Но вот поддомены третьего уровня и выше в эту проверку уже не попадают (например `notinclude.test.example.org`). Также будем проверять центр сертификации, что указано в ключе `NSPinnedCAIdentities` и сертификат конечного сервера, за который отвечает ключ `NSPinnedLeafIdentities`.
Можно сразу же указать несколько отпечатков, что может быть полезно при ротации сертификатов на сервере:
```
NSAppTransportSecurity
NSPinnedDomains
example.com
NSPinnedLeafIdentities
SPKI-SHA256-BASE64
i9HaIScvf6T/skE3/A7QOq5n5cTYs8UHNOEFCnkguSI=
SPKI-SHA256-BASE64
mM294xslEgmvDODAxWWH2DeH4/bNgPBpgZvd7SfciuA=
```
Но как показывает практика, это работает не всегда. Такой способ хорош для `URLSession`, но не подходит для API поверх `CFNetwork`.
* `WKWebView` по-прежнему будет подключаться и загружать контент из домена, если открытый ключ SSL отличается от указанного в `Info.plist`
* `SFSafariViewController` также не учитывает настройки в `Info.plist`. Такое поведение неудивительно, учитывая, что SFSafariViewController выполняется в отдельном [процессе](https://developer.apple.com/videos/play/wwdc2015-504/?time=494).
[Ответ Apple](https://developer.apple.com/forums/thread/681734) пока неутешительный, поскольку не несет в себе никакой конкретики. Непонятно, будут ли когда-то настройки Certificate Pinning из AppTransport Security работать для всех API. Может быть, однажды это случится, ну а сейчас просто надо учитывать эту особенность при разработке.
Идеальная конфигурация
----------------------
Если говорить про идеальную конфигурацию, то это, конечно, включение ATS в полном объеме на уровне всего приложения и без исключений для доменов:
```
NSAppTransportSecurity
NSAllowsArbitraryLoads
NSAllowsArbitraryLoadsForMedia
NSAllowsArbitraryLoadsInWebContent
NSPinnedDomains
example.com
NSPinnedLeafIdentities
SPKI-SHA256-BASE64
i9HaIScvf6T/skE3/A7QOq5n5cTYs8UHNOEFCnkguSI=
SPKI-SHA256-BASE64
mM294xslEgmvDODAxWWH2DeH4/bNgPBpgZvd7SfciuA=
```
К сожалению, такое встречается очень редко. Сегодняшние мобильные приложения зачастую используют большое количество сторонних сервисов, которые они не контролируют, и не могут гарантировать обеспечения должного уровня безопасности, например, использование корректной версии TLS.
Примеры
-------
### Отключение ATS
Полностью отключить ATS можно, указав флаг`NSAllowsArbitraryLoads=YES`. Такая конфигурация рекомендуется только для отладки.
```
NSAppTransportSecurity
NSAllowsArbitraryLoads
```
К сожалению, во многих приложениях мы до сих пор встречаем полностью отключенный ATS:
Выявленная неправильная конфигурация App Transport SecurityС чем это связано, до конца не ясно, но я надеюсь, что эта статья натолкнет на мысли о более детальной конфигурации приложения.
### Работа с исключениями
Как было сказано выше, возможны ситуации, когда приложение взаимодействует с серверами, не отвечающими требованиям ATS. В этом случае нужно сообщить операционной системе, какие именно это домены, и указать их в `Info.plist` вашего приложения (и отметить, какие именно требования не выполняются).
Здесь стоить помнить про одну важную деталь: конфигурация исключений может быть очень интересна злоумышленникам, особенно если вы оставляете в продуктивной сборке адреса тестовых стендов.
Срабатывание с адресом тестового стенда в конфигурации App Transport SecurityКак правило, такие стенды, если они имеют доступ в интернет, намного слабее “охраняются“ различными средствами защиты, мониторингом и прочими разработками. А значит, их интересно исследовать на предмет наличия уязвимостей. А дальше уже можно попробовать зайти в сеть и развернуться по-настоящему. Как я говорил в других статьях, одна уязвимость или даже недостаток в мобильном приложении не являются такой уж огромной проблемой (конечно, если это не какая-то инъекция или RCE). Однако, наличие нескольких слабостей помогает выстроить в вектор атаки, который сработает и принесет реальный ущерб приложению или пользователям.
#### Отключение ATS для всех соединений кроме одного
Не очень правильный, но все-таки имеющий право на жизнь способ - отключить ATS для всего, кроме ваших серверов. Конечно, не очень хорошо так делать, но это лучше, чем отключать ATS вообще. Вот как может выглядеть `Info.plist` при такой конфигурации:
```
xml version=»1.0″ encoding=»UTF-8″?
…
NSAppTransportSecurity
NSAllowsArbitraryLoads
NSExceptionDomains
api.test.com
NSExceptionAllowsInsecureHTTPLoads
…
```
В этом случае приложение сможет осуществлять соединения со всеми серверами вне зависимости от корректности настройки HTTPS (да и просто по HTTP), но для выделенного в исключения домена `api.test.com`подключения можно будет осуществлять только по HTTPS. Также для него будут применяться все остальные требования ATS.
#### Отключение PFS для всех поддоменов
```
NSAppTransportSecurity
NSExceptionDomains
test.com
NSIncludesSubdomains
NSExceptionRequiresForwardSecrecy
```
При такой конфигурации подключение к домену `test.com` и всех его поддоменов не будет требовать настройки Perfect Forward Secrecy. Она может применяться, например, если на вашем сервере не настроены правильные шифронаборы, позволяющие использовать это крайне полезное свойство.
#### Совмещение исключений
В следующем `Info.plist` мы определим три исключения и затем разберем их более детально:
```
xml version=»1.0″ encoding=»UTF-8″?
…
NSAppTransportSecurity
NSExceptionDomains
api.insecuredomain.com
NSExceptionAllowsInsecureHTTPLoads
cdn.somedomain.com
NSThirdPartyExceptionMinimumTLSVersion
1.1
otherdomain.com
NSIncludesSubdomains
NSExceptionRequiresForwardSecrecy
…
```
**api.insecuredomain.com**
Первое исключение, которое мы определили, сообщает ATS, что связь с этим поддоменом отменяет требование обязательного использования HTTPS. Оно применяется только к конкретному адресу, указанному в исключении, и не затрагивает поддомены. Не стоит забывать, что ключ `NSExceptionAllowsInsecureHTTPLoads` относится не только к использованию HTTPS, а и к ATS в целом. Таким образом, для этого домена отменяются все требования App Transport Security.
**cdn.domain.com**
Возможна ситуация, в которой приложение обращается к серверу, не использующему необходимую версию TLS (1.2 или выше). В этом случае можно определить исключение, указывающее минимальную версию TLS, которая может использоваться. Это будет лучше с точки зрения безопасности, чем полное отключение App Transport Security для этого домена.
**otherdomain.com**
Ключ `NSIncludesSubdomains` сообщает App Transport Security, что исключение применяется к каждому поддомену указанного адреса. Кроме того, определяется, что домен может использовать шифры, которые не поддерживают Forward Secrecy (`NSExceptionRequiresForwardSecrecy`).
Заключение
----------
ATS - это очень хороший инструмент, позволяющий намного лучше и проще контролировать происходящее в вашем приложении. Видно, к каким серверам оно обращается, как они настроены и т.д. Кроме того, эта настройка помогает, в какой-то мере, контролировать состояние серверных частей приложения и поддерживать их безопасную конфигурацию. Да, механизм ATS - не только про клиента, он в какой-то степени заставляет backend придерживаться лучших практик безопасности. Так что перед тем, как просто отключить ATS в приложении, задумайтесь: “Может, пришло время правильно сконфигурировать серверную часть?” Также проанализируйте, какие ресурсы, кроме собственных, вы используете, и почему для них нужно отключать потенциальную защиту?
Конечно, хотелось бы видеть в настройке App Transport Security и другие параметры, например, связанные с SSL Pinning (по аналогии с тем, как это сделано в Android). Это позволило бы не искать свои пути для каждого фреймворка, а задавать это на уровне системы. Но, к сожалению, думаю, что этого мы уже не дождемся.
Надеюсь, что эта статья поможет всем интересующимся понять нюансы настройки App Transport Security, а возможно и заставит правильно его сконфигурировать для своего приложения, вместо полного отключения.
Ссылки
------
1. [Preventing Insecure Network Connections](https://developer.apple.com/documentation/security/preventing_insecure_network_connections)
2. [HTTPS Server Trust Evaluation](https://developer.apple.com/library/archive/technotes/tn2232/_index.html)
3. [AVFoundation](https://developer.apple.com/documentation/avfoundation)
4. [Supporting App Transport Security](https://developer.apple.com/news/?id=12212016b)
5. [Debugging HTTPS Problems with CFNetwork Diagnostic Logging](https://developer.apple.com/documentation/network/debugging_https_problems_with_cfnetwork_diagnostic_logging)
6. [WEBVIEWS](https://books.nowsecure.com/secure-mobile-development/en/webviews/)
7. [Working together to detect maliciously or mistakenly issued certificates](https://www.certificate-transparency.org/)
8. [OWASP Mobile Top 10](https://www.owasp.org/index.php/Mobile_Top_10_2016-M3-Insecure_Communication)
9. [CWE-319: Cleartext Transmission of Sensitive Information](https://cwe.mitre.org/data/definitions/319.html)
10. [Безопасность транспорта приложений](https://developers.google.com/admob/ios/app-transport-security)
11. [Безопасность транспорта приложений в Xamarin. iOS](https://docs.microsoft.com/ru-ru/xamarin/ios/app-fundamentals/ats)
12. [Подготовка приложения для iOS 9](https://habr.com/ru/company/e-legion/blog/265767/)
13. [Working with Apple’s App Transport Security](http://www.neglectedpotential.com/2015/06/working-with-apples-application-transport-security/)
14. [App Transport Security Has Blocked My Request](https://cocoacasts.com/app-transport-security-has-blocked-my-request)
15. [Forward secrecy](https://en.wikipedia.org/wiki/Forward_secrecy)
16. [Info.plist based Certificate Pinning on iOS](https://blog.eidinger.info/infoplist-based-certificate-pinning-on-ios)
17. [Identity Pinning: How to configure server certificates for your app](https://developer.apple.com/news/?id=g9ejcf8y)
18. [TLS Pinning with ATS](https://msolarana.netlify.app/2021/01/24/tls-pinning-with-ats/)
19. [[SSL Pinning] NSPinnedDomains will be honored by which APIs?](https://developer.apple.com/forums/thread/681734)
20. [Introducing Safari View Controller](https://developer.apple.com/videos/play/wwdc2015-504/?time=494) | https://habr.com/ru/post/661345/ | null | ru | null |
# 1000+1 способ определения того, являются ли все элементы в списке одинаковыми
В жизни у нас всегда есть выбор, знаем мы о нем или нет. То же самое происходит и в кодировании. Существует множество способов, с помощью которых мы можем подойти к какой-то конкретной задаче. Мы можем изначально не рассматривать эти способы или не иметь о них никакого понятия, но они существуют. Быть программистом — это не просто знать язык и процесс написания кода. Очень часто это значит быть самой креативной версией себя, рассматривая даже то, над чем Вы раньше не задумывались. И на этой ноте я хотел бы представить себя. Здравствуйте! Меня зовут Алекс, я основатель [CheckiO](https://py.checkio.org/), и я уже давно занимаюсь творческими аспектами этого проекта.
Наши пользователи имеют разные уровни знаний и опыта в области кодирования, поэтому я часто вижу стандартные и более очевидные подходы к решению задач. Но время от времени я сталкиваюсь с такими уникальными и необычными решениями, что они заставляют меня вновь изучать неведомые ранее тонкости языка.
В этой статье я хочу рассмотреть некоторые решения одной из очень простых задач, которые, на мой взгляд, являются самыми интересными. Миссия требует от Вас написать функцию, которая будет определять, имеют ли все элементы массива одинаковое значение.
**1.** Одно из первых решений, которое приходит в голову — сравнить длину списка исходных элементов с тем, сколько раз первый элемент входит в список. Если эти значения равны, значит список состоит из одинаковых элементов. Также присутствует проверка того, является ли список пустым, так как в этом случае также необходимо вернуть True.
```
def all_the_same(elements):
if len(elements) < 1:
return True
return len(elements) == elements.count(elements[0])
```
Либо более сокращенный вариант:
```
def all_the_same(elements):
return len(elements) < 1 or len(elements) == elements.count(elements[0])
```
**2.** В этом решении использовалась полезная особенность Python — возможность сравнивать списки всего лишь с помощью оператора сравнения — ‘==’ (в отличии от некоторых других языков программирования, где это сделать не так просто). Рассмотрим, как это работает:
```
>>> [1, 1, 1] == [1, 1, 1]
True
>>> [1, 1, 0] == [0, 1, 1]
False
```
Другая особенность языка в том, что он предоставляет возможность умножать list на число и результатом этой операции будет list в котором все элементы скопированы указанное количество раз. Давайте я покажу вам несколько примеров:
```
>>> [1] * 3
[1, 1, 1]
>>> [1] * 5
[1, 1, 1, 1, 1]
>>> [1] * 0
[]
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]
```
Таким образом можно прийти к простому решению — если умножить массив из одного первого элемента из исходного массива на длину этого исходного массива, то должен опять получиться исходных массив, если все элементы этого массива одинаковые.
```
def all_the_same(elements):
if not elements:
return True
return [elements[0]] * len(elements) == elements
```
Как и в предыдущем случае, можно укоротить это решение:
```
def all_the_same(elements):
return not elements or [elements[0]] * len(elements) == elements
```
**3.** В этом решении использовалась стандартная [функция set()](https://docs.python.org/3/library/functions.html?#func-set). Эта функция преобразовывает объект в set в котором, по определению, все элементы должны быть уникальными. Это выглядит так:
```
>>> elements = [1, 2, 5, 1, 5, 3, 2]
>>> set(elements)
{1, 2, 3, 5}
```
Если в итоге полученный set будет состоять из 1 или 0 элементов — значит в исходном списке все элементы были одинаковы или же он был пуст. Решение может выглядеть так:
```
def all_the_same(elements):
return len(set(elements)) in (0, 1)
```
или так:
```
def all_the_same(elements):
return len(set(elements)) <= 1
```
Подобный подход можно использовать с помощью модуля [NumPy](http://www.numpy.org/), в котором есть [функция unique()](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.unique.html), работающая следующим образом:
```
>>> from numpy import unique
>>> a = [1, 2, 1, 2, 3, 1, 1, 1, 1]
>>> unique(a)
[1 2 3]
```
Как видите, её работа весьма схожа с работой set(), только в этом случае не
меняется тип объекта — список остается списком. Решение с помощью этой функции выглядит так:
```
from numpy import unique
def all_the_same(elements):
return len(unique(elements)) <= 1
```
**4.** Вот пример весьма оригинального решения, в котором, к тому же, обыгрывается название данной задачи с помощью стандартной функции Python — [all()](https://docs.python.org/3/library/functions.html#all). Функция all() вернет True, если все элементы переданного списка будут True. Например:
```
>>> all([1, 2, 0, True])
False
#(0 не true)
>>> all([1, 2, None, True])
False
#(None не true)
>>> all([1, 2, False, True])
False
>>> all([1, 2, 0.1, True])
True
```
Сперва переменной first присваивается значение первого элемента списка, а rest — список всех остальных элементов, кроме первого. Затем в кортеж the\_same добавляются значения True or False в зависимости от того, равен ли очередной элемент списка rest первому элементу исходного списка. После этого функция all() вернет True, если the\_same будет состоять только из элементов ‘True’, и False, если в кортеже будет хотя бы один элемент ‘False’.
```
def all_the_same(elements):
try:
first, *rest = elements
except ValueError:
return True
the_same = (x == first for x in rest)
return all(the_same)
```
Исключение ValueError будет вызвано только в том случае, если массив пуст. Но мы можем сделать более привычную нам проверку:
```
def all_the_same(elements):
if not elements:
return True
first, *rest = elements
the_same = (x == first for x in rest)
return all(the_same)
```
**5.** Следующее решение очень похоже на предыдущее. В нем есть лишь небольшая поправка — первый и остальные элементы из исходного списка разделяются с помощью итератора. [Функция iter()](https://docs.python.org/3/library/functions.html#iter) создает итератор из переданного списка, а [функция next()](https://docs.python.org/3/library/functions.html#next) берет из него следующий элемент (т.е. первый — при первом вызове). Если вывести с помощью print элементы, входящие в el и first, мы увидим следующее:
```
>>> el = iter([1, 2, 3])
>>> first = next(el, None)
>>> print(first)
1
>>> for i in el:
>>> print(i)
2
3
```
В остальном, это решение похоже на предыдущее, за исключением того, что у нас отпадает необходимость в проверке — является ли список пустым или нет.
```
def all_the_same(elements):
el = iter(elements)
first = next(el, None)
return all(element == first for element in el)
```
**6.** Одним из креативных подходов к решению этой задачи является перестановка элементов. Мы меняем элементы местами и проверяем, что список из-за этого не изменился. Это говорит нам о том, что все элементы в списке — одинаковые. Вот пару примеров такого подхода:
```
def all_the_same(elements):
return elements[1:] == elements[:-1]
```
и
```
def all_the_same(elements):
return elements == elements[1:] + elements[:1]
```
Стоит также обратить внимание, что сравнивать массивы можно и поэлементно, используя [функцию zip()](https://docs.python.org/3/library/functions.html#zip). Рассмотрим это на примере следующих решений.
**7.** [Функция zip()](https://docs.python.org/3/library/functions.html#zip) объединяет каждый i-ый элемент одного объекта с i-ым элементом остальных до тех пор, пока не закончится самый короткий объект.
```
>>> x = [1, 2, 3]
>>> y = [10, 11]
>>> list(zip(x, y))
[(1, 10), (2, 11)]
```
Как видите, несмотря на то, что x состоит из трех элементов, были использованы только два, так как самый короткий объект — в данном случае y — состоит всего из 2-х элементов.
Приведенное ниже решение работает следующим образом: сперва создается второй список (elements[1:]), который равен исходному списку, но без первого элемента. Затем поочередно сравниваются элементы из этих двух списков и в результате каждого такого сравнения мы получаем True или False. После чего функция all() возвращает результат обработки этого набора True и False.
```
def all_the_same(elements):
return all(x == y for x, y in zip(elements, elements[1:]))
```
Предположим, наш исходный список elements = [2, 2, 2, 3]. Тогда с помощью zip(), мы объединим полный список ([2, 2, 2, 3]) и список без первого элемента ([2, 2, 3]) таким образом: [(2, 2), (2, 2), (2, 3)], сравнения элементов между собой передадут в функцию all() набор [True, True, False] и в результате мы получим False, что является правильным ответом, так как в исходном списке не все элементы одинаковы.
**8.** Весьма любопытным оказалось следующее решение. В нем использовался [итератор groupby()](https://docs.python.org/3/library/functions.html#zip), который работает таким образом — сравнивает каждый i-ый элемент с (i-1)-ым и если элементы равны — двигается дальше, а если не равны — оставляет в итоговом списке элемент (i-1) и продолжает сравнение со следующего элемента. На практике это выглядит так:
```
>>> from itertools import groupby
>>> elements = [1, 1, 1, 2, 1, 1, 1, 2]
>>> for key, group in groupby(elements):
>>> print(key)
1
2
1
2
```
Как видите, остались только те элементы, которые отличаются от элемента на следующей позиции (elements[0], elements[1], elements[4] и elements[5] были исключены).
В данном решении функция с помощью итератора groupby() добавляет в список единицу (1) каждый раз, когда следующий элемент исходного списка отличается от предыдущего. Таким образом, если в исходном списке 0 элементов или все элементы равны, сумма (sum(1 for \_ in groupby(elements))) будет равна 0 или 1 — то есть в любом случае меньше 2, что и указано в решении.
```
from itertools import groupby
def all_the_same(elements):
return sum(1 for _ in groupby(elements)) < 2
```
**9.** Еще одно креативное решение, в котором используется один из стандартных модулей Python — [collections](https://docs.python.org/3/library/collections.html). [Counter](https://docs.python.org/3/library/collections.html#collections.Counter) создает словарь, куда заносит информацию о количестве каждого элемента в исходном списке. Давайте посмотрим, как это работает:
```
>>> from collections import Counter
>>> a = [1, 1, 1, 2, 2, 3]
>>> Counter(a)
Counter({1: 3, 2: 2, 3: 1})
```
Соответственно, если длина этого словаря будет 2 и больше — в исходном списке как минимум 2 разных элемента и не все элементы одинаковы.
```
def all_the_same(elements):
from collections import Counter
return not len(list(Counter(elements))) > 1
```
10. Данное решение построено на такой же логике, как и решение №7, но используются функции [eq()](https://docs.python.org/3/library/operator.html#operator.eq) и [starmap()](https://docs.python.org/3/library/itertools.html#itertools.starmap). Разберемся, как они работают:
```
>>> from operator import eq
>>> eq(1, 2)
False
```
По сути, функция eq() делает то же, что и “==” — сравнивает два объекта и возвращает True, если они равны и False в ином случае (eq — сокращенно от equivalent). Однако, обратите внимание, что функция — это объект и она может быть, к примеру, передана в качестве аргумента для другой функции, что и было сделано в описанном далее решении.
Функция starmap() создает итератор, который применяет другую функцию к списку объектов. Используется тогда, когда объекты уже сгруппированы в кортежи. Например:
```
>>> import math
>>> from itertools import starmap
>>> list(starmap(math.pow, [(1, 2), (3, 4)]))
[1.0, 81.0]
```
Как вы видите, указанная один раз функция math.pow(), благодаря функции starmap() была применена дважды — к обоим наборам объектов (1\*\*2 = 1.0, 3\*\*4 = 81.0)
Упрощенно функцию starmap() для данного примера можно представить в виде цикла:
```
import math
elements = [(1, 2), (3, 4)]
result = []
for i in elements:
result.append(math.pow(i[0], i[1]))
```
Решение с использованием описанных ранее функций выглядит так:
```
from operator import eq
from itertools import starmap
def all_the_same(elements):
return all(starmap(eq, zip(elements, elements[1:])))
```
**Заключение**
Итак, мы рассмотрели некоторые смекалистые решения, которые относятся к одной из самых простых головоломок. При всем желании, я даже понятия не имею, как начать описывать то количество уникальных подходов, которые применяют наши пользователи для решения других интересных и более сложных задач. Надеюсь, Вы получили такое же удовольствие от прочтения этой статьи, что и я во время ее написания. Я с нетерпением жду Ваших отзывов. Было ли это полезно для Вас? Как бы Вы решили эту задачу?
*Перевод статьи **[“Determining if all Elements in a List are the Same in Python”](https://www.blog.pythonlibrary.org/2018/05/09/determining-if-all-elements-in-a-list-are-the-same-in-python/)**, опубликованной на блоге [“The Mouse Vs. The Python”](http://www.blog.pythonlibrary.org/).* | https://habr.com/ru/post/358284/ | null | ru | null |
# Все ли вы знаете о useCallback
Привет, Хабр!
Начиная с версии *ReactJS* 16.8 в наш обиход вошли хуки. Этот функционал вызвал много споров, и на это есть свои причины. В данной статье мы рассмотрим одно из самых популярных заблуждений использования хуков и заодно разберемся стоит ли писать компоненты на классах ([данная статья является расшифровкой видео](https://youtu.be/2Wp7QPTkpms)).
Два пути
--------
Как вы знаете в реакте есть 2 вариант написания компонента, с помощью классов и с помощью функций. И каждый вариант по своему взаимодействует с методами. Давайте рассмотрим оба варианта:
### Метод в классе
Первый вариант, это использовать классы:
```
class Test extends Component {
onClick = () => {
console.log('onClick');
}
render() {
return (
test
)
}
}
```
В данном варианте мы добавили метод `onClick` классу `Test` и при создании инстанса класса, этот метод создается 1 раз и в рендере мы уже используем ссылку на этот метод `onClick={this.onClick}`, таким образом при каждом рендере мы обращаемся всегда к одной и той же ссылке и не пересоздаем метод класса. Эта конструкция всем, кто давно в профессии, привычна и понятна даже если вы недавно пришли в *React* с другого языка программирования.
### Метод в функции
Второй способ создания компонента является использование функции:
```
const Test = () => {
const onClick = () => {
console.log('onClick');
}
return (
test
)
}
```
В таком подходе, чтобы создать обработчик `onClick`, мы описываем тело функции прямо внутри `render`, потому что все тело функции и есть `render`, другого варианта в принципе не существует, если вы хотите использовать props.
И тут у нас начинает зудеть в боку, да как это так, мы же теперь заново создаем функцию, абсолютно на каждый рендер. По сравнению с классами это как будто шаг назад.
### Классы лучше чем функции?
Чтобы разобраться с этим вопросом я полез в React документацию в секцию вопросы и ответы и нашел там следующий вопрос:
Судя по документации создание инстанса класса для реакта настолько дорогостоящая операция, что создавать функцию на каждый рендер на порядок дешевле. Да и тот факт, что дерево становится глубже при использовании компонента высшего порядка **connect** от **redux** или бесконечных **observer** от **mobX** совсем не радует.
Кажется есть один "вариантик" сэкономить
----------------------------------------
Идею, создавать на каждый рендер новую функцию и думать что это дешевле, чем один раз создать инстанс класса, немного сложно принять разработчикам, потому что с нашей стороны мы должны писать код хуже, и верить что приложение ускорится. Звучит крайне противоречиво, а мы привыкли все оптимизировать.
Как результат, мы начинаем искать пути, как выйти на прежний уровень оптимизации с нашей стороны. И первое что гуглится, это начать использовать хук `useCallback`. И многие особо не вникая в суть происходящего начинают его активно использовать. Чтобы разобраться во всем этом давайте устроим небольшую викторину
Викторина!
----------
Сейчас мы рассмотрим 2 примера и Вы попытаетесь ответить кто круче!
В одном углу ринга находится уже изученный нами ранее вариант написания обработчика события `someFunction`:
```
const Test = ({ title }) => {
const someFunction = () => {
console.log(title);
}
return (
click me!
)
}
```
В другом углу ринга находится точно такой же компонент, но уже решили завернуть функцию в `useCallback`.
```
const Test = () => {
const someFunction = useCallback(() => {
console.log(title);
}, [title])
return (
click me!
)
}
```
Для пользователя ничего не изменилось, `console.log(title)`, точно так же вызывается при нажатии на кнопку.
### Внимание вопрос
В каком из вариантов написания компонента функция присваемая переменной `someFunction` создается реже?
Даем минутку подумать...
Аккуратно ответ!
### Ответ
И правильный ответ ни в каком! Да именно, никакой оптимизации `useCallback` нам не дал, функция создается ровно столько же раз, как и до оптимизации. Более того, мы наоборот ухудшили перфоманс нашего компонента.
### Разбираем ответ
То что многих вводит в заблуждение - это представление что `useCallback`, это какой-то черный ящик, в который ты отдаешь функцию, с ней что-то происходит и после будет тебе счастье. Но давайте рассмотри как это работает на самом деле. Для начала сделаем `typeof` этого черного ящика:
Естественно мы получим результат `function`. По синтаксису это было очевидно. Чтобы понять как работает черный ящик, давайте сами напишем имплементацию `useCallback`.
Пишем свой useCallback
----------------------
`useCallback` - это функция, которая принимает 2 параметра, `callback` и `deps`.
```
function useCallback (callback, deps) {
}
```
Далее нам надо хранить где-то этот `callback` и `deps`, чтобы иметь возможность при очередном вызове вернуть ту же самую функцию `callback`.
```
const prevState = {
callback: null,
deps: null,
}
function useCallback(callback, deps) {
}
```
Теперь рассмотрим разные случаи: если `deps` не существует либо в `prevState`, либо в новых данных, тогда нужно сохранить текущие параметры и вернуть `callback`.
```
const prevState = {
callback: null,
deps: null,
}
function useCallback(callback, deps) {
if (!prevState.deps || !deps) {
prevState.callback = callback;
prevState.deps = deps;
return callback;
}
}
```
Если же `deps` существуют. Тогда сравниваем какой-либо функцией массивы и если они совпадают, тогда возвращаем мемоизированную функцию.
```
const prevState = {
callback: null,
deps: null,
}
function useCallback(callback, deps) {
if (!prevState.deps || !deps) {
prevState.callback = callback;
prevState.deps = deps;
return callback;
}
if (shallowEqual(deps, prevState.deps)) {
return prevState.callback;
}
}
```
Ну и если `deps` не совпадают, тогда снова сохраняем параметры и возвращаем текущий `callback`.
```
const prevState = {
callback: null,
deps: null,
}
function useCallback(callback, deps) {
if (!prevState.deps || !deps) {
prevState.callback = callback;
prevState.deps = deps;
return callback;
}
if (shallowEqual(deps, prevState.deps)) {
return prevState.callback;
}
prevState.callback = callback;
prevState.deps = deps;
return callback;
}
```
Вроде бы мы покрыли все кейсы
### Какие выводы из этого мы можем сделать?
Функция `useCallback` как и любая другая функция вызывается на каждый рендер и в качестве параметра `callback` **каждый рендер приходит новая функция и новый массив зависимостей**. Которые мы либо выбрасываем, если зависимости до и после совпадают, либо сохраняем в хранилище, для будущего использования.
Давайте теперь посмотрим на эту функцию со стороны компонента. Мы знаем, что `useCallback` это просто функция и мы можем извлечь передаваемые параметры в отдельные переменные.
```
const Test = ({ title }) => {
const callback = () => {
console.log(title);
}
const deps = [title];
const someFunction = useCallback(callback, deps);
return (
click me!
)
}
```
Тут становится совсем очевидно, что мы на каждый рендер создаем не то что функцию, а еще и массив с зависимостями, а потом еще и прокручиваем все это через `useCallback`.
Если мы просто закомментируем создание зависимостей и вызов `useCallback` и передадим параметр `callback` напрямую в `onClick`, тогда кажется перфоманс компонента должен улучшиться, ведь мы убрали посредника, который не нес никакой пользы для перфоманса.
```
const Test = ({ title }) => {
const callback = () => {
console.log(title);
}
// const deps = [title];
// const someFunction = useCallback(callback, deps);
return (
click me!
)
}
```
По итогу мы вернулись к начальной ситуации. Когда просто создавали функцию на каждый рендер.
Получается, в данном случае использовать хук `useCallback` - это не значит улучшить перфоманс, **а скорее совсем наоборот, ухудшить перфоманс**.
А для чего тогда нужен useCallback ?
------------------------------------
Получается мы как то не так используем `useCallback`. Чтобы разобраться в этом, давайте обратимся к документации:
Получается основная идея не в улучшении перформанса в конкретном компоненте, а скорее использование `useCallback` выгодно только в случае передачи функции как props. Давайте рассмотрим еще один пример.
Допустим у нас есть список машин, который мы хотим отобразить:
```
const Cars = ({ cars }) => {
return cars.map((car) => {
return (
)
});
}
```
Тут нам понадобилось добавить обработчик клика на машину. Мы создаем метод `onCarClick` и передаем его в компонент `Car`.
```
const Cars = ({ cars }) => {
const onCarClick = (car) => {
console.log(car.model);
}
return cars.map((car) => {
return (
)
});
}
```
В такой ситуации на каждый рендер компонента `Cars` у нас создается новая функция `onCarClick`, соответственно, не важно `Car` это `PureComponent` или обернут в `memo`, все машины всегда будут заново рендерится, т.к. получают каждый раз новую ссылку на функцию.
Для этого и нужен `useCallback`, если мы завернем функцию в хук, то у нас в переменной `onCarClick` будет уже возвращаться мемоизированая функция, хоть мы в нее на каждый рендер и передаем новую функцию
```
const Cars = ({ cars }) => {
const onCarClick = useCallback((car) => {
console.log(car.model);
}, []);
return cars.map((car) => {
return (
)
});
}
```
Таким образом все компоненты `Car` не будут рендериться лишний раз, т.к. ссылка на функцию останется прежней.
А если заглянуть внутрь компонента `Car`. Там мы создадим еще одну функцию, которая свяжет `onCarClick` и объект `car`.
```
const Car = ({ car, onCarClick }) => {
const onClick = () => onCarClick(car);
return (
{car.model}
)
}
```
В этом случае нет никакой пользы оборачивать метод в `useCallback`, т.к. нам не важно, ссылка это на функцию с прошлого рендера или с текущего рендера, а `useCallback` как мы уже знаем не бесплатный.
Итоги
-----
Подытожить данную статью можно следующими словами. React хоть и поддерживает компоненты в виде классов, но имеет больше маневров над ускорением именно компонентов в виде функций. Да и сама экосистема все больше в качестве API предоставляет вам именно хуки, что невозможно использовать в классах:
```
import { useLocation } from "react-router-dom";
import { useSelector } from "react-redux";
import { useLocalObservable } from "mobx-react-lite";
import { useTranslation } from "react-i18next";
```
И конечно, доверяйте реакту, если они сказали лучше создавать функцию на каждый рендер, так и делайте, ведь они заинтересованы только в улучшении перформанса вашего проекта.
А если вам понравилось данная статья, то [здесь](https://www.youtube.com/playlist?list=PLz_dGYmQRrr-g02jHDzuu-6VlOt8-8Uu5) есть еще немного интересного.
Чао | https://habr.com/ru/post/529950/ | null | ru | null |
# Глубокое погружение в Linux namespaces
**Часть 1**
[Часть 2](https://habr.com/ru/post/459574/)
[Часть 3](https://habr.com/ru/post/541304/)
[Часть 4](https://habr.com/ru/post/549414/)
В этой серии постов мы внимательно рассмотрим один из главных ингредиентов в [контейнере](https://www.docker.com/resources/what-container) – namespaces. В процессе мы создадим более простой клон команды `docker run` – нашу собственную программу, которая будет принимать на входе команду (вместе с её аргументами, если таковые имеются) и разворачивать контейнер для её выполнения, изолированный от остальной системы, подобно тому, как вы бы выполнили `docker run` для запуска [из образа](https://docs.docker.com/engine/reference/run/).
Что такое namespace?
--------------------
[Linux namespace](http://man7.org/linux/man-pages/man7/namespaces.7.html) – это абстракция над ресурсами в операционной системе. Мы можем думать об namespace, как о ящике. В этом ящике находятся системные ресурсы, которые точно зависят от типа ящика (namespace). В настоящее время существует семь типов пространств имён (namespaces): Cgroups, IPC, Network, Mount, PID, User, UTS.
Например, Network namespace включает в себя системные ресурсы, связанные с сетью, такие как сетевые интерфейсы (например, `wlan0`, `eth0`), таблицы маршрутизации и т.д., Mount namespace включает файлы и каталоги в системе, PID содержит ID процессов и так далее. Таким образом, два экземпляра Network namespace **A** и **B** (соответствующие двум ящикам одного типа в нашей аналогии) могут содержать различные ресурсы – возможно, **A** содержит `wlan0`, тогда как **B** содержит `eth0` и отдельную копию таблицы маршрутизации.
Пространства имён (namespaces) – не какая-то дополнительная фича или библиотека, которую вам нужно установить, например, с помощью пакетного менеджера apt. Они предоставляются самим ядром Linux и уже являются необходимостью для запуска любого процесса в системе. В любой данный момент времени любой процесс **P** принадлежит ровно одному экземпляру namespace каждого типа. Поэтому, когда ему требуется сказать «обнови таблицу маршрутизации в системе», Linux показывает ему копию таблицы маршрутизации namespace, к которому он принадлежит в этот момент.
Для чего это нужно?
-------------------
Абсолютно ни для чег… конечно, я просто пошутил. Одним их замечательных свойств ящиков является то, что вы можете добавлять и удалять вещи из ящика и это никак не повлияет на содержимое других ящиков. Тут та же идея с namespaces – процесс **P** может «сойти с ума» и выполнить `sudo rm –rf /`, но другой процесс **Q**, принадлежащий другому Mount namespace, не будет затронут, поскольку они они используют отдельные копии этих файлов.
Обратите внимание, что содержащийся в namespace ресурс не обязательно представляет собой уникальную копию. В ряде случаев, возникших намеренно или ввиду бреши в безопасности, два и более namespaces будут содержать одну и ту же копию, например одного и того же файла. Таким образом, изменения, внесенные в этот файл в одном Mount namespace, фактически будут видны во всех других Mount namespaces, которые также ссылаются на него. Поэтому мы тут откажемся от нашей аналогии с ящиком, поскольку предмет не может одновременно находиться в двух разных ящиках.
Ограничение — это забота
------------------------
Мы можем видеть namespaces, которым принадлежит процесс! Типичным для Linux образом они отображаются как файлы в каталоге `/proc/$pid/ns` данного процесса с process id `$pid`:
```
$ ls -l /proc/$$/ns
total 0
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 cgroup -> cgroup:[4026531835]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 ipc -> ipc:[4026531839]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 mnt -> mnt:[4026531840]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 net -> net:[4026531957]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 pid -> pid:[4026531836]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 user -> user:[4026531837]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 uts -> uts:[4026531838]
```
Вы можете открыть другой терминал, выполнить ту же команду и это должно дать вам тот же результат. Это потому, что как мы упоминали ранее, процесс обязательно должен принадлежать некоторому пространству имён (namespace) и до тех пор, пока мы мы явно не зададим к какому, Linux добавляет его в namespaces по умолчанию.
Давайте немного вмешаемся в это. Во втором терминале мы можем выполнить что-то вроде этого:
```
$ hostname
iffy
$ sudo unshare -u bash
$ ls -l /proc/$$/ns
lrwxrwxrwx 1 root root 0 May 18 13:04 cgroup -> cgroup:[4026531835]
lrwxrwxrwx 1 root root 0 May 18 13:04 ipc -> ipc:[4026531839]
lrwxrwxrwx 1 root root 0 May 18 13:04 mnt -> mnt:[4026531840]
lrwxrwxrwx 1 root root 0 May 18 13:04 net -> net:[4026531957]
lrwxrwxrwx 1 root root 0 May 18 13:04 pid -> pid:[4026531836]
lrwxrwxrwx 1 root root 0 May 18 13:04 user -> user:[4026531837]
lrwxrwxrwx 1 root root 0 May 18 13:04 uts -> uts:[4026532474]
$ hostname
iffy
$ hostname coke
$ hostname
coke
```
Команда `unshare` запускает программу (опционально) в новом namespace. Флаг `-u` говорит ей запустить `bash` в новом UTS namespace. Обратите внимание, что наш новый процесс `bash` указывает на другой файл `uts`, тогда как все остальные остаются прежними.
> *Создание новых namespaces обычно требует доступа с правами суперпользователя. Здесь и далее мы будем считать, что как `unshare`, так и наша реализация выполняются с помощью `sudo`.*
Одним из следствий того, что мы только что проделали, является то, что теперь мы можем изменить системный hostname из нашего нового процесса bash и это не повлияет ни на какой другой процесс в системе. Вы можете проверить это, выполнив `hostname` в первом терминале и увидев, что имя хоста там не изменилось.
Но что, например, такое контейнер?
----------------------------------
Надеюсь, теперь у вас есть некоторое представление о том, что может делать namespace. Вы можете предположить, что контейнеры по своей сути — обыкновенные процессы с отличающимися от других процессов namespaces, и вы будете правы. Фактически это квота. Контейнер без квот не обязан принадлежать уникальному namespace каждого типа — он может совместно использовать некоторые из них.
Например, когда вы набираете `docker run --net=host redis`, всё, что вы делаете — говорите докеру не создавать новый Network namespace для процесса redis. И, как мы видели, Linux добавит этот процесс участником дефолтного Network namespace, как и любой другой обычный процесс. Таким образом, с точи зрения сети процесс redis точно такой же, как и все остальные. Это возможность настройки не только сети, `docker run` позволяет вам делать такие изменения для большей части существующих namespaces. Тут возникает вопрос, что же такое контейнер? Остаётся ли контейнером процесс, использующий все, кроме одного, общие namespace? ¯\\_(ツ)\_/¯ Обычно контейнеры идут вместе с понятием **изоляции**, достигаемой через namespaces: чем меньше количество namespaces и ресурсов, которые процесс делит с остальными, тем более он изолирован и это всё, что действительно имеет значение.
Изолирование
------------
В оставшейся части этого поста мы заложим основу для нашей программы, которую назовём `isolate`. `isolate` принимает команду в качестве аргументов и запускает её в новом процессе, изолированном от остальной системы и в ограниченном собственными namespaces. В следующих постах мы рассмотрим добавление поддержки отдельных namespaces для команды процесса, запускаемого `isolate`.
В зависимости от области применения, мы сфокусируемся на User, Mount, PID и Network namespaces. Остальные же будут относительно тривиальны для реализации после того, как мы закончим (фактически, мы добавим поддержку UTS здесь в первичной реализации программы). А рассмотрение, например, Cgroups, выходит за рамки этой серии (изучение cgroups — [другого компонента контейнеров](http://man7.org/linux/man-pages/man7/cgroups.7.html), используемого для управления тем, сколько ресурсов может использовать процесс).
Пространства имён могут очень быстро оказаться сложными и есть много разных путей, которыми можно воспользоваться при изучении каждого namespace, но мы не можем выбрать их все разом. Мы будем обсуждать только те пути, которые имеют отношение к разрабатываемой нами программе. Каждый пост будет начинаться с некоторых экспериментов в консоли над рассматриваемым namespace с целью разобраться с действиями, требуемыми для настройки этого namespace. В результате у нас уже будет представление о том, чего мы хотим достичь, а затем последует и соответствующая реализация в `isolate`.
> *Чтобы избежать перегрузки постов кодом, мы не будем включать такие вещи, как вспомогательные функции, не являющиеся необходимыми для понимания реализации. Вы можете найти полный исходный код [здесь на Github](https://github.com/iffyio/isolate).*
Реализация
----------
Исходный код для этого поста [можно найти здесь](https://github.com/iffyio/isolate/tree/part-1). Наша реализация `isolate` будет простой программой, которая считывает строку с командой из stdin и клонирует новый процесс, выполняющий её с указанными аргументами. Клонированный процесс с командой будет выполняться в собственном UTS namespace точно также, как мы делали это ранее с `unshare`. В следующих постах мы увидим, что namespaces не обязательно работают (или хотя бы обеспечивают изоляцию) из коробки и нам нужно будет выполнить некоторую настройку после их создания (но перед реальным запуском команды), чтобы команда действительно выполнялась изолированной.
Эта комбинация создания-настройки namespace потребует некоторого взаимодействия между основным процессом `isolate` и дочерним процессом запускаемой команды. В результате часть основной работы здесь будет заключаться в настройке связующего канала между обоими процессами — в нашем случае мы будем использовать [Linux pipe](https://www.tldp.org/LDP/lpg/node11.html) из-за его простоты.
Нам нужно сделать три вещи:
1. Создать основной процесс `isolate`, читающий данные из stdin.
2. Клонировать новый процесс, который будет запускать команду в новом UTS namespace.
3. Настроить пайп таким образом, чтобы процесс выполнения команды начинал её запуск только после получения сигнала от основного процесса о завершении настройки namespace.
Вот основной процесс:
```
int main(int argc, char **argv)
{
struct params params;
memset(¶ms, 0, sizeof(struct params));
parse_args(argc, argv, ¶ms);
// Создание пайпа для связи между основным и командным процессом.
if (pipe(params.fd) < 0)
die("Failed to create pipe: %m");
// Клонирование командного процесса.
int clone_flags = SIGCHLD | CLONE_NEWUTS ;
int cmd_pid = clone(cmd_exec, cmd_stack + STACKSIZE, clone_flags, ¶ms);
if (cmd_pid < 0)
die("Failed to clone: %m\n");
// Получить доступный к записи конец пайпа.
int pipe = params.fd[1];
// Тут будут размещаться некоторые настройки namespace ...
// Сигнал командному процессу, что мы закончили с настройкой.
if (write(pipe, "OK", 2) != 2)
die("Failed to write to pipe: %m");
if (close(pipe))
die("Failed to close pipe: %m");
if (waitpid(cmd_pid, NULL, 0) == -1)
die("Failed to wait pid %d: %m\n", cmd_pid);
return 0;
}
```
Обратите внимание на `clone_flags`, которые мы передаем в наш вызов `clone`. Видите, как просто создать процесс в его собственном namespace? Всё, что нам нужно сделать, это установить флаг для типа namespace (`CLONE_NEWUTS` флаг соответствует UTS namespace), а Linux позаботится об остальном.
Далее процесс команды ожидает сигнала перед её запуском:
```
static int cmd_exec(void *arg)
{
// Убить процесс cmd если процесс isolate умирает.
if (prctl(PR_SET_PDEATHSIG, SIGKILL))
die("cannot PR_SET_PDEATHSIG for child process: %m\n");
struct params *params = (struct params*) arg;
// Ожидание сигнала 'настройка завершена' от основного процесса.
await_setup(params->fd[0]);
char **argv = params->argv;
char *cmd = argv[0];
printf("===========%s============\n", cmd);
if (execvp(cmd, argv) == -1)
die("Failed to exec %s: %m\n", cmd);
die("¯\\_(ツ)_/¯");
return 1;
}
```
Наконец, мы может попробовать это запустить:
```
$ ./isolate sh
===========sh============
$ ls
isolate isolate.c isolate.o Makefile
$ hostname
iffy
$ hostname coke
$ hostname
coke
# Проверьте в новом окне терминала, что имя хоста не изменилось
```
Сейчас `isolate` — это немногим больше, чем программа, которая просто форкает команду (у нас есть UTS, работающий для нас). В следующем посте мы сделаем еще один шаг, рассмотрев User namespaces заставим `isolate` выполнять команду в собственном User namespace. Там мы увидим, что на самом деле надо проделать некоторую работу, чтобы иметь пригодный к использованию namespace, в котором может выполняться команда. | https://habr.com/ru/post/458462/ | null | ru | null |
# ZTools for Apache Zeppelin
Zeppelin is a web-based notebook for data engineers that enables data-driven, interactive data analytics with Spark, Scala, and more.
The project recently reached version *0.9.0-preview2* and is being actively developed, but there are still many things to be implemented.
One such thing is an API for getting comprehensive information about what's going on inside the notebook. There is already an API that completely solves the problems of high-level notebook management, but it doesn’t help if you want to do anything more complex.
That was a real problem for Big Data Tools, a plugin for IntelliJ IDEA that provides integration with Spark, Hadoop, and makes it possible to edit and run notebooks in Zeppelin.
The high-level API for creating and removing notebooks is not enough for the IDE. You need much lower-level access to do things like smart autocompletion or visual debugging.
This is why ZTools came to exist. It’s a tool that allows you to pull information from Zeppelin, even if it's not present in the API. The server-side code is publicly available on GitHub under the Apache License 2.0. About 90% of the code is written in Scala, and the rest is in Java.
ZTools will actually work with any Scala REPL, so it is not just for Zeppelin, but for dealing with Scala in general.
To understand what ZTools can do, we'll look at the Variables View panel and code editor in the Big Data Tools plugin. This plugin is a part of IntelliJ Ultimate Edition, and of course, its code is not open.
Nevertheless, this example shows how it might look like in your own product.
When you add a new notebook to Big Data Tools, there's an option to enable ZTools integration.
Now you can observe the values of local variables:
Wait, what? How is it possible to view the variables after the execution?
This simple feature is an alternative to the debugger and it’ll save you a lot of time. And if that's not enough, you can now autocomplete columns of the sql.DataFrame in the editor.
It looks and feels like magic, and this is what ZTools provides us. At the time of the paragraph's execution, it analyzes the context on the server and sends it to the client.
Part one: client-server communication
-------------------------------------
Let's try to understand how Zeppelin finds a list of local variables and columns.
There are two ways. We can go from the server side (the open-source code for this is available on GitHub), or from the client side (a closed-source part of IntelliJ IDEA).
The latter method is easier than it sounds: you can intercept traffic and see requests and responses.
Let's start with this and see how deep the rabbit hole goes. It might also teach us about an exciting hack on how to write clients for Zeppelin (spoiler: it does).
You can filter traffic in different ways, but I like to use a combination of mitmproxy and Wireshark. Sorry, I don’t have the time to go into the technical details of setting up these tools in this article.
Let's run some paragraphs from the standard Zeppelin example, "Spark Basic Features".
Let's go to mitmproxy and see what a typical Zeppelin server response to its standard API /api/notebook looks like (see [this gist](https://gist.github.com/olegchir/249c374e567ee0ab8ba8b222a922698d) for the full response).
There is no interesting data here, as expected. But it does lead to some interesting questions: Where are our local variables? Could it be that they are transmitted via WebSocket?
Now let’s go into Wireshark and look closely at the traffic:
After a little digging in the traffic, we see that immediately after starting a paragraph, some JSON with the full text of the paragraph is sent to the server. This is expected.
Now if you don’t blink, you’ll notice something really weird.
When you run a paragraph in Big Data Tools, for a split second an additional paragraph appears in your notebook in the IntelliJ IDEA interface, and then disappears:
Let's take a look at how this affects traffic.
First, this temporary paragraph was sent to the server. The full text of the request [is here](https://gist.github.com/olegchir/e1fdb3e0fa5578face7b2ba9cc3665e6), but we are only interested in this piece of it:
```
%spark
// It is generated code for integration with Big Data Tools plugin
// Please DO NOT edit it.
import org.jetbrains.ztools.spark.Tools
Tools.init($intp, 3, true)
println(Tools.getEnv.toJsonObject.toString)
println("----")
println(Tools.getCatalogProvider("spark").toJson)"
```
This is the code of that temporary paragraph that mysteriously appeared and then disappeared. This is where the call to ZTools comes in, and it gives us a clue as to which functions we need to examine first in the GitHub repository.
The server returns a lot of data chunks, but we’re only interested in two of them:
1. [One](https://gist.github.com/olegchir/37c1d4ab1434ddd1d5542cd96a7de936) contains the complete structure and values of the `bank` and `bankText` local variables.
2. [The other](https://gist.github.com/olegchir/7fc2774ebee34924e08839d626a104b3) contains the dataframe columns.
Now we’ve found everything we were looking for: client requests, server response, and how exactly the additional data is transferred.
Keep reading to find out whether we can apply the same technique to our own application (another spoiler: we can).
Summary of part one
-------------------
* Thanks to traffic scanning, we learned an essential trick for writing Zeppelin clients using ZTools: you can add a temporary paragraph, call ZTools, and then immediately delete the temporary paragraph (before anyone notices it). This is how the Big Data Tools plugin works.
* Inside the temporary paragraph, we can see calls to the `Tools` class. That gives us a good starting point for examining the ZTools source code on GitHub.
Part two: ZTools source code
----------------------------
You can find ZTools sources [on GitHub](https://github.com/jetbrains/ztools).
The repository consists mainly of two large parts: "scala-repl" and "spark".
Let’s take a look at that temporary paragraph code again:
```
%spark
// It is generated code for integration with Big Data Tools plugin
// Please DO NOT edit it.
import org.jetbrains.ztools.spark.Tools
Tools.init($intp, 3, true)
println(Tools.getEnv.toJsonObject.toString)
println("----")
println(Tools.getCatalogProvider("spark").toJson)"
```
The last line lists columns in the dataframe using the Spark function `Catalog.listTables() and Catalog.listColumns() then` transforms them into JSON and sends them to the client.
Even more interesting is where the local variables come from. When `Tools` is initialized, something called VariablesView is created, and there's a whole separate subproject dedicated to it. Let's take a look inside the VariablesView subproject.
If you look at the tests, it should become instantly clear how to use it:
```
@Test
def testSimpleVarsAndCollections(): Unit = {
withRepl { intp =>
intp.eval("val x = 1")
val view = intp.getVariablesView()
assertNotNull(view)
var json = view.toJsonObject
println(json.toString(2))
val x = json.getJSONObject("x")
assertEquals(2, x.keySet.size)
assertEquals(1, x.getInt("value"))
assertEquals("Int", x.getString("type"))
assertEquals(1, json.keySet.size)
}
```
It lets us interpret arbitrary Scala code and retrieve information about the variables in it.
The actual interpretation of the code is carried out by the standard Scala compiler, or to be more precise, by the [scala.tools.nsc.interpreter](https://www.scala-lang.org/api/2.12.3/scala-compiler/scala/tools/nsc/interpreter/index.html) package.
```
def withRepl[T](body: Repl => T): T = {
// ...
val iLoop = new ILoop(None, new JPrintWriter(Console.out, true))
iLoop.intp = new IMain(iLoop.settings)
// ...
}
```
First, the ILoop is created, this is the main loop of the interpreter. Inside it is IMain – this is the interpreter itself. Now we call `interpret(code)` and that's it.
Information about variables is obtained through the following trait:
```
trait VariablesView {
def toJson: String
def toJsonObject: JSONObject
def toJsonObject(path: String, deep: Int): JSONObject
def variables(): List[String]
def valueOfTerm(id: String): Option[Any]
def registerTypeHandler(handler: TypeHandler): VariablesView
def typeOfExpression(id: String): String
}
```
Of all these methods, the most important is the one that gets the list of variables. There’s nothing supernatural going on here at all, it's implemented by a direct request to the Scala interpreter, iMain:
```
override def variables(): List[String] =
iMain.definedSymbolList.filter { x => x.isGetter }.map(_.name.toString).distinct
```
The function that renders the JSON of the "temporary paragraph" is much more interesting. Inside toJsonObject() is some complex dark magic that allows you to wander through the links between dependent variables and limit the number of collections and strings that are sent.
By default, the maximum collection size is 100, and the maximum string length is 400 characters. So you don't have to worry that a terabyte of commas will be sent over the network to the client (the Big Data Tools plugin or your own app), and make everything hang forever. These limits are currently hardcoded, but if I had my way, I would move them to the settings.
If you use ZTools through the `Tools` class, some variables are unavailable to you. Things like $intp, sc, spark, sqlContext, z, and engine are banned. If you are writing your own launcher, you should also consider creating a similar filter.
Summary of part two
-------------------
* With ZTools, you can get a variety of data from Zeppelin without cluttering up the public API.
* Currently, only the data that exists during the lifetime of our temporary paragraph is available.
* When you are inside Zeppelin, interpreting Scala code is easy. Especially when you already have a REPL binding from the ZTools project. You don't have to limit yourself to ideas from ZTools, and you can add things on your own.
* The data is limited: 400 characters per line, 100 elements per collection, and some stoplisted variables that will never get into your JSON.
Part four: writing your own client
----------------------------------
Let's take advantage of the fact that ZTools can work without IntelliJ IDEA and write our own client app. A working example can be found in [this GitHub repository](https://github.com/olegchir/olegchir-zeppelin-demo-client.git).
To prove it doesn't depend on Java, let's write everything in JavaScript (TypeScript, to be more precise) and Node.js. We will use Axios as a library for HTTP requests – as it has a pretty nice interface with promises.
First, let's find a specific notebook on the server. I really like the "Spark Basic Features" notebook from the sample library.
```
const notes = await *axios*.get(NOTE_LIST_URL);
let noteId: string = null;
for (let item: Object of notes.data.body) {
if ( item.path.indexOf('Spark Basic Features') >= 0 ) {
noteId = item.id;
break;
}
}
```
Now let's create our temporary paragraph:
```
const PAR_TEXT = `%spark
import org.jetbrains.ztools.spark.Tools
Tools.init($intp, 3, true)
println(Tools.getEnv.toJsonObject.toString)
println("----")
println(Tools.getCatalogProvider("spark").toJson)`;
```
And new let’s create the temporary paragraph create on the server side:
```
const CREATE_PAR_URL = `${Z_URL}/api/notebook/${noteId}/paragraph`;
const par: Object = await axios.post(CREATE_PAR_URL, {
title: 'temp',
text: PAR_TEXT,
index: 0
});
```
And run it:
```
const RUN_PAR_URL = `${Z_URL}/api/notebook/run/${noteId}/${parId}`;
await axios.post(RUN_PAR_URL);
Получим ответ:
const INFO_PAR_URL = `${Z_URL}/api/notebook/${noteId}/paragraph/${parId}`;
const { data } = await axios.get(INFO_PAR_URL);
```
Then we will delete it, because it's useless now:
```
const DEL_PAR_URL = `${Z_URL}/api/notebook/${noteId}/paragraph/${parId}`;
await axios.delete(DEL_PAR_URL);
```
The received response needs to be cut into two parts and parsed as JSON:
```
const [varInfoData, dbInfoData] = (data.body.results.msg[0].data)
.replace('\nimport org.jetbrains.ztools.spark.Tools\n', '')
.split('\n----\n');
const varInfo = JSON.parse(varInfoData);
const dbInfo = JSON.parse(dbInfoData);
```
Now, let's list all the variables:
```
for (const [key, {type}] of Object.entries(varInfo)) {
console.log(`${key} : ${type}`);
}
```
And here is our schema:
```
for (const [key, database] of Object.entries(dbInfo.databases)) {
console.log(`Database: ${database.name} (${database.description})`);
for (const table of database.tables) {
const columnsJoined = table.columns.map(val => `${val.name}/${val.dataType}`).join(', ');
Logger.direct(`${table.name} : [${columnsJoined}]`);
}
}
```
See how easy that was? You can write this code faster than I can finish my third cup of morning coffee.
Part five: distribution
-----------------------
It's not enough just to write a client for Zeppelin – you also need to change the Zeppelin server settings to install ZTools.
But on a big production server, you probably don't have the permissions you need to do this. You'll have to ~~beg~~ ask the system administrators. There's absolutely no way to avoid this, and that makes me sad.
As for the installation process itself, if you use vanilla ZTools without any patches, you can use our public repository. You can add it as a Maven artifact or a separate JAR file.
* Repository: <https://jetbrains.bintray.com/zeppelin-dependencies>
* Artifact: org.jetbrains.ztools:ztools-spark-all:0.0.13
* JAR file: <https://dl.bintray.com/jetbrains/zeppelin-dependencies/org/jetbrains/ztools/ztools-spark-all/0.0.13/ztools-spark-all-0.0.13.jar>
If you want to extend ZTools yourself, you can build a project from sources using Gradle. You will get a JAR file, and then you’re free to deploy it as you like under the open-source Apache License 2.0.
Big Data Tools automatically installs ZTools on the connected Zeppelin servers. We strongly recommend that you take this route.
Summary
-------
* With ZTools, you can get a variety of data from Zeppelin without cluttering up the public API.
* The code that does that is quite simple and straightforward, and is distributed under the open-source Apache License 2.0.
* If your security folks need to monitor traffic this article shows that the traffic content is quite understandable even for people without special skills.
* Writing client code can be complicated. But now you know the "temporary paragraph" trick and can get some inspiration from the Big Data Tools user interface. | https://habr.com/ru/post/522272/ | null | en | null |
# Photoshop Scripting для автоматизации печати многотиражной полиграфической продукции
Здравствуйте. Хотелось бы поделиться опытом автоматизации процесса печати большого количества документов из Adobe Photoshop.
Задача состоит в следующем:
имеется большое количество (в моем случае — 100 000 шт.) уже напечатанных документов. Необходимо на них в определенных местах определенным шрифтом напечатать их порядковый номер в заданном формате (или любую строку, сформированную по определенному алгоритму).
Чтобы было более понятно, приведу пример.
Исходное изображение:
Что должно получиться:
и таких — 100 000 документов. Явно, что вручную такой объем осилить достаточно сложно, поэтому надо искать возможности автоматизации.
В процессе поиска решения задачи автоматической нумерации документов по определенному алгоритму при печати, был найден способ, который использует Corel Draw и MS Office: генерируем таблицу с нужными значениями, производим слияние, и Corel генерирует нам необходимое количество листов с нужным содержанием. Вроде бы все — ничего, но все листы должны быть в памяти, а это говорит, что ресурсоемкость выполнения задачи возрастает с количеством печатаемых изделий. Кому интересно, вот ссылка на видео — [Нумерация в Corel Draw](http://www.youtube.com/watch?v=IVFbAyOy8Q0). Безусловно, существуют макросы в Corel, но я с Corel не так хорошо знаком, как с Photoshop, поэтому именно Photoshop был выбран для решения поставленной задачи.
#### Решение
Приведу пример скрипта, который выполняет необходимые операции:
```
var start1 = 1; //номер, с которого начинать нумерацию
var count = 100000; //общее количество экземпляров
var doc = app.activeDocument;
var layer = doc.layers.getByName("text1");
function changeTextByLayerName(layerName,newText){ //функция изменения содержания текстового слоя по его имени на переданную строку
layer = doc.layers.getByName(layerName);
if(layer.kind == LayerKind.TEXT) layer.textItem.contents = newText; //присваиваем содержимое
}
function printIt(){ //функция отправки на печать
app.bringToFront();
doc.printSettings.flip = false;
doc.printSettings.setPagePosition(DocPositionStyle.SIZETOFIT);
doc.printSettings.negative = false;
doc.printOneCopy();
}
for(a=start1; a<=count; a++){
changeTextByLayerName("text1", a);
changeTextByLayerName("text2", a);
changeTextByLayerName("text3", a);
changeTextByLayerName("text4", a);
$.sleep(2000); //задержка выполнения на 2 секунды, чтобы принтер успел обрабатывать запросы
printIt();
}
```
Скрипты для Adobe Photoshop имеют расширение jsx.
Для успешного выполнения данного скрипта, необходимо иметь в открытом виде photoshop-проект с текстовыми слоями,
имена которых — text1, text2, text3, и text4.
Управление скриптом осуществляется из программы ExtendScript Toolkit.
Обратите внимание на то, что в левом верхнем углу окна программы ExtendScript Toolkit необходимо выбрать Adobe Photoshop, иначе скрипт не запустится.
Спешу отметить тот факт, что скрипт ни в коем случае не претендует на образец для подражания, был написан «на скорую руку» и показывает лишь возможность автоматизации описанного выше процесса.
Полезной информацией является то, что вместо
```
changeTextByLayerName("text4", a);
```
можно использовать
```
changeTextByLayerName("text4", "000" + a);
```
что явно демонстрирует возможность приведения типов и конкатенации строк.
С документацией по Photoshop Scripting можно ознакомиться [тут](http://www.adobe.com/devnet/photoshop/scripting.html).
Спасибо за внимание, надеюсь мое решение будет полезно общественности. | https://habr.com/ru/post/165517/ | null | ru | null |
# Первые шаги в Java: как начать разрабатывать ничего не устанавливая
По прошествию многих лет я подумал, а как бы я разрабатывал свою первую программу на Java, если бы я начал сегодня?
Знакомство с Java было в университете и при воспоминаниях об этом бросает в холодный пот. Кроме нового незнакомого языка, приходилось устанавливать какой-то JDK, потом IDE, потом создавать первый проект и вручную добавлять в него библиотеки. Делать по аналогии с готовыми программами и ловить неизведанные java.lang.ClassNotFoundException и java.lang.NoSuchMethodException и тому подобный ужас. Когда знал как работать только в операционной системе Windows и доступ в интернет был по модему через телефонную линию.
Надеюсь интересно будет как тем, кто делает первые шаги в java и тем, кто помнит jdk 1.4. Попробуем online IDE Eclipse Che.
Оговорюсь про главное условие — сейчас у вас должен быть **стабильный доступ в интернет**. И конечно же после прочтении статьи вы не получите работу Java архитектором в Нью-Йорке за 180 000 $ в год и даже не выучите Java за 21 день. Просто разработаем в современном окружении свой Hello world в несколько строчек кода, но **с веб сервером**.
Облачная IDE и разработка в Docker контейнере
=============================================
Открытое программное обеспечение Eclipse Che — IDE нового поколения для коллективной разработки ПО. Не столь привычно нам «старичкам», но позволяет разрабатывать имея локально лишь современный браузер и стабильный доступ к сети. Сервер Che может быть запущен в локальной сети. Для быстрого старта нам даже не нужно ничего устанавливать!!!
Перейдите по ссылке [Eclipse Che](https://www.eclipse.org/che/getting-started/cloud/?https://habrahabr.ru/post/310438/). Там возможно создать бесплатный аккаунт на codenvy.com. Можно зарегистрировать его на свою почту, либо воспользоваться OAuth провайдерами: Github, Google или Microsoft online.
На стороне сервера автоматически создается Docker контейнер с уже настроенным окружением для разработки. С помощью агента в контейнере к нему подключается IDE на javascript из вашего браузера.
При создании из шаблона «Java» в контейнере обычная сборка Ubuntu, а это значит что можно устанавливать необходимые вам для работы пакеты. Шаблон «Eclipse Che» основан на Alipine — минималистичной сборке linux под Docker и там такой свободы у вас нет.
Итак о чем я это. Если вы не знаете что это такое, пока можете даже не беспокоиться об этом. **Все работает** и так «из коробки», пусть на первом шаге это будет казаться магией! Со временем при желании разобраться во всем этом довольно просто.
Создадим новый «Workspace» из шаблона «Java». Прийдется посмотреть мультфильм со строительным краном, пока создается ваше пространство для разработки.
В вашем окружении разработки будут доступны Oracle JDK 8u45 и Maven 3.3.9. Точно также легко можно начать разработку на основе проекта с Github.
**Готовим окружение для проекта...**
Система управления зависимостями и сборки
=========================================
Стандартом де-факто в мире Java является [Maven](https://maven.apache.org) и, наверное, самая лучшая поддержка в разных IDE. [Gradle](https://gradle.org) более молодой проект и он заслуживает право стать вашим выбором №1. Но при выходе на работу Java разработчиком вероятность встретить Maven гораздо выше, особенно на унаследованных проектах. К тому же он тоже пытается молодиться и уйти от XML формата за счет проекта [Polyglot](https://github.com/takari/polyglot-maven). Atom, Groovy, Clojure, Ruby, Scala, YAML — как основа для написания файла сборки. Тут история как и с языком программирования в JVM. Несмотря на существование Groovy, Scala, JRuby, Jython, Clojure всю их мощь и лаконичность, язык Java живее всех живых. И даже не сравнивайте Java с вождем — язык программирования живой и хоть медленно, но развивается.
Проект по-умолчанию console-java-simple предложит нам любимый Hello World.
Предлагаю чуть усложнить наш первый шаг и добавить Apache Camel в проект. Источники и приемники данных и вся сложность работы с технологиями скрываются за Url синтаксисом внутри его компонент и мы не будем погружаться глубоко.
Магия «верблюда»
================
Eclipse Che создал для нас нас шаблон проекта, который мы сейчас отредактируем и создадим наше веб приложение.
[Apache Camel](http://camel.apache.org/?from=https://habrahabr.ru/post/310438/) — это open source интеграционный фреймворк и нам он нужен лишь для простого Hello World. Добавим его библиотеки в pom.xml зависимость на ядро «верблюда» и компонент jetty веб сервера.
```
org.apache.camel
camel-core
2.18.0
org.apache.camel
camel-jetty
2.18.0
```
Для того, чтобы компилировались лямбды добавим в этот же файл:
```
1.8
1.8
```
После этого отредактируем файл /console-java-simple/src/main/java/org/eclipse/che/examples/HelloWorld.java заодно прочувствуем как работает эта online IDE.
```
package org.eclipse.che.examples;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.main.Main;
public class HelloWorld {
public static void main(String[] argvs) throws Exception {
Main main = new Main();
main.addRouteBuilder(new RouteBuilder() {
@Override
public void configure() throws Exception {
from("jetty:http://0.0.0.0:8080")
.process(exchange -> {exchange.getIn().setBody("Hello World");});
}
});
main.run(argvs);
}
}
```
**Для того чтобы можно было запустить пример командой mvn clean install exec:java нужно добавить в pom.xml exec-maven-plugin**
```
org.codehaus.mojo
exec-maven-plugin
1.5.0
java
org.eclipse.che.examples.HelloWorld
```
Запустим проект командой из терминала
```
mvn clean install exec:java
```
Или отредактируем конфигурацию запуска «по щелчку» в IDE.
Подключиться к нашему веб приложению из внешнего мира можно по адресу из столбца «Server Address» для строки «tomcat8». Как это сделать можете посмотреть в видео дальше:
Результат работы нашей программы:
В этом примере создается Apache Camel и его маршрут обработки данных. Маршрут начинается с веб сервера jetty, который слушает http запросы на порту 8080. При получении запроса мы создаем ответ с помощью строчки **process(exchange -> {exchange.getIn().setBody(«Hello World»);})**.
Скринкаст процесса написания java кода (без звука и мата) в Che и запуска программы Hello World:
Что дальше?
===========
Достаточно доступа в интернет и браузера в 2016 году чтобы учиться разрабатывать на Java. Не надо решать 1000 и 1 проблему с установкой и настройкой IDE и окружения, чтобы начать учиться программировать.
А еще не верьте курсам что вас научат программировать на Java за 21 день и тому подобному маркетингу. Чтобы познать дзен разработки на Java нужны годы. Учиться, учиться и еще раз учиться! | https://habr.com/ru/post/310438/ | null | ru | null |
# Patroni cluster (with Zookeeper) in a docker swarm on a local machine
Intro
-----
There probably is no way one who stores some crucial data (in particular, using SQL databases) can possibly dodge from the thoughts of building some kind of safe cluster, distant guardian to protect consistency and availability at all times. Even if the main server with all the precious data gets knocked out deadly - the show must go on, right? This basically means the database must still be available and data be up-to-date with the one on the failed server.
As you might have noticed, there are dozens of ways to go and Patroni is just one of them. There is plenty of articles providing a more or less detailed comparison of the options available, so I assume I'm free to skip the part of luring you into Patroni's side. Let's start off from the point where among others you are already leaning towards Patroni and are willing to try that out in a more or less real-case setup.
As for myself, I did try a couple of other solutions and in one of them (won't name it) my issue seems to be still hanging open and not answered on their GitHub even though months have passed.
Btw, I am not a DevOps engineer originally so when the need for the high-availability cluster arose and I went on I would hit my bones against the bottom of every single bump and every single post and rock down the road. Hope this tutorial will help you out to get the job done with as little pain as it is possible.
If you don't want any more explanations and lead-ins, jump right in.
Otherwise, you might want to read some more notes on the setup I went on with.
One more Patroni tut, huh?### Do we need one more Patroni tut?
Let's face it, there are quite enough tutorials published on how to set up the Patroni cluster. This one is covering deployment in a docker swarm with Zookeeper as a DCS. So why zookeeper and why docker swarm?
#### Why Zookeeper?
Actually, it's something you might want to consider seriously choosing a Patroni setup for your production.
The thing is that Patroni uses third-party services basically to establish and maintain communication among its nodes, the so-called DCS (Dynamic Configuration Storage).
If you have already studied tutorials on Patroni you probably noticed that the most common case is to implement communication through the 'etcd' cluster.
The notable thing about etcd is here (from its faq page):
```
Since etcd writes data to disk, its performance strongly depends on disk
performance. For this reason, SSD is highly recommended.
```
If you don't have SSD on each machine you are planning to run your etcd cluster, it's probably not a good idea to choose it as a DCS for Patroni. In a real production scenario, it is possible that you simply overwhelm your etcd cluster, which might lead to IO errors. Doesn't sound good, right?
So here comes Zookeeper which stores all its data in memory and might actually come in handy if your servers lack SDDs but have got plenty of RAM.
### Why docker swarm?
In my situation, I had no other choice as it was one of the business requirements to set it up in a docker swarm. So if by circumstances it's your case as well, you're exactly in the right spot!
But for the rest of the readers with the "testing and trying" purposes, it comes across as quite a distant choice too as you don't need to install/prepare any third-party services (except for docker of course) or place on your machine dozens of dependencies.
Guess it's not far from the truth that we all have Docker engine installed and set up everywhere anyway and it's convenient to keep everything in containers. With one-command tuning, docker is good enough to run your first Patroni cluster locally without virtual machines, Kubernetes, and such.
So if you don't want to dig into other tools and want to accomplish everything neat and clean in a well-known docker environment this tutorial could be the right way to go.
Some extra
----------
In this tutorial, I'm also planning to show various ways to check on the cluster stats (to be concrete will cover all 3 of them) and provide a simple script and strategy for a test run.
Suppose it's enough of talking, let's go ahead and start practicing.
Docker swarm
------------
For a quick test of deployment in the docker swarm, we don't really need multiple nodes in our cluster. As we are able to scale our services at our needs (imitating failing nodes), we are going to be fine with just one node working in a swarm mode.
I come from the notion that you already have the Docker engine installed and running. From this point all you need is to run this command:
```
docker swarm init
//now check your single-node cluster
docker node ls
ID HOSTNAME STATUS AVAILABILITY
a9ej2flnv11ka1hencoc1mer2 * floitet Ready Active
```
> The most important feature of the docker swarm is that we are now able to manipulate not just simple containers, but services. Services are basically abstractions on top of containers. Referring to the OOP paradigm, docker service would be a class, storing a set of rules and container would be an object of this class. Rules for services are defined in docker-compose files.
>
>
Notice your node's hostname, we're going to make use of it quite soon.
Well, as a matter of fact, that's pretty much it for the docker swarm setup.
Seem like we're doing fine so far, let's keep up!
Zookeeper
---------
Before we start deploying Patroni services we need to set up DCS first which is Zookeeper in our case. I'm gonna go for the 3.4 version. From my experience, it works just fine.
Below are the full docker-compose config and some notes on details I find that it'd be reasonable to say a few words about.
docker-compose-zookeeper.yml
```
version: '3.7'
services:
zoo1:
image: zookeeper:3.4
hostname: zoo1
ports:
- 2191:2181
networks:
- patroni
environment:
ZOO_MY_ID: 1
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
zoo2:
image: zookeeper:3.4
hostname: zoo2
networks:
- patroni
ports:
- 2192:2181
environment:
ZOO_MY_ID: 2
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
zoo3:
image: zookeeper:3.4
hostname: zoo3
networks:
- patroni
ports:
- 2193:2181
environment:
ZOO_MY_ID: 3
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
networks:
patroni:
driver: overlay
attachable: true
```
DetailsThe important thing of course is to give every node its unique service name and published port. The hostname is preferably be set to the same as the service name.
```
zoo1:
image: zookeeper:3.4
hostname: zoo1
ports:
- 2191:2181
```
Notice how we list servers in this line, changing the service we bind depending on the service number. So for the first (zoo1) service server.1 is bound to 0.0.0.0, but for zoo2 it will be the server.2 accordingly.
```
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
```
This is how we control the deployment among nodes. As we have only one node, we set a constraint to this node for all services. When you have multiple nodes in your docker swarm cluster and want to spread services among all nodes - just replace node.hostname with the name of the desirable node (use 'docker node ls' command).
```
placement:
constraints:
- node.hostname == floitet
```
And the final thing we need to take care of is the network. We're going to deploy Zookeeper and Patroni clusters in one overlay network so that they could communicate with each other in an isolated environment using the service names.
```
networks:
patroni:
driver: overlay
// we need to mark this network as attachable
// so that to be able to connect patroni services to this network later on
attachable: true
```
Guess it's time to deploy the thing!
```
sudo docker stack deploy --compose-file docker-compose-zookeeper.yml patroni
```
Now let's check if the job is done right. The first step to take is this:
```
sudo docker service ls
gxfj9rs3po7z patroni_zoo1 replicated 1/1 zookeeper:3.4 *:2191->2181/tcp
ibp0mevmiflw patroni_zoo2 replicated 1/1 zookeeper:3.4 *:2192->2181/tcp
srucfm8jrt57 patroni_zoo3 replicated 1/1 zookeeper:3.4 *:2193->2181/tcp
```
And the second step is to actually ping the zookeeper service with the special Four-Letter-Command:
```
echo mntr | nc localhost 2191
// with the output being smth like this
zk_version 3.4.14-4c25d480e66aadd371de8bd2fd8da255ac140bcf, built on 03/06/2019 16:18 GMT
zk_avg_latency 6
zk_max_latency 205
zk_min_latency 0
zk_packets_received 1745
zk_packets_sent 1755
zk_num_alive_connections 3
zk_outstanding_requests 0
zk_server_state follower
zk_znode_count 16
zk_watch_count 9
zk_ephemerals_count 4
zk_approximate_data_size 1370
zk_open_file_descriptor_count 34
zk_max_file_descriptor_count 1048576
zk_fsync_threshold_exceed_count 0
```
Which means that the zookeeper node is responding and doing its job. You could also check the zookeeper service logs if you wish
```
docker service logs $zookeeper-service-id
// service-id comes from 'docker service ls' command.
// in my case it could be
docker service logs gxfj9rs3po7z
```
Okay, great! Now we have the Zookeeper cluster running. Thus it's time to move on and finally, get to the Patroni itself.
Patroni
-------
And here we are down to the main part of the tutorial where we handle the Patroni cluster deployment. The first thing I need to mention is that we actually need to build a Patroni image before we move forward. I'll try to be as detailed and precise as possible showing the most important parts we need to be aware of managing this task.
We're going to need multiple files to get the job done so you might want to keep them together. Let's create a 'patroni-test' directory and cd to it. Below we are going to discuss the files that we need to create there.
* **patroni.yml**
This is the main config file. The thing about Patroni is that we are able to set parameters from different places and here is one of them. This file gets copied into our custom docker image and thus updating it requires rebuilding the image. I personally prefer to store here parameters that I see as 'stable', 'permanent'. The ones I'm not planning to change a lot. Below I provide the very basic config. You might want to configure more parameters for a PostgreSQL engine, for example (i.e. max\_connections, etc). But for the test deployment, I think this one should be fine.
patroni.yml
```
scope: patroni
namespace: /service/
bootstrap:
dcs:
ttl: 30
loop_wait: 10
retry_timeout: 10
maximum_lag_on_failover: 1048576
postgresql:
use_pg_rewind: true
postgresql:
use_pg_rewind: true
initdb:
- encoding: UTF8
- data-checksums
pg_hba:
- host replication all all md5
- host all all all md5
zookeeper:
hosts:
- zoo1:2181
- zoo2:2181
- zoo3:2181
postgresql:
data_dir: /data/patroni
bin_dir: /usr/lib/postgresql/11/bin
pgpass: /tmp/pgpass
parameters:
unix_socket_directories: '.'
tags:
nofailover: false
noloadbalance: false
clonefrom: false
nosync: false
```
DetailsWhat we should be aware of is that we need to specify 'bin\_dir' correctly for Patroni to find Postgres binaries. In my use case, I have Postgres 11 so my directory looks like this: '/usr/lib/postgresql/11/bin'. This is the directory Patroni is going to be looking for an inside container. And 'data\_dir' is where the data will be stored inside the container. Later on, we'll bind it to the actual volume on our drive so that not to lose all the data if the Patroni cluster for some reason fails.
```
postgresql:
data_dir: /data/patroni
bin_dir: /usr/lib/postgresql/11/bin
```
I also list all the zookeeper servers here to feed them to patronictl later. Note that, If you don't specify it here we'll end up with a broken patroni command tool (patronictl). Also, I'd like to point out that we don't use IPs to locate zookeeper servers, but we feed Patroni with 'service names' instead. It's a feature of a docker swarm we are taking advantage of.
```
zookeeper:
hosts:
- zoo1:2181
- zoo2:2181
- zoo3:2181
```
* **patroni\_entrypoint.sh**
The next one is where most settings come from in my setup. It's a script that will be executed after the docker container is started.
patroni\_entrypoint.sh
```
#!/bin/sh
readonly CONTAINER_IP=$(hostname --ip-address)
readonly CONTAINER_API_ADDR="${CONTAINER_IP}:${PATRONI_API_CONNECT_PORT}"
readonly CONTAINER_POSTGRE_ADDR="${CONTAINER_IP}:5432"
export PATRONI_NAME="${PATRONI_NAME:-$(hostname)}"
export PATRONI_RESTAPI_CONNECT_ADDRESS="$CONTAINER_API_ADDR"
export PATRONI_RESTAPI_LISTEN="$CONTAINER_API_ADDR"
export PATRONI_POSTGRESQL_CONNECT_ADDRESS="$CONTAINER_POSTGRE_ADDR"
export PATRONI_POSTGRESQL_LISTEN="$CONTAINER_POSTGRE_ADDR"
export PATRONI_REPLICATION_USERNAME="$REPLICATION_NAME"
export PATRONI_REPLICATION_PASSWORD="$REPLICATION_PASS"
export PATRONI_SUPERUSER_USERNAME="$SU_NAME"
export PATRONI_SUPERUSER_PASSWORD="$SU_PASS"
export PATRONI_approle_PASSWORD="$POSTGRES_APP_ROLE_PASS"
export PATRONI_approle_OPTIONS="${PATRONI_admin_OPTIONS:-createdb, createrole}"
exec /usr/local/bin/patroni /etc/patroni.yml
```
Details: Important!Actually, the main point of even having this ***patroni\_entrypoint.sh*** is that Patroni won't simply start without knowing the IP address of its host. And for the host being a docker container we are in a situation where we somehow need to first get to know which IP was granted to the container and only then execute the Patroni start-up command. This indeed crucial task is handled here
```
readonly CONTAINER_IP=$(hostname --ip-address)
readonly CONTAINER_API_ADDR="${CONTAINER_IP}:${PATRONI_API_CONNECT_PORT}"
readonly CONTAINER_POSTGRE_ADDR="${CONTAINER_IP}:5432"
...
export PATRONI_RESTAPI_CONNECT_ADDRESS="$CONTAINER_API_ADDR"
export PATRONI_RESTAPI_LISTEN="$CONTAINER_API_ADDR"
export PATRONI_POSTGRESQL_CONNECT_ADDRESS="$CONTAINER_POSTGRE_ADDR"
```
As you can see, in this script, we take advantage of the 'Environment configuration' available for Patroni. It's another way aside from the patroni.yml config file, where we can set the parameters. 'PATRONI\_*RESTAPI\_*CONNECT*ADDRESS', 'PATRONI\_RESTAPI\_*LISTEN', 'PATRONI\_*POSTGRESQL*CONNECT\_ADDRESS' are those environment variables Patroni knows of and is applying automatically as setup parameters. And btw, they overwrite the ones set locally in patroni.yml
And here is another thing. Patroni docs do not recommend using superuser to connect your apps to the database. So we are going to this another user for connection which can be created with the lines below. It is also set through special env variables Patroni is aware of. Just replace 'approle' with the name you like to create the user with any name of your preference.
```
export PATRONI_approle_PASSWORD="$POSTGRES_APP_ROLE_PASS"
export PATRONI_approle_OPTIONS="${PATRONI_admin_OPTIONS:-createdb, createrole}"
```
And with this last line, where everything is ready for the start we execute Patroni with a link to patroni.yml
```
exec /usr/local/bin/patroni /etc/patroni.yml
```
* **Dockerfile**
As for the Dockerfile I decided to keep it as simple as possible. Let's see what we've got here.
Dockerfile
```
FROM postgres:11
RUN apt-get update -y\
&& apt-get install python3 python3-pip -y\
&& pip3 install --upgrade setuptools\
&& pip3 install psycopg2-binary \
&& pip3 install patroni[zookeeper] \
&& mkdir /data/patroni -p \
&& chown postgres:postgres /data/patroni \
&& chmod 700 /data/patroni
COPY patroni.yml /etc/patroni.yml
COPY patroni_entrypoint.sh ./entrypoint.sh
USER postgres
ENTRYPOINT ["bin/sh", "/entrypoint.sh"]
```
DetailsThe most important thing here is the directory we will be creating inside the container and its owner. Later, when we mount it to a volume on our hard drive, we're gonna need to take care of it the same way we do it here in Dockerfile.
```
// the owner should be 'postgres' and the mode is 700
mkdir /data/patroni -p \
chown postgres:postgres /data/patroni \
chmod 700 /data/patroni
...
// we set active user inside container to postgres
USER postgres
```
The files we created earlier are copied here:
```
COPY patroni.yml /etc/patroni.yml
COPY patroni_entrypoint.sh ./entrypoint.sh
```
And like it was mentioned above at the start we want to execute our entry point script:
```
ENTRYPOINT ["bin/sh", "/entrypoint.sh"]
```
That's it for handling the pre-requisites. Now we can finally build our patroni image. Let's give it a sound name 'patroni-test':
```
docker build -t patroni-test .
```
When the image is ready we can discuss the last but not least file we're gonna need here and it's the compose file, of course.
* **docker-compose-patroni.yml**
A well-configured compose file is something really crucial in this scenario, so let's pinpoint what we should take care of and which details we need to keep in mind.
docker-compose-patroni.yml
```
version: "3.4"
networks:
patroni_patroni:
external: true
services:
patroni1:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5441:5432
- 8091:8091
hostname: patroni1
volumes:
- /patroni1:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
patroni2:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5442:5432
- 8092:8091
hostname: patroni2
volumes:
- /patroni2:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
patroni3:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5443:5432
- 8093:8091
hostname: patroni3
volumes:
- /patroni3:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
```
Details. also important The first detail that pops-up is the network thing we talked about earlier. We want to deploy the Patroni services in the same network as the Zookeeper services. This way 'zoo1', 'zoo2', 'zoo3' names we listed in ***patroni.yml*** providing zookeeper servers are going to work out for us.
```
networks:
patroni_patroni:
external: true
```
As for the ports, we have a database and API and both of them require its pair of ports.
```
ports:
- 5441:5432
- 8091:8091
...
environment:
PATRONI_API_CONNECT_PORT: 8091
// we need to make sure that we set Patroni API connect port
// the same with the one that is set as a target port for docker service
```
Of course, we also need to provide all the rest of the environment variables we kind of promised to provide configuring our entry point script for Patroni, but that's not it. There is an issue with a mount directory we need to take care of.
```
volumes:
- /patroni3:/data/patroni
```
As you can see '/data/patroni' we create in Dockerfile is mounted to a local folder we actually need to create. And not only create but also set the proper use and access mode just like in this example:
```
sudo mkdir /patroni3
sudo chown 999:999 /patroni3
sudo chmod 700 /patroni3
// 999 is the default uid for postgres user
// repeat these steps for each patroni service mount dir
```
With all these steps being done properly we are ready to deploy patroni cluster at last:
```
sudo docker stack deploy --compose-file docker-compose-patroni.yml patroni
```
After the deployment has been finished in the service logs we should see something like this indicating that the cluster is doing well:
```
INFO: Lock owner: patroni3; I am patroni1
INFO: does not have lock
INFO: no action. i am a secondary and i am following a leader
```
But it would be painful if we had no choice but to read through the logs every time we want to check on the cluster health, so let's dig into patronictl. What we need to do is to get the id of the actual container that is running any of the Patroni services:
```
sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a0090ce33a05 patroni-test:latest "bin/sh /entrypoint.…" 3 hours ago Up 3 hours 5432/tcp patroni_patroni1.1.tgjzpjyuip6ge8szz5lsf8kcq
...
```
And simply exec into this container with the following command:
```
sudo docker exec -ti a0090ce33a05 /bin/bash
// inside container
// we need to specify cluster name to list its memebers
// it is 'scope' parameter in patroni.yml ('patroni' in our case)
patronictl list patroni
// and oops
Error: 'Can not find suitable configuration of distributed configuration store\nAvailable implementations: exhibitor, kubernetes, zookeeper'
```
The thing is that patronictl requires patroni.yml to retrieve the info of zookeeper servers. And it doesn't know where did we put our config so we need to explicitly specify its path like so:
```
patronictl -c /etc/patroni.yml list patroni
// and here is the nice output with the current states
+ Cluster: patroni (6893104757524385823) --+----+-----------+
| Member | Host | Role | State | TL | Lag in MB |
+----------+-----------+---------+---------+----+-----------+
| patroni1 | 10.0.1.93 | Replica | running | 8 | 0 |
| patroni2 | 10.0.1.91 | Replica | running | 8 | 0 |
| patroni3 | 10.0.1.92 | Leader | running | 8 | |
+----------+-----------+---------+---------+----+-----------+
```
HA Proxy
--------
Now everything seems to be set the way we wanted and we can easily access PostgreSQL on the leader service and perform operations we are meant to. But there is this last problem we should get rid of and this being: how do we know where is that leader at the runtime? Do we get to check every time and manually switch to another node when the leader crashes? That'd be extremely unpleasant, no doubt. No worries, this is the job for HA Proxy. Just like we did with Patroni we might want to create a separate folder for all the build/deploy files and then create the following files there:
* **haproxy.cfg**
The config file we're gonna need to copy into our custom haproxy image.
haproxy.cfg
```
global
maxconn 100
stats socket /run/haproxy/haproxy.sock
stats timeout 2m # Wait up to 2 minutes for input
defaults
log global
mode tcp
retries 2
timeout client 30m
timeout connect 4s
timeout server 30m
timeout check 5s
listen stats
mode http
bind *:7000
stats enable
stats uri /
listen postgres
bind *:5000
option httpchk
http-check expect status 200
default-server inter 3s fall 3 rise 2 on-marked-down shutdown-sessions
server patroni1 patroni1:5432 maxconn 100 check port 8091
server patroni2 patroni2:5432 maxconn 100 check port 8091
server patroni3 patroni3:5432 maxconn 100 check port 8091
```
DetailsHere we specify ports we want to access the service from:
```
// one is for stats
listen stats
mode http
bind *:7000
// the second one for connection to postgres
listen postgres
bind *:5000
```
And simply list all the patroni services we have created earlier:
```
server patroni1 patroni1:5432 maxconn 100 check port 8091
server patroni2 patroni2:5432 maxconn 100 check port 8091
server patroni3 patroni3:5432 maxconn 100 check port 8091
```
And the last thing. This line showed below we need if we want to check our Patroni cluster stats from the Haproxy stats tool in the terminal from within a docker container:
```
stats socket /run/haproxy/haproxy.sock
```
* **Dockerfile**
In the Dockerfile it's not much to explain, I guess it's pretty self-explanatory.
Dockerfile
```
FROM haproxy:1.7
COPY haproxy.cfg /usr/local/etc/haproxy/haproxy.cfg
RUN mkdir /run/haproxy &&\
apt-get update -y &&\
apt-get install -y hatop &&\
apt-get clean
```
* **docker-compose-haproxy.yml**
And the compose file for HaProxy looks this way and it's also quite an easy shot comparing to other services we've already covered:
docker-compose-haproxy.yml
```
version: "3.7"
networks:
patroni_patroni:
external: true
services:
haproxy:
image: haproxy-patroni
networks:
- patroni_patroni
ports:
- 5000:5000
- 7000:7000
hostname: haproxy
deploy:
mode: replicated
replicas: 1
placement:
constraints: [node.hostname == floitet]
```
After we have all the files created, let's build the image and deploy it :
```
// build
docker build -t haproxy-patroni
// deploy
docker stack deploy --compose-file docker-compose-haproxy.yml
```
When we got Haproxy up running we can exec into its container and check the Patroni cluster stats from there. It's done with the following commands:
```
sudo docker ps | grep haproxy
sudo docker exec -ti $container_id /bin/bash
hatop -s /var/run/haproxy/haproxy.sock
```
And with this command we'll get the output of this kind:
To be honest, I personally prefer to check the status with patronictl but HaProxy is another option which is also nice to have in the administrating toolset. In the very beginning, I promised to show 3 ways to access cluster stats. So the third way of doing it is to use Patroni API directly, which is a cool way as It provides expanded, ample info.
Patroni API
-----------
Full detailed overview of its options you can find in Patroni docs and here I'm gonna quickly show the most common ones I use and how to use 'em in our docker swarm setup.
We won't be able to access any of the Patroni services APIs from outside of the 'patroni\_patroni' network we created to keep all our services together. So what we can do is to build a simple custom curl image to retrieve info in a human-readable format.
Dockerfile
```
FROM alpine:3.10
RUN apk add --no-cache curl jq bash
CMD ["/bin/sh"]
```
And then run a container with this image connected to the 'patroni\_patroni' network.
```
docker run --rm -ti --network=patroni_patroni curl-jq
```
Now we can call Patroni nodes by their names and get stats like so:
Node stats
```
curl -s patroni1:8091/patroni | jq
{
"patroni": {
"scope": "patroni",
"version": "2.0.1"
},
"database_system_identifier": "6893104757524385823",
"postmaster_start_time": "2020-11-15 19:47:33.917 UTC",
"timeline": 10,
"xlog": {
"received_location": 100904544,
"replayed_timestamp": null,
"replayed_location": 100904544,
"paused": false
},
"role": "replica",
"cluster_unlocked": false,
"state": "running",
"server_version": 110009
}
```
Cluster stats
```
curl -s patroni1:8091/cluster | jq
{
"members": [
{
"port": 5432,
"host": "10.0.1.5",
"timeline": 10,
"lag": 0,
"role": "replica",
"name": "patroni1",
"state": "running",
"api_url": "http://10.0.1.5:8091/patroni"
},
{
"port": 5432,
"host": "10.0.1.4",
"timeline": 10,
"role": "leader",
"name": "patroni2",
"state": "running",
"api_url": "http://10.0.1.4:8091/patroni"
},
{
"port": 5432,
"host": "10.0.1.3",
"lag": "unknown",
"role": "replica",
"name": "patroni3",
"state": "running",
"api_url": "http://10.0.1.3:8091/patroni"
}
]
}
```
Pretty much everything we can do with the Patroni cluster can be done through Patroni API, so if you want to get to know better the options available feel free to read official docs on this topic.
PostgreSQL Connection
---------------------
The same thing here: first run a container with the Postgres instance and then from within this container get connected.
```
docker run --rm -ti --network=patroni_patroni postgres:11 /bin/bash
// access to the concrete patroni node
psql --host patroni1 --port 5432 -U approle -d postgres
// access to the leader with haproxy
psql --host haproxy --port 5000 -U approle -d postgres
// user 'approle' doesn't have a default database
// so we need to specify one with the '-d' flag
```
Wrap-up
-------
Now we can experiment with the Patroni cluster as if it was an actual 3-node setup by simply scaling services. In my case when patroni3 happened to be the leader, I can go ahead and do this:
```
docker service scale patroni_patroni3=0
```
This command will disable the Patroni service by killing its only running container. Now I can make sure that failover has happened and the leader role moved to another service:
```
postgres@patroni1:/$ patronictl -c /etc/patroni.yml list patroni
+ Cluster: patroni (6893104757524385823) --+----+-----------+
| Member | Host | Role | State | TL | Lag in MB |
+----------+-----------+---------+---------+----+-----------+
| patroni1 | 10.0.1.93 | Leader | running | 9 | |
| patroni2 | 10.0.1.91 | Replica | running | 9 | 0 |
+----------+-----------+---------+---------+----+-----------+
```
After I scale it back to "1", I'll get my 3-node cluster with patroni3, the former leader, back in shape but in a replica mode.
From this point, you are able to run your experiments with the Patroni cluster and see for yourself how it handles critical situations.
Outroduction
------------
As I promised, I'm going to provide a sample test script and instructions on how to approach it. So if you need something for a quick test-run, you are more than welcomed to read under a spoiler section. If you already have your own test scenarios in mind and don't need any pre-made solutions, just skip it without any worries.
Patroni cluster testSo for the readers who want to put their hands-on testing the Patroni cluster right away with something pre-made, I created [this script](https://pastebin.com/p23sp83L). It's super simple and I believe you won't have problems getting a grasp of it. Basically, it just writes the current time in the database through the haproxy gateway each second. Below I'm going to show step by step how to approach it and what was the outcome from the test-run on my local stand.
* **Step 1.**
Assume you've already downloaded the script from the link and put it somewhere on your machine. If not, do this preparation and follow up. From here we'll move on and create a docker container from an official Microsoft SDK image like so:
```
docker run --rm -ti --network=patroni_patroni -v /home/floitet/Documents/patroni-test-script:/home mcr.microsoft.com/dotnet/sdk /bin/bash
```
The important thing is that we get connected to the 'patroni\_patroni' network. And another crucial detail is that we want to mount this container to a directory where you've put the script. This way you can easily access it from within a container in the '/home' directory.
* **Step2.**
Now we need to take care of getting the only dll we are going to need for our script to compile. Standing in the '/home' directory let's create a new folder for the console app. I'm gonna call it 'patroni-test'. Then cd to this directory and run the following command:
```
dotnet new console
// and the output be like:
Processing post-creation actions...
Running 'dotnet restore' on /home/patroni-test/patroni-test.csproj...
Determining projects to restore...
Restored /home/patroni-test/patroni-test.csproj (in 61 ms).
Restore succeeded.
```
And from here we can add the package we'll be using as a dependency for our script:
```
dotnet add package npgsql
```
And after that simply pack the project:
```
dotnet pack
```
If everything went as expected you'll get 'Ngsql.dll' sitting here:
'patroni-test/bin/Debug/net5.0/Npgsql.dll'.
It is exactly the path we reference in our script so if yours differs from mine, you're gonna need to change it in the script.
And what we do next is just run the script:
```
dotnet fsi /home/patroni-test.fsx
// and get the output like this:
11/18/2020 22:29:32 +00:00
11/18/2020 22:29:33 +00:00
11/18/2020 22:29:34 +00:00
```
> Make sure you keep the terminal with the running script open
>
>
* **Step 3.**
Let's check the Patroni cluster to see where is the leader using patronictl, PatroniAPI, or HaProxy, either way, is fine. In my case the leader status was on 'patroni2':
```
+ Cluster: patroni (6893104757524385823) --+----+-----------+
| Member | Host | Role | State | TL | Lag in MB |
+----------+-----------+---------+---------+----+-----------+
| patroni1 | 10.0.1.18 | Replica | running | 21 | 0 |
| patroni2 | 10.0.1.22 | Leader | running | 21 | |
| patroni3 | 10.0.1.24 | Replica | running | 21 | 0 |
+----------+-----------+---------+---------+----+-----------+
```
So what we need to get done at this point is to open another terminal and fail the leader node:
```
docker service ls | grep patroni
docker service scale $patroni2-id=0
```
After some time in the terminal with the script we'll see logs throwing error:
```
// let's memorize the time we got the last successfull insert
11/18/2020 22:33:06 +00:00
Error
Error
Error
```
If we check the Patroni cluster stats at this time we might see some delay though and patroni2 still indicating a healthy state running as a leader. But after some time it's going to fail and cluster, through a short stage of the leadership elections, will come to the following state:
```
+ Cluster: patroni (6893104757524385823) --+----+-----------+
| Member | Host | Role | State | TL | Lag in MB |
+----------+-----------+---------+---------+----+-----------+
| patroni1 | 10.0.1.18 | Replica | running | 21 | 0 |
| patroni3 | 10.0.1.24 | Leader | running | 21 | |
+----------+-----------+---------+---------+----+-----------+
```
If we go back to our script output we should notice that the connection has finally recovered and the logs are as follows:
```
Error
Error
Error
11/18/2020 22:33:48 +00:00
11/18/2020 22:33:49 +00:00
11/18/2020 22:33:50 +00:00
11/18/2020 22:33:51 +00:00
```
* **Step 4.**
Let's go ahead and check if the database is in a proper state after a failover:
```
docker run --rm -ti --network=patroni_patroni postgres:11 /bin/bash
psql --host haproxy --port 5000 -U approle -d postgres
postgres=> \c patronitestdb
You are now connected to database "patronitestdb" as user "approle".
// I set the time a little earlier than the crash happened
patronitestdb=> select * from records where time > '22:33:04' limit 15;
time
-----------------
22:33:04.171641
22:33:05.205022
22:33:06.231735
// as we can see in my case it required around 42 seconds
// for connection to recover
22:33:48.345111
22:33:49.36756
22:33:50.374771
22:33:51.383118
22:33:52.391474
22:33:53.399774
22:33:54.408107
22:33:55.416225
22:33:56.424595
22:33:57.432954
22:33:58.441262
22:33:59.449541
```
**Summary**
From this little experiment, we can conclude that Patroni managed to serve its purpose. After the failure occurred and the leader was re-elected we managed to reconnect and keep working with the database. And the previous data is all present on the leader node which is what we expected. Maybe it could have switched to another node a little faster than in 42 seconds, but at the end of the day, it's not that critical.
I suppose we should consider our work with this tutorial finished. Hope it helped you figure out the basics of a Patroni cluster setup and hopefully it was useful. Thanks for your attention and let the Patroni guardian keep you and your data safe at all times! | https://habr.com/ru/post/527370/ | null | en | null |
# Несколько находок
#### Кроссдоменные запросы с помощью YQL
Как клиентский веб разработчик, я всегда хочу уменьшить расходы потребления серверных ресурсов. Может быть, я один такой, не знаю. Но есть группа задач, которые просто-напросто не реализуемы на стороне клиента. Одна из таких задач: запрос на чужой домен. Нам приходится создавать серверный скрипт, который выступает посредником между браузером и сервером, с которого хотим стянуть данные, отдавая данные как бы со своего домена.
Позавчера, один уважаемый человек с форума javascript.ru с ником **melky** вскользь упомянул о каком-то странном, на первый взгляд, jQuery плагине, который называется [jquery.xdomainajax.js](https://github.com/padolsey/jQuery-Plugins/tree/master/cross-domain-ajax)
Пытливому уму программиста не нравятся всякие плагины, без понимания сути, поэтому я выковырял самую нужную часть:
```
var query = 'select * from html where url="http://javascript.ru/" and xpath="*"'
var url = 'http://query.yahooapis.com/v1/public/yql?q='+encodeURI(query)+'&format=xml&callback=callback';
var script = document.createElement('script');
script.src = url;
document.body.appendChild(script);
function callback(data) {
console.log(data); //сам текст ответа находится в data.result[0]
}
```
Откройте консоль и зупустите код. Как видно, в запрос пихается урл сайта и XML запрос в виде xpath, ответ приходит в виде jsonp. Если в урле написать format=json, то ответ придет в виде объекта с тегами.
Дальше этого применения я не пошел, поэтому лучше сами изучите матчасть здесь: [developer.yahoo.com/yql](http://developer.yahoo.com/yql/)
В комментариях настаивают указать на [ограничения](http://habrahabr.ru/blogs/webdev/135413/#comment_4498603) по количеству запросов с одного IP и запросов, использующих accesskey, которого у нас нет (так что, скорее всего, можно забить :) ).
#### Кроссдоменная загрузка данных изображения
Не так интересно, но на всякий случай
[getImageData](https://github.com/betamax/getImageData) — jQuery плагин, позволяющий извлекать данные изображений с других доменов, для использования в canvas или WebGL. По умолчанию, автор дает возможность пользоваться своим сервером в качестве прокси, но можно развернуть такой сервер и у себя, с помощью node.js, php или AppEngine
#### SVG → Canvas с помощью [Canvg](http://code.google.com/p/canvg/)
Рендерит SVG в Canvas на основе спецификации. SVG — очень удобный инструмент для конструирования каких-нибудь кнопочек, сложных извилистых линий и градиентов с привычным манипулированием DOMом. Теперь можно генерировать векторную графику в браузере и сохранять сразу на клиенте или сервере, не задействуя серверный конвертер.
#### Использование History API в старых браузерах с помощью [history.js](https://github.com/balupton/history.js)
Нет, я вас разочарую, для старых браузеров по-преднему используется хеш, зато теперь можно пользоваться одними и теми же функциями для смены адреса без перезагрузки страницы.
#### Скачивание файлов, сгенерированных на клиенте
Есть такая проблема: если файл генерируется на стороне браузера, то дать ему нормальное имя и расширение не получится. Проблема неплохо описана здесь: [jszip.stuartk.co.uk](http://jszip.stuartk.co.uk/). На помощь приходит еще дышащий флеш с костылем, называющимся Downloadify: [github.com/dcneiner/Downloadify](https://github.com/dcneiner/Downloadify)
Пример работы можно посмотреть тут: [pixelgraphics.us/downloadify/test.html](http://pixelgraphics.us/downloadify/test.html)
#### Очень красивая замена селекту («select»)
Без комментариев :D
[Chosen](https://github.com/harvesthq/chosen), [Пример](http://harvesthq.github.com/chosen/) | https://habr.com/ru/post/135413/ | null | ru | null |
# Руководство APPIUM по тестированию мобильных приложений для Android и iOS
### Что такое Appium?
Appium — это свободно распространяемый фреймворк с открытым исходным кодом, предназначенный для тестирования пользовательского интерфейса мобильных приложений. Он помогает тестировать нативные, гибридные и веб-приложения и проводить автоматизированное тестирование на физических устройствах, а также с помощью эмулятора и симулятора. Он предлагает кросс-платформенное тестирование приложений — единый API работает для сценариев тестирования платформы Android и iOS.
Он не отягощен зависимостью от операционной системы мобильного устройства — у Appium есть фреймворк или оболочка, которые переводят команды Selenium Webdriver в команды UIAutomation (iOS) или UIAutomator (Android) в зависимости от типа устройства, а не любого типа ОС.
Appium поддерживает все языки с клиентскими библиотеками Selenium, такие как: Java, Objective-C, JavaScript с node.js, PHP, Ruby, Python, C# и т. д.
В этой статье мы поговорим о таких моментах:
* Как Appium работает?
* Необходимые условия для использования Appium
* Установка [Appium Desktop](https://www.guru99.com/introduction-to-appium.html#22)
* Appium Inspector
* Подключение эмулятора Android к Appium
* Тест-кейс Appium для нативного Android-приложения (калькулятор)
* Ограничения использования Appium
* Распространенные ошибки и шаги по устранению неполадок в Appium
#### Как работает Appium?
* Appium — это «HTTP-сервер», написанный с использованием платформы Node.js и управляющий сессиями iOS и Android с использованием проводного протокола Webdriver JSON. Следовательно, перед инициализацией Appium Server в системе необходимо предварительно установить Node.js.
* Когда Appium скачан и установлен, на компьютере настраивается сервер с REST API.
* Он получает запрос на подключение и команду от клиента и выполняет эту команду на мобильных устройствах (Android/iOS).
* Он отвечает ответами HTTP. Опять же, чтобы выполнить этот запрос, он использует платформы автоматизации мобильного тестирования для управления пользовательским интерфейсом приложений. Фреймворк вроде:
— Apple Instruments для iOS (Instruments доступен только в Xcode 3.0 или более поздних версиях с OS X v10.5 и более поздних версиях).
— Google UIAutomator для Android API уровня 16 или выше.
— Selendroid для Android API уровня 15 или ниже.
Необходимое условие для использования APPIUM
1. Установить [ANDROID SDK](https://developer.android.com/sdk/index.html) (Studio)
2. Установить [JDK](https://www.guru99.com/install-java.html) (Java Development Kit)
3. Установить [Eclipse](https://www.eclipse.org/downloads/)
4. Установить [TestNg для Eclipse](https://www.guru99.com/all-about-testng-and-selenium.html#1)
5. Установить [JAR Selenium Server](https://www.guru99.com/introduction-to-selenium-grid.html#5)
6. Клиентская [библиотека Appium](http://appium.io/docs/en/about-appium/appium-clients/index.html)
7. Информация о приложении [APK в Google Play](https://play.google.com/store/apps/details?id=de.migali.soft.apkinfo&hl=en)
8. js (не требуется — всякий раз, когда сервер Appium установлен, он по умолчанию поставляется с «Node.exe» и NPM. Он включен в текущую версию Appium)
9. Установить Appium Desktop
### Установка Appium Desktop:
Appium Studio — это приложение с GUI с открытым исходным кодом для установки Appium Server. Он поставляется в комплекте со всеми зависимостями для установки и использования Appium Server. Включает в себя Inspector для получения основной информации о приложениях. А также поставляется с Recorder для создания шаблонного кода для автоматизации мобильных приложений.
Шаг 1) Перейдите на http://appium.io/ и загрузите Appium.
Шаг 2) Для Windows выберите исполняемый файл и загрузите его. Размер файла составляет около 162 МБ. Загрузка займет какое-то время в зависимости от скорости интернета.
Шаг 3) Нажмите на скачанный файл exe.
Шаг 4) На компьютере с Windows устанавливать Appium нет необходимости — он запускается прямо из exe. После нажатия на exe в течение нескольких минут увидите следующее.
Если вы пользуетесь Mac, необходимо установить dmg.
Шаг 5) Далее вы увидите окно запуска сервера с предзаполненными параметрами хоста и порта по умолчанию, которые можно изменить. На кнопке старта упоминается используемая версия Appium.
Шаг 6) При нажатии на кнопку запуска сервера на указанном хосте и порту запускается новый сервер. Отобразится журнал работы сервера.
Шаг 7) Нажмите на «New Session Window».
Шаг 8) Можно ввести необходимые данные и начать сеанс.
#### APPIUM Inspector
Подобно инструменту записи и воспроизведения Selenium IDE, Appium содержит инструмента Inspector для тех же целей. Он записывает и воспроизводит поведение нативного приложения, проверяя DOM, и генерирует тестовые сценарии на любом языке. Однако в настоящее время поддержка Appium Inspector для Microsoft Windows отсутствует. В Windows он запускает Appium Server, но не может проверить элементы. Однако в качестве инструмента для проверки элементов можно использовать UIAutomator viewer.
Шаги для начала работы с Appium Inspector на Mac:
Шаг 1) Загрузите и запустите сервер Appium с IP-адресом по умолчанию 0.0.0.0 и портом 4725.
1. Выберите исходный файл или файлы .app из локального для тестирования.
2. Поставьте галочку в поле «App Path», чтобы активировать кнопку выбора.
Шаг 2) Теперь нажмите кнопку «Choose», чтобы получить возможность просмотреть и выбрать тестовый файл с локального диска.
Шаг 3) Запустите симулятор на Mac.
Шаг 4) Нажмите кнопку «Launch» в правом верхнем углу, которая активирует значок синего цвета. Снова нажмите на значок синего цвета, он откроет инспектор Appium и симулятор с предварительно выбранным приложением.
Шаг 5). Запуск Appium Inspector покажет иерархию элементов в виде столбцов. Кроме того, пользователь может применять действия с помощью таких кнопок, как Tap, Swipe и т. д.
Шаг 6) Нажмите кнопку «Stop», чтобы остановить запись.
#### Подключение эмулятора Android к Appium
Шаг 1) Установите Android SDK в свою систему.
Перейдите в Панель управления [Control panel] >> Система и безопасность [System and Security] >> Система [System] и на левой панели нажмите «Продвинутые настройки системы» [Advanced System Settings]. Во всплывающем окне «Свойства системы» [System Properties] перейдите на вкладку «Дополнительно» [Advanced], а затем нажмите кнопку «Переменные среды» [Environment Variables].
Шаг 2) Теперь во всплывающем окне «Переменные среды» [Environment variables] дважды щелкните «Путь» [Path] и установите переменную ANDROID\_HOME, которая указывает на ваш каталог SDK. В пути добавьте весь путь к папке SDK.
например –
`C:\User\ABC\Desktop\adt-bundled-windows-x86_64-20140321\sdk`
Шаг 3) Запустите эмулятор Android или подключите любое устройство Android к вашей системе (убедитесь, что на устройстве Android включена опция отладки Android. Чтобы проверить параметр отладки, перейдите в «Настройки устройства» >> «Параметры разработчика» >> Установите флажок «Параметры отладки» [Debugging Option]).
Шаг 4) Откройте командную строку и перейдите в каталог \platform-tools\ вашего Android SDK (например, D:\adt-bundle-windows-x86\_64-20130514\sdk\platform-tools).
Шаг 5) Запустите команду `adb devices`. Подключенное устройство можно увидеть в списке в окне командной строки. (В CMD наберите `>adb devices` — эта команда выведет список подключенных экземпляров эмулятора. Например: `adb –s emulator-5554 install` )
Шаг 6) Запустите команду `adb start-server`. Она запустит сервер ADB, который будет использоваться Appium для отправки команд на ваше Android-устройство.
Шаг 7) Теперь перейдите в каталог Appium в системе и запустите Appium.exe.
Шаг 8) Не меняйте IP-адрес или номер порта, нажмите кнопку запуска. Ваша консоль Appium начинается с адреса 127.0.0.1:4723, как показано ниже.
Шаг 9) Нажмите кнопку «Пуск», сервер Appium запустится в вашей системе.
#### Тестовый пример APPIUM для нативного приложения Android (калькулятор)
Шаг 1) Загрузите плагин ADT eclipse или загрузите ADT в комплекте отдельно [здесь](https://developer.android.com/tools/help/adt.html).
Шаг 2) Откройте Eclipse и создайте новый проект >> Пакет >> Класс (a new Project >> Package >> Class).
Шаг 3) Импортируйте библиотеку Selenium и [Testng](https://www.guru99.com/all-about-testng-and-selenium.html) в этот новый проект.
Шаг 4) Теперь создайте небольшую тестовую программу для «Calculator.app», чтобы суммировать два числа.
```
package src_Appium;
import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
//import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.*;
public class Calculator {
WebDriver driver;
@BeforeClass
public void setUp() throws MalformedURLException{
//Set up desired capabilities and pass the Android app-activity and app-package to Appium
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("BROWSER_NAME", "Android");
capabilities.setCapability("VERSION", "4.4.2");
capabilities.setCapability("deviceName","Emulator");
capabilities.setCapability("platformName","Android");
capabilities.setCapability("appPackage", "com.android.calculator2");
// This package name of your app (you can get it from apk info app)
capabilities.setCapability("appActivity","com.android.calculator2.Calculator"); // This is Launcher activity of your app (you can get it from apk info app)
//Create RemoteWebDriver instance and connect to the Appium server
//It will launch the Calculator App in Android Device using the configurations specified in Desired Capabilities
driver = new RemoteWebDriver(new URL("https://127.0.0.1:4723/wd/hub"), capabilities);
}
@Test
public void testCal() throws Exception {
//locate the Text on the calculator by using By.name()
WebElement two=driver.findElement(By.name("2"));
two.click();
WebElement plus=driver.findElement(By.name("+"));
plus.click();
WebElement four=driver.findElement(By.name("4"));
four.click();
WebElement equalTo=driver.findElement(By.name("="));
equalTo.click();
//locate the edit box of the calculator by using By.tagName()
WebElement results=driver.findElement(By.tagName("EditText"));
//Check the calculated value on the edit box
assert results.getText().equals("6"):"Actual value is : "+results.getText()+" did not match with expected value: 6";
}
@AfterClass
public void teardown(){
//close the app
driver.quit();
}
}
```
Сервер Appium и эмулятор Android из «AVD Manager» и нажмите «Run» >> TestNG. Вышеупомянутая программа запустит Calculator.app на выбранном эмуляторе, и результат отобразится в консоли Eclipse с использованием среды TestNG.
#### Ограничения использования APPIUM
1. Appium не поддерживает тестирование версии Android ниже 4.2.
2. Ограниченная поддержка тестирования гибридных приложений, например: невозможно протестировать действие переключения приложения с веб-приложения на нативное и наоборот.
3. Нет поддержки запуска Appium Inspector в Microsoft Windows.
#### Распространенные ошибки и шаги по устранению неполадок в Appium
| | |
| --- | --- |
| Ошибка | Действия по устранению ошибок |
| Ошибка: Требуются следующие параметры, но они не были даны: имя устройства, имя платформы | Добавьте нужные параметры: имя устройства, имя платформы в сценарии APPIUM. например: `capabilities.setCapability("deviceName","Emulator"); capabilities.setCapability("имя_платформы","Android");` |
| Ошибка: Не удалось найти adb. Задайте для переменной среды ANDROID\_HOME путь к корневому каталогу Android SDK. | Вероятно, необходимо указать путь к корневому каталогу SDK в системных настройках [Environment Variables] в поле «Path». |
| error: org.openqa.selenium.SessionNotCreatedException: не удалось создать новый сеанс. | Необходимо указать правильный путь к приложению и перезапустить сервер Appium. |
| Как найти элемент DOM или XPath в мобильном приложении? | Используйте UIAutomatorviewer, чтобы найти элемент DOM для приложения Android. |
---
> Приглашаем всех желающих на открытое занятие **«Install Selenoid cluster»**. На этом открытом уроке рассмотрим разворачивание Selenoid кластера с использованием Docker и разберем, как организовать балансировку нагрузки между Selenoid инстансами. Регистрация — [**по ссылке.**](https://otus.pw/uMpB/)
>
> | https://habr.com/ru/post/682268/ | null | ru | null |
# Загрузка c iso образов при помощи memdisk и grub4dos
Вы наверняка слышали о таких девайсах как нетбук. И знаете, что в них не предусмотрен оптический привод (CD\DVD).
Приобретя нетбук я столкнулся с проблемой — мне необходимо было выложить еще 60$ за внешний оптический привод, что для бедного студента в условиях кризиса было немного накладно. Девайс наотрез отказался грузится с флешки с карточки (почему — до сих пор не пойму...) и тут мне в голову пришла мысль: «А если загрузится с образа?» — так начались поиски…
Далее я предлагаю почитать как я решил проблему при помощи grub4dos и memdisk. Конечная цель — загрузить образ нетинсталла openSUSE 11.3.
Сразу оговорюсь:
Не все образы получается загрузить описанным образом (у меня так и не получилось установить WinXP).
Образ монтируется в оперативную память и поэтому большие образы описанным образом смонтировать не получится.
Это не единственный способ загрузить содержимое iso — можно скопировать ядро и все необходимые ресурсы на диск и загрузить получившуюся конструкцию, но этот способ требует понимания как работает инсталлер и не всегда осуществим.
#### Шаг первый: подготовка
Мне попался нетбук с предустановленной Windows XP, поэтому вся статься отталкивается от наличия установленной Win XP.
Я использовал grub4dos, хотя всё изложенное в этой статье применимо и к обычному GRUB (в данный момент всё работает на обычном).
Нам нужен один раздел с поддерживаемой загрузчиком файловой системой (любой, кроме NTFS).
\*Я использовал FAT32, но подойдет и ext2\ext3.
Копируем на наш раздел образ.
#### Шаг второй: установка grub4dos
Читаем [документацию](http://greenflash.su/Grub4Dos/files/install.htm) или продолжение статьи ;)
Качаем grub4dos [отсюда](http://sourceforge.net/projects/grub4dos/).
Распаковываем архив, копируем grub4dos-\*\grldr в корневой каталог системного диска (обычно — C:\, далее — %sysdisk%); открываем %sysdisk%\boot.ini и дописываем в секции [operating system]
`C:\grldr="Grub4Dos"`
Адрес «C:\grldr» должен быть использован даже если установленная ОС имеет другую букву диска.
\*В документации описана установка на более современный загрузчик.
Получится что-то вроде:
`[boot loader]
timeout=30
default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional" /noexecute=optin /fastdetect
C:\grldr="Grub4Dos"`
Содержимое папки grub4dos-\* складываем в %sysdisk%\Grub4Dos
Конфиг из %sysdisk%\Grub4Dos\MENU.LST перекладываем в %sysdisk%\MENU.LST
\*Важно понимать, что grub4dos изначально пытается считать (hd0,0)\MENU.LST, поэтому лучше либо использовать ключ `--config-file=%CONFIG%` либо положить MENU.LST в корень раздела (hd0,0). Обычно это C:\ или /dev/sda1
\*\*Важно также понимать как GRUB нумерует диски, об этом можно почитать либо в [официальной](http://www.gnu.org/software/grub/manual/html_node/Naming-convention.html), либо в [переведенной](http://greenflash.su/Grub4Dos/files/syntax.htm) документации.
\*\*\*Согласно документации существует еще вариант, который предусматривает прописывание конфига в ключе --config-file=%CONFIG% следующим образом `--config-file="find --set-root /openSUSE-11.3-NET-i586.iso; kernel /memdisk iso raw; initrd /openSUSE-11.3-NET-i586.iso"` но у меня почему-то он так работать не хочет (вероятно из-за того, что штатный GRUB прописан в MBR).
#### Шаг третий: memdisk
У вас есть 2 варианта: скачать syslinux и собрать memdisk самостоятельно или скачать собранный мной memdisk с [dropbox'a](http://dl.dropbox.com/u/17629640/memdisk).
Memdisk сохраняем на разделе с образом (для простоты).
\*Вообще говоря мы можем держать образ и memdisk на разных разделах, но тогда нам придется использовать абсолютный путь до memdisk (или образа, что менее вероятно).
#### Шаг четвертый: настройка
Открываем %sysdisk%\MENU.LST
Добавляем туда блок (openSUSE-11.3-NET-i586.iso — имя образа)
`title boot an image with memdisk
find --set-root /openSUSE-11.3-NET-i586.iso
kernel /memdisk iso raw
initrd /openSUSE-11.3-NET-i586.iso`
Сохраняем, перезагружаемся… Загружается стандартный загрузчик (ntldr) с 2мя опциями — загрузить Windows или загрузить Grub4Dos.
Загружаем последний и видим как у нас грузится образ.
#### Альтернативный вариант
В Grub4Dos есть и другой способ монтировать iso: добавляем в %sysdisk%\MENU.LST
`title boot an image with memdisk
find --set-root /openSUSE-11.3-NET-i586.iso
map /openSUSE-11.3-NET-i586.iso (0xff) || map --mem /openSUSE-11.3-NET-i586.iso (0xff)
map --hook` | https://habr.com/ru/post/111045/ | null | ru | null |
# Как мы боролись с проблемами производительности в «Redmine». Кто виноват и как помочь?
Конечно, статья не совсем верно названа. В чистом Redmine особо больших проблем с производительностью нет. Но мы, в процессе разработки большого количества плагинов, эти проблемы с легкостью вносили.
Поэтому, статья расскажет о том, как разобраться в чем причина медленной работы той или иной функции плагина Redmine и какие инструменты могут помочь в этом. Многие советы, естественно, могут касаться не только самого Redmine, но и Rails-приложений в целом.
Симптом у проблем с производительностью всегда один – это разгневанный пользователь, кричащий, клянущий твое ПО и возможно тебя лично.
##### Rack Mini Profiler
Чаще всего проблемы с долгим открытием какой-нибудь странички связаны с SQL-запросами. Это могут быть просто долго исполняющиеся SQL-запросы или циклические запросы вызванные особенностями механизма Active Record в ROR. В любом случае, Rack Mini Profiler – это мегополезная вещь для анализа проблем производительности в Redmine.
Rack Mini Profiler – это маленький gem, который устанавливается в пару команд и в режиме почти реального времени показывает, какие запросы выполнялись в процессе загрузки странички, и сколько ушло времени на каждый запрос. Для анализа проблем производительности, эта штука просто незаменимая.
На ранних стадиях программирования на Rails у меня было стойкое ощущение того, что Ruby on Rails настолько продуманный фреймфорк, что, пользуясь Active record, я просто выбирал нужные мне данные, думая, что обо всем остальном позаботились разработчики фреймворка.
В результате? я наплодил большую кучку циклических SQL-запросов. С ростом количества пользователей, некоторые странички стали открываться очень долго.
Rack Mini Profiler позволяет очень быстро найти причину долгого открытия странички у конкретного пользователя. Вот как, например, это может выглядеть, если не добавить «includes» в «active record» — конструкцию.
Общее количество SQL-запросов само по себе наводит на подозрение:
Если посмотреть более подробную статистику, то можно понять, что при открытие странички генерируются циклические SQL-запросы и эту проблему нужно устранить.
Даже после того, когда пришло более глубокое понимание Active record в Rails, периодически, циклические запросы пролазили на рабочий сервер. Поэтому мы решили, что тестировщик, проверяя задачу, в обязательном порядке должен анализировать информацию из Rack Mini Profiler на наличие долгих и циклических запросов.
##### Плагин для Redmine — «RmPlus DevTools»
Rack Mini Profiler по умолчанию включен в development-среде и выключен в production. Но часто бывает нужно проанализировать ситуацию с производительностью именно в production-среде и у конкретного пользователя, поэтому мы написали небольшой плагин для Redmine, который подключает Rack Mini Profiler в production-среду Redmine и позволяет подключать профилирование только для конкретного пользователя – [Redmine Dev Tools](https://github.com/pineapple-thief/rmplus_devtools/tree/master).
Также, этот плагин подключает джем Oink (про него расскажу немного позже) и дает возможность вести более удобную разработку плагинов для Redmine в development-среде: нет необходимости перезагружать web-сервер для того, что бы изменения в JS-файлах применялись на странице.
##### «OINK»
Oink это еще один суперполезный джем для анализа проблем с производительностью. Он очень помог, когда у нас на рабочем сервере стала утекать память. Один из процессов Rails по непонятным причинам выедал больше гигабайта оперативной памяти и вешал весь Remine.
Как следствие: кучка звонков на телефон, мурашки по коже и легкое ощущение бессилия.
Oink позволяет проанализировать, какие контроллеры и экшены Rails съедают память, задав пороговое значение. Эта статистика проливает свет на источник проблемы, после чего устранение источника проблемы становится более тривиальным.
`oink --threshold 50 /usr/share/srv-redmine/redmine-2.5/log/oink.log`
Как-то вот так! Надеюсь, моя статья будет полезной. Мне она бы очень пригодилась в свое время. | https://habr.com/ru/post/227155/ | null | ru | null |
# React. Не вглубь, а вширь. Композиция против реальности
Давайте рассмотрим искусственный пример кода, который, как и в жизни, постепенно будет расширяться и усложняться, а наша задача, глядя на это всё, понять: не пора ли рефакторить. План наших действий: задача – решение – анализ – рефакторинг. Приступим.
Задача: в проект нужны тултипы. Сказано – сделано.
```
interface OwnProps {
hint: string
}
export const Tooltip: FC = ({ hint, children }) => {
// допустим, в зависимости от кол-ва символов и пространства на экране
// производится позиционирование
const [config, setConfig] = useState(null)
const ref = useRef(null)
useLayoutEffect(() => {
// реализация алгоритма позиционирования
// ...
setConfig(someConfig)
}, [hint])
return (
{children}
)
```
Спустя какое-то время в проекте должен появиться ещё один тултип, он красивее и принимает обработчик клика. Самое простое и кратчайшее решение – изменить имеющийся компонент Tooltip.
```
interface TooltipProps {
hint: string
onClick?: () => void
}
export const Tooltip: FC = ({ hint, children, onClick }) => {
// допустим, в зависимости от кол-ва символов и пространства на экране
// производится позиционирование
const [config, setConfig] = useState(null)
const ref = useRef(null)
useLayoutEffect(() => {
// реализация алгоритма позиционирования
// ...
setConfig(someConfig)
}, [hint])
// А ВОТ И НОВЫЙ ВАРИАНТ ИСПОЛЬЗОВАНИЯ!!!
// в этом компоненте уже обязательно нужен onClick
if (onClick) {
return (
{children}
)
}
return (
{children}
)
}
```
Мы модифицировали старый компонент, добавили инструкцию if и всё заработало. Единственное, что несколько смущает на данном этапе, это то, что из интерфейса TooltipProps совсем не очевидно, что обработчик onClick на самом деле не просто опциональное свойство, а ещё и определитель: какой вариант тултипа нужно вернуть. В общем, может и не очевидно, а может и очевидно, ясно одно: Done is better than perfect.
И вот нас снова просят добавить новый тултип – DiscountTooltipComponent, который тоже обязательным свойством принимает обработчик onClick. Чтобы отличать два компонента DiscountTooltipComponent от AnotherTooltipComponent мы используем дополнительное свойство type.
```
interface TooltipProps {
hint: string
type?: 'another' | 'discount'
onClick?: () => void
}
export const Tooltip: FC = ({ type, hint, children, onClick }) => {
// допустим, в зависимости от кол-ва символов и пространства на экране
// производится позиционирование
const [config, setConfig] = useState(null)
const ref = useRef(null)
useLayoutEffect(() => {
// реализация алгоритма позиционирования
// ...
setConfig(someConfig)
}, [hint])
// А ВОТ И НОВЫЙ ВАРИАНТ ИСПОЛЬЗОВАНИЯ!!!
// в этом компоненте уже обязательно нужен onClick
if (type && onClick) {
return (
{children}
{type === 'another' ? (
) : (
}
)
}
return (
{children}
)
}
```
Условие в инструкции if усложнилось, внутри появился тернарный оператор, само собой код стало сложнее читать. И вот когда условия становятся сложнее и специфичнее, стоит это дело проанализировать.
Начнём сверху, с интерфейса TooltipProps. Глядя на него, совсем не очевидно, что поля type и onClick связаны между собой. Следовательно, не очевидны и варианты использования компонента Tooltip. Мы можем указать type = "another", но не передать onClick, и тогда typescript не выдаст ошибки.
Самое время обратиться к принципу разделения интерфейсов (Interface Segregation Principle), который на уровне компонентов называется принципом совместного повторного использования. Он гласит:
> Не вынуждайте пользователей компонента зависеть от того, чего им не требуется.
>
>
Чтобы проблема стала видна отчётливее, представим, что прошло ещё немного времени.
Аналитики просят залогировать нажатие на DiscountTooltipComponent.
```
interface TooltipProps {
hint: string
type?: 'another' | 'discount'
onClick?: () => void
}
export const Tooltip: FC = ({ type, hint, children, onClick }) => {
// допустим, в зависимости от кол-ва символов и пространства на экране
// производится позиционирование
const [config, setConfig] = useState(null)
const ref = useRef(null)
useLayoutEffect(() => {
// реализация алгоритма позиционирования
// ...
setConfig(someConfig)
}, [hint])
// ЗДЕСЬ МЫ БУДЕМ ЛОГИРОВАТЬ
const handleClick = () => {
if (type === 'discount') {
// произвести логирование
}
if (onClick) {
onClick()
}
}
// А ВОТ И НОВЫЙ ВАРИАНТ ИСПОЛЬЗОВАНИЯ!!!
// в этом компоненте уже обязательно нужен onClick
if (type) {
return (
{children}
{type === 'another' ? (
) : (
}
)
}
return (
{children}
)
}
```
Теперь все, кто использовал Tooltip в его первозданном виде, получили в нагрузку handleClick, который ими никак не используется, но ресурсы на него расходуются. А те, кто использовал компонент с type='another', получили не нужную обертку handleClick. Что, если мы разделим интерфейсы, например:
```
interface Tooltip {
hint: string
}
interface TooltipInteractive extends Tooltip {
onClick: () => void
}
```
Теперь выделим общую логику в компонент TooltipSettings:
```
interface TooltipSettingsProps {
hint: string
render: (config: any, hint: string) => JSX.Element
}
export const TooltipSettings: FC = ({ render }) => {
// допустим в зависимости от кол-ва символов и пространства на экране
// производится позиционирование
const [config, setConfig] = useState(null)
const ref = useRef(null)
useLayoutEffect(() => {
// реализация алгоритма позиционирования
// ...
setConfig(someConfig)
}, [hint])
return (
{children}
{render(config, hint)}
)
}
```
Реализуем интерфейс Tooltip:
```
export const Tooltip: FC = ({ hint }) => (
} />
)
```
Реализуем интерфейс TooltipInteractive:
```
export const AnotherTooltip: FC = ({ hint, onClick }) => (
}
/>
)
```
В частности DiscountTooltipComponent:
```
export const DiscountTooltip: FC = ({ hint, onClick }) => {
const handleClick = () => {
// произвести логирование
// вызвать обработчик
onClick()
}
return (
}
/>
)
}
```
Ничто так не усложняет понимание кода, как обилие ветвлений – в том числе инструкций if, – и специфичных условий. Чем быстрее мы стараемся реализовать задачу, тем больше компонентов мы помещаем "под одной крышей". Это помогает выиграть время на короткой дистанции, но вероятность того, что однажды этот код станет легче полностью переписать, чем расширить или изменить, неуклонно возрастает. Предугадать, как будет развиваться проект даже в ближайшие год-два, задача нетривиальная в нашем быстро меняющемся мире, а вот вовремя реагировать на изменения – задача вполне посильная. | https://habr.com/ru/post/550532/ | null | ru | null |
# Measurement Protocol — просто о несложном
На днях Universal Analytics вышел из статуса беты и теперь становится основной версией Google Analytics. Это событие позволяет использовать его без ряда ограничений, существовавших ранее. Новая версия несет также ряд новых возможностей для отслеживания посетителей сайта и дает возможность сопоставить действия пользователя на сайте и последующее совершение целевых действие в оффлайне.
Для этих целей используется **Measurement Protocol** или **Протокол передачи данных**. В каких случаях вы можете использовать эту возможность? Приведу пару примеров.
**Первый вариант** — посетитель приобретает у вас на сайте товар или услугу, при этом выбирает вариант оплаты «безналичный расчет». Мы можем предположить, что процесс покупки по ряду причин может быть и не завершен, поэтому передача сведений в Google Analytics о транзакции после завершения процесса оформления заказа/покупки некорректна. Данные должны быть переданы после фактического поступления оплаты.
**Второй вариант** — оплата наличными курьеру при доставке товара. Покупка считается завершенной после получения оплаты курьером.
В обеих ситуациях, если мы будем передавать данные о покупке (транзакции) после завершения процесса оформления заказа, мы исказим статистику, т.к. у нас пока нет фактической оплаты. Для исправления ситуации с лишними учтенными платежами придется использовать отрицательные транзакции, что не всегда удобно и не совсем правильно.
Решить обозначенную проблему нам поможет новая возможность, появившаяся в Google Analytics с выходом Universal Analytics, под названием **Mesurement Protocol.**
В чем заключается принцип работы протокола? Все достаточно просто: необходимо отправить специальным образом сформированный запрос на определенный URL.
*Пример запроса:*
**[www.google-analytics.com/collect?v=1&tid=UA-47xxxx-1&cid=12xx916x95.13x6127xx4&t=pageview](http://www.google-analytics.com/collect?v=1&tid=UA-47xxxx-1&cid=12xx916x95.13x6127xx4&t=pageview)**
**Разберем подробнее параметры подлежащие передаче.**
**Первое** — это URL, на который должен быть отправлен запрос. Он должен принимать значение **[www.google-analytics.com/collect](http://www.google-analytics.com/collect)** для незащищенного соединения и **[ssl.google-analytics.com/collect](https://ssl.google-analytics.com/collect)** для протокола SSL.
**Второе** — обязательный набор из 4 параметров:
* 1. v — версия протокола, в настоящей момент используется значение равное 1;
* 2. tid — идентификатор кода отслеживания (ресурса) Google Analytics в виде UA-XXXX-Y;
* 3. cid — анонимный Client-ID;
* 4. t — тип хита.
Если первый и второй параметр не должны вызвать сложностей, то третий и четвертый требуют уточнений.
Параметр cid, это анонимный client-id или идентификатор клиента. Если посетитель просматривает ваш сайт с помощью браузера, Universal Analytics сохранит значение client-id в cookie, а если вам не известно значение, используйте любое свое.
Обратите внимание, если вы используете client-id, который получен из cookie файла, переданные данные будут сопоставлены с другими действиями посетителя, а если передаете свое значение, то будет просто зафиксирован некоторый хит нового посетителя (операции под одним client-id приписываются одному посетителю). Для иллюстрации сказанного посмотрите на изображение:
Просмотр страницы под номером 1 — это первое посещение сайта, просмотр 2 сгенерирован с помощью Mesurement Protocol по клику на кнопке (при этом использовался clid из cookie, установленного в посещении номер 1). У нас по отчету на сайте будет 1 посетитель.
Просмотр 3, как и просмотр 2, сгенерирован при клике на кнопку, при этом в качестве clid передано значение 12345, что приводит к появлению на сайте второго посетителя. У нас по отчету уже 2 посетителя. Просмотр 4 полностью аналогичен просмотру 2 (это действие посетителя номер 1, который ранее осуществил просмотры 1 и 2).
Вернемся к параметрам. Следующий параметр t (это тип хита). Он может принимать ограниченный круг значений — 'pageview', 'appview', 'event', 'transaction', 'item', 'social', 'exception', 'timing'.
**Наиболее часто используемые значения:**
pageview — просмотр страницы;
event — событие;
transaction — транзакция;
item — элемент транзакции.
Уже сейчас у вас есть возможность передачи в Universal Analytics данных с помощью Measurement Protocol. Но для того, чтобы нам получить в отчетах достоверную и полную информацию, необходимо выполнить еще два действия:
**1.** Получить client-id посетителя сайта и сохранить его в CRM вместе с данными о заказе (сопоставить активность пользователя на сайте и его оффлайн действия).
**2.** Дополнить запрос дополнительными параметрами, позволяющими работать нам с передаваемыми данными в отчетах.
Получить clien-id можно из cookie Universal Analytics:
Вы можете самостоятельно либо с помощью разработчиков получить нужное значение. Я в своей деятельности пользуюсь следующим кодом на языке PHP (автор Matt Clarke):
```
php
/*
* Name: Universal Analytics Cookie Parser Class
* Description: Parses the new format Universal Analytics cookie.
* Developer: Matt Clarke
* Date: January 10, 2013
*/
class UniversalAnalyticsCookieParser{
// Parse the _ga cookie if found
function __construct() {
if( isset($_COOKIE["_ga"]) ){
echo $this-getCid();
}
}
// Handle the parsing of the _ga cookie
public function parseCookie()
{
list($version,$domainDepth, $cid1, $cid2) = split('[\.]', $_COOKIE["_ga"],4);
return array('version' => $version, 'domainDepth' => $domainDepth, 'cid' => $cid1.'.'.$cid2);
}
// Get cid
public function getCid()
{
$contents = $this->parseCookie();
return $contents['cid'];
}
}?>
```
Что касается дополнительных параметров, их достаточно много, некоторые из них с описанием на русском языке вы найдете [здесь](http://prometriki.ru/measurement-protocol-28-parametrov-dly-peredachi-dannih-v-universal-analytics/), а полный список доступен в официальной документации Google Analytics.
Рассмотрим некоторые из параметров, которые относятся к ранее обозначенным **типам хитов.**
* dh — доменное имя сайта;
* dp — адрес страницы относительно доменного имени сайта;
* dt — заголовок страницы;
* ec — категория события;
* ea — действие по событию;
* el — ярлык события;
* ti — идентификатор транзакции;
* ta — название филиала или магазина;
* tr — общая сумма транзакции;
* in — название товара;
* ip — стоимость товара;
* iv — категория товара.
Теперь, когда мы имеем все необходимое для использования *Measurement Protocol* (протокола передачи данных), можно попробовать на практике приобретенные знания. Мы с вами воспользуемся всеми типами хитов, которые были названы ранее. Я буду демонстрировать передачу данных, отправляя запросы с помощью JQuery.
Отправка данных о просмотре страницы:
```
$('#buttonId').click(function(){
$.post(
"http://www.google-analytics.com/collect",
{
v: '1',
tid: 'UA-xxxxx-1',
cid: '12xx916x95.13x6127xx4',
t: 'pageview',
dh: 'test.prometriki.ru',
dp: '/my-test-page',
dt: 'Это проверка работы!'
},
onAjaxSuccess
)
});
```
Отправка данных о событии:
```
$('#buttonId').click(function(){
$.post(
"http://www.google-analytics.com/collect",
{
v: '1',
tid: 'UA-xxxxx-1',
cid: '12xx916x95.13x6127xx4',
t: 'event',
ec: 'Проверка события',
ea: 'Виртуальное',
el: 'Получилось'
},
onAjaxSuccess
)
});
```
Отправка данных о покупке:
```
$('#buttonId').click(function(){
$.post(
"http://www.google-analytics.com/collect",
{
v: '1',
tid: 'UA-xxxxx-1',
cid: '12xx916x95.13x6127xx4',
t: 'transaction',
ti: '44473',
ta: 'SITE',
tr: '19990.00'
},
onAjaxSuccess
)
$.post(
"http://www.google-analytics.com/collect",
{
v: '1',
tid: 'UA-xxxxx-1',
cid: '12xx916x95.13x6127xx4',
t: 'item',
ti: '44473',
'in': 'Название товара',
ip: '19990.00',
iv: 'Категория товара'
},
onAjaxSuccess
)
});
```
Обратите внимание, что для отправки данных о покупке необходимо сначала передать данные о транзакции, а затем о каждом товаре.
В какой момент вам необходимо передавать данные с помощью Mesurement Protocol? Для примеров, которые я привел в самом начале публикации, моментом передачи данных может быть перевод заявки в CRM из статуса «заказ доставляется» в «заказ оплачен». Разработчикам, при наличии необходимых данных, не составит особого труда отправить сформированный запрос по определенному действию или событию на сайте.
Как видите, сложного в использовании этого функционала Universal Analytics нет. Используйте его для сбора достоверных данных и оптимизации вашего бизнеса.
Для получения полной и официальной информации обратитесь к документации.
В заключении приведу пример ролика, который демонстрирует фиксацию событий и передачу сведений в Universal Analytics для датчика движения: | https://habr.com/ru/post/222169/ | null | ru | null |
# WEBO Site SpeedUp версия 0.9.5 (публичная бета)
[](http://www.web-optimizer.ru/)После почти трех недель дорисовки макетов, интеграции и усиленного тестирования (да-да, все отдыхали, а мы работали!) вышла новая версия open source приложения для автоматического ускорения сайтов — WEBO Site SpeedUp 0.9.5 ([подробнее](http://www.web-optimizer.us/)). Текущий статус — публичная бета (т.е., скорее всего, версия содержит некоторые некритичные ошибки, но полностью готова к «боевому» использованию). Мы будем крайне признательны за содержательные сообщения об ошибках в [официальном баг-трекере](http://code.google.com/p/web-optimizator/issues/list).
Загрузить
[www.web-optimizer.us/web-optimizer/download.html](http://www.web-optimizer.us/web-optimizer/download.html)
Под катом больше подробностей и картинок
Часть нововведений уже была озвучена в посте про [альфа-версию](http://habrahabr.ru/blogs/web_optimizator/79034/), это:
* Как вы уже заметили, название продукт изменено на WEBO Site SpeedUp, чтобы не конфликтовать с Google Web(site) Optimizer. Нам конкуренция с гуглом ни к чему :)
* Полностью новый интерфейс, который собрал уже множество положительных откликов. Скриншоты выложены [также здесь](http://blog.web-optimizer.us/2009/12/webo-site-speedup-alpha-version.html) и [здесь](http://blog.web-optimizer.us/2009/12/webo-site-speedup-configuration-sets.html).
* [](http://4.bp.blogspot.com/_fnXjivAyka0/Szwf9rifK2I/AAAAAAAAAns/e3A4hRRkjVI/s1600-h/2009-12-31.options.public.2.png)Из наиболее вкусного: теперь есть возможность быстро менять наборы настроек. По умолчанию доступно 3 набора (естественно, можно создавать и свои собственные): безопасный (исключает все потенциально «опасные» настройки), оптимальный (обеспечивает отличное ускорение, но может иногда «убивать» систему) и экстремальный (ну, тут ускорение максимально, но и риск очень большой, нужно дополнительно настраивать).
* Концепция панели управления также пересмотрена, и на нее вынесены наиболее важные части приложения «в трех предложениях». Блоки можно скрывать / раскрывать.
* Добавлена отдельная страница для файлов кэша. Концепт еще будет дорабатыватся и пересматриваться, чтобы сделать интерфейс более удобным.
* Добавлены утилиты для рекурсивного gzip-сжатия файлов и оптимизации изображений (последнее только через smush,it, но punypng на подходе).
* Добавлена отдельная страница с информацией о текущем системном окружении и его настройкой.
* Добавлен выбор языка интерфейса (если вы готовы перевести продукт на свой родной язык, отличный от русского/украинского, — [пожалуйста, напишите нам](http://www.web-optimizer.us/about/contacts.html)).
+ еще немного новых возможностей
* WEBO Site SpeedUp имеет свое [API для оптимизации](http://code.google.com/p/web-optimizator/wiki/PluginsAPI?wl=ru) (в новой версии в него добавлены методы onBeforeOptimization, onAfterOptimization, onCache). С его помощью можно проводить как регулярные действия, так и единоразовые (например, навешивать индексы на базу при установке приложения).
* Обновиться теперь можно не только до последней стабильной версии, но и до промежуточной беты. В процессе добавления механизм «отката» до стабильной версии, если установлена последняя бета-версия.
* Улучшена работа с .htaccess и обнаружение модулей Apache на большом количестве разнообразных окружений.
* Также одно из наиболее ожидаемых улучшений: метка lang=«wo» в заголовке страницы убрана (вместо нее в конец страницы вставляется ).
* Добавлена возможность «Использовать единый кэш для всех браузеров» (может помочь при использовании внешних кэширующих механизмов, но делает невозможным применении кроссбраузерной технологии data:URI + mhtml).
* Добавлена возможность кэшировать статические файлы, расположенные на внешних ресурсах (будь то скрипты или картинки, для которых не выставляются нормальные кэширующие заголовки).
* Добавлена «отложенная» загрузка для фреймов (чтобы они не мешали основному содержимому страницы).
* Для нативных плагинов (WordPress / Joomla!) улучшено серверное кэширование (перед выходом версии 1.0 проведем дополнительные тесты производительности).
* Добавлена возможность исключать страницы из серверного кэширования при наличии определенных cookie.
* Добавлена поддержка PrestaShop (1.2.5).
### Поддержка систем
Сейчас в списке поддерживаемых [систем более 40](http://www.web-optimizer.us/web-optimizer/requirements.html#cms), нативно (на уровне внутренних расширений) поддерживаются WordPress, Joomla!, Drupal, Bitrix (последний пока только через Web Optimizer, интерфейс WEBO Site SpeedUp в процессе прикручивания).
Если у вас есть какие-то специфические пожелания по поводу поддержки, то, пожалуйста, напишите в комментариях.
### Техническая поддержка
Полноценная техническая поддержка оказывается только пользователям полной версии. Но все оформленные в [баг-трекере](http://code.google.com/p/web-optimizator/issues/list) ошибки рассматриваются обычно в течение 24 часов (и обычно так же быстро решаются).
### Условия лицензирования
WEBO Site SpeedUp (как и Web Optimizer начиная с версии 0.6.0) имеет 3 разных редакции ([сравнение версий](http://www.web-optimizer.us/web-optimizer/comparison.html)):
* Некоммерческую. Может быть использована на сайтах, не предназначенных для извлечения прибыли (=некоммерческих).
* Облегченная. Может быть использована на любых сайтах. Обладает почти тем же функционалом, что и некоммерческая версия.
* Полная. Все, что есть в продукте, и даже больше — техническая поддержка 24/7.
Обновления бесплатны во всех редакциях. Все платные лицензии имеют ограниченный срок действия (год). Есть возможность приобрести неограниченную лицензию ([пожалуйста, напишите нам, если это ваш случай](http://www.web-optimizer.us/about/contacts.html)).
Как вы понимаете, мы не собираемся останавливаться в разработке приложения, будет добавлено множество новых возможностей и отдельных утилит в общий пакет, улучшена совместимость и быстродействие. Мы рады, что [после выхода платной версии](http://habrahabr.ru/blogs/web_optimizator/71238/) и большого количества критики в наш адрес, количество любителей быстрых сайтов не уменьшилось, а их ожидания были оправданы.
### Партнерская программа
По многочисленным просьбам мы добавили партнерскую программа по продаже WEBO Site SpeedUp (комиссия до 20% и более). Все очень просто: вы [регистрируетесь на webo.in](http://webo.in/my/) и получаете [индивидуальную ссылку](http://webo.in/my/partners/) (если у вас уже есть аккаунт на webo.in, то все еще проще — достаточно зайти по последней ссылке). Все продажи по этой ссылке учитываются как «ваши».
Мы планируем подготовить также ряд графических материалов для партнеров. Если уже есть какие-то идеи, пожалуйста, [напишите их](http://webo.in/my/support/contact/)..
### Дополнительная информация
Официальный сайт
[www.web-optimizer.us](http://www.web-optimizer.us/)
Загрузить WEBO Site SpeedUp
[www.web-optimizer.us/web-optimizer/download.html](http://www.web-optimizer.us/web-optimizer/download.html)
Твиттер: [twitter.com/wboptimizer](http://twitter.com/wboptimizer)
Блог (на английском): [blog.web-optimizer.us](http://blog.web-optimizer.us/)
P.S. да, есть и онлайн-демо продукта, не завалите сервер :)
[www.web-optimizer.us/web-optimizer/demo.html](http://www.web-optimizer.us/web-optimizer/demo.html) | https://habr.com/ru/post/80527/ | null | ru | null |
# JEP 181: контроль доступа ко вложенным классам
Продолжаем знакомиться с не слишком известными JEPами. На этот раз, у нас еще один подпроект из Valhalla, который так и называется — ***nestmates***. Эта фича позволяет вложенным классам иметь неограниченный доступ друг к другу. Как именно — описано ниже. По сути, эта статья — формальный перевод [JEP 181](http://openjdk.java.net/jeps/181), ибо он весьма внятно описывает суть вопроса для новичка.
(Если нужен не новичковый взгляд, а какое-то экспертное мнение, то с этим лучше обратиться к специалистам — Никите Липскому, Тагиру Валееву, Владимиру Иванову и другим. Скорей всего, их можно будет поймать на [Joker 2017](http://jokerconf.com). В августе еще действуют [ранние цены](https://jokerconf.com/tickets), кстати).
Напомню, JEP — это JDK Enchancement Proposal, процесс сбора предложений и улучшений для OpenJDK, позволяющий коммитерам работать более неформально, вплоть до выпуска официального формального JSR. О JEPах можно думать как о стратегическом плане OpenJDK.
Для прикладного программиста (не коммитера в OpenJDK) такие знания вряд ли пригодятся для непосредственно написания кода — вместо этого, они дают общее архитектурное понимание Java-платформы, учат мыслить стратегически и позволяют предсказывать ближайшее будущее.
Пара слов для тех, кто читал недавнюю статью о [Minimum Value Types](https://habrahabr.ru/company/jugru/blog/336378/). (*статья о практических аспектах MVT пишется прямо сейчас*) Там рассказывалось о байткоде `vwithfield`, который позволяет взять выбранный тип-значение и подменить в нем поле. Такой метод должен, очевидно, находиться не в самом голом «значении», а в его объектной обертке. По логике вещей, только класс с приватным доступом до объекта языка может менять его поля. Соответственно, между компонентами типа-значения (VCC и DVT) должны возникать особые доверительные отношения, реализацию которых очень хочется иметь напрямую в JVM.
Поэтому предполагается, что некие будущие версии JVM могут реализовать явные *nestmates* на уровне VM, которые будут иметь доступ к приватным полям и методам друг друга. Это будет не какой-то компиляторный хак на генерации оберток, а вполне нативная возможность. В этих версиях JVM, инструкция `vwithfield` будет доступна для всех nestmates каждого конкретного типа-значения. Другими словами, `vwithfield` будет доступна внутри некоей «капсулы», в которой доступны все приватные методы.
Ладно, хватит болтать, переходим к самому JEP!
JEP 181: контроль доступа ко вложенным классам
==============================================
**Краткое описание**
Необходимо связать проверки доступа в JVM с правилами языка Java, определенными для методов, конструкторов и полей во вложенных (nested) классах, разделяя классы на гнезда (nest) — то есть, группы связанных классов, имеющих общий контекст контроля доступа (и обычно появившиеся из одного файла с исходником). В частности, дать возможность классфайлу получать доступ до приватных имен другого классфайла, если все они скомпилированы в контексте одного и того же верхнеуровневого типа. Это нужно, чтобы компилятору не приходилось расставлять методы-переходники, пробрасывающие повышенный уровень доступа.
**Цели**
Расширить функциональность виртуальной машины так, чтобы компиляторы могли группировать классы в *гнезда* (nest), имеющие общий контекст контроля доступа. Это позволит классам компилироваться в индивидуальные классфайлы, логически продолжая оставаться частью одной общей сущности (вроде внутреннего класса в Java), что позволит получать доступ до членов друг друга без создания специальных методов-переходников.
Добавить возможность точно описывать вложенность классов и интересов внутри классфайлов.
Провести подготовительную работу в виртуальной машине, которая ляжет в основу связанной функциональности, такой как безопасная и хорошо поддерживаемая альтернатива `Unsafe.defineAnonymousClass()` и sealed классов.
**Ограничения**
Этот JEP не касается улучшения других масштабных проектов, связанных с контролем доступа, например, модулей.
**Мотивация**
Многие JVM-языки умеют объявлять несколько классов в одном файле (например, в Java имеются вложенные классы), или транслировать другие исходники (не классы!) в классфайлы. Между тем, с точки зрения пользователя, все эти вещи кажутся частями «одного и того же класса», и поэтому пользователь интуитивно предполагает, что к ним применяется один и тот же режим безопасности. Пытаясь соответствовать ожиданиям, компиляторам зачастую приходится уменьшать строгость проверок `private` членов класса до `package`, используя методы-переходники. К сожалению, подобные переходники разрушают всю инкапсуляцию, могут привести к ошибкам в различных инструментах или просто вызвать непонимание пользователя. Если же мы введем формальное определение для группы классфайлов, формирующих *гнездо*, в котором соседи (*nestmate*) объединены общим механизмом контроля доступа, это позволит достичь того же результата более быстро, безопасно и прозрачно для всех.
**Описание**
Спецификация языка Java позволяет классам и интерфейсам вкладываться друг в друга. [JLS 7.6](https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.6) вводит понятие верхнеуровневого объявления типа. В него можно вложить произвольное количество вложенных типов. Про верхнеуровневый тип и все типы внутри него, можно сказать, что они «формируют *гнездо*(*nest*)». Два члена гнезда называются *соседями* по этому гнезду (*nestmates*). Соседи имеют неограниченный доступ друг до друга ([JLS 6.6.1](https://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.6.1)), включая приватные поля, методы и конструкторы. Такой доступ распространяется совершенно на всё внутри объявления верхнеуровневого типа, содержащего все остальные типы. (Можно думать об этом верхнеуровневом типе как о «мини-пакете», внутри которого всем предоставляется расширенный доступ — более широкий чем то, что предоставляется членам настоящего Java-пакета, где все они лежат).
Java-компилятор компилирует группу вложенных типов в соответствующую ей группу классфайлов. Чтобы материализовать эту вложенность ([JVMS 4.7.6](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.6), [JVMS 4.7.7](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.7)), он использует атрибуты `InnerClasses` и `EnclosingMethod`. Этих атрибутов достаточно, чтобы JVM смогла выявить соседство, и чтобы мы могли дать соседям более широкое и общее определение, чем если бы мы считали их просто вложенными типами. В целях повышения эффективности, предлагается поменять формат классфайла, добавив туда пару новых атрибутов, используемых и соседями, и верхнеуровневым классом (который называется *вершиной гнезда*, *nest top*). Каждый сосед будет иметь атрибут, указывающий на вершину, а каждая вершина — атрибут, указывающий на известных соседей.
Мы немного поменяем правила доступа в JVM, добавив что-то такого в [JVMS 5.4.4](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.4.4):
Поле или метод `R` доступен из класса или интерфейса `D` тогда и только тогда, когда выполняется одно из следующих условий:
* …
* `R` имеет приватный доступ, определен в другом классе или интерфейсе `C`, таких что `C` и `D` являются соседями
Чтобы `C` и `D` стали соседями, у них должна быть одна и та же вершина. Тип `C` заявляет себя членом гнезда `D`, добавляя `D` в свой атрибут `MemberOfNest`. Это соседство проверяется, когда `D` тоже добавил `C` свой атрибут `NestMembers`. Проверка запускается только при попытке доступа к приватному члену соседа. Из-за этого, некоторые типы придется загрузить раньше, чем это могло бы произойти в других случаях.
После введения этих новых правил, и соответствующих изменений в байткоде, никакие обертки в javac больше не потребуется, поскольку javac сможет генерировать инструкции прямого вызова приватных членов соседей. Соответствующие байткоды вызова:
* `invokespecial` для приватных конструкторов
* `invokevirtual` для приватных (не интерфейсных) методов экземпляра
* `invokeinterface` для приватных интерфейсных методов
* `invokestatic` для приватных статических методов
После реализации концепции соседей и соответствующих правил в коде VM, мы не только дадим javac сбросить с себя эту роль и улучшим существующие проверки доступа, но еще и поможем другим проектам:
* При [специализации дженериков](http://cr.openjdk.java.net/~briangoetz/valhalla/specialization.html), любой специализированный тип можно будет создать как соседа для дженерика
* Безопасная и хорошо поддерживаемая замена для API `Unsafe.defineAnonymousClass()` сможет создавать новые классы, делая их соседями уже существующих
* Концепцию «sealed classes» можно будет реализовать как возможность создавать только такие подклассы, которые являются соседями
Более мягкие правила доступа повлияют на проверки в следующих вещах:
* раскрытие полей и методов ([JVMS 5.4.3.2](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.4.3.2), и т.п.)
* раскрытие method handle constants ([JVMS 5.4.3.5](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.4.3.5))
* раскрытие call site specifiers ([JVMS 5.4.3.6](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.4.3.6))
* проверка доступа на уровне языка Java с помощью экземпляров `java.lang.reflect.AccessibleObject`
* проверка доступа при выполнении запросов к `java.lang.invoke.MethodHandles.Lookup`
Возможно, придется рассмотреть взаимодействие с другими ограничениями, которые накладываются на вызывающие байткоды, например:
* приватные методы интерфейса должны вызываться через `invokespecial` ([JVMS 6.5](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokespecial))
и на семантику вызова `MethodHandle` (которая зеркально отражает ограничения байткодов). Кое-что придется поменять в общих описаниях, таких как [JVMS 3.7](http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-3.html#jvms-3.7).
Начав контролировать доступ до соседей на уровне виртуальной машины, мы можем ограничить и все остальные методы-переходники, генерируемые с помощью javac, уровнем доступа private, а не package-private, как это делается сейчас. Много где они не потребуются вовсе.
Актуальные проблемы:
1. Высказанные здесь предложения расширяют границы доступа до соседей, прямо на уровне VM. Если уж мы уже занялись этим, не должны ли мы *сузить* доступ до классов, объявленных как `protected` и `private`, тем самым более точно следуя правилам языка Java? Это потребует от JVM выполнения дополнительных проверок на основе значения `Class.getModifiers`. (Скорей всего, не должны, поскольку это может поломать такой код с использованием рефлекшена, который предполагает, что приватный доступ был расширен до package-private. Кроме того, новые проверки на protected-классах могут привести к глобальным эффектам, поскольку представляются в JVM как публичные).
2. Должно ли отношение «соседства» быть видно с помощью рефлекшена? Базовые методы рефлекшена, конечно, придется поправить, чтобы они учитывали правила доступа до соседей. Но вот стоит ли выносить проверку на соседство в публичное API — с этим придется разбираться. Самый простой запрос, который можно придумать: `Class#getNestTop`, который вернет либо `null`, если класс не является частью гнезда, либо вершину гнезда. (Если класс сам по себе является вершиной, запрос вернет самого себя).
**Альтернативы**
Мы можем продолжать генерировать обертки в компиляторе Java. Тут сложно что-то предсказать. Например, в Project Lambda было сложно раскрыть ссылки на методы, если в этом раскрытии участвовали внутренние классы, и это привело к созданию нового метода-переходника. Поскольку сгенерированные компиляторами обертки получаются хитрыми и непредсказуемыми, в них множество багов, и их очень сложно анализировать с помощью инструментария, включая декомпиляторы и отладчики.
В начале, для определения соседства мы предлагали использовать только существующие атрибуты `InnerClasses` и `EnclosingMethod`. Но создание специальных атрибутов соседства перевело вопрос на уровень более общий, чем просто отражение вложенных типов на уровне языка Java, и позволило придумать более эффективную реализацию.
**Тестирование**
Нам придется разработать большой набор тестов для JVM, которые будут проверять правила доступа и изменения в семантике байткодов, которые были введены специально для реализации соседства.
Точно так же, придется написать дополнительные тесты для рефлекшена, ссылок на методы, var-handles, и на внешний доступ к стандартным API типа JDWP, JVM TI и JNI.
Поскольку мы не предлагаем никаких проверок в языке, то и тестов на соответствие языку тоже писать не придется.
Адекватные функциональные тесты могут сами по себе появиться из языковых тестов, сразу как компилятор Java начнет использовать для себя описанные выше возможности.
**Риски и предположения**
Все эти новшества придется связать с новым номером версии классфайла, поскольку меняются правила, по которым работает компилятор Java.
Чтобы сохранить обратную совместимость со старыми версиями JVM, компилятору Java потребуется поддерживать устаревшую логику генерации оберток.
Более мягкие права доступа не должны что-либо поломать. В качестве исключения, теоретически, могут сломаться негативные compliance тесты.
Риск потерять совместимость — очень мал или отсутствует совсем, поскольку предлагается не ужесточить правила доступа, а наоборот, сделать их более мягкими. Если пользователи «обнаружили» наличие магических методов-оберток и придумали, как использовать их существование, то после внедрения наших изменений, делать этого они больше не смогут. Этот риск очень мал, потому что, в первую очередь, такие обертки не имеют стабильных имен.
Риск поломать целостность платформы — очень мал или отсутствует, поскольку предложенные правила присваивают новые права доступа только внутри какого-то конкретного рантайм пакета. Убирая необходимость в методах-переходниках, мы системно понижаем шанс доступа между отдельными верхнеуровневыми классами.
Валидация соседства требует наличия верхнеуровневого класса, даже если сам по себе он не используется (кроме как в качестве контейнера для вложенных членов). Это может оказать влияние на такие тесты или приложения, которые выбрасывают неиспользованные классы из своих дистрибутитвов.
**Влияние на другие системы**
Потребуются новые описания в спецификации JVM, а также изменения в реализации JVM. Кроме того, потребуются изменения в спецификации и реализации рефлекшена, ссылок на методы, var-handles, и возможно, JVM TI, JDWP и JNI (впрочем, нативные интерфейсы обычно игнорируют права доступа — может оказаться, что делать здесь почти ничего не придется).
Необходимо исследовать, как изменяется производительность при осуществлении дополнительных проверок доступа.
Текущий компилятор Java генерирует методы-переходники для доступа между гнездами. Несмотря на то, что в этом документе мы не требуем перестать генерировать их, все-таки, их лучше выбросить сразу же, как они станут бесполезны.
Правила соответствия между исходником на Java и классфайлом упростятся. И это очень вовремя, поскольку Project Lambda усложняет те же самые правила. Впрочем, некоторые эффекты возникают и на пересечении продуктов (например, [JDK-8005122](https://bugs.openjdk.java.net/browse/JDK-8005122)), поэтому недавнее увеличение сложности нельзя считать обычным ростом.
Выбрасывание переходников может слегка уменьшить размер некоторых приложений.
Возможно, придется поправить спецификацию [Pack200](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/pack200.html).
Авторы
======
**Джон Роуз** — инженер и архитектор JVM в Oracle. Ведущий инженер Da Vinci Machine Project (часть OpenJDK). Ведущий инженер JSR 292 (Supporting Dynamically Typed Languages on the Java Platform), занимается спецификацией динамических вызовов и связанных вопросов, таких как профилирование типов и улучшенные компиляторные оптимизации. Раньше работал над inner classes, делал изначальный порт HotSpot на SPARC, Unsafe API, а также разрабатывал множество динамических, параллельных и гибридных языков, включая Common Lisp, Scheme («esh»), динамические биндинги для C++.
Переводчики
===========
**Олег Чирухин** — на момент написания этого текста, работает архитектором в компании «Сбербанк-Технологии», занимается разработкой архитектуры систем автоматизированного управления бизнес-процессами. До перехода в Сбербанк-Технологии, принимал участие в разработке нескольких государственных информационных систем, включая Госуслуги и Электронную Медицинскую Карту, а также в разработке онлайн-игр. Спикер на [конференциях JUG.ru](https://jokerconf.com/) (JPoint, JBreak). Текущие исследовательские интересы включают виртуальные машины, компиляторы и языки программирования. | https://habr.com/ru/post/336768/ | null | ru | null |
# Пишем свой DSL на Clojure для работы с БД
Давайте напишем Clojure-библиотеку для работы с реляционными БД. Заодно потренируемся в написании макросов, попробуем использовать протоколы и мультиметоды. Ведь нету лучшего способа узнать язык, нежели что-то на нем написать. Ну… или почитать, как написал кто-то другой.
**Зачем?**В свое время мне понадобилась такая библиотека для личных нужд. На тот момент существовало два распространенных решения — ClojureQL и Korma. По тем или иным причинам они мне не понравились (да да, фатальный недостаток), было решено сделать свой велосипед. Велосипед вполне рабочий, я доволен. Из внешних отличий — выше расширяемость, упор делался на легкость добавления новых операторов и функций, была важна поддержка подзапросов и вставок из голого SQL.
В статье описывается общая структура этого велосипеда, правда, в несколько упрощенной форме. Некоторых фич нету, код обычно разрабатывался в иной последовательности, за бортом осталось много промежуточных вариантов API. Но, в целом, основные архитектурные идеи описаны точно. Надеюсь, кому-нибудь статья окажется полезной.
#### Так а что мы пишем?
Создаем DSL (**не** ORM). В отличие от ORM:
— никаких «умных объектов» — только функции и встроенные структуры данных (включая records);
— никаких «ленивых» связей, магической подгрузки записей и прочих «гадостей»;
— мы хотим четко контролировать время возникновения побочных эффектов — они должны происходить только в строго ожидаемых местах.
Добавим еще несколько требований:
— схожесть с SQL;
— прозрачность, чем меньше «магии» — тем лучше;
— никакой валидации запросов, схем и подобного — оставляем на совести БД;
— автоматическое квотирование идентификаторов и аргументов;
— обеспечение независимости от конкретной базы (но без фанатизма);
— иногда нам нужно писать БД-зависымый код (хранимки, триггеры и т.п.).
Что понимается под «мало магии»? Грубо говоря, подобной библиотеке **не следует** заниматься оптимизацией запросов, да и любой подобной деятельностью. Теоретически это, быть может, и позволит несколько (ну чуть-чуть) разгрузить БД, на практике дела обычно ухудшаются. Ведь только БД и программист (изредка), обладают достаточными знаниями, чтобы правильно выполнить нужную оптимизацию. Плохой вариант: разработчик пишет запрос, затем очень тщательно изучает логи приложения, дабы выяснить, какой же SQL на самом деле посылается в БД. Перепроверять логи приходится регулярно, ведь после нового релиза библиотека может неожиданно стать «умнее»!
Итак, наш DSL по возможностям будет достаточно ~~глупым~~ прозрачным — семантически мы работаем с голым SQL, но пользуемся синтаксисом Clojure. Что-то вроде записи SQL посредством S-выражений с учетом специфики нашего языка. Выглядеть все будет примерно так:
```
(select
(fields [:name :role_name])
(from :Users)
(join-inner :Roles (== :Users.role_id :Roles.id))
(where (= :Roles.name "admin"))
(order :Users.name)
(limit 100))
```
Для этого кода нужно будет породить запрос:
```
SELECT `name`, `role_name`
FROM `Users` INNER JOIN `Roles` ON `Users`.`role_id` = `Roles`.`id`
WHERE `Roles`.`name` = ?
ORDER BY `Users`.`name`
LIMIT ?
```
Все имена мы экранируем при помощи обратных кавычек. По-хорошему надо бы использовать двойные кавычки (а еще лучше учитывать тип БД), но в целях читабельности в примерах будем пользоваться MySQL-стилем. Константы заменяются на `?` — jdbc-драйвер конкретной БД будет сам заниматься передачей и экранированием параметров.
Непосредственным выполнением SELECT запросов у нас будут заниматься отдельные функции: `fetch-all`, `fetch-one`, `with-fetch`. Все они принимают на вход параметры подключения к БД и запрос, который мы хотим выполнить:
```
(def db
{:classname "com.mysql.jdbc.Driver"
:subprotocol "mysql"
:user "test"
:password "test"
:subname "//localhost/test"})
; вытаскиваем ровно 1 запись из таблицы Users
(fetch-one db
(select
(from :Users)
(where (== :id 123))))
; все записи из таблицы в виде вектора
(fetch-all db
(select (from :Users)))
(with-fetch db [rows (select (from :Users))]
; тут мы работаем с *ленивой* последовательностью `rows`
(doseq [r rows]
(print ">" r)))
```
#### Генерируем SQL
Для начала определимся, как будем хранить запросы внутри нашей библиотеки.
```
(def raw-select
['SELECT :name :role_name
['FROM :Users ['JOIN :Roles ['ON :Users.role_id :Roles_id]]]
['WHERE ['LIKE :Users.name "And%"]
['LIMIT 100]]])
```
В этом примере мы имеем дерево из векторов, символов и ключей. При помощи символов будем обозначать ключевые слова SQL, при помощи ключей — имена таблиц и полей, значения (строки, числа, даты и прочее) оставляем «как есть». Скомпилированный запрос представим в виде пары: SQL код (строка) и вектор аргументов. Заводим отдельный тип:
```
(defrecord Sql [sql args])
;; запросы после компиляции будут выглядеть так:
(Sql. "SELECT * FROM `Users` WHERE `id` = ?" [123])
```
Это нижнее представление в нашей библиотеке. Реализуем преобразование из одного представления в другое. Для этого нужен некий *универсальный* способ преобразовывать *любую* сущность в запись `Sql`. Отлично подойдут протоколы:
```
(defprotocol SqlLike
(as-sql [this]))
; вспомогательная функция
(defn quote-name
[s]
(let [x (name s)]
(if (= "*" x)
x
(str \` x \`))))
(extend-protocol SqlLike
; для любого `x` (= (as-sql (as-sql x)) (as-sql x))
Sql
(as-sql [this] this)
; по умолчанию считаем все объекты параметрами для запросов
Object
(as-sql [this] (Sql. "?" [this]))
; экранируем имена таблиц и столбцов
clojure.lang.Keyword
(as-sql [this] (Sql. (quote-name this) nil))
; символами обозначаем ключевые слова SQL
clojure.lang.Symbol
(as-sql [this] (Sql. (name this) nil))
; для nil специальное ключевое слово
nil
(as-sql [this] (Sql. "NULL" nil)))
```
Вместо протоколов можно было бы воспользоваться набором `if`-ов, или вообще pattern matching. Но у протоколов есть неоспоримый плюс: пользователи библиотеки могут *сами* реализовать специфическое преобразование для *любых* типов. Например, кто-то может захотеть автомагически извлекать значения из ссылок:
```
(extend-protocol SqlLike
clojure.lang.ARef
(as-sql [this] (as-sql @this)))
; теперь вместо констант можно передавать
; ссылки (ref, agent, var, atom)
(def a (atom 123))
(assert
(=
(as-sql a)
(as-sql @a)
(Sql. "?" [123])))
```
Реализуем наш протокол для векторов и списков:
```
; вспомогательная функция, объединяет 2 sql-объекта в один
(defn- join-sqls
([] (Sql. "" nil))
([^Sql s1 ^Sql s2]
(Sql. (str (.sql s1) " " (.sql s2)) (concat (.args s1) (.args s2)))))
(extend-protocol SqlLike
clojure.lang.Sequential
(as-sql [this]
(reduce join-sqls (map as-sql this))))
```
С эффективностью алгоритма тут не очень хорошо, можно написать код и побыстрее. Зато теперь:
```
(as-sql ['SELECT '* ['FROM :Users] ['WHERE :id '= 1 'AND :name 'IS 'NOT nil]])
; => #user.Sql{:sql "SELECT * FROM `Users` WHERE `id` = ? AND `name` IS NOT NULL" :args (1)}
```
Отлично! Определим еще парочку функций…
```
(require '[clojure.java.jdbc :as jdbc])
(defn- to-sql-params
[relation]
(let [{s :sql p :args} (as-sql relation)]
(vec (cons s p))))
(defn fetch-all
[db relation]
(jdbc/query
db
(to-sql-params relation)
:result-set-fn vec))
; аналогично реализуем `fetch-one`
```
Работать напрямую с JDBC утомитильно, поэтому хитрим — всю грязную работу за нас делает `clojure.java.jdbc`. Наконец у нас уже есть вполне приемлемые результаты, библиотекой даже можно пользоваться:
```
; параметры подключения к БД
(def db
{:classname "com.mysql.jdbc.Driver"
:subprotocol "mysql"
:user "test"
:password "test"
:subname "//localhost/test"})
; делаем запрос к БД
(fetch-all
db
(as-sql '[SELECT * FROM :users ORDER BY :name]))
```
Ах да, мы же забыли про `with-fetch`. Реализуем:
```
(defmacro with-fetch
[db [v rel :as vr] & body]
`(let [params# (to-sql-params ~rel)
rsf# (fn [~v] ~@body)]
(jdbc/query
~db
params#
:result-set-fn rsf# ; весь RS передаем в функцию rsf#
:row-fn identity))) ; строки никак не обрабатываем
```
#### Наращиваем запросы итеративно
У выбранного представления есть серъезные минусы — запросы сложно наращивать *итеративно*. Допустим, у нас есть дерево для запроса `SELECT FROM `Users` LIMIT 10`, а мы хотим в него добавить секцию `WHERE`. В общем случае, для подобного придется заниматься разбором синтаксиса SQL (анализировать AST-дерево), чего, по правде говоря, очень хотелось бы избежать.
Зачем нам «итеративно наращивать» запросы? Ну, во-первых, это полезная опция сама по себе. При написании программы частенько мы заранее не знаем, какие запросы будем выполнять. Пример: динамически строим произвольные условия для секций `WHERE` и ORDER BY в админке.
Но гораздо важнее то, что это хорошая практика при написании программ на Clojure. Мы разбиваем работу на множество небольших кусочков, итеративно делающих свою работу. Каждый такой кирпичик (чистая функция) принимает данные на вход и возвращает «подправленный» результат. Кирпичики легко тестировать и разрабатывать. А под конец такие кусочки легко собираются вместе.
Запросы представляем в виде хеш-таблицы. Пример:
```
(def some-query-example
{
; отображение "алиас таблицы - имя талицы"
:tables {:r :Roles, :u :Users},
; список [алиас таблицы, тип джоина, выражение для секции ON]
; первый элемент -- [исходная таблица, nil, nil]
; используем список, т.к. нам важен порядок join'ов
:joins
[[:u nil nil]
[:r :inner ['= :Users.role_id :Roles.id]]]
; ast-дерево выражения
:where [:= :u.name "Ivan"],
; отображение "алиас столбца - имя столбца"
:fields {:name :name, :role_name :role_name},
; просто числа
:offset 1000,
:limit 100,
; order, group, having, etc...
})
```
Для секций `WHERE`, `ORDER BY` и т.п. мы храним AST-дерево выражения — так проще. Для списка таблиц и полей мы храним словари, ключи — имена алиасов, значения — выражения или имена таблиц. В рамках такой структуры реализуем необходимые функции:
```
; для `limit` & `offset` тривиально
(defn limit
[relation v]
(assoc relation :limit v))
; *пока* сойдут и такие реализации
(defn fields
[query fd]
(assoc query :fields fd))
(defn where
[query wh]
(assoc query :where wh))
; helper-функция
(defn join*
[{:keys [tables joins] :as q} type alias table on]
(let [a (or alias table)]
(assoc
q
:tables (assoc tables a table)
:joins (conj (or joins []) [a type on]))))
(defn from
([q table] (join* q nil table table nil))
([q table alias] (join* q nil table alias nil)))
(defn join-cross
([q table] (join* q :cross table table nil))
([q table alias] (join* q :cross table alias nil)))
;; для других join-ов (left, right, full) нужны макросы - пока опустим
```
Итак, у нас есть много функций (`where`, `fields`, `from`, `join`, `limit` и другие), умеющих «подправлять» запросы. Точка отправления — пустой запрос.
```
(def empty-select {})
```
Теперь мы можем записывать:
```
(-> empty-select
(fields [:name :role_name])
(from :Users)
(limit 100))
```
Этот код использует макрос [->](http://clojuredocs.org/clojure_core/clojure.core/-%3E), который разворачивается во что-то вроде:
```
(limit
(from
(fields
empty-select
[:name :role_name])
:Users)
100)
```
Для красоты определяем свой макрос `select`, который ведет себя подобно `->`:
```
(defmacro select
[& body]
`(-> empty-select ~@body))
```
Осталось научить нашу библиотеку конвертировать одно представление в другое.
```
; пустой SQL, поскольку nil преобразуется в "NULL"
(def NONE (Sql. "" nil))
; большинство фукнций реализуется тривиально
(defn render-limit [s]
(if-let [l (:limit s)]
['LIMIT l]
NONE))
(defn render-fields [s] '*) ; пока будем возвращать все столбцы
; эти функции реализуем чуть позже
(defn render-where [s] NONE)
(defn render-order [s] NONE)
(defn render-expression [s] NONE)
; а эти выходят за рамки статьи
(defn render-group [s] NONE)
(defn render-having [s] NONE)
(defn render-offset [s] NONE)
; вспомогательная функция
(defn render-table
[[alias table]]
(if (= alias table)
; если алиас и таблица совпадают, то не выводим 'AS'
table
[table 'AS alias]))
(defn render-join-type
[jt]
(get
{nil (symbol ",")
:cross '[CROSS JOIN],
:left '[LEFT OUTER JOIN],
:right '[RIGHT OUTER JOIN],
:inner '[INNER JOIN],
:full '[FULL JOIN],
} jt jt))
; некоторые функции довольно сложные
(defn render-from
[{:keys [tables joins]}]
; секции FROM может и не быть!
(if (not (empty? joins))
['FROM
; первый джоин
(let [[a jn] (first joins)
t (tables a)]
; первый джоин должен делаться при помощи `(from ..)`
(assert (nil? jn))
(render-table [a t]))
; перебираем оставшиеся джоины
(for [[a jn c] (rest joins)
:let [t (tables a)]]
[(render-join-type jn) ; связка JOIN XX или запятая
(render-table [a t]) ; имя таблицы и алиас
(if c ['ON (render-expression c)] NONE) ; секция 'ON'
])]
NONE))
(defn render-select
[select]
['SELECT
(mapv
#(% select)
[render-fields
render-from
render-where
render-group
render-having
render-order
render-limit
render-offset])])
```
Пользователи библиотеки могут вообще не знать про протокол `SqlLike` и функцию `as-sql`. Хорошая практика. Для сравнения, в Java интерфейсы часто определяют API модуля/библиотеки. В Clojure протоколы обычно создаются для самых низкоуровневых операций, некоего базиса, над которым уже работает набор helper-функций. И вот уже эти helper-ы предоcтавляют публичный API библиотеки. Пробуем сгенерировать простой запрос:
```
(fetch-all db
(render-select
(select
(from :Users)
(limit 10)))
```
Готово! Правда вызывать `render-select` вручную утомительно. Исправляем:
```
(declare render-select)
; все поля объявлять не обязательно
; record поддерживает установку ключей, не перечисленных при объявлении типа
(defrecord Select [fields where order joins tables offet limit]
SqlLike
(as-sql [this] (as-sql (render-select this))))
(def empty-select (map->Select {}))
```
Теперь при выполнении `(as-sql (select ...))` автоматически будет вызываться и `render-select`:
```
(fetch-all db
(select
(from :Users)
(limit 10)))
; если мы хотим просто посмотреть SQL без выполнения запроса
(as-sql
(select
(from :Table)
(limit 10)))
; или даже так
(select
(from :Table)
(limit 10)
(as-sql))
```
#### Поддержка выражений
Приступим к написанию функции `where`. Мы хотим иметь возможность использовать ее так:
```
(select
(from :Table)
(where (and (> :x 1) (== :y "z"))))
```
Очевидно, что нельзя вычислять `(> :x 1)` в момент вызова `where` — нужен макрос. Построенное выражения будем хранить в виде AST-дерева: узлы — операторы, листья — константы и поля. Для начала напишем вспомогательную функцию `where*`:
```
; склеиваем 2 выражения вместе при помощи AND
(defn- conj-expression
[e1 e2]
(cond
(not (seq e1)) e2
(= 'and (first e1)) (conj (vec e1) e2)
:else (vector 'and e1 e2)))
(conj-expression '[> 1 2] '[< "a" "b"])
; => '[and [> 1 2] [< "a" "b"]])
(conj-expression '[and [> 1 [+ 2 3]] [= :x :y]] '[<> "a" "b"])
; => '[and [> 1 [+ 2 3]] [= :x :y] [<> "a" "b"]]
(defn where*
[query expr]
(assoc query :where (conj-expression (:where query) expr)))
```
Теперь пришла пора для `render-where`:
```
; взаимнорекурсивные функции
(declare render-operator)
(declare render-expression)
; функция или оператор?
(defn- function-symbol? [s]
(re-matches #"\w+" (name s)))
; форматируем вызов функции или оператора
(defn render-operator
[op & args]
(let [ra (map render-expression args)
lb (symbol "(")
rb (symbol ")")]
(if (function-symbol? op)
; функция (count, max, ...)
[op lb (interpose (symbol ",") ra) rb]
; оператор (+, *, ...)
[lb (interpose op (map render-expression args)) rb])))
(defn render-expression
[etree]
(if (and (sequential? etree) (symbol? (first etree)))
(apply render-operator etree)
etree))
(defn render-where
[{:keys [where]}]
(if where
['WHERE (render-expression where)]
NONE))
```
Отлично, теперь мы можем записывать простейшие выражения:
```
(select
(from :Users)
(where* ['= :id 1])
(as-sql))
; => (Sql. "SELECT * FROM `Users` WHERE ( `id` = ? )" [1])
```
Получилось некрасиво, поправим это несложным макросом:
```
(defn prepare-expression
[e]
(if (seq? e)
`(vector
(quote ~(first e))
~@(map prepare-expression (rest e)))
e))
(defmacro where
[q body]
`(where* ~q ~(prepare-expression body)))
```
Заменяем все последовательности (списки) на вектора. Остальные значения оставляем как есть. Мы пропустили важный момент — некоторые операторы в Clojure и SQL называются по-разному, например `<>` и `not=`. Вопрос философский, какой же вариант лучше использовать. С одной стороны, мы решили оставлять библиотеку максимально «глупой», с другой — гораздо приятнее видеть «родные» для Clojure функции. Давайте разрешим оба варианта:
```
(defn- canonize-operator-symbol
[op]
(get '{not= <>, == =} op op))
; перепишем функцию
(defn prepare-expression
[e]
(if (seq? e)
`(vector
(quote ~(canonize-operator-symbol (first e)))
~@(map prepare-expression (rest e)))
e))
```
Хорошо, при использовании макроса `where` можно писать оба варианта, но внутри нашего представления запросов будет только один. То что надо. У нас остался небольшой должок — не работают джоины.
```
(defmacro join-left
([q table cond] `(let [t# ~table] (join-left ~q t# t# ~cond)))
([q table alias cond] (join* ~q :cross ~table ~alias ~(prepare-expression cond))))
; аналогично для других джоинов, меняется только ключ...
```
Писать несколько одинаковых макросов — неблагородное дело:
```
; импортируем очень полезный макрос `do-template`
(use 'clojure.template)
; этот код разворачивается в 5 объявлений макросов
(do-template
[join-name join-key] ; параметры для шаблона
; сам шаблон
(defmacro join-name
([relation alias table cond]
`(join* ~relation ~join-key ~alias ~table ~(prepare-expression cond)))
([relation table cond]
`(let [table# ~table]
(join* ~relation ~join-key nil table# ~(prepare-expression cond)))))
; значения для параметров
join-inner :inner,
join :inner,
join-right :right,
join-left :left,
join-full :full)
```
#### Больше возможностей
Пока мы умеем выполнять только простейшие запросы. Сделаем поддержку выражений в перечислении столбцов.
```
; применяем `f` к значениям `m` (не ключам)
(defn- map-vals
[f m]
(into (if (map? m) (empty m) {}) (for [[k v] m] [k (f v)])))
; счетчик для генерации уникальных идентификаторов
(def surrogate-alias-counter (atom 0))
; генерируем идентификаторы вида :__00001234
(defn generate-surrogate-alias
[]
(let [k (swap! surrogate-alias-counter #(-> % inc (mod 1000000)))]
(keyword (format "__%08d" k))))
; преобразуем произвольное выражение в "алиас"
(defn as-alias
[n]
(cond
(keyword? n) n ; имя столбца/таблицы оставляем как есть
(string? n) (keyword n) ; аналогично для строк
:else (generate-surrogate-alias))) ; для выражений генерируем суррогатный алиас
; список столбцов для запроса -- словарь "алиас - выражение" или вектор столбцов
(defn- prepare-fields
[fs]
(if (map? fs)
(map-vals prepare-expression fs)
(into {} (map (juxt as-alias prepare-expression) fs))))
(defn fields*
[query fd]
(assoc query :fields fd))
(defmacro fields
[query fd]
`(fields* ~query ~(prepare-fields fd)))
(defn render-field
[[alias nm]]
(if (= alias nm)
nm ; просто имя столбца
[(render-expression nm) 'AS alias]))
(defn render-fields
[{:keys [fields]}]
(if (or (nil? fields) (= fields :*))
'*
(interpose (symbol ",") (map render-field fields))))
```
Неплохо. Теперь можно писать так:
```
(select
(fields {:n :name, :a :age}) ; алиасы для столбцов
(from :users))
; или так
(select
(fields {:cnt (count :*), :max-age (max :age)})
(from :users))
; или даже так
(select
(fields [(count :*)]) (from :users))
```
Добавляем сортировку. Уже привычный порядок действий: создаем функцию `order*` и макрос `order`, реализуем `render-order`:
```
(defn order*
([relation column] (order* relation column nil))
([{order :order :as relation} column dir]
(assoc
relation
:order (cons [column dir] order))))
(defmacro order
([relation column]
`(order* ~relation
~(prepare-expression column)))
([relation column dir]
`(order* ~relation
~(prepare-expression column) ~dir)))
(defn render-order
[{order :order}]
(let [f (fn [[c d]]
[(render-expression c)
(get {nil [] :asc 'ASC :desc 'DESC} d d)])]
(if order
['[ORDER BY] (interpose (symbol ",") (map f order))]
[])))
```
Появилась возможность сортировать выборку в наших запросах, в том числе по произвольному выражению:
```
(select
(from :User)
(order (+ :message_cnt :post_cnt)))
```
Аналогичным способом можем добавить поддержку группировок, подзапросов и подобного… Вот так, например, может выглядеть реализация для `UNION ALL`:
```
; вспомогательная функция-рендер
(defn render-union-all
[{ss :selects}]
(interpose ['UNION 'ALL] (map render-select ss)))
; отдельный тип, просто храним список всех селектов
(defrecord UnionAll [selects]
SqlLike
(as-sql [this] (as-sql (render-union-all this))))
; тут нам *не* нужна пара функция-макрос
(defn union-all
[& ss]
(->UnionAll ss))
;; пользуемся ...
(as-sql
(union-all
(select (from :Users) (fields [:email]))
(select (from :Accounts) (fields [:email]))))
```
#### Поддержка нескольких БД — диалекты
Добавим поддержку нескольких баз данных. Идея проста: ряд функций в нашей библиотеке может менять свое поведение в зависимости от того, какую базу мы используем. Организуем древовидную иерархию диалектов:
```
; самый общий диалект
(def ^:const default-dialect ::sql92)
; тут мы будем хранить диалект для текущего соединения с БД
(def ^:dynamic *dialect* nil)
; а это иерархия диалектов
(def dialects-hierarchy (make-hierarchy))
; функция, чтобы регестрировать диалекты было удобнее
(defn register-dialect
([dialect parent]
(alter-var-root #'dialects-hierarchy derive dialect parent))
; по умолчанию диалекты наследуются от ::sql92
([dialect]
(register-dialect dialect default-dialect)))
; пример
(register-dialect ::pgsql)
(register-dialect ::pgsql92 ::pgsql)
; postgresql позволяет определять свои операторы
; можно создавать ad-hoc диалекты для конкретных баз
(register-dialect ::my-custom-db-with-extra-functions ::pgsql92)
```
Теперь определим небольшой макрос `defndialect`:
```
; просто возвращаем текущий диалект
; игнорируем все параметры
(defn current-dialect
[& _]
(or *dialect* default-dialect))
; макрос для определения "обычных" функций
(defmacro defndialect
[name & args-and-body]
`(do
; определяем мультиметод
(defmulti ~name current-dialect :hierarchy #'dialects-hierarchy)
; реализация для диалекта `sql92`
(defmethod ~name default-dialect ~@args-and-body)))
```
Теперь нужно не забыть занести значение диалекта в переменную `*dialect*`:
```
(defmacro with-db-dialect
[db & body]
; диалект нужно прописать в параметры подключения к БД
`(binding [*dialect* (:dialect ~db)]
~@body))
```
Отлично. Остался последний шаг: переписываем все определения функций для рендеринга, заменяя `defn` на `defndialect`. Тело функций менять не надо. И теперь нас появилась возможность генерировать разный SQL в зависимости от базы:
```
(defndialect quote-name
[s]
(let [x (name s)]
(if (= "*" x) x (str "\"" x "\""))))
; MySQL использует обратные кавычки
(defmethod quote-name ::mysql
[s]
(let [x (name s)]
(if (= "*" x) x (str "`" x "`"))))
```
Напоследок замечаем, что вовсе нет необходимости вызывать `with-db-dialect` вручную, можно переписать наши функции `fetch-*`:
```
(defn fetch-all
[db relation]
(jdbc/query
db
(with-db-dialect db (to-sql-params relation))
:result-set-fn vec))
; аналогично переписываем остальные функции fetch-*
```
#### RAW запросы
Иногда нужно использовать слишком специфические запросы — их проще записывать в виде строки, минуя DSL. Не проблема:
```
(require '[clojure.string :as s])
(defn format-sql
[raw-sql args]
(let [; находим все плейсхолдеры вида :x
al (map
(comp keyword second)
(re-seq #":([\w.-]+)" raw-sql))
; заменяем все плейсхолдеры на "?"
pq (s/replace raw-sql #":[\w.-]+" "?")]
(->Sql pq (map args al))))
; пользуемся...
(fetch-all db
(format-sql
"SELECT * FROM Users WHERE role = :rl AND age < :age"
{:rl "admin" :age 18}))
```
Кстати, сформированные таким образом запросы можно использовать в `UNION ALL`, который мы реализовали чуть выше. К сожалению, инкрементально изменять их не получится — для этого пришлось бы парсить строку с SQL-кодом. Обходной путь — подзапросы:
```
(defn users-by-role
[r]
(format-sql "SELECT * FROM Users WHERE role = :r" {:r r}))
; вот так нельзя
(->
(users-by-role "ADMIN")
(order :name)
(as-sql))
; а вот так можно..?
(select
(from :x (users-by-role "ADMIN"))
(order :name)
(as-sql))
; => #user.Sql{:sql "SELECT * FROM SELECT * FROM Users WHERE role = ? AS `x` ORDER BY `name`", :args ("ADMIN")}
```
Упс, в сгенерированном SQL не хватает круглых скобочек. Устраняем оплошность, вот исправленная версия `render-table`:
```
(defn render-table
[[alias table]]
(if (= alias table)
; если алиас и таблица совпадают, то не выводим 'AS'
table
; если таблица - это sql - добавляем скобочки
(if (or (instance? Sql table) (instance? Select table))
[(symbol "(") table (symbol ")") 'AS alias]
[table 'AS alias])))
; вот теперь работает как положено
(select
(from :x (users-by-role "ADMIN"))
(order :name)
(as-sql))
```
#### Постоянное соединение с БД
Разумеется, открывать каждый раз новое соединение внутри функций `fetch-*` не вариант. Снова макрос:
```
(defn with-connection*
[db body-fn]
(assert (nil? (jdbc/db-find-connection db)))
(with-open [conn (jdbc/get-connection db)]
(body-fn (jdbc/add-connection db conn))))
(defmacro with-connection
[binding & body]
`(with-connection* ~(second binding) (fn [~(first binding)] ~@body)))
```
Тут мы проверяем что открытого соединения еще нету, открываем новое и «прикрепляем» к словарю с параметрами БД. Пользоваться нужно так:
```
(def db {...})
(with-connection [c db]
; в параметрe `c` хранятся параметры из `db` + открытое соединение
(fetch-all c (select (from :B)))
; ...
(fetch-all c (select (from :A))))
```
Аналогичным способом можно добавить поддержку транзакций.
**Небольшой бонус - больше скорости с элементами ненормального программирования**Очевидно, что библиотека вносит дополнительные расходы: нужно сформировать исходный запрос в самом высокоуровневом представлении, преобразовать его при помощи `render-select`, результат пропустить через `as-sql`. В добавок ко всему, многие функции у нас реализованы через `defndialect`, что тоже отрицательно сказывается на производительности. Особенно обидно повторять такие операции для простейших запросов вроде «вытащить запись по id». По правде говоря, оверхед совсем незначительный по сравнению со временем работы БД… Но при сильном желании можно добавить еще больше скорости. Итак, наша цель:
```
; специальный макрос, который компилирует SQL только один раз
(defselect get-user-by-id [x]
(from :Users)
(where (= :id x))))
; или так, особенно удобно оформлять legacy запросы
(defselect get-user-by-id [x]
"SELECT * FROM `Users` WHERE `id` = :x")
; используем
(fetch-one db (get-user-by-id 123))
```
Есть проблемка — диалекты. Мы не можем вычислить запрос на этапе компиляции программы (в теле макроса), поскольку не знаем какой же диалект будет активен при выполнении. Можно предвычислять запрос для всех доступных диалектов, но они ведь могут добавляться динамически (в рантайме) — скорее всего мы пропустим нужный, плохо.
Альтернативное решение — кешировать вычисленные запросы. Т.е. каждый такой `defselect` хранит в себе кеш — словарь «диалект — SqlLike-объект». Таким образом, для каждого диалекта мы выполняем компиляцию (потенциально дорогую для сложных запросов) один раз для каждого диалекта. После извлечения записи `Sql` мы просто подставляем нужные аргументы в поле `:args`, никак не изменяя `:sql`.
```
; ленивый запрос - просто храним функцию для вычисления SQL кода
(defrecord LazySelect [content-fn]
SqlLike
(as-sql [this] (content-fn)))
; уже готовый запрос в виде строки
(defrecord RenderedSelect [content]
SqlLike
(as-sql [this] (as-sql content)))
; вспомогательный тип
(defrecord SurrogatedArg [symbol]
SqlLike
(as-sql [this] (Sql. symbol "?")))
(defn emit-precompiled-select
[name args body]
(let [; тут args - имена параметров функции
sargs (map ->SurrogatedArg args)
; отображение суррогатных аргументов в символы
sargs-args (into {} (map vector sargs args))]
`(let [sqls# (atom {}) ; тут храним вычисленые запросы
; "оригинальная" функция
original# (fn ~name ~args (as-sql (select ~@body)))
; вычисляем оригинальную функцию,
; но с суррогатными параметрами
compile# (fn [] (apply original# (list ~@sargs)))]
(defn ~name ~args
(->LazySelect
(fn []
(let [; берем диалект, проверяем есть ли
; вычисленный запрос
dialect# (current-dialect)
cached-sql# (get @sqls# dialect#)
; если нет - вычисляем новый
sql# (if cached-sql#
cached-sql#
; синхронизация упрощена
; запрос может скомпилироваться несколько раз,
; но нам это не страшно - игнорируем
(let [new-sql# (compile#)]
(swap! sqls# assoc dialect# new-sql#)
new-sql#))
; извлекаем вектор с суррогатными параметрами
args# (:args sql#)]
; заменяем суррогатные параметры на настоящие
(assoc sql# :args (replace ~sargs-args args#)))))))))
; запрос задан в виде строки
(defn emit-raw-select
[name args sql]
; вычисляем список параметров
(let [args-map (into {} (map (juxt keyword identity) args))]
; определяем функцию, порождающую RenderedSelect
`(defn ~name ~args
(->RenderedSelect
(format-sql ~sql ~args-map)))))
(defmacro defselect
[name args & body]
(if (and (== 1 (count body)) (string? (first body)))
(emit-raw-select name args (first body))
(emit-precompiled-select name args body)))
```
#### В завершение
В статье не затронута реализация функций для модификации БД: вставка, удаление, обновление записей. Нету инструментов для работы с DDL, транзакциями да и много чего еще. Зато новую функциональность добавить довольно легко, часто даже без модификации существующего кода. Предложенный способ — один из многих, не без недостатов, но вполне имеющий право на жинь. Напоследок оставляю ссылку на [код полной версии](https://github.com/anjensan/azql), по мотивам которой и была написана эта статья. | https://habr.com/ru/post/204992/ | null | ru | null |
# Как мы подружились с PayPal
Дорогой иностранный гость с фамилией слишком известной, чтобы ее называть, гражданин PayPal только-только «сошел с корабля» на отечественный «причал», но уже успел стать своим на балу, где активно крутят танцы всех стилей и направлений электронные платежные системы российского сегмента. Мы не стали стоять в стороне и поспешили завести полезное знакомство со столь уважаемым товарищем, добавив, наконец, и его доброе имя в свой [список друзей](https://unitpay.ru/tariff). С какой стороны подойти, о чем говорить и как привлечь его внимание читаем в небольшой истории под катом.
#### Дружба начинается с улыбки
Первый робкий шаг на пути к большой дружбе – представление, то есть, регистрация, где в персональных данных необходимо предоставить информацию о коммерческой деятельности компании, что и было нами добросовестно выполнено.
Однако вместо легких и непринужденных отношений, которым мы успели мысленно обрадоваться, нас ожидало неприветливое сообщение об ограничении счета и просьба предоставить целый ряд дополнительных документов для подтверждения нашего аккаунта. Не успели мы собрать все необходимое, как, к счастью, в середине сентября PayPal значительно упростил процедуру подключения юридических лиц. Требовалось только заполнить специальную для этого форму на стороне PayPal. Но и теперь рано было радоваться — первые несколько дней форма попросту не работала. Мы честно заполняли все обязательные и необязательные поля, но каждый раз получали ошибку передачи данных и, как ни старались, это повторялось снова и снова. Не растеряв решительности и имея в запасе немало упорства, спустя неделю мы повторили “эксперимент” и, наконец, получили долгожданное подтверждение, а в скором времени и заветное письмо от компании PayPal.
#### Настоящий друг познается в API
Разобраться во всех тонкостях [протокола PayPal](https://developer.paypal.com/webapps/developer/docs/api/) дело не легкое. Разбросанные по разным частям сайта куски документаций, тяжелое наследие SOAP, всеобщая мешанина стека протоколов (NVP, SOAP, REST) и нехватка примеров сделали свое дело. Типичный пример неразберихи, действие реализуемое одним протоколом, невозможно выполнить другим и наоборот.
Но путь в тысячу миль начинается с первого шага, отбросив все сомнения прочь, будем использовать наиболее популярный на данный момент REST API, а в качестве обертки к нему возьмем их собственный [PHP SDK](https://github.com/paypal/rest-api-sdk-php). Некоторые вещи, правда, все равно придется додумывать самим, исследуя код.
Общую идею можно описать в следующих шагах:
1. Регистрируем [PayPal Application](https://developer.paypal.com/webapps/developer/applications/myapps), для получения пар значений client\_id и secret\_key для live и sandbox режима:
2. Производим OAuth авторизацию:
```
$apiContext = new ApiContext(new OAuthTokenCredential(
$clientId, $clientSecret));
$apiContext->setConfig([ 'mode' => 'live']);
```
3. Делаем запрос на создание платежа. Если вы планируете принимать оплату со счета paypal, а также привязанной к нему карты не забудьте указать метод оплаты: paypal
```
$payer = new Payer();
$payer->setPaymentMethod('paypal');
$amount = new Amount();
$amount->setCurrency('RUB');
$amount->setTotal('10');
$item1 = new Item();
$item1->setName('Продажа товара/услуги')->setCurrency('RUB')->setQuantity(1)->setPrice('10');
// Ид товара/услуги на вашей стороне
$item1->setSku('1000');
$itemList = new ItemList();
$itemList->setItems(array($item1));
$transaction = new Transaction();
$transaction->setAmount($amount);
$transaction->setDescription('Payment to UnitPay');
$transaction->setItemList($itemList);
$payment = new Payment();
$payment->setIntent('sale');
$payment->setPayer($payer);
$payment->setTransactions(array($transaction));
$payment>setRedirectUrls(array(
"return_url" => $resultUrl,
"cancel_url" => $resultUrl
));
$payment->create($apiContext);
```
4. В ответ получаем номер платежа в PayPal и redirectURL формы оплаты, куда и перебрасываем пользователя:
```
// ID платежа, связываем его с заказом и сохраняем в БД
$payment->getId();
$links = $payment->getLinks();
foreach ($links as $link) {
if ($link->getMethod() == 'REDIRECT') {
header('location:'.$link->getHref());
return;
}
}
```
5. Подтверждение счета клиентом:
6. Автоматический возврат клиента с GET параметрами token, PayerID на $resultUrl (см. шаг 3).
7. Деньги списаны, но платеж еще не выполнен. Говорим PayPal, что да, мы точно подтверждаем платеж:
```
$apiContext = new ApiContext(new OAuthTokenCredential(
$clientId, $clientSecret));
$apiContext->setConfig([ 'mode' => 'live']);
$payment = Payment::get($payment->getExternalPaymentId(), $apiContext);
$paymentExecution= new PaymentExecution();
$paymentExecution->setPayerId($payerId);
$payment->execute($paymentExecution, $apiContext);
```
8. Опционально PayPal производит уведомление о платежах на указанный URL, называется это у них [IPN](https://www.paypal.com/ru/cgi-bin/webscr?cmd=p/acc/ipn-info-outside):
Каждое такое полученное уведомление необходимо валидировать ответным запросом в сторону PayPal. Также нужно сверять сумму платежа, валюту и email получателя. Остается только дождаться заветного статуса completed и платеж можно считать выполненным. Если вы не хотите связываться с IPN, то всегда можно просто опрашивать платформу PayPal о статусах требуемых платежей, к примеру, через cron, хотя IPN все же удобней:
```
$ipn = new PPIPNMessage(null, array(['mode' => 'live']));
if (!$ipn->validate()) {
throw new \Exception('Не пройдена валидация платежа на стороне PayPal');
}
// $_GET['txn_id'] Ид платежа PayPal
// $_GET['mc_gross'] Сумма платежа
// $_GET['mc_currency'] Валюта платежа
// $_GET['payer_email'] Еmail плательщика
// $_GET['item_number1'] Ид первого товара
// $_GET['payment_status'] Статус заказа
// $_GET['receiver_email'] Email получателя
switch ($_GET['payment_status']) {
// Платеж успешно выполнен, оказываем услугу
case 'completed': break;
// Платеж не прошел
case 'failed': break;
// Платеж отменен продавцом
case 'denied': break;
// Деньги были возвращены покупателю
case 'refunded': break;
}
```
На наш взгляд, большинство шагов данной схемы избыточные: можно убрать повторные проверки в адрес PayPal на этапе уведомлений о платеже, просто заранее подписав присланные данные. Это же касается и лишних действий с подтверждением уже сделанного платежа пользователя. Также, помимо хранения номера платежа PayPal, придется организовывать хранение token’а для однозначной идентификации заказа и выполнения шага 7. Альтернативный вариант заключается в формировании Url’а возврата с уникальным ключом.
На данный момент API PayPal [один из самых запутанных и неоднозначных](http://habrahabr.ru/post/128198/) среди популярных платежных систем, но с другой стороны если, не сворачивая, идти по протоптанной тропинке, то все получится.
#### Не имей сто рублей, а имей сто друзей
В свою очередь мы упростили подключение и работу с PayPal и готовы предоставить ряд платежных инструментов на выбор.
Если вы только задумались над тем, как реализовать прием платежей для своего проекта и какие методы оплаты вам подойдут помимо PayPal, то рекомендуем самый быстрый и простой способ подключения — [универсальная форма оплаты UnitPay](https://unitpay.ru/pay/demo/mc?sum=10&account=demo&desc=DEMO+%D0%BF%D0%BB%D0%B0%D1%82%D0%B5%D0%B6+Unitpay.ru). Среди прочих методов оплаты будет доступен и PayPal.
Для тех кто уже сформировал свой список платежных систем и просто хочет расширить его, подключив PayPal, мы предлагаем воспользоваться нашим API, полное описание которого можно найти на странице вашего проекта.
#### А что для стран СНГ?
К сожалению, пока PayPal не доступен для ряда ближайших к нам стран. Многие испытывают с этим ряд трудностей и предлагают достаточно [разные решения](http://habrahabr.ru/post/182790/). Думаем, что в скором времени эта ситуация изменится в лучшую сторону.
#### В заключение
PayPal в России ещё очень молод, но у него богатое прошлое и огромный потенциал. Мы надеемся, что пройдет совсем немного времени, и он займет свое достойное место в списке безопасных и удобных платежных систем на отечественном рынке. | https://habr.com/ru/post/199370/ | null | ru | null |
# Точки останова на ручной тяге (для архитектуры x86)
Любой программист хоть раз заглядывавший в отладчик знаком с понятием точки останова (aka бряк, breakpoint). Казалось бы нет ничего проще, чем поставить точку останова пара кликов мышкой в графическом интерфейсе или команда в консоли отладчика, но не всегда жизнь системного программиста столь проста и иногда возникает необходимость выставлять точки останова автоматически — изнутри самой программы.
#### Instruction breakpoints
*[про этот вид точек останова оказывается достаточно подробно [писали два года назад](http://habrahabr.ru/blogs/development/39771/), поэтому я кратко привел лишь общие соображения]*
[](https://habrastorage.org/storage/habraeffect/21/a9/21a957a026e35a9da3ccb1433f494b7b.png "Хабрэффект.ру") Предположим мы пишем JIT компилятор и хотим выставлять точки останова внутри генерируемого им кода. Оказывается для этого достаточно вставить в поток кода всего лишь одну инструкцию `int 3` в тех местах, в которых мы хотели бы остановить исполнение программы. Когда процессор натолкнется на эту инструкцию, то сгенерирует соответсвующее прерывание, которое ядро ОС обработает и превратит, например, под Linux в сигнал **SIGTRAP**. Запущенная в свободная плаванье программа просто упадет натолкнувшись на `int 3`, но вот отладчик поймает этот сигнал, остановит программу и позволит исследовать её состояние.
Кстати сами отладчики тоже пользуются этой инструкцией: просто подменяют ей инструкции в памяти, когда мы просим их поставить бряк. Именно поэтому `int 3` кодируется одним байтом (`0xCC`) а не двумя, как остальные инструкции генерации программого прерывания `int X` (`0xCD imm8`) — иначе бы `int 3` не годилась бы для подмены однобайтовых инструкций.
Как мы видим ничего сложного в ручной расстановке instruction breakpoints нет. Можно даже реализовывать их интерактивное включение-выключение: достаточно запоминать их позиции и заменять ненужные на пустую инструкцию `nop` (`0x90`).
Гораздо интереснее дело обстоит с другим типом точек останова — точками останова на доступ к памяти.
#### Access breakpoints
[](https://habrastorage.org/storage/habraeffect/f3/14/f31489d6e7b837ea33c626f42e6c533a.jpg "Хабрэффект.ру") Допустим мы отлаживаем повреждение памяти в среде исполнения с копирующим сборщиком мусора, который постоянно компактифицирует кучу и всякими другими способами тасует объекты в памяти. Мы смогли выяснить приблизительно какое поле в каком объекте повреждается, но просто загрузить программу в отладчик и поставить им точку останова на доступ к этому полю не получается, потому что GC постоянно путается под ногами своими перемещениями. Поэтому у нас возникает разумное желание, чтобы сам добряк Сборщик Мусора и выставлял/обновлял этот бряк.
Иными словами мы хотим предоставить ему в распоряжение функцию
`void SetAccessBreak(void* addr);`
Здесь нам на помощь приходят добры молодцы отладочные регистры `dr0`, `dr1`, `dr2`, `dr3` и их дядька Черномор `dr7`, содержащий контрольные флаги.
Пользоваться ими достаточно просто: в один из регистров `dr0` — `dr3` загружаем адрес, за которым нужно следить, а в `dr7` выставляем соответствующие флажки определяющие активирована или нет точка останова соответствующего регистра, событие за которым она следит (выполнение/ чтение/чтение-или-запись по этому адресу), размер данных (1 байт, 2 байта, 4 байта, 8 байт). Дабы не тратить место на невнятные словесные объяснения правил кодировки флагов, я сразу приведу код двух утилитных функций: `MakeFlags`, которая кодирует флаги для заданного отладочного регистра в формате использующемся в `dr7`, и `MakeMask`, которая для заданного регистра вычисляет битовую маску, покрывающую все флаги относящиеся к этому регистру (подобная маска нужна, если мы хотим сбросить все флаги).
`enum DebugRegister {
kDR0 = 0,
kDR1 = 2,
kDR2 = 4,
kDR3 = 6
};
enum BreakState {
kDisabled = 0, // disabled - 00
kEnabledLocally = 1, // task local - 01
kEnabledGlobally = 2, // global - 10
kBreakStateMask = 3 // mask 11
};
enum Condition {
kWhenExecuted = 0, // on execution - 00
kWhenWritten = 1, // on write - 01
kWhenWrittenOrReaden = 3, // on read or write - 11
kConditionMask = 3 // mask 11
};
enum Size {
kByte = 0, // 1 byte - 00
kHalfWord = 1, // 2 bytes - 01
kWord = 3, // 4 bytes - 11
kDoubleWord = 2, // 5 bytes - 10
kSizeMask = 3 // mask 11
};
uint32_t MakeFlags(DebugRegister reg, BreakState state, Condition cond, Size size) {
return (state | cond << 16 | size << 24) << reg;
}
uint32_t MakeMask(DebugRegister reg) {
return MakeFlags(reg, kBreakStateMask, kConditionMask, kSizeMask);
}`
Вооружившись этими функциями можно не зная брода бросится в воду и попробовать реализовать `SetAccessBreak` с помощью простого встроенного ассемблера:
`bool SetAccessBreak(void\* addr,
DebugRegister reg,
Condition cond,
Size size) {
const uint32_t control = MakeFlags(reg, kEnabledLocally, cond, size);
__asm__("movl %0, %%dr0\n"
"movl %1, %%dr7\n" : : "r"(addr), "r"(control) : );
}`
Однако эта попытка обречена на провал: доступ к отладочным регистрам возможен только из нулевого кольца защиты, т.е. из ядра. Однако, регистры эти плюсплюс-полезны (любой современный отладчик ими пользуется), поэтому ОС обычно предоставляют API для доступ к этим регистрам. Например, на Mac OS X читать и писать эти регистры можно через функции `thread_get_state`/`thread_set_state`. Получив через них доступ к нужным регистрам, мы легко реализуем `SetAccessBreak`:
`bool SetAccessBreak(pthread_t target_thread,
void\* addr,
DebugRegister reg,
Condition cond,
Size size) {
x86_debug_state dr;
mach_msg_type_number_t dr_count = x86_DEBUG_STATE_COUNT;
// Извлечем из POSIX потока нижлежащий MACH поток.
mach_port_t target_mach_thread = pthread_mach_thread_np(target_thread);
// Запросим состояние отладочных регистров потока.
kern_return_t rc = thread_get_state(target_mach_thread,
x86_DEBUG_STATE,
reinterpret\_cast<thread_state_t>(&dr),
&dr_count);
// Попытка получить текущее состояние отладочных регистров провалилась
if (rc != KERN_SUCCESS) return false;
// Загрузим адрес, за которым нужно следить с указанный регистр.
switch (reg) {
case kDR0: dr.uds.ds32.__dr0 = reinterpret\_cast<unsigned int>(addr); break;
case kDR1: dr.uds.ds32.__dr1 = reinterpret\_cast<unsigned int>(addr); break;
case kDR2: dr.uds.ds32.__dr2 = reinterpret\_cast<unsigned int>(addr); break;
case kDR3: dr.uds.ds32.__dr3 = reinterpret\_cast<unsigned int>(addr); break;
}
// Сбросим все флаги относящиеся к указанному регистру.
dr.uds.ds32.__dr7 &= ~MakeMask(reg);
// Установим новое значение флагов.
dr.uds.ds32.__dr7 |= MakeFlags(reg, kEnabledLocally, cond, size);
// Обновим состояние отладочных регистров.
rc = thread_set_state(target_mach_thread,
x86_DEBUG_STATE,
reinterpret\_cast<thread_state_t>(&dr),
dr_count);
// Обновление регистров провалилось.
if (rc != KERN_SUCCESS) return false;
// Точка установа успешно выставлена.
return true;
}`
Вот и все! Теперь добрый дядька Дворник-Сборщик Мусора может сам управлять точками останова. Кто не верит, может написать маленькую тестовую программку:
`static int16_t foo = 0;
static int32_t bar = 0;
int main (int argc, char \*argv[]) {
foo = 1;
bar = 1;
SetAccessBreak(pthread_self(), &bar, kDR0, kWhenWritten, kWord);
foo = 2;
bar = 2;
SetAccessBreak(pthread_self(), &foo, kDR0, kWhenWritten, kHalfWord);
foo = 3;
bar = 3;
return 0;
}`
и запустив её под отладчиком убедится, что исполнение каждый прерывается в правильных местах — т.е. на инструкции следующей за той, которая доступается к области памяти:
`(gdb) r
Starting program: /Users/mraleph/test
Reading symbols for shared libraries +++. done
Program received signal SIGTRAP, Trace/breakpoint trap.
main (argc=1, argv=0xbffff9f8) at test.cc:107
*106 bar = 2; <= triggered SIGTRAP -- примечание mr.aleph*
107 SetAccessBreak(pthread_self(), &foo, kDR0, kWhenWritten, kHalfWord);
(gdb) c
Continuing.
Program received signal SIGTRAP, Trace/breakpoint trap.
main (argc=1, argv=0xbffff9f8) at test.cc:109
*108 foo = 3; <= triggered SIGTRAP -- примечание mr.aleph*
109 bar = 3;
(gdb) c
Continuing.
Program exited normally.` | https://habr.com/ru/post/103073/ | null | ru | null |
# Разработчики в борьбе за эффективность программиста, команды, команд
Всем привет.
Сегодня мы хотели бы обсудить один очень важный аспект эффективной работы — повторное использование.
##### Речь пойдет, конечно, о коде.
Рутинном, который не хочется писать дважды, а тем более трижды. Инфраструктурном, который приходится писать от проекта к проекту. Гениальном, который просто выражает собой отличную идею и которым грех не дать попользоваться другим.
Да и давайте признаемся — все мы любим писать “фреймворки”, которыми пользуемся потом сами и которыми пользуются другие. Это добавляет немного куража нашей повседневной деятельности.
И тут автор ловит себя на том, что поступает неправильно, начиная описывать ситуации — все и так понимают, о чем речь. А описать нужно технологии и процесс. Поэтому давайте просто остановимся на абстрактной мысли, что внезапно нашлось много кода, который может быть полезен коллегам и его хорошо бы сделать легкодоступным. Также примем во внимание вторую, куда менее приятную, мысль, что в “зрелых” проектах можно найти большое количество copy-paste кода, значительно понижающего сопровождаемость. Да и работу над такими проектами приятной назвать трудно. И с этим надо что-то делать.
##### И мы решили с этим что-то делать.
Путь, пройденный нами, оказался не таким сложным, мы можем посоветовать повторить его другим, ибо потраченное время себя окупает. А поскольку в какой-то момент этот путь стал интересным и даже забавным, мы решили поделиться своим опытом.
##### Ну да хватит предисловий.
Итак, сегодня мы в деталях расскажем:
1. Как развернуть корпоративный nuget-сервер ([основы nuget](http://docs.nuget.org/docs/start-here/overview) мы опустим, полагая, что большинство читателей знает, что это такое).
2. Как развернуть корпоративный symbol-сервер, интегрированный с nuget.
3. Почему одного nuget-сервера недостаточно для построения эффективного процесса.
4. Также заранее обозначим темы для второй части, которую мы с удовольствием изготовим, если данная тема найдет своих читателей:
5. Что такое SandCastle и с чем его едят.
6. Как настроить continuous integration, чтобы автоматизировать всё нами содеянное.
7. Несколько мыслей по поводу (само)организации.
##### Разворачиваем корпоративный nuget-сервер.
Итак, nuget — это здорово и весело. Это не просто новый инструмент, повышающий продуктивность, это новый подход, новый образ мыслей. Почти такой же полезный, как здоровое питание и утренняя гимнастика. Значит надо использовать.
Если речь идет о развертывании корпоративного сервера, то вариантов установки есть два:
1. Простое развертывание ленты без UI и плюшек. Для этого варианта достаточно создать MVC application и установить сервер nuget, скачав [nuget-пакет](http://www.nuget.org/packages/NuGet.Server) (такая вот рекурсия).
2. Второй вариант создан для чуть менее ленивых, но зато он с UI и плюшками. Для него необходимо скачать [исходники](https://github.com/NuGet/NuGetGallery) и собрать их согласно инструкции с той же страницы. После этого, нажав Ctrl+F5, мы должны увидеть (почти) полный аналог официальной ленты.
Собственно, на этом и всё — процесс чрезвычайно прост. Однако есть несколько моментов, не описанных в документации, которые проявились у нас и которые могут быть полезны другим:
1. **IIS express**. Вариант работы на IIS express с использованием localdb трудно рассматривать как production ready по целому ряду причин. Поэтому мы перенесли нашего новорожденного на полнофункциональный сервер IIS. Благо, сложностей с этим никаких не возникает. Просто идем во вкладку properties проекта “Website” и снимаем галку “Use IIS Express” в разделе “Web”. Visual Studio моментально среагирует на такие перемены — предложит создать Virtual Directory и сменить Connection Strings в web.config с localdb на SQL express.
2. **Database Migrations**. Nuget использует для доступа к данным Entity Framework и активно пользуется механизмом Database Migrations. В руководстве к развертыванию есть шаг № 4 — создание БД при помощи танцев с саблями вокруг порядка открывания вкладок в студии. На самом деле всё проще. Достаточно просто указать имя проекта, в котором хранятся migrations, при обновлении через консоль. И никаких танцев:
3. **Настройки безопасности**. В руководстве не описаны моменты, касающиеся настроек безопасности (хотя они были в [устаревшем руководстве](http://docs.nuget.org/docs/contribute/setting-up-a-local-gallery)). Видимо, предполагается что ставит всё безоговорочный админ и крутиться всё будет под его же учеткой. Если это не так, то нам нужно:
* a. Дать права на запись в папку “AppData” приложения. Туда будут складываться nuget-пакеты. Даем права аккаунту, под которым крутится AppPool-приложения. На случай, если в настройках IIS стоит ApplicationPoolIdentity, а не конкретная учетная запись, даем права группе IIS\_IUSRS.
* b. По тем же принципам даём права на доступ к БД в SQL.
* c. Можно после регистрации дать себе же роль админа. Для этого после стандартной регистрации через UI вставляем запись в таблицу dbo.UserRoles, поглядев Id роли в таблице dbo.Roles. После этого по адресу “<путь к серверу>/admin” вам станет доступна админка cо всякими плюшками и букмарклетом [glimpse](http://getglimpse.com/).
4. **GalleryOwner**. Есть смысл поменять на реальные настройки пункта “Gallery.GalleryOwner” в web.config. От него будут рассылаться письма при регистрации. А можно и вовсе отключить эту рассылку. И обязательно пропишите актуальный SiteRoot.
```
```
5. **В файле stats.js есть функция getStats**. На момент написания данной статьи ее вызов приводил к ошибке на главной странице.
Причина кроется в том, что в локальной версии nuget статистика [отключена](http://blog.nuget.org/20130226/Introducing-Package-Statistics.html). На данный момент она предназначена только для облачной версии.
Вы можете создать свою реализацию IStatisticsService или просто отключить данный вызов. Мы выбрали второй путь.
На этом, собственно, всё. Теперь у нас есть nuget-сервер с галереей и [пакетами](http://docs.nuget.org/docs/creating-packages/creating-and-publishing-a-package).
Но что, если в наш пакет (dll-ку из него) закрался баг? Или разработчик просто хочет понять, что делает наша функция “DoStuff”? Очевидно, библиотеку нужно дебажить. Но не так-то это просто, когда у нас в распоряжении есть только dll. Именно поэтому nuget умеет собирать не только пакеты библиотек, но и [symbol-пакеты](http://docs.nuget.org/docs/creating-packages/creating-and-publishing-a-symbol-package).
##### А мы идем учиться собирать свой собственный symbol server
В качестве решения для поддержки отладки мы решили использовать [SymbolSource](http://www.symbolsource.org/Public), поскольку он настолько хорошо дружит с nuget, что тот его поддерживает как symbol-сервер [по умолчанию](http://docs.nuget.org/docs/creating-packages/creating-and-publishing-a-symbol-package).
Тут мы сделаем небольшое отступление и расскажем, как это всё работает.
При создании nuget-пакета через команду nuget pack мы можем указать флаг “–Symbols”. В результате nuget создает, помимо стандартного пакета с библиотечкой, ещё пакет <имя\_пакета>.symbols.nupkg, который будет содержать в себе pdb-файл и исходники. Потом этот пакет можно разместить на сервере SymbolSource, который проиндексирует pdb-файл и разместит у себя во внутреннем каталоге исходники проекта. Далее в Visual Studio [настраивается доступ к symbol серверу](http://www.symbolsource.org/Public/Home/VisualStudio), и при необходимости она загрузит с сервера pdb-файл и исходники. Так и становится возможной отладка.
Но, коли уж библиотеки мы не решились складывать в публичный feed, то про исходники и говорить нечего. В принципе, SymbolSource даёт возможность завести приватную ленту. Но также он поддерживает Community версию, позволяющую развернуть свой внутренний сервер. По целому ряду причин мы решили пойти последним путём.
##### И тут начались приключения…
По задумке авторов, развернуть свой symbol сервер задача почти такая же простая, как и развернуть свой nuget feed — создаем MVC-приложение, качаем [nuget-пакет](http://www.nuget.org/packages/SymbolSource.Server.Basic/), даём права на папки “App\_Data” и “Data” — всё работает.
Ах да, есть одно дополнительное требование — необходимо поставить [Debugging Tools for Windows](http://msdn.microsoft.com/en-us/windows/hardware/gg463009) и прописать путь к ним в web.config:
```
```
Собственно, так мы и сделали — загрузили версию 1.3.2 SymbolServer-а, поставили, настроили, увидели волшебный экран.
Диагностику запустили — всё хорошо. Настроили Visual Studio в точности по [инструкции](http://www.symbolsource.org/Public/Home/VisualStudio).
##### Но Debug не работает…
Проблема нашлась достаточно быстро – сервис не сохранял в каталог “Data” исходники при загрузке symbol-пакета. Повозившись какое-то время с настройками IIS, мы поняли, что проблема в другом, и занялись отладкой.
##### Именно. Отладка сервера SymbolSource при помощи сервера SymbolSource.
Причина проблемы тоже нашлась достаточно быстро, и поначалу показалась даже смешной. В классе ManagedSourceExtractor есть метод IsTemporaryCompilerFile, возвращающий, как понятно из названия, признак, является ли некий файл временным файлом компилятора. И в этом методе стоял лишний оператор логического отрицания. То есть этот метод сообщал, что темповыми являлись как раз те файлы, которые ими не являлись. Так один лишний символ сломал весь сервер.
Ну что поделаешь… Посмеялись, форкнули [исходники](https://github.com/SymbolSource/SymbolSource.Community), поправили, собрались делать pull request. И тут мы обнаруживаем, что аналогичный request [уже есть](https://github.com/SymbolSource/SymbolSource.Community/pull/22), причём создан достаточно давно. Да и пакет версии 1.3.2 выпущен уже два месяца как, а вот версия пакета с фиксом не выпущена до сих пор. Вот это уже было не так смешно. Точнее, совсем не смешно.
На какое-то время мы даже задумались, стоит ли вообще использовать этот сервер или лучше поискать другой. Но положительный предыдущий опыт использования… И разработчики nuget сделали его сервером по умолчанию, значит доверяют. И пакет версии 1.3.1 отлично работает. В итоге мы решили запустить всё на поправленных исходниках. Для этого дополнительно скопировали настройку из “Web.config.transform” в “Web.config”, поскольку при локальной сборке transform не выполняется:
```
```
Теперь готово и еще и работает как надо. И тут настало время подумать о том,
##### Почему одного nuget-сервера недостаточно для построения эффективного процесса (beta).
А недостаточно его по очень простой причине: nuget, как он есть, это доступный всей компании сервер.
Значит, в него нельзя класть пакеты, которые могут оказаться нестабильными. Но когда разработка конечных проектов потребовала изменения сборок, размещаемых в nuget, то внести изменения так, чтобы заработало сразу, задача из разряда “пишем код без багов”.
Различных приемов и приседаний, чтобы как-то работать с одним сервером, можно найти множество. Например, подменять ручками dll-ки в папке “packages” конечного проекта, а в nuget публиковать только когда уже всё готово. Но мы же делаем это всё, чтобы жизнь стала проще, а не наоборот. Поэтому, мы решили подойти к вопросу более обстоятельно. Немного подумав, мы придумали нечто.
Написанное ниже — это бета-версия процесса, которую мы ещё только испытываем и осмысливаем. Поэтому было бы очень здорово услышать мнения читателей в комментариях.
Итак, мы решили, что у нас будет три nuget-ленты.
1. **Local feed**. На самом деле это просто сетевая папка (в Visual Studio при настройке источников можно указать не только адрес сервера, но и UNC путь к папке). В эту ленту пакеты собираются на каждый commit в VCS. Никто кроме разработчиков reusable кода source к этой ленте не настраивает.
2. **Test feed**. Эта роль вполне логично ложится на сервер SymbolSource, у которого есть своя лента (именно лента, не галерея) для пакетов, куда автоматически размещается обычный nuget-пакет при публикации symbol-пакета. Публикация в эту ленту выполняется, когда закончено внесение изменений в базовый код и можно приступать к его использованию. Source к этой ленте есть у всех разработчиков компании и у build-машин, собирающих тестовые версии конечных продуктов.
3. **Сервер release-пакетов**. Этим сервером стал тот, который мы развернули ещё в начале статьи — красивый, с UI и прочими плюшками. Самая важная плюшка — требование ApiKey. Локальная лента его не требует, как и лента SymbolSource (точнее SymbolSource требует, но не верифицирует). И там они и не нужны. Здесь же всё серьезнее, поэтому имеет смысл сделать так, чтобы публиковать могли не все. А если кто-то смог, было бы понятно кто это. Публикация на этот сервер идет только тогда, когда базовый код протестирован и сам по себе, и в работе с конечными продуктами. Source на данный сервер настроен у всех разработчиков, build-машин, собирающих тестовые версии конечных продуктов, build-машин, собирающих release версии конечных продуктов.
Получается, с одной стороны, что build-машины, собирающие release-версии конечных продуктов, **никогда** не соберут проект, если он ссылается на тестовую версию пакета.
С другой стороны, порядок того, как указаны сервера в настройках Package Sources у Visual Studio (Tools->Library Package Manager->Package Manager Settings) задает приоритет загрузки пакетов. Поэтому, например, developer-ы базового кода имеют доступ ко всем трем лентам и порядок в настройках выставлен как release feed, test feed, local feed.
В Visual Studio это выглядит это примерно вот так:
Кстати, именно тут достаточно весомым становится аргумент в пользу локального развёртывания серверов — независимость от доступа в internet и бОльшая скорость при работе в локальной сети.
“А что, если один из серверов упал?” — спросите вы. Ну, так не беда. Ведь build process “фреймворка” один на все ленты. То есть, если пакет версии 1.2.3.4 объявляется релизным, то он лежит во всех трех лентах. И доступ к нему, например, у разработчика будет всегда.
С одной стороны, такой процесс не очень прост, но с другой стороны он получился очень естественным, поэтому о его сложности задумываться придётся не часто — он просто ложится на стандартный поток работ.
Ну что же, продумали. Теперь можно вернуться к технологиям и подумать про Continuous Integration, который автоматизирует весь этот процесс.
##### Но статья уже затянулась.
Поэтому, будем прощаться и оставим немного материала для второй части. И тут мы хотели бы обратиться с просьбой к нашим читателям. Если тема показалась вам интересной — дайте нам это понять, оставляйте комментарии. Они помогут нам сделать вторую часть более полезной и информативной, а также мотивируют на скорейший её выпуск.
Спасибо за ваше внимание.
**UPD:** как оно обычно и бывает, ровно на следующий день после того, как статья была дописана, вышло обновление пакета [SymbolSource.Server.Basic](http://www.nuget.org/packages/SymbolSource.Server.Basic/) (версия 1.3.3), в которой исправили баг, упомянутый в разделе про развертывание symbol-сервера. | https://habr.com/ru/post/191406/ | null | ru | null |
# От песочных часов к пирамиде: как усовершенствовать структуру тестов
Меня зовут Владислав Романенко, я Senior iOS QA Engineer в Badoo и Bumble. Мы регулярно внедряем новые фичи в приложения, и автоматизация тестирования — один из способов не пропустить баги. Фактически автотесты входят в жизненный цикл всех частей наших приложений: бэкенда, сервисов, фронтенда и мобильных клиентов. Чем раньше мы обнаружим ошибку, тем дешевле будет её исправить.
Сегодня я расскажу об автоматизации тестирования в iOS, потому что на протяжении всей своей карьеры в Badoo я плотно занимался тестированием наших нативных iOS-приложений, которые написаны на Objective-C и Swift. Хотя кое-где я буду упоминать характерные для iOS инструменты и термины (например, XCTest), общие принципы и подходы универсальны. Так что, даже если в вашем проекте используется совсем другой стек, статья будет вам полезна.
### Что такое пирамида тестов?
[Пирамида тестов](https://martinfowler.com/articles/practical-test-pyramid.html) — это абстракция, которая отражает группировку тестов программного обеспечения по разным уровням детализации. Также она характеризует относительное количество тестов в каждой группе.
Так выглядит исходная пирамида тестов Майка Кона. Она состоит из трёх уровней: модульных тестов, сервисных тестов и тестов пользовательского интерфейса (UI). Вне зависимости от выбранных вами названий и гранулярности пирамида иллюстрирует два тезиса:
1. Тесты нужны на каждом из уровней пирамиды;
2. Чем выше вы поднимаетесь по пирамиде, тем меньше тестов вам требуется.
Иными словами:
* пишите много маленьких и быстрых модульных тестов;
* пишите поменьше тестов среднего уровня;
* пишите совсем немного высокоуровневых сквозных тестов.
Количество уровней и их названия могут быть разными. Самая распространённая модель включает четыре категории тестов (сверху вниз): ручное тестирование, сквозные (end-to-end) тесты, интеграционные тесты, модульные тесты. Следовательно, пирамида в этом случае будет выглядеть так:
Все мы стремимся к идеалу и хотим иметь идеальную пирамиду тестов. Но по мере роста проекта ее форма часто меняется, становясь больше похожей на мороженое:
Такое случается при недостатке низкоуровневых тестов (модульных, интеграционных и компонентных), при избытке тестов, запускаемых через UI, и при ещё большем количестве ручного тестирования (в чуть более благоприятном варианте — сквозных).
Чаще всего это происходит, когда над проектом работают несколько разных команд, возможно, изолированных друг от друга, и они добавляют тесты на разные уровни пирамиды. Например, разработчики пишут модульные и интеграционные тесты независимо от QA-инженеров, которые пишут сквозные тесты. Это приводит не только к неправильному распределению тестов по уровням пирамиды (потому что некоторые сценарии автоматизируются на нескольких разных уровнях), но ещё и к дублированию действий.
### Уровни iOS-тестирования в Badoo и Bumble
Мы применяем для тестирования iOS-приложений следующие тесты (сверху вниз):
1. **Ручное тестирование**. Мы используем его для небольшого количества сценариев и активно автоматизируем часто повторяющиеся и утомительные задачи. Но всё же ручное тестирование у нас присутствует. Например, при внедрении новой фичи (конечно же, покрытой автотестами) разработчики и QA-инженеры проводят так называемую «часовую QA-сессию», в ходе которой мы хотим убедиться, что фича реализована в соответствии с требованиями и готова к запуску. Более того, поскольку мы релизим приложения каждую неделю, перед выкаткой билда мы проводим ручное тестирование — проверяем самую важную функциональность, тестирование которой невозможно автоматизировать, или которая требует дополнительного внимания. Наконец, у нас есть разные активности вроде Testing Dojo, которые предполагают коллективное тестирование приложений многими людьми из разных команд.
2. **Сквозные тесты**. Это тесты типа «чёрный ящик», написанные нашими QA-инженерами. Эти тесты фокусируются на клиентской интеграции с другими сервисами и инфраструктурой. Мы используем кросс-платформенный фреймворк автоматизации тестирования Calabash. Эти тесты написаны на Ruby и используют синтаксис Cucumber и [Gherkin](https://cucumber.io/docs/gherkin/reference/). В своей [предыдущей статье](https://habr.com/ru/company/badoo/blog/558496/) я приоткрыл завесу над некоторыми паттернами процессов, которые мы используем при создании сквозных тестов. Чтобы продемонстрировать наш фреймворк, мы даже опубликовали [пример проекта](https://github.com/badoo/MobileAutomationSampleProject). Также у нас есть набор тестов для разных девайсов и языков, которые проходят по всему приложению и делают скриншот каждого экрана. Мы называем эти тесты liveshots, о них подробно рассказано [здесь](https://2019.codefest.ru/lecture/1447).
3. **Компонентные и интеграционные тесты**. Это особые виды тестов типа «чёрный ящик». Проверяемые с их помощью сценарии зависят от спецификаций функциональных компонентов и их интеграции друг с другом и с iOS-сервисами. Эти тесты должны быть изолированы от остальных систем приложения. Они написаны на Swift (как и другие тесты на нижерасположенных уровнях пирамиды) и используют встроенный фреймворк XCTest. Мы ещё к ним вернёмся. В этой статье я объединил оба вида в одну категорию — компонентные тесты. Сделано это с одной стороны для простоты, с другой - потому что сейчас все эти тесты мы не разделяем. А в будущем мы планируем перенести компонентные тесты в специальные функциональные модули.
4. **Тесты визуальной регрессии**. Они проверяют, соответствует ли дизайн пользовательского интерфейса требованиям, и корректно ли интегрируются компоненты интерфейса с соответствующей подсистемой ОС. Часто такие тесты называют snapshot-тестами.
5. **Модульные тесты**. Они позволяют убедиться, что модуль соответствует своей архитектуре и ведёт себя как предписано. Часто модулем является целый интерфейс, например класс, но им может быть и отдельный метод. Такие тесты должны гарантировать проверку всех нестандартных путей кода (включая успешные и пограничные случаи).
Я уже говорил, что для ситуаций, когда тестовая пирамида напомнает форму мороженого характерен недостаток тестов на нижних уровнях (модульные тесты). А если отсутствуют тесты среднего уровня (интеграционные), то пирамида превращается в песочные часы. Собственно, такова сейчас структура наших тестов:
В такой структуре много сквозных и модульных тестов, но мало интеграционных. Это не так плохо, как в случае с формой мороженого, но всё ещё приводит к слишком большому количеству падений сквозных тестов. В то же время, обнаружить баги приложения, которые приводят к падениям этих тестов, было бы быстрее и проще с помощью среднеуровневых тестов. Более того, сквозные тесты обычно медленные, ненадёжные и сложные. К сожалению, избежать их сложности и недетерминированности невозможно. [Мартин Фаулер](https://martinfowler.com/articles/nonDeterminism.html) считает, что главные причины этого - недостаток изолированности, асинхронное поведение, удалённые сервисы, утечки ресурсов.
Мой коллега недавно опубликовал серию статей, в которых рассказал о том, как мы улучшаем наши сквозные тесты: [часть 1](https://habr.com/ru/company/badoo/blog/546188/), [часть 2](https://habr.com/ru/company/badoo/blog/547196/).
### Создаём тестовую пирамиду
Итак, нам нужно превратить песочные часы в пирамиду. Мы понимаем, что нам нужны тесты на всех уровнях, но при этом должны иметь больше тестов на более низких уровнях, поскольку они позволяют быстро и эффективно диагностировать проблемы.
Для нас, оптимальное соотношение тестов определяется по двум главным критериям: инженерной продуктивности и уверенности в продукте. Сосредоточившись на низкоуровневых тестах, мы быстро обретём уверенность на ранних стадиях разработки. С другой стороны, по мере развития продукта более высокоуровневые тесты будут выступать тестами работоспособности (sanity tests). Но их нельзя считать главным инструментом для поиска багов.
Вам может потребоваться другое соотношение. Но если вы сосредоточитесь на интеграционном тестировании, то может оказаться, что тесты выполняются дольше, но находят больше проблем во взаимодействии компонентов. Сосредоточитесь на модульных тестах — ваши тесты наверняка будут выполняться очень быстро и находить много распространённых логических багов. Однако модульные тесты не смогут проверить взаимодействие компонентов, например, контракт между двумя системами разрабатываемыми разными командами. Поэтому хороший тестовый набор содержит тесты разных размеров и типов, соответствующие локальным архитектурным и организационным условиям.
Нельзя за день получить желаемую структуру тестовой пирамиды — это долгий процесс. При изменении нашей пирамиды мы следуем таким принципам:
1. **Покрытие тестами и уровни пирамиды нужно обсуждать на стадии планирования**. Как только новая фича приложения готова к разработке, для неё назначают QA-инженеров. Они вместе с разработчиками и другими командами активно участвуют в организации начала работ. После этого QA-специалисты проверяют всю документацию и вместе с разработчиками принимаются прорабатывать разные тестовые сценарии. На этом этапе все участники обсуждают и вырабатывают на будущее тестовое покрытие. И только после завершения всех этих процедур мы начинаем писать код и можем запускать тесты.
2. **У тестов может быть разная гранулярность, но они всегда должны быть полезны**. Помните: чем выше уровень тестов, тем меньше их должно быть. Поэтому мы стараемся опустить тесты в пирамиде как можно ниже. *Примечание:* если более высокоуровневый тест даст вам больше уверенности в корректной работе приложения, то добавляйте его; в противном случае лучше сосредоточиться на нижних уровнях.
3. **Обращаться с кодом автотестов нужно как с кодом тестируемого приложения**. Необходимо уделять коду автотестов столько же внимания, сколько коду приложения, иначе можно получить кодовую базу тестов, которую невозможно поддерживать. Она не будет особо помогать и потребует много усилий для работы с ней.
### Пишем низкоуровневые тесты
Поскольку я QA-инженер, мне чаще приходится иметь дело с руынм тестированием и высокоуровневыми сквозными тестами. Большая часть моего рабочего времени уходит на вещи вроде добавления тестов для поддержки новой функции приложения или перепроверки отчёта о непростом баге.
В ходе разработки новой фичи мы обсуждаем и проверяем тесты со всех уровней. Для любой фичи мы обязательно составляем план тестирования. Этот процесс предваряет фазу активной разработки и подразумевает создание «набросков» предполагаемых тестов. Также на этом этапе QA-инженеры могут попросить разработчиков проверить, у всех ли добавленных элементов есть идентификаторы для использования в сквозных тестах, или запросить необходимые вспомогательные инструменты (мы называем их QAAPI-методами, почитать о них можно [здесь](https://habr.com/ru/company/badoo/blog/528742/)).
Хоть я и участвую в таких обсуждениях, однако никогда не чувствовал себя полностью вовлечённым ни в планирование или разработку низкоуровневых тестов, ни, что ещё важнее, в аргументирование перемещения тестов с верхних уровней вниз (для поддержания формы пирамиды). Мне хотелось этого не только из-за природного любопытства. Как и многие из нас, я знал, что если сосредоточиться на обширном наборе сквозных тестов, то можно проиграть в длительности тестирования, скорости получения обратной связи и эффективности результатов. То есть упустить все преимущества низкоуровневых тестов.
Чтобы представить себе это в перспективе, сегодня для приложения Bumble на iOS у нас около 900 сквозных сценариев в различных наборах тестов. Подавляющее большинство из них выполняется на симуляторах параллельно (насколько это возможно) и относительно быстро. Последние измерения показывают, что в среднем выполнение сквозного теста на симуляторе iOS занимает от 30 до 90 секунд (включая настройку и удаление). Следовательно, выполнение полного набора тестов займёт 20—30 минут. Кроме того, мы делаем тестовые запуски и на реальных iOS-устройствах. Это другое подмножество тестов, которые нельзя перенести в симулятор, потому что им, например, нужна физическая камера или какие-то разрешения. Такие прогоны занимают около 12 минут при средней продолжительности теста в две минуты. Обратите внимание, что, к счастью, мы не запускаем все эти конфигурации для каждого изменения в приложении. Мы внедрили специальную логику, которая выбирает для изменённых модулей и функций только подходящие тесты. Однако если мы спустимся по пирамиде вниз, от сквозных к более низкоуровневым тестам, то скорость и частота запусков вырастут, а объём ручного контроля уменьшится. Что касается длительности выполнения, то, забегая вперёд, скажу, что в разных конфигурациях запуск сценария компонентного тестирования занимает в среднем 12—15 секунд.
В прошлом году в компании ввели новую инициативу — “Focus Fridays”. Эта программа создана для того, чтобы дать сотрудникам передышку от таких особенностей удалённой работы, как многочисленные видеозвонки, письма и сообщения. Она позволяет выделять две пятницы в месяце на то, чтобы подумать, расслабиться и поработать без отвлекающих факторов. Я решил посвятить это время углублению в компонентное тестирование.
### Переносим сквозные тесты на компонентный уровень
Компонентными называют приёмочные тесты, которые проверяют пользовательский опыт посредством взаимодействия с графическим интерфейсом. Они зависят от возможностей UI-тестирования фреймворка Apple XCTest. Приложение проверяется как чёрный ящик, а для всех внешних взаимодействий, например доступа по сети или пуш-уведомлений, используются заглушки или симуляции.
Сейчас мы работаем так:
* Во время написания теста, мы прогоняем его на реальном сервере, взаимодействия с которым записываем и сохраняем;
* после добавления в приложение новой функции прогоняем все тесты только в режиме воспроизведения. Если позже нужно внести изменения в тест, приходится перезаписывать его взаимодействия.
Прежде чем выбрать этот подход, хорошенько обдумайте все его достоинства и недостатки.
Трудности, с которыми мы сталкиваемся при компонентном тестировании, и наши подходы к избавлению от недетерминированности — темы для отдельной статьи. Скажу лишь, что мы придерживаемся политики нулевой терпимости к недетерминированности в компонентных тестах (а для приложения Bumble на iOS у нас их около 300).
Стоит отметить, что наши тесты компонентов не покрывают:
* внешние по отношению к iOS компоненты, такие как сеть, сервер и службы Apple Push Notification (APNs), — их мы проверяем с помощью сквозных тестов;
* дизайн пользовательского интерфейса, макет и внешний вид приложения — их мы проверяем с помощью тестов визуальной регрессии;
* логику, определённую в наборе классов без пользовательского интерфейса или единственном классе, — её мы проверяем с помощью модульных тестов.
Для всех новых функций приложения мы сразу же добавляем компонентные тесты. Однако у нас ещё остаются сквозные тесты, которые можно перенести на нижние уровни пирамиды. Мы провели анализ и нашли подходящие для этого сценарии.
Вот два примера сквозных сценариев, которые можно перенести ниже в тестовой пирамиде и которые не требуют внешних зависимостей и взаимодействия с сервером:
```
Scenario: Cancelling Photo Upload doesn't upload any photos
Given new user with following parameters
| role | photos_count |
| primary_user | 0 |
And primary_user logs in
When primary_user goes to Own Profile
Then primary_user verifies Own Profile with NO photo
When primary_user taps on Add Photo on Own Profile page
And primary_user goes back from Add Photo page
Then primary_user verifies own profile with NO photo
```
```
Scenario: "Clear folders" warns user about consequences and can be cancelled
Given new user with following parameters
| role | photos_count |
| primary_user | 1 |
And primary_user goes to own profile
And primary_user taps on Account section
And primary_user taps on Delete account from Account screen
When primary_user selects 'Clear folders'
Then primary_user verifies the 'Clear folders' warning dialogue
When primary_user cancels clearing folders for account
Then primary_user verifies the Delete Account, Are You Sure screen?
```
В основном они сохранят ту же идею, структуру и набор шагов. Изменятся только особенности реализации, язык и фреймворк. Возьмём второй пример и посмотрим, как такая смена уровня влияет на длительность тестирования. У исходных сквозных тестов для наших агентов непрерывной интеграционной сборки средняя продолжительность составляет около минуты:
После переноса сценария средняя длительность выполнения стала меньше 15 секунд:
Помимо заметного ускорения тестов, нужно отметить и повышение стабильности благодаря улучшению изоляции за счёт вышеупомянутых заглушек для серверных и сетевых взаимодействий.
### Заключение
Мы пишем тесты разных типов, чтобы убедиться в том, что приложение функционирует как нужно. Неважно, над каким приложением вы работаете, — при оптимизации покрытия лучше всегда стремиться к поддержанию правильной формы тестовой пирамиды. Но необходимо, чтобы все в команде это понимали и разделяли такой подход. Учитывая тестовую пирамиду, вы должны подумать о том, куда направить свои усилия: хотя сквозные тесты очень важны, они также самые дорогие в написании и поддержке, а ещё самые медленные. Очень важно обсуждать план тестирования до начала разработки функциональности.
Мы всё ещё активно улучшаем тестовое покрытие и добавляем тесты на все уровни пирамиды. Наша главная цель — разместить нужные тесты на нужных уровнях. Мы обсуждаем миграцию имеющихся сценариев на два или даже на три уровня вниз. Вполне может случиться так, что однажды после переработки сквозной сценарий попадёт в набор тестов визуальной регрессии. Или компонентный тест может быть заменён модульным.
Самостоятельно погрузившись в компонентное тестирование, я прочувствовал его особенности. Кроме того, я гораздо больше узнал о возможностях, устройстве и ограничениях фреймворка XCTest. Теперь я лучше понимаю нашу систему компонентных тестов и могу поделиться своими знаниями с QA-командой.
Надеюсь, это поможет нам эффективнее планировать тестовое покрытие, а также будет полезно в обслуживании, поддержке и миграции тестов. | https://habr.com/ru/post/652025/ | null | ru | null |
# Настройка pfBlockerNG на pfSense (часть 2)
Продолжим знакомство c pfBlockerNG - многофункциональным IP/DNSBL фильтром файровола pfSense, позволяющего использовать скачанные из интернета списки блокировки, фильтровать DNS по категориям, а IP - по странам, ограничивать выдачу поисковых систем и youtube для показа только "семейных" результатов, и много другое.
В этой части мы разберёмся в гео-блокировке, узнаем на что влияет репутация, посмотрим отчёты-диаграммы и настроим синхронизацию настроек в HA кластере.
Первую часть можно прочитать [тут](https://habr.com/ru/post/580978/).
GeoIP blocking
--------------
Использование базы MaxMind GeoIP DB позволяет с достаточно высокой точностью определить страну-источник IP адреса. Это будет полезно в первую очередь для фильтрации входящего трафика - так, можно блокировать VPN подключения удалённых сотрудников, если попытка подключения происходит из совсем неожиданного места. Подобным же образом можно фильтровать подключения к HAProxy балансировщику или к любым серверам, находящимся за файрволом. В ряде случаем может быть полезно фильтровать и исходящий трафик с серверов. При желании можно блокировать пользователям локальной сети подключение к серверам Антарктиды, к примеру.
Но для начала нам нужно получить ключ для скачивания базы. Заходим на <https://www.maxmind.com/en/geolite2/signup>, проходим регистрацию. Создав пароль, заходим в панель управления аккаунтом и переходим на вкладку *Manage License Keys*.
Нажимаем "Generate new license key" и в появившемся окне ставим No возле вопроса "Old versions of our GeoIP Update program use a different license key format. Will this key be used for GeoIP Update?". License key description может быть любым.
Получаем "License Key" который нам нужно будет ввести в поле **MaxMind License Key** на странице *Firewall / pfBlockerNG / IP* нашего pfSense
Настраиваем pfBlockerNG
-----------------------
Будем считать, что вы хорошо знакомы с настройками разобранными в первой части статьи, и пройдёмся только по тому, что нас конкретно касается. **MaxMind Localized Language** - на каком языке будет список стран на страницах настройки. Если вы лучше знаете, к примеру, французский или испанский, то можете поменять на своё усмотрение. **MaxMind CSV Updates** - лучше не отключать, иначе мы не увидим того самого списка стран и континентов на страницах конфигурации. Разве что можно чекнуть эту опцию если всё уже настроено и работает как часы, и хочется немного сэкономить трафика (т.е. pfSense с LTE модемом).
Перейдём непосредственно на *Firewall / pfBlockerNG / IP / GeoIP*.
Видим таблицу условных континентов или географических зон. **Actions** - что мы будем с ними делать. В большинстве случаев используется *Alias Deny* (для блокировки), *Alias Match* (для pass-правил или логирования), либо *Permit/Deny In/Outbound*, если не хотим видеть алиасы на страницах правил файрвола. Отдельно стоит отметить "континент" под названием *Top Spammers* - как понятно из названия, это самые отпетые спамеры со всего мира.
Нажмём на иконку карандаша и увидим более тонкую настройку. Возьмём к примеру Oceania:
Как видите, можно детально выбрать адреса каких стран и по каким IP протоколам (IPv4/IPv6) мы хотим фильтровать. В квадратных скобках указан так называемый Geoname ID, по которому можно посмотреть детали той или иной локации (иногда это не страна) через разные онлайн-сервисы, к примеру <https://www.geonames.org/> (пример для Самоа - <https://www.geonames.org/5880801>). В круглых скобках - количество записей. Это могут быть как адреса отдельных хостов, так и сети с какой угодно маской. Ниже видим List Action и Enable Logging, как в общей таблице.
Ниже идёт **Advanced Inbound/Outbound Firewall Rule Settings** - используется только в том случае, если в качестве Action не было выбрано действие *Alias Deny/Permit/Match/Native*, т.е. когда создаются авто-правила, не видимые на странице правил файрвола (*Firewall / Rules*). По сути тут просто указываются параметры этих авто-правил - IP адрес назначения, порт, протокол и шлюз (если мы используем Match Outbound для маршрутизации трафика через нужный шлюз). По мне удобнее использовать Alias режим и уже создавать нужное правило в настройках файрвола, чтобы наглядно видеть все правила и их порядок.
Если выбрано слишком много стран, то при обновлении конфигурации можно увидеть такую ошибку:
```
There were error(s) loading the rules: /tmp/rules.debug:37: cannot define table pfB_Europe_v6:
Cannot allocate memory - The line in question reads [37]:
table persist file "/var/db/aliastables/pfB\_Europe\_v6.txt" @ 2016-09-24 18:01:48
```
Это означает, что превышен размер памяти выделенный файрволом для хранения записей IP таблиц. Лечится увеличением **Firewall Maximum Table Entries** (лучше сразу раза в 2-3) на странице *System / Advanced / Firewall & NAT*.
Reputation
----------
Перейдём на вкладку *Reputation* - эти настройки используются для оптимизации размера IP таблиц и блокирования целых подсетей, если в тех оказалось нужное количество IP адресов. При настройке нужно соблюдать осторожность, а если настраиваете pfBlockerNG первый раз, то и вовсе пропустить. Данная вкладка активна только если скачана база Geo IP.
Пойдём по порядку - *Individual List Reputation.* Включаем данную фичу отметив **Max** и задаём в **Max Setting** максимальное количество допустимых адресов в одной /24 сетке. Рассмотрим на примере - предположим, что в одной /24 сети есть четыре IP адреса: 192.168.123.1, 192.168.123.2, 192.168.123.3, 192.168.123.4. Если в сети окажется ещё и пятый 192.168.123.5 адрес, то данные записи будут заменены на одну - 192.168.123.0/24. Это увеличивает вероятность ложных срабатываний, но уменьшает размер таблиц (а они могут занимать немало оперативной памяти), ну и в некоторых случаях лучше блокировать сразу подсеть.
*Collective List Reputation* - выполняется после *Individual List Reputation* и применяется ко всем блоклистам сразу. Работает по схожему принципу. **pMax** и **dMax** отличаются друг от друга тем, что в первом случае, все блоклисты просто сканируются на заданное количество IP адресов в любых диапазонах (т.е. не только /24). Во втором случае, дополнительно можно исключить из данной операции выбранные страны (дабы не заблокировать ненароком сетку с вашими удалёнщиками).
Посмотрим, как можно настроить параметры **dMax** - *Country Code Settings (max/dMax)*. Выбираем в списке **IPv4 Country Exclusion** страны, для которых не будет срабатывать правило блокировки "есть N хостов -> блочим всю сеть". В **ccwhite Action** выбираем как именно - **Ignore** значит просто не преобразовывать блокировку N хостов в блокировку сети, в то время как **Match** создаёт файл /var/db/pfblockerng/match/matchdedup.txt, содержащий IP адреса хостов, попавших под правило "N хостов в одном диапазоне из выбранного списка стран". После можно создать Alias Match, группу использую в качестве адреса фида путь к файлу. Такой Match алиас можно применять в правилах файрвола как вам захочется - к примеру, логировать такой трафик, если полностью блочить не является допустимым (вдруг это VPN подключение тех же удалёнщиков), но нужно знать объём трафика с таких хостов. **ccblack Action** - Block/Match действие для IP адресов не из списка список выбранных стран. В большинстве случаев, ccwhite/ccblack опции трогать не надо.
Proofpoint ET IQRISK IPv4 Reputation - если у вас есть [платная подписка](https://www.proofpoint.com/us/solutions/products/threat-intelligence) на IORist фиды, то вам необходимо создать IP блоклист с адресом фида вида https://rules.emergingthreatspro.com/XXXXXXXXXXXXXXXX/reputation/iprepdata.txt.gz, где XXX - это полученный ETPRO код, а присвоенное вами значение Header/Label нужно будет ввести в поле **Header/Label Name**.
пример IP блоклистаДалее выбираем категории для которых хотим создать Block алиас (**Block Categories**) и Match алиас (**Match Categories**).
Чтобы заработал Match алиас, нужно дополнительно создать Alias Match указав в качестве URL /var/db/pfblockerng/match/ETMatch.txt. Если нужно то можно создать дополнительные алиасы по категориям, достаточно посмотреть содержимое папки /var/db/pfblockerng/ET и увидеть соответствующие файлы.
Не забываем, что для применения всего этого дела, нужно запустить update/reload на странице *Firewall / pfBlockerNG / Update*.
Sync
----
Настройке High Availability на pfSense можно посвятить отдельную статью, тут же мы посмотрим на немножко необычное применение синхронизации настроек между узлами. На странице Firewall / pfBlockerNG / Sync помимо синхронизации на backup узел кластера ( **Enable Sync** = Sync to configured system backup server ), можно указать любое количество других файрволов в списке **XMLRPC Replication Targets**. Для чего это может быть полезно? Предположим у вас целое стадо pfSense, а некоторые и вовсе не имеют выхода в интернет, но фильтруют трафик внутри сети. Прописав их в списке Target'ов и указав в качестве **Enable Sync** Sync to host(s) defined below, можно синхронизировать все настройки pfBlockerNG на перечисленные файрволы. Так как интерфейсы и направление фильтрации могут быть разными на разных узлах, вам, скорее всего, нужно будет использовать Alias Deny/Match для обработки IP трафика.
Reports
-------
А теперь перейдём к самому красивому - логам/отчётам/диаграммам. *Firewall / pfBlockerNG / Alerts*.
В последних версиях pfBlockerNG перешёл на отображение *Unified* лога, это означает, что на данной странице будут отображаться как заблокированные домены (DNSBL), так и IP адреса, попавшие под правила Block/Permit/Match вперемешку. Для просмотра логов по типу событий используется вкладка *Alerts*.
Посмотрим на лог DNSBL с конца - столбец **Feed/Group** показывает с помощью какой группы и фида был заблокирован домен, либо IP адрес. **Domain/Block mode** показывает, какой домен и каким образом был заблокирован. DNSBL-python говорит нам о Unbound python mode DNSBL-1x1, что была переадресация на встроенный веб-сервер pfBlockerNG с пустым пиклесем, HSTS\_A после вертикальной черты - о HSTS блокировке (без исп. встроенного веб-сервера). В квадратных скобках видим что именно спровоцировало блокировку - A или AAAA DNS запись, либо CNAME (если проверка по CNAME включена). Для лучшего понимания можно обращаться к первой части статьи. **Source**, **IF**, **Date** - не нуждаются в комментариях. Таблица с заблокированными IP адресами довольно информативна сама по себе, разве что стоит отметить GeoIP/ASN столбец - без скачанной базы мы не увидим двухбуквенные коды стран.
Threat Services для просмотра информации о доменеПосмотрим, для чего нужны иконки. Нажатие на лупу у номера порта открывает страницу с ссылками на Threat Services - различные онлайн базы данных о портах, где можно посмотреть, какие сервисы обычно находятся на том или ином порту. Аналогичным образом работает иконка "i" возле IP адресов или заблокированных доменах - можно посмотреть, что знают о домене/IP общедоступные базы угроз:
Иконка замка позволяет разблокировать IP/домен - используется как временное решение, т.к. после очередного обновления фидов может быть заблокирован снова. Поэтому для перманентного добавления в белый список нужно нажать на иконку плюса. Если добавляется домен, то появится всплывающее окно, предлагающее добавить в том числе и все поддомены (wildcard запись), либо только сам домен в белый список:
Если же добавляется IP адрес, то его можно добавить как в глобальный Suppress список, применяющийся ко всем фидам, либо добавить в существующий/создать новый белый список. Второй вариант удобен тем, что созданный белый список будет в форме алиаса, который уже можно как угодно применить в правилах фильтрации, например, разрешить ходить на IP адреса из белого списка только определённым хостам.
И напоследок самое красивое - долгожданные диаграммы с остальных вкладок. Следует отметить что на вкладках *DNS Reply* и *DNS Reply Stats* будет какая-либо информация только если **DNSBL Mode** установлен в Unbound mode.
Немного DNSBL статистики:
Топ заблокированных доменовТоп блоклистов по количеству срабатыванийТоп фидов по количеству срабатыванийСтатистика по IP адресам:
Наиболее часто блокированные IP адресаТоп портов на заблокированных адресахТоп стран по количеству заблокированных IP адресовЗаключение
----------
Пожалуй, мы рассмотрели на настройку pfBlockerNG на достаточном уровне, чтобы настроить с нуля под любые возможные нужды. Если какие-то термины кажутся непонятными - не забываем [подсматривать в первой части](https://habr.com/ru/post/580978/). Быстрая настройка для домашней сети - [в одной из предыдущих публикаций](https://habr.com/ru/company/timeweb/blog/581208/). А любые вопросы - в комментариях! | https://habr.com/ru/post/583974/ | null | ru | null |
# Знакомство с Apache Ignite: первые шаги
 Рискну предположить, что среднестатистический читатель этой статьи с продуктом [Apache Ignite](https://ignite.apache.org/) не знаком. Хотя, возможно, слышал или даже читал [статью](https://habrahabr.ru/post/271475/) на Хабре, в которой описывается один из возможных сценариев использования этого продукта. О принудительном использовании Ignite в качесте L2 кэша для Activiti я писал [недавно](https://habrahabr.ru/post/310170/). Возможно, узнав о том, что это написанный на Java open source продукт, позиционирующий себя как «высокопроизводительная, интегрированная и распределённая in-memory платформа для вычисления и обработки больших объёмов данных в реальном времени», обладающая, помимо прочего возможностью автоматического деплоймента вашего проекта на все ноды сложной топологии, вам захочется с ним познакомиться. Испытав такое желание, вы обнаружите, что Ignite документирован не то, чтобы совсем плохо, но и не очень хорошо. Есть [туториал](https://apacheignite.readme.io/docs), кое-какой javadoc, но полного и целостного впечатления от ознакомления с этими источниками не возникает. В настоящей статье я попытаюсь восполнить этот пробел на основе собственного опыта познания Ignite, полученного преимущественно путём дебага. Возможно, в своих выводах и впечатлениях я буду не всегда прав, но таковы издержки метода. От читателя и тех, кто захочет повторить мой путь, требуется не так много, а именно знание Java 8 core, multithreading и Spring core.
В статье будет рассмотрен и препарирован пример класса «Hello World!» с использованием данной технологии.
Установка и запуск
------------------
Последней версией Ignite на момент написания статьи являлась 1.7.0 и исследовалась именно она (хотя на GitHub уже есть 1.8.0-SNAPSHOT). Получить Ignite можно двумя способами. Во-первых, в приложение следует добавить Maven зависимость на org.apache.ignite:ignite-core;LATEST и дополнительно на org.apache.ignite:ignite-spring:LATEST. Также можно скачать с сайта производителя [собраный релиз](https://ignite.apache.org/download.cgi#binaries), который состоит преимущественно из тех же библиотек, которые подключает Maven, или образ Docker. Поскольку я провожу свои исследования на Windows 7, мне вариант с докером не доступен, и я скачал бинарный дистрибутив. Его надо скачать и распаковать, папка, куда распаковывали, будет называться IGNITE\_HOME. Далее я буду в целом следовать порядку изложения оригинального туториала, местами его неизбежно дублируя, но исключительно с целью удобства читателя.
Прежде всего надо отметить, что топология Ignite состоит из узлов двух типов, клиентов и серверов. В типовом случае нагрузка выполняется на серверах, а работающие на слабых машинах клиенты к ним подключаются и инициируют задачи. Клиентские и серверные узлы могут быть запущены внутри одной JVM, однако чаще всего узлы относятся к JVM 1:1. На одной физической (или виртуальной машине) можно запустить любое количество узлов. Далее мы проанализируем это отличие глубже. В этой терминологии наше «Hello World!»-приложение будет состоять из сервера и клиента, который пошлёт на сервер своё знаменитое сообщение.
Для получения узла Ignite используется утилитный класс [Ignition](http://ignite.apache.org/releases/1.7.0/javadoc/org/apache/ignite/Ignition.html). Из множества его методов нас пока интересуют пять перегруженных методов start. Один из них без параметров и запускает узел с параметрами по-умолчанию, нам он не подходит. Второй получает на вход сформированный конфигурационный объект типа [IgniteConfiguration](http://ignite.apache.org/releases/1.7.0/javadoc/org/apache/ignite/configuration/IgniteConfiguration.html), а три других хотят получить спринговый кофигурационный файл, описывающий всё тот же объект IgniteConfiguration, в виде пути к ресурсу с xml-конфигурацией, URL на xml-конфигурацию или он же в виде InputStream. Из личного опыта не рекомендую использовать вариант с ручным формированием конфигурации через **new** IgniteConfiguration. Дело в том, что объект IgniteConfiguration является составным, у него много всяких вложенных объектов, которые тоже надо проинициализировать. И тут может скрываться подвох, поскольку кое-какие классы содержат приватные поля, инициализируемые исключительно путём инжекции. Например, в классе [TcpDiscoveryJdbcIpFinder](https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ipfinder/jdbc/TcpDiscoveryJdbcIpFinder.java) таким образом инжектируется логгер. Как известно, при создании объектов через **new** инжектирования не происходит, и логгер остаётся неинициализированным что, очевидно, приводит к NullPointerException в самый неподходящий момент. Так что не зависимо от ваших предпочтений надёжнее написать xml-конфигурацию и её использовать. Этот вариант хорош ещё тем, что этот конфиг можно использовать для запуска Ignite из командной строки. Примеры кофигов можно увидеть в дистрибутиве, в папке ${IGNITE\_HOME}\examples\config\. Простейший конфиг приведён ниже:
**Конфиг клиента**
```
xml version="1.0" encoding="UTF-8"?
127.0.0.1:47500..47509
```
Здесь мы говорим о том, что создаём узел с именем «testGrid-client», что это клиент, и что он будет искать сервер в диапазоне адресов 127.0.0.1:47500..47509, то есть локально. Для сервера мы подготовим похожий конфиг:
**Конфиг сервера**
```
127.0.0.1:47500..47509
```
Сохраним серверный конфиг в файл test.xml и поместиим его в ${IGNITE\_HOME}\examples\config. Чтобы запустить сервер, перейдём в папку ${IGNITE\_HOME}\bin и выполним команду ignite.(bat|sh) examples\config\test.xml. Если не случится ексепшенов, то конфиг годный, и в конце должно появиться что-то вроде:
Выполненный командный файл полезно изучить. Помимо стандартных возможностей по установке переменных JVM, из него можно узнать о существовании системной переменной IGNITE\_QUIET, управляющей подробностью логирования. Полный перечень системных переменных приводится в классе [IgniteSystemProperties](http://ignite.apache.org/releases/1.7.0/javadoc/org/apache/ignite/IgniteSystemProperties.html) с расшифровкой; имеет смысл ознакомиться (оказывается, Ignite даже умеет проверять появление своих новых версий). Далее можно узнать, что за запуск из командной строки отвечает класс [CommandLineStartup](https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/startup/cmdline/CommandLineStartup.java). Он тоже небезынтересен. Можно увидеть, что если вы работаете на OSX, то вам при старте за это выскочит попап-окошко. Мелочь, а не приятно — за что это только им такое счастье? Из интересного видно, что если в этот класс попасть без параметров, то включится интерактивный режим и вам будут предложены на выбор доступные конфиги, которые отыщет GridConfigurationFinder; он умеет искать в ${IGNITE\_HOME}. Поскольку через командный файл мы без параметров стартовать не можем, то тут нам эта возможность не доступна. Но не расстраивайтесь, можно выполнить команду ${IGNITE\_HOME}\bin\ignitevisorcmd.bat — это интерактивный мониторинг Ignite, в нём выполните команду open, и он выведет что-то такое:
Тут мы можем указать наш конфиг, в этом списке он под цифрой 6. Введя 6, мы подключимся к нашему серверу и увидим
Далее, мы можем ввести в консоль команду top и увидить нашу топологию:
Смотрим глубже
--------------
Возвращаясь к классу CommandLineStartup, можно обнаружить тоску разработчиков по алиасам для классов, которые им так нравятся в Scala: для краткости вызовов они создали класс G, пустой наследник класса Ignition. Ну ок, мы стартовали сервер, что дальше? Дальше запустим клиент. Типовой код для запуска инстанса выглядит примерно так:
**Конфигурирование узла**
```
@Configuration
public class IgniteProvider {
private Log log = LogFactory.getLog(IgniteCacheAdapter.class);
private final Ignite ignite;
private boolean started = false;
public IgniteProvider() {
try {
Ignition.ignite("testGrid-client");
started = true;
} catch (IgniteIllegalStateException e) {
log.debug("Using the Ignite instance that has been already started.");
}
if (started)
ignite = Ignition.ignite("testGrid-client");
else {
ignite = Ignition.start("ignite/example-hello.xml");
((TcpDiscoverySpi) ignite.configuration().getDiscoverySpi())
.getIpFinder()
.registerAddresses(Collections.singletonList(new InetSocketAddress("localhost", DFLT_PORT)));
}
}
public Ignite getIgnite() {
return ignite;
}
}
```
Здесь мы проверяем, не запущен ли в данном JVM уже узел с таким именем, если запущен, то он хранится в не абы в чём, не в java.util.concurrent.ConcurrentHashMap, как кто-то, наверное подумал, а в org.jsr166.ConcurrentHashMap8. В чём их отличие даже боюсь предположить, надеюсь, что кто-нибудь в комментах просветит. А если узла ещё нет, он создаётся на основе конфига. Поскольку мы подключаемся как клиент, нам нужно найти сервер. В качестве способа обнаружения в конфиге указан TcpDiscoverySpi и TcpDiscoveryMulticastIpFinder, инициализируются эти классы и совершают свои поисковые манипуляции. Основные из них следующие.
В соответствии с нашими указанями, выбор между двумя имплементациями интерфейса [TcpDiscoveryImpl](https://github.com/apache/ignite/blob/41f81da8f7efe629affc1cfae52ed1d8820a1043/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/TcpDiscoveryImpl.java) совершается в пользу [ClientImpl](https://github.com/apache/ignite/blob/04514fe062025ce412bad762e691b37cdeb83729/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java). Затем, если бы указали конфигурацию ssl, был бы поднят ssl-контекст — он бы потом пригодился для создания сокетов. Объекту TcpDiscoverySpi очень важно самоидентифицироваться, для этого мы в конфиге установили свойство «localAddress». Если бы мы его не установили, то получили бы org.apache.ignite.spi.IgniteSpiException: Failed to resolve local host to addresses: 0.0.0.0/0.0.0.0 Далее для внутренней самодиагностики регистрируются MBean'ы, то есть их можно использовать для мониторинга продукта. Затем в методе spiStart стартует выбранная имплементация. И клиент и сервер должны подключиться к топологии, однако клиент при этом блокируется до устанолвки соединения. В конфиге мыуказали диапазон портов для локалхоста, и каждый из них Ignite пытается зарезолвить. На каждый из этих адресов-портов клиент шлёт joinRequest. Вот в этом месте меня лично поджидало разочарование, поскольку предусмотрено взаимодействие только через сокеты и, например на основе JMS топологию построить нельзя. Обидно. Но ладно, на порту 47500, который является для Ignite портом по-умолчанию, я отдискаверил сервер. В ответ мы получаем первый hearthbeat сервера и на его основе обновляем соответствующие метрики диагностики. В дальнейшем этот процес — поиска сервера и получения hearthbeat'ов будет происходить непрерывно. Возвращаемся к нашему визору и спрашиваем о состоянии топологии, и ответ соответствует нашим ожиданиям:
Обратите внимание на вывод консоли сервера:
[15:36:11] Topology snapshot [ver=7, servers=1, clients=1, CPUs=8, heap=7.1GB]
[15:37:11] Topology snapshot [ver=8, servers=1, clients=0, CPUs=8, heap=3.6GB]
[15:42:15] Topology snapshot [ver=9, servers=1, clients=1, CPUs=8, heap=7.1GB]
[15:42:24] Topology snapshot [ver=10, servers=1, clients=0, CPUs=8, heap=3.6GB]
Видно, что в какой-то момент подключился клиент, а потом отвалился — это потому что я был в дебаге, и он отвалился по таймауту. Отлично. Теперь можно поздороваться с миром. Для этого гайд предлагает использовать код вида
**JUnit тест**
```
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {IgniteProvider.class})
public class IgniteHelloWorld {
@Autowired
private IgniteProvider igniteProvider;
@Test
public void sendHelloTest() {
Ignite ignite = igniteProvider.getIgnite();
while(true) {
try {
ignite.compute().broadcast(() -> System.out.println("Hello World!"));
Thread.sleep(1000);
}
catch (Exception ex) {}
}
}
}
```
Что он делает? Объект ignite представляет наш узел. Метод compute() для нашего клиента, сообразно его знанию о топологии, и с учётом его присоединённости, создаёт объект для распределённого вычисления. Метод broadcast асинхронно выполняет job, который он сконструировал из команды System.out.println(«Hello World!»). Результат мы на это получим достаточно неожиданный:
**Неожиданный exception**
```
Caused by: class org.apache.ignite.binary.BinaryInvalidTypeException: ru.kmorozov.ignite.test.IgniteHelloWorld
at org.apache.ignite.internal.binary.BinaryContext.descriptorForTypeId(BinaryContext.java:671)
at org.apache.ignite.internal.binary.BinaryUtils.doReadClass(BinaryUtils.java:1454)
at org.apache.ignite.internal.binary.BinaryUtils.doReadClass(BinaryUtils.java:1392)
at org.apache.ignite.internal.binary.BinaryReaderExImpl.readClass(BinaryReaderExImpl.java:369)
at org.apache.ignite.internal.binary.BinaryFieldAccessor$DefaultFinalClassAccessor.readFixedType(BinaryFieldAccessor.java:828)
at org.apache.ignite.internal.binary.BinaryFieldAccessor$DefaultFinalClassAccessor.read(BinaryFieldAccessor.java:639)
at org.apache.ignite.internal.binary.BinaryClassDescriptor.read(BinaryClassDescriptor.java:776)
at org.apache.ignite.internal.binary.BinaryReaderExImpl.deserialize(BinaryReaderExImpl.java:1481)
at org.apache.ignite.internal.binary.BinaryUtils.doReadObject(BinaryUtils.java:1608)
at org.apache.ignite.internal.binary.BinaryReaderExImpl.readObject(BinaryReaderExImpl.java:1123)
at org.apache.ignite.internal.processors.closure.GridClosureProcessor$C2V2.readBinary(GridClosureProcessor.java:2023)
at org.apache.ignite.internal.binary.BinaryClassDescriptor.read(BinaryClassDescriptor.java:766)
at org.apache.ignite.internal.binary.BinaryReaderExImpl.deserialize(BinaryReaderExImpl.java:1481)
at org.apache.ignite.internal.binary.GridBinaryMarshaller.deserialize(GridBinaryMarshaller.java:298)
at org.apache.ignite.internal.binary.BinaryMarshaller.unmarshal(BinaryMarshaller.java:109)
at org.apache.ignite.internal.processors.job.GridJobWorker.initialize(GridJobWorker.java:409)
... 9 more
Caused by: java.lang.ClassNotFoundException: ru.kmorozov.ignite.test.IgniteHelloWorld
at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:348)
at org.apache.ignite.internal.util.IgniteUtils.forName(IgniteUtils.java:8350)
at org.apache.ignite.internal.MarshallerContextAdapter.getClass(MarshallerContextAdapter.java:185)
at org.apache.ignite.internal.binary.BinaryContext.descriptorForTypeId(BinaryContext.java:662)
... 24 more
```
Этот же ексепшен мы увидим на стороне сервера. Это не совсем то, чего бы хотелось. Так произошло, потому что мы не включили удивительной крутизны фичу, P2P class loading или Zero Deployment. Этот момент хорошо разъяснён в [аутентичном гайде](http://apacheignite.gridgain.org/docs/zero-deployment), поэтому повторяться не буду. Смысл в том, что все наши классы, и lambda-замыкания тоже, должны быть пропагированы на все узлы. Альтернативой является подкладывания jar'а с классами в папку ${IGNITE\_HOME}\libs. Но включим фичу, добавив в конфиги строку
Вносим изменение, перестартовываем сервер. И ура!
[16:21:11] Topology snapshot [ver=6, servers=1, clients=0, CPUs=8, heap=3.6GB]
[16:21:48] Topology snapshot [ver=7, servers=1, clients=1, CPUs=8, heap=7.1GB]
Hello World!
Hello World!
Hello World!
Выводы
------
Предсказуемым образом простенький пример выявил не то чтобы бездны, но интересные подробности. Я думаю, о них можно будет рассказать в следующих сериях, равно как других фичах Ignite, ещё незатронутых.
Ссылки
------
» [Код тестового примера на GitHub](https://github.com/kvmorozov/CachedActiviti) | https://habr.com/ru/post/310334/ | null | ru | null |
# Регулярные выражениия в Java на примере адреса электронной почты
Известно, что регулярные выражения – это, по сути, шаблоны из символов, которые задают определённое правило поиска. И, среди прочего, с их помощью возможно осуществить проверку определённой строки или строк на соответствие некоему заранее заданному паттерну или стандарту.
Одним из наглядных и довольно простых примеров использования регулярных выражений в Java и не только является проверка проверка данных пользователя, ввёдённых при регистрации на определённом сайте на корректность. В первую очередь это касается адреса электронной почты, так как к нему всегда предъявляются определённые орфографические требования.
Таким образом, предлагаю разобрать частный случай применения регулярных выражений на примере простого Java-приложения, которое могло бы обрабатывать введённый пользователем адрес электронной почты.
Итак, в Java все классы, описывающие регулярные выражения, хранятся в пакете java.util.regex. Нам понадобятся два класса – Pattern и Matcher
Первый класс, как видно из его названия, описывает паттерн или шаблон, которому должены соответствовать введённые нами данные (в нашем случае – адрес электронной почты), второй – собственно сами данные.
```
public class RegularExpression {
public static void main(String [] args) {
Pattern pattern = Pattern.compile(“”);
Matcher matcher = pattern.matcher(“”);
boolean matches = matcher.matches();
}
}
```
С помощью класса Pattern создается объект, который возвращается статическим методом compile(). У данного метода нет конструкторов и передается в этот метод строка, которая, собственно, и будет нашим шаблоном. Кроме того, к классе Pattern предусмотрен метод matcher, в который по параметрам передается другая строка – та, которую мы хотим проверить на соответствие вышеуказанному шаблону. С помощью этого метода создается экземпляр класса Matcher.
У класса Matcher же, в свою очередь, имеется метод matches(), возвращающий true в случае соответствия данных паттерну и flase, если данные не прошли проверку. Результат мы запишем в булевую переменную matches.
Для того, чтобы перейти, собственно, к самой важной части – самому шаблону и его синтаксису, необходимо условиться о части требований предъявляемых к адресу электронной почты. В общем случае адрес электронной почты должен:
1. Состоять из двух частей, разделённых символом “@”.
2. Левая часть должна состоять из английских букв или цифр, **может** содержать точки и тире, притом после точки или тире обязательно должна следовать как минимум одна буква.
3. Правая часть **должна** содержать хотя бы одну точку в конце, после которой **должны** следовать от двух до четырёх букв.
4. Начинаться обе части должны с буквенных символов.
Начнём проверку с левой части. Она содержит буквенные символы в количестве от одной до бесконечности (на самом деле, конечно, количество их ограничено, но для наглядности представим себе потенциально бесконечный email). Синтаксисом регулярных выражений это описывается следующим образом:
```
Pattern pattern = Pattern.compile(“[A-Za-z0-9]{1,}”);
```
Символы в квадратных скобках указывают интервал возможных буквенных значений.
В фигурных скобках мы описываем допустимое количество символов, указанных ранее. Слева от запятой указано минимальное значение (единица), справа – максимальное. Отсутствие значения, как в нашем случае, говорит о том, что количество символов не имеет максимального значения. Паттерн также может содержать и строго фиксированное число символов или не содежать его вовсе. В последнем случае символ может быть использован лишь один раз.
Далее в нашем паттерне может быть знак тире. “Может быть” означает, что символ будет присутствовать в паттерне либо один раз, либо ни разу, следовательно:
```
Pattern pattern = Pattern.compile(“[A-Za-z0-9]){1,}[\\-]{0,1}”);
```
В случае присутствия тире, как мы уже оговорили, после него в обязательном порядке должна следовать хотя бы одна буква, т.е. начальный паттерн повторяется. Символ тире обозначается как [\\-]:
```
Pattern pattern = Pattern.compile(“[A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}”);
```
Помимо этого, в строке также может присутствовать точка ([\\.]), после которой, опять-таки, обязан следовать буквенный символ:
```
Pattern pattern = Pattern.compile(“[A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,}”);
```
Так как описанный паттерн левой части должен повторяться, мы обозначим это в следующем виде:
```
Pattern pattern = Pattern.compile(“([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+”);
```
Знак плюса после общей скобки означает, что паттерн может повторяться от одного раза до неопределённого количества раз.
Так как левую часть от правой отделяет собачка, мы указываем, что после левой части в обязательном порядке будет присутствовать этот символ:
```
Pattern pattern = Pattern.compile(“([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+@”);
```
Правая часть паттерна должна содержать в себе уже упомянутый набор букв в количестве от одного до бесконечности с обязательным наличием точки в конце. Как и в предыдущем случае, паттерн до точки может повторяться:
```
Pattern pattern = Pattern.compile(“([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+@([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+[\\.]{1});
```
В конце паттерна должны вновь следовать символы, причём в количестве от двух до четырёх:
```
Pattern pattern = Pattern.compile(“([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+@([A-Za-z0-9]{1,}[\\-]{0,1}[A-Za-z0-9]{1,}[\\.]{0,1}[A-Za-z0-9]{1,})+[\\.]{1}[a-z]{2,4}”);
```
Вот, собственно, и весь паттерн. Не маленький, не находите? К счастью, есть способ несколько сократить этот набор, сделав его более читабельным и лёгким для восприятия.
Для начала, существует способ одновременного выражения наличия тире или точки в паттерне. Вместо того, чтобы отдельно пропсывать все точки ([\\.]) и тире ([\\-]), их можно выразить единым символом — **[\\.-]**. Используя его, мы можем сократить паттерн до следующего:
```
Pattern pattern = Pattern.compile(“([A-Za-z0-9]{1,}[\\.-]{0,1}[A-Za-z0-9]{1,})+@([A-Za-z0-9]{1,}[\\.-]{0,1}[A-Za-z0-9]{1,})+[\\.]{1}[a-z]{2,4}”);
```
Также, существует символ, который может означать любую букву или цифру — **\\w**. Т.е. он способен заменить описание типа [A-Za-z0-9]:
```
Pattern pattern = Pattern.compile(“(\\w{1,}[\\.-]{0,1}\\w{1,})+@(\\w{1,}[\\.-]{0,1}\\w{1,})+[\\.]{1}[a-z]{2,4}”);
```
Так как знак плюса означает наличие символа в количестве от одного до бесконечности, описанное выше можно также свести до:
```
Pattern pattern = Pattern.compile(“(\\w+[\\.-]{0,1}\\w+)+@(\\w+[\\.-]{0,1}\\w+)+[\\.]{1}[a-z]{2,4}”);
```
Кроме того, наличие символа не более одного раза можно обозначить символом **?**:
```
Pattern pattern = Pattern.compile(“(\\w+[\\.-]?\\w+)+@(\\w+[\\.-]?\\w+)+[\\.]{1}[a-z]{2,4}”);
```
Есть также символ, означающий наличие чего-либо в паттерне неопределённое количество раз, т.е. {0,}. Обозначается он как \*. В итоговом варианте мы имеем следующее:
```
Pattern pattern = Pattern.compile(“\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*\\.\\w{2,4}”);
```
Подобный паттерн намного компактнее, чем то, к чему мы пришли ранее. Всё, что нам теперь остаётся – это реализовать формальную часть приложения, используя наш готовый паттерн и булевую переменную:
```
public class RegularExpression {
public static void main(String [] args) {
Pattern pattern = Pattern.compile(“\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*\\.\\w{2,4}”);
Matcher matcher = pattern.matcher(“”);
boolean matches = matcher.matches();
}
}
```
Как именно использовать данную булевую переменную – это уже дело вкуса или возможностей. Ключевые же моменты уже готовы и дальнейшая доработка остаётся целиком за Вами.
Надеюсь, данное изожение было достаточно доступным. И конечно же, дерзайте. | https://habr.com/ru/post/267205/ | null | ru | null |
# Обмануть Мигеля?
Как-то раз Мигель…
*(Хотя нет, история не совсем о нем, попробую начать иначе)*
Однажды в мире Open Source…
*(Тоже мимо, OSS в истории затронуто лишь частично)*
Когда жажду наживы называют здравым смыслом, начинается обман.
*(Почти афоризм)*
##### Предыстория
Стукнуло мне в голову написать программу под Мак на C#. Я поблагодарил [Мигеля де Икасу](http://ru.wikipedia.org/wiki/%D0%98%D0%BA%D0%B0%D1%81%D0%B0,_%D0%9C%D0%B8%D0%B3%D0%B5%D0%BB%D1%8C_%D0%B4%D0%B5) за отличный Open Source проект [Mono](http://mono-project.com/), воздал хвалу за его же библиотеку [MonoMac](https://github.com/mono/monomac), чуть ругнулся на сыроватый [MonoDevelop](https://github.com/mono/monodevelop) и принялся за работу. Через некое время был оплачен аккаунт в AppStore, программа была в шаге от завершения, когда начался большой проект по основной работе и ее пришлось отложить. И вот через год пришло сообщение, что пустующий аккаунт в AppStore будет закрыт через 30 дней — это был знак, что надо что-то делать. MonoDevelop, обновившийся сам до Xamarin Studio, предложил сразу проект MonoMac преобразовать в Xamarin.Mac и повел меня на сайт, где было предложено купить этот самый Xamarin.Mac всего за $999, иначе деплоймент в AppStore будет невозможен.
Сказать по правде, я был несколько ошарашен — начиная хобби-разработку в бесплатном продукте я и думать не мог об оплате тысячи долларов за возможность публикации, пусть и рассчитывал заработать на пиво. Даже больше — я смутно помнил посты и истории успеха на StackOverflow о публикации в маркете, каком-то пекеджере и пр. Но все нужные галочки в Xamarin Studio были намертво отключены и требовали покупки полной версии продукта. Тут я и понял, что где-то меня обманули, или выражаясь современным языком, изменили стратегию распространения продукта так, что премиум услуга публикации в маркет стала платной.
##### Все в своем праве
Если смотреть на отношения мои и Xamarin в лице Мигеля, то никто никого не обманывал — разработчик в праве делать со своим продуктом что-угодно, тем более менять лицензии или предоставлять премиум услуги за отдельные деньги. В случае Xamarin.Mac это услуга статической линковки с библиотеками Mono, в ходе чего программа перестает быть зависимой от Mono Runtime и может запускаться на любом компьютере. Также проект подписывается нужными сертификатами, снабжается Entitlements, настройками Sandboxing и пр. требованиями для публикации в AppStore:
> As of December 12th 2012, Xamarin now offers a superset of MonoMac called Xamarin.Mac. It features broader API coverage, a commercial license for Mono's LGPL components, Mono embedding, license to publish to the Mac AppStore and support.
Сам Mono Runtime тоже распространяется по лицензии [GNU Library GPL 2.0](http://www.gnu.org/copyleft/library.html#TOC1) , в которой вопрос статической линковки остается довольно спорным. Если опустить хитросплетение терминов, то выпуская проприетарный продукт, слинкованный с LGPL библиотекой, разработчик должен еще и дать возможность заменить эту LGPL библиотеку на другую версию. Обычно это подразумевает, что вместе с программой надо поставлять и исходный код, либо использовать другую лицензию. Сайт Xamarin придерживается того же мнения:
> Or if you ship an application that requires to statically link the Mono runtime and you are not able to provide the object code to relink Mono, you must obtain a commercial license from Xamarin.
##### Обман
Меньше всего в жизни мне хотелось кого-либо обманывать, тем более такого уважаемого человека, как Мигель де Икаса, автора Gnome, Mono, основателя Xamarin и Ximian. Но по большому счету я уверен, что его маркетологи сделав продукт платным (и как по мне, непомерно платным), уже меня обманули прикрывшись буквой закона и нарушив его дух. Потому это же право я оставил за собой, формально ничего не нарушив, но в результате опубликовав свою программу в AppStore с бесплатной версией инструментария. Программа содержит кроме всего прочего .exe файл с .NET Bytecode и нужными библиотеками, который может быть выполнен с помощью актуальной .NET Framework и Mono Runtime, а также абсолютно достаточен для статической линковки c библиотеками Mono, AOT компиляции или других действий. Но лицензия LGPL не обязывает меня писать инструкцию для конечного пользователя, как это сделать (не говоря о том, что я и сам этого не знаю), только предоставить все необходимое для этого.
##### Технические нюансы
Мой MonoDevelop сам обновился до Xamarin Studio и создание .pkg пакетов там теперь заблокировано. Также на странице [MonoMacPackager](http://mono-project.com/MonoMacPackager) пропала инструкция по созданию пакетов и появились ссылки на Xamarin.Mac. Это неприятно, но не смертельно, ведь в природе есть и архивы, и более старые версии продукта. Я скачал MonoDevelop 3.0.6, адаптировал проект под него (пришлось убрать один несовместимый вызов API), выбрал параметр «Link All» и… так и не смог нормально откомпилировать программу. Сказать по правде, причины я не понял, упаковщик просто отказывается работать с разными версиями Mono Runtime, выдает ошибку линковки и дальше не проходит. Но все же, выбрав пункт «Don't link» можно создать проект, он будет на ~8 мегабайт больше, но работать будет без особых проблем. В проект при этом включаются полные версии сборок System.\*.dll, а не только мета-данные, как было бы с «Link All» режимом. В моем случае это даже плюс, потому что такое же правило относится и к основному .exe проекта — в нем остается весь байткод.
Полученный таким образом инсталлятор отлично запускается, устанавливает продукт, но затем программа отказывается стартовать. Исследование гугла и системного лога показало, что Mono Develop включает в программу неверные Entitlements — keychain-access-groups, которые не совместимы с версией ОС 10.8, а может и вообще не валидны. Эта проблема решена в Xamarin.Mac, но я ведь пошел тернистым путем, потому решать ее тоже должен был сам. В результате я остановился на варианте выполнения post-build скрипта, который применяет корректные данные к сборке и заново подписывает ее.
Версия была отправлена в AppStore, но тут же вернулась с сообщениями о других проблемах с Entitlements, отсутствием подписи у файла libMonoPosixHelper.dylib, а заодно не разрешенном использовании Shared Memory. Первое решилось дополнительными правками plist файла, второе — доработкой post-build скрипта, а вот третья проблема поставила меня в тупик. Информация о проблеме была на [Stackoverflow](http://stackoverflow.com/questions/14535456/submitting-sandboxed-monomac-app-without-accessing-shared-memory), но там говорилось, что она уже исправлена, а вообще решается установкой переменной окружения MONO\_DISABLE\_SHARED\_AREA. Идея с переменной вполне хороша, но ставить-то ее надо не на этапе компиляции, а на этапе выполнения уже на компьютере клиента. Я не знаю, как это решается в Xamarin.Mac, но сам решил добавлением ключа в файл info.plist, который и ставит эту переменную при запуске программы:
```
LSEnvironment
MONO\_DISABLE\_SHARED\_AREA
1
```
Этого оказалось достаточно, хотя программу еще один раз заворачивали из-за неправильного названия в заголовке окна.
**Сверх-критичная ошибка**
##### Эпилог
Программа сейчас в маркете и честно приносит свои 1 доллар и 40 центов в день. Если ничего не изменится, то через 713 дней я смогу купить полную версию Xamarin.Mac, без учета платы за сам AppStore. Мигелю я написал в Твиттер об этой ситуации, но ответа не получил. Другому вопрошающему по этому же вопросу он ответил в ключе «пользуйтесь», но лучше купите Xamarin.Mac.
**Скрытый текст**
Тем временем мне ответили ребята из саппорта Xamarin, что как постоянный клиент Xamarin.iOS и действующий студент я могу купить продукт всего за $99. Это хорошее предложение и наверняка я на него соглашусь, пусть и не совсем солидарен с позицией компании.
P.S. Всем комментирующим в ключе «гадкий пират отбирает деньги у уважаемого человека» советую не тратить зря нервы и не повышать энтропию мировой сети. | https://habr.com/ru/post/217529/ | null | ru | null |
# Уж+ёж: реактивные компоненты в сервлетном окружении (3/3)
В [предыдущей](https://habr.com/ru/company/cft/blog/648821/) заметке было подробно рассмотрено одно из решений для обеспечения повсеместной доступности текущего обрабатываемого запроса. В отличие от неё, нынешняя заметка не будет посвящена глубокому рассмотрению одной проблемы, а поверхностно пробежится по парочке разных.
Унификация @Around-аспектов
---------------------------
Ещё одна любопытная задачка, возникающая при внедрении реактивного стека в сервлетные приложения, – это поддержка AOP-аспектов, оборачивающих тело целевого метода. Такие аспекты декларируются с аннотацией `org.aspectj.lang.annotation.Around` и имеют возможность повлиять как на аргументы перехватываемого метода, так и на его результат, вплоть до полной его замены. Например, вот так может выглядеть примитивный аспект, логирующий аргументы и результат любого метода, помеченного аннотацией `@GetMapping`:
```
@Aspect
@Component
public class LoggingAspect {
private static final Logger log = LoggerFactory.getLogger(LoggingAspect.class);
@Around("within(pro.toparvion.sample.gateway.gatewaydemo..*) " + // [1]
" && execution(@org.springframework.web.bind.annotation.GetMapping * *.*(..))") // [2]
public Object logArgsAndResult(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs(); // [3]
String targetMethodName = pjp.getSignature().getName();
log.debug("Метод '{}' вызван с аргументами: {}", targetMethodName, args);
Object response = pjp.proceed(args); // [4]
log.debug("Метод '{}' ответил: {}", targetMethodName, response);
return response;
}
}
```
1️⃣ Ограничиваем область действия аспекта, чтобы не [напороться](https://twitter.com/toparvion/status/1177542707541086208?s=20).
2️⃣ Задаём шаблон методов, на которые должен действовать аспект.
3️⃣ Получаем аргументы и имя целевого метода из точки вкрапления.
4️⃣ После логирования аргументов делегируем управление целевому методу, чтобы потом сразу залогировать его результат. Для простоты аспект не учитывает случай, когда метод завершается исключением.
### Проблема
Проблема здесь, в сущности, та же, что и с фильтром для поддержки MDC: из-за «двухэтапного» исполнения реактивного конвейера аспект захватит лишь результат *декларации* конвейера, но не реально курсирующие по нему данные:
```
16:24:18.136 DEBUG [ctor-http-nio-3] LoggingAspect : Метод 'proxy' ответил: MonoPeekTerminal
```
, т.е. вместо действительного результата в логах всегда будет числиться `MonoPeekTerminal` (для данного примера).
### Решение
Решением может стать такое же (как с MDC) разделение аспекта на два: для сервлетного и реактивного режимов (при помощи аннотации `@ConditionalOnWebApplication`). Однако, в отличие от случая с MDC, здесь мы не привязаны к API веб-фильтров, а значит, можем переписать аспект так, чтобы он один умел работать в обоих режимах. Это может быть особенно ценным, если логика аспекта достаточно сложна и/или объёмна, чтобы сохранить её как можно более [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself).
Чтобы это сделать, нужно:
1. Уметь отличать реактивные методы от императивных;
2. Уметь назначать желаемое поведение *отложенно*, т.е. не в момент применения аспекта, а позже, когда по конвейеру будут проходить данные.
Первое достаточно легко сделать анализом типа результата метода: если он представляет собой реактивный «хвостик» в виде `Mono` или `Flux` , то и весь метод можно считать реактивным. Второе решается использованием [соответствующих](https://projectreactor.io/docs/core/release/reference/#which.peeking) реактивных операторов: в рассматриваемом простом случае для `Mono` это будет метод `doOnSuccess()`, а для `Flux` – `doOnNext()`. Кроме того, чтобы не повторять само логирование ответа в каждом месте, вызов `log.debug(...)` стóит оформить в метод `logResult()`. Тогда основной метод аспекта (точнее, его окончание) преобразится вот таким образом:
```
@Around("within(pro.toparvion.sample.gateway.gatewaydemo..*) " +
" && execution(@org.springframework.web.bind.annotation.GetMapping * *.*(..))")
public Object logArgsAndResult(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
String targetMethodName = pjp.getSignature().getName();
log.debug("Метод '{}' вызван с аргументами: {}", targetMethodName, args);
Object resultTail = pjp.proceed(args);
return assignResultLoggingBehavior(targetMethodName, resultTail); // [1]
}
```
1️⃣ Теперь здесь нет явного логирования результата. Вместо него вызывается некое назначение (декорирование) ответа, которое на самом деле может сводиться и к непосредственному логированию. Это видно в коде нового метода `assignResultLoggingBehavior`:
```
private Object assignResultLoggingBehavior(String targetMethodName, Object tail) {
if (tail instanceof Mono monoResult) { // [1]
tail = monoResult.doOnSuccess(result -> logResult(targetMethodName, result));
} else if (tail instanceof Flux fluxResult) { // [2]
tail = fluxResult.doOnNext(result -> logResult(targetMethodName, result));
} else {
logResult(targetMethodName, tail); // [3]
}
return tail; // [4]
}
```
1️⃣ Используем [Pattern Matching](https://docs.oracle.com/en/java/javase/16/language/pattern-matching-instanceof-operator.html) (JDK 16+) для сокращения записи.
2️⃣ В случае с HTTP-вызовом результат в виде `Flux` соответствует стриминговому ответу сервера, например, [SSE](https://ru.wikipedia.org/wiki/Server-sent_events) (просто FYI).
3️⃣ Если результат не реактивный, просто логируем результат сразу.
4️⃣ Возвращаем результат, чтобы на него можно было подписаться либо сразу вернуть клиенту.
В таком виде аспект сможет воевать на два фронта: например, будучи оформленным в инфраструктурную библиотеку, он может использоваться как с привычными сервлетными приложениями, так и с новомодными реактивными. Однако важно помнить, что в `import`'ах у него есть классы из Project Reactor, а значит, при использовании этого класса в runtimeClasspath **должна** присутствовать библиотека `io.projectreactor:reactor-core`, даже если аспект применяется к сервлетному приложению.
Разумеется, такой аспект далёк от состояния production-ready, хотя бы потому, что:
* не учитывает, что аргументы тоже могут быть реактивными;
* не обрабатывает исключения, летящие из жерла целевого метода;
* декларирован как `@Around`, хотя далеко не всегда требуется именно двусторонняя обёртка (часто достаточно обойтись аннотациями `@Before` или `@After`).
Однако в качестве отправной точки его должно быть достаточно.
Полный код аспекта можно найти в прилагаемом [демо-проекте](https://github.com/Toparvion/reactivlet-sample/blob/main/shared/src/main/java/pro/toparvion/sample/reactivlet/shared/LoggingAspect.java).
### Попутное резюме
Эта часть заметки была посвящена одному из самых «магических» механизмов вкрапления в поведение приложений. Теперь и он сможет работать на любом из двух стеков. В следующей части речь пойдёт о гораздо более явном инструменте – декларативных HTTP-клиентах.
---
Ремонт OpenFeign-клиентов
-------------------------
В отличие от предыдущих пунктов, рассматриваемые здесь две проблемы нельзя назвать широко распространёнными. Однако тем «счастливчикам», кто всё же сталкивается с ними, от этого не легче.
### Проблема 1
Она [констатирована](https://docs.spring.io/spring-cloud-openfeign/docs/3.0.5/reference/html/#reactive-support) прямо в документации на Spring Cloud OpenFeign:
> As the [OpenFeign project](https://github.com/OpenFeign/feign) does not currently support reactive clients, such as [Spring WebClient](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/reactive/function/client/WebClient.html), neither does Spring Cloud OpenFeign.
>
>
Другими словами, если в каком-то проекте используется *высокоуровневый* декларативный HTTP-клиент на основе библиотеки OpenFeign, то под его капотом не сможет работать соответствующий *низкоуровневый* реактивный HTTP-клиент. Это относится к Spring Cloud OpenFeign версии 3.0.5 и остаётся актуальным, как минимум, на 02.02.2022.
Сразу за этой констатацией идёт многообещающее:
> We will add support for it here as soon as it becomes available in the core project.
>
>
, и в самом OpenFeign об этом действительно много [разговоров](https://github.com/OpenFeign/feign/issues/361), однако воз и ныне там. А пока всё так, разработчики Spring Cloud предлагают:
> Until that is done, we recommend using [feign-reactive](https://github.com/Playtika/feign-reactive) for Spring WebClient support.
>
>
Но этот путь годится только новым проектам, ведь он требует переработки интерфейсов декларативных клиентов – их результаты должны получить обёртки в виде `Mono` или `Flux`. А в текущей задаче мы рассматриваем вариант только с сохранением императивного стиля.
Чем чревата эта проблема? Тем, что в реактивном приложении ненароком вызванный OpenFeign-клиент может заблокировать какой-либо из потоков-обработчиков в Reactor’е и этим парализовать его частично или даже полностью. Коварство проблемы в том, что, пока потоков-обработчиков достаточно много, а ответы OpenFeign-клиентам приходят достаточно быстро, деградация, скорее всего, останется незамеченной. По законам жанра это будет происходить в тестовом окружении. И только под серьёзной нагрузкой (например, на production, почему бы нет) она начнёт периодически постреливать то тут, то там, или вовсе поставит всё колом.
#### Решение 1
Если потенциальное место вызова OpenFeign-клиента известно, то его нужно локализовать относительно реактивного конвейера и приправить вызов оператором `.subscribeOn(Schedulers.boundedElastic())` или `.publishOn(Schedulers.boundedElastic())`. Это позволит Reactor’у аллоцировать под вызов отдельный поток, который будет [не жалко](https://projectreactor.io/docs/core/release/api/reactor/core/scheduler/Schedulers.html#boundedElastic--) на какое-то время заблокировать.
Если же такое место не известно или есть опасение, что оно не одно, то стоит потестировать приложение под наблюдением [BlockHound](https://github.com/reactor/BlockHound) – специального Java-агента, умеющего детектировать блокирующие вызовы из неблокирующих потоков. Он должен помочь выявить проблемные вызовы и либо обернуть их в эластичный ~~бинт~~ пул, либо исключить.
### Проблема 2
Куда «веселее» становится, когда в дело вступает балансировщик нагрузки `spring-cloud-loadbalancer`, который для OpenFeign-клиентов поставляет класс:
```
org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient
```
Как не трудно догадаться по его имени, с реактивщиной этот класс дружит плоховато. Из-за этого получается, что с переходом на реактивный стек некогда безупречные OpenFeign-клиенты уже в runtime начинают падать *на каждом* запросе с неприглядным
```
java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread reactor-http-nio-3
at reactor.core.publisher.BlockingSingleSubscriber.blockingGet(BlockingSingleSubscriber.java:83) ~[reactor-core-3.4.11.jar:3.4.11]
```
Так происходит потому, что в методе `choose` класса `BlockingLoadBalancerClient` (для балансировщика версии 3.0.4) есть вот такая строчка:
```
Response loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
```
Своим вызовом `block()` она раздражает в методе `reactor.core.publisher.BlockingSingleSubscriber#blockingGet()` проверку:
```
if (Schedulers.isInNonBlockingThread()) {
throw new IllegalStateException("block()/blockFirst()/blockLast() are blocking, which is not supported in thread " + Thread.currentThread().getName());
}
```
, которая и роняет выполнение запроса. Любопытно, что под вызовом `isInNonBlockingThread()` скрывается не какая-нибудь реактивная магия, а всего лишь проверка на `Thread.currentThread() instanceof NonBlocking` (наличие специального маркерного интерфейса).
Выброс такого исключения – сознательная мера Project Reactor’а, чтобы выявлять и предотвращать выполнение блокирующего кода в потоках-обработчиках, коих всегда немного (как правило, по числу ядер процессора) и которые должны освобождаться максимально быстро (чтобы подхватить другие задачи). В этом заключается часть смысла слова «неблокирующий» в дефиниции любого реактивного фреймворка. И да, это тоже проявление fail-fast, благодаря чему проблемные места можно замечать без применения спецсредств наподобие BlockHound.
#### Решение 2
Но что делать с этим нам, прикладным разработчикам? К счастью, в качестве основного (правильного) решения здесь подходит такое же, как для проблемы 1 – [оформлять](https://projectreactor.io/docs/core/release/reference/#faq.wrap-blocking) подобные вызовы в пул потоков, допускающих блокировку, например, `Schedulers.boundedElastic()`. Пример [прилагается](https://github.com/Toparvion/reactivlet-sample/blob/94eebf15d73761d3db102788d480ee4728be3e2b/webflux/src/main/java/pro/toparvion/sample/reactivlet/WebFluxApplication.java#L78).
Если же оно по каким-либо причинам не подходит, придётся ~~вбивать костыли~~ искать обходные пути, например, переопределять бин `blockingLoadBalancerClient` своей собственной реализацией, не порождающей явной блокировки. Один пример такого бина [приведён](https://github.com/Toparvion/reactivlet-sample/blob/3b234976e5dcf36aa3de2dcde12ded4a9d24725d/webflux/src/main/java/pro/toparvion/sample/reactivlet/FeignClientConfig.java#L42) в прилагаемом проекте, но его точно **не надо использовать в production без доработки**, это намеренно примитивный вариант. Если прочтение этих строк отзывается в голове другими вариантами решения, милости просим в комментарии.
---
Общее заключение
----------------
В этой пространной серии заметок мы рассмотрели несколько задач, с которыми может столкнуться прикладной разработчик при попытках подружить императивный код на сервлетном фреймворке Spring WebMVC с кодом на реактивном фреймворке Spring WebFlux:
* Как разрулить зависимости и составить правильный classpath?
* Как поддержать вывод MDC-меток в логах на реактивном стеке?
* Как сохранить доступность текущего запроса из любого места?
* Как сделать аспекты-обёртки терпимыми к реактивному стеку?
* Как сохранить работоспособность HTTP-клиентов на OpenFeign?
Ни весь этот список целиком, ни отдельные его пункты не претендуют на полноту раскрытия темы, поскольку класс таких задач весьма обширен. Однако приведённый материал должен помочь читателю ухватить основные идеи и принципы, чтобы решать подобные задачи гораздо быстрее, чем довелось автору этих строк.
Насколько это (не)удалось, можно и нужно рассказывать в комментариях под этим текстом. Там же приветствуются ссылки на схожие источники информации по этой теме.
Дабы не ранить тонкие чувства читателя, все вкрапления русского текста в приведённых примерах переведены на английский и [выложены](https://github.com/Toparvion/reactivlet-sample) в виде цельного проекта на GitHub.
--- | https://habr.com/ru/post/650165/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.